Great news for everyone building with Trongate: the latest framework release (v2.2026.0903) introduces the Module Relations Generator — a brand-new wizard that wires up relationships between your existing modules in a few clicks.

WHAT DOES IT DO?
Pick two of your modules, choose how they relate, and the generator does the rest — automatically:

- Creates the database changes (foreign key columns or junction tables).
- Writes a small settings file that describes the relationship.
- Updates the two modules' code: a create-form dropdown, a live "Associated …" panel on each record's show page (add and remove links, no page reloads), and delete hooks that keep your data clean — no orphaned records, no dangling links.

You end up with plain, readable, generated PHP — nothing hidden, nothing to compile, nothing to deploy. And no custom JavaScript to write: the panels run on Trongate MX, exactly like the rest of the framework.

Three relationship types are supported:
- One to many — e.g. one artist, many albums.
- Many to many — e.g. movies and actors, via an automatically created junction table.
- One to one — with the option of a bridging table where you need it.

Existing records can be linked from the show pages straight away, and the generator's delete hooks make sure that when a record goes, its links go with it — cleanly and deliberately.

UPDATING AN EXISTING TRONGATE APPLICATION
The Module Relations Generator is a developer tool, and it ships inside the framework. To use it in an existing application:

1. Update Trongate to v2.2026.0903 (released 3 September 2026). Grab the latest files from the Trongate framework repository (https://github.com/trongate/trongate-framework) and copy the framework files across, keeping your own modules and config/ files intact. If you update selectively, the pieces you need are:
- modules/module_relations/ — the new runtime module (new).
- modules/trongate_control/ — updated; contains the new module_relations_builder wizard.
- public/js/trongate-mx.js and public/js/trongate-mx.min.js — updated; the page-load activation fix is required for the new panels.
- modules/templates/css/admin.css — updated; adds the panel styles.

No database changes are required on your part — the generator writes the schema itself when you create a relationship.

2. Check your environment is set to dev. Open config/config.php and confirm ENV is 'dev'. The generator is a development-time wizard and only runs in dev mode — it will politely decline otherwise.

3. Make sure the generator can write to your modules. During generation it needs write access to a few files. Full details below.

4. Log in to your admin panel and open the wizard. In dev mode you'll see the Flo button in the admin area — open it, choose Module Manager, then Create Module Relation. Alternatively, go straight to the wizard at:
http://your-site.com/trongate_control-module_relations_builder/choose_relation_type

5. Create your first relation. The wizard walks you through: relation type, then the two modules. Only modules with their own database tables are offered. Confirm the details and generate — the wizard applies everything in one go, and if anything isn't right it stops before changing a single file, with a clear explanation of what it needs.

PERMISSIONS
The generator writes only two kinds of things, and only at the moment you generate a relation:

- A settings JSON inside modules/module_relations/settings/ — the generator creates this folder and file itself and sets their permissions automatically, so you don't need to do anything with it.
- Small code additions to the two modules you're linking: their controllers, models, views/create.php and views/show.php.

After generation, the runtime only reads these files — no special permissions are needed for day-to-day use. If you tighten permissions after generating, everything keeps working. (And before you ask: no, you don't need a blanket chmod -R 777 on anything. Only the files listed above need write access, and only for the few seconds it takes to generate.)

macOS
If your web server runs under your own account — the usual setup with the built-in PHP server or MAMP — you don't need to change any permissions. Just generate.

If Apache/PHP runs as a different user (e.g. the built-in macOS Apache _www, or XAMPP), give the generator write access to the two modules you are linking, for example:

sudo chmod -R ugo+w modules/artists modules/albums

chmod changes file permissions; ugo+w grants write access to the file owner, the owner's group and everyone else; -R applies it through the whole folder. This is a local development convenience — scope it to the modules you're linking rather than your whole app, and once the relation is generated you can restore normal permissions:

sudo chmod -R u+w,go-w modules/artists modules/albums

Linux
First find out which user your web server runs as:

ps aux | grep -E 'apache|nginx|php-fpm' | grep -v grep

- If the server runs as you (common with PHP-FPM pools or php -S), no changes are needed.
- If it runs as a dedicated user such as www-data or http, the simplest local-development fix is to add that user's group to the two modules you're linking and grant group write access:

sudo chgrp -R www-data modules/artists modules/albums
sudo chmod -R g+w modules/artists modules/albums

chgrp changes which group owns the files; chmod g+w lets that group write to them — the server user, as a group member, can then inject the generated code. Replace www-data with your server's actual user. Tighten again afterwards if you like:

sudo chmod -R go-w modules/artists modules/albums

Don't assume your server user — check first; names vary between distributions and setups.

Windows
Windows (typically XAMPP) normally needs no permission changes at all: your Apache/PHP runs under your own user account, and files you create in C:\xampp\htdocs are already writable by that same account.

If you ever do see a "file is not writable" message, the fix is a Windows one, not a Unix one: right-click the module folder, choose Properties, go to the Security tab, click Edit, select your user account, tick Modify for the affected modules, and apply. Unix-style chmod commands don't map to NTFS permissions, so leave them alone.

TRY IT OUT
Here's a two-minute check that everything is working:

1. Open the wizard (step 4 above). You should see a list of your modules with database tables.
2. Create a quick relation between two of them — say, a one-to-many from artists to albums — and let it generate.
3. Open one of your artists' show pages. You should now see an "Associated albums" card beneath the record details, with a form to link albums.
4. Add an album from the form. It appears in the list instantly — no page reload.
5. Head to an album's create page. There's now an artist dropdown at the top of the form.

If all of that works, you're ready — the Module Relations Generator is installed and running in your application.

Give it a try and let us know how you get on. Questions, ideas and feedback are very welcome here on the forums or over on the framework repository (https://github.com/trongate/trongate-framework).

Happy relating! 🎩