Download the PHP package drivkraft/interlock without Composer

Lightweight architecture manager for structuring Laravel apps with modules.

A module is a folder in modules/ with its own composer.json, classes, routes, views, translations and migrations. The package discovers and registers everything a module contains, and adds module:* generators that write straight into a module.

Requirements: PHP 8.5+, Laravel 13.

Installation

Module autoloading uses wikimedia/composer-merge-plugin, which the package requires. Composer only reads the plugin's settings from your application, so add them to its composer.json and run composer dump-autoload:

Without allow-plugins, non-interactive installs (CI) fail.

Configuration

Quick Start

No registration needed: the provider, routes, views, translations and migrations are discovered. make:module runs composer dump-autoload (skip with --no-dump) and asks which parts to create; without interaction it creates all except --api.

How-to Guides

Generate classes inside a module

Every make:* command has a module:* counterpart with the same options plus --module (prompted when omitted, required with --no-interaction). Module-aware differences:

• module:command prefixes the signature with the module name (billing:send-reminders).
• module:component writes the view to the module and renders billing::components.invoice-card.
• module:listener --event=InvoicePaid resolves Module\Billing\Events\InvoicePaid.
• module:model asks for related files unless you pass an option.
• module:provider does not touch bootstrap/providers.php (module providers are discovered) and warns when the provider won't be discovered: only top-level Providers/*ServiceProvider classes are.

make:* is unchanged and still writes to app/.

Actions and data objects

module:action adds AsAction when lorisleiva/laravel-actions is installed; module:data extends Spatie\LaravelData\Data when spatie/laravel-data is installed, otherwise a final readonly class. Names are used as given; no suffix is added.

Change generator folders

Set directories.{generator} to a folder relative to source, for example 'interface' => 'Interfaces' or 'class' => 'Support'. Unlisted generators use Laravel's defaults. Nested names (module:enum Billing/Status) go below the configured folder.

Add route groups

Every module's routes/tenant.php now loads in that group. Route files not in the map load without a group.

Translations, components and Livewire

• lang/en/messages.php → __('billing::messages.paid'). JSON translations are merged unprefixed.
• src/View/Components and resources/views/components → <x-billing::invoice-card />.
• With Livewire installed, each module is a namespace: <livewire:billing::invoice-list />. Each livewire.namespaces entry adds a sub-namespace (billing.pages::invoices), whose folder is also a view and anonymous component namespace (<x-billing.layouts::app>). Generate with module:livewire {name} --module=billing [--kind=pages]; all make:livewire options work. Add --form (or choose Form object when prompted) to create a Livewire form object in src/Livewire/Forms instead: module:livewire InvoiceForm --module=billing --form, also available as module:livewire-form.

Seed a module

make:module creates the module's DatabaseSeeder with the seeders part.

Custom module stubs

With custom stubs, make:module writes the whole map and skips the parts prompt. Paths and contents support the placeholders. Include a composer.json with a PSR-4 entry for source.

Cache discovery in production

php artisan optimize runs module:cache, and optimize:clear runs module:clear. While cached, new modules and discovered classes are ignored until you run module:clear (make:module does this for you).

Find modules from code

module() matches the folder name or its kebab-case form.

Explanation

Discovery. Any folder in path with a composer.json is a module, named after the folder. Its namespace comes from the PSR-4 entry pointing at source, falling back to {namespace}\{Name}\. On boot the package builds a manifest of everything each module contains; providers are registered during Laravel's register phase, the rest at boot. module:cache snapshots the manifest, like Laravel's config and route caches.

Autoloading. Modules are plain Composer autoload entries merged by the merge plugin rather than registered at runtime. Module classes therefore work with optimised and authoritative classmaps, exist before Laravel boots, and are visible to IDEs and static analysis. The cost is a dump-autoload per new module.

Generators. Each module:* command extends its make:* counterpart and only changes the target namespace and path, so all options, and future ones, keep working. References to your application in Laravel's stubs stay in App\, so a module controller still extends App\Http\Controllers\Controller.

Optional integrations. Livewire, laravel-actions and laravel-data are detected at runtime and never required. They only change what the generators produce.

Reference

Commands

Generators mirroring make:*: cast, channel, class, command, component, controller, enum, event, exception, factory, interface, job, job-middleware, listener, livewire, livewire-form, mail, middleware, migration, model, notification, observer, policy, provider, request, resource, rule, scope, seeder, test, trait.

What gets discovered

Stub placeholders

Changelog

Please see CHANGELOG for more information on what has changed recently.

Contributing

Thank you for considering contributing to Interlock! Please review our contributing guide to get started.

Security Vulnerabilities

Please review our security policy on how to report security vulnerabilities.

Credits

• Kim Eric Helle
• All Contributors

License

Interlock is open-sourced software licensed under the MIT license.