0.0.2-alpha.75
- The server no longer waits for Nextly to start before it answers requests.
- One command adds a plugin to a site: nextly plugins add installs the package, registers it in nextly.config.ts and applies its schema.
- The admin is served as not listable by search engines, with or without a plugin that manages search.
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,uniqueorhasManysetting, 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
dbNamemoves it to a table that is already there is refused at start and bydb: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.findComponentReferencesis 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:createfile makes now agree.More
The first Builder save of a field group used to drop the
_order,created_atandupdated_atdefaults and add acreated_atindex. On MySQL a save could also turn a text field'stextcolumn intovarchar(255), which MySQL refuses once a value is longer, andcreated_at/updated_atfromdatetimeintotimestamp. - 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 thecreated_atindex with its next save. -migrate:createdescribes a Builder Single's or field group's table as the Builder made it, so on MySQL its unbounded text staystext. - On MySQL a migration that sets a column's default to a function, such asCURRENT_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,stockCountandmaxPerLinereported 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 throughdb: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:creategenerates. - 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 bylogNotFoundfrom the site's not-found page.addressOfRequest(url)fromnextlyand@nextlyhq/plugin-sdkanswers 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 (designMetadataForfrom@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, andtypesWithoutAddress()lists the types with none yet. A type made in the Schema Builder has its address supplied by a plugin through thepublicAddress.templatefilter, 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.extendtakes 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.typesReachedByand theContentTypeScopetype (@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-metadatacapability and contributes apageMetadataresolver, and the content, Single and Page Builder routes ask it for each page with no change to the site's routes. A route's ownbuildMetadatabecomes one input: its title, description and social values are used where nobody set one, and itsrobotsand 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 installnow 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, asnextly migratefrom 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 migratefollows, 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 ownerapp, for those of a plugin namedapp. Anextly migraterun 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, andset(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),
setwrites nothing and answersfalse.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 answernull. - Exported from@nextlyhq/plugin-sdk/adminwithDocumentField. - 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_ENVset todevelopment). Runnextly migratebefore 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_rulescolumn of the registry tables, which this release no longer enforces, and still refuses a database laid out for the other choice ofexperimental.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
withNextlynames (passmigrationsDirtowithNextlyif you changeddb.migrationsDir) andinstrumentation.tshands tocreateRegisterasbuildSchemaVersion: process.env.NEXTLY_BUILD_SCHEMA_VERSION, so it reaches Nextly on Vercel and withoutput: "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-updatesbesideteam_updatesreads 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_TAKENnaming 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_TAKENnaming 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 friendlylabel, anexample, and for a list or an object itsfields.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 (
exceptin acontributes.extendscope) 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:createandnextly migrate:checkkeep 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=cappedfor the same count. With more than 1,000 matches,meta.totalis1000and the newmeta.totalCappedistrue. Without the parameter, or withcount=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
numberfield 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
numberfield used to store 2.5 correctly, and after this change the same write is a 400 validation refusal. Remedy: declaredbType: "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/meand 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 theaccountplace, around itsprofilecard. - A person's own profile change through/me(and the Direct API'supdateMe) 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"(orafter: "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 areplaces: "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
TargetSlotandPlaceTabsfrom@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) andeditor(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 receivesSidebarSectionProps(new, from@nextlyhq/plugin-sdk/admin): the place'scontextandentry, and on a collection entry's page also every field ofDocumentPanelSectionProps, 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. -PlaceTabstakes an optionalclassNamefor 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
toolbarandtable, 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. - Afieldcolumn 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
visibleWhenholds 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/configexportsMAX_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:
Skeletontakes astillprop 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=offto 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 throughdevicePreferenceStorefrom@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;userPreferenceStorefrom@nextlyhq/builder/shelltakes an optional opener for such a store. The startup request's answer now carriesX-Nextly-Device-Memory,X-Nextly-Schema-VersionandX-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.
SheetContentfrom@nextlyhq/uigains adragHandleprop 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.configis read from the page itself when the admin route carries it (a#nextly-admin-brandingJSON 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
titleorsluginside 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:createwould write for that collection into your migrations folder (db.migrationsDir), after recording its whole definition indb.uiSchemaFile.More
In development the save runs that file the way
nextly migratedoes and records it applied with its checksum, sonextly migrateandmigrate:createhave nothing left to do. Outside development the save writes the definition, the file and the snapshot, runs nothing, and the deploy'snextly migrateapplies 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 throughupdateCollection, and a delete, whether made in the admin, through a plugin'sctx.services.collections, or through theCollectionsHandler. Nothing is written tosrc/db/migrations/dynamicany more. Files an earlier version wrote there are not read; delete the folder once you no longer need it. - A save first runs the checksnextly migrateruns before it writes anything. While an applied migration file is edited or missing, or an attempt is unfinished, the save is refused withNEXTLY_MIGRATION_HISTORY_REFUSED(409) and the textnextly migrateprints, 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, andnextly migrateasks 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 throughupdateCollection, 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:createnow 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:createdescribes a Builder collection's columns as the Builder creates them: on MySQL a text field isTEXT, as the Builder has always made it, in its table and in its translations table, where a code-first collection's isvarchar(255). A project that already ranmigrate:createon Builder collections gets a one-time migration widening those columns fromvarchar(255)toTEXT;nextly migrateapplies it without asking for--accept-data-loss, since a widening deletes nothing. -nextly migrateand the other commands that ask consent before deleting data no longer ask it for a string column widened:varchar(n)totextor to avarcharat 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,texttovarchar, 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 asTEXT), a<timestamp>_<slug>_convert.sqlconverts 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 asacknowledgedConversions, and is otherwise refused withNEXTLY_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 itsonDeleteandonUpdate, 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, somigrate:checkreports 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 fornextly migrate:resolve, withNEXTLY_MIGRATION_PARTIALLY_APPLIED. Where an earlier file of the save applied and a later one then failed, every file and the new definition stay, andnextly migrateruns the rest once the cause is fixed. - The definition file (ui-schema.json) now holds a field'soptionsexactly as the registry stores them, such as a relationship'starget,relationType,onDelete,onUpdateandjunctionTable, a text'svariantor a number'sformat, besiderelationToandhasMany, 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-losson deploy, as any such filemigrate:createwrites 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:createwrites 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 (aTEXTcolumn) 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/acceptedwith 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-enginenow exportsslotAdmits, its one reading of a block allow-list, which the blocks field's validator now uses too;@nextlyhq/builder/opsoffersfieldLabelandpropLabel(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,.updatedand.deleted) now arrive when the write commits, before itsafterCreate/afterUpdate/afterDeletehooks rather than after them: a listener that relied on the after-hooks having run should do that work in anafter*hook instead.More
A write made inside a caller's transaction (
createEntryInTransaction,updateEntryInTransaction,deleteEntryInTransaction), and each entry ofcreateEntries,updateEntriesanddeleteEntries, 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:typesand--checklist the components a collection names for its own screens: itsEditandListviews, 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, andnext devnames it. -registerKnownPluginis 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 withregisterComponentsin your plugin's admin module instead. The plugin template and the first-party plugins now do. - The generated map now registers throughregisterComponentMap(experimental, from@nextlyhq/admin). It registers likeregisterComponents, 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. Rerunnextly 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/nextexportsnextlyHtmlLimitedBots, for a Next config'shtmlLimitedBots.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.configsets it, andwithNextly()sets it where the app sets no list of its own. - An app made earlier adds two lines to itsnext.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/testingexports 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.hand thehin 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".
listEntriesandMAX_WIDGET_ROWS(now 20) are exported, experimental, fromnextlyand@nextlyhq/plugin-sdkfor widgets that list;rowsThatFitkeeps 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:
defineWidgetdeclarations are unchanged. A setting'ssection: "advanced"is still accepted and is drawn under Display;quickstill 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 exportedStatsCard's trend is a quiet chip with a coloured arrow, and the exportedContentStatusWidgetdraws Published and Draft in their status colours. The widget documentation recommends the status tokens andBadge'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'sSsl_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 gaininspectConnection(), 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:synctakes--dry-runin 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-runnames 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-orphanedadds the tables it would delete. -db:sync --promote <slug> --dry-runshows the snippet it would append and the registry row it would remove. -db:sync --demote <slug> --dry-runshows the registry record it would write. ---dry-runcannot be combined with--watch.Fixes:
db:sync --promoteof a collection defined in code is refused before it appends anything tonextly.config.ts; it used to append the snippet and then be refused.nextly migratestopped because a migration file changed after its deletions were judged now reads asPLAN_CHANGED_AFTER_CONSENTrather than an unexpected error.
nextly events reportandnextly events abandonclean 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 (
languageAddressesinnextly.config.ts), andlanguageAddressOf(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
PageFramefrom@nextlyhq/uidrawstype="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=siteorowner=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-basedpageas well asoffset, 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-Versionheader now carries that stored version, one number for every copy, rather than a count kept by each process.bumpSchemaVersion(fromnextly/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
ETagthat is a hash of the body sent, and answer304 Not Modifiedwith no body to a request whoseIf-None-Matchholds 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 anAuthorizationheader) is now markedprivate, no-storeand 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 bydefineConfig(), 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_DEPTHstays 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 migrateon 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:createis refused, naming it, when it comes after one that carries the metadata or after the record. Amigrate:createfor 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.
AddFieldDialogandFieldEditorare no longer exported from@nextlyhq/plugin-form-builder/admin: they were the builder's own parts, and the sharedFieldPickerandFieldSettingsPanelfrom@nextlyhq/plugin-sdk/adminreplace 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 whosecomponentis the edit view itself; the admin draws the edit view at that address, passes the page's path as the newviewprop ofCustomEditViewProps, and keeps it mounted while the address moves between its pages. A custom edit view can now also report unsaved work withuseReportUnsavedWork, 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.beforeEmailfilter 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 itsqueuedId), 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
dataasg-recaptcha-responseorcf-turnstile-response, and the token is checked with the provider before the submission is accepted, wherever it is written. Keys go in the plugin'sspamProtection.recaptcha/spamProtection.turnstileoptions, 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 formbotCheck: { provider, siteKey, field }to render the widget with.Forms saved before keep their protection. The previously unused
recaptchaoption ofcheckSpam's config is deprecated, andSpamCheckResult.reasongains"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/:sluganswers 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/formsandGET /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'onAddFieldcallback gains an optional third argument, the place in the list a field was asked for;generateFieldNamenow 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-tokenanswer; 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
responseKeycolumn and its unique index on the submissions collection through their own migrations: runnextly migrate:createand thennextly migrate(ornextly db:syncin 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.keysInSavesubmissions (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
oneResponseandbotCheckin place ofallowMultipleSubmissionsandcaptchaEnabled; 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:typeslists them exactly, and a read'slocaleandfallbackLocaletake only those codes (or"all"); where admins manage languages in Settings, any code is accepted and checked at run time.LocaleandLocaleOptionare 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:freshandusers:create-adminload 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 adetermineUserauth hook, which decides who is signed in — without being listed inauth.loginPluginsrefuses to start, naming the plugin and theauth: { 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.completeLoginanswers 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 indefineConfig({ auth: { loginPlugins } })are unaffected; an app whose login plugin only declared the capability now adds the listing tonextly.config.ts. nextly migrate:createno longer writes the drop of a field group or Single something still depends on.More
A field group whose table was named through the
dbNameit 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, asseo (field group).nextly migratechecks 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-runnames the refusal. A rename after another change to the same table in the run is left to the runner's failure, as before.nextly migratenow 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 migrateends, 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:createwrites these changes as a prepared statement built from the live column, andnextly migrateused 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 migratenow 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 migratenow 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 migratealone 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 migrateand every other migration command now ignore the.sqlfiles an earlier Schema Builder wrote into your migrations folder, wherenextly migrateused 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, thencreate,update,i18n,statusordrop, then the entity's name), no snapshot beside it inmeta/, none of the linesmigrate:createwrites (-- 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:checkandmigrate:statusname 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 --jsonlists them in a newignoredOldBuilderFilesfield 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 aDROP TABLEof 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 migrateof 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 codeOLD_BUILDER_FILE_SNAPSHOT_ADDEDwhere a snapshot now stands beside it. Put the file back, remove the snapshot, delete the file, or accept it withnextly 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 migrationnextly migrate:createwrites, or to delete it.
Before upgrading:
- Keep the old Builder files in your migrations folder until the first
nextly migrateof this release has run: that run records which ledger rows are theirs. You can delete them after it. nextly migrate --dry-runornextly migrate:checknames 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 migrationnextly migrate:createwrites, or delete it.
- The field-UI parts
@nextlyhq/plugin-sdk/adminhas exported for building field editors are deprecated, each naming what replaces it: -FieldTypePickerandFieldTypePickerProps: useFieldPicker. -usePluginFieldTypeEntries: useFieldPicker, whoseconfig.surfacejoins 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,drawsAnyValidationRuleandEDITABLE_VALIDATION_RULES: useFieldSettingsPanel.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>(alsonextly add <package>) installs the package, registers it innextly.config.ts, adds itsnextly plugins installstep to the build afternextly migrate, runsnextly generate:typesand 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 ofnextlythe site has.--dry-runnames 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_INVALIDandPLUGIN_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/adminaddsFieldSettingsPanelwithFieldSettingsPanelProps,FieldSettingsSurface,FieldSettingsField,FieldSettingsControlProps,FieldSettingsSurfaceControlProps,FieldSettingsTab,FieldTypeSettingsandFixedFieldSetting, 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. - A Blocks field has settings: the blocks it accepts and the kinds of document it holds, typed as names (such as
- 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-heighton.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
optionalDependsOnis left out while that plugin is absent or disabled, instead of stopping the app withadmin-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/uicreate-nextly-appnextly
Earlier releases
Releases before 0.0.2-alpha.66 are listed in Nextly's changelog on GitHub.