Skip to content

v0.0.2-alpha.76

Pre-release
Pre-release

Choose a tag to compare

@mobeenabdullah mobeenabdullah released this 13 Nov 20:36
· 2023 commits to dev since this release
ef1e82a

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

What's changed

Patch Changes

  • #4053 d283cb3 Thanks @nextly-agent! - A blog scaffolded with the code-first approach now gets its first migration written from its own config. Once the dependencies are installed, the CLI runs nextly migrate:create initial for the database you chose, so the build's nextly migrate creates every table the blog reads, the form-builder plugin's included. Before, the scaffold copied the visual blog's hand-written SQL to a folder the code-first config never read, so the build migrated nothing. With --skip-install, the next steps name the command to run after installing. A visual blog still gets the template's migration.

  • #4193 aba11f0 Thanks @mobeenabdullah! - On MySQL, db:sync and the dev reload keep a code-first field group's text column at the width they narrow it to. A text field that states no width is varchar(255) in a field group defined in code, as the sync plans it, but the table handed to the push described it as TEXT, so every sync narrowed the column and the push widened it straight back.

  • #4045 4a60f0c Thanks @nextly-agent! - A nextly migrate run in development mode, which is how it runs when NODE_ENV is not set, now writes the registry rows its migrations record. On a fresh database it adds every collection, Single and field group row the newest applied snapshot records, and it brings the row of each entity an applied migration changed to that migration's record, on a later run too when the run that applied it could not write the row. Before, it added only the rows an older template-shaped snapshot listed, so a site migrated with migrate:create files had no registry rows until a development start synced them. Rows a live sync edited with no migration for the edit are still left as they are.

    A run in any mode also adds the rows a template's older-format snapshot lists (the blog template's hand-written migration), where the registry lacks them. Outside development such a snapshot was read as unreadable, so a site built from it got none of those rows from nextly migrate. A snapshot that cannot be read for another reason is still refused.

  • #3895 6f12301 Thanks @aqib-rx! - A development start ensures each permission once, and skips the entities that have not changed since the last one. A start used to ensure every collection's and Single's permissions twice, one statement at a time, and read every content table's shape on each restart; an unchanged start with 50 collections sent 2,836 statements. Now the permissions are ensured once, against one read of the table, and a development start reads the tables of only the collections, Singles and field groups whose declaration changed since the last development start, as recorded in nextly_meta; a restart with nothing changed writes no permissions, roles, registry rows or user field definitions, and sends the same number of statements whatever the number of entities. An upgrade of Nextly, a change of database, or a change to localization or experimental.perLanguageStorage makes the next start check everything again.

    Code-defined user fields are written only where they differ from what is stored: a configuration declaring none no longer deletes on every start and db:sync.

  • #3913 4bfd670 Thanks @zeshan-rx! - A field changing between translated and shared now keeps what every reader sees, and says so first.

    • The shared value is the one readers saw. When a field stops being translated, an entry's shared value comes from the default language where it's live; otherwise from the first live language in the site's language order; otherwise from the default language's draft; otherwise from the site's order. Previously an entry with no default-language value took the first language by code, which could be a draft no reader saw. Every other language's value is archived, and nextly i18n:restore brings it back.
    • The summary names whose page changes. The Schema Builder's preview counts what goes to the archive with the same rule, and lists the languages entries take their shared value from. A field becoming translated now has a summary too: how many values become the default language's.
    • Password and virtual fields can't be marked translatable. A configuration that sets localized: true on one is refused, naming the field; it was quietly stored as shared. The Schema Builder no longer offers the switch on a password field.
  • #4115 bb77364 Thanks @nextly-agent! - The form builder's start reads less. It no longer reads every form to warn about a bot check missing its keys: the site default's missing keys are still said at start, from the plugin's options alone, and a check a form names itself is said when that form is saved and when the first submission is accepted unchecked. A redirect target's localized setting is taken from the collection's declaration in the configuration instead of its registry row; only a collection made in the Schema Builder is still asked of the registry. An unchanged start sends one statement where it sent six.

  • #4022 3e08502 Thanks @zeshan-rx! - A held save under per-language storage hands its part drafts a language its types guarantee, never the shared slot. Behaviour is unchanged: the same value reaches the store, and check-types accepts it.

  • #4231 def1cad Thanks @mobeenabdullah! - A plugin's own item at the icon rail's foot no longer moves the rail as the admin finishes loading. The rail's foot is held to the bottom of the window, and the item was drawn inside the box that holds the Inbox and the account menu, so when the admin's answers arrived that box grew upwards by one item's height. The Inbox and the avatar stayed where their loading shapes stood, but the browser recorded the rail's foot as moving. The item now has a box of its own above the Inbox, which appears whole once the answers are in, so nothing already drawn on the rail moves. It looks the same as before: the item sits above the Inbox, in the same order and at the same spacing, and in the top bar (where a surface takes the rail away) nothing changes.

  • #4006 081277c Thanks @nextly-agent! - A plugin may no longer be named app. The site's own permissions are stored under the owner app, and a plugin's under its name, so a plugin with that name could not be told apart from the site: uninstalling it, nextly migrate or a migrate:down could take one's permissions for the other's. Startup and every CLI command now refuse a plugin named app, in any letter case, with PLUGIN_RESOLUTION_ERROR (logContext.reason plugin-name-reserved). Compatibility: a plugin named app stops the app from starting until it is renamed; apps, my-app and other names are unaffected.

  • #4046 3b3817b Thanks @zeshan-rx! - The SEO and Page Builder plugins' published types now carry the admin place they type. The Page Builder's Settings place (nextlyhq-plugin-page-builder.settings) was declared in AdminPlaces by a module augmentation that the build left out of every published declaration file. A project type-checking the installed plugins was then refused the place's name in the SEO plugin's Page Builder tab. Both plugins' declarations now include the augmentation, and nothing else changes.

  • #4050 9a4f3fe Thanks @nextly-agent! - A number in a plugin's panel now counts drafts too. A count declared as { collection, where } counts every entry the reader may open, drafts included, as the collection's own list shows them, where it counted published entries only. A where still narrows it, to drafts for one.

  • #4069 ea4dc01 Thanks @nextly-agent! - A production start no longer creates or changes a table. Every start used to create the tables its configuration declared and the database lacked (a collection's, a Single's, a field group's, a translated entity's translation table, the user fields' columns), rename a table whose dbName changed, add a plugin's field to a Schema Builder entity, create a missing PostgreSQL schema, and set up every table of an empty database, in production too and with no lock between cold starts. A production start now serves the structure nextly migrate made: a missing translation table answers that its translations are not ready, and a field the database lacks answers ENTITY_NOT_MIGRATED. A development start (next dev) is unchanged.

    A production start against a database with no Nextly tables, or without its configured PostgreSQL schema, creates nothing and refuses to start with NEXTLY_DATABASE_NOT_SET_UP, telling you to run nextly migrate. With db.runMigrationsOnBoot, the start runs that step first, which sets the database up as the command does.

    A changed dbName now needs a migration. nextly migrate:create writes it as a dropped table and a new one, so until it writes a table rename, replace those statements with a rename by hand, as the production migrations guide shows. A site whose production tables were made by its starts, with no migration for them, takes a baseline (nextly migrate:baseline) before upgrading.

  • #4095 8625cf2 Thanks @nextly-agent! - A production start waits on the database far fewer times. It read the Schema Builder's registries four or five times each, and asked the database's catalog the same questions from several steps, one after another (on SQLite once per field group), so a start against a database 100 ms away spent about 4.5 seconds waiting before Nextly served. It now reads the catalog and each registry once, sends the reads that need nothing else together, and runs the independent steps after them together: about 12 waits on PostgreSQL and MySQL and 18 statements on SQLite, the same for 5 entities and for 50, outside the migrations at start and the plugins' own start-up code.

    A production start no longer writes to nextly_meta to discard a setup token when none is stored, and the email templates' reconciliation no longer runs an update when no row needs it, so a start of a set-up site writes nothing of its own.

    Each plugin's own start-up time (its init and onReady) is logged at debug level after the plugins start, and a warning names every plugin whose start-up took longer than 500 ms, with its time: every cold start waits for it before Nextly serves.

    On SQLite, the catalog is read through SQLite's table-valued PRAGMA functions, a few statements whatever the number of tables, wherever Nextly reads it (migrations and nextly migrate:create included).

  • #4031 14fe629 Thanks @nextly-agent! - A production start no longer writes the registry, the permissions, the roles or their grants, or the user field definitions, and no longer marks an entity migrated. Every start used to write the registry rows of your collections, Singles and field groups from the configuration of the build that was starting, seed the permissions and preset grants before getNextly() resolved, and mark a plugin collection's table applied though it lacked the plugin's new column. So whichever build started last decided what the database said, an older one included, and a start ran a few statements for every collection, Single and permission. A production start now serves what nextly migrate (and a plugin's install and uninstall) wrote, and runs the same number of statements however many entities the site has. A development start (next dev) keeps its live sync, unchanged.

    nextly migrate now also makes the built-in Public role and grants it what visitors read: read-media, the read of each collection and Single whose read rule answers a visitor true, and what your plugins declare for it, each once. A plugin's install grants what that plugin declares. Before, only a start did this.

    Run nextly migrate before serving. The scaffolded build script already runs nextly migrate && next build; a deployment that relied on its start to bring a new field, collection or permission into the database must now run nextly migrate first. Until it does, a read or write that reaches a declared field the database has not been migrated for answers ENTITY_NOT_MIGRATED, naming the field to trusted server code. With db.runMigrationsOnBoot, the start runs nextly migrate first and gets the same.

    Moving production back to a Nextly release from before this one is outside this guarantee: such a release seeds the permissions and preset grants at every production start, from its own configuration and presets, and has no setting that turns that off.

  • #4113 be9d517 Thanks @nextly-agent! - The admin no longer sends a refused read a second time. A read the server answers with a 4xx status, such as 401 while signed out, 403, 404 or 422, is shown at once; a timeout (408), a rate limit (429), a server error (5xx) or a lost response is still sent once more. The signed-out sign-in screen asks for the general settings once rather than twice.

  • #4192 1700426 Thanks @mobeenabdullah! - A Builder save on MySQL that makes a field required while rows hold no value in it is again refused with its reason alone: nothing of it ran. MySQL writes that change as a statement built from the live column, which the save could not read a table from, so it reported the refusal as a migration that failed part-way, told you to settle it with nextly migrate:resolve, and kept the save's files. It now reads that statement as the column change it makes.

  • #4191 446e80b Thanks @mobeenabdullah! - Collections, Singles and field groups registered in the same second now list in one order on MySQL. MySQL keeps their creation time to the second, so entities a start registers together came back in whichever order the server sorted them that time: the setup card could list the Singles differently from one load to the next. Among entries created together, the registry now lists by slug.

  • #4148 c078251 Thanks @mobeenabdullah! - A field group renamed while another field takes its old name now keeps its stored values. When a site renames its own seo field group to legacySeo and adds the SEO plugin, whose seo group lands on the same types, in one change, nextly migrate:create now offers the rename (and --accept-renames accepts it), so the migration moves the group's rows to legacySeo and moves them back in its down step. Before, the old name still being in use hid the rename: the rows stayed under seo, where nothing reads them, and legacySeo read empty. A field group that changes which groups it holds, or whether it repeats, under the same name now counts as removed and added in the same way, in the Schema Builder too, so another field group renamed in the same save can take its rows.

  • #4021 3cd690b Thanks @zeshan-rx! - Breaking: a restore through the APIs writes the working draft and never publishes. Restoring
    a version through REST (POST …/versions/{n}/restore) no longer writes the live document or its
    status: the chosen fields (all of them by default, or the ones fields names) go into the drafts
    of the parts the version holds, and what readers see stays as it is until the draft is
    published. A collection or Single kept without drafts (versions: { drafts: false }, or no
    status) has no draft to write, so its restore is now refused with 422 BUSINESS_RULE_VIOLATION
    before anything changes. To put a version back live there, edit the values back, or turn drafts
    on and publish the restored draft.

    The Direct API gains nextly.versions (list, get, compare, name, restore,
    markSeen), and plugins gain ctx.services.versions.restore; both are experimental. Each
    restored value records the version it came from: a restore records its own, and a save names
    its restored fields in _restoredFrom. Retention keeps every version a recorded source names.

    Storage: the versions table gains a nullable field_sources column. nextly migrate and
    start-up add it to an existing database, with no migration file and no change to existing rows.

  • #4000 1399960 Thanks @nextly-agent! - nextly migrate:down now keeps the registry in step with the database once the database has its registry record. A rollback that brings the database back to the point that record was taken at undoes the rolled-back migrations' own changes to the bookkeeping, in the same transaction as the last migration it rolls back: each collection, Single and field group row goes back to how it stood when the record was written, the row of an entity those migrations added is removed and its permissions marked as no longer declared, a permission they added is marked the same way with its grants kept, and a permission they marked is declared again where that point declares it: the app's own, an entity's or Nextly's where the baseline holds it, and a plugin's where the plugin is installed and its current release declares it. What plugin installs and uninstalls wrote in the meantime, and Nextly's own permissions, stay as they are. A rollback that would leave the database at any other point where nothing records the registry (an earlier migration without the registry metadata, or the point before any app migration when the record is not there) is now refused before it changes anything, naming that point; write a new migration to undo the change instead. On MySQL, where schema statements commit as they run, a rollback whose bookkeeping cannot be written is left recorded as a failed rollback rather than as rolled back.

  • #3931 c3f076d Thanks @aqib-rx! - A run that can no longer show it holds the schema lock now stops. That covers nextly migrate, migrate:down, the boot migrate step, db:sync, the development push and the Schema Builder's saves. A run loses the lock when another run took it, or when the run stalled past its lease without confirming it. It then starts no further statement, writes nothing further to the migration ledger, and says it lost the lock, naming the last migration it applied.

    A run that takes over a lock whose holder stalled or was killed now first asks the database to stop each statement that holder sent which is still running (PostgreSQL and MySQL), and waits for them to end before it changes anything. If one is still running when the wait is over, the run gives the lock back and stops, naming the statement and its database session. A holder killed while a statement runs leaves a lock that lapses within one lease once no statement of it is running, so the next run proceeds without anyone unlocking it by hand.

  • #4128 b7ca686 Thanks @mobeenabdullah! - A save to a working draft that already exists keeps every translated value it sends. On a translated content type keeping drafts, the second and later saves of a draft dropped the translated fields they changed, a translated named group included, in every language, while the save reported success; the first save of the draft and field groups were not affected.

  • #4100 23d7e70 Thanks @nextly-agent! - The SEO plugin no longer rewrites its bookkeeping at every start. The start-up catch-up of the address record is skipped whenever the address templates, the site's content types and the pending moves are unchanged since its last run, including on a site where no page holds an address yet, and a run that finds a stored note already current leaves it as it is. The note that the site's Proxy runs is written only when the stored one is an hour old or more, so a server's first request after a start writes nothing within that hour.

  • #4072 df8eb70 Thanks @mobeenabdullah! - A Single read or saved for the first time by two requests at once no longer fails one of them. On a fresh site, the first page views reading a Single that has no document yet (such as a plugin's settings) could each try to create it, and on PostgreSQL and MySQL one failed with a duplicate key error. Exactly one document is now created, with its defaults, first version and "created" history event written once, and every request gets it.

  • #4032 42c694b Thanks @mobeenabdullah! - Sites that render their own pages now get the SEO plugin's head and structured data without workarounds.

    • singlePageMetadata and singlePageStructuredData (from nextly/runtime) answer a Single a site reads itself, as contentPageMetadata and contentPageStructuredData answer an entry. Both take the address the page was served at, so a later page of a Single's list (/blog/page/2) gets its own canonical; Single routes take the same address as a new path option.
    • seoStructuredData(path, options) (from @nextlyhq/plugin-seo) gives a page built in code its structured data from the same answer as seoMetadata.
    • jsonLdScriptProps(data) (from nextly/runtime) places structured data in a page, <script {...jsonLdScriptProps(data)} />, escaped so no value can end the element.
    • The plugin's title is served as title: { absolute }, so a root layout's title.template no longer adds the site name a second time. A route's own title keeps the form the route gave it.
    • A route's noindex (and nofollow) is kept: the route can hide a page, never list one the plugin hides, and a page built in code its route hides leaves the plugin's sitemap. Google's max-image-preview, max-snippet and max-video-preview limits and the route's other robots directives are kept.
    • A page the plugin gives no canonical, such as one whose type declares no public address, keeps the canonical and og:url its route set.
    • A page served before anything in its worker started Nextly (every read a cache hit, or prerendered by next build) now starts it and is served the plugin's answer, rather than silently its route's own head.
  • #4030 c7a8a45 Thanks @aqib-rx! - A run refused because an earlier holder's statement would not stop now names that statement's migration file and its database session, never the statement's text. The text could hold a literal value, such as a key, which no longer reaches the message or the logs.

  • #4056 1adc552 Thanks @nextly-agent! - A form submission's page keeps unsaved work safe. Answers or a note typed and
    not yet saved now hold the page, so moving to another submission or away asks
    first; answers typed while a save is on its way stay in the editor; a note
    draft is never saved over someone else's newer note; a failed refresh keeps
    the page and its drafts instead of replacing them with an error; and after a
    submission is deleted the page moves on without asking about it. Fields a
    site adds to submissions with formSubmissionOverrides.fields show, read-only,
    in the page's Details.

  • #4086 504266d Thanks @nextly-agent! - A write no longer reads the same registry rows again and again inside its transaction. Each collection's registry row is read from the database once per transaction and then answered from that transaction's own memo, which a registry or schema write in the same transaction, or a rollback to a savepoint, makes it read again; no other transaction ever sees it. An entry update that read dynamic_collections ten times now reads each collection once.

    Two start-up costs go too. A retention pass offered while its marker is current is now refused by one read, where it deleted nothing and then sent an insert the primary key refused, a failed statement in the database log for every pass each process offered. And a boot settles every email template's engine from one read of the engine marks, where each template read the meta table twice.

    DrizzleAdapter gains an experimental transactionInFlow(), which names the open transaction the calling flow runs in and says whether its part has rolled back to a savepoint.

  • #4078 d0c7b28 Thanks @nextly-agent! - Closing a release's Add documents dialog gives focus back to the Add documents button again. Since the dialog's code began loading on first open, the dialog shown while it loaded held focus, and closing left it at the top of the page.

  • #4071 30cab7e Thanks @nextly-agent! - Lists, the rich-text editor and the account menu read correctly to screen readers and keyboards. A list's sortable column headers keep their sort state, rows and row cards are no longer controls wrapped around other controls (each row is reached through its title), the title link is a larger target, and the rows-per-page selector is named. The rich-text toolbar's icon buttons and a code field's editor are named, and the account menu no longer hides the page behind it from assistive technology while it is open.

  • #4116 9f26449 Thanks @mobeenabdullah! - The SEO import now covers every version of a page a value applies to, in one run. A translated content type or Single is imported into each of the site's languages, from each language's own values, and a type that keeps working drafts is imported into what is published and into the draft waiting beside it, each on its own: a value an editor typed in the draft is kept, the draft stays a draft, and a page with no draft gets none. Pages never published are imported into too. The import's last step shows one row per version, such as English · published, English · draft and Deutsch · published, each value with its own result, and the downloaded report has a Version column. It is still all or nothing: whatever is written outside the one step (a Single, another language, a draft of a type that isn't translated) is put back as it was when anything after it fails. A page in another language with a draft waiting is left as it is, and said so, until the draft is published or discarded.

    Plugins can list the site's languages as they are now, a list set in Settings included, through ctx.publicAddresses.languages(), which the import uses.

  • #4033 694f7ce Thanks @zeshan-rx! - A save that changes nothing a language shows no longer withdraws that language's approval on SQLite and MySQL. An approval's record of the content it approved now leaves out every column the framework manages and no client writes, the time the document was first published among them. Those databases read that time back to the second, while the version a publish writes holds it to the millisecond, so a held edit of another language read it as a change.

  • #4088 166c2b8 Thanks @nextly-agent! - The admin no longer sends autosave requests for a collection or Single with autosave turned off. The entry and Single editors, and the Page Builder canvas inside them, used to record recovery points there anyway; the server refused each one, so every editing session filled with refused requests. Where autosave is off they now record nothing, look for no recovery point and show no autosave status. Nothing changes where autosave is on.

  • #4138 e61a18f Thanks @mobeenabdullah! - The Builder's form preview fetches its code the first time the preview is turned on, so opening a collection, Single or field group in the Builder no longer downloads the entry form's field editors.

  • #4184 42e2b9c Thanks @mobeenabdullah! - Code that loads the collection service or the collection dispatcher, such as each request's boot, no longer loads the Builder save writer with it, and with it the migration generator and runner. The writer is now loaded the first time a Builder save, preview or delete through it runs.

  • #3826 e378ae8 Thanks @aqib-rx! - nextly migrate:check no longer reports drift right after nextly migrate:create for a Schema Builder collection on MySQL. The check described a Builder collection's table by the code-first column rule, so a text field that states no width was expected as varchar(255) while the migration had created it as TEXT.

    nextly migrate:create now also describes Builder Singles and field groups by the column rule of the Builder that builds them, as nextly migrate and the running app already do. On MySQL, an app whose earlier migrations created such a column as varchar(255) gets, at its next nextly migrate:create, one migration that widens it to TEXT; the widening needs no confirmation and keeps every value. A unique text field that states no width stays varchar(255) on MySQL for every Builder entity, since MySQL can key only a bounded column; such a field is now accepted there instead of refused. So on MySQL, turning Unique on or off for a text field with no maxLength changes its column (varchar(255) while unique, TEXT otherwise), and the Schema Builder takes it through its schema preview as a change to the table; give the field a maxLength to keep its column as it is. A translated field is unique per language and keyed without bounding its column, so a translated unique text field keeps TEXT, and turning localization off restores its values into TEXT with nothing cut; such a field leaving translation while unique is refused, since its shared column would be bounded. An indexed one is not widened either: where an earlier migration made it varchar(255) with an index over the whole column, nextly migrate:create refuses with a message naming the column, and asks for a maxLength on the field or for its index to be removed. Widening such a column together with its index comes later.

  • #4070 d40d57e Thanks @nextly-agent! - A contains filter on a hasMany relationship now works on PostgreSQL. Its ids are stored as a jsonb array there, and the case-insensitive match lowered the column, which PostgreSQL refuses for jsonb ("function lower(jsonb) does not exist"), so where: { categories: { contains: id } } failed while MySQL and SQLite searched the serialized array. The value is now folded as text on PostgreSQL, which also fixes the blog template's category and tag pages there, which listed no posts. A text column matches exactly as before.

  • #4029 a2ed0dc Thanks @nextly-agent! - The admin's Content panel now lists collections and Singles together in one list, each under a heading with its count, instead of switching between them with a segmented control. One search filters both headings, and each heading folds, remembered for you across visits. Collections that set admin.sidebarGroup are listed under that group's sub-heading inside Collections. Where no admin.icon is set, a collection now shows a list icon and a Single a framed-page icon. A role that can read only one kind sees only that kind's heading, and the panel's title links to the Content overview.

  • #4038 61b76b0 Thanks @nextly-agent! - The admin has a Content overview at /admin/content: a table of the collections you can open, with each one's entries, drafts, last edit and a New action where you may create, and a table of the Singles, with who edited each last, when, and Edit. Collections that set admin.sidebarGroup are listed under their group. Clicking Content in the rail opens the overview with the Content panel beside it. /admin/collections and /admin/singles no longer redirect to the first item: each shows the overview with that one table. A role that can open only Singles is sent from /admin/collections to /admin/singles, and the other way round for collections only; with neither, each address says there is no content to open, and offers to create a collection to someone who may. A new endpoint, GET /admin/api/dashboard/content, answers every row the overview shows in one request.

  • #4108 bbf7151 Thanks @nextly-agent! - Content routes take the site's own notFound. createContentRoute, createPublicContentRoute, createSingleRoute and createPublicSingleRoute from nextly/runtime, and createContentPage, createPublicContentPage, createBlocksPage, createPublicBlocksPage, createSinglePage and createPublicSinglePage from @nextlyhq/blocks-react/next, accept a notFound function that answers a path the route has nothing for in place of Next.js's notFound(), from the page and from generateMetadata alike, so a site can do something for each miss, such as logging the address. A handler that returns is followed by notFound(), and a route given none answers as before. The page builder's public forms call it only with Cache Components on, since without them a public page's answer is rendered once and kept. The option is experimental.

  • #4235 089dd8f Thanks @mobeenabdullah! - A plugin's block on the dashboard no longer jumps when the cards arrive. A screen's loading outline now holds its place from the first paint, laid out but not drawn until its 0.4 s, so whatever a page draws after a part that is still loading (a plugin's block after the dashboard's cards) is drawn where it will stay, rather than up under the greeting and then pushed off the screen.

  • #4120 2dec523 Thanks @mobeenabdullah! - On SQLite, a field group table that a schema push rebuilds keeps its id NOT NULL. Before, the
    rebuild wrote id text PRIMARY KEY without NOT NULL, so the upgraded table accepted a row with no
    id.

  • #4106 05f6343 Thanks @mobeenabdullah! - The submissions list's chosen status tab is raised with a shadow, as the admin's other segmented controls are, instead of a faint outline that was too light to see in dark mode.

  • #4062 215c66d Thanks @nextly-agent! - A form's file field now has an upload route, and a submission's files are deleted with it.

    POST /admin/api/forms/:slug/upload (multipart: field and file) stores a visitor's file for one file field of an open form and answers with its mediaId, the value the field's answer names. It refuses a form that is not open, a field that is not a file field, a type or size the field does not take (the field's accept and maxFileSize, never above the plugin's uploads.maxFileSize), and a visitor past five uploads per submission the rate limit allows.

    The plugin records each upload, and a submission written by a request (a visitor, or staff over the API) may only name uploads made for its own form and field that no other submission has claimed; anything else is refused with a validation error on the field. An edit may send back the ids a submission already holds. A write no request produced (the Direct API from server code) is trusted as before, and one naming a file another submission holds is recorded as holding it too, so the file stays while either names it.

    Deleting a submission, one at a time, in bulk, by the nightly retention pass or with its form, now deletes the files it holds once the deletion commits, unless something else on the site uses one. The nightly pass also deletes uploads no submission claimed within a day. Settings › Privacy says so.

    A plugin's ctx.services.media.delete now removes the item's stored files durably: they are recorded as left to remove in the delete's own transaction, and the jobs queue retries a removal storage refused until the files are gone, rather than leaving them behind after a storage error.

    Migration: the plugin adds an internal form-uploads collection. Existing installations receive it through their own migrations: run nextly migrate:create and then nextly migrate (or nextly db:sync in development). Files named by submissions stored before the upgrade were not recorded, so they are not deleted with them.

    The plugin SDK also re-exports the date field factory and the CollectionConfig type, as part of its public field-authoring surface, so a plugin can author the collections it contributes without importing from core.

  • #4076 bb940f2 Thanks @nextly-agent! - A submission page's links are underlined in a colour that reads in dark mode, and a notification's recipient field fills its row beside Add instead of setting a width of its own.

  • #4082 bc230f5 Thanks @nextly-agent! - Form notifications are queued in the transaction that saves their submission, so a submission and its notifications are kept together or not at all, and marking a submission as spam cancels and clears its notifications not yet sent in the same transaction. One the provider is sending at that moment finishes: it ends sent if the provider takes it, and cancelled if that attempt fails. A submission flagged as spam still queues nothing, and marking it "Not spam" sends nothing.

    The form-builder.beforeEmail hook now runs inside that transaction: a hook that throws refuses the submission, and it may run again if the transaction is retried. No collection or field changes, so there is nothing to migrate.

  • #4092 ecbb6b0 Thanks @nextly-agent! - A submission's page shows each notification it sent and, for each recipient, Waiting, Retrying, Sending, Sent, Sent after N retries, Failed or Cancelled (and why), and when; a notification whose recipients differ reads Partly sent. A notification's page lists its recent sends. The Form Builder keeps each send's per-recipient outcome with the submission, by masked hint and keyed digest, updated in the same transaction as each change of the queued email, so it outlives the 90-day delivery log and is deleted with the submission.

    Resend sends a notification again to the recipients who have not received it, plus any the person ticks, and records who asked. It needs both update-<submissions> and manage-email-deliveries, is refused while a send is in progress, and retires a failed earlier send whose message is still held.

    @nextlyhq/plugin-sdk now exports the json and number field factories, beside date, intended to be stable.

    Migration: form-submission-sends gains fields (form, notification and its name, state, attempts, retries, when it changed, cancel causes, configured and final recipients, who asked and the resend), and a new internal collection form-submission-resends keeps Resend's requests. Run nextly migrate:create and nextly migrate (or nextly db:sync in development). Sends recorded before the upgrade are not listed.

  • #4001 453404a Thanks @nextly-agent! - Forms can ask for consent: a Consent field is a required box the visitor ticks to agree to a text, such as a privacy policy. Each submission stores the choice with the text the form showed, so a later change to the text leaves what earlier visitors agreed to as it was, and an edit of a submission can never change or drop its consent. A site that sends the text it showed is held to it: a submission agreeing to a text the form no longer shows is refused.

  • #4008 be32ee2 Thanks @nextly-agent! - Deleting a form submission forgets the notifications it sent, in the same transaction: one not yet sent is cancelled and cleared, and the delivery records of one that went out are erased. This holds for one deletion, a bulk deletion, and deleting a form, which now deletes its submissions with it.

    The plugin records what each submission sent in a new internal form-submission-sends collection. Existing installations receive it through their own migrations: run nextly migrate:create and then nextly migrate (or nextly db:sync in development). Notifications queued before the upgrade were not recorded, so deleting their submissions does not forget them.

  • #4103 1d9003e Thanks @nextly-agent! - A submission marked Spam no longer offers Resend in its Emails box, which could only be refused; the box says it is marked Spam and to mark it Not spam to send its emails again. The Resend dialog lists who it sends to, rather than showing them as boxes that cannot be unticked, and offers a box only for a recipient who received it, to send it to them again.

  • #4080 2b11e20 Thanks @mobeenabdullah! - Forms: a notification whose condition is on a choice field now reads the option by its label ("Only when Joining is In person"), not its stored value ("in_person"), in the notifications list and on the notification page.

  • #4014 aa25ba0 Thanks @nextly-agent! - Form notifications can send to several team addresses (recipients), send only when all or any of several conditions hold (conditions: { match, list }), and choose which of the form's file fields they attach (attachFields). A notification saved before these reads and sends exactly as it did: its single address and single condition read as lists of one, and it attaches the file fields marked to attach to notification emails. FormEmailNotification.to is a list for an email with several recipients and stays a string for one, and each email carries its own attachments.

    In the admin, Notifications becomes a list with an Active switch per notification, and each notification opens on its own page (?notification=<id> on the form's Notifications page). Add notification offers two presets, "Notify your team" and "Confirm to the visitor". The file field's "Attach to notification emails" switch moves to each notification's "Attach files from" choice; a field's stored switch stays what a notification saved before attaches.

  • #4085 f6b9b53 Thanks @nextly-agent! - A required form field left out of a submission is now refused as " is required" (or the field's own error message), not with a raw type error such as "Invalid input: expected string, received undefined". In a form's Settings, "One per network" now says it needs the site to see each visitor's real address through the trusted proxy setting, and that until it can, every response is accepted.

  • #4009 052f95a Thanks @nextly-agent! - Forms can delete old submissions. Settings › Privacy › Delete submissions after (Never, 30 days, 90 days or 1 year, stored as settings.keepDays) sets how long a form keeps them. A nightly pass the plugin schedules deletes each form's submissions older than that, and spam older than 30 days whatever the setting. Each is deleted the way any deletion is, and a pass that runs out of time continues on the next jobs run.

  • #4026 a9f05ea Thanks @nextly-agent! - Each form submission has a page of its own, at its own address, in place of the drawer the submissions list opened. It shows:

    • the answers as the visitor was asked them, with option labels, dates in words, links, and files with name, size and download;
    • fields a condition hid, marked as not asked;
    • its activity;
    • a side panel with its status, internal note and details.

    Newer and Older move through the list it was opened from, keeping its filter. Opening a New submission marks it Read for a person who may update submissions. Staff edit answers there, except a consent.

    Each new submission now keeps what it was asked (each field's label, type and option labels, and which fields its conditions hid), so it reads as it was answered after the form changes. It also keeps a title (who sent it, from a name or email answer), which the admin uses in breadcrumbs and lists. A submission stored before this reads with the form as it is now.

    SubmissionSheet is no longer exported from @nextlyhq/plugin-form-builder/admin; the page replaces it.

    Existing installations receive the new asked and title columns on the submissions collection through their own migrations: run nextly migrate:create and then nextly migrate (or nextly db:sync in development).

  • #4077 1e194ba Thanks @nextly-agent! - The form submissions list shows each form's labels as its columns and a choice
    by its option's label (for example "Backend engineer" rather than
    backend-engineer), on a form's Submissions tab and in the list of every
    form, which shows who sent each submission, its form and a summary. The list
    filters by date (today, the last 7 or 30 days, or a range of days) as well as
    by status, with each status tab's count beside it. Ticked rows can be marked
    as read, archived, moved to or out of Spam, exported or deleted, for those
    rows alone, each offered only to a role allowed to do it; Delete asks first.
    Export, with no rows ticked, exports everything the current filter shows, as
    a CSV headed by the form's labels or as JSON. The export route accepts the
    list's date filter (from, to) and the ticked submissions (ids), and its
    CSV reads a choice by its option's label.

  • #4236 296ddd5 Thanks @mobeenabdullah! - Installing a plugin with nextly plugins install no longer takes back the access other plugins give site visitors, such as the form builder's public form submissions.

  • #4054 3e9bf1c Thanks @nextly-agent! - A JSON value written inside a transaction is now stored as JSON on MySQL. A transaction's insert and insertMany handed an object or an array to the driver as it was, so MySQL refused the row or stored [object Object], and on PostgreSQL an array was refused as invalid JSON. They now serialize a JSON column's value as the ordinary insert does, on every dialect; SQLite, update and upsert were already correct and are unchanged.

  • #4231 def1cad Thanks @mobeenabdullah! - Less of the admin moves as a screen's data arrives. An editor's bar outline now stands at the bar's right end on its own, so the document's trail, which arrives with the document, no longer pushes the bar's controls along, and it draws More and the panel toggle where the bar draws them, with one still bar where the document's own buttons go. A list's outline rows are as tall as its real rows and the pager's frame follows them, so what sits under the table stays put. The dashboard's outline cards are as tall as its cards are first drawn. The Publishing section holds its place while it checks releases, and the bar's controls now reach the bar's right end.

  • #4015 d9b4ba7 Thanks @nextly-agent! - A plugin can ask whether a media item is in use: ctx.services.media.isInUse(mediaId) (@experimental) answers whether a document's field, an avatar or a logo uses it, the same condition the media library's Unused view applies, and answers in use whenever that cannot be known yet (before the usage table exists, while the usage record is not built, or for an id no item has).

  • #4105 2c8c7f8 Thanks @mobeenabdullah! - nextly migrate:create now asks whether a renamed field group (fieldGroup({ name }) in your config, including a repeatable one or a list of several groups) is a rename, as it does for a renamed column. Accept it and the migration moves the field's stored values to the new name, with the reverse in its DOWN. Before, the migration moved nothing and the renamed field read empty after nextly migrate, its values left under the old name. With no terminal, --accept-renames accepts it; without that flag it is declined and migrate:create warns that the values stay under the old name.

  • #4057 6c835fd Thanks @aqib-rx! - nextly migrate:create now lists every table, column and row a migration would delete before it writes the file, judged the way nextly migrate judges it when applying the file. That covers a collection, Single or field group no longer in the config, a removed field, a rename declined into a drop and an add, a type change, and a translation change that moves values before it drops a column or table. Each deletion says why it goes where that is known. Where the database can be read, it adds row counts and each column's count of non-empty values, opened read-only and for at most a few seconds; it needs no database. At a terminal it asks, and a no writes nothing. A run that cannot ask (CI, --non-interactive) now writes nothing and exits 1 unless --accept-data-loss (or NEXTLY_ACCEPT_DATA_LOSS) covers every deletion, where it used to write the file and exit 0; the refusal prints the exact consent to pass. A CI migrate:create that turns translation on or off now needs --accept-data-loss too, as nextly migrate already does to apply it. A file that deletes data carries a -- Destructive: line and one -- Deletes: line per table and column in its header, Schema Builder files included.

  • #4039 9cf52aa Thanks @aqib-rx! - nextly migrate now carries every settings change a migration records into the registry rows, and nextly migrate:down undoes only what the rolled-back migrations changed there.

    • A field's help text, placeholder, hidden switch and its other admin options change no column, so they never reached a deployed registry row. They are now compared and written, by nextly migrate and by the development start alike, which share one comparison.
    • A description or admin block a Schema Builder entity's migration clears is now cleared in the registry. A setting no migration ever recorded for that entity is still left as it is stored.
    • The registry row of a collection, Single or field group that an applied migration drops (its snapshot no longer records an entity the one before it did, and its table is gone) is removed, on the run that applies the drop or on any later run. A row of an entity no snapshot records, or whose table still stands, is left as it is.
    • A migration that changes a field's type now writes that entity's registry row with its file: inside the file's transaction on PostgreSQL and SQLite, so the conversion and the row commit together, and right after the file's last statement and before it is recorded applied on MySQL or in a file marked to run outside a transaction. nextly migrate, the boot migrate step and nextly migrate:down all do this, so no later file in the run sees the old type.
    • nextly migrate:down to a point whose snapshot records the registry brings each row that snapshot records back to it, settings included, so rolling back a settings-only migration undoes it, and removes the row of an entity a rolled-back migration added. Rows nothing in the rolled-back migrations touched are left as they are. A rollback to a point whose snapshot predates recorded settings changes no row.

    Compatibility

    Registry writes in production move to nextly migrate: deploy a settings change, a dropped entity or a type change by running nextly migrate, which now writes what a production start no longer writes. A deployed field whose help text or placeholder differed from the code is rewritten once, at the first development start or nextly migrate after upgrading.

  • #4041 d358b0b Thanks @zeshan-rx! - nextly workflow:move-stranded --dry-run lists the documents a move would take, with their parts and the stages they leave, and what the move would refuse (an unknown or deactivated person, a stage the workflow lacks or one that allows publishing, no comment), writing nothing. It judges them exactly as the move does.

  • #4051 061dde3 Thanks @aqib-rx! - next build no longer writes to the database. Next.js starts the app while it builds, to prerender pages that read content, and that start used to create missing tables, update the collection registry, run migrations at start when they were turned on, reconcile the email templates, set SQLite's journal mode, and on an empty database create the whole schema. A build may point at a database other deployments share, so Nextly's own start now only reads there. The one write left is sealing a plugin setting that its manifest now marks secret (or that was sealed under a rotated NEXTLY_SECRET), which must happen before that plugin starts. A plugin's own init and onReady code still runs in the build, and what it writes is the plugin's.

    A build against a database with no Nextly tables now stops with NEXTLY_DATABASE_NOT_MIGRATED: "The database has no Nextly tables. Run nextly migrate before next build." On SQLite a database file that does not exist yet is not created, and on PostgreSQL a configured db.postgres.schema that does not exist is not created; both refuse with the same advice. Run nextly migrate before next build, as the scaffolded build script already does. Everything the build skipped happens at the first start after it.

    @nextlyhq/adapter-drizzle exports isNextBuildPhase() from the new @nextlyhq/adapter-drizzle/build-phase subpath, the one check Nextly and the adapters share.

  • #4043 4ad38c3 Thanks @nextly-agent! - The Page Builder now has its own item in the admin rail, right after Forms, in place of its heading in the Plugins panel. Its panel lists Patterns, Components, Layouts and Templates with how many of each you can see, then Bindings to fix with a badge while any need fixing. Clicking the item opens the new Page Builder overview: the bindings to fix first, when there are any, then the four libraries with their counts and a New action for those who may create, and the collections and Singles that have a Page Builder field, each opening its list or edit page. The overview is for people who can edit pages; anyone else opening the item lands on the first library they can read. A site preferring the old place can set placement: "plugins" for the plugin in admin.pluginOverrides.

  • #4107 3aed99d Thanks @nextly-agent! - The page builder no longer reads or writes anything on a write it has no part in. A save to a collection the site's code declares that no template can serve and that holds no blocks field, such as another plugin's private records, no longer reads the templates, writes a lock row to the address store or reads the component registry, so each such save costs several fewer database round trips.

    The composition graph lock's row is now put in place once, by the plugin's migration, on install and on nextly migrate for an existing install, instead of at every start. A start on PostgreSQL or MySQL no longer sends an insert that fails on a duplicate key. Run nextly migrate after upgrading; until then the first page-builder write that locks the graph inserts the row, as before.

  • #4099 48c8fd2 Thanks @nextly-agent! - A production start no longer makes the page builder's address store write anything, and its background work on served addresses no longer grows with the number of pages. Holding an address's lock reads the lock row for update instead of rewriting it, so a start, and every save that takes a lock, writes no lock row, content event, media usage or cache tag for it. Once the start-up passes have settled every page and entry, the plugin keeps a mark of everything the claims follow from (languages, page path, template addresses, the plugin's version, how many pages and entries there are and when they last changed), and a later start whose mark matches skips the passes after a few reads. When they do run, pages are compared with their claims a batch at a time, and only a page whose claims differ is reconciled.

  • #4111 33ad57f Thanks @mobeenabdullah! - A content or Single route in a worker where Nextly cannot be started no longer reads the page's
    content, or works out its own metadata, for a page-metadata provider nobody can ask; it serves the
    route's own head and no structured data, as before, and starts Nextly first where it can.

  • #3991 d8cd783 Thanks @nextly-agent! - A plugin can now choose where its own item goes: the top bar's right end (the default, unchanged for every existing plugin), the rail's foot just above the Inbox, or the person's menu under "Help and community". The bar and the rail's foot take a component that stays mounted on every page and at every width; the menu takes a declared item with a label, an icon, and either a link or an action, never a component. Set it with contributes.admin.header.place; the new types are exported from nextly and @nextlyhq/plugin-sdk as experimental.

  • #4110 8385af5 Thanks @mobeenabdullah! - A plugin context no longer fails to start when the media service it is given lacks one of the
    methods a plugin media write runs: only that write fails, when it is called.

  • #4119 3ea4392 Thanks @nextly-agent! - A plugin page can now name the data it reads as it opens, with the experimental startupReads on a contributes.admin.pages entry: reads of the plugin's own routes, each named as the page's usePluginRoute names it, at most four. When a tab opens on that page, the admin asks for them inside its startup request, in its first round, and the page's own read takes that answer instead of asking again. Each read keeps its route's own permission check. The admin layout carries the reads in the prebuilt page with the new adminStartupScreensJson(config.plugins) from nextly/config; the scaffolded layout writes them, and an existing app's layout can add the same element to get them. The app refuses to start if a page names more than four reads or a path the startup request cannot carry. The startup request now also accepts a plugin route under its scoped name (/plugins/@scope/name/...).

  • #4018 9b7a456 Thanks @nextly-agent! - A standalone plugin can now declare its own admin panel: contributes.admin.panel.groups draws its menu items under headings, and a menu item takes a quiet count or an attention badge, counting one of the plugin's own collections for the reader or reading one of its own Needs your attention items. The numbers are read in one request while the panel is open and never hold it up. A menu item linking to one of the plugin's own pages that it does not register is now left out of the admin, and a development start reports it, along with a group, count or badge naming something the plugin does not declare or own. The new types are exported from nextly and @nextlyhq/plugin-sdk as experimental.

  • #4084 9b16475 Thanks @nextly-agent! - A plugin is told of each change of its own queued emails inside the transaction that makes it, through ctx.services.email.onQueuedEmailChange: an attempt starting, a failure a retry can help, sent, failed, or cancelled with why (a person, the plugin itself, or a request made while an attempt was with the provider). Each change lists every recipient the send went to after email.beforeSend filters, with its line, what became of it, a masked hint and the plugin's own rotation-stable digest; no address. readQueued reads where the plugin's own queued emails stand, and recipientDigest gives the digest for an address.

    Sends and queued sends take excludeRecipients, a list of those digests, compared after the filters run: the recipients it names are left out, and when no to is left each remaining copy gets a message of its own. People cancel a queued email with nextly.email.cancelQueued, which asks the new manage-email-deliveries permission of a checked call.

    Migration: manage-email-deliveries is seeded on the next start, granted to super-admin only, under the newly reserved system resource email-deliveries: an installation with a collection or Single of that slug must rename it. No table or column changes.

  • #4124 e91a85a Thanks @nextly-agent! - The admin reads the collection, Single and field group registry once, and then not again until it changes. Registry rows and listings were kept for a second and read again after it, so a dashboard, list or edit screen read the same rows over and over; they are now kept until the database's schema version records a registry change, which every registry write (a Schema Builder save, a rename, a delete, nextly migrate, a plugin install) now does. Another server sees such a change within the two seconds it already takes to reload its schema.

  • #4052 851df16 Thanks @aqib-rx! - nextly repair-columns --apply now converts a lossy column, one holding
    values its new type cannot hold, when the data-loss consent names that column:
    --accept-data-loss=<table>.<column>, or NEXTLY_ACCEPT_DATA_LOSS. The values
    cleared, set to null, are exactly the rows the run's report names, and the
    repair record keeps the consent and the count. The consent without a list, or
    one naming only the table, does not cover a repair: the column is skipped and
    the report says which consent would.

    In a terminal, a run with no consent naming the column asks once per lossy
    column, naming the count and the first rows, and the table is never held while
    it waits for the answer. Whether a run may ask is decided before anything is
    asked; a run that may not (no terminal, --non-interactive, CI or --json)
    never reads standard input, and skips the column.

    On MySQL the clearing is a step of its own, committed with its record, so a
    stopped run resumes from it; a clearing still to run needs that run's own
    consent. A value that would be cleared where the column does not allow a null
    now blocks the conversion, since clearing it would need a value invented.

  • #4047 328af70 Thanks @zeshan-rx! - In the admin, restoring a version now puts its values back into the editor rather than writing
    them. "Restore" in History lists every field the version holds differently, all chosen. A field
    you may not read or change, or one no longer in the content type, is listed unchosen with its
    reason. A field with an unsaved edit says the restore replaces it. The chosen fields come back
    as unsaved edits, and Undo takes them out again. A single changed field can also be restored
    straight from the version on screen. Nothing is stored until you save, and the save keeps the
    draft unpublished and records which version each restored value came from. A version is
    restored only into the editor of its own language, and on a translated document the list names
    that language.

  • #4094 d3cf486 Thanks @nextly-agent! - Rich text HTML can now be styled by the site: pass richTextStyles: "none" to a Direct API read (or ?richTextStyles=none over REST) together with richTextFormat: "html" or "both", and the HTML carries no style Nextly adds. Every element has a class in the nextly-rich-text- namespace (nextly-rich-text-paragraph, nextly-rich-text-h2, nextly-rich-text-link, nextly-rich-text-button--outline and so on), and alignment is a class too (nextly-rich-text-align-center). Styles an author chose in the editor, a text colour or a button's colours, are kept. The classes are listed in the rich text field docs. Without the option, the HTML is exactly what it was.

  • #4081 19781cb Thanks @mobeenabdullah! - Plugin pages can draw more of the admin through @nextlyhq/plugin-sdk/admin (experimental). ListView and DataTableView take grouping, which draws rows in groups under a header row with a title, a badge, a count and actions (folding the rows away with collapsible), and rowDetail, which gives a row a toggle that opens a region below it. Stepper shows where a flow of a few steps is, with a way back from a step already done; the email provider setup now draws its steps with it. FormActions takes a message, such as "1 page changed", in place of "You have unsaved changes".

  • #4087 28adb3d Thanks @mobeenabdullah! - Plugin pages can draw the admin's own notice, side panel, in-page tabs, progress bar, action menu and hover hint through @nextlyhq/plugin-sdk/admin (experimental): Alert, Sheet, Tabs, Progress, DropdownMenu and Tooltip, with their parts and prop types. They are the same components the admin's pages use, so a plugin page needs no styling of its own for them.

  • #4079 fbf4caa Thanks @mobeenabdullah! - Plugins can now build their admin pages from the admin's own building blocks through @nextlyhq/plugin-sdk/admin (experimental): the list surface (ListView with its search, filters, columns menu and empty states, plus useTableColumns), Breadcrumbs for the trail in the top bar, SegmentedChoice, the setup Checklist, SettingsRowGroup, Badge, and a layout="row" settings row on FieldShell.

  • #4117 2051992 Thanks @nextly-agent! - The SEO plugin's address record moves from a collection to its own tables,
    seo__addresses and seo__notes, written on the save's transaction with
    ctx.db. Each claim, release and lock row is now one statement rather than a
    whole entry save, so an entry save on PostgreSQL issues about a tenth of the
    address bookkeeping it did. Run nextly migrate to create the tables; the
    first start afterwards moves the rows an earlier version kept, before the
    plugin answers any save, and leaves the old collection in place, unused.

    ctx.db.select(...).lock("update" | "share") (experimental) reads rows
    FOR UPDATE or FOR SHARE inside a transaction, which on MySQL also reads
    the latest committed rows rather than the transaction's snapshot. A public
    address participant's deadlock is reported as a conflict to try again, as
    core reports its own.

  • #4121 6bdd9c5 Thanks @mobeenabdullah! - A site upgrading the SEO plugin from 0.0.2-alpha.75 loads its admin again. The admin entry still exports SeoBulkPage and SeoReceivedPage, now the screens that send an old bookmark on to Pages and Inspect, so a committed component map that names them compiles; in development the map is then rewritten with the current names (SeoBulkMoved, SeoReceivedMoved). The old names are deprecated.

  • #4154 7f78f8d Thanks @mobeenabdullah! - The SEO admin reads right at every width. Import's last step gives every title and description a result, "Nothing to import" where the source holds no value, in the table and in the downloaded report; a file's match table counts "Pages it changes", as the import does; the step labels wrap on a phone rather than being cut short, and the four counts sit two by two there. A page's tab row (PageTabs) brings its current tab into view when the row is wider than the screen. The Overview's cards sit two by two on a tablet, Problems keeps "Check again" beside when the list was checked, and the SEO tab's source chips and labels are drawn at 12px. A link to a Single's SEO tab, from Pages, Problems or Inspect, opens that tab rather than the Single's content: a Single's editor holds the tab under its own id.

  • #4132 e772619 Thanks @mobeenabdullah! - A choice card in the SEO plugin's settings now darkens its border to full strength on hover, as the admin's other choice cards do, instead of a faded border too light to see against the page.

  • #4136 5876328 Thanks @mobeenabdullah! - The SEO plugin's list of pages built in code no longer makes a Next.js build trace the whole
    project into the server output. Looking up each route's source file joined the working
    directory with the route's name, which Turbopack could not bound, so every source file and
    the public folder were deployed as server code: slower deploys, and a risk of a host's size
    limit. The lookup is now marked for Turbopack to ignore. Where a deployment does not ship its
    sources, a route is named by its path under app, as it already was where no source file was
    found.

  • #4098 0990686 Thanks @mobeenabdullah! - The SEO plugin's Import is its own screen, reached from Pages: choose this site's field group or a
    WordPress (Yoast or Rank Math), Rank Math CSV or Payload export, match the fields with an example of
    each, then check the dry run before importing. An export file is read in the browser, and only the
    values it holds are sent. Values a page's own code overrides are skipped as never served unless
    included, and the result says what was imported or that nothing was. A content type with a field
    of its own called seo is named, with how to import it once that field is renamed. Plugins can
    draw the admin's drop area with FileDropArea from @nextlyhq/plugin-sdk/admin.

    A value already typed on a page is reported as kept, never as the same as the automatic one, and
    the drop area's hidden file input sits beside its button rather than inside it, in the Media
    library's upload area too.

  • #4109 58781b8 Thanks @nextly-agent! - The SEO plugin's log of addresses not found counts only requests a route answered not found. Logging from the site's app/not-found.tsx, as the guide showed, counted every page view, since Next.js renders that page for every page. notFoundLogged() from the new @nextlyhq/plugin-seo/next answers not found and logs the address once the response is sent, once per request though the page and its generateMetadata both answer it; pass it as a content route's notFound, call it from a site's own routes, and from an app/[...missing] catch-all for addresses no route matches. The Proxy no longer passes the address on for a prefetch, so a prefetch is never logged. logNotFound keeps working. Remove any logging from app/not-found.tsx.

  • #4101 93385a8 Thanks @nextly-agent! - ctx.db.update takes increment(n) for a numeric column, exported from @nextlyhq/plugin-sdk/db (experimental): the update adds to the stored value in its own statement, column = column + n, on every dialect, so updates made at once each count. The SEO plugin's not-found log moves from a collection to the plugin's own table (seo__not_found) and counts a request for an address already logged in one statement, and a first request in at most three, where each was a whole entry save of about 80 statements before. Rows an earlier version logged are moved to the table at start; the old collection stays declared and is left empty.

  • #4097 a06eee0 Thanks @mobeenabdullah! - The SEO Overview matches its design: the verdict on Search health has a dot in its colour and the error, warning and notice counts are written in their colours rather than as chips; Search health and Pages lead with a smaller figure; the setup steps sit in two columns with done steps crossed off.

    Plugin pages can draw these too (experimental, through @nextlyhq/plugin-sdk/admin): Stat takes tone (success, warning, destructive or info) and size="compact", and Checklist takes columns={2} and doneStyle="struck". Without them both draw as before, so the dashboard's setup card is unchanged.

    A plugin's own sidebar panel no longer repeats the plugin's name as a small heading under the panel's title; the menu is still named by it for screen readers.

  • #4096 8c4ac96 Thanks @mobeenabdullah! - The SEO section's Pages lists every public page with the title and description search is given
    for it, where the title comes from, and its status, read from the problem list. Search it, narrow
    it by type and status, and from each row edit its SEO, inspect what search engines receive, add a
    redirect or open the page. Its Edit mode replaces Bulk edit: titles and descriptions are typed
    straight into the list and saved one content type at a time, and a save that stops part-way names
    the pages not saved and keeps their changes. An old Bulk edit link opens Edit mode.

    Inspect fetches a page as Google, Bing, Facebook, X, LinkedIn and an AI crawler, says for each
    whether it matches, shows each value Nextly holds with where it comes from beside what the chosen
    crawler received, lists the page's structured data and its JSON-LD, and says when a network won't
    show the share image (an SVG on any card). A difference that needs no fix is said to be expected,
    and an address that isn't fetched, or a fetch that stops at its limits, says why while still
    showing what Nextly holds.

    For code reading the check's answer: its crawlers are now googlebot, bingbot, facebook,
    x, linkedin and ai (Slack is gone), the /received/pages route is removed, and
    SeoReceivedPage is no longer exported from @nextlyhq/plugin-seo/admin; use SeoInspectPage.

  • #4104 2395dea Thanks @mobeenabdullah! - The SEO Pages list now names only the entries the person asking may read. Someone holding manage-seo who may read only some of a type's entries, or none of a type, no longer sees the others' addresses, titles or descriptions there; pages built in code are listed as before.

  • #4112 bb93349 Thanks @mobeenabdullah! - On SEO Pages, a page the problem list has not checked for you now says Not checked instead of Good, page by page and language by language, rather than only for a whole content type you may not read.

  • #4065 0a98250 Thanks @mobeenabdullah! - A page saved on a transaction, such as by the SEO import or another plugin's write, is checked for the problem list once that transaction commits, rather than from inside it. The check used to make its own writes on the transaction's connection, where on PostgreSQL and MySQL it could fail the import's apply with savepoint "nextly_sp_1" does not exist, and it read the page before the save was committed.

  • #4093 f2b2b3e Thanks @mobeenabdullah! - The SEO section's Problems screen is now one table, a row for each kind of problem with the most
    serious first: its severity, what is wrong, whether it is on the whole site or on pages, how many
    pages, and the way to its fix. A row naming several pages opens on each page with its own fix, the
    errors, warnings and notices can be shown one at a time with the counts the Overview shows, and the
    screen says when the site was last checked, with Check again beside it.

    A page marked as having first appeared on another site no longer lists its canonical to that site
    as a problem: the address is the one meant, so the site's search health stays clear.

  • #4055 4eba1af Thanks @mobeenabdullah! - The SEO plugin's Proxy no longer reads the database for a page request no redirect is for: each server keeps the addresses redirects hold in memory, so a static or CDN-served site can wire proxy.ts without a database read per page. A saved redirect applies at once on the server that saved it and within 15 seconds elsewhere. With NEXTLY_PRODUCTION_ADDRESSES set, the staging guard reads only the environment. The Proxy now notes that it runs, so SEO › Problems lists "Redirects saved but not served" when redirects are saved and proxy.ts is not wired, and /proxy-status says whether it runs.

  • #4102 cd7e13f Thanks @mobeenabdullah! - The SEO section's Redirects screen is rebuilt on the admin's own list: each redirect shows the
    status the site answers (301, 302, or the new 410 Gone for a page removed for good, which needs no
    To address), who made it ("You" for your own), how many requests it has answered and when it last
    did, counted by the Proxy in the background. Redirects are added and edited in a dialog, removed
    from each row's menu, and a CSV file (which may now mark rows gone or 410) is imported after a
    dry run in a dialog. Where the Proxy does not run, the list says the redirects are saved but not
    served, with the note a developer needs.

    The Not found tab shows where visitors came from (another site, a page here, or Direct), narrows by
    when an address was last asked for, and lets an address be ignored and shown again. Bots' probes
    for other systems' pages, such as /wp-login.php and /.env, are left out of the log.

    The plugin's redirects and not-found collections gain columns (hits, last hit, gone; came from,
    ignored). Run nextly migrate:create and then nextly migrate after upgrading to add them.

  • #4083 1331030 Thanks @mobeenabdullah! - The SEO plugin's admin is now one section with its own menu: Overview, Pages, Problems, Redirects
    and Settings, each screen showing its place in the admin's top bar (SEO / Pages / Import). The
    section opens on its Overview: a setup checklist worked out from the plugin's stored state (hide it
    and it stays hidden until shown again), the site's search health with its errors, warnings and
    notices linking to Problems, how the site's public pages stand, the addresses not found in the last
    week with a Redirect for each, and Search Console, IndexNow and the redirects running on the site.
    First-time setup ends on the Overview.

    Every kind of problem now has a severity, and a problem is counted once for each page a check fails
    on and once for a check of the whole site. Problems opens narrowed to one severity from the
    Overview's counts, and Pages has an Import button. The SEO menu's Problems item shows the errors and
    warnings as a badge, the same number the dashboard's SEO problems line now counts. The Bulk edit and
    What search engines received menu items are gone: bulk edit stays at its address, and the check's
    old address opens Inspect for the page it named, or Pages. Each page the Pages list answers says where its title and description
    come from.

    navigateTo from @nextlyhq/plugin-sdk/admin takes { replace: true }, to move without leaving the
    current address in the history.

  • #4091 1a38791 Thanks @mobeenabdullah! - The SEO plugin's Settings and its SEO tab are drawn with the admin's own parts. Settings has six
    tabs, each with an address of its own (General, Content types, Share images, Organization, Search
    engines and AI, Connections), each a card of rows with Cancel and Save changes under it; a
    production address set by NEXTLY_PRODUCTION_ADDRESSES is shown read-only, and llms.txt and the
    plain-text copies moved to Search engines and AI. The SEO tab shows the page on Google beside its
    shared card, says each problem above the fields with its one fix (such as Make a share image),
    and says under an empty title or description what it uses instead. The side panel's SEO line reads
    "2 to check".

  • #4035 0460128 Thanks @mobeenabdullah! - Bulk edit and the SEO import now reach Singles. Each Single the SEO plugin is added to is a content type of the Bulk edit screen with its one page, read and saved as the person asking at the version they read, and the import reads and writes it beside the collections, its existing field groups included (such as a metaData component on a homepage Single), with the same dry run. A Single cannot join the import's one transaction, so its page is written first and put back as it was if anything after it fails. A Single that keeps working drafts, or one made in the Schema Builder rather than declared in code, is read-only there, and its SEO is changed in its own editor.

    The SEO tab, Bulk edit and the problem list now show what a page's route sets in its own code. The title, description and social values a content route's buildMetadata returns are recorded each time the page's head is worked out, and shown as Set in code, so the admin shows what the page is served rather than a pattern's text. A page whose route hides it from search says so in the tab and beside it in Bulk edit. A later page of a list is not recorded as the list's own. They are kept in a new internal collection, nx_seo_route_values: a site that applies its schema with migrations runs nextly migrate:create and nextly migrate after upgrading, to create its table.

    The import's dry run now reports each page it read and each record it passed over: what it would set, what is already the same as the page's automatic value, what a person already typed and keeps, and why one is skipped. A second run after an import sets nothing.

  • #4037 1d738f4 Thanks @mobeenabdullah! - The SEO plugin's structured data now names each page, article headline and breadcrumb step by the page's own title rather than its search title, follows the page's address for its breadcrumb trail, describes About, Contact, questions, technical article and source code pages, lists what a route shows, and carries the brand's description, contact points, parent organisation and founders. An app is described without a rating it does not have, and og:locale always names a territory (en becomes en_US). Routes can pass structuredDataHints for what a page shows that its document does not hold.

  • #4049 9075217 Thanks @mobeenabdullah! - The SEO tab shows what a Single's route set in code only once the Single's own read, as the person asking and in the language asked, finds it, as it already did for an entry. The SEO tab and Bulk edit no longer draw their own line for a page its route hides from search; the bulk table's rows still carry it as hiddenByCode, for the redesigned screens to show.

  • #4048 74151e0 Thanks @mobeenabdullah! - SEO plugin fixes for titles, lengths, share images and installing:

    • A title pattern that goes on after {Site name}, such as {Title} | {Site name} Blog, now always keeps the site's name: "Why we chose Acme" gives "Why we chose Acme | Acme Blog" rather than "Why we chose Acme Blog". The name is left out only where the pattern ends with it and the title already ends with the name.
    • metaTitle and metaDescription save at any length. Search engines cut a long title or description to fit rather than refusing it, so the SEO tab and the problem list warn with the length (68 characters, Google shows about 60) instead of the save being refused. Pass seoPlugin({ hardLengthLimits: true }) to refuse a title over 60 characters or a description over 160, as before. On a site that already has the plugin, the two fields' changed settings are a schema change like any other: run nextly migrate:create, and nextly migrate where you deploy, before a longer title saves there.
    • A share image in a format some networks don't show on a card (SVG, AVIF or WebP) is named in the problem list and the SEO tab, fixed by making a share image, which is a JPEG.
    • @nextlyhq/plugin-sdk is now a dependency of the plugin rather than a peer, so it is installed with the plugin and a site can no longer leave it out of a production install. A client secret wrapped by a site's own copy of the SDK is still read.
  • #3886 7e1c7a2 Thanks @muzzamil-rx! - nextly migrate:baseline now compiles the app's extension schema, as migrate:create and migrate:check already do. Adopting a database built by db:sync records the tables an app declared through db.schema.extend and names the elements it contributed to other owners' tables, so the first migrate:create after graduating no longer re-creates a table that is already standing or re-emits an index the database already has.

  • #4044 e5f78c1 Thanks @mobeenabdullah! - The admin's sign-in page offers "Sign up" only when auth.allowRegistration is on, and /admin/register says registration is closed, with a link back to sign-in, while it is off; GET /admin/api/auth/setup-status now reports allowRegistration, and every signed-out admin screen has a main landmark. A hand-named migration without a timestamp (such as get_started_only.sql) no longer counts as the newest, so the schema version a production start checks names the newest timestamped one. --help after a command name the CLI does not have (for example nextly events abandon --help on a release without events) is refused as an unknown command, rather than printing the parent's help.

  • #4068 1c9568c Thanks @nextly-agent! - Form submissions keep the page they were sent from: the origin and path of the
    browser's Referer (never its query or fragment, and only for http/https
    pages), shown on each submission's page under Details › Page. The plugin adds
    one field to the submissions collection, page (long text), created on the
    next schema apply; earlier submissions keep none.

  • #4089 684c0be Thanks @nextly-agent! - The Form Builder's submissions lists fit their box and wait for what they need. A form's Submissions tab no longer shows every form's columns for a moment before its own: the list stays loading until the form and the person's rights are known. A list too narrow for its columns, as on a laptop beside the Forms panel, leaves some out instead of scrolling sideways: every form's list gives up its Summary, then names the form under the sender, and a form's tab shows fewer of its first fields until the person picks columns themselves. Someone who can only read submissions gets no tick boxes, since a ticked row would offer them nothing, and the delete question answers "Keep it" for one submission.

  • #4118 3d0f23c Thanks @nextly-agent! - The admin's startup request now leaves as the browser reads the admin page, before the admin's main code has loaded. A small script in the prebuilt page sends it, and the admin takes that request, and the paths it named, instead of sending its own. The script is written from the admin's own code when the page is built, so it sends exactly the request the admin would; it carries nothing about the visitor, so the page stays the same for everyone. Where the script does not run, the admin sends the request itself as before; where its request fails or its answer cannot be read, the admin sends it once more without showing an error. RootLayout's nonce now covers this script too, for a site that renders the admin with a nonce-based Content Security Policy.

  • #3574 d3fc9a0 Thanks @zeshan-rx! - Under experimental.perLanguageStorage, a document keeps one pending change for its shared fields and one per language: an edit to a shared field, made in any language, is held in the shared draft and reaches every language; an edit to a translatable field is held in that language's draft only. Every language's editor read reports _sharedChangesPending, and the language panel says when shared fields have unpublished changes.

    Publishing a language puts its draft and the shared draft live. With the setting off nothing changes.

  • #4058 5af3565 Thanks @mobeenabdullah! - A Next.js site deployed on Vercel no longer answers 500 on every unknown address. On the server Nextly loaded the client next/navigation for notFound() and redirects, which Next's require hook sends on to the pages router's runtime, react-dom, styled-jsx and client-only, files a deployment that ships only traced files does not have. It now loads Next's server build of next/navigation, which needs none of them, by a literal specifier a tracer can follow. withNextly() also adds the Next.js files Nextly loads at request time (from next/cache, next/headers, next/server and that entry) to every route's outputFileTracingIncludes, and nextlyTracingIncludes() from nextly/next gives the same list to a config not wrapped in it; new projects from create-nextly-app include it. Where a file is still missing, a not-found page answers 404 and a permanent redirect answers 308 with Next.js's own errors, cached reads run uncached, and the media revalidation after an upload is skipped, each named once in the log, instead of a 500.

  • #4090 2692bca Thanks @nextly-agent! - A Date written inside a transaction to a column the table model does not declare now stores the same instant as one written to a declared date column. On PostgreSQL it was bound by node-postgres in the app server's own time zone, and a timestamp column drops the offset, so on a server not running in UTC the value was stored shifted by the server's offset. Each adapter now spells such a Date as its date field columns do. MySQL (since its sessions were pinned to UTC) and SQLite already stored the right instant and are unchanged. Rows written that way before this release keep their shifted value: on PostgreSQL with a server not in UTC, a date written through an undeclared key inside a transaction may need checking.

  • #3817 9768bd0 Thanks @zeshan-rx! - Every workflow move now reaches webhooks and history. Whenever a part of a document (a language, or the shared fields) changes review stage or loses its approval, Nextly records one workflow.stage_changed webhook event for that part, in the same transaction as the move, and delivers it after the move is saved. This covers a step, an edit or a deployed change of workflow definition that withdraws an approval (also when the part stays in its stage), a deploy that renames a stage, redirects a removed one or detaches the workflow, discarding a working draft, and the workflow:move-stranded command. The event's data names the document (collection or single, its slug and id), the part, from and to (to is null when the part's review state was removed), the cause (step, edit, definition, rename, redirect, detach, discard or recovery), approvalWithdrawn and the hash of the workflow definition it was made under; its actor is the person or API key who acted, or the system. Endpoints can subscribe to workflow.stage_changed, or receive it through "all events". A comparison of versions can now start from since-submitted (the version a part last entered review at) or since-approved (the version its last approval named); a part with neither is refused with the reason, and the comparison view says which baseline it compares from. Known limits: publishing does not yet record this event when it closes a part's review; the admin's webhook form does not yet list workflow.stage_changed on its own (choose all events, or create the endpoint through the API); and history shows a workflow's events by their kind's name ("Workflow submit · English").

  • #3816 053b304 Thanks @zeshan-rx! - A workflow now tells the people it names. When a part of a document is assigned to a person (directly, or as a stage's default reviewer when the part enters that stage), that person gets a notice in their list of notices. When a part is approved or sent back with requested changes, the person accountable for the stage it left gets one: whoever brought it into review, by a step or by an edit, including on a workflow with no submit step. Each notice names the collection, the document's title, the language (or the shared fields), the step and who acted, and links to the document's edit page; once the document is deleted it says so and has no link. Where the site sends email, the notice is also emailed, unless that trigger's email is switched off in the workflow's settings (emails.assigned, emails.approved, emails.changesRequested); the notice itself is always given. Work assigned to a role tells no one, nor does a part no one is accountable for, and nobody is told of their own act. Release notice emails look and behave as before.

  • #4023 797d608 Thanks @zeshan-rx! - A production start no longer reads the review-state table's shape: bringing review state into line with changed workflows (renamed, removed and detached stages, and approvals given under an earlier definition) now runs at a development start and in nextly migrate, the deploy step, instead of at every start.

Packages

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

Upgrading

  • Run nextly migrate:create and nextly migrate right after upgrading. This release adds settings fields and tables, and until the database has them some reads refuse with a message naming nextly migrate.
  • Upgrading from alpha.75 or earlier on a host that keeps the old deployment serving during the build (such as Vercel): an alpha.75 start can rewrite the content types' registry from its own configuration after the new build's nextly migrate, dropping fields a newly added plugin contributes (the SEO tab then does not show). Run nextly migrate once more after the new deployment is live (a redeploy does it).
  • Upgrading from alpha.75 with the SEO plugin: stop all alpha.75 processes before starting alpha.76 (or start once more after the deploy). If pages changed their slug during the deploy, check SEO → Redirects for the old addresses.

Known issues in this release

  • The admin's published bundle is above its size budget (shell 330 KB gzip against 280; total 3,842 KB against 3,740), as it was in alpha.75. The next release splits the admin's root entry.
  • In the blog template under Cache Components, an unknown /blog/... address can answer 200 with noindex to search crawlers instead of 404 (the page shows "not found" and is not indexed). The next release takes blog detail pages out of the loading boundary.
  • Several end-to-end tests still describe the admin as it was before this release's redesign of the form builder, history, navigation and dashboard, and fail on their old selectors; the product screens themselves work. A few timing-based tests (start-up round trips, the list's loading outline shift) are also red. All are being fixed for the next release.