Before you upgrade0

These notes list no steps.

What's changed108

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

Patch Changes

  • A Schema Builder save's migration checks judge the saved entity by its kind as well as its slug, so a collection, a Single and a field group that share a slug are told apart.
    More

    The writer behind a Builder save now reads what tells the kinds apart from one table; collections are saved exactly as before.

  • A Schema Builder save no longer reports a change to a field that did not change.
    More

    A field made through the REST API, the Direct API or code may store no required, unique or hasMany setting, while the Builder always sends each one, so every save of such a field, even one that only changed its label, asked to confirm a schema change. A missing setting now counts as off.

  • A code-first collection whose dbName moves it to a table that is already there is refused at start and by db:sync, naming both tables, and keeps its old table: before, the sync only warned and recorded the new table, so the collection was served from a table that did not hold its entries.
    More

    The same holds when the database refuses the table rename, or the tables cannot be read to decide. The collection is reported among the ones not set up, and serves from its old table until the configuration or the tables are put right.

  • A field group or Single something depends on can no longer be deleted.
    More

    While a field of a collection, a Single or another field group places the field group, 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 it, the Schema Builder's delete, the schema API and the Direct API's fieldGroups.delete() refuse before anything is removed, naming each with its owner and table and saying what to do. A Single is refused the same way, through the Schema Builder and the schema API, for a foreign key into one of its tables or another owner's element on one. Where those cannot be read the delete is refused rather than going ahead; before, a field group's refusal named nothing, and a registry it could not read was taken for one that held no use. A field group's delete now holds the schema lock from its check to its last drop. FieldGroupRegistryService.findComponentReferences is deprecated, and now throws when a registry cannot be read instead of returning the references it could read. Fixed: a relationship or upload inside a group with no name was not counted as pointing at its collection, so that collection could be deleted while still pointed at; it is now found and named at the level it is stored, and so is a field group placed inside one.

  • A field group's table now has one shape whoever builds it, and a Schema Builder save no longer rewrites columns it does not change. - The table the Builder's create makes and the one a migrate:create file makes now agree.
    More

    The first Builder save of a field group used to drop the _order, created_at and updated_at defaults and add a created_at index. On MySQL a save could also turn a text field's text column into varchar(255), which MySQL refuses once a value is longer, and created_at/updated_at from datetime into timestamp. - When upgrading: a field group made by a migration file gets those three column defaults with its next migration (no data changes), and one made by the Builder gets the created_at index with its next save. - migrate:create describes a Builder Single's or field group's table as the Builder made it, so on MySQL its unbounded text stays text. - On MySQL a migration that sets a column's default to a function, such as CURRENT_TIMESTAMP, now runs; it was a syntax error. - A development save no longer loses a unique index that holds a field's uniqueness under a name other than the one the schema declares.

  • A fractional price is refused once, not twice.
    More

    The write gate's whole-number rule now answers for every integer-backed number field, so the commerce plugin's own whole-number validator on price, stockCount and maxPerLine reported the same mistake a second time, beside it; the plugin's rule is removed and one refusal names the field.

  • A hasMany relationship, or one naming several collections, that the Schema Builder creates is now stored as a list, with no foreign key to one row, so saving and reading several related entries works on PostgreSQL, MySQL and SQLite.
    More

    Switching a relationship from one related entry to many keeps each value as a one-item list: on a collection or a Single through a Schema Builder save, a configuration reload, db:sync, a development start or a generated migration; on a field group or a translated field's translations through a Schema Builder save, a configuration reload or a generated migration. Switching from many to one converts when every row holds at most one, and is refused, naming the field and the rows, while a row holds more, or, for a required field, none. Switching to or from naming several collections is refused while a row holds a value, by the apply before anything changes and by a generated migration before any DDL. A change no road can carry is refused rather than leaving values in the old shape: a switch made while the field starts or stops being translated, a switch made in the same change that renames the field, a field group's switch through db:sync, and any switch when the registry recording what the field was cannot be read.

    Migration snapshots now record each relation column's storage shape (referenceShape), which is how a generated migration sees a switch on SQLite, where every shape is text. The key is optional: a snapshot written before it plans what it planned before, so a switch made across such a snapshot is not converted by the file.

    On PostgreSQL and MySQL, a hasMany column an earlier save created as a single reference, with a foreign key, is converted to a list by the next schema apply or by the next migration migrate:create generates.

  • A published page whose address changes now leaves a permanent redirect from its old address, in the save or, after a deploy, at the next start, stored to the end of its chain and never in a loop.
    More

    A page taking a redirect's address replaces it, and a redirect that cannot be saved refuses the save with the reason. The SEO plugin answers redirects from the site's Proxy before the page is served, exact addresses before /old/* patterns, and keeps a bounded log of the page addresses that were not found, written by logNotFound from the site's not-found page. addressOfRequest(url) from nextly and @nextlyhq/plugin-sdk answers the language and kept path a request asks for.

  • The SEO tab, the problem list and the check of what search engines received now see what a Page Builder design sets for a page.
    More

    The Page Builder offers a page's design level as a service (designSeo), worked out by the route's own derivation (designMetadataFor from @nextlyhq/blocks-react/next), and the SEO plugin reads it where the Page Builder is installed: a description only the design sets is no longer listed as missing, and the SEO tab says a value comes from the page's template.

  • A collection or Single can declare where its pages are served with publicAddress ("/blog/{slug}", or "/about" for a Single), judged by one rule when the configuration loads.
    More

    publicAddressOf(type, entry, locale) answers an entry's address from that declaration, and typesWithoutAddress() lists the types with none yet. A type made in the Schema Builder has its address supplied by a plugin through the publicAddress.template filter, judged by the same rule; a type declared in code never asks a plugin. Both functions are experimental.

  • A permission is now marked as no longer declared only by nextly migrate, as it applies the recorded migration whose snapshot drops it: an app permission, or a plugin's permission whichever writer added it, for each owner the migration's snapshot or the one before it records (for the first migration after the registry record, each plugin the registry baseline held).
    More

    Every grant of it is kept and the log names the roles holding it; a later migration that declares it again clears the mark. A plugin a migration knows nothing of keeps its permissions, Nextly's own are never marked, and a snapshot without the registry metadata or the permissions marks nothing. No server start marks a permission any more, in production or in development: a build that stops declaring a permission, an older one included, leaves it as it is.

  • A plugin can add fields to every collection and Single a site defines without naming them.
    More

    contributes.extend takes a scope as its target, { every: ["collection", "single"], except: [...] }, which reaches the site's own types, including those made in the Schema Builder, and never a plugin's own types, Nextly's system types or field groups. A type the scope reaches that already has a field of that name is left as it is and named in a warning at startup. typesReachedBy and the ContentTypeScope type (@experimental) give the same answer to anything else that needs it.

All 108 changes
  • A plugin can now work out the head of every page the site serves.
    More

    It declares the page-metadata capability and contributes a pageMetadata resolver, and the content, Single and Page Builder routes ask it for each page with no change to the site's routes. A route's own buildMetadata becomes one input: its title, description and social values are used where nobody set one, and its robots and canonical are not used. Without such a plugin, routes serve the same metadata as before. The contract types are in @nextlyhq/plugin-sdk.

  • nextly plugins install now adds the permissions and roles the plugin declares and sets every preset role's grants, with the record of the Nextly release that set them, as nextly migrate from the same release does, in the same transaction that records the plugin installed.
    More

    A plugin a production start serves therefore has its access whether or not a nextly migrate follows, and an install that stops part-way, or cannot set the preset grants, records nothing. nextly plugins uninstall, with or without --keep-data, marks the plugin's permissions as no longer declared in the transaction that records it uninstalled, keeping every grant and logging the roles that hold each; installing it again clears the marks. Neither an uninstall nor a migration takes the app's own permissions, stored under the owner app, for those of a plugin named app. A nextly migrate run with an uninstalled plugin still in the configuration no longer declares that plugin's permissions again, so their marks and grants stay as the uninstall left them; a plugin with no install or uninstall recorded is declared as before. In production, both commands refuse before changing anything when run from a Nextly release older than the one that set the preset grants, naming the release to run them from.

  • A plugin's component inside an edit page can read the document as it is being typed, and write a field (experimental). - useDocumentValues(paths) answers the named fields of the document being edited, by their dot paths, before any save, and draws again only when one of them changes. - useDocumentField(path) answers one field's value, whether it may be written now, and set(next), which writes as the author typing would and marks the document changed.
    More

    While the document's content is held (a past version on screen, a colleague editing it, a page the reader may only read), set writes nothing and answers false. set(null) returns a field to its automatic value. - Both work in any component a plugin draws inside an edit page, on an entry, a new one or a Single. They read the editor's own form, so a component with a form of its own still reads the document. Outside an editor they answer null. - Exported from @nextlyhq/plugin-sdk/admin with DocumentField.

  • A production start no longer compares the configuration with the live schema.
    More

    It used to read every collection's table on each start through getNextly() to look for drift, and every core table on each start, to warn about core columns, core tables and retired auth tables or image sizes, and the indexes of each translated collection with a field marked unique, to warn that one was missing. Those reports are now a development start's (NODE_ENV set to development). Run nextly migrate before serving: it brings the core tables up to date and names what it finds.

    A production start still names the rules left in the retired access_rules column of the registry tables, which this release no longer enforces, and still refuses a database laid out for the other choice of experimental.perLanguageStorage.

    A dry run names each file from the project folder with / between its parts on every operating system, Windows included.

  • A production start now reads the database's schema version once and compares it with the build's, the newest migration in the app's migrations folder, which withNextly names (pass migrationsDir to withNextly if you changed db.migrationsDir) and instrumentation.ts hands to createRegister as buildSchemaVersion: process.env.NEXTLY_BUILD_SCHEMA_VERSION, so it reaches Nextly on Vercel and with output: "standalone" too; new apps and the templates pass it.
    More

    A database behind the build logs one warning naming both versions and saying to run nextly migrate; one ahead of it (an older build still serving) logs one line at info level. Either way the app keeps serving and nothing is written. nextly migrate, migrate:down, Schema Builder saves and plugin installs and uninstalls now store that version in the same transaction as the registry rows they write.

  • Renaming a collection or a Single onto an address whose snake_case form another collection or Single already holds is refused with SLUG_SAME_SNAKE_CASE, as creating one already was: team-updates beside team_updates reads as one address.
    More

    A collection rename is now judged by the same address rule every other road applies (reserved names, routes, a taken slug and a same snake_case form), where before it compared the exact slug alone and threw a plain error.

    A rename now judges its new address inside the schema lock, so a collection or Single created or renamed onto the same form at the same moment is seen and refused, rather than both succeeding.

  • Renaming a collection now takes the relationships that point at it along: every relationship stored in a collection, Single or field group the Schema Builder made, nested ones included, points at the new name, in the same step as the rename.
    More

    A rename is refused, naming the fields, while a relationship that can point at several collections lists it, while a relationship defined in code points at it, or while a relationship already points at the new name. A renamed collection keeps its table, and a key to it, added or changed later, references that table. A schema the rename rewrote moves to a new version, so an editor still holding it from before the rename cannot save the old target back.

  • A field renamed onto a column that is already there is refused before anything is written, with RENAME_TARGET_TAKEN naming the table and both columns, on every road that applies a schema change: the collection Builder save and the schema dialogs of collections, Singles and field groups, as the Single Builder save already was.
    More

    In a dialog such a change read as the old column dropped beside a field kept on the column that was there, and confirming it lost the field's values to the leftover column.

  • A Single schema save that renames a field onto a column the table already has is refused before any statement runs, with RENAME_TARGET_TAKEN naming the table and both columns, on every dialect.
    More

    This holds for a translated field's companion table too. Before, on MySQL, the database's "Duplicate column name" was passed over as a step an earlier run had made: the registry recorded the new name while every value stayed in the old column.

    A rename statement the database refuses is now always a failure, never a step already applied. A save that finishes a rename an earlier stopped save already made goes through, as before.

  • Adding a Required date field to a collection that already holds entries now fills those entries on PostgreSQL and MySQL too: the migration the Schema Builder writes for it no longer refuses the date it fills them with, and writes it as each database reads the same instant.
    More

    Saving a translated collection again, after an earlier change that made a field translated did not finish, is now judged by the migration the Schema Builder writes as it is by the save itself. A save that widens the field finishes that change. One that narrows it names the unfinished change and how to complete it from the Schema Builder. A field made translated while its type changes is refused in the Schema Builder's words, not the command line's.

  • A template variable may now declare what kind of value it holds (type: text, number, date, money, link, boolean, list or object), a friendly label, an example, and for a list or an object its fields.
    More

    Today's declarations read and save as they are, and the admin API now refuses a malformed one.

    These shape only the editor's test data: a send renders whatever it is given. An owner's later presentation reaches every copy of its template, overridden or not, and never makes a template the site's or asks it to review an update. Core's built-in templates and the accounts plugin's declare theirs.

    The template editor finds the variables a template uses from the parsed template, in every field, so filters, tags, loops and bracket access are read and loop items are left out. It lists those not yet declared, with a Declare action where the site owns the template. It also marks, in the editor and the Data panel, each variable that would show blank: no test value and no | default: fallback.

  • A type a site switches off for a plugin's field (except in a contributes.extend scope) after the field's column was made keeps the column and the values in it.
    More

    The field stops showing in the API, the admin and the outputs, and an entry saved while the type is off needs no value for it; switch the type on again and the saved values are back. Dev push, nextly migrate:create and nextly migrate:check keep the column rather than planning or reporting its drop, for types in the configuration and types made in the Schema Builder. A type switched off before its first migration still never gets the column.

  • A collection's entry list in the admin now stops counting at 1,000 entries and shows "1000+" past that, so a very large collection's list no longer pays for counting every row.
    More

    Paging forward and back keeps working past 1,000. The pager offers the next page, but no jump to a last page that hasn't been counted. With 1,000 entries or fewer, the list shows the exact total as before.

    The REST list takes ?count=capped for the same count. With more than 1,000 matches, meta.total is 1000 and the new meta.totalCapped is true. Without the parameter, or with count=exact, the total is exact as it always was. Any other value is refused with a 400.

  • A fractional value written to a whole-number number field used to be decided by the database: MySQL silently rounded it, PostgreSQL answered a 500, SQLite stored it as written.
    More

    The entry write validation now refuses the fraction with a validation error naming the field — before any write, identically on every dialect, on create, update and bulk, and on hasMany list elements. Fields declared with dbType: "decimal" or the float format keep accepting fractions, and values already stored are untouched: a legacy fractional row keeps reading and publishing unchanged.

    SQLite compatibility: on SQLite, a default number field used to store 2.5 correctly, and after this change the same write is a 400 validation refusal. Remedy: declare dbType: "decimal" (which needs a migration), or round the value before saving.

  • Every signed-in person now has an account page, at /admin/account. - It edits their own name and avatar through /me and shows their email, which an administrator changes.
    More

    It needs no permission beyond being signed in. - The user menu's "My Account" opens it. Before, it opened the users edit page, which needs update-users. - Plugins can add blocks and tabs to it, at the account place, around its profile card. - A person's own profile change through /me (and the Direct API's updateMe) is refused, naming the field, when its name or picture address is longer than 255 characters, the most every database stores. Before, MySQL refused such a save with a database error, or cut the value short. The limit now holds on every dialect: PostgreSQL and SQLite, which kept a longer value before, refuse it with the same message, so the same request gets the same answer everywhere. - The account page sends only the fields you changed. A picture address stored before this limit, longer than 255 characters, is not sent again when you change only your name, so that save still goes through.

  • The dashboard draws what plugins add to it (experimental). - Its blocks stand around the page's own two, the welcome header (welcome) and the grid of cards (widgets), in the order sent, each behind its own error boundary.
    More

    A block placed by nothing goes below the grid; one with before: "widgets" (or after: "welcome") goes between the header and the cards. - The grid is each person's own arrangement of their cards, so a plugin may place a block beside it but not replace it: startup refuses a replaces: "widgets", naming the plugin and the contribution (contribution-replace-not-allowed). The welcome header may be replaced. - A dashboard with nothing contributed is unchanged.

  • The admin now draws what plugins add to four of its places (experimental). - Settings, a user's detail page, the entry form (in both the collection entry and the Single editor) and the login page draw the blocks sent to them, in the order sent, each behind its own error boundary, and settings and a user's detail page draw contributed tabs after the page's own content. - A page with nothing contributed is unchanged. - The login page's contributions are kept after signing in, beside the signed-in places'. - A plugin draws a place it declared on its own page with TargetSlot and PlaceTabs from @nextlyhq/plugin-sdk/admin.
  • The edit pages draw what plugins add to them (experimental). - A collection entry's and a Single's edit pages draw the blocks sent to them around their own two, document-bar (the bar with the banners under it) and editor (the form's notices, the fields and the side panel), in the order sent, each behind its own error boundary.
    More

    A block replacing either is drawn where it was. - A contributed tab heads the field column after the page's own content, labelled "Content"; the document bar and the side panel stay whichever tab is open. - A Single's side panel now draws the sections plugins declare at its place, as a collection entry's does, ordered among its own four by the same rule, with narrow: "above-form" honoured on both. - A side panel section's component receives SidebarSectionProps (new, from @nextlyhq/plugin-sdk/admin): the place's context and entry, and on a collection entry's page also every field of DocumentPanelSectionProps, so a section written for the document panel keeps working. Sections wait until the signed-in admin is known, and a form of a section's own no longer submits the document. - An edit page with nothing contributed is unchanged. - PlaceTabs takes an optional className for its strip and the contributed tabs' panels, leaving the page's own content as it is.

  • The entry list now draws what plugins add to it (experimental). - Blocks stand around the list's own header and list, the place's built-ins toolbar and table, in the order sent, each behind its own error boundary. - Declared columns are drawn after the collection's own, always shown and not offered in the column chooser. - A field column draws through that field's own cell.
    More

    It names a field at the collection's top level; one inside a group or repeater is not drawn. - A component column draws one cell at a time, each cell behind its own boundary. A click or key on a control inside a cell stays in the cell rather than opening the row's entry. - Declared bulk actions are offered in the bar shown while rows are selected, when the action's visibleWhen holds for every selected row, and run on the selected rows. Rows can be selected for a declared bulk action even where no built-in bulk action is allowed. An action that calls its route is held back, saying why, on more rows than one request to the route may name; one that opens a component takes any number. - Row and bulk actions share one filter for the collections they're offered on and one way of running. - nextly/config exports MAX_ACTION_ROWS (experimental), the most rows one request to a declared action's route may name.

  • The admin paints its frame (the top bar, the rail and the logo) as soon as its code runs, before any request answers, and only the content area waits.
    More

    A screen's still outline appears from 0.4 s in the place its parts will take (the dashboard's cards, a list's table, an editor's fields and side panel, and the other main screens), a thin line moves under the bar from 0.5 s, and from 5 s one line says the server is starting; none of them appears when the data arrives sooner, and under reduced motion nothing moves. The outline gives way to the screen without moving the frame, an editor's bar keeps its buttons in place while the document loads, and the rail holds neutral shapes until its entries are known. A browser that has never signed in here opens on the real sign-in form at once: it takes typing while the server starts, says it is connecting, and sends the sign-in once, when the server answers. Every screen still waits for the server to confirm the session before it draws any data. The outlines are still, never pulsing: Skeleton takes a still prop for an outline that does not move.

  • The admin remembers the map of the site on each editor's device, so a new tab draws the real rail and Content panel at once, before the server answers, then replaces them with what the server sends.
    More

    It keeps only metadata: the menu as that person sees it, the schemas of the collections, Singles and field groups they read (a later read of one asks "has it changed?" and is not sent again when it has not), the site's public logo and name, interface preferences, and a note that someone signed in here; never an entry, a media item, a user, a form's values, a session token or a permission list, and no form is ever filled from it. What it keeps is labelled with the person, the admin build, the schema version and the permission version, and is discarded when any of them changes. Signing out, or the session ending, removes everything about the person in every open tab, which signs out too; only the public logo and name stay, so the sign-in screen keeps the site's look. Remembering is on by default; set NEXTLY_ADMIN_DEVICE_MEMORY=off to keep nothing on the device, and each browser removes what it kept on its next visit. Plugins keep an author's choices by the same rules through devicePreferenceStore from @nextlyhq/plugin-sdk/admin (experimental), which the page builder's editor now uses for its panels, recent pages and icons, template previews and getting-started card; userPreferenceStore from @nextlyhq/builder/shell takes an optional opener for such a store. The startup request's answer now carries X-Nextly-Device-Memory, X-Nextly-Schema-Version and X-Nextly-Permission-Version (a hash of the permission version) for this.

  • A plugin's permission keeps its role grants when a start no longer declares it.
    More

    The start marks the permission orphaned as before, but setting the preset roles no longer takes an orphaned permission away from them (or gives it to one that does not hold it), so the Admin role keeps its grant and has it as before when the plugin returns. The log line written when a permission is orphaned or declared again now names the roles that hold it.

  • On a phone, the document panel and an item's media details open as bottom sheets with a grab strip: dragging it down past a quarter of the sheet, or flicking it, closes the sheet, and a shorter drag springs back; Escape still closes it.
    More

    Each sheet is as tall as its content, up to 90% of the screen, and scrolls inside beyond that. SheetContent from @nextlyhq/ui gains a dragHandle prop for bottom sheets. No drawer library is added.

  • The admin's logo and favicon no longer change after the page loads.
    More

    With no logo configured, the rail, the sign-in card and the phone header all show the same boxed mark from the first paint. Branding set in nextly.config is read from the page itself when the admin route carries it (a #nextly-admin-branding JSON element), so a configured logo shows before any request answers and wins over branding set in General settings. The admin no longer replaces the page's favicon with its own default after load: with no favicon set the page keeps its own, a configured favicon is left as the page links it, and only a favicon set in General settings is applied.

  • The Schema Builder shows a collection's, Single's or field group's fields as one outline, every nested field included: each row names its label, its type, its name and badges for Required, Translatable, Hidden, Has a condition, Locked (naming where it is defined) and Has an error.
    More

    Containers fold, and Fold all and Unfold all are remembered for each entity in the browser; a find box shows the fields matching a label, name or type with the containers above them opened. A hidden field stays in the outline, marked Hidden, and can be shown again. A field that uses a field group shows that field group's fields beneath it, read-only, with a way to open the field group in its own editor; a blocks field shows how many blocks it accepts. A field owned by code or a plugin, and every field beneath a field group, offers no change in its menu, the panel or by key, and says where it is defined. Selecting a row opens its settings without moving the outline. An optional form preview shows the entry form as editors will see it, pending changes included. The outline is a tree to assistive technology, with the tree's keys; a row's actions open from its menu (Shift+F10), and "/" adds a field after it.

    A field moves within its own container by dragging it, or with Move up and Move down in its menu (Alt+Up and Alt+Down).

    Fixed: a field named title or slug inside a group or a field group is no longer treated as one of the entity's built-in fields, so it shows in the outline and can be edited and deleted. A field group's resolved fields, which the server adds when it hands a definition out, are no longer written back into the field's options on save. Every field with an error is now marked, at any depth; a field without a name inside a group is refused at save as one at the top level is.

  • The Schema Builder offers a field group among a field group's own fields, beside the fields at its top level as well as inside a group or repeater: such a field group is stored at every depth.
    More

    The notice that named field groups placed directly in a field group as not saved is removed.

  • A Schema Builder save that switches a relationship between one related entry and many, or to or from several collections, is applied by the push again, with its migration file recorded once the push has run: the switch is refused, naming the field and its rows, while rows would not survive it, its values are converted, and a column an older save left as one reference is repaired.
    More

    Saves that write their migration had skipped all three.

  • A Schema Builder collection whose group holds a group with no name, which only lays its fields out, saves again.
    More

    The definition file now accepts a group without a name; every other field still needs one.

    A Schema Builder field change that removes a field and fills a new required field over existing rows in the same save is no longer refused with "destructive_drop:… is not a change to a field of this collection". The drop's confirmation is now matched against the fields the collection had before the save.

  • A Schema Builder save of a collection now writes the migration and snapshot nextly migrate:create would write for that collection into your migrations folder (db.migrationsDir), after recording its whole definition in db.uiSchemaFile.
    More

    In development the save runs that file the way nextly migrate does and records it applied with its checksum, so nextly migrate and migrate:create have nothing left to do. Outside development the save writes the definition, the file and the snapshot, runs nothing, and the deploy's nextly migrate applies them. - Every save of a collection does this: a create, a field change from the Builder's schema dialog, an update of its settings or fields through updateCollection, and a delete, whether made in the admin, through a plugin's ctx.services.collections, or through the CollectionsHandler. Nothing is written to src/db/migrations/dynamic any more. Files an earlier version wrote there are not read; delete the folder once you no longer need it. - A save first runs the checks nextly migrate runs before it writes anything. While an applied migration file is edited or missing, or an attempt is unfinished, the save is refused with NEXTLY_MIGRATION_HISTORY_REFUSED (409) and the text nextly migrate prints, and nothing is written. A delete is refused before anything is torn down. - The answers you give in the schema dialog are part of the file, so every database it reaches is settled the same way: a rename keeps the column's values; rows that do not fit a field made required are filled with the value you gave, or deleted where you chose that, before the column becomes NOT NULL. The preview names each fill and each delete, and nextly migrate asks consent (--accept-data-loss) before running such a delete on a database whose rows it would remove. A JSON field's fill may be any JSON value. An answer is taken only for a field the save makes required, named by the field's own name (a camelCase one too), and any other is refused with nothing written. A unique field takes no single fill value, and a delete of 10,000 rows or more is refused, as before. - An update through updateCollection, and on a translated collection a field change or turning translation on or off, keeps the development push it has always had; its migration is written as well and recorded applied once the push has run, and the save is refused, naming the file, where the database does not stand as the file says. - nextly migrate:create now writes a translated field's accepted rename as a rename of its column in the translations table, so its values stay under the new name; before, it added the new column and left the values under the old one. - The first save of a collection whose table no snapshot records (one an earlier version made) writes <timestamp>_<slug>_adopt.sql, describing the table exactly as your database has it and recorded applied without running, before the save's own file, so a fresh database replays the collection. - nextly migrate:create describes a Builder collection's columns as the Builder creates them: on MySQL a text field is TEXT, as the Builder has always made it, in its table and in its translations table, where a code-first collection's is varchar(255). A project that already ran migrate:create on Builder collections gets a one-time migration widening those columns from varchar(255) to TEXT; nextly migrate applies it without asking for --accept-data-loss, since a widening deletes nothing. - nextly migrate and the other commands that ask consent before deleting data no longer ask it for a string column widened: varchar(n) to text or to a varchar at least as long, or the type restated, with no character set, collation or other conversion named, no nullable column made NOT NULL and, on MySQL, the column in its table's default character set. Every narrowing, text to varchar, a change that makes a nullable column NOT NULL, and any other type change still asks. - Where a table an earlier version made holds a column whose type differs from what its field makes now (on MySQL, a short text field stored as TEXT), a <timestamp>_<slug>_convert.sql converts it before the change. The preview names each conversion, and a save converts no column it was not shown: a save through the API or a plugin passes the confirmed columns as acknowledgedConversions, and is otherwise refused with NEXTLY_SCHEMA_CONVERSION_UNCONFIRMED (409). A stored value too long for the new type is refused by MySQL, and nothing is applied. - A many-to-many relationship's junction table, and a relationship column's foreign key with its onDelete and onUpdate, are written into the save's file as the Builder has always created them, so a deploy replays them too. Snapshots keep leaving both out, as before, so migrate:check reports no drift for them. - A save whose statements fail with nothing applied leaves no file and puts the definition back. One that fails part-way (MySQL commits each schema statement), in any table its file changes, keeps its files for nextly migrate:resolve, with NEXTLY_MIGRATION_PARTIALLY_APPLIED. Where an earlier file of the save applied and a later one then failed, every file and the new definition stay, and nextly migrate runs the rest once the cause is fixed. - The definition file (ui-schema.json) now holds a field's options exactly as the registry stores them, such as a relationship's target, relationType, onDelete, onUpdate and junctionTable, a text's variant or a number's format, beside relationTo and hasMany, and a number's storage (dbType, precision, scale). Every key is optional, so every existing file stays valid. - On MySQL, a migration that makes a column required needs --accept-data-loss on deploy, as any such file migrate:create writes does: its statement restates the column, and a server not in strict mode turns the column's NULLs into empty values. - A field's name in the definition file may be camelCase (^[A-Za-z][A-Za-z0-9_]*$), as the Builder accepts it. - On SQLite, nextly migrate:create writes a field's type change as a rebuild of its table, as it already does for a nullability change, instead of refusing it. - On MySQL, a save that makes a field unique where its column cannot carry a unique index (a TEXT column) is refused, as a code-first change is, and nothing is written.

  • In the Schema Builder's outline, a blocks field now shows beneath it each registered block it accepts, named as the page editor names it, with that block's props, read-only and naming the plugin that registered it.
    More

    An allow-list entry no registered block matches is said beside the field, and the row says when the blocks are still loading, could not be read, or need the Page Builder plugin. The Page Builder serves this from a new read, POST /plugins/@nextlyhq/plugin-page-builder/blocks/accepted with a field's allow-list in the body (a POST that changes nothing, since the list need not fit in a URL), open to any signed-in user and answering code-defined block metadata only. @nextlyhq/blocks-engine now exports slotAdmits, its one reading of a block allow-list, which the blocks field's validator now uses too; @nextlyhq/builder/ops offers fieldLabel and propLabel (experimental).

  • The SEO plugin's start-up catch-up records every page even while pages are deleted or made as it lists them: the listing of each type's pages now goes by id, so nothing moves an unread page behind it, and a page deleted after it was listed claims nothing.
  • Collection events (collection.<slug>.created, .updated and .deleted) now arrive when the write commits, before its afterCreate / afterUpdate / afterDelete hooks rather than after them: a listener that relied on the after-hooks having run should do that work in an after* hook instead.
    More

    A write made inside a caller's transaction (createEntryInTransaction, updateEntryInTransaction, deleteEntryInTransaction), and each entry of createEntries, updateEntries and deleteEntries, now sends its collection event too: once the outermost transaction commits, after the after-hooks it runs inside that transaction, and never if the transaction rolls back.

  • The admin component map now holds every collection view, and the admin no longer imports plugin modules by name at run time. - nextly generate:types and --check list the components a collection names for its own screens: its Edit and List views, and what is drawn before and after its list table and edit form.
    More

    A plugin's collections and the site's own are both covered, and so does the development check that rewrites an out-of-date map, so it keeps them. - The admin's run-time import() of a plugin's admin module is removed. In a bundled admin it could not resolve a package by name, so a component missing from the map now draws its fallback, and next dev names it. - registerKnownPlugin is deprecated, and removed at the next major release after two minor releases. It still registers what it's given, now straight away, and says once that it is deprecated. Register components with registerComponents in your plugin's admin module instead. The plugin template and the first-party plugins now do. - The generated map now registers through registerComponentMap (experimental, from @nextlyhq/admin). It registers like registerComponents, then tells the admin nothing more is on its way, so a plugin's document action or panel section whose component is missing draws its fallback instead of Loading. Rerun nextly generate:types: a map generated before this keeps working, but a component missing from it shows Loading instead of the fallback.

  • Search engines and AI crawlers now read each page's whole head in the first HTML they are sent. - nextly/next exports nextlyHtmlLimitedBots, for a Next config's htmlLimitedBots.
    More

    It is Next.js's own list plus the main Googlebot and the AI crawlers and answer engines, such as GPTBot, ClaudeBot and PerplexityBot. Next.js streams a page's metadata to everyone else, after the head. - A new app's next.config sets it, and withNextly() sets it where the app sets no list of its own. - An app made earlier adds two lines to its next.config:

      import { nextlyHtmlLimitedBots } from "nextly/next";
      // in the config:
      htmlLimitedBots: nextlyHtmlLimitedBots,
  • Add widget is one list you can search.
    More

    The drawer opens with focus in its search, then lists every widget you may add once, each with its icon, name, the plugin it comes from, one line about it, and Add. A one-card widget already on your dashboard says "On dashboard", and a widget that reads a collection says "Needs a collection you can read" when you may read none. The Suggested row, the Removed group, the filter chips and the step that asked for a collection are gone: Add puts the card at the end with its defaults and keeps the drawer open, a card that reads a collection starts on the first one no card of that widget uses yet, and Add on a one-card widget you removed puts that card back as it was. When every collection already has its card, the new card's settings open, and it is kept only once something tells it apart from the card it matches. The layout write refuses a card that reads a collection from a reader who may read none. The widget previews page is no longer served by the admin, on a development server or in production; its accessibility check of every widget's preview cases runs from a page of the end-to-end test app, and @nextlyhq/admin/testing exports the board it draws (WidgetPreviewBoard, experimental). Each core widget names an icon for the list.

  • Dashboard cards are as tall as their content, at rest and in Customize: no card is drawn at a fixed number of rows, nothing inside a card is cut off, and the cards that share a row are drawn as tall as the tallest of them.
    More

    A chart over time is taller on a wider card. While a card reloads it keeps the height it was last drawn at, so the cards below it stay put. The card menu no longer offers a Height. A widget's size.h and the h in saved layouts are kept and still decide how many list rows a load asks for (rowsThatFit); they no longer set a card's height. Nothing stored is rewritten.

  • System health on the dashboard can now copy a diagnostics report. "Copy diagnostics", at the card's foot and in its Details drawer, copies a plain-text report ready for an issue or a chat: the Nextly, Node, Next.js and React versions, the environment, the database and whether its connection is encrypted (yes, no or unknown), migrations, storage, email, background jobs, each plugin with its version, how many collections, Singles, users and locales the site has, and how many server errors this server process answered in the last 24 hours.
    More

    The report is built on the server from a fixed list of facts, so it never holds a password, key, token, connection string, host name, email address, person's name, entry content or environment variable's value. Details shows exactly what is copied. If the browser refuses the clipboard, Details opens with the report selected to copy by hand. Only super-admins can build the report (GET /api/dashboard/diagnostics).

  • The dashboard's Count card reads well at any number.
    More

    It shows what it counts, the number written whole ("12,480", never "12.5k"), and one line under it: by default the change this week ("+3 this week", "No change this week"). In its settings, "Count" chooses all entries, the published ones or the drafts, and "Under the number" chooses the change this week, a trend line over the last 8 weeks, a status split, or nothing. Every line counts what the number counts, so a Drafts card's change counts only drafts, and the status split is offered only with all entries. A reader who may read users can also set a Count card to Users, to count the people on the site; a reader who may not is never offered Users, and the server refuses a card set to it. Recent entries rows no longer start with a letter square: each row leads with its title and shows its status as a quiet chip with a dot. Upcoming releases keeps its date chip.

  • A final pass over the dashboard at phone, tablet, laptop and desktop widths, in light and dark.
    More

    Every control on it is now at least 24 by 24 pixels, so it is easy to tap: the card footers' links ("View all", "Details", "All users"), the Content card's names and draft counts, a note's links and the settings drawer's "Reset to defaults". A card with nothing in its footer no longer keeps an empty line under its content. A long card title next to a header control, such as "Continue where you left off" beside Mine and Team on a phone, wraps onto the header's second line instead of being cut short. In Customize, cards are drawn with the stronger control border, and on a touch screen the resize edge is shown without needing a hover. A card in the right-hand column can now be widened from its edge: taking the edge past the grid's right edge widens the card to its widest width. The settings drawer's short choices (Width, Number of entries, Row spacing) are one bordered row with the chosen option filled, and the Title field's hint reads "Leave empty to use the name shown." Team cuts a long role name short, with the whole name on hover, so the person's name keeps its room. A note's links are drawn in the text's own colour, underlined. In System health's Details, the report keeps phrases such as "24 h" and "3 locales (en, es, ar)" on one line where it wraps, without changing the text it copies, and a toast said while Details is open stands above its footer instead of over the Copy diagnostics button.

  • Dashboard lists show their reader's "Number of entries" (the setting formerly "Number of items"), up to 20, whatever the card's size, and load no more than that.
    More

    Content and Upcoming releases now offer the setting too, as does Forms' "New form submissions", whose footer now reads "View all (N)" when there are more. Needs your attention shows every item, with no "Show N more". listEntries and MAX_WIDGET_ROWS (now 20) are exported, experimental, from nextly and @nextlyhq/plugin-sdk for widgets that list; rowsThatFit keeps its meaning (at most ten). Saved "Number of items" values are read as saved.

  • While customizing the dashboard, the cards move aside as you drag one, so you see where everything lands before you let go, and the card settles into its outline on release; with reduced motion they move without sliding.
    More

    The drag handle now sits left of each card's title instead of adding a row. On a dashboard at least 1,024px wide you can drag a card's right edge to resize it: it snaps to the widths the widget allows (25%, 33%, 50%, 66%, 75%, 100% and its own limits), shows the width as you drag, and stops at the widest. From the keyboard, a card's menu still moves it earlier or later and says where it went.

  • The dashboard opens with one line, "Good afternoon, <your first name>", as its heading, and its only action is a cog at the right end of the top bar, named "Customize dashboard".
    More

    In Customize, Reset, Add widget, Cancel and Save take the cog's place in the bar, and the breadcrumb reads "Dashboard / Customizing"; on a phone, Add widget is an icon beside Cancel and Save. Cancel, or the breadcrumb's Dashboard, asks before discarding unsaved changes, and leaving Customize puts focus on the greeting. The project name, environment badge, summary line, "Resume setup", the freshness line, the "+ New" menu and the "Preview widgets" link are gone from the dashboard. A reader who dismissed the setup card with the old dismiss control sees it again while it is on their dashboard: hiding it is now "Hide setup" in its ⋯ menu, which takes it off the layout, and Add widget brings it back. The stored dismissal is left as it is.

  • A dashboard card's settings now live in one place: its menu's Settings… opens one drawer with a preview of the card, then Content, Display and Size, all open, with nothing folded under "Advanced".
    More

    Changes apply when you press Save (Cancel, Escape or the close button discard them); outside Customize, Save keeps them for you at once, and in Customize it keeps them with the rest of your changes until you save the dashboard. - Clicking a card's title no longer opens a quick-settings popover, and the card menus no longer offer Width or Height. The width is chosen in the drawer's Size section, in percent (a width saved before that is not one of the choices stays selected until you pick another). Cards are as tall as their content, so there is no height setting. - The card menu holds Settings…, Refresh and Remove; in Customize it adds Move earlier and Move later (Move to start and Move to end are gone). - A list's "Number of entries" is a choice of 5, 10 or 20, still stored as a number: a number saved before (say 7) is shown and kept until you choose another. - List density is now "Row spacing" (Comfortable or Compact) under Display. - The Note's text says it supports Markdown, with examples, and counts the characters left of its 2,000.

    Compatibility: defineWidget declarations are unchanged. A setting's section: "advanced" is still accepted and is drawn under Display; quick still marks the setting a card's header draws. Stored layouts and settings are not rewritten.

  • On a phone (a dashboard under 640px), two 25%-wide cards now share a row at half the width each; every other card still takes the full width.
  • The dashboard's "Set up your project" card is now a short checklist: a progress bar, then one line per step with a tick or an empty circle, its name and hint, and its buttons on the right, with Skip on the steps you can skip.
    More

    It starts at half the dashboard's width, beside Needs attention, and can be made 66%, 75% or full width; on a phone its buttons drop under the step's name instead of the card scrolling sideways. "Fill in your Singles" lists your Singles inside its line, each with a Fill in button. Every action is a button rather than an underlined link. The card's separate collapse and dismiss buttons are replaced by Hide setup in its ⋯ menu, with Undo in the notice it leaves, and the sample-content step leaves the list once it has been answered. Core's default dashboard now places every card at half the row, so a card you cannot see, or one that is empty, never leaves a gap.

  • Status text and icons on the dashboard (the Needs attention marks and the Stats card trend arrows) now use the readable status text tokens, so they meet contrast in light and dark mode.
  • Statuses on the dashboard are drawn in the admin's status colours, the same in light and dark.
    More

    A chart of statuses, in Breakdown and in Widget.BarChart, draws Published in the success colour, Scheduled in the info colour, Changes in the warning colour, and Draft and Archived in the muted ink, so a status reads the same on a chart as beside it. The severity marks in Needs your attention and a card's error icon use the status's solid colour, the exported StatsCard's trend is a quiet chip with a coloured arrow, and the exported ContentStatusWidget draws Published and Draft in their status colours. The widget documentation recommends the status tokens and Badge's status variants to widgets that draw their own component.

  • System health on the dashboard now answers a developer's first questions.
    More

    Under one status line ("Everything is working", or how many problems need attention and things to check), it shows the Nextly version and whether it is the newest in its release channel (or "Couldn't check for updates" when the registry cannot be reached), the environment, the database and its response time, whether the database connection is encrypted, migrations, storage, the email provider and background jobs. Details opens a drawer with the Node, Next.js and React versions and each plugin's version.

    Whether the connection is encrypted is read from the database session itself (PostgreSQL's pg_stat_ssl, MySQL's Ssl_cipher), not from configuration; once the session has answered, the site's own connection decides, so behind a connection pooler a plain session over the site's TLS connection counts as encrypted, and an encrypted pooler session over the site's plain connection does not. In production, an unencrypted connection to a database on another machine is a problem on the card and in Needs your attention, with a "How to fix" link to the new Encrypted connections page; a connection whose encryption could not be read is a warning, never treated as encrypted. The database adapters gain inspectConnection(), which answers this without throwing. System health's default width is now half the dashboard.

  • The dashboard's Team card lists the people on the project instead of two count tiles: each person's name, email, role and when they were last active, most recently active first.
    More

    A role filter in the card's header, "All roles" by default, narrows the list and is also a setting, beside "Number of people" (5, 10 or 20) and "Show last active". The footer holds Invite, for a reader who may add people, and "View all (N)" when there are more people than the card shows, or "All users" when it shows them all. The card is now offered to every reader who may read users, not only to those who may also add or change them, and the server reads only the fields the card draws, filtered, ordered and cut in the database. Last active is the later of a person's newest session renewal and newest sign-in.

  • Dashboard card widths are named as a share of the row: 25%, 33%, 50%, 66%, 75% and 100%, with 75% now offered wherever a widget allows it.
    More

    A width outside those six reads as its own share (5 columns is 42%). The add-widget panel says "25% to 100% wide", and a card in Customize shows its width as a percentage. Stored sizes and widget declarations are unchanged.

  • nextly db:sync takes --dry-run in every form: show what would change, change nothing.
    More

    It opens the database read-only, takes no schema lock, asks no confirmation or consent, and exits 0, naming the real run's refusal where it would refuse. - db:sync --dry-run names each table and column operation the schema push would run, and each question it would ask, with a note on what it does not show; --remove-orphaned adds the tables it would delete. - db:sync --promote <slug> --dry-run shows the snippet it would append and the registry row it would remove. - db:sync --demote <slug> --dry-run shows the registry record it would write. - --dry-run cannot be combined with --watch.

    Fixes:

    • db:sync --promote of a collection defined in code is refused before it appends anything to nextly.config.ts; it used to append the snippet and then be refused.

    • nextly migrate stopped because a migration file changed after its deletions were judged now reads as PLAN_CHANGED_AFTER_CONSENT rather than an unexpected error.

  • nextly events report and nextly events abandon clean their output without a control-character pattern, with the same result.
    More

    No change in behaviour.

  • A site declares how each language's address is formed, under a prefix or on a domain of its own (languageAddresses in nextly.config.ts), and languageAddressOf(path, locale) answers the address a page kept in a language is opened at.
    More

    Content and Single routes, the blocks routes included, placed under a [locale] segment read the language from it: one route serves every language, a segment naming none of the site's languages answers not found, and the addresses a route hands on are formed by the rule.

  • An open entry or Single draws no bar of its own: its status, save state and actions (History, Preview, Save or Publish with its arrow, More, the panel toggle) are drawn in the admin's one top bar, after the breadcrumb, on one row at every width.
    More

    Editor pages run edge to edge: the scheduled, lock and recovery banners start directly under the bar, and the side panel meets the window's edge. Singles are drawn as Editor pages, with their fields in the same 72rem column as an entry's and no cap on the page. A plugin's custom edit view keeps the page gutter without a width cap. The shared PageFrame from @nextlyhq/ui draws type="editor" with no gutter and no padding.

  • Settings › Email names a plugin's group of emails, its layouts and the owner filter with the name the admin shows for the plugin everywhere else (its label), not its package name.
    More

    Grouping, filtering and order stay keyed by the plugin, and a plugin no longer installed keeps its package name.

  • The Builder's lists of collections, Singles and field groups now say what is true.
    More

    A plugin's entries are listed under that plugin by name, folded by default and read-only (no selection, no delete), instead of among the site's own or as "Unknown". Each entry names its source: "Defined in code", "Made in the Builder", "Built in" or the plugin's name. The column reporting whether a schema is applied is called "Schema" and draws attention only when something is not applied. "View entries" opens the collection's entries; "Generate Types", which only promised a later feature, is gone; a code-defined entry offers no delete rather than a disabled one. Each field group shows how many fields use it.

    The list endpoints for collections, Singles and field groups accept owner=site or owner=plugins, applied in the query so a page and its count describe the same rows; without it they list everything, as before. The admin's plugin metadata names a plugin's collections, Singles and field groups by the slugs a host's rename registered them under. The field-group list now reads a 1-based page as well as offset, so its second page is no longer its first.

  • Every running server copy now serves a schema change within a few seconds, with no restart.
    More

    Each copy reads the database's stored schema version at most once every 2 seconds (one indexed read, shared by every request arriving meanwhile, and none while no requests arrive) and, when it moved, loads its collection, Single and field group definitions again from the registry, so a field added in the Schema Builder on one copy is written and read on every other. The first read after a start loads them once more, since the start's own load cannot be dated against the version.

    The X-Nextly-Schema-Version header now carries that stored version, one number for every copy, rather than a count kept by each process. bumpSchemaVersion (from nextly/runtime) keeps its signature and now asks the next request to read the stored version at once; it returns the version served until then. A registry write in this process does the same by itself.

    The admin's metadata reads (the collection, Single and field group lists, and collection and Single schemas) answer with an ETag that is a hash of the body sent, and answer 304 Not Modified with no body to a request whose If-None-Match holds it: only when an ordinary request would receive the same bytes. If-None-Match: * is not honoured, and the startup request answers every part in full. Every admin API response to a signed-in request (one with a session cookie or an Authorization header) is now marked private, no-store and varies on the credentials, whatever its route asked for, so no shared cache keeps it.

  • A field group's editor in the Schema Builder now says which collections, Singles and field groups use it, each linked to its own editor, and that a change there reaches all of them; it says so when that cannot be read, rather than showing nothing.
    More

    In the outline, a field that uses a field group shows how many places use it. The answer comes from a new read, GET /api/field-groups/<slug>/used-by, which lists each field that places the field group with the collection, Single or field group holding it; like reading the field group itself, it needs a signed-in user and no specific permission. The field-group list's use count is now the length of that same list.

  • Field groups nest inside each other to any depth, and a field group placed inside itself is refused where it is written.
    More

    The three-level limit defineConfig() enforced at start is lifted, so a configuration nesting deeper now starts. A field group placed inside itself, directly or through other field groups (including through a group, a repeater or a list of allowed field groups), is refused by defineConfig(), by the start when the cycle takes in a field group defined in code, and by every Schema Builder save, naming the field groups in the cycle. A cycle among Schema Builder field groups saved before this change does not stop a start: the start and CLI commands that load the configuration name it in a warning, and the next save of any field group in it is refused until one stops placing the next. Text values nested in field groups are sanitized at every depth, where they were reached only three field groups deep, and deleting a collection or Single removes its field-group rows at every depth.

    Text inside a group without a name is now sanitized like any other text. Before, a text or textarea field placed in such a group was stored with its HTML intact, while the same field outside the group was stripped.

    MAX_FIELD_GROUP_NESTING_DEPTH stays exported with its old value and is deprecated: nothing enforces it any more.

  • A field group placed directly in another field group's fields is now stored, read and removed at every depth.
    More

    Its values were refused before, with "not stored", and the admin left the field out of the form. Each level is a row of its own field group's table, pointing at the row of the instance that holds it. It is validated by its own rules, a required one is required, passwords in it are hashed, its fields' read and write rules apply, its translated values are kept per language, version restores and media usage include it, and deleting or clearing an instance removes everything placed in it. The Builder's form draws it, and the configuration no longer warns about it.

    A filter path that goes past a field group's own fields (hero.cta.label) is refused as a field that cannot be filtered on. It used to be read as a column named after the whole path, which answered with the wrong rows.

    A plugin's write to a field-group row nested more than eight levels deep now still expires its document's cached reads. Removing a field-group instance, or deleting the collection or Single holding it, also removes rows that a field group stopped placing in it after they were stored.

    A required field inside a group without a name is now enforced; a save that leaves it empty, accepted before, is refused. Existing entries with that field empty must fill it on their next save, as for any required field.

  • The entry's fields a surface draws beside a field that takes the form over (useEntryFieldsPanel) now leave out the fields a plugin's tab takes over, as the edit page's own content does.
    More

    Such a field was drawn twice: in its tab and in the surface's panel.

  • A database's first nextly migrate on this release writes a registry record once, naming the newest applied app migration or the point before any, decided from the database and the migrations folder alone so a run that stopped part-way is finished by the next.
    More

    Where no migration's snapshot carries the registry metadata, it applies the pending migrations, then writes the registry rows from the configuration it runs with (saying how many), adds the permissions and sets the preset grants, and writes the record with those rows and the live permissions kept as the registry baseline, all in one transaction. Where a pending migration carries the metadata, the record and the baseline (the registry as it stands) commit just before it applies. Where an applied one already carries it, the rows from its snapshot, the permissions, the grants and the record commit in one transaction before anything applies. Once the record exists, the rows come only from the migrations. A pending migration written by an earlier release's migrate:create is refused, naming it, when it comes after one that carries the metadata or after the record. A migrate:create for a configuration declaring no collection, Single or field group now records that it declares none, so its migration applies after the registry record instead of being refused.

  • The page builder's font catalogue no longer leaves its popularity read running when a daily refresh of the font list fails: the editor is answered with the last good catalogue once both reads have finished.
  • The Form Builder adds a field through the shared field picker (search, then a label that names the field) and edits it in the shared settings panel, docked beside the list on a wide window and opened in the field's card on a narrow one.
    More

    The panel is configured for forms: a dropdown's and radio group's choices, a checkbox as one yes or no, the form's own settings for text areas, files, dates, numbers and hidden fields, only the validation rules a form's checks enforce, and the form's own show-or-hide conditions. A saved field's type is shown fixed, with the reason. Every setting a form stores is kept through an edit, and Move up, Move down, drag, Duplicate and the refusal to delete a referenced field are unchanged. AddFieldDialog and FieldEditor are no longer exported from @nextlyhq/plugin-form-builder/admin: they were the builder's own parts, and the shared FieldPicker and FieldSettingsPanel from @nextlyhq/plugin-sdk/admin replace them.

  • The form editor now sits in the admin's frame, with one bar and one header. - Its controls are in the admin's top bar, after the breadcrumb: the form's status as a menu (Live, Closed or Draft), the save state with Undo, the number of submissions (a link to the form's Submissions), More (Copy form ID, Delete form) and Save. - The header shows the form's name, its field count and API path, and a tab for each page: Builder, Preview, Settings, Notifications and Submissions. - Each page has its own address under the form's edit address (/admin/collections/forms/<id>/settings, and so on), so a reload or a shared link opens the same page.
    More

    The edit address opens Builder. - One save for the whole form. Changes on every page are held together, counted in the bar, can be undone one at a time, and are saved once. Moving between pages keeps them, and leaving the form with any asks first. A refused save keeps them and says what to fix, with a link to the page that holds it. - The Forms panel starts folded on the form editor; the bar's toggle brings it back. - The editor's own heading, the name, slug and status box, and the footer are gone. The name and the form ID are edited in Settings, which also holds the closed message once the form is closed. - A new form, once created, stays open in the editor at its own address instead of returning to the list.

    For plugin authors (@experimental): a collection's custom edit view can have pages of its own. Declare a document view on the collection whose component is the edit view itself; the admin draws the edit view at that address, passes the page's path as the new view prop of CustomEditViewProps, and keeps it mounted while the address moves between its pages. A custom edit view can now also report unsaved work with useReportUnsavedWork, and the admin asks before leaving the document while it holds any.

  • Form Builder notifications are queued through the queued email send once a submission is saved, instead of being sent once: the first attempt is made at once, and a failure a retry can help is tried again through the job queue until it is sent or fails for good, so a provider outage no longer loses a form's emails.
    More

    Every notification setting is kept (provider, sender, static or field recipients, cc, bcc, reply-to, condition, template, attachments), the form-builder.beforeEmail filter still runs once before queueing, and each email carries its own idempotency key, from its submission, its place and its notification. Retries need the jobs trigger (POST /admin/api/jobs/run) to run. A queued email that fails for good is now logged with its reason (queued-email-failed, with its queuedId), so the Form Builder's own failure line can be matched to why.

  • Form bot checks are verified on the server.
    More

    A form's bot check (Site default, Off, Google reCAPTCHA v3 or the new Cloudflare Turnstile) sends its token inside data as g-recaptcha-response or cf-turnstile-response, and the token is checked with the provider before the submission is accepted, wherever it is written. Keys go in the plugin's spamProtection.recaptcha / spamProtection.turnstile options, which are validated at start. - A token that fails, or a missing one, stores the submission flagged as spam. - A provider that cannot be reached leaves it unchecked, and logs a warning. - A form whose check has no secret key keeps accepting submissions unchecked, with a start-up warning and a note in Settings. Settings no longer lets a check without keys be newly chosen. - Settings shows the plugin's rate limit, read-only. - The public form read gives a visitor's form botCheck: { provider, siteKey, field } to render the widget with.

    Forms saved before keep their protection. The previously unused recaptcha option of checkSpam's config is deprecated, and SpamCheckResult.reason gains "turnstile".

  • A form can close by itself on a date, or once it has a number of submissions.
    More

    Both are set in Settings › Availability. Past either, a submission is refused with the form's closed message, the one it gives when closed by hand, and GET /api/forms/:slug answers as for a closed form. Spam does not count towards the limit. Submissions racing for the last place cannot take more than there are: the limit is held inside the transaction that stores a submission, whatever stores it.

  • A form's notification rules, which name the addresses each submission is emailed to, are no longer returned to visitors by the public form endpoints (GET /api/forms and GET /api/forms/:slug) or to staff who can only read forms.
    More

    Staff who can update forms and super-admins still read them, and submissions still send every notification. The form's internal note follows the same rule, and super-admins now read it too.

  • The form builder's fields are one outline, with the selected field's settings docked at the window's edge. - One row per field: its label, its type and stored name, and badges for what you would otherwise open it to see (Required, a width other than full, "Shown if…" with the fields its condition reads, and its default, by the choice's label). - The settings panel docks as a column against the window's right edge, as tall as the window, from 1024px wide; below that it opens under the row. - Add a field where it belongs: from the toolbar, from "Add here" between two rows, or with "/" on a row, which adds it below. - A saved field's name is fixed, with the reason, as its type already was: its answers are stored under it. - A rename finished after visiting another page of the form still moves what refers to the field (conditions, notifications), even when the name was cleared on the way. - Every submission's own stored values (submitted at, status, notes, IP address and browser) are named under the list.
    More

    For plugin authors: FieldCards' onAddField callback gains an optional third argument, the place in the list a field was asked for; generateFieldName now lives in its own module and is still exported from the same place.

  • Settings offers one response per email address, comparing a chosen Email field that must be required and not hidden by a condition.
    More

    The builder will not delete that field, make it optional or give it a condition while it is chosen, saying why each time, and an Email field can be chosen from its own panel. Saving a form through any door is refused when its one response per email has no such field. A field renamed before it is saved keeps the choice.

  • Forms can take one response per browser.
    More

    The form's script keeps a random token in the visitor's browser and sends it as the nextly-browser-token answer; the server keys it with the plugin's keyed digest, never stores the token, and refuses a second response from the same browser atomically. The public read of a form that compares browsers names the answer to send the token in (oneResponse). A submission without a token is accepted unchecked, with a warning. Settings offers "One per browser".

  • One response per person is held by the database.
    More

    A form that takes one response per network (IP address), or per email address with a chosen Email field (compared ignoring case), stores a keyed one-way digest beside each non-spam submission, never a second copy of the address. A unique index on the form and the digest refuses a second submission with the same value, even when several arrive at once. The digest is made by the plugin wherever a submission is written, and is never taken from the caller. A form that allowed one submission per IP before this change still refuses a network that submitted then.

    Existing installations receive the new responseKey column and its unique index on the submissions collection through their own migrations: run nextly migrate:create and then nextly migrate (or nextly db:sync in development).

  • Changing a form's one-response setting now counts its earlier submissions.
    More

    Keys carry the form's one-response version, which a change of mode or Email field moves on, so earlier keys stop matching at once. A form with up to oneResponse.keysInSave submissions (default 200) gets keys for the new version inside the save; a larger one is finished by a sweep (form-builder:one-response-keys), and until then a new submission is compared with the earlier ones directly. The earliest of several with one value keeps it, and when the holder is deleted, marked spam or edited, the next earliest takes it. A key made for a version the form has since left is refused where it is stored. The form editor saves on through a revision moved on only by the plugin's own record that keys are made.

  • A form's Preview runs the form as a visitor meets it. - The site's own checks: a submission in the preview is refused for exactly what the site refuses (a malformed email address, a length or number limit, a required answer left empty), checked over the fields a visitor sees, with the reason under each field. - Show hidden fields shows hidden fields and fields a condition hides, each saying why it is hidden. - Desktop and Phone widths, and Reset, in the preview's toolbar. - Submitting shows what the visitor would see next (the message, or where they would be sent), and saves and sends nothing, as the note under the preview says.
    More

    Fix: a submission is no longer refused for leaving empty a required field that a condition hides. The field was never on the visitor's page, so such a form could not be sent at all. Only the fields a visitor is shown are checked; what is stored is unchanged. The site and the preview decide which fields a condition hides with one shared function.

  • A form can stop keeping the IP address and browser of new submissions (Settings › Privacy › Store IP address and browser).
    More

    One per network still works on such a form, by the keyed digest made before the address is dropped, and the builder's note on what every submission stores says what the form keeps.

  • Form settings are one page in sections: Form, After someone submits, Availability, One response per person and Spam protection.
    More

    The form ID is fixed once the form has been live, a form can carry an internal note that only people who manage forms can read, and the closed message is always at hand in Availability. Settings now stores oneResponse and botCheck in place of allowMultipleSubmissions and captchaEnabled; forms saved with the old keys read as before, and the old keys are still accepted. The per-form reCAPTCHA site key is no longer offered, since a key works only with the site-wide secret.

  • On a form taking one response per email, an edit that moves a submission onto an address another submission already holds is refused with a message naming that submission to a person who may read it, and saying only that the address is already used to anyone else.
  • Generated types now know the site's languages.
    More

    Where the configuration declares them, generate:types lists them exactly, and a read's locale and fallbackLocale take only those codes (or "all"); where admins manage languages in Settings, any code is accepted and checked at run time. Locale and LocaleOption are exported for typing your own values (experimental).

  • Nextly loads less at start.
    More

    The version comparison engine, the terminal prompt for column renames, the listing of every page's public address and the route handler's configuration load only when a request or a config reload uses them, and the CLI's migrate:fresh and users:create-admin load the database seeders only when they seed.

  • A plugin that can finish a login now needs the app's listing as well as its own declaration.
    More

    An enabled plugin that declares capabilities.auth.login — or contributes a determineUser auth hook, which decides who is signed in — without being listed in auth.loginPlugins refuses to start, naming the plugin and the auth: { loginPlugins: [...] } line to add. A disabled plugin is not checked, and a listed name that matches no installed plugin grants nothing while boot warns about it. ctx.auth.completeLogin answers to the verdict the boot decided, not to a manifest a plugin edits after it starts: flipping the capability on, or renaming itself onto a listed plugin, grants nothing. Apps that already list their login plugins in defineConfig({ auth: { loginPlugins } }) are unaffected; an app whose login plugin only declared the capability now adds the listing to nextly.config.ts.

  • nextly migrate:create no longer writes the drop of a field group or Single something still depends on.
    More

    A field group whose table was named through the dbName it once accepted is recognised by its table's columns. When a field group or Single is removed from the configuration while a remaining field still places the field group, a plugin or the app declares a foreign key to its table, or a plugin or the app adds a column or index to it, or a foreign key points at its translation table, the command refuses with the message a delete gets, naming each with its owner, before it writes anything. A plugin hook that still extends a removed field group's or Single's table is named with what it adds, where the command used to stop with "Validation failed.". A collection, Single or field group sharing a slug and removed together is each named with its own dependents, the later one with its kind, as seo (field group).

  • nextly migrate checks each pending file's renames before the run's first statement: a file that renames a column or a table onto one that is already there, while the one it renames still is, is refused, naming the file, the table and both names, and nothing of the run is applied.
    More

    Before, the database refused the rename only when it ran, and on MySQL, which commits each schema statement as it runs, the statements of the file before it stayed applied. migrate --dry-run names the refusal. A rename after another change to the same table in the run is left to the runner's failure, as before.

  • nextly migrate now writes the registry rows of collections, Singles and field groups from the migrations, under the schema lock, after its migrations apply.
    More

    Each row is brought to the newest applied snapshot that records every entity's declaration, whether the entity is defined in code, in the Schema Builder or by a plugin, and a row that already matches is not written. A field added in code therefore reaches the registry when nextly migrate ends, before any start. Rows of entities that snapshot does not record, and fields the running configuration lacks, are left as they are; a run whose later migration fails still writes the rows of the ones that applied. A snapshot written before declarations were recorded is read as saying nothing, so it rewrites no row. The development boot keeps inserting only missing rows, since its start keeps them in step with the code.

    A field group whose label, description or admin options alone change now has that change written, as collections and Singles already did; a description or admin block the declaration no longer has is cleared.

  • Making a field required, or renaming one, on MySQL now migrates with the right checks.
    More

    nextly migrate:create writes these changes as a prepared statement built from the live column, and nextly migrate used to read that as a statement that could delete anything: it refused unless you passed a blanket --accept-data-loss, and it never checked for rows with no value before making the column required. nextly migrate now reads the prepared statement as the change it makes. A rename needs no consent. Making a column required asks consent for that column only (--accept-data-loss=<table>.<column>), and is refused before anything runs while any row holds no value in it.

  • Forms now bring two starter emails to Settings › Email: "Form submission", which lists every answer by its label for your team, and "Form confirmation", which confirms to the visitor that their submission arrived.
    More

    A new notification starts on the team's email, and switches to the confirmation when it is sent to the visitor, so a new form sends from its first submission instead of waiting for someone to write an email. Templates also receive _submission.answers: each answer's label and value, a choice by its option's label, leaving out questions left blank or hidden by a condition. A submitted field's own value is never replaced by these variables.

    A notification saved earlier without an email keeps sending nothing until you choose one: its editor now offers the matching starter in one press.

  • Creating something starts from one plain list.
    More

    The admin's New menu lists every content type you can create, once each, in the order the sidebar shows them, with a search box that always takes focus. It has no recent-types section, no group headings and no type name on its button, and the highlighted row is a light fill with a thin border that stays visible under any brand colour. The dashboard's New split button and the per-person "last type" it remembered are gone.

  • nextly migrate now adds the permissions and roles a database lacks and sets the preset roles' grants, under the schema lock, once its migrations and registry rows are in place.
    More

    It adds Nextly's own permissions, each collection's and Single's (an attached workflow's included), the ones the config declares and each plugin's, and the roles plugins declare (a role waits until every permission it bundles exists), then brings Admin, Editor, Author and Viewer to what their presets grant by difference. A database set up by nextly migrate alone now has an Admin role holding every permission its preset grants before any start, a grant it changes expires every cached content read on running instances, and a run with nothing to add or change writes nothing to the permission, role or grant tables. The run marks no permission as undeclared, and a start still seeds as before. nextly upgrade's conversion of roles holding a retired manage permission now expires those cached content reads too.

  • A page with no panel (the dashboard, Releases, Translations) no longer holds an empty 256px column beside the admin's icon rail; its content starts at the rail.
    More

    A page whose section has a panel (Content, Media, Settings, a plugin's own section) still reserves it from the first paint, decided from the route, so nothing shifts while the panel's links load. Moving between the two moves the content once, as part of the navigation.

    A page can now ask for its panel to start folded away with useFoldedPanel(key): the rail stays, a panel toggle appears at the left end of the top bar, and each reader's choice is remembered for that page.

  • Every admin user now has a "For you" section in the bell: their own notices, newest first, each linked to what it is about, with the unread count on the bell.
    More

    The notices shown are marked read once seen, and "Mark all read" clears the rest. The schema-change journal stays below it, for super-admins only.

    While any release is stopped or overdue, a strip at the top of the Releases page names the first few, each linked to its page with its state, says how many there are in all, and links to the Needs attention tab. On the dashboard, the Needs your attention card now names the stopped and overdue releases under their rows, each linked to its page.

  • nextly migrate and every other migration command now ignore the .sql files an earlier Schema Builder wrote into your migrations folder, where nextly migrate used to refuse them, or, at a development start, apply them as written.
    More

    A file is ignored only when it carries the whole signature the Builder left: a name like 1730000000000_create_posts.sql (13 digits, then create, update, i18n, status or drop, then the entity's name), no snapshot beside it in meta/, none of the lines migrate:create writes (-- UP, -- DOWN, -- Collections: and the other entity headers), and statements that change only that entity's own tables, or its own registry row. Such a file is never applied, listed, counted or compared, and its ledger rows play no part in any check.

    • nextly migrate, the boot migrate step, nextly migrate --dry-run, migrate:check and migrate:status name each ignored file with "ignored: written by an earlier Schema Builder". It is information: the exit code is what it would be without the file. migrate:status --json lists them in a new ignoredOldBuilderFiles field and writes the line to standard error, so standard output holds only the document.
    • A delete the Builder wrote for several collections, <13 digits>_drop_<N>_collections_<hash>.sql, is ignored only when every statement is a DROP TABLE of a Builder collection's table; the same holds for a single collection's, a field group's and the user-field table's drop files.
    • The first nextly migrate of this release records, for each ignored file a ledger row names, that the row is an old Builder file's, with the file's checksum. A file edited later within the signature has its new checksum recorded.
    • If such a marked file later stops carrying the signature, every command refuses before changing anything: with exit code 2 (MIGRATION_TAMPERED) where its content changed, or with the new code OLD_BUILDER_FILE_SNAPSHOT_ADDED where a snapshot now stands beside it. Put the file back, remove the snapshot, delete the file, or accept it with nextly migrate:resolve --applied <file>, which withdraws the record.
    • A file with the Builder's name and no snapshot that does not carry the rest of the signature, for example one that changes another collection's table or a table nothing declares, is still refused, with BUILDER_MIGRATION_SNAPSHOT_MISSING: the refusal now names the part of the signature it lacks, and the fix is to replace it with the migration nextly migrate:create writes, or to delete it.

    Before upgrading:

    • Keep the old Builder files in your migrations folder until the first nextly migrate of this release has run: that run records which ledger rows are theirs. You can delete them after it.
    • nextly migrate --dry-run or nextly migrate:check names any file with a Builder name that is not recognised as an earlier Builder's, with the part of the signature it lacks. Without a snapshot it is refused, as before; replace it with the migration nextly migrate:create writes, or delete it.
  • The field-UI parts @nextlyhq/plugin-sdk/admin has exported for building field editors are deprecated, each naming what replaces it: - FieldTypePicker and FieldTypePickerProps: use FieldPicker. - usePluginFieldTypeEntries: use FieldPicker, whose config.surface joins that surface's plugin field types to the picker. - FieldOptionsEditor, withOptionIds, FieldOption, FieldOptionsEditorProps, FieldDefaultValueInput, FieldDefaultValueInputProps, FieldDefaultOption, ConditionRow, ConditionRowProps, operatorsForType, operatorTakesValue, ConditionOperatorName, ConditionRange, ConditionSource, ConditionSourceOption, ConditionValue, ValidationNumberField, ValidationNumberFieldProps, ValidationRulesEditor, ValidationRulesEditorProps, ValidationRuleValues, drawsAnyValidationRule and EDITABLE_VALIDATION_RULES: use FieldSettingsPanel.
    More

    They keep working unchanged, with the same props, until they are removed. Removed no earlier than 0.0.2-alpha.75, and only once the Form Builder and user custom fields use the shared picker and panel. The deprecation is in the published type declarations, so an editor marks each use; nothing is logged at run time.

  • One command adds a plugin to a site: nextly plugins add <package> (also nextly add <package>) installs the package, registers it in nextly.config.ts, adds its nextly plugins install step to the build after nextly migrate, runs nextly generate:types and applies its schema; on a database not migrated yet, the schema is left to the build.
    More

    A package says how it is registered in its package.json under nextly.plugin (the export, whether it is called, and the options its install asks for); one that declares nothing is registered by the plugin definition its entry exports. Options are given as --option <name>=<value> or asked for in a terminal, and a run without one in a script is refused, naming the flag. Nextly packages named without a version install at the version of nextly the site has. --dry-run names every change and makes none, and a second run changes nothing. Six new error codes cover what it refuses: PLUGIN_PACKAGE_NOT_INSTALLED, PLUGIN_DECLARATION_INVALID, PLUGIN_REGISTRATION_UNKNOWN, PLUGIN_OPTION_MISSING, PLUGIN_OPTION_INVALID and PLUGIN_CONFIG_NOT_EDITABLE.

  • The Schema Builder edits a field in one settings panel, docked beside the field list (a sheet on a narrow screen).
    More

    It is the same panel for a field just added and one that already existed, with five tabs: General, Validation, Display, Conditions and Advanced. The settings that make a field its type come first in General: a dropdown's options, a link's collection, a field group's choice, an upload's files, a Blocks field's accepted blocks. Width is in General and offers every stored width (25, 33, 50, 66, 75 and 100 per cent), and each field shows the path the API returns it by, such as authors[].social[].url.

    There is no Apply step any more: each change is kept in the Builder's unsaved changes the moment it is made, so switching to another field keeps it, and Save works as before. Deleting a field from the panel still asks first.

    A saved field's name no longer follows its label. Relabelling "Summary" as "Excerpt" used to rename the column and ask at save whether to rename or drop it; now the name, the column and the API key stay as they are, and the save has no schema change to review. A field added since the last save still takes its name from its label.

    Fixes in the same panel:

    • A Blocks field has settings: the blocks it accepts and the kinds of document it holds, typed as names (such as core/*).
    • A field of a plugin's type always shows the settings every field has, and says it has none of its own.
    • Changing a Blocks field's accepted blocks, or a plugin type's own options, now counts as an unsaved change, so Save is enabled.
    • Switching a field-group field between Single and Dynamic zone now changes it; before, the second of its two writes undid the first.
    • The type editors' switches, inputs and choices now have accessible names, and the chosen layout, appearance or mode is announced as chosen.

    @nextlyhq/plugin-sdk/admin adds FieldSettingsPanel with FieldSettingsPanelProps, FieldSettingsSurface, FieldSettingsField, FieldSettingsControlProps, FieldSettingsSurfaceControlProps, FieldSettingsTab, FieldTypeSettings and FixedFieldSetting, all @experimental. A surface configures the panel (its plugin types, how a label becomes a name, the settings it fixes and why, its own settings by tab, its conditions) and stores each change itself; the panel writes nothing. The existing field-UI exports are unchanged.

  • The admin draws one top bar, 56px tall at every width.
    More

    Each page's breadcrumb is in it, and on a bar narrower than 600px it shortens to a back link named by the parent page. Below 1024px the bar holds the menu button that opens the navigation drawer, so a phone gets one bar instead of two. A page can put its own actions at the bar's right end. The bar's height is the CSS variable --admin-bar-height on .nextly-admin, which the editors and full-height pages read.

  • A plugin can add to another plugin's admin place when that plugin is installed, and still start without it.
    More

    A contribution to a place owned by a plugin named in the contributor's optionalDependsOn is left out while that plugin is absent or disabled, instead of stopping the app with admin-place-unknown. A place the running owner does not declare, or one of a plugin the contributor does not name, is still refused.

> 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.75.

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.