CodeBooster
Get the kit free

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.

  1. Install — one command, whole stack. make init builds the images, starts the containers, installs dependencies, migrates, seeds demo data and compiles assets. You close the terminal with a running application. The commands.
  2. 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.
  3. Generate — a whole module from one command. php artisan make:crud sends 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.

ServiceAddress
Apphttp://localhost:8002
Mailpithttp://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:

FeaturePostgreSQLMySQL 8.4
Array columns, and the filter that reads themYes—
inet and macaddr column typesYes—
Trigram search on large tablesIndex-backedPlain LIKE
Reusing the e-mail of a soft-deleted accountYes—
Everything else on this pageYesYes

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:

WhereFilesWhat it is
app/Models1The model, with its casts, relations and scopes
app/Enums1A backed enum per fixed-value column
app/Columns1The column set read by the table, the CSV, the Excel file and the detail payload — declared once
app/Queries3The filter declaration, the form’s option lists, and the cached counters behind the tabs
app/Observers1Cache invalidation, so a counter is never stale
app/Policies1Who may do what, read from the module’s own permissions
app/Actions9Store, update, delete, restore, force-delete and each bulk action — each one transaction and one audit entry
app/Http/Controllers20The screens, the REST twin, and one small controller per action — export, import, bulk edits, trash, files
app/Http/Requests9Validation written once, then split across create, update, import and each bulk action
app/Http/Resources2The API shape
app/OpenApi1The module’s REST API, described for the OpenAPI document
database/factories1A factory that produces values your own rules accept
resources/js/pages6Index, detail and form screens, plus their columns, filters and type definitions
routes/modules1Its own route file, gated and throttled
tests/Feature1A 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 indexOn the record
Search across the columns you marked searchableA detail page with the record, its relations and its status flow
Filters, with a badge counting the active onesAn activity timeline — who changed what, and when
A status tab strip, from the enum in your schemaCreate and edit in a modal, validated server-side
A column menu, remembered per browserOptimistic concurrency — a second editor is told, not silently overwritten
Sorting, pagination and a row-count footerSoft delete, a trash view, restore and permanent delete
Bulk actions: status, assignment, deleteSensitive columns masked on screen and redacted in the audit log
CSV and Excel export, and CSV importThe same module over REST, with tokens and scopes
The table updating itself when someone else writesEvery 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:

1
Introduction What the kit is, what it is not, and what you are expected to already know.
2
Technology Stack Every version it is pinned to, and why each one is pinned rather than floating.
3
Getting Started From the zip to a running app, on a machine that has only Docker.
4
The Admin Panel The screens you get before you write anything: users, roles, permissions, audit trail, settings.
5
Anatomy of a Module The files one module is made of, and what each one is responsible for.
6
Designing Your Table The migration is the config — this is the vocabulary it reads.
7
Field Types — The Full Matrix Every column type the generator recognises, and the control, rule and format each one gets.
8
Eloquent Relationships Explained Belongs-to, has-many, many-to-many and self-referencing, and what each emits on screen.
9
Index Views The table, and the tree, board, calendar and map a module can ask for.
10
Actions, Export & Import Bulk actions, CSV and Excel export, and importing from a spreadsheet.
11
REST API The same module over HTTP, with tokens, scopes and optimistic concurrency through If-Match.
12
Advanced Features Realtime tables, soft deletes and the trash, activity timelines, health checks.
13
End-to-End Walkthrough A Suppliers module built by hand from a module that ships, so you know what every file is for.
14
Setting up Single Sign-On & passkeys Google and GitHub, plus passwordless sign-in, wired end to end.
15
Production Checklist & Troubleshooting What to change before the first deploy, and the failures that look like something else.
16
Command Reference Every artisan command the kit adds, with its flags.

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.