Everything you need before you buy.
This page is the part you should be able to read first: what the kit needs, how long it takes to stand up, and what one generator command actually produces.
Quick start: three steps, not three weeks
The kit runs on your machine. The generator runs on ours — it reads the shape of your database, never its contents.
- Install — one command, whole stack.
make initbuilds the images, starts the containers, installs dependencies, migrates, seeds demo data and compiles assets. You close the terminal with a running application. The commands. - Write the schema — an ordinary migration, plus hints. What is searchable, what filters, what is money, which column is the status axis — declared as column comments, so they travel wherever your schema goes. Schema recipes.
- Generate — a whole module from one command.
php artisan make:crudsends the table’s shape, writes back the formatted, type-checked files, then seeds the permissions. Not quite right? Change the schema and regenerate — refining a module is free within your current period. The command.
Requirements
Docker and Docker Compose v2. That is the whole list — PHP, Node, PostgreSQL and Redis all run inside containers, pinned to exact patch versions so two people who install it in different months run the same stack.
On Linux, add yourself to the docker group and then start a new login
session — group membership is read when a session begins, so it never reaches a shell
that is already open. Skip it and the first command stops at permission denied while
trying to connect to the Docker daemon socket, which reads like a broken kit rather
than a missing group.
From the zip to a running app
unzip codebooster-enterprise-kit-*.zip -d codebooster-enterprise-kit
cd codebooster-enterprise-kit
cp .env.example .env
make init # = ./scripts/dev-init.sh
That one command builds the images, starts the containers, installs the Composer and npm dependencies, generates the app key, runs the migrations and seeders, and builds the frontend assets.
| Service | Address |
|---|---|
| App | http://localhost:8002 |
| Mailpit | http://localhost:8031 |
Sign in with [email protected] / password. Those seeded demo
accounts refuse to be created in production — a guard with its own tests, not a note in
the docs.
PostgreSQL or MySQL
PostgreSQL is what the kit is built on, and it is what you get if you change nothing. MySQL 8.4 is supported and runs the product end to end — install, migrations, seeders, CRUD, filters, exports, roles, the audit trail, two-factor, the REST API and generated modules.
Supported is not the same as equal, so here is the whole of the difference. Four things do not exist on MySQL, and they are absences rather than settings — no flag switches them on:
| Feature | PostgreSQL | MySQL 8.4 |
|---|---|---|
| Array columns, and the filter that reads them | Yes | — |
inet and macaddr column types | Yes | — |
| Trigram search on large tables | Index-backed | Plain LIKE |
| Reusing the e-mail of a soft-deleted account | Yes | — |
| Everything else on this page | Yes | Yes |
The trigram row is the one worth understanding before you choose. On PostgreSQL a search that finds nothing — which is the common case, because people mistype — is answered by an index. On MySQL the same search reads the table. On a few thousand rows you will not notice; on a few million you will.
Switching is a commented block in .env plus one extra compose file:
docker compose -f compose.yml -f compose.mysql.yml up -d
compose.yml is a PostgreSQL file and you never edit it for this. MySQL lives
entirely in compose.mysql.yml, which replaces the database service
rather than adding to it — so a MySQL installation runs one database, not two.
./scripts/dev-init.sh reads DB_CONNECTION from your
.env and adds that file itself, so there is nothing to remember day to day;
in production prod-deploy.sh does the same.
A managed database is a third option and needs neither file: point DB_* at
your host — RDS, Cloud SQL, Neon, PlanetScale — and deploy.
One migration in
The generator reads your table — the columns, their types, their nullability, their foreign keys, and the hints you leave in the column comments — and writes the whole module — 58 files, listed below.
php artisan crud:login # once per machine
php artisan make:crud products --as=product --wire --api --public --public-key=slug --import --relations --section=Catalog --icon=Shirt
npm run build
The last line is not optional: without it the module exists on disk but not in the Vite manifest, and the screen fails to load with an error that never mentions npm.
The migration is the configuration. A column comment like
'filter;mask:currency' decides the input control, the validation rule, the
table formatting, the export format and the factory value — in one place, not five.
What one command writes
58 files, and nothing you then have to go and wire up by hand. This is the example module in the kit as it ships in v2.9.0, counted file by file:
| Where | Files | What it is |
|---|---|---|
app/Models | 1 | The model, with its casts, relations and scopes |
app/Enums | 1 | A backed enum per fixed-value column |
app/Columns | 1 | The column set read by the table, the CSV, the Excel file and the detail payload — declared once |
app/Queries | 3 | The filter declaration, the form’s option lists, and the cached counters behind the tabs |
app/Observers | 1 | Cache invalidation, so a counter is never stale |
app/Policies | 1 | Who may do what, read from the module’s own permissions |
app/Actions | 9 | Store, update, delete, restore, force-delete and each bulk action — each one transaction and one audit entry |
app/Http/Controllers | 20 | The screens, the REST twin, and one small controller per action — export, import, bulk edits, trash, files |
app/Http/Requests | 9 | Validation written once, then split across create, update, import and each bulk action |
app/Http/Resources | 2 | The API shape |
app/OpenApi | 1 | The module’s REST API, described for the OpenAPI document |
database/factories | 1 | A factory that produces values your own rules accept |
resources/js/pages | 6 | Index, detail and form screens, plus their columns, filters and type definitions |
routes/modules | 1 | Its own route file, gated and throttled |
tests/Feature | 1 | A passing feature test for the module you just made |
Registration is part of it, not a follow-up: the sidebar entry, the route include, and the
permission rows for view, create, edit, delete, restore, force-delete, export and import
all land with --wire.
And this is what is on the screen when it finishes:
| On the index | On the record |
|---|---|
| Search across the columns you marked searchable | A detail page with the record, its relations and its status flow |
| Filters, with a badge counting the active ones | An activity timeline — who changed what, and when |
| A status tab strip, from the enum in your schema | Create and edit in a modal, validated server-side |
| A column menu, remembered per browser | Optimistic concurrency — a second editor is told, not silently overwritten |
| Sorting, pagination and a row-count footer | Soft delete, a trash view, restore and permanent delete |
| Bulk actions: status, assignment, delete | Sensitive columns masked on screen and redacted in the audit log |
| CSV and Excel export, and CSV import | The same module over REST, with tokens and scopes |
| The table updating itself when someone else writes | Every export recorded — who took a copy, and of what |
Index views are the table, a tree when a table points at itself, and — when a module asks for them — a board by status, a calendar by date and a map from coordinates. In the example shop, Categories is a tree, Orders has a board and a calendar, and Customers a map.
Which of these a module gets is decided by the schema, not by a preference file — that is what the schema recipes page is for.
What the manual covers
Sixteen chapters, shipped with the kit as HTML and PDF — read the whole manual online:
Security, stated the way it was measured
The kit ships SECURITY.md — how to report a vulnerability, which versions
get fixes, and a hardening checklist for a deployment — and
docs/security-controls.md: every control, the file that implements it and the
test that locks it, grouped by the areas ISO 27001, SOC 2 and OWASP ASVS use, so your own
assessment has something to open rather than something to take on trust. Role-based
access on every endpoint, a second factor that can be required per role, an audit
trail that names the real actor even during impersonation, personal-data export and
anonymisation, fail-closed CSP and CORS, pinned images, dependency audits in CI and hourly
on the health screen, and a request id on every log line. What it does not claim: a
penetration test, or WCAG conformance — a passive authenticated scan and an axe-core
gate are what was run, and the documents say so.
Included without you writing it.
- Roles and permissions, and an audit trail with IP and user agent
- Two-factor, passkeys, Google and GitHub SSO, and impersonation that still records the real actor
- CSV and Excel exports that are logged, and tables that refresh themselves in realtime
- Optimistic concurrency on web forms and on the REST API, through
If-Match - Health checks, queues, a scheduler, and database backups from the settings screen
Personal data rights. Data export and anonymisation live in one class — deliberately, so an export can never hand over a field that deletion left behind. Deleting an account anonymises and soft-deletes it, so the audit trail never loses who did what.
What we do not claim. The accessibility gate is axe-core clean on 19 screens and states, in both themes, run before every release — that is not the same thing as “WCAG 2.2 AA compliant”, and we do not write that. Security was checked with a passive scan over an authenticated session, behind the login and on the REST API, and dependencies are audited before every release — that is not “pentested”, and we do not write that either.
How every release is checked
A release reaches the store only after every check below passes. The numbers are from release 2.9.1, measured 18 November 2026.
- Installed from nothing on four clean machines. Docker and native, PostgreSQL and MySQL or MariaDB, each from the zip a buyer downloads, then the whole test suite on each: 2,441 tests passing on PostgreSQL, 2,348 on MariaDB and 971 on MySQL after the example modules are removed — none failing on any.
- Upgraded from the release before. The previous release is installed,
the upgrade patch applied with
make upgrade, and the suite run again. - Generated on a clean machine, and through the live server. Modules are generated on a clean install and verified with php -l, PHPStan, tsc and ESLint; then one example module is generated through the production generator from the downloaded zip, and its files have to match the ones that ship.
- 49 of 49 files identical under two names. One table is generated twice, under two module names; once the names are swapped back every file has to match. A generator whose output drifted with the module’s name would show here first. Measured 17 November 2026.
- 80% of injected bugs caught. Small bugs are put into a generated module’s code one at a time — a flipped condition, a removed line — and its own tests have to fail on each. The share they catch is the mutation score: it shows the tests check behaviour, not only that they run.
- 9 permissions on the Product example module: view, create, edit, delete, restore, force-delete, export, import, edit-restricted. Export and import are separate from view — reading a table and taking a copy of it are different powers — and edit-restricted guards the columns the schema marks restricted.
- Dependencies and secrets. Composer and npm packages are audited for known vulnerabilities, and the whole history is scanned for leaked credentials, for every release.
Updates and support
Every release comes as two downloads: the full bundle, for a new project, and an
upgrade patch from the previous release, for the project you already
have. The patch is built between the two bundles exactly as they shipped and applied as a
three-way merge — make upgrade-check <patch> shows what would
change, make upgrade <patch> applies it, your edits survive, and the
few places where you and the kit changed the same lines are named for you to resolve.
UPGRADING.md in the kit has the procedure and the ownership table.
Refining a module is free within your current period: run the generator again on a changed table and it does not count as a new module. The same module in a later period counts again. Releases are listed on the changelog, and every released version stays available.