Download the PHP package khaleelibrahim/laravel-modular without Composer

Laravel Modular

A modular architecture system for Laravel applications. Run php artisan make:module {Name} and get a fully-wired, self-contained feature module — controller, service, repository (with tag-based, tenant-scoped caching), Form Requests, API Resource, and its own Service Provider — instead of hand-rolling everything under app/Http and app/Services.

Installation

The package's Service Provider is auto-discovered. Publish the config and/or stub templates:

Publishing modular-stubs copies the generator templates to stubs/laravel-modular/ in your application, where you can edit them freely — the package always prefers a published stub over its own internal copy.

Configuration (config/modular.php)

• namespace — the PSR-4 root under which modules are generated. Must correspond to a namespace your app actually autoloads (the default App\ → app/ mapping covers App\Modules out of the box).
• path — the filesystem directory modules are written to. Must correspond to namespace.
• auto_register_providers — whether the package should automatically register every module's Service Provider on boot (see below). Disable if you'd rather list them manually.

The module folder convention

Every module lives at {path}/{ModuleName}/ with this structure:

Rules the generators encode:

• Repositories extend BaseRepository and implement their {Entity}RepositoryInterface. tag() returns a lowercase, hyphenated string. All reads go through $this->remember($this->cacheKey(...), fn () => ...); all writes call $this->flush() afterward. cacheKey() already scopes by tenant — never scope cache keys manually elsewhere.
• Services implement their {Entity}ServiceInterface, constructor-inject the repository interface, contain all business logic, and throw domain-specific exceptions.
• Controllers constructor-inject the service interface, use Form Requests for input validation, and never touch the repository or database directly.

Artisan commands

Every generator command accepts --force to overwrite existing files, normalizes names with Str::studly(), and pulls templates from your published stubs/laravel-modular/ directory when present, falling back to the package's built-in stubs otherwise.

Caching

BaseRepository gives every module repository tag-based, tenant-scoped caching for free:

• remember() uses Cache::tags([$this->tag()])->remember(...) when the configured cache store extends Illuminate\Cache\TaggableStore (array, database, memcached, redis, dynamodb), and falls back to a plain Cache::remember(...) otherwise.
• flush() clears only this repository's tag when the store is taggable, and falls back to a full Cache::flush() otherwise.
• Override protected int $cacheTTL in a repository to change its TTL.
• cacheKey() already scopes by tenant (via app('tenant') when bound, else 'system') — never add manual tenant scoping elsewhere.

Provider auto-discovery

On boot, the package scans config('modular.path') for */Providers/*ServiceProvider.php files, resolves their fully-qualified class name from config('modular.namespace'), and registers each one with the container — so you never list module providers in bootstrap/providers.php by hand.

To avoid a filesystem scan on every request in production, cache the discovered list (mirroring Laravel's own package:discover cache):

Set MODULAR_AUTO_REGISTER=false (or 'auto_register_providers' => false in the config) to disable auto-discovery entirely and register module providers yourself.

Quick start

This produces app/Modules/Blog/ with a PostController, PostService/PostServiceInterface, PostRepository/PostRepositoryInterface (both bound automatically in BlogServiceProvider), Post model, CreatePostRequest/UpdatePostRequest, and PostResource — all wired together.

Add the standard CRUD routes to the generated (empty) app/Modules/Blog/Routes/api.php:

Because BlogServiceProvider is auto-discovered and its boot() already calls loadRoutesFrom(__DIR__ . '/../Routes/api.php'), these routes are immediately reachable at /api/v1/posts — no manual registration required.

Testing

Tests use Orchestra Testbench and cover the generator commands, the bind-insertion behavior, BaseRepository caching against both a taggable and non-taggable store, and provider auto-discovery.

License

MIT.