A major release: upgrading needs work from you. Read these before applying the patch.
1.19.2 was never published; everything prepared under that number is in this release.
-
Every API of a module is named after its table, in the plural. The admin API took the
module's screen name, so make:crud employees --as=employee --api answered at
/api/v1/employee while the same module's self-service and public APIs answered at
…/employees. REST names a collection in the plural, and an API is a contract with the apps
that call it: the admin API is now /api/v1/<table-kebab> with route names
api.v1.<table-kebab>.*, whatever --as or --route call the screens. A module wired under
the old path is moved when it is generated again — the old lines are taken out of
routes/api.php, not left answering beside the new ones. Breaking: clients of the admin API
move to the plural path (the example modules: /api/v1/employees, /api/v1/departments,
/api/v1/skills); the OpenAPI document and its tags follow.
-
A hand-written operation documents the headers it reads. #[Operation] had no way to say
"this takes an Idempotency-Key header", and a FormRequest that merges the header into its data
to validate it had the field documented as a body field no client sends. headers: now lists
them; a header named after the field it is merged into takes that field's rule as its schema,
and the field leaves the body.
-
The Postman export sends what the API takes. A multipart request sent a file as an empty
text field, a list as one JSON string (which the array rule refuses), a boolean as the text
false, left out a record's key said once for every verb of a path, and filled a coded field
with string. Files are now file fields, a list is one key[] entry per item, a boolean is
1/0, path-level parameters are carried, and a field with a simple pattern gets an example
that matches it (^[A-Z]{2}-\d{3}$ → AA-000).
-
The API document lists what the API sends and takes. Missing were: the X-RateLimit-* and
X-Request-Id headers on every answer (and X-RateLimit-Reset on a 429); the paginator's
meta.links; a file's real type (it said application/octet-stream for a PNG served inline);
several sort keys at once (sort=-status,name); include=<rel>Count / <rel>Exists; and a
contact. The rate limit was "60 requests/minute" in the text whatever the limiter said. Now
each is documented, sort and include are comma-separated lists, the limit is
API_PER_MINUTE (60) for the limiter and the text alike, and info.contact names the
application. A count was accepted for any relation and printed for none: a list now counts a
to-many relation (<relation>_count, <relation>_exists on each row) and refuses a count of
a to-one relation with 400. An edit-only module's UpdateInput/PatchInput schemas were left
out of the document; they are in it. Regenerate with --force.
-
The input schema says what the rules check. A regex: hint and date_format: were not
in the document, so a client met a 422 for a value the document allowed; an upload's max
(kilobytes) was written as maxLength; a int[] column came back as strings
(["1","2"]) under a schema promising integers; and an ip column was documented IPv4 only
though IPv6 is taken. Now regex becomes pattern (left out when it carries a flag a
pattern cannot), digits/digits_between and date_format become pattern (several
formats, any of them) or minimum/maximum, a file says At most N KB., an int[]
column is cast PostgresArray::class.':int' and read as integers, and ip is documented as
either family. Regenerate with --force.
-
A refused token is rate-limited too. Laravel authenticates a route before it throttles it,
so a request with a bad or expired token was never counted — each one a token lookup anyone
could repeat — and its 401 carried no X-RateLimit-* headers (OWASP API4:2023). The rate limit
now runs first ($middleware->priority() in bootstrap/app.php: Laravel's own list with
ThrottleRequests moved ahead of authentication), and the api limiter asks Sanctum for the
token's owner itself, so a valid token is still limited per user and a refused one per address.
A project whose routes/api.php predates this lists throttle:api before auth:sanctum.
-
Public ids find their row however a client spells them, and the public API keeps internal
ids to itself. A ULID sent upper-cased — its specification makes it case-insensitive — was a
404 in the self-service and public APIs; a public module keyed by slug printed the ULID as
id and then answered 404 to it; and a link to a table with no public key went out as the
internal integer (department_id: 3, filter[department]=3), naming nothing a public client
could fetch and counting the rows behind it. ULIDs are now matched case-insensitively, a
slug-keyed module with a ULID answers to either, and the public API leaves such a link out
(make:crud says which and how to add a ulid). An embed stays keyed by its include name.
Regenerate with --force.
-
PUT replaces, PATCH changes what it sends. Both verbs reached one handler with one rule
set: a PATCH naming one field was refused because the others were "required", a PUT leaving
fields out kept their old values, a changed immutable field was dropped with a 200, and the
document listed only PUT with the create body. Now a PUT is checked as the edit form is (a
required field it leaves out is a 422), a PATCH checks and writes only the fields it sends —
a field it sends whose rule reads another (a date range, show-if, a composite unique) is
checked against the other as stored — and a changed immutable field is a 422
(App\Support\Validation\Unchanged); sent back unchanged it passes. Update<Model>Request
gains formRules() (the whole-record rules, which the inline cell edit uses too). The OpenAPI
documents describe PUT and PATCH separately, with <Model>CreateInput, <Model>UpdateInput
and <Model>PatchInput in place of the one <Model>Input. Regenerate with --force; a
client generated from the old document renames the input types.
-
A query the API cannot use is a 400, wherever it appears. An unknown include on a single
record was ignored (the list already answered 400); per_page=2 served 15 rows while
links.next still said 2; filter[department]=abc matched nothing and filter[active]=maybe
was dropped, both looking like a real answer; an unknown image size was 422. Each is now 400
with code: invalid_query and a sentence naming it (PageSize::api(), Includes::requested(),
FilterSet::acceptsValue()). The screen keeps dropping a value it cannot use. A filter on an
integer key now treats a non-number as no filter on the screen, as it did a value outside an
enum. Regenerate with --force.
-
A create says where the record lives, and a read can be revalidated. A 201 carried neither
Location nor ETag, so a client built the record's URL itself and read it again before its
first conditional write; and If-None-Match with the current ETag was answered 200 with the
whole body. A create now answers 201 with Location and ETag (admin and self-service), and
a show answers 304 with no body to the version the client holds — unless ?include embeds
rows the tag does not version. The public API answers Cache-Control: public, max-age=60
(API_PUBLIC_MAX_AGE; 0 turns it off) with an ETag on each record, and stored files carry
ETag and Last-Modified and answer 304. The OpenAPI documents list Location, ETag,
If-None-Match, 304 and Cache-Control, and leave out shared parameters, headers and
responses no operation uses. Regenerate with --force.
-
A body the API cannot read is answered 415 or 400, not 422. A write sent as text/plain
or XML, with no type, or with JSON cut off mid-object was read as no fields at all and answered
422 with every required field "missing". EnsureSupportedBody (on the admin and self-service
API groups in routes/api.php) answers a type other than JSON, a form or multipart with 415
and the types it takes (Accept-Post/Accept-Patch), and JSON that does not parse with 400
invalid_json. The OpenAPI documents list both on every create and update. A project whose
routes/api.php predates this adds EnsureSupportedBody::class to those two groups.
-
Every API error is problem details (RFC 9457). Errors answered {"message": …} (and
errors on a validation), the same body for every 403 whatever the reason, and a missing
record's sentence named its model class (No query results for model [App\\Models\\…]) to
anyone, the public API included. Every error from the admin, self-service and public APIs —
wherever their prefixes put them — is now application/problem+json with type, title,
status, detail, instance, a machine-readable code and the request_id; message and
errors stay where clients read them. A 401 carries WWW-Authenticate: Bearer (with
error="invalid_token" when a token was refused), a read-only token's 403 carries
error="insufficient_scope", and a suspended account, the trash and a missing permission are
told apart by code. The OpenAPI documents describe the Problem schema and give every
operation a default response. A business refusal under a custom self-service prefix
(API_SELF_PREFIX=storefront/v1) answered with a redirect; it answers JSON now. A client that
checked for Content-Type: application/json on errors reads application/problem+json.
-
A browser client can read the API's own headers. config/cors.php exposed none, and a
browser hides every header outside a short safelist from the calling script — so a web client
could not read the ETag it must send back as If-Match, a 201's Location, a 429's
Retry-After or the request id. They are exposed now (exposed_headers).
-
GET /api/v1/user answers who the token belongs to, and no more. It returned the user
model as stored — the second factor's confirmation, the suspension, the last sign-in, the
password's age. It now answers {"data": {"id", "name", "email"}} through
CurrentUserResource, from a controller the API documents list.
-
An API page has a total order. The admin, self-service and public indexes ordered by the
requested or default column alone, so rows sharing a value (a seeded batch's created_at, a
status) could come back in any order under LIMIT/OFFSET: one row served on two pages, another
on none. The primary key is now the last ordering, in the direction of the first, as on the
screen. Nothing to regenerate.
-
The API answers create and update with the record as stored. The response was built from
the model the request had just filled, so a multipart create or update — where every value
arrives as text — answered "department_id": "1" where a read answers 1, and a strict client
(Dart, Swift, Kotlin) failed to decode it. The record is read back first; the update's body and
its ETag now describe that one state. Each module with a foreign key tests it.
-
Deleting a row other rows still refer to is refused with 409, not a 500. A module with no
trash removes the row on delete, so a foreign key may refuse it — and the delete action did
not catch that (only the permanent delete from the trash did), so the API, the screen and the
bulk delete all answered 500. The refusal is now a sentence naming what still refers to the
row: 409 Conflict on the API (the request is sound; the row's state refuses it), a toast on
the screen. Every delete refusal, permanent ones included, answers 409 now rather than 422,
and the OpenAPI document lists 409 on the DELETE of a module whose delete can be refused.
Each such module tests it against a real foreign key. Regenerate with --force.
-
Sorting by a related row in the API no longer answers 500. A foreign key sorts by its
related row's label, and the document lists it in sort — but the API handed the name to the
database as a column, so ?sort=department (the public API's too, without signing in) was a
SQL error. Related labels and declared ranks now order through the list's own ordering
(FilterSet::orderByKey(), a correlated subquery so it stays clear of the public scope and
the public keys), both ways. Each module with a foreign key tests both directions.
-
A self-service write cannot point at a row the public may not see. A foreign key sent by
its public key was looked up without the related module's publiclyVisible() scope, so a
shopper could attach an unpublished row by its ulid and read its name back through
?include=. PublicKey::toIds() now applies the scope where the model has one; such a key
is refused as exists, like one that names nothing.
-
The lost-update guard holds under concurrency. If-Match was compared before the write and
outside its transaction, so two clients holding the same version both passed, and the second
silently overwrote the first; the web form's _version had the same gap. The Update and Delete
actions now take the version the caller read (expected:), lock the row, compare and write
against that one state, and refuse with StaleRecord — 412 on the API, the
"changed elsewhere" toast on the screen. If-Match is also answered before the body is
validated (RFC 9110 §13.2.2), so a stale write is 412 even when its body is invalid. The
ETag is strong now and compared strongly (a W/ tag never matches); the update's body and
ETag describe one state. API_CONDITIONAL_WRITES=required makes If-Match mandatory:
a write without it is refused 428 (RFC 6585), and the OpenAPI document marks it required and
lists 428. Each module tests the strong comparison, 428, 412 before validation, the ETag after
a write, and the refusal inside the action itself. Regenerate with --force; an edited Update
or Delete action needs the new ?array $expected = null parameter.
-
An API update no longer deletes the gallery or the links it does not mention. The document
named a gallery's input gallery and a picker's skills, while the requests read
gallery_new/gallery_existing and skill_ids/skill_new; and the update read a missing list
as an empty one. A client that followed the document lost its uploads on create, and every
update it sent deleted the record's gallery files from disk and detached every linked row. Now
the document names the keys the requests read; on update a list left out stays as it is and
an empty list clears it; and a gallery reads as [{path, url}], the path being what
{column}_existing sends back to keep a file (the public API still lists URLs). The web form
keeps its reading — it always holds every list, so there a list a multipart body dropped is
an empty one. Each module's tests now check that every documented input key is one its
requests read, and that an update without the lists leaves them alone. Regenerate API
modules with --force; a client reading a gallery as URLs reads url.
-
Two API documents, hand-written operations in them, a Postman export. The OpenAPI
document described the generated modules only, behind login: a sign-in, a checkout or a
webhook written by hand was missing, and an app developer could read none of it. A
controller method now declares its operation with #[App\Support\Api\OpenApi\Operation]
— summary, documents, security (token, none, or a scheme from api.docs.security;
stripe ships), responses — while the path and verb are its route's and the body its
FormRequest's rules (RequestSchema), so the document and the code cannot disagree. There
are two documents: admin at /api/docs, behind login, the whole API; public at
API_PUBLIC_DOCS_PATH (api/public/docs), readable by anyone, with its own Swagger UI
outside the app's layout: the --owner and --public modules and the operations declared
for it. Both are checked against the OpenAPI Initiative's own 3.1 schema in the tests and in
the generator's conformance run (new dev dependency ajv). php artisan api:postman admin|public writes either as a Postman v2.1 collection.
-
The OpenAPI documents are 3.1.1. They were 3.0.3; 3.1 is OpenAPI's current line and
takes its schemas from JSON Schema 2020-12, so a schema in the document is a schema any
JSON Schema tool reads. A value that may be null says so in its type — "type": ["string", "null"] — where 3.0 had nullable: true, which 3.1 ignores; a schema's example is an
examples list; a file in a multipart body is a string with contentMediaType (and
format: binary, which Swagger UI still looks for). A file rule's max: no longer turns
into a maxLength: it is kilobytes. Generated ApiSpec classes are written this way; one
generated before is read into the same terms when the document is assembled, so nothing has
to be regenerated for the document to be valid. The tests check both documents against the
OpenAPI Initiative's own 3.1 schema (kept in tests/Fixtures/openapi-3.1), every schema in
them against the 3.1 dialect, with Ajv (tests/Support/openapi31.mjs), and the new
dev dependency ajv replaces justinrainbow/json-schema, which stops at JSON Schema draft 7.
-
The public OpenAPI document is valid before there is anything in it. With no public
module yet, its paths were written as [], which is not an OpenAPI document — Redocly and
client generators refused the page a fresh install serves. An empty set of paths is {} now.
-
php artisan api:openapi admin|public writes either document as JSON, for a linter in
CI, a client generator or a gateway. The generator's conformance run lints both with
Redocly.
-
The public and self-service APIs speak in public ids. Their resources extended the
admin one, so the integer id and every integer foreign key went out beside the ulid
("id": 25, "category_id": 8) and came back in — filter[category]=8, a bag item posted
with product_variant_id: 277 — and a client could count the table. Now a record's id is
its ulid (else the public API's --public-key), printed once; a foreign key is the
related row's ulid or unique slug, out, in and in filters; an embedded row carries its
own. Lists read the related keys beside each row in one query (Resource::keys(), the new
App\Support\Api\PublicKey, ApiQuery::withKeys()); filters by FilterSet::belongsToKey();
the self-service API lists through a new Filtered{Models}::selfSet() (no owner, no trash)
and its requests list their keys in KEYS, which PublicKey::toIds() turns
into ids before the module's own rules (and the project's customRules()) check them; a
key that names no row, or an integer, is refused as exists. A table without a public key keeps its integer, and make:crud warns. The admin API
is unchanged. Regenerate --public/--owner modules with --force; clients that read
ulid read id, and send related rows by their public id. (TL91)
-
Errors under the self-service and public prefixes are JSON. Only /api/v1/* and requests
asking for JSON got JSON errors, so an app calling /api/storefront/v1/… without an
Accept header got the HTML error page — a 404, a 429, a 500. The prefixes in
config/api.php count too, through one check both exception hooks share in
bootstrap/app.php (one of them had kept its own, api/v1-only, copy).
-
The API reference is Swagger UI over a valid OpenAPI 3.1 document. /api/docs renders
the document with Swagger UI (Authorize, Try it out, filter by tag, operation ids) and offers
it as openapi.json for Postman, Insomnia or a client generator. The document passes the
Redocly linter. Each generated module now describes itself — openApi() on its API
controller states the resource's fields (enums, formats, decimals as the strings Laravel
sends, money in cents, read-only columns), the request's rules (required, lengths, bounds),
the filters' types and the relations ?include may embed — and the document lists only the
operations whose routes exist, with filter[...], sort, include, per_page and
page/cursor as the endpoint reads them, ETag/If-Match, and 400, 404, 412, 422 and 429.
Before, every module was documented with POST, PUT and DELETE, search/direction
parameters the API does not read, and every table column, hidden ones included. Regenerate
your API modules with --force to take this up; a hand-written API controller is still
documented from its table. New dependency: swagger-ui-react (loaded on that page only).
-
One policy decides, and a module's HTTP layer is split by concern. A generated controller held
six concerns — the resource, export, import, bulk actions, the trash, file downloads — in twenty
public methods, and decided who may do what twice: ten can:<module>.<ability> rules in its
middleware() beside the policy, which knew only update and delete; the pages guessed again from
auth.permissions. Each module now has {Model}Controller with its resource actions, and every
other thing its screens do is a controller of its own that answers with resource actions only —
the record the form opens with is {Model}FormController@show, the CSV and Excel downloads
{Model}ExportController@index and {Model}ExcelExportController@index, the import's dry run
{Model}ImportPreviewController@store, a row back from the trash {Model}RestoreController@update,
a bulk status change {Model}BulkStatusController@update, a workflow step
{Model}TransitionController@update, a picker's search {Model}LookupController@index, a panel's
delete {Model}{Child}Controller@destroy, and so on — the shape Laravel's own starter kits take
and the one Pest's laravel architecture preset holds every controller to. The form's lookup
lists are App\Queries\{Model}FormOptions::get() (a parent's page reads its child's), and the
rules each import row is held to are Import{Model}Request::rowRules(). Every action is authorized with Laravel 13's #[Authorize] through the module's
policy — viewAny, view, create, update, delete, restore, forceDelete, the selection
abilities (updateAny, deleteAny, restoreAny, forceDeleteAny), export, import,
approve, updateRestricted — and the policy is the only place a permission is named. The pages
receive an abilities prop from the same policy, so a button shows exactly when its action is
allowed; the export menu no longer shows to someone who may not export. The selection a bulk
action works on is read off its request (selection(), trashedSelection(), target()), the
list's filters off the query class (Filtered<Models>::fromRequest(), forRequest()), and the
trash's routes bind the deleted record (->withTrashed()) so its policy is asked about it. Route
names and URLs are unchanged; a module wired before is moved onto its new controllers when it is
generated again — its route lines are found by their name and pointed at the controller that
serves them now. A row deleted from a parent's panel is now deleted by its own module — its policy and its
Delete action — where the parent's controller deleted it and wrote the audit entry itself.
-
A module's tests speak Pest, and check what a write ends in. Each route of the module and the
permission it answers to is one row of a dataset — a user holding every other permission of the
module is refused each — and each of the create form's rules is one row of another: blank where
required, an array where text belongs, a character past the column, an address that is not one,
a case the enum lacks, a negative amount, a key into nothing, a value another record holds; an
optional field left empty is accepted, and a bulk selection that is not one is refused. A write's toast and redirect are asserted, not only
its status; the index's props and the record page's fields are checked; a bulk delete of "every
row the filters match" is shown to take only those, and its audit entry to name them; the trash's
bulk restore and permanent delete are tested. Each file opens with pest()->group('<module>')
(./scripts/test.sh --group=employee runs one module) and mutates(...) naming the module's
controllers, actions, requests and policy, so pest --mutate measures the tests against them;
each closes with arch() rules of its own. On the example Employee module the mutation score of
those classes went from 24 % to 51 %; the tests from 82 to 143.
-
A module's web controllers live in a folder of their own. Split by concern, a module has a
dozen or more, and they sat flat in app/Http/Controllers/ beside the application's own, while the same module's
requests and actions were already one folder each. They are in app/Http/Controllers/<Model>/
now (Controllers/<Group>/<Model>/ with --namespace), as Laravel's own starter kit groups its
Settings/ controllers; the class names stay whole (EmployeeBulkController), so no two modules
share one, and the API controllers stay in Api/. Route names and URLs are unchanged.
Regenerating with --force moves a module: its route file imports the new classes and the flat
files the generator wrote are removed; a flat file it did not write is left where it is and
named. Code of your own that names a module controller by class (App\Http\Controllers\EmployeeController)
or imports its Wayfinder actions (@/actions/App/Http/Controllers/EmployeeController) takes the
folder into the name.
-
A link to another module asks for the permission that module's policy checks. A page that
links to a related module, or lists its rows in a panel, read that module's permission off a
can:<permission>.view on its controller. Since the policies decide, no controller carries one,
so the link fell back to the module's route name: for a module made with --permission, it was
hidden from every role but super-admin. The permission is read from the module's policy now —
a module from before the policies still from its controller — and the generator server is told
it the same way.
-
A missing record is not told apart from a forbidden one, again. A caller without a module's
permission got 403 for an id that exists and 404 for one that does not — enough to map which ids
exist without reading one. App\Support\Auth\RouteGate closed that for can: middleware and
skipped the policy abilities #[Authorize] puts on a route (view, update, … on the bound
record). It asks the policy now whether the caller may do that to any record (viewAny,
updateAny, …) and answers 403 when they may not; a caller who may still gets an honest 404.
-
A regeneration no longer reports moving a read route it left where it was. Every run said
(form-data route) · moved to the read group and wrote the route file again: the group was
looked for by its opening line directly above its marker, which stops being true once one route
is in it.
-
Regenerating without --force leaves a module's policy, API description and API controllers
alone. The client sent the generator server some of a module's files and not others, and wrote
back whatever the server returned: a policy you had edited was written over, and a file the
module no longer has stayed behind. Every file the generator can write for the module is sent
now. The generator server has to be updated first: an older one refuses a policy it is sent.
-
A module's list page is composed from shared parts, and its filters have a file of their own.
index.tsx held the whole screen in one component — the URL state and every visit that changes
it, the loading and scroll listeners, the filter controls, the chips, the table, the bulk bar —
1,654 lines for the Employee example, most of them the same in every module. The parts that are
the same are now shared: useListQuery (the list's URL state: navigate, runSearch,
toggleSort, resetFilters), useNavigating, useScrollMarker and useBulkActions in
resources/js/hooks/, and DataTable, RowIdentity, TableEmptyState, BulkActionBar,
BulkSetMenu, StatusTabs and the overflow menu's OverflowItem, OverflowExportMenu,
OverflowColumnsMenu and OverflowViewsMenu in resources/js/components/table/, each with
its tests. What is the module's own — its filter controls and chips, with the option lists they
read — is generated into resources/js/pages/<module>/filters.tsx as <Model>FilterPanel and
<Model>FilterChips. The Employee page is 836 lines and Department's 705; the markup, the
routes and the behaviour are unchanged, and the browser suite passes as it did. Three things
were wrong on the way and are right now: a loading row hid its columns at the window's
breakpoints while the row it stands in for used the card's, so the table changed shape as it
loaded; an enum's filter chip showed the stored value (on_leave) beside a select reading
"On Leave"; and the free-text filter asked for its values at a URL written into the page
instead of through the module's route helper. A module generated before keeps working as it
is; generate it again to move it onto the shared parts.
-
A module's form and record page are composed from shared parts too. After the list page
(above), form-modal.tsx and show.tsx were the two files still copied whole into every
module: the dialog, its fetch and placeholder, the "discard your changes?" guard, the footer,
the details list, the audit trail and the delete dialog — 815 and 615 lines for the Invoice
example. They are resources/js/components/crud/: CrudFormDialog, useFormGuard,
CrudForm, FormField, OptionSelect, LineItemsEditor, LineItemsTable, RecordPage,
RecordHeader, DetailList/DetailRow, RecordMeta, InfoCard and ActivityTimeline,
each with tests; a module's files arrange them (the Invoice form is 339 lines, its page 246).
A form's record is read through the form-data route helper rather than a URL written into
the page, and a field's label now points at its control, a select included.
-
Editing a document opens on its lines. A master-detail module's form-data loaded the
record's lines and then left them out of what it sent — the payload was the header's column
set — so the edit form opened on one blank line: saving was refused for that line, or, once
it was filled in, replaced every line the document had. The lines are in the payload now
(the columns a person edits, and the label behind a searchable key), and a generated module
test opens the form and counts them. Regenerate master-detail modules with --force.
-
A document's lines say which of them the server refused. The server names a refused line
value items.<n>.<column>; the form showed only an error about the lines as a whole, so a
wrong price on the third line was a refused save with nothing marked. Each message is now
shown under its cell and marks the control (aria-invalid, aria-describedby), and lines
are keyed by an id of their own, so removing one does not hand its input to the next.
-
A document's amounts are written one way, and previewed on the digits. On a module whose
lines total qty × price, the discount, tax, subtotal and grand total are money and the tax
rate a percentage, as if each column had been hinted mask:currency or mask:percent — the
name alone made subtotal money and discount a bare number, so one invoice showed four
amounts three ways. The lines and totals on the record page follow the same columns instead
of an Indonesian format written into the page, plain decimals are shown with the places the
column keeps (formatDecimal, new), and formatMoney no longer rounds through a float. The
form previews its totals with lib/decimal (new), the client's half of App\Support\Money\Decimal,
in the order the server computes them, so the preview and the stored invoice agree to the cent.
-
A master-detail record's API returns its lines, and its document asks for them. The API took
items on create and update — required, at least one — but never gave them back, and the
OpenAPI document did not name them: a client built from it was refused with 422 every time, and
no endpoint showed a document's lines. Every single-record response (show, create, update) now
carries items in the shape they are written in, with the amount the server worked out; the
document describes them on the way in (required, minItems, each line's rules) and out. The
lines are part of the record's version, so a read carrying them still answers 304, and a write
from a copy whose lines another editor replaced is refused with 412.
-
A module's first page sorts its imports as every later one does. Until wayfinder had written
a new module's route helpers, eslint could not resolve @/routes/<module> and sorted it among
the external packages, so the first generation of a page and the second differed by two lines.
eslint.config.js now treats every @/ import as the project's own (import/internal-regex).
-
Through the generator server, the names you are told are the ones the kit wired. After a
generate the client named the permissions to grant from the route, ignoring --permission, and
warned that a parent page "does not list" the module whenever the module had a panel key — it
read the server's stand-in of the parent, which lists nothing. The kit now hands back the
permission base and the panel parents, and the client checks the parents against your own
models. A page that links to another module checks that module's own permission there too, as it
does when generating locally.
-
A master-detail module writes through its Actions, and adds its money exactly. --detail
modules kept their own store and update bodies in the web and API controllers — the transaction,
the lines, the totals and the audit entry — and computed every amount as a float:
(float) $qty * (float) $price, summed, then round(…, 2). They now write through
Store<Model> and Update<Model> like every other module, so they gain what those carry: the
version compared under a row lock, stamps, file handling, the importer. Amounts are worked out
with App\Support\Money\Decimal (bcmath, on decimal strings): each line rounded to its price's
places, then summed; the tax at a rate and the total rounded to the header column's; half away
from zero. An update without items — a cell edit, a partial API write — keeps the stored lines
and works the totals out from them, with the stored discount and rate where the request leaves
them out; the module's tests now prove it. The line model written for a --detail module no
longer names a policy no file declares — it stopped the module compiling. The conformance gate
now generates a master-detail module, compiles it and runs its tests, and refuses a generated
controller that holds a transaction, an audit entry or inline validation.
-
A selection's writes are Actions, as one record's are. Bulk delete, set status, reassign,
restore and permanent delete wrote, logged and dropped the cached stats inside the controller —
the one place a module's writes were not in app/Actions/<Model>/. Each is now an Action
(BulkDelete<Models>, BulkUpdate<Model>Status, BulkAssign<Models>, BulkRestore<Models>,
BulkForceDelete<Models>) that takes the query the controller built — the selection, live or in
the trash, narrowed to scopeWritable() — and an App\Support\Audit\BulkTarget describing it,
and returns how many rows it changed. The controller keeps authorization, the toast and the
redirect; the audit entries and their wording are unchanged. Like the other Actions they carry a
fingerprint, so --force replaces one only while you have not edited it.
-
A bulk action on a uuid-keyed module names the rows it touched. The audit entry normalised
ids as integers, so every uuid was recorded as 0. BulkTarget keeps a uuid as itself.
-
Generated docblocks say "an employee", not "a employee" — in the delete, force-delete and
transition actions, the form modal and the self-service and public API resources.
-
An API controller answers requests; its OpenAPI description is a class beside it. A
module's admin, self-service and public API controllers each carried their part of the OpenAPI
documents as one array literal in openApi() — 450 of the example EmployeeApiController's 620
lines were schema, so the endpoints were hard to find in their own controller. The description is
now app/OpenApi/<Model>ApiSpec.php, written by make:crud with admin(), selfService()
(--owner) and publicApi() (--public); each controller's openApi() returns its method, so
the documents are built exactly as before. A module regenerated with --api gains the file;
crud:remove takes it out with the module.
-
The trash is its permissions, and one record is checked as a selection is. A module's
<module>.restore and <module>.force-delete were seeded and listed in the role matrix but
decided nothing: the trash was the super-admin role's, hard-coded, so granting them did nothing.
They are now the rule — either opens the Deleted view, each allows its own action, on the screen
and the API — and the seeder still gives them to super-admin alone, so nothing changes until a
role is granted them. And a write to one record ignored the model's scopeWritable(), which every
bulk action is narrowed by: each module now has a thin policy (app/Policies/<Model>Policy.php,
#[UsePolicy] on the model) asked by can:update,<record> / can:delete,<record> on its
single-record routes. Regenerate with --force.
-
Models are declared the Laravel 13 way. A generated model restated its table and listed
$fillable/$hidden/$timestamps as properties, where the kit's own User — and Laravel 13's
skeleton — use attributes; a view model got a fillable list though nothing writes it; and the
public ulid was mass-assignable. Models now carry #[Fillable([...])], #[Hidden([...])],
#[WithoutTimestamps] and #[Table('...')] only when the name is not the one the class
implies; a view has no fillable list, and ulid is filled by HasUlids alone. make:crud
reads both shapes when it adds a column to an existing model. Regenerate with --force; the
crud:custom block is carried over.
-
Generated comments say what is true, and nothing points at notes you never got. Shipped code
and comments named the kit's internal tracker ids (TL91, "kit finding TL57"); a generated docblock
read "Updates a employee"; writable() spoke of a policy there was none of; a workflow's bulk move
promised stamps a module without stamps does not have; a self-service request inherited "Authorized
by can:" from a controller with none; the screen's store() kept a variable it never used; and
the README told you to run storage:link for files that are private. All corrected; the release
build and the conformance gate now refuse a tracker id in anything that ships or is generated.
-
Generated tests check what their names say. "Creates a record and logs the activity" counted
rows; it now checks there were no errors, that the text sent is the text stored, and that the
created entry was filed. The API tests answer a missing record (404 not_found) and a body
that fails its rules (422 validation_failed with the field named).
-
A table with no free text still gets an update test. The generated update test renamed a
text column; a table without one (counts, flags, keys) had it skipped, and its Update action was
exercised by nothing. It now moves a number the form writes between two values its rules accept
(between:1,10 → 1, then 2), or turns a flag on.
-
Smaller rough edges, smoothed. An upload written inside a save that then failed stayed on
disk with nothing pointing at it; it is now taken back when the transaction rolls back
(StoredFiles::store() registers DB::afterRollBack()), for every module, no regenerate
needed. A module's counts were one COUNT a state; they are one grouped query. A password
field checked min:8 whatever the installation's policy said; it checks Password::defaults().
A typed slug that normalises to nothing (!!!) was saved empty; it falls back to the source
column. Regenerate with --force.
-
Uploads are bounded the way OWASP asks. A gallery took any number of files a save, an image
any pixel size, and resizing decoded whatever came: a 5 MB PNG of 20000×20000 asked for 1.6 GB
and killed the queue worker on every retry. Images now carry
dimensions:max_width=8000,max_height=8000, a gallery takes at most 20 files a save, and
ImageVariants reads the size from the header and builds no size past 40 megapixels (the
original is still served). Uploads go to filesystems.uploads (UPLOADS_DISK, default
local) — StoredFiles::DISK is replaced by StoredFiles::disk(); code that named the
constant names the method. The OpenAPI documents state both limits. Regenerate with --force.
-
Factories make their rows the way Laravel's own do. A required link picked a random
existing parent (inRandomOrder() — a query per row, and a test that depended on what the last
one left behind), an optional link did the same, a password was hashed per row, an enum was
written as its string value and a length cap cut multibyte text mid-character. Now a required
link is Parent::factory() (made only when the caller passes no parent; reuse existing ones
when seeding with ->recycle($rows)), an optional link starts null, one
Hash::make('password') serves every row as in Laravel's UserFactory, an enum is its case,
and caps use mb_substr. A parent with no factory is still looked up and named when missing.
Regenerate with --force.
-
Telescope no longer records the generator. In development Telescope recorded every query of
every make:crud run, and a day of regenerating modules filled a disk: telescope_entries
reached 34 GB inside the 48 hours the nightly prune keeps. make:crud, crud:remove,
kit:remove-examples, the API document exports, images:variants and demo:reset are now in
telescope.ignore_commands.
-
A page of photos is not refused halfway. Every route a module adds beside its resource sat
under one throttle:30,1, so an index of fifty thumbnails — one request each — was answered 429
from the 31st, and a form's options and a row's form data counted against the same budget as an
export. Reads one screen makes many of (file, form data, filter and picker options) now sit in
their own group under the crud-reads limiter (600 a minute); exports, imports, mass edits and
the trash under crud-bulk (30). Both are per user and set in config/table.php
(MODULE_READS_PER_MINUTE, MODULE_BULK_PER_MINUTE). Regenerating moves an existing module's
reads into the new group; a project without the two limiters keeps numeric throttles.
-
customRules() replaces any generated rule, create-only and update-only ones included. The
Store and Update requests added their own rules after the base had laid customRules() over the
shared ones, so a key there could not replace a rule only one mode has — though the docblock said
it could. Those rules now come from modeRules(), which the base lays under customRules().
Regenerate with --force; the crud:custom block is carried over.
-
An inline-editable column that may be empty compiles. With --inline-edit, a nullable
column's cell (item.x ? (…) : (<Empty />)) was handed to the editor inside a fragment, where
it printed as text and lost its narrowing, so tsc refused the module. The cell is now passed
as the expression it is. Inline editing stays opt-in. Regenerate with --force.
-
A bulk delete takes the uploads with the rows. A bulk delete was one query, and a query
fires no model events, so the observer that removes a row's files never ran: the rows went,
their photos stayed on disk. A module with file fields now deletes the selection row by row
through its Delete action (or, from the trash, its ForceDelete action) inside one
transaction — a row other rows still refer to refuses the whole selection, as the single
statement did, and each row files its own audit entry. A module without files keeps the one
statement. Each module with files tests it. Regenerate with --force.
-
The audit trail records the whole update. A password change, a multi-value enum and a
gallery were left out of an update's entry, and a many-to-many change (retagging) was not
recorded at all. Now the password is recorded as changed, blanked like a sensitive column
([redacted]); a list column is recorded as the list, and reads red, blue on the record's
timeline; a many-to-many save records the links it attached and detached, read as
+ PHP, Go · − Java. A save that changed nothing files no entry. Each module tests the empty
save and, with a many-to-many relation, the links. Regenerate with --force.
-
A related row in its trash cannot be picked by a request. Rule::exists() counted
deleted rows, so a request could point a record at a parent the pickers never offer; and the
bulk reassign took to=1abc to the database, which answered with a cast error — a 500. A
foreign key, a picker's ids and the bulk target now use ->withoutTrashed() when the related
table has a trash, and the bulk target is typed (integer, uuid, or string for a natural
key) before it is looked up. Each module tests a trashed parent and a malformed target.
-
A number its column cannot hold is the field's error. An integer had no ceiling and a
decimal no scale: quantity=3000000000 passed validation and came back from Postgres as an
overflow — a 500 — and 12.505 in a numeric(12,2) column was stored as 12.51 without a
word. An integer now stops at its column's range (int2, int4; MySQL UNSIGNED doubled),
a numeric(p,s) takes at most s places (decimal:0,s) and p digits, and the OpenAPI
document states both. Each module tests it on one such column.
-
A range with an open end is valid. Two columns paired with range-end: compared each other
even when one was empty, and Laravel's date rules fail against nothing — so a start date with
no end yet was refused. When the other end may be empty, the comparison now waits for it
(Rule::when, read from the data being validated, so a form, an API call and an imported row
are judged alike); a two-column CHECK on numbers is read the same way.
-
An import checks each row with the create form's own rules. The import validated with a
second rule set the generator wrote beside the form's, and the two had drifted: a 200-character
name passed the preview of a 120-character column, then failed in the database after earlier
rows were written; a rating of 200 or a colour of "banana" went in. importRules() is now the
Store request's rules for the columns a sheet carries (Arr::only), so the project's
customRules() count too. A time field takes 09:30 and 09:30:00 alike — the form, the
API and an export read back in. Each module tests that a row the form refuses is refused by
the import. Regenerate with --force.
-
A workflow move is one locked, audited write. transition() read to straight off the
request, updated the row and wrote the audit entry in the controller, with no transaction and
no lock — two moves at once both passed against the same starting state — and the bulk move
repeated the transition map inline. Now Transition{Model}Request validates the target,
Transition{Model} locks the row, asks the enum's own canTransitionTo() from where the record
stands now, applies the stamps and files one entry; a disallowed move is a 409 on JSON, a toast
on screen. The bulk move goes through the same action row by row. The map lives on the enum
(transitions()).
-
stamp-once:<column>=<value> — a milestone that stays. stamp:status=paid clears paid_at
when the order moves on to shipped; stamp-once writes it the first time and keeps it. An
English <x>_at / <x>_by pair is recognised beside <x>_pada / <x>_oleh, and make:crud
warns when a stamp: sits on a state the workflow leaves. Stamps are documented in the README.
-
A cell edit is the form's write. Inline editing validated with a third rule set of its own
(max:255 whatever the column) and wrote and audited in the controller, past the Update action
— its stamps, its version lock. InlineUpdate{Model}Request extends the Update request, so a
cell is checked by the form's rule for that column, and the change saves through the Update
action. The status of a workflow, stamps, immutable and range-paired columns are no longer
inline-editable. A partial write — a cell, an API call leaving fields out — no longer clears a
show-if field whose controlling field it did not send.
-
The exports no longer hand out the trash. Only the list checked that the caller may see
deleted rows; the CSV and Excel exports read the same filters without the check, so anyone
holding <module>.export downloaded the deleted rows with ?filter[trashed]=only. The check
now lives in the controller's filters(), which the list, both exports and every other
reader of the filters go through. Each soft-deleting module's tests prove both exports refuse
it. Regenerate with --force.
-
A typed-in tag needs the permission of the module it lands in. A "pick or type a new one"
field created rows in the related table for anyone who could save the form — no
<related>.create, no audit entry — and a name already in that table's trash came back as
"has already been taken" under an unrelated field. Now <relation>_new is refused unless the
caller holds the related module's create (read from that module's own controller, so
--as/--route/--permission are honoured), the row is made by the related module's Store
action (so it is audited and shaped like one added from its screen), and a name in the trash
is refused on <relation>_new with "restore it there, or pick another name". The form shows
that error under the picker. A master-detail parent links to a child module by the child's
own permission the same way, where it guessed it from the route. Regenerate with --force.
-
A module over a database view. make:crud customers on a view answered "Table
[customers] is not present", so a report over users and their orders became a hand-written
page. A view is now a read-only module: list with search, filters, sort and export, the show
page, the menu, .view/.export permissions, the GET API with --api and its OpenAPI, and
tests — --read-only is implied and the flags that would write (--import, --inline-edit,
--detail, --kanban) are refused. It needs an id column. A view declares no foreign keys,
so the new hint fk:<table>[.<column>] on a view column makes the belongsTo (label, filter,
link). Its tests make rows in the tables under the view through a hook the project writes,
database/factories/Domain/<route>.php (a closure returning the view row's id), and skip with
that file's name when it is missing. In server mode the client now sends views with the
schema, and the server rebuilds them as views. (TL94)
-
A module without a form no longer fails PHPStan over its combobox. A combobox foreign key
on a --read-only module emitted the <relation>PickerChain() the form's picker reads, unused
without a form, and the closing check failed. It is emitted only beside a form now. (TL97)
-
Images in smaller sizes: image;variants. A list or a phone downloaded the full upload
for every thumbnail. Hint an image column image;variants and each upload is also kept as
thumb 320, medium 800 and large 1600 pixels on the longest edge — or the sizes
variants:thumb=320,medium=800 names (1–5, 16–4096 px) — as WebP at quality 80, made with
GD (no new package): never enlarged, the aspect ratio kept, turned upright from the EXIF
orientation, metadata gone. They sit beside the original (products/abc.jpg →
products/abc.thumb.webp); no column records them. The module's observer queues the new
App\Jobs\MakeImageVariants after the write commits (3 tries, backed off, idempotent), and
removes an image's sizes when it is replaced or its row deleted for good. The admin, API and
public file routes take ?size= — the size once built (cached a day), the original until
then (a minute), 422 for a size the column does not keep (App\Support\Files\ImageVariants);
resources add <column>_variants URLs; the show page, form preview and relation panels draw
the thumbnail; OpenAPI documents both. Galleries (image;multiple;variants) too.
php artisan images:variants <module> [--column=] [--sync] builds them for rows that were
already there. Modules without the hint are byte-identical.
-
A module whose file columns are all NOT NULL passes its own check. The observer filtered
the paths it deletes with is_string(), which PHPStan level 8 calls always true for a
string column, and make:crud stopped with "does not compile" (TL93).
-
Deleting a row with uploads, in a module without a trash, removes the uploads. Only a
permanent delete from the trash did; a module without deleted_at left every file of a
deleted row on disk. Its observer now discards them after the commit too (TL88).
-
What anyone may browse, through the API: make:crud --api --public. A catalog, blog
posts, events — rows an app or a site shows to anyone, signed in or not — had only the
admin API (a token and a permission) or the self-service one (the caller's own rows), so
every storefront was hand-written. --public adds a read-only API beside the admin one,
under /api/v1/public (API_PUBLIC_PREFIX, new in config/api.php): a list, a record
and the record's files at the table's name — /categories for make:crud categories --as=category, whatever the admin module is called — named api.public.<table>.*, with no token and no permission,
rate limited per address by the new public-api limiter (API_PUBLIC_PER_MINUTE, 120).
Which rows anyone may see is the model's scopePubliclyVisible(), which the generator
writes once into its crud:custom block — every row, until you narrow it — and never
touches again; a row it leaves out is not listed and its URL is a 404. A record is found
by --public-key=<column> (unique: a slug), else its ulid, else its id. A column
hinted private (new hint) — and every password, sensitive and encrypted value, and
the timestamps — stays out of Public<Model>Resource, the filters, the sort and the
search (Filtered<Models>::publicSet()); there is no filter[trashed]. ?include
embeds a relation only when the module at its other end is public too, through that
module's own scope and resource, decided when the request runs (App\Support\Api\PublicApi).
Files are served while their record is visible, raster images in place and everything
else — SVG and PDF included — downloaded, cacheable for an hour
(StoredFiles::publicResponse()). Documented in the OpenAPI document with no security
requirement, and tested by a public api block in the module's test. Refused without
--api, with --detail and with --owner. Modules without it are byte-identical.
-
A user's own records through the API: make:crud --api --owner=<column>. An address
book, a wishlist, a device list — rows a user reads and writes from an app — had only the
admin API, where staff see every row behind permissions, so the user-facing endpoints were
written by hand, narrowing and all. --owner=user_id adds a self-service API beside the
admin one, under /api/v1/me (API_SELF_PREFIX, read by the new config/api.php), at the
table's name (/api/v1/me/cart-items), named api.self.<table>.*: the list
holds only the caller's rows (same search, filters, sort, ?include and pagination), another
user's record is a 404, the owner is set from the token on create and is left out of the
request rules, the JSON and ?include, and records are addressed by ulid when the table
has one. Writes go through the module's Actions with If-Match; token scopes and the api
rate limit apply; there is no can:. The routes go in a new group at the crud:api-self
marker of routes/api.php — added to the file if it predates it. The endpoints appear in
the OpenAPI document and the module's test gains a self-service api block. Refused
without --api, with --detail, on a table with file columns, and when the column is not a
foreign key to users. The admin module, and every module without --owner, is
byte-identical to before.
-
Modules for records the application writes: make:crud --except=create,edit,delete and
--read-only. An order placed at checkout or a payment a webhook recorded is read, and at
most worked through, in the admin — never typed in. Every module used to get New, Edit,
Delete and everything behind them. A left-out ability now takes its routes (web and API),
controller methods, requests, Actions, buttons, form modal, permissions and generated tests
with it, and the generated test asserts the routes are not there. --except=create,delete
keeps the edit form (an order's tracking number); --read-only leaves list, detail,
filters and export. Regenerating a full module with --except --force removes the files it
no longer has and the permissions it no longer checks; an Action or request you edited is
kept and named. Combinations that cannot be honoured (--import without create, a board
without edit, transitions without edit, --detail with --except) are refused.
RowActions takes its handlers as optional props; ModulePermissions::names() takes
without:. Full modules are byte-identical to before.
-
The detail page has slots the project owns: make:crud --show-extra. It writes
resources/js/pages/<module>/show-extra.tsx once — ShowActions renders in the record
header beside Edit and Delete, ShowPanels under the record card — and never overwrites it;
from then on every regeneration keeps the page wired to it. Data the slots need beyond the
columns comes from <Model>::showExtra() in the model's crud:custom block. For what a
schema cannot describe: an order's status buttons and refund, a timeline, a summary. Before,
that meant editing show.tsx, which the next --force overwrote.
-
A ulid column is filled on create. A char(26) column named ulid — a public id for an
API — makes the model use HasUlids with uniqueIds(), stays off the form and the table, and
is left out of the factory, which used to fill it with AB-12345. A model whose crud:custom
block already uses HasUlids is left to it.
-
A regeneration takes out the generator's files the module no longer has, in any shape —
the bulk "set status" request of a status that became no-form, the Store action of a module
that lost create. An Action or request you edited, or a file you wrote under one of those
names, is kept and named.
-
A status the application fills (no-form) gets no bulk "Set status". It was a way round
whatever moves it — an order's state machine. no-bulk is no longer needed for that.
-
Wiring a sidebar icon leaves other lucide-react imports alone. A sidebar that also
imports type { LucideIcon } had the new icon written into that line too, and did not parse.
-
A column a CHECK fills for one value of another is required for that value.
(type = 'percent') = (percent_off IS NOT NULL) already shaped the demo data and the
generated tests; the request let the field through empty and the database refused the row
with a 500. A show-if field on that column and value is now required when shown; one
always on the form gets required_if and prohibited_unless.
-
A CHECK added NOT VALID is read like any other. Postgres binds every row written after
such a constraint but prints it with the two words appended, and the generator matched none
of them: an enum, a bound or a required-when CHECK added that way — the usual way on a large
table — was invisible to it. The same fix lets the generator server carry the two-column
CHECKs above (required-when, ends_at >= starts_at, value pairs two columns may not hold
together) to its rebuilt copy of your schema; generating through the server had dropped them,
so its modules differed from a local generate. Needs the client bundled with this release.
-
A json/jsonb column is a document on every surface. The model casts it with the new
App\Casts\JsonDocument (decoded on read; JSON text from the form kept, an array your code
builds encoded), the request validates it with App\Rules\JsonValue (text from the form or an
object/list from an API client, within a length), the API returns it as JSON rather than an
escaped string, the export writes JSON text, and the form edits it indented. Before, the
model held the raw string, so code writing an array needed a cast by hand — and Laravel's
array cast then encoded the form's text a second time, while the export handed the array to
the spreadsheet writer and failed with a 500. Regenerate a module with a json column to take
this up. The table and export cell goes through JsonDocument::text(), so a NOT NULL json
column no longer carries a null check PHPStan calls always false (the conformance fixture now
has one).
-
Model docblocks name the date class the app returns. The kit runs
Date::use(CarbonImmutable::class), so every date cast and now() is a CarbonImmutable;
generated models (and User, OauthIdentity, ImpersonationGrant) documented
Illuminate\Support\Carbon, which is not its parent, and PHPStan refused
$order->paid_at = now() in your own code. Regenerate a module to take this up; a model you
keep can swap the import by hand.
-
ModulePermissionsTest passes in a project with --except/--read-only modules or with
permissions of its own on a module (order.refund). It compared every seeded permission with
the full set and failed on both.
-
Merging labels tells a shared label from a dropped column. A key another module's file
already labels used to be reported as "no column any more", which invited deleting a label
still in use.
-
Money stored as integer cents is shown as money. An integer column named *_cents
(price_cents, total_in_cents), or one hinted mask:cents, is labelled by its amount
("Price"), printed as $28.50 in the table, on the detail page and in related-record
panels, and edited as an amount — the input converts, so the form, the REST API and the
database keep the integer. CSV/Excel exports write 28.50 and imports read it back. Demo
data seeds $1.00 to $500.00 instead of 0 to 1,000 cents. Before, price_cents printed
2800 for $28.00 under the heading "Price Cents". New: App\Support\Money\Cents,
formatCents() in @/lib/format, and mask="cents" on MaskedInput.
-
Status badges are coloured by what the word means. active, paid, delivered are
green; pending, refund_requested amber; shipped, processing blue; cancelled,
failed, expired red; draft, archived grey; refunded violet — in English and
Indonesian. Colours used to follow the order of the values, so enum:draft,active,archived
drew the draft green and the live record grey. Words the list does not know keep their
positional colours. Regenerate a module with --force to take this up.
-
Related-record panels show what the child's own table shows. A no-index column (a
ulid) no longer takes a slot, an image column is a thumbnail instead of its storage path,
a boolean reads Yes/No instead of an empty cell, an enum its label, and the panel holds six
columns instead of five — a variant's stock and active flag were cut before.
-
make:crud --force keeps what you wrote by hand, as the README always said it did.
It used to rewrite the abstract request and every Action: a rule or a line of logic
written into them vanished on the next regeneration, reported as a written file.
- The abstract request now has a
// crud:custom block, carried like the model's. Rules
the schema cannot state go in customRules() — a key there replaces the generated rule
for that field — and rules() lays them over the generated ones.
- Each generated Action carries a
// crud:fingerprint line. --force replaces an Action
only while it still matches it, keeps and names the ones you edited, and replaces those
too only with --overwrite-actions.
- A request from before the block is saved as
.bak when --force would change it.
Regenerate a module once with --force to take this up; an Action that is identical to
what the generator writes now is fingerprinted silently.
-
crud:remove --dry-run (and kit:remove-examples --dry-run) now counts what the run does.
It promised "100 paths, 7 files" for a run that removed 78 and edited 10: it counted the
files inside a folder it was about to delete, and never saw an icon import or a route file
become unused. The preview now plays the run out in memory.
-
A project that has removed the examples generates and tests cleanly. kit:remove-examples
keeps routes/modules/.gitkeep, so a fresh clone still has the folder the next module and
the suite write into.
-
display on an image, file, long-text or protected column is set aside with a warning,
and the record is titled by a text column instead. Before, the index read a property its
row type does not declare and the module did not compile.
-
A regex: hint keeps the pattern it was given. It was pasted between single quotes as
it stood, so a pattern holding a quote (regex:/^[^']+$/) broke the request class. It is
now written as an escaped PHP literal — unchanged byte for byte when it holds no quote and
no doubled backslash. On the generator server, regex:/^[A-Z]{2}$/ — the form the schema
recipes document — was refused both as a column comment and as --hint; it is accepted
now as a ;-segment of its own that compiles, holds no quote, space or backtick and is at
most 200 characters.
-
The API document lists each shared response under its own status code. Every
operation documented Forbidden under 402 and Too Many Requests under 403: the shared
responses were spread into the list, which renumbers integer keys. They keep 403 and 429
now, and each operation's responses are in status order.
-
Regenerating without --owner takes the self-service controller and resource out.
They were taken for somebody's own work and kept, and the command named them.
-
A table with nothing to name a row by is named #id, not by a column the table leaves
out. With no display hint the title fell back to the first short text column — which
could be the ulid public id or a column hinted no-index, neither of which the index row
carries. The delete dialog then read item.ulid and the module failed its own type check
(a bag item: a ulid, two keys and a quantity). The title is now only ever a column the
row has; display on a column kept off the table is set aside with a warning.
-
A combobox onto a soft-deleting table alone no longer fails the module's own check.
A module whose only searchable lookup pointed at a soft-deleting table — users, once it is
large enough for a combobox — got if ($config['soft']) over nothing but true, which
PHPStan level 8 calls always true, and make:crud stopped with "does not compile". When
every lookup soft-deletes the filter is now unconditional; mixed lookups keep their flag.
-
A soft-deleting table's slug no longer collides with a trashed row. The generated slug
picker looks in the trash too, and the slug rule takes the column's own length instead
of 255.
-
Generated tests write values the column's own rules accept. A validate:uppercase|alpha_dash
column (a coupon code) is renamed to RENAMED-VALUE, not Renamed Value, which the form
refused in eight generated tests.
-
On the generator server, make:crud no longer runs your RoleSeeder or the compile check.
Neither means anything in the server's checkout, which does not have your project's classes;
make:crud checks the written module in your project instead (php -l, PHPStan, tsc, eslint)
and exits non-zero naming the errors. --no-verify skips it.
-
A show-if column that is NOT NULL with a default keeps its default. When its condition
was off, the generated Store/Update wrote null into it and the factory did the same, so the
database refused the row. Such a column is now set to its default; a nullable one is still
cleared.
-
Generated tests stay inside the column. The search test's fixtures are cut to a short
column's length, a number guessed from a column's name (tahun, jumlah) stays within its
CHECK, and the conditional-field test never moves the condition to a system: value the
form refuses.
-
A binary column stays out of payloads and the audit trail. A bytea column is read as a
stream, which broke the activity diff and the JSON resource; it is now in the model's
#[Hidden] and redacted from the audit entry.
-
A hidden enum column is documented as the text it is on the model, not as an enum class the
generator never writes.
-
The created column's header follows the reader's language — read at render through a
getter rather than once when the bundle loads.
-
A detail page's relation panels read like the child module. A panel shows an enum column
by its label, not its stored value, and its heading is the child's --label rather than its
table name. A child generated without a create form (--read-only, --except store) is
listed as a plain section instead of a panel whose form does not exist.
-
The generator says what to do before a test goes red. A required key into a model without a
factory is named at generate time, with the two ways out; a detail page that does not compile
because a child module is missing or older says to generate that module first. The cascade
picker is no longer warned about as if it were a combobox.
-
A second module over the same table leaves the first one's admin API alone. The admin API
is named after the table, so a second module over it (make:crud employees --as=worker --api)
edited the first's apiResource('employees', …) line, and removing the second took the line
with it. The path stays the first module's; the second's API is generated but not wired, and
make:crud says so.
-
--map works on a uuid-keyed table. MapPoint['id'] and pointHref take
string | number.