@proteinjs/db 1.46.0 → 1.47.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@proteinjs/db",
-  "version": "1.46.0",
+  "version": "1.47.0",
   "main": "./dist/generated/index.js",
   "types": "./dist/generated/index.d.ts",
   "exports": {
@@ -66,5 +66,5 @@
     "ts-jest": "29.1.1",
     "typescript": "5.2.2"
   },
-  "gitHead": "93bcd1aaf8d85abf75c20478e324b6b5323baf2f"
+  "gitHead": "ed0fb780bf900daefb251880e49c330e7d818a1f"
 }

package/src/Table.ts

@@ -101,6 +101,31 @@ export const addUpdateFieldValues = async (table: Table<any>, record: any) => {
 /**
  * primary key is `id`
  */
+/**
+ * One act of a record table's LIST ACTIONS — the acts the table's title-row seat carries, on every
+ * form factor (the seat's create act is the `+` that opens the new-record form; its delete act
+ * removes the selected rows and shows once rows are selected). The framework performs the act by
+ * `kind`; the table declares who may see it and what it is called.
+ */
+export type RecordTableAction = {
+  /** Which seat act this declaration configures. */
+  kind: 'create' | 'delete';
+  /**
+   * Who may see the act — the `Table.auth` Identity vocabulary. Undeclared → the act keeps the
+   * doors' verdict (`create` from the insert doors, `delete` from the delete doors). Declare when
+   * the act is a DOMAIN act rather than the generic operation: an invite is minted by its own
+   * service, so the generic insert doors stay closed by design and the create act names the
+   * identity the send act serves instead. The act itself stays gated where it runs (the form,
+   * the service); this door is the affordance's.
+   */
+  door?: Identity;
+  /**
+   * The act's name — tooltip and accessible label — when the generic verb is not what the act
+   * IS (an invite is SENT). Undeclared → "Create <table>" / "Delete selected rows".
+   */
+  label?: string;
+};
+
 export abstract class Table<T extends Record> implements Loadable, CustomSerializableObject {
   public __serializerId = TableSerializerId;
   abstract name: string;
@@ -147,6 +172,15 @@ export abstract class Table<T extends Record> implements Loadable, CustomSeriali
        * redirect never needs a row load.
        */
       recordLink?: (row: Pick<T, 'id'>) => string;
+      /**
+       * The list actions the record table's title-row seat carries (see `RecordTableAction`).
+       * Undeclared, the seat derives the generic pair from the auth doors — create from the
+       * insert doors, delete-on-selection from the delete doors — exactly as every table did
+       * before this declaration existed. A declared entry CONFIGURES the act of its kind (door
+       * and/or label); kinds left undeclared keep the derivation. The seat, not the table, owns
+       * placement: every declared act renders in the same seat on desktop and phone.
+       */
+      actions?: RecordTableAction[];
     };
   };
   public auth?: {

package/src/tables/MigrationTable.ts

@@ -79,20 +79,26 @@ export class MigrationTable extends Table<Migration> {
     service: { query: { permission: 'dev' }, update: { permission: 'dev' }, delete: { permission: 'dev' } },
   };
   /**
-   * The row scan the founder actually reads (ruled 2026-09-02): WHICH migration (name — the
-   * loader's class name), what it does, how the run went, WHEN it ran ("Ran at" = start_time,
-   * the one timestamp that answers "when did it land"), how long, when it finished, and a
-   * glimpse of its output (the mono JSON snippet; the record form carries the full value).
-   * The declaration flags and the failure detail stay on the record form. Most recent run
-   * first; never-run rows last — GoogleSQL orders NULL as the least value, so start_time DESC
-   * places rows without a run after every real timestamp; ledger order (created) breaks ties.
+   * The row scan: WHICH migration (name — the loader's class name), what it does, how the run
+   * went, WHEN it ran ("Ran at" = start_time, the one timestamp that answers "when did it
+   * land"), how long, when it finished, and a glimpse of its output (the mono JSON snippet; the
+   * record form carries the full value). The declaration flags and the failure detail stay on
+   * the record form.
+   *
+   * Ordered as a ledger: newest first by `created` (id breaking ties — rows land in batches at
+   * one boot), the reverse of the order {@link MigrationRunner.runPendingMigrations} runs them
+   * in. Status plays no part: a row that never ran (`proposed`, a `manual` migration waiting
+   * for its operator) keeps its place among the rows that did, so the migrations that shipped
+   * together read together. An order by run time would push every never-run row below every
+   * run one (a never-run row has no start_time, and GoogleSQL orders NULL as the least value,
+   * last under DESC) — the pending manual migrations become the hardest rows to find.
    */
   public ui: Table<Migration>['ui'] = {
     recordTable: {
       columns: ['name', 'description', 'status', 'startTime', 'duration', 'endTime', 'output'],
       sort: [
-        { field: 'startTime', desc: true },
-        { field: 'created', desc: false },
+        { field: 'created', desc: true },
+        { field: 'id', desc: true },
       ],
     },
   };