Before you upgrade0

These notes list no steps.

What's changed113

Released 21 packages at 0.0.2-alpha.73 in lockstep. Every package below ships at this version.

Patch Changes

  • A Schema Builder Single now keeps its registry row in a migration when a code-first collection shadows a Builder collection of the same slug.
    More

    nextly migrate:create used to leave out the row of every Builder entity sharing a shadowed slug, of any kind, so the Single's settings change reached the snapshot but not a deployed registry.

    nextly migrate --dry-run --step <n> now also names a pending Schema Builder file with no snapshot that the step leaves out of the preview. A real run refuses such a file before applying anything, whatever --step says.

  • A bulk or batch write is limited to the entries its access rule's filter matches, as a write to one entry is.
    More

    A bulk update or delete by query changes only the entries the filter matches, and counts only those; an entry outside it is neither written nor named. A bulk update or delete by ids writes each entry the filter matches and fails each other one on its own: as a missing entry where the caller may not read it, and as refused where it may. A batch of updates or deletes in one transaction does the same for each item, and an item the caller may not read fails in the same words as one that does not exist. A by-ids bulk update that would move an entry out of the filter refuses that entry alone; inside a batch in one transaction, it refuses the whole batch, with nothing changed. The filter is matched in the default language, as the write to one entry matches it.

  • A collection field with a camelCase name, created or changed through the API or the Direct API, keeps its name, and its column is the snake_case form the write path uses (metaTitle → meta_title), as with code-first collections.
    More

    Before, the name itself was lowercased on save (metaTitle became the field metatitle), so every write to the field as declared failed with "no column named meta_title". - Existing collections keep their fields where they are: an update sending a field that differs from a stored one only in case, or that names the same column, keeps the stored name, so a field stored lowercased keeps its column and values. Renaming such columns to the snake_case form is not done here. - Field names are checked by the column they become: two names that become one column (metaTitle and meta_title), a name whose column is a system column (createdAt), and a column longer than 63 characters are refused. - A camelCase field's min, max and minLength constraints are created on its column. - A collection created through the API or Direct API with camelCase field names is edited through the API: the Schema Builder refuses camelCase names, its own and in its manifest.

  • A dashboard card's common settings change on the card itself, and every card's menu offers the same four things. - The quick popover: a card's title, and Settings in its "…" menu, open a popover holding the card's Collection, the settings its widget marks quick (a period, such as Over time's Date range) and its Size, ending with "More settings", which opens the settings sheet.
    More

    A change applies to the card at once, with the popover still open and the card beside it. Outside customise mode it is saved for that reader alone, and a toast says so and offers Undo, which puts back what the card had just before that change; the toast is the one place a screen reader hears it, and the dashboard's own announcement stays silent for it. In customise mode it is staged with the session's other changes until Save. Escape closes it, and focus goes back to the title or the menu it was opened from. - Every card's menu at rest lists Settings, Size, Refresh and Remove, in that order, each where the card has it. Size saves the card's width and height at once, with Undo, through the same layout write customise mode's Save makes. A reader following the default keeps a size they choose this way: the stored row now records which cards they resized, held to each widget's bounds, while every other card goes on following the size the default gives it. Rows written before this read as they always did, with no migration, and resetting the dashboard clears the sizes with the rest. Remove takes any card off at once, asking nothing, with Undo in the removal notice. For a reader following the default dashboard it is their own dismissal of the card, so they keep following the default; for a reader who has arranged their dashboard it takes the card out of their arrangement, so adding the widget again from the gallery meets no hidden copy, and Undo puts it back where it was, with its settings. The layout read now says which of the two a reader is (arranged). Before, only a card whose widget declared dismissible could be removed outside customise mode, with a dismiss button of its own; that button is gone, and dismissible is deprecated: it has no effect, is still accepted, and will be removed with the legacy definition fields. The customise menu now lists Settings and Size first, then the moves, then Remove. - A widget may mark up to three settings quick, where it could mark one. A declaration marking two or three, which startup refused, now starts; one marking four or more is still refused, with each named. The limit is published as MAX_QUICK_SETTINGS from nextly/config, beside MAX_CHOSEN_FIELDS, and the quick popover holds that many beside the card's Collection. The card's header draws the first marked setting it can draw. - A dashboard write no longer re-asks every card. Each read of the layout carries a read-ahead token of its own, and the cards' batch was asked again under every new one, so the layout read that follows a reader's own write (a quick setting, a size, a removal) asked every card on the dashboard again for one card's change. The batch now takes a fresh layout answer's token only when that answer hides or reveals a card, so a write asks again only the card it changed, and a fresh read that reveals a card still has the batch asked for it once. - Entering customise mode takes a card's Undo toast down, so an Undo pressed after customising began no longer writes underneath the open draft.

  • A dashboard card's quick changes hold up in three cases they did not. - A size a reader chose stays theirs when the default catches up. A reader following the default who resized a card kept that size only while it differed from the default's, so once a later release gave the widget's default that same size, the next unrelated change outside customise mode (a setting, or removing another card) forgot the size was theirs, and a later change to the default moved their card.
    More

    A chosen size now stays chosen while a write leaves it as stored, including for a card the row holds under an id an earlier default gave it; resizing the card, back to the default's size or to any other, is what gives it up or replaces it. - A quick change is always said, with its Undo. When the card's new answer arrived before the save reported landing, the toast that says the change, and offers Undo, never appeared. It now does, as soon as the save lands, judged by the card's own answer, so a card on a dashboard large enough to be asked in several requests is said too. A change whose new answer was refused is still said as saved but not shown. - Removing a card takes its Undo toast down. Removing a card within the ten seconds its last quick change's toast stays left that toast, and its Undo, on screen; pressing Undo could write the removed card's earlier setting or size back. The toast now goes with the card, and an Undo pressed after it does nothing.

  • A dashboard card no longer brings the settings panel's loading screen or the form label check with it.
    More

    Each card only starts fetching its settings panel and asks whether the admin runs in development, so a page that draws cards without opening their settings, such as the development widget preview page, loads less. Nothing looks or works differently.

  • A collection something depends on can no longer be deleted.
    More

    While a field of another collection, a Single or a field group points at it, a foreign key a plugin or the app declares points at its table, or a plugin or the app has added a column, index, foreign key or check to one of its tables, the Schema Builder's delete, the schema API, nextly prune --force and migrate:create refuse before anything is removed, naming each with its owner and table and saying what to do. Where those cannot be read the delete is refused rather than going ahead. A Builder bulk delete is now one request checked as a whole, so collections that point only at one another can be deleted together; deleting each alone is refused. A Builder delete that fails part-way, of one collection or several, now removes nothing on PostgreSQL and SQLite: their field-group values, translations, tables and registry rows go in one transaction, and the drop migration written for it is withdrawn. On MySQL, which keeps each table drop as it runs, every collection not yet deleted stays registered and the message says to delete again to finish.

  • nextly generate:widget <name> scaffolds a working dashboard widget in the site or plugin it runs in: a declaration, a component of its own for --view component, and a test that loads it as the instance's administrator and draws its card.
    More

    Pick how it shows its data with --view figure|list|table|bars|series|component (a figure when left out), and whether it reads from a collection the reader chooses with --collection. It lists the widget in the site's admin.dashboard.widgets or the plugin's contributes.dashboard.widgets when the file has a shape it can edit safely, and otherwise leaves the file as it was and prints the line to add. A project without @nextlyhq/plugin-sdk, which the test imports, or @nextlyhq/adapter-sqlite, which it boots on, gets them added to its devDependencies at the running nextly's version, and is told to install. It honours the root -c, --config path. It never writes over an existing file unless given --force, generating a widget again leaves it listed and imported once, and it refuses to switch a widget between a component of its own and a core view, naming the files to remove first; --dry-run shows everything without writing, and on a terminal it asks for anything left out. A site's widgets are named site/<name>, a plugin's under its own name, with its scope in front when that name is one core keeps (@acme/core → acme-core/<name>). nextly gains a dependency on @babel/parser, which the command reads the config with to find where the widget is listed; only generate:widget loads it, so nothing else pays for it. createTestNextly gains an experimental widgets option, for a site's own widgets, and gives an instance booted without a NEXTLY_SECRET a random one, so runWidgetLoad works without setting it first.

  • The dashboard asks for its collections, its layout and your permissions once per load instead of twice, and each screen you open asks for your permissions afresh.
    More

    A card missing a setting says "No collection chosen yet" beside its "Choose collection" button, or, where no button is shown, to choose it in the card's settings.

  • A collection's delete access rule may answer a filter instead of true.
    More

    A delete through the Direct API or a plugin service then removes an entry only if it matches the filter. An entry outside the filter is left in place and refused: with a 403 where the caller may read it, and as a missing entry (404) where it may not. The entry is matched under the delete's lock, so a concurrent change can't move it out of the filter between the check and the delete. A filter on a translated field is matched in the site's default language, since a delete removes every language.

    Over REST, and for the bulk and batch deletes, a delete rule's filter is still refused, as before.

  • Deleting a collection or a Single now expires its cached pages straight away, so the site stops showing content that is gone.
    More

    A collection or Single that opts out of revalidation is still left alone.

  • Team activity no longer reads as though a whole collection was deleted.
    More

    A row names the entry by its title when it carries one ("Ana deleted Spring launch announcement"), and otherwise says "an entry in" the collection ("Ana deleted an entry in Posts"); a Single without a name is "a Single". A row carries no title when the entry has none, or when the entry no longer exists, so a title the reader may not be told is never shown and never called empty. Settings changes keep naming what they changed, and legacy settings activity rows now arrive with subjectKind: "settings": a row on GET /dashboard/activity or from the system:activity source that was recorded before the kind was, under a settings namespace, said null and now says "settings".

All 113 changes
  • A development server now has a widget preview page.
    More

    While the server runs in development, the admin offers a page (linked from customise mode's bar) that draws every widget the reader may see from its declared preview cases, at its smallest, default and largest sizes, in light and dark, in its ready state and in each frame state (loading, empty, error, not available), with an accessibility check beside each state. A widget with no preview case says so in place of its ready state. No widget's data is loaded. A production server neither serves the page nor its read, GET /api/_dev/widget-previews, which answers there as any path it does not serve. Startup now also refuses a preview case whose settings would not reach the browser as they are, such as a date inside a filter setting.

  • A finished step on the dashboard's setup card has a border you can see: it now draws at full success strength instead of a faint tint that failed the contrast check.
  • A plugin route whose requiredPermission cannot be worked out, because its resolver throws or returns an empty permission, now answers 500 INTERNAL_ERROR, as any server fault does.
    More

    It is not answered 403, since no access the caller held could have been enough, and the request is never let through.

    A REST request whose handler reports a failure as a returned result, rather than throwing it, is answered with that failure's own status and code: a refusal 403 FORBIDDEN, a missing record 404, a busy database 503. A reported failure with no message is answered by its status too.

  • A field group with a many-to-many relationship can now be created on MySQL.
    More

    Its relation column holds a list of ids, and it no longer gets a plain index on any database: MySQL refused the index, so the create failed, and on PostgreSQL the index refused a save once the list held about a hundred ids. A unique field in a field group also no longer gets a plain index beside its unique one.

    The next migration drops an unused index on many-to-many fields in field groups.

  • A field renamed and made required, or given a new default, in one change now keeps that change in the migration nextly migrate:create writes, on every database.
    More

    On MySQL, a column made required or renamed by a migration keeps its comment, character set, collation and the checks that use it; on SQLite, a migration that would rebuild a table holding a collation, an index or a table option (STRICT, WITHOUT ROWID) the schema does not record is refused with a message saying so, rather than dropping it. Making a field required no longer stops migrate:create on MySQL or SQLite with a request to write the migration by hand.

  • A new core table, nextly_cache_tag_expiries, keeps when each cache tag last expired, on the database's clock.
    More

    It's where writes made outside a request (a job, the CLI, another instance) will record the tags they change, so every instance can expire its cached reads. Run nextly migrate to add it. Until it exists, nextly warns once and works as before.

    Rows older than seven days are pruned by a retention pass, in bounded batches, both on writes and on the scheduled webhook drain.

  • A cached read, through cachedFind or Nextly's collection and Single routes, now leaves out any tag longer than the 256 characters Next.js accepts before applying the 128-tag limit, so an over-long tag can no longer push a valid one off the end.
    More

    The caching and REST guides now say when a page shows a write, what happens when an expiry fails, which writes expire pages, and that the login returns accessToken.

  • A check of whether a caller may read a collection now answers yes where the collection's read rule answers with a filter, where it answered no before: ctx.caller.can, GET /me/capabilities, the dashboard and widget scopes, and the entity reader behind versions, translations and content events.
    More

    What those checks let the caller read is limited to the entries the filter matches, and a document lock is read only for a document the filter matches.

  • On the media page, a page picked straight after it loads now stays picked.
    More

    Moving to another page within a moment of the page opening used to send you back to page one, because the search box reset the page while settling a search that had not changed. Media tiles and their checkboxes are also named by the file name the tile shows, not its storage path, so screen readers read the name you uploaded, and voice control or a search by that name finds the tile.

  • A migration's state is now read from its latest outcome alone, and an interrupted run leaves nothing half-recorded. - nextly migrate, migrate:down, migrate:status and migrate:resolve read an app migration as applied or rolled back from the last run, rollback or migrate:resolve that recorded one.
    More

    An attempt that failed or stopped afterwards no longer makes an applied migration read as pending, so it is never applied twice. - A migration file run in a transaction on PostgreSQL or SQLite records its attempt and its outcome inside that transaction. When the process is killed, its connection drops or a statement fails, nothing of the file is left, not even a ledger row, and the next nextly migrate applies it from its start. A failed file of this kind is no longer listed as failed by migrate:status; the command that ran it reported the error. - On MySQL, and for a file marked -- nextly:no-transaction, migrate:down now records that a rollback started before its first statement, as nextly migrate already did for a file. A rollback that stops part-way is shown by migrate:status as one that recorded no outcome, and the migration stays recorded applied. - An attempt cleared by migrate:resolve --failed-cleanup is no longer read as a rollback, so clearing an attempt made after a migration was applied leaves it applied. - A migration file with no snapshot whose statement fails now ends with "Migration <name> failed: <reason>", as a file with a snapshot does, rather than the database's bare message.

  • On MySQL, a migration file marked to run outside a transaction now runs in strict mode like every other migration, so a statement that would cut a stored value short fails instead of silently truncating it.
  • A dashboard widget whose component is missing from the app's component map now draws its own card's error state, and the rest of the admin serves.
    More

    Production no longer reads, checks or writes the map: the admin's server layout does nothing there, and no longer refuses the admin over a missing widget component. In development the map is still written again when it falls behind; where it cannot be (NEXTLY_GENERATED_FILES_WRITE=0, or a folder that is not writable) the server log names each missing component, its owner and the fix instead of refusing.

    The card's error names the widget, its owner and the missing path in development, and says only that the component could not be loaded in production. The grid counts the card as failed.

    New: nextly generate:types --check compares the committed map with the config and writes nothing. It exits 1 naming each missing component and each path no longer declared, and 2 when it cannot load the config. Run it in CI.

    The error code NEXTLY_ADMIN_COMPONENT_MAP_STALE is gone with the refusal it named. The widget definition gains an owner that core publishes for a widget drawn by its own component; registerWidget() and overrideWidget() refuse it, as they refuse serverData.

  • The dashboard header gains a New button beside Customize.
    More

    Its main part creates the type a person created most recently (or the first they may create), and its menu lists the recent types, then every type they may create, grouped as the sidebar groups them, with a search past ten. It is hidden for someone who may create nothing. The command palette offers "Create <type>" for each type too. A type is remembered as recent when an entry of it is created, from anywhere in the admin, not when its form is opened.

    The Create card is removed: core/quick-create is no longer a core widget, and core's default dashboard gives Needs attention its row. Its id is now a retired card, as the per-collection and per-Single cards are: a site whose admin.dashboard.defaultLayout (or hide or overrides) still names it is refused at startup with a message saying creating entries now lives in the dashboard header's New button, so remove it from the config. A saved layout holding it reads without it.

    The header holds its layout from the first paint: the summary line's height, Customize's place and the New button's fixed width are reserved before their data arrives, so nothing in the header moves as the dashboard loads.

  • A password inside a group is kept when an edit doesn't resend it.
    More

    An update that leaves out, or sends empty, a password held in a group or repeater, or in a field group held inline in one, keeps its stored hash; null still clears it and a new value replaces it. Repeater rows keep their own by id, and a translated group keeps the written language's.

  • A plugin can pin a version in its own transaction (experimental).
    More

    ctx.services.versions.pins.registerHolder({ name, label }) registers a version pin holder in the plugin's namespace, so two plugins naming a holder alike hold apart and none reaches one of core's. Its pin, release, releaseAll and list take { tx }: the handle ctx.db.transaction passes its callback, or the transaction ctx.services.collections.withTransaction hands its work. A pin commits or rolls back with the plugin's own writes, under the same document lock and refusals as core's pins. The plugin SDK exports the types, with VersionPinHolderDefinition (what registerHolder takes) and VersionRef. A registered holder now reads its own slots as well: holder.list(db, ref) takes a transaction or the adapter and names the holder in the query, so what other features pin on the same document is never read. Registration returns a RegisteredVersionPinHolder, a VersionPinHolder with list; VersionPinHolder itself is unchanged, so a type written to it keeps compiling.

  • A plugin's write made as a user inside ctx.services.collections.withTransaction reads that user's roles on the transaction.
    More

    They were read on the pool, outside it: a role the transaction had taken away was still on the caller a field rule reads as req.user, so a rule checking req.user.roles could allow a write the transaction's own roles refuse, and on PostgreSQL and MySQL each lookup ran on another connection while the transaction held its own.

  • A plugin that writes to columns it added to a collection, a Single or a component through ctx.db.contributed now expires the cached pages showing that entry or Single, as any other content write does.
    More

    Inside ctx.db.transaction the pages expire once the transaction commits, and a rolled-back write expires nothing. A cached page also keeps its own collection's or Single's tag when a read names more tags than Next.js keeps. On SQLite, a collection or Single deleted inside ctx.db.transaction expires its cached pages once that transaction commits, and not at all when it rolls back; on PostgreSQL and MySQL that delete commits on its own connection, so it expires them straight away and a rollback does not undo it.

  • A populated relationship under the related collection's read rule that answers with a filter now shows the related rows the filter matches, where it withheld every row of that collection before.
    More

    A row the filter does not match is withheld, as a row the caller may not read is.

  • A built-in Public role is added: the role visitors will be judged by.
    More

    It does not change access yet. It can't be deleted, renamed, given to a person or an API key, or joined to another role's inheritance; only its permissions can be set.

    A site whose own role already used the slug public keeps that role under the next free slug (public-1, public-2, …) on the first boot of this version, with its name, holders, permissions and inheritance unchanged, and the change is logged. Code access rules that check the role slug public must check the new slug instead.

    Saving a role in the admin keeps its slug.

    An app or plugin role declared with the slug public is refused at boot, as one declared with super-admin already is.

    At boot, the Public role is given read-media and the read of each collection and Single whose read rule answers true for a visitor. Each read is granted once, so one an owner removes stays removed. Access doesn't change yet.

    Plugins can declare permissions for the Public role on their own collections with contributes.publicGrants (experimental), for example [{ collection: "tickets", action: "create" }]. Only read and create can be granted. Each grant is made once at boot, so one an owner removes stays removed, and a grant on a collection the plugin doesn't contribute is refused and logged. The form builder uses it to let the Public role create form submissions. A plugin's grant lasts only while an enabled plugin declares it: disabling or removing the plugin, or a version that no longer declares it, removes the grant, and the removal is logged. Declaring it again grants it again, except one an owner had already removed.

    Each startup log names what the Public role does not hold yet that visitors may rely on: reads with no read rule, reads whose rule answers neither true nor false, writes whose rule answers true for anyone, and rules that failed or gave no answer when asked. Grant the Public role each one visitors should keep.

  • A publish of every language at once is limited to the entries its publish rule's filter matches: through the Direct API (nextly.update by id with locale: "*") or REST (publish-all, or a status-only write with ?locale=*).
    More

    The rule is asked in each language the publish puts live, and the entry is matched against that language's filter, in that language. unpublish-all is limited the same way, its filter matched in the default language. An entry outside a filter is refused and left as it was: with a 403 where the caller may read it, and as a missing entry (404) where it may not. The entry is matched before the write, under its row lock and once the write is in.

  • A read by id under a collection read rule that answers with a filter, through the Direct API, a plugin service or REST, now reads an entry the filter matches and answers one it does not match exactly as an entry that does not exist, where it refused such a caller before.
    More

    Such a read returns the entry the filter matched, without its pending working draft. A read rule's filter can't name a field inside a component yet: a rule whose filter does is refused, and the refusal is logged once.

    A read rule's filter that names a localized field must hold in each language the read may fall back to, so a read never shows a fallback value the rule refuses. A filter on a localized date, a read rule's or a caller's own where, now compares the date as the instant it names on every database.

  • A collection's read rule is now typed to answer a filter, typed by the collection's own fields: defineCollection checks each key and operator the rule's filter names, and the value each is compared with, so a misspelt field or operator fails to compile.
    More

    The keys are the top-level fields declared with a field factory or inline, and the system fields; a path into a group is not typed yet. The new types (CollectionRuleFilter, CollectionFilterRule, CollectionRuleAnswer, UntypedRuleFilter, CollectionFilterRuleInput) are experimental.

    Existing code compiles unchanged, with one exception. CollectionAccessControl['read'] now includes a filter-returning rule; code that used it as the type of any rule should use AccessControlFunction | boolean. The field factories that a filter can name (text, textarea, email, code, number, checkbox, date, select, radio, upload, relationship) keep the name as written, and still return their field's config type; a name built at runtime is a string, as before, and leaves the filter untyped. CollectionConfigInput takes two type parameters with defaults that keep its meaning. Code that calls a stored read rule and reads its answer as a boolean should handle the filter case, or treat any answer other than true as a refusal.

  • A collection's read rule may now answer with a filter (a where) instead of true, as an experimental step: a list, its total, a count, and the group and timeseries reads made through the Direct API or a plugin service then read only the entries the filter matches, as does a page the website resolves by its slug.
    More

    Every other read, including a read by id, every REST route and relationship population, still refuses a caller whose rule answers with a filter, as before, and the rule's type is unchanged. A read rule's filter can't use near or within yet, nor the reserved _translated, _pendingChange and _inRelease keys: a rule whose filter does is refused, and the refusal is logged once.

  • A user who may publish a document but not change it now waits for a colleague who is editing it: while someone else holds the document, Publish, Publish changes, Unpublish and Publish all are held, and the read-only page names who is editing.
    More

    The reader never claims the document; they read who holds it on the same beat an editor's claim is renewed, and their writes are held until that first read answers.

  • Fixed: in an app without nextly's cache handlers, a write made outside a request (a job, a script) or one whose cache expiry failed inside a request is expired in Next.js's own cache again at the next request, as before the cache tag expiry ledger was connected at startup.
    More

    The ledger records it for nextly's handlers, and Next.js's own cache never reads that record, so a read cached without a revalidate time could otherwise keep the previous version.

    Other instances now treat a recorded cache tag expiry as standing for one second past the write, the time an instance may keep a collection's settings cached. An entry another instance fills from settings cached before a schema change is therefore not served once the change is recorded. The instance that made the write isn't held to that second, since it cleared its own cached settings at once, and a tag that expires again never has its recorded time moved back.

    A write made while nextly is restarting, after one registration released the ledger and before the next one connects it, is now kept and recorded by the next ledger, instead of reaching only the instance that made it.

  • The Visual Schema Builder's create dialogs for a collection, a Single and a field group now show why an address is refused (for example, that a Single address cannot end in _locales, or that it names a Nextly system resource) instead of a bare "Validation failed.".
  • When the database refuses the record that tells other instances a cache tag expired, nextly now retries it by itself until it succeeds: after 1 second, then waiting twice as long each time up to 30 seconds, and at the process's next cached read, where a timer may not run.
    More

    Other instances see the write within about a minute of the database answering again, instead of only after the process's next write. It logs once when the retries start and once when they succeed, and the timer stops when nextly's services are released.

  • A Single publish refused because someone else published newer shared values now reads the caller's grants inside its own transaction when the request was routed and trusted.
    More

    They were read on another database connection while the transaction held one, so a visitor's Public role read ran outside it and, on a small connection pool, could wait for a connection that never came free.

  • A REST request that only changes an entry's status and is refused now says which action it was refused (publish or unpublish), not edit.
  • Populating a relationship under a read rule that answers a filter reads the related rows' columns with Drizzle's current column helper, so it runs unchanged on Drizzle v1.
  • A release that is not ready to go out now says so inside a border drawn at the destructive colour's full strength, which meets the 3:1 contrast a border needs, where the faded border before it did not.
  • The Schema Builder's save preview no longer reports removing a field that holds values as safe. - A removed field's values are counted where they are stored: a translated field's in its translations table, every other field's on the main table, by its stored column name.
    More

    Before, a translated field was counted on the main table, and a field whose name differs from its column (metaTitle, stored as meta_title) was queried by the wrong name. Both counts failed and read as 0. - A count that cannot be read is no longer taken as 0. The removal is classed destructive, carries rowCountUnknown: true (a new optional field on the preview's removed rows), and a warning says the count could not be read. A field group or many-to-many relationship, whose values live in their own table, is reported the same way. - Switching a relationship between one related entry and many is classed destructive, in both directions, with a warning that its values are stored differently and may be lost.

  • A collection or Single removed from your configuration is no longer brought back by next dev, a configuration reload, next build or nextly db:sync.
    More

    Once a migration has dropped its tables, no start creates them again, and while they are kept no start changes them or its registry row. A Schema Builder collection or Single still gets a missing table created in development, as before.

  • Where the server cannot read the app's migrations folder (a standalone or serverless bundle may leave it out), the admin no longer tells the operator to write a drop migration for a collection or Single removed from code; opening a version of such a document no longer sends a "seen" mark that the server would refuse; and reading a removed entity's state on a request no longer loads the CLI's migrate command.
  • A collection on either side of a many-to-many relationship is no longer renamed.
    More

    Its links live in a junction table spelled from both collections' slugs, which a rename keeps, so after a rename the relationship read every link as empty. The rename is now refused with a conflict naming the fields, and the links stay readable. A collection or Single rename also holds the schema lock now, as every other schema change does, so one started while a migration or another schema change is running is refused at once, with nothing changed.

  • A REST list or count of a collection's entries now reads only the entries a collection's read rule's filter matches, where it refused such a caller before.
    More

    The rule is asked once in the request, for the route and the read alike. Every other REST route still refuses a caller whose read rule answers with a filter.

  • A REST write is limited to the entries its access rule's filter matches, as a write through the Direct API is: an update, a delete, a publish or unpublish sent as a status change, and the writes an editor makes through an entry's versions (a restore, a discard of the held edit, taking the live shared values, an autosave).
    More

    The route lets a caller through on the filter its rule answers and keeps it for the request; the write matches the entry against that filter, in the language the write names, or the default where it names none. An entry outside it is refused and left as it was: with a 403 where the caller may read it, and as a missing entry (404) where it may not. A check that cannot apply the filter refuses rather than allowing every entry.

    A restore that the update refuses is now answered as the update was: a 403 where the caller may read the entry, rather than a 404 for every refusal.

  • A Schema Builder change that MySQL refused part-way is finished by saving it again: - A relationship whose options name its target collection (options.target), the relationships the schema pipeline gives a foreign key, gets that key when the change adds it, even when the earlier attempt already added its column.
    More

    A relationship the collection already records is planned no new key, and one the change renames, in this attempt or in the one that failed, keeps what its old column had: no key where it had none. - A field made translated over a column the translations table already has takes that column as its own only when it holds every value the field allows: the same type, a length or precision at least as large, and empty values allowed. Otherwise the change is refused before anything changes, naming the column, both definitions and how to go on, since the column may hold the field's values from the change that did not finish. - A field the change made translated whose values the earlier attempt already moved is finished by the retry. A retry that also narrows its length or precision is refused, saying how to finish the earlier change first.

    The same check applies where a config sync (nextly db:sync, its --watch loop, nextly migrate and a config reload under next dev) takes a translations column already there as a field's own, for the fields that run newly translates, judged against the fields recorded before the run.

    A config sync now widens a translated field's column when the config raises its length or precision, keeping the column's other properties; a column already wide enough is left as it is. A column that cannot hold the field and cannot be widened to it, such as one of another type, is never converted: the run that changes the field is refused, and later runs report it as a warning.

    The Schema Builder now shows why a schema change was refused, naming each field and its reason, instead of only "Validation failed.".

  • With nextly's cache handlers installed, a database that takes connections but never answers can no longer hold cached public reads.
    More

    Every call to the cache tag expiry ledger, a lookup or a record, is now given up on after 5 seconds, and a cached read waits at most a second on a retry of a refused record, which goes on in the background. Before, both waited for as long as the database did. A call given up on is not cancelled and keeps its connection, so while one is still running no other of its kind is started: a database that does not answer holds one waiting record and one waiting lookup per process, not one more at every write, retry and lookup. A lookup that is given up on counts its tags as expired at that moment: entries cached before it are read afresh, and those cached after it are served, until the next lookup says what the ledger holds.

    A retried cache tag expiry record now writes only to the ledger: it no longer expires the tag in the instance again, so a page regenerated since the write stays cached while the retries fail. When a retry succeeds, it is judged by the database time it read, as a write's own record is, since another instance may have recorded the same tag in that millisecond; a page regenerated during the outage is rebuilt once then. A record that answers after it was given up on is not made again by the retry, but only for the write it was made for: an earlier record landing late does not stand in for a later one the ledger refused. A refusal kept while a retry is under way waits the first retry delay again once that retry succeeds, and the tags a cache expiry hand-off gave back after its timeout are retried too, rather than waiting for the next write. Each record the ledger refuses is now logged with its tags (cache-tag-record-failed), a refusal during a retry included, so the content another instance may still serve stale can be named; the retries themselves are said only when they begin and when they succeed.

  • A role or permission change now takes effect at once everywhere in the server process that made it.
    More

    A production Next.js build loads Nextly's modules more than once in one process, and each copy kept its own record of the role version, so a check asked through a service another copy had registered could serve the grant it had cached for up to a second after the change: a release's readiness then read Ready for a document whose author had just lost the right to publish it, and the early stop of a scheduled release on that change could miss it. Every copy now shares the one role version.

  • A code access rule that answers with a filter that isn't well formed (an unknown operator, an empty in, an and that isn't a list, and the other shapes a where refuses), or a filter from a create rule or a Single's rule, which may only answer true or false, is now reported in the log once, naming the rule's collection and operation.
    More

    In development it is also raised as an error. The caller is refused either way, as before. A rule that answers a well-formed filter is refused as before too, and its log notice now says the check does not apply a rule's filter, rather than telling the rule to answer true or false.

  • A setting's own editor (@experimental) gets two fixes. - SettingEditorProps<Value>["onChange"] takes Value | undefined, so an editor can clear an optional setting: onChange(undefined) saves the setting unset, and the card reads its default, or no value where it has none.
    More

    This is a widening of the parameter: an editor that calls onChange with a value keeps compiling unchanged. Only code that builds SettingEditorProps itself, with an onChange that accepts Value alone, needs its callback to accept undefined too. - An editor for a Field setting is held to the fields the chosen collection offers the reader in the settings sheet. A field the collection does not offer is named under the editor on Done ("names a field that is not available", the words the layout write refuses it with) and nothing is saved, rather than failing the whole sheet's save. The check is the layout write's own field-fit rule (unfitContentField).

  • A change to settings alone now reaches production.
    More

    When only a collection's, Single's or field group's settings change (labels, description, icon, sidebar group and other admin options, versioning, Draft/Published, the localisation flag, or a field's help text, placeholder or hidden flag), in code or in the Schema Builder, nextly migrate:create writes a migration with no table statements that names each entity and what changed (-- Settings: posts: description), with its snapshot. A migration that changes columns also names every settings change since the previous snapshot, a cleared setting counts as a change, and a Builder entity's registry row travels with its settings change. Site content settings (general settings, the email setup) never appear in a migration.

    Every snapshot migrate:create writes now records every entity's settings. Snapshots written before this release carry none and are read as saying nothing about them, so the first migrate:create after upgrading writes one settings-only migration that records every entity's settings (-- Settings: posts: settings recorded).

    nextly migrate now refuses a pending migration file the Schema Builder wrote with no snapshot beside it (a <timestamp>_create_<slug>.sql, _update_, _drop_, _i18n_ or _status_ file), where it used to apply it as written. It stops before changing anything, names the file, and says to replace it with the migration nextly migrate:create writes for that change. nextly migrate:check names the same file and remedy.

  • A site's own dashboard widgets, declared in admin.dashboard.widgets, are now registered and offered like a plugin's, and defaultLayout may place them; startup no longer warns that they are checked but not applied.
    More

    Their components are listed in the generated component map, by next dev, nextly generate:types and its --check, under the site config's name. A site names a component relative to its config file ("./dashboard/notes#NotesCard"), which the map imports from its own folder, or by a package name; a path alias is refused at startup with the relative spelling to write instead. Widgets a plugin's setup() adds to the site's dashboard are listed too, as the running server registers them. In development a map whose config has moved is written again, so a component named relative to the config resolves from its new folder.

  • With nextly's cache handlers, a slow lookup of the tag expiry ledger can no longer make an instance serve an entry filled before another instance's write.
    More

    Each instance learns the database's clock from its lookups, and it took the statement to have run halfway through the round trip. Under load, a lookup that waited for a connection could then put an entry seconds later than it began, past the write's recorded expiry, and that entry was served for its whole lifetime. The statement is now taken to have run as late as its answer arrived, so an entry looks no later than it began, and each lookup's bound replaces the last, so a database clock that stepped back, as after a failover, is followed at once. A slow lookup can still cost a rebuild, but never a stale read. An earlier copy of nextly's cache module still loaded after a hot reload keeps its own offset, which this one does not read.

  • A SQLite migration that rebuilds a table to change a column's nullability or default is now refused when a column carries an ON CONFLICT policy the schema does not record, rather than rebuilding the table without it.
  • With nextly's cache handlers, a database that stops answering now holds at most four cache tag ledger calls of each kind per process, a record or a lookup, from the moment they start.
    More

    Before, every write and lookup in the first five seconds of an outage started a call of its own before any was given up on. Further calls wait for a slot within the same five seconds, and are turned away rather than started if a call of their kind is given up on meanwhile. A call of a withdrawn ledger that never answers no longer holds back the ledger installed after it, and a call still waiting for a withdrawn ledger's slot is turned away when the next is installed, never started against the withdrawn one. A retry turned away while an earlier record is stuck no longer stops that record, landing late, from counting as the expiry it was, so the retry doesn't record it a second time. After a hot reload, an expiry an earlier copy of nextly's cache module looked up is asked about again before it is judged by, so this copy never judges it by a clock offset it learned before a database failover. If that lookup fails, it is not asked again before the lookup lifetime passes, and meanwhile the expiry counts as no earlier than the failure, so entries begun before then are still refused.

  • After a restart, a delete inside a plugin's own transaction, opened by ctx.services.collections.withTransaction or by ctx.db.transaction, is now judged by a delete rule's filter on a translated field.
    More

    Before, such a delete was refused, even for an entry the filter matched, until some earlier write or read had looked at the collection's translation table, because a write inside a transaction cannot look that table up itself.

    At boot, Nextly now looks up each translated collection's, Single's and field group's translation table once, in the background. Startup doesn't wait for it; it costs one database look-up per translated entity. Until it finishes, such a delete is refused as before. A look-up that fails is logged and skipped.

  • A restore of a version and a take of the live values into a held edit are judged by the update rule in the language they write, as an update in that language is.
    More

    A rule that refuses one language, such as update: ({ locale }) => locale !== "de", now refuses a restore of a German version and a take of the live values into a German held edit; before, both went through, because the route judged them in every language and the write did not ask the rule again. A rule that allows only one language, such as locale === "de", now allows a restore of a German version and a take of the live values into a German held edit, which it refused before. A rule whose filter is answered by language is matched in the written language: a restore or take that matches the German filter succeeds, and one that does not is refused. This holds for a collection entry and a Single.

  • A checked call with no signed-in user and no plugin person, which the Public role doesn't cover, is answered 401 AUTH_REQUIRED ("Authentication required.") by the Direct API and plugin services, as REST answers it, instead of 403: signing in could grant what it asked for.
    More

    A rule that refuses a visitor the Public role does cover is still answered 403. A website page still answers such a refusal with its not-found page.

  • renderWidgetCard from @nextlyhq/plugin-sdk/testing/admin now loads in a jsdom test.
    More

    It reached nextly/testing, whose test instance refuses to load where window is defined, so a card test under jsdom failed on import. The card helpers it uses are published on their own as nextly/testing/widget-card, which loads in a browser environment; nextly/testing still exports them.

  • defineWidget takes its fields by the names a widget is read by, and startup names every fault of every owner in one message.
    More

    Breaking for defineWidget (@experimental). The fields are renamed, with no old spelling kept:

    • data is now load.
    • display is now view, which is one of core's views ("figure", "list", "table", "bars", "series") or { component: "<module>#<Export>" }. Today's display names are not view names: "metric" is now "figure", and "timeseries" is now "series".

    • empty.when is now the top-level isEmpty, and a view with its own component must give it. empty holds the message and the action.

    • example is now preview, a list of named cases, each checked against the widget's data and settings types. A case is written { name, data, settings? }.

    • permission is now access.
    • sketch is removed: the add panel draws the view's own sketch.

    A declaration still using an old name is refused at startup, and the message names the field that replaced it.

    New, all @experimental:

    • An icon field.
    • category is optional, and defaults to "Other".
    • The CoreView, WidgetView, WidgetAccess, WidgetPreviewCase and WidgetSummary types, exported from nextly and @nextlyhq/plugin-sdk.

    Typed now, judged in a later release:

    • access as the collections a widget reads, or as a predicate of the person;
    • shows;
    • summary, a label and a count for the dashboard's header.

    Until that release, a declaration using any of these is refused at startup rather than started with the rule ignored.

    Startup:

    • Core's own widgets, every plugin's and the site's go through one registration, so a fault in core's list and a plugin's fault arrive in the same message, and nothing is kept until every check passes.

    • A long title or description no longer stops startup.
    • Core's widget list is one module per widget under core-widgets/.

    Core's Note card is declared with defineWidget, as a plugin's widget is. It reads the same to its reader, with one exception: an unwritten note's empty state now reads "Nothing written yet. Write it in the card's settings.", drawn by the card's frame like every other empty card.

  • A dashboard widget declared with defineWidget now reads its data only through its load function, run on the server for the person asking.
    More

    Its read services read as that person, so two people see what their own access allows. Breaking: the load: { query } form is removed, along with the ContentQuery type the package root exported. A widget still using it is refused at startup with a message saying load must be a function. Move the query into a function that reads with the count and find services it is handed: load: async ({ settings, services }) => ({ total: await services.count(settings.collection) }).

    Each card is now decided in order before its data is read. A person who fails the widget's access gets the card's "not available" state, and access may now be a permission name, { collections } (every collection must be readable by the person, renamed collections included) or a function of the person; a function that throws counts as no access and is logged. A card missing a setting its widget needs draws "Choose <setting> in the card's settings" as its empty state. A widget's shows function is now judged per card: when it answers false, the card is left off that person's dashboard and out of the update count, and customise mode shows it marked "Not shown for you right now". A data function that throws, runs past its time budget or answers a value JSON cannot carry fails its own card only, and the cards beside it are still drawn. The log names the plugin, the widget and the reason; the plugin's own error message and stack are logged only in development, since they can hold data.

  • A collection's update, delete, publish and unpublish rules may return a filter in their declared type, as its read rule may: defineCollection types the filter by the collection's own fields, so a misspelt field or operator, or a value of the wrong kind, fails to compile.
    More

    CollectionAccessControl's update, delete, publish and unpublish now accept a rule that answers a filter. Code that stores one of those rules as a general rule should type it AccessControlFunction | boolean, which every operation still accepts.

  • A collection's update, publish and unpublish access rules may answer a filter instead of true.
    More

    A write through the Direct API or a plugin service, by a signed-in user or an API key, then changes an entry only if it matches the filter. An entry outside the filter is left as it was and refused: with a 403 where the caller may read it, and as a missing entry (404) where it may not. The entry is matched under the write's lock, and a write inside the caller's own transaction is matched in that transaction.

    A write that changes an entry's data must leave it matching every filter that judged it. An update that would move the entry out of its filter is refused with a 403 and changes nothing, and so is a publish that would promote a held edit doing the same. A filter on a translated field is matched in the language being written, and an unpublish of every language at once is matched in the default language. An edit held as a pending change on a published entry is refused when it changes a field the update filter names, and is otherwise held and shown to a caller whose update filter matches the entry.

    Over REST, for the bulk and batch writes, for a release's members, and for a publish of every language at once, an update, publish or unpublish rule's filter is still refused, as before.

  • A content write that couldn't expire its cached pages no longer fails silently.
    More

    The expiry is retried, then handed off to finish outside the request. The response carries a notice that the change is saved and its public pages may show the previous version for a while. Server Actions now let the writer read their own write at once. A release's pages follow each collection's and Single's revalidate settings, so an opted-out collection is left alone and extra tags are expired too.

  • A plugin's or the API's yes-or-no question of whether a caller may update, delete, publish or unpublish a collection now answers no when that action's rule answers a filter: ctx.caller.can(...) in a plugin route and nextly.access.check(...).
    More

    Such an answer names no entry and applies no filter. A read under a filter still answers yes. The hints are unchanged, a filter counting as the permission held: the admin's capability cells, a dashboard widget's and an attention item's offer, and giving up a document lock.

  • nextly.access.check answers with the access decision every route asks.
    More

    Two answers change. On media, settings and the Email hub, a manage- permission now counts as the plain read, create, update and delete it stands for, as every route already counts it, so a role holding only manage-settings may update settings by access.check too. And for a read, true now means the user may read some entries: where a collection's read rule answers a filter, the user may read only the entries the filter matches, so read with the user's context (overrideAccess: false) rather than as a trusted call, which returns every entry. A write whose rule answers a filter is still refused, and a check that cannot read the user's roles or grants refuses rather than throws.

  • An access rule on a site whose languages are stored, rather than declared in its configuration, is now told every language the site has.
    More

    Before, such a rule was told none. A site that declares its languages in its configuration is unchanged.

  • The access-control service no longer has a checkAccess method.
    More

    Nothing in Nextly called it any more: every check asks the access decision, and code that asked whether a user may act should ask nextly.access.check({ userId, operation, resource }), which answers as the route gate does.

  • Adding a widget to the dashboard now happens in a gallery that shows each widget once, drawn small by its own view, instead of a list grouped by collection.
    More

    Open Add widget in customise mode to search widgets or collections, filter by All, Content, Activity, Trends or Plugins, and pick from up to four suggested pairs, such as "Recent Posts" or "Pages over time". Suggestions follow the collections you saved most in the last 30 days, or the ones with the most entries if you have saved none. A widget that reads a collection opens a short add step in the same panel: choose the collection (it starts on the one you edit most), the period where the widget has one and the width, and see the card previewed before Add to dashboard. A widget that reads no collection is added straight away. Searching a collection's name lists each widget that can read it as a pair, such as "Count · Posts", which adds with that collection chosen. Cards you removed this session are listed first and come back with their settings.

    What the gallery offers is decided on the server, as the person asking, by the new GET /api/dashboard/gallery. It leaves out any widget whose own access or shows refuses them, and any collection they may not read or that is kept off the dashboard.

    Core's Count, Over time, Breakdown and Note widgets now declare a preview case of sample data, which their gallery tiles are drawn from.

  • The admin accepts the plain settings and email permissions.
    More

    Settings pages are shown on read-settings and used on the permission their action names: creating an image size or a user field asks create-settings, editing one update-settings, and the plugins area any settings change. A role that may only read settings sees General, Image Sizes and User Fields read-only: it may open a user field to see it, and is offered no save, add, edit, delete or reorder it would be refused. A plugin's "Open settings" link is shown only to a caller its settings page lets in. A role still holding manage-settings, manage-email-providers, manage-email-templates or manage-media keeps every page it had, since the admin counts each as the plain read, create, update and delete it stands for, as the server does. A plugin that names no settings permission of its own now asks update-settings (before, manage-settings, which still counts as it).

  • The admin asks each request it sends as the server judges that request: the localized list, the editor and quick-edit ask for every language's translation state only where the server lets the user read them all, the list and quick-edit in the default language their reads are sent in, and otherwise show no Languages column or language filter; the version history and its compare pages are offered only to a user who may read the whole history, in every language, and are not offered at all otherwise; Publish all languages warns that languages whose state could not be read may go live too; Publish all languages, a create (sent with no language, so in the default one) and the quick-edit modal's save each follow their own answer from GET /me/capabilities.
    More

    The permission list is asked again when the role assignment it was read under ends. /me/permissions answers an API key with the key's own permissions.

  • ---
    More

    The admin's bundle size is now checked on every CI run, so a change that makes it noticeably bigger fails with the size it measured and the budget it broke. The total the package ships stays within 3,500 KB minified; the code every admin page shares stays within 280 KB gzipped; and each page is held to its own measured size plus 10%. A new page has to be measured and pinned when it is added (pnpm --filter @nextlyhq/admin check:budgets --pin). Lazily loaded pages now ship in chunks named after their place in the admin, so each can be told apart from build to build.

  • The admin rail has one Content item in place of Collections and Singles.
    More

    Its panel switches between the two with a segmented control, and one search finds either kind and marks the other part when it has matches.

  • An app scaffolded with create-nextly-app, or one it adds Nextly to, renders its admin for each request, never from a cache another user's request filled.
    More

    Its admin layout renders its shell statically and awaits connection() beneath a Suspense boundary, so with Cache Components on the build still prerenders the shell, and nothing the admin reads is shared between users. Adding Nextly to an existing app writes the base template's own admin layout, so it renders the same way as a new project. The plugin template's development app gets the same admin layout.

  • The admin no longer shows an empty page while the server is starting.
    More

    A signed-in screen says it is loading at once, says the server is starting after a few seconds, and offers Try again after about 45 seconds; if the server cannot be reached, it says so with Try again instead of sending you to the login page. The login and setup pages draw at once and check the session in the background.

  • Admin pages open faster after a hover.
    More

    Pointing at a link, focusing it with the keyboard or touching it now starts loading that page's code, so the click usually finds it ready. Downloads and links to other sites are left alone. While a page's code is still loading, the spinner appears only after 200 ms, so a fast load no longer flashes it. Screen readers still hear "Loading" straight away. If a page's code fails to load, the error is written to the browser console and a later visit tries again.

  • The admin's rich-text editor and a release's page load less code: the editor about 80 KB less, minified, and a release's page no longer loads the document history screen's rows to name who did what.
    More

    Both work and look as before.

  • Admin pages load on demand: opening any screen fetches the shared shell and that screen's chunk instead of every page's, with a loading state while the chunk arrives and a retry when its fetch fails.
    More

    The first screen no longer downloads the other 58 pages; the finer split adds per-chunk overhead, so the shipped total is slightly larger.

  • Every admin screen now names its browser tab, as in "Posts · Golden Shop": the screen, then your site's name, with the item's name first on a screen that shows one, so several admin tabs and their history entries can be told apart.
  • On a wide screen, the admin's main column no longer slides sideways when the second sidebar panel opens or closes.
    More

    Moving between the dashboard and a collection list, the media library, a plugin or settings used to move the whole column 256 px as the panel beside it opened and closed. The panel's column is now held on every screen of the wide layout, empty where the screen has no panel, so the column the reader was reading stays where it was. Screens without a panel, the dashboard among them, are 256 px narrower as a result, and the dashboard's cards wrap to that width; nothing saved changes. An editor that takes the full width still releases the panel's column, and on a phone the panel still opens over the page in the navigation drawer.

  • On a fresh load, the admin's sidebar and header no longer move while they fill in.
    More

    The sidebar's icons used to be pushed down as the sections the reader's permissions and content decide arrived, and the header's controls slid sideways when the notification bell joined them. The sidebar now draws its icons only as far as is already decided, so each one that arrives later lands below the ones drawn, and the header draws the account menu at once and the controls beside it together once what decides them is known.

  • When the server refuses an action, the admin now shows the server's own message as it is, such as "You can't delete this post.", rather than putting "Failed to delete entry:" in front of it.
    More

    A refused entry list says so in place of the empty state, and a collection read that the server answers with 404 is no longer read again as a Single unless the slug is one.

  • The admin has a "Skip to content" link, the first thing Tab reaches on every page.
    More

    It moves focus past the rail, the sidebar and the header into the page's main region, so a keyboard user no longer tabs through every collection and Single on each page. It stays hidden until it has focus.

  • The admin's stylesheet is now generated from the admin's own code, the shared UI components and the first-party plugin screens, and nothing else in the package.
    More

    Before, the build scanned every file in the package, prose included: a note or changelog quoting a class with an unfinished value such as [var(...)] produced invalid CSS that took down every admin page, and classes quoted in the changelog were shipped in the stylesheet. The stylesheet loses only those quoted classes; nothing the admin draws changes.

  • A widget's empty state can now offer the card's own settings as its action: empty: { action: { label: "Choose a collection", opens: "settings" } } beside the existing { label, link, permission? }.
    More

    The card draws it as a button that opens that card's settings sheet with focus on its first field. The button appears only at rest, and only where the reader can change that card's settings, so a settings preview, customise mode, or a card whose settings can't be saved right now shows the message alone. Startup refuses an action that gives both opens and a link or permission, any opens value other than "settings", and opens: "settings" on a widget that declares no settings. Core's Note uses it: an unwritten Note now reads "Nothing written yet." with a "Write a note" button.

  • An unpublished or unknown blocks page answers 404 again when Cache Components is off, which is every app's default.
    More

    The page factories in @nextlyhq/blocks-react/next wrapped their read in a Suspense boundary, so the page's shell streamed before notFound() ran and the request answered 200 with the not-found page. They now add the boundary only under Cache Components, where a static shell needs it, and read before the page returns otherwise.

    nextly/runtime now exports cacheComponentsEnabled(value), which says whether a value means Cache Components is on: the config's true, or the "true" Next.js inlines into an app's bundle as process.env.__NEXT_CACHE_COMPONENTS.

  • An upload keeps the alt text it is given.
    More

    nextly.media.upload({ file, altText }) stored every file without its alt text, so anything that needs one on a new image had nothing to read. The blog template's demo seed, for one, failed most of its posts, because a post refuses a featured image with no alt text. Alt text set on a file afterwards was never affected.

  • Breaking: image sizes are no longer made or offered. An uploaded image is now stored as the original and one thumbnail, nothing more.
    More

    The thumbnail is the whole image fitted inside 480×480, keeping its proportions and never enlarged, instead of a 300×300 centre crop. Moving an item's focus point saves the point and stores no new file.

    What an app loses, and what to use instead:

    • The sizes defined at Settings › Image sizes are no longer cut at upload or when the focus point moves. The screen, its menu entry and the /admin/api/image-sizes routes (list, get, create, update, delete, regeneration-status, regenerate) are removed; a request to one is answered as an unknown route (404).
    • Media items no longer carry sizes in any API: REST, the Direct API (MediaFile), server actions, populated relationships and Singles, and media.* webhook payloads. The Media type @nextlyhq/admin exports loses sizes.
    • Removed from nextly: getMediaVariant, getSmallestMediaVariant, GetMediaVariantOptions and MediaLike. Removed from nextly/storage: generateImageSizes, deleteImageSizes, ImageSizeConfig, GenerateImageSizesOptions, UploadFn, and ImageProcessor.resizeWithFocalPoint. Removed from nextly/schemas (and the root): the imageSizes table.
    • Instead: give an item's url to next/image, which resizes it on request (a custom loader can send that to an image CDN); use thumbnailUrl for a small preview; and use focalX and focalY with object-position to keep the subject in frame.

    Nothing stored is removed by this release. Items uploaded before it keep their sizes, their size files and their square thumbnail, and the image_sizes table and its rows stay; none of it is read. Deleting such an item still removes its size files.

  • system:attention answers a new list query, the attention digest: each reader's open work, read as that reader at read time, one item per thing waiting.
    More

    The grouped answer the current Needs attention card reads is unchanged. - Each item carries id, kind (stopped, overdue or plugin), label, count, atLeast when the count is a floor, severity, an admin-relative link, and failed when it could not be counted (@experimental). - Core's kinds are releases that stopped and overdue releases, both critical, each the releases domain's own count, linked to Releases filtered to its reason, and shown only to a reader of releases. - Plugins' attention items (contributes.dashboard.attention) now reach the digest as warnings. An item with permission shows only to a holder of it, and one with collections only to a reader of one of them. Who may see an item is asked within its own budget, and a check that fails or runs out of time hides the item. Its count reads only those collections, as the reader, and one the reader cannot read answers empty. - Every item is counted at once, each within its own 10-second budget. One that throws, runs out of time or answers something that is not a count fails alone and is logged with its plugin and id. Counts above 99 read as 99 and a floor. A reader whose access to releases cannot be read is shown neither release kind. - Startup refuses, in the one dashboard fault message, an attention item that breaks its shape, repeats another's id, uses the reserved core, collection or single namespace, names a permission other than in its stored action-resource form, or is one of more than 10 from a plugin. An item naming a collection the site does not have is warned about and shows to nobody.

  • A cached dashboard is refetched when any widget's Collection setting changes, including one its widget's query does not read: the settings sheet and the workspace still show such a setting, so a change to it no longer leaves the earlier payload in place.
  • Going Back or Forward from a document with unsaved changes asks before leaving again on an app rendered with Cache Components.
    More

    There the admin's code arrives after Next's router has started listening for Back, so the router moved to the page Back was going to before the admin was asked, and the changes were lost without a word. Where the browser lets a page cancel Back (it does once the reader has used the page), the admin now cancels it before it moves and asks; where it does not, or where the browser has no Navigation API, it asks as before. Nothing changes for an app without Cache Components, and a Back with nothing unsaved is never touched.

  • Going Back from a document view, such as the Page Builder, to the document's own form now lands on the form on an app rendered with Cache Components.
    More

    There the view, kept mounted while hidden, wrote the field it was editing onto the form's address as Back showed it again, so Back seemed to do nothing. A view now corrects the field in the address only while the address is still its own.

  • A blog category or tag whose slug is __none__ renders its posts.
    More

    The blog's archive routes give the build that slug as a placeholder when the site has no archives yet, and its page answered the not-found page on every request too, so a real archive with that slug could never be seen. The placeholder now stops before the database only while next build runs.

  • The blog template's category and tag pages no longer answer 500 on a site built before it had any categories or tags.
    More

    Both an unknown archive and one created after the build failed, because Next.js took the archive routes for static when the build rendered none of them. The build now always renders one, so it learns the pages read the request. An unknown archive shows the not-found page, and one added after the build lists its posts, page 2 included.

  • The blog template lets an author edit and delete only the posts they wrote, while anyone who may publish posts changes every post.
    More

    A blog scaffolded with the visual approach has no such rule, so its seed gives authors no delete permission on posts.

  • The blog template's migration creates the first_published_at column on its posts, categories, tags and Singles.
    More

    Without it, a blog scaffolded with the visual approach failed every read of those tables ("no such column first_published_at"), so its pages errored. The migration's status columns are now NOT NULL, and posts' content column is text on PostgreSQL and MySQL, as nextly builds them.

    On MySQL the migration failed part way: MySQL has no CREATE INDEX IF NOT EXISTS, keys no TEXT column without a length, and refuses a foreign key between tables of different collations. Its indexes are now plain CREATE INDEX; the columns that reference a row (user_ext's ids, posts' author and featured_image, Site Settings' logo) and the author slug are varchar columns; and its tables take the database's collation, as nextly's own users and media do. Author slugs stay unique, as on PostgreSQL and SQLite.

    A blog scaffolded with the visual approach before this release keeps the migration it was created with, so it needs the column added once. On PostgreSQL:

    ALTER TABLE "dc_posts" ADD COLUMN IF NOT EXISTS "first_published_at" timestamp with time zone;
    ALTER TABLE "dc_categories" ADD COLUMN IF NOT EXISTS "first_published_at" timestamp with time zone;
    ALTER TABLE "dc_tags" ADD COLUMN IF NOT EXISTS "first_published_at" timestamp with time zone;
    ALTER TABLE "single_site_settings" ADD COLUMN IF NOT EXISTS "first_published_at" timestamp with time zone;
    ALTER TABLE "single_navigation" ADD COLUMN IF NOT EXISTS "first_published_at" timestamp with time zone;
    ALTER TABLE "single_homepage" ADD COLUMN IF NOT EXISTS "first_published_at" timestamp with time zone;

    On MySQL:

    ALTER TABLE `dc_posts` ADD COLUMN `first_published_at` timestamp NULL DEFAULT NULL;
    ALTER TABLE `dc_categories` ADD COLUMN `first_published_at` timestamp NULL DEFAULT NULL;
    ALTER TABLE `dc_tags` ADD COLUMN `first_published_at` timestamp NULL DEFAULT NULL;
    ALTER TABLE `single_site_settings` ADD COLUMN `first_published_at` timestamp NULL DEFAULT NULL;
    ALTER TABLE `single_navigation` ADD COLUMN `first_published_at` timestamp NULL DEFAULT NULL;
    ALTER TABLE `single_homepage` ADD COLUMN `first_published_at` timestamp NULL DEFAULT NULL;

    On SQLite:

    ALTER TABLE "dc_posts" ADD COLUMN "first_published_at" INTEGER;
    ALTER TABLE "dc_categories" ADD COLUMN "first_published_at" INTEGER;
    ALTER TABLE "dc_tags" ADD COLUMN "first_published_at" INTEGER;
    ALTER TABLE "single_site_settings" ADD COLUMN "first_published_at" INTEGER;
    ALTER TABLE "single_navigation" ADD COLUMN "first_published_at" INTEGER;
    ALTER TABLE "single_homepage" ADD COLUMN "first_published_at" INTEGER;
  • Cache Components and Partial Prefetching are now on in every Nextly app, and Nextly supports only that state. - A project create-nextly-app creates sets cacheComponents: true and partialPrefetching: true in its next.config, with Nextly's cache handlers (cacheHandler, cacheMaxMemorySize: 0 and cacheHandlers.default), which make the first read after a write show the new version.
    More

    A next.config.mjs defines require with createRequire to resolve them. - A new blog's src/nextly/cached-read.ts is the "use cache" read function itself, so its reads go through it from the start. The separate cached-read.cache-components.txt is gone. - When create-nextly-app adds Nextly to an existing app, it turns both options on where either is off or missing, including in an app an earlier Nextly release turned off, and adds Nextly's cache handlers. Its report names each change. A setting it can't read safely (a spread, a computed value, a wrapper call) leaves the file as it was, and the report prints the exact lines to add. A config with a cache handler of its own keeps it, and the report prints Nextly's handler lines. - The blank template's home page reads the admin's setup status inside a <Suspense> boundary, so it prerenders as a static shell under Cache Components. - Nextly warns once at start when Cache Components is off, from the value instrumentation.ts passes to createRegister, and withNextly() warns once when either option is off in the config it wraps. partialPrefetching reaches no code while an app runs, so only withNextly() can check it. The old warning that Cache Components is unsupported is gone.

    createRegister(config, { cacheComponents }) is unchanged: keep passing process.env.__NEXT_CACHE_COMPONENTS from instrumentation.ts.

    Upgrading an app made by an earlier release, which has cacheComponents: false: run create-nextly-app in the app again, or set cacheComponents: true, partialPrefetching: true and Nextly's cache handlers in next.config by hand. A blog also replaces its stub src/nextly/cached-read.ts with the read function the caching guide prints. What to set, and why: https://nextlyhq.com/docs/getting-started/installation#cache-components

  • Under Cache Components, Nextly's cached reads can now go through a "use cache" function of the app's own, registered with the new registerCachedRead and runRegisteredRead from nextly/runtime, so a page read right after a write shows the new version with Nextly's cache handlers installed.
    More

    The blog template ships src/nextly/cached-read.ts as a stub that registers nothing while Cache Components is off, and its Cache Components version beside it. A read with revalidate: false stays tag-only, and one past its revalidate is refreshed in the background. A read outside a request or build, in a script or a background job, runs directly, uncached.

    withNextly() and Nextly's start no longer warn that Cache Components is unsupported and should be turned off. Instead, with Cache Components on and no function registered, Nextly warns once at the first cached read, naming the file to add. create-nextly-app still writes Cache Components off, now as Nextly's default, and links to how to turn it on. Nothing changes with Cache Components off.

  • Two cache handlers for next.config: nextly/cache-handler for cacheHandler (with cacheMaxMemorySize: 0) and nextly/cache-handlers for cacheHandlers.default.
    More

    They keep entries in each instance's memory, at most 50 MB each, least recently used first out. Before serving an entry they ask the cache tag expiry ledger, by key, when its tags last expired, so a write recorded there from another instance or outside a request expires the entry within seconds. An answer is reused for five seconds. An entry older than the ledger keeps an expiry (seven days) is never served.

    The handlers don't read the ledger yet: nextly will hand it to them at startup in a later release. Until then they expire only what their own instance expires, as Next.js's default handlers do.

  • Without nextly's cache handlers, a cached public read in production is now given a revalidate of 30 seconds, so a write from another instance, the CLI or a job shows within a minute of a visit: the first read past the 30 seconds is served the previous version once while it refreshes, and the next is fresh.
    More

    The app's "use cache" read function, as create-nextly-app writes it, now expires a timed read at twice its revalidate and never within 5 minutes (Math.max(revalidate * 2, 300), where it was 60), so it serves no entry older than 5 minutes. Next.js leaves a "use cache" entry that expires within 5 minutes out of a static prerender, and a route that must be static (ensureStatic) then fails to build. A read with no such function registered is refreshed at 30 seconds but not expired. The warning for this case says it applies to an app that keeps a cache handler of its own too, and links the installation guide.

    Who sees a change: an app without nextly's handlers, including one made by an earlier release with Cache Components off, now refreshes its cached public reads at 30 seconds rather than 60, through unstable_cache. Its reads are fresher, at the cost of rebuilding each one about twice as often. The 5-minute expiry concerns only an app that turned Cache Components on by hand without nextly's handlers, since a new app ships the handlers. If your src/nextly/cached-read.ts has Math.max(revalidate * 2, 60), change the 60 to 300.

    The warning for Cache Components or Partial Prefetching being off now goes through nextly's logger, as cache-components-off (and cache-components-unknown when createRegister() isn't told the value), so an app's own logger receives it. A line said while Next.js loads the config, before instrumentation.ts has run, waits for the app's logger and goes out when one is installed, when register() runs, after ten seconds, or as the process exits, whichever comes first. It no longer repeats the cache handlers, which have a warning of their own.

    create-nextly-app no longer writes require.resolve(...) handler lines into an ES module next.config that declares require after its config object, where loading the config would throw. It prints the lines instead, and says to move the declaration. When it keeps an app's own cache handler, its report says what that costs: cached public reads refresh within a minute of a visit.

  • The @experimental GET /me/capabilities answer gives each collection and Single a cell for each request the admin sends whose languages differ from its action's own: readTranslations (a read with every language's translation state, such as a localized list or a document with translation-status), readHistory (the version history of every language), publishEveryLanguage (publishing every language at once, the publish rule asked once for each configured language), createInDefaultLanguage and updateInDefaultLanguage (a create or an update sent with no language, which writes the default one; a Single has no create), and duplicate (a copy of a published entry: the source read and the create, in the default language and its fallbacks, and publish too where the collection has a Draft/Published lifecycle, since the copy is created published; a draft never published cannot be copied, whoever asks; collections only).
    More

    A cell answers for every document of its collection, so where the request depends on the document (publishEveryLanguage, duplicate) it takes the strict side and never offers what the route might refuse for some document. Each is the answer the route gives that request. GET /me/permissions now returns validUntil: when the permission list stops holding, the soonest end of a role assignment it was read under, or null.

  • Keep a cleared card title and an emptied filter, and see a hoisted var as a taken name in nextly generate:widget. - A cleared card title stays cleared. A reader who clears the Title of a card the site's default titles now keeps the automatic title: the layout stores the clearing as an empty title (""), which the default's own title no longer comes back over.
    More

    An empty title reads as automatic, as no title does. Rows stored before have no title where a reader cleared one, and keep reading as they did. - Removing a filter's last chip keeps the card unfiltered. Where a widget's Filter has a default, removing its last chip stores an empty filter ({}), as the preview's Clear filters does, so the default no longer filters the card again or comes back as a chip. - nextly generate:widget sees a hoisted var. A var inside a top-level if, loop, block, try or switch of nextly.config.ts counts as a name already taken, so the command does not add an import that would collide with it. A var inside a function, and a block's let or const, stay in their own scope.

  • A card's More settings opens a side panel that shows the card as it will look, beside a dashboard that stays usable. - The panel is not modal. The dashboard behind it can still be read and clicked, and clicking it does not close the panel.
    More

    The panel is 480 to 560 px wide, and full width on a phone. - A live preview at the top draws the card at the size tier its real width gives it, scaled down to fit when the card is wider than the panel. - The settings are grouped into Data, Display and Advanced, and Advanced starts folded. Each section shows only what the widget declares, and Display always holds the card's title. Each section has its own Reset to defaults link. - Filters are chips ("Title is Hello ✕"). A card can have several, joined with AND, and "+ Add filter" adds one. One condition is stored as before; two or more are stored under and. The fields offered are still only those of the chosen collection that no read rule can refuse. - Changing the collection says what it reset, beside the Collection field: "Changing the collection reset Filter and Sort". - The preview says "No entries match these filters", with Clear filters, when the panel's filters match nothing. - Done saves and Cancel or Escape discard. Leaving the page with changes still in the panel asks first, with the admin's usual Save, Discard and Keep editing. While customising, the dashboard's own prompt asks instead, so a leave is asked about once. Its Save keeps an open panel's change in the saved arrangement, as the panel's Done would. If the panel would refuse that change (a title too long, a filter begun and not finished), Save stops and nothing is saved: the panel says what to fix, with focus on it. Discard drops both. - A filter begun and not finished is refused on Done, with "Finish this filter, or remove it." Before, it was saved without that filter. - One panel at a time. Opening another card's settings closes a panel with nothing unsaved. A panel holding a change asks first, and the other card's panel opens only once the reader has answered. - A card's automatic title names its subject and its range ("Posts · last 30 days"), with the widget's name beneath it ("Over time").

    Published additions (all patch):

    • section on a widget setting: "data", "display" or "advanced", accepted by every setting builder, and refused at startup when it is anything else. Unset, a setting over the card's content (Collection, Filter, Sort, Group by, Field) and a date range are drawn under Data, and every other setting under Display. A setting goes under Advanced only when it says so. Core's list cards fold their Density there.
    • title on a dashboard placement: the title a reader gives one card. It is trimmed, holds at most 80 characters, and is checked by the same layout write as the rest of the placement. Empty or absent means automatic.
    • MAX_CARD_TITLE_LENGTH from nextly/config: the bound the layout write applies to that title, so the admin's field uses the same number.
  • The dashboard's charts are drawn by Recharts 3, behind the admin's own chart components, and look as the redesign draws them: an area under a line with its value axis, gridlines and dates, and a dashed rule, a hollow point and a tooltip on the point in view; a chart of groups as rows of name, bar and count.
    More

    GroupsChart and OverTimeChart keep their names and props. - The chart engine loads only where a chart is drawn, never in what the admin loads before its first screen, and no published type names it. A new CI check, check-bundle-boundaries, holds both. - Every chart's numbers are in a visually hidden table that assistive tech can always reach, in place of the "View as table" disclosure, which hid them until opened. - A chart animates its marks in only when the person has not asked for reduced motion. - A chart of statuses keeps each status's colour on every card. A chart of any other field draws every bar in the first chart colour, where each value used to take a colour hashed from it. - The five chart colours, --nx-chart-1 to --nx-chart-5, are re-tuned so that each pair stays apart for readers with protanopia, deuteranopia or tritanopia, in light and dark, and still clear 3:1 against the card, a bar's track and the tooltip. A theme that sets its own chart colours is unaffected.

  • On the roles screen, a role built on a base role now holds only its own permissions.
    More

    The base's are shown ticked and locked but are never saved onto the role, so they no longer outlast a change to the base. Clear All takes away everything the role holds itself, and a new role built on one base with no permissions of its own is told it needs one before anything is saved.

  • Every nextly command that fails now ends with the same four lines: what happened, why, what to run next, and a link to the page for its error code, under a code of its own (CONFIG_NOT_FOUND, CONFIG_SYNTAX_ERROR, SCHEMA_LOCK_HELD, DATA_LOSS_CONSENT_REQUIRED and the others listed at https://nextlyhq.com/docs/cli/errors).
    More

    It no longer prints an internal envelope such as [INVALID_INPUT] Failed to load Nextly configuration. | Config loader error | context: {…}, and a configuration's syntax error is shown once, with its file, line and column. --verbose (or DEBUG=1) adds the internal context and the stack below those lines. The CLI's codes are separate from the REST API's error codes, which are unchanged; each keeps its meaning in later releases, and the codes the production-migrations guide documents (MIGRATION_TAMPERED, MIGRATION_MISSING) keep their spelling. The exit code of a failed command is still 1.

  • The Get started card is compact: twelve columns by four rows by default, and as short as three.
    More

    It draws the whole steps its rows hold, then "Show N more", which grows the card in place to show every step; "Show less" folds it back, and the card is drawn at its own size again on the next load. Nothing is saved by either.

    A card that is empty, failed or not available to its reader now shows its message centred in the card rather than at its top-left, so a tall card no longer looks unfinished.

  • Removed ServiceContainer.withTransaction and ServiceDispatcher.withTransaction.
    More

    Both opened a transaction and then ran their callback on services that used the pooled connection, so nothing they did was atomic, and on a pool of one connection they waited forever. Neither had a caller. Use the database adapter's transaction() instead, and hand the work inside it the transaction it is given.

  • The dashboard's Recently edited card is replaced by Continue where you left off.
    More

    Its header offers two tabs, as a segmented control: Mine, the default, lists the entries and Singles you pinned, in the order you pinned them, then the ones you saved most recently; Team lists what other people saved most recently, each with who saved it. Every row shows the collection's icon, the entry's title, "<collection> · edited <time>" and its status (Draft, Published, Changed, Scheduled), opens the entry, and has Pin or Unpin in its "…" menu. A title is read as you may read it now: an entry you can no longer read, or one that was deleted, is left out.

    Removed, with no alias: the core/recently-edited widget and the system:recent-edits source. A saved dashboard naming core/recently-edited keeps an empty place for it until the reader arranges it again; a site config that names it (defaultLayout, hide, replace, overrides) is refused at startup and should name core/continue instead. The exported CoreWidgetId type names core/continue in its place. A widget source may now narrow by a tab filter ("mine" or "team", @experimental).

    A card's quick setting that is a choice of exactly two options is now drawn on its header as a segmented control (a radio group: the arrows, Home and End move and choose) rather than a dropdown; a choice of any other number of options keeps the dropdown.

    Pins: a pin whose entry or Single no longer exists is removed when your pins are read and no longer counts toward the limit of 20, and two pins made at the same moment can no longer take a reader past that limit.

> Notes truncated to stay within GitHub's release body limit. The complete changelog for every package is in its CHANGELOG.md at v0.0.2-alpha.73.

Packages

  • @nextlyhq/adapter-drizzle
  • @nextlyhq/adapter-mysql
  • @nextlyhq/adapter-postgres
  • @nextlyhq/adapter-sqlite
  • @nextlyhq/admin
  • @nextlyhq/admin-css
  • @nextlyhq/blocks-engine
  • @nextlyhq/blocks-react
  • @nextlyhq/builder
  • @nextlyhq/eslint-plugin
  • @nextlyhq/plugin-form-builder
  • @nextlyhq/plugin-mcp
  • @nextlyhq/plugin-page-builder
  • @nextlyhq/plugin-sdk
  • @nextlyhq/plugin-seo
  • @nextlyhq/storage-s3
  • @nextlyhq/storage-uploadthing
  • @nextlyhq/storage-vercel-blob
  • @nextlyhq/ui
  • create-nextly-app
  • nextly

Earlier releases

Releases before 0.0.2-alpha.66 are listed in Nextly's changelog on GitHub.