@proteinjs/db 1.55.0 → 1.55.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@proteinjs/db",
-  "version": "1.55.0",
+  "version": "1.55.1",
   "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": "e2cb123d846e60e8cddccbca06b5076a009817ed"
+  "gitHead": "195e4d8a6aae026ad6c6b8b0fbfa831a57ecb501"
 }

package/src/Columns.ts

@@ -1,6 +1,6 @@
 import moment from 'moment';
 import { v1 as uuidv1 } from 'uuid';
-import { Column, ColumnOptions, getColumnPropertyName, Table, tableByName } from './Table';
+import { Column, ColumnOptions, getColumnPropertyName, Table } from './Table';
 import { Record } from './Record';
 import { ReferenceArray } from './reference/ReferenceArray';
 import { Db } from './Db';
@@ -263,17 +263,29 @@ export class ReferenceArrayColumn<T extends Record> extends ObjectColumn<Referen
     return new ReferenceArray(this.referenceTable, ids);
   }
 
-  async beforeDelete(table: Table<any>, columnPropertyName: string, records: any[]) {
+  /**
+   * Cascade: the referenced records go with the holder. Runs through the Db the firing write
+   * hands it — its driver, its transaction context, its authority — and off the ids the column
+   * stores; nothing here opens a Db of its own or re-reads the referenced rows, either of which
+   * would run as the session's user rather than as the write (a system delete's cascade must stay
+   * system: in a background context there is no session user at all).
+   */
+  async beforeDelete(
+    table: Table<any>,
+    columnPropertyName: string,
+    records: any[],
+    getTable?: (tableName: string) => Table<any>,
+    db?: Db
+  ): Promise<void> {
     if (!this.cascadeDelete) {
       return;
     }
 
     const recordIdsToDelete: string[] = [];
     for (const record of records) {
-      const referenceArray = record[columnPropertyName] as ReferenceArray<Record>;
-      const referenceRecords = await referenceArray.get();
-      for (const referenceRecord of referenceRecords) {
-        recordIdsToDelete.push(referenceRecord.id);
+      const referenceArray = record[columnPropertyName] as ReferenceArray<Record> | null | undefined;
+      if (referenceArray) {
+        recordIdsToDelete.push(...referenceArray._ids);
       }
     }
 
@@ -281,11 +293,12 @@ export class ReferenceArrayColumn<T extends Record> extends ObjectColumn<Referen
       return;
     }
 
-    const referenceTable = tableByName(this.referenceTable);
+    // Optional in the hook contract for implementers that need neither; the Db hands both to every hook.
+    const referenceTable = getTable!(this.referenceTable);
     const qb = new QueryBuilderFactory()
       .getQueryBuilder(referenceTable)
       .condition({ field: 'id', operator: 'IN', value: recordIdsToDelete });
-    await new Db().delete(referenceTable, qb);
+    await db!.delete(referenceTable, qb);
   }
 }
 
@@ -331,7 +344,18 @@ export class ReferenceColumn<T extends Record> extends StringColumn<Reference<T>
     return reference as Reference<T>;
   }
 
-  async beforeDelete(table: Table<any>, columnPropertyName: string, records: any[]) {
+  /**
+   * Cascade: the referenced record goes with the holder. Runs through the Db the firing write
+   * hands it (its driver, transaction context and authority) off the stored id — see
+   * `ReferenceArrayColumn.beforeDelete` for why the hook never opens a Db of its own.
+   */
+  async beforeDelete(
+    table: Table<any>,
+    columnPropertyName: string,
+    records: any[],
+    getTable?: (tableName: string) => Table<any>,
+    db?: Db
+  ): Promise<void> {
     if (!this.cascadeDelete) {
       return;
     }
@@ -348,11 +372,12 @@ export class ReferenceColumn<T extends Record> extends StringColumn<Reference<T>
       return;
     }
 
-    const referenceTable = tableByName(this.referenceTable);
+    // Optional in the hook contract for implementers that need neither; the Db hands both to every hook.
+    const referenceTable = getTable!(this.referenceTable);
     const qb = new QueryBuilderFactory()
       .getQueryBuilder(referenceTable)
       .condition({ field: 'id', operator: 'IN', value: recordIdsToDelete });
-    await new Db().delete(referenceTable, qb);
+    await db!.delete(referenceTable, qb);
   }
 }
 
@@ -508,6 +533,12 @@ export class DynamicReferenceColumn<T extends Record> extends StringColumn<Refer
     return new Reference<T>(tableName, serializedFieldValue);
   }
 
+  /**
+   * Cascade: the referenced record goes with the holder, whichever table the row names. Runs
+   * through the Db the firing write hands it (its driver, transaction context and authority) off
+   * the stored ids — see `ReferenceArrayColumn.beforeDelete` for why the hook never opens a Db of
+   * its own.
+   */
   async beforeDelete(
     table: Table<any>,
     columnPropertyName: string,
@@ -519,12 +550,8 @@ export class DynamicReferenceColumn<T extends Record> extends StringColumn<Refer
       return;
     }
 
-    const getTableFn = getTable ? getTable : tableByName;
-    const dbInstance = db ? db : new Db();
-
-    // Get all referenced record IDs grouped by table
+    // The referenced ids, grouped by the table each row names
     const recordsToDelete = new Map<string, string[]>();
-
     for (const record of records) {
       const reference = record[columnPropertyName] as Reference<Record>;
       if (!reference?._id || !reference._table) {
@@ -537,17 +564,13 @@ export class DynamicReferenceColumn<T extends Record> extends StringColumn<Refer
       recordsToDelete.get(reference._table)!.push(reference._id);
     }
 
-    // Delete records from each referenced table using Promise.all to properly await all deletions
-    const entries = Array.from(recordsToDelete.entries());
-    console.log(`entries to delete: ${JSON.stringify(entries)}`);
-    for (const [tableName, ids] of entries) {
-      if (ids.length > 0) {
-        const referenceTable = getTableFn(tableName);
-        const qb = new QueryBuilderFactory()
-          .getQueryBuilder(referenceTable)
-          .condition({ field: 'id', operator: 'IN', value: ids });
-        await dbInstance.delete(referenceTable, qb);
-      }
+    // Optional in the hook contract for implementers that need neither; the Db hands both to every hook.
+    for (const [tableName, ids] of Array.from(recordsToDelete.entries())) {
+      const referenceTable = getTable!(tableName);
+      const qb = new QueryBuilderFactory()
+        .getQueryBuilder(referenceTable)
+        .condition({ field: 'id', operator: 'IN', value: ids });
+      await db!.delete(referenceTable, qb);
     }
   }
 }

package/src/Db.ts

@@ -551,6 +551,14 @@ export class Db<R extends Record = Record> implements DbService<R> {
     return recordDeleteCount;
   }
 
+  /**
+   * A column's `beforeDelete` hook runs with the authority of the write that fired it: the Db it
+   * is handed rides this instance's driver, tables and transaction context AND its system mode.
+   * The hooks cascade a delete through reference columns, and a system delete's cascade must stay
+   * system — handed a default (non-system) Db, the cascade ran as whoever the session held, which
+   * narrowed it to that user's rows inside a request and refused it outright in a background
+   * context, where a scoped table finds no user to scope the query to.
+   */
   private async runColumnBeforeDeletes(table: Table<any>, recordsToDelete: Record[]) {
     for (const columnPropertyName in table.columns) {
       const column = (table.columns as any)[columnPropertyName] as Column<any, any>;
@@ -560,7 +568,7 @@ export class Db<R extends Record = Record> implements DbService<R> {
           columnPropertyName,
           recordsToDelete,
           this.getTable,
-          new Db(this.dbDriver, this.getTable, this.transactionContextFactory)
+          new Db(this.dbDriver, this.getTable, this.transactionContextFactory, this.runAsSystem)
         );
       }
     }

package/test/reusable/CascadeDeleteTests.ts

@@ -6,6 +6,10 @@ import {
   GroupArr,
   GroupDyn,
   GroupRef,
+  GuardedHolderArr,
+  GuardedHolderDyn,
+  GuardedHolderRef,
+  GuardedMember,
   MemberArr,
   MemberArrRev,
   MemberDyn,
@@ -224,5 +228,91 @@ export const cascadeDeleteTests = (
         expect(missionsAfterPilot.length).toBe(0);
       });
     });
+
+    /**
+     * -------------------- Cascade Delete as system (holder → guarded referenced) --------------------
+     * A system delete's cascade runs with the authority of the write that fired it. The children's
+     * table refuses every non-system query (a scoped table's shape), and the delete runs in a fresh
+     * async context with no session — a background sweep's shape. Before the fix the cascade hooks
+     * ran as a non-system Db, and every case below failed with the guarded table's refusal.
+     */
+    describe('Cascade Delete as system', () => {
+      const systemDb = new Db(driver, undefined, transactionContextFactory, true);
+      const memberTable = cascadeDeleteTestTables.GuardedMember;
+
+      /** A fresh async context with nothing inherited from the test's own — a background sweep's shape. */
+      const inFreshContext = <T>(fn: () => Promise<T>): Promise<T> =>
+        new Promise<T>((resolve, reject) => {
+          setImmediate(() => {
+            fn().then(resolve, reject);
+          });
+        });
+
+      test('ReferenceColumn: a system delete of the holder deletes the guarded referenced record', async () => {
+        const holderTable = cascadeDeleteTestTables.GuardedHolderRef;
+
+        const m = await systemDb.insert(memberTable, { name: 'Gail' });
+        const h = await systemDb.insert(holderTable, {
+          holderName: 'H-Ref',
+          memberRef: new Reference<GuardedMember>(memberTable.name, m.id),
+        });
+
+        const delQb = new QueryBuilder<GuardedHolderRef>(holderTable.name).condition({
+          field: 'id',
+          operator: '=',
+          value: h.id,
+        });
+        const deleted = await inFreshContext(() => systemDb.delete(holderTable, delQb));
+        expect(deleted).toBe(1);
+
+        expect(await systemDb.query(memberTable, { id: m.id })).toHaveLength(0);
+      });
+
+      test('ReferenceArrayColumn: a system delete of the holder deletes every guarded referenced record', async () => {
+        const holderTable = cascadeDeleteTestTables.GuardedHolderArr;
+
+        const m1 = await systemDb.insert(memberTable, { name: 'Gus' });
+        const m2 = await systemDb.insert(memberTable, { name: 'Greta' });
+        const m3 = await systemDb.insert(memberTable, { name: 'Glen' });
+        const h = await systemDb.insert(holderTable, {
+          holderName: 'H-Arr',
+          memberRefs: new ReferenceArray<GuardedMember>(memberTable.name, [m1.id, m2.id]),
+        });
+
+        const delQb = new QueryBuilder<GuardedHolderArr>(holderTable.name).condition({
+          field: 'id',
+          operator: '=',
+          value: h.id,
+        });
+        const deleted = await inFreshContext(() => systemDb.delete(holderTable, delQb));
+        expect(deleted).toBe(1);
+
+        expect(await systemDb.query(memberTable, { id: m1.id })).toHaveLength(0);
+        expect(await systemDb.query(memberTable, { id: m2.id })).toHaveLength(0);
+        // The unreferenced member stands: the cascade is the stored ids, nothing wider.
+        expect(await systemDb.query(memberTable, { id: m3.id })).toHaveLength(1);
+      });
+
+      test('DynamicReferenceColumn: a system delete of the holder deletes the guarded dynamically referenced record', async () => {
+        const holderTable = cascadeDeleteTestTables.GuardedHolderDyn;
+
+        const m = await systemDb.insert(memberTable, { name: 'Gwen' });
+        const h = await systemDb.insert(holderTable, {
+          holderName: 'H-Dyn',
+          memberDynTableName: memberTable.name,
+          memberDynRef: new Reference<GuardedMember>(memberTable.name, m.id),
+        });
+
+        const delQb = new QueryBuilder<GuardedHolderDyn>(holderTable.name).condition({
+          field: 'id',
+          operator: '=',
+          value: h.id,
+        });
+        const deleted = await inFreshContext(() => systemDb.delete(holderTable, delQb));
+        expect(deleted).toBe(1);
+
+        expect(await systemDb.query(memberTable, { id: m.id })).toHaveLength(0);
+      });
+    });
   };
 };

package/test/util/tables/cascadeDeleteTestTables.ts

@@ -80,6 +80,28 @@ export interface Mission extends Record {
   assigneeRef?: Reference<Pilot | Robot> | null;
 }
 
+// --- Cascade under the write's authority: a guarded child (GuardedHolder* -> GuardedMember)
+// The child's table refuses every non-system query, the shape of a scoped table (its column adds
+// the caller's scope to each query and throws when the context carries no user). A holder deleted
+// AS SYSTEM must take its children with it: the cascade runs with the authority of the write that
+// fired it, never as whoever happens to be in the session.
+export interface GuardedMember extends Record {
+  name: string;
+}
+export interface GuardedHolderRef extends Record {
+  holderName: string;
+  memberRef?: Reference<GuardedMember> | null;
+}
+export interface GuardedHolderArr extends Record {
+  holderName: string;
+  memberRefs?: ReferenceArray<GuardedMember> | null;
+}
+export interface GuardedHolderDyn extends Record {
+  holderName: string;
+  memberDynTableName?: string | null;
+  memberDynRef?: Reference<GuardedMember> | null;
+}
+
 /**
  * ---------- Table Names ----------
  */
@@ -112,6 +134,15 @@ const PILOT_TABLE = 'db_test_cd_pilots';
 const ROBOT_TABLE = 'db_test_cd_robots';
 const MISSION_TABLE = 'db_test_cd_missions';
 
+// Cascade under the write's authority (guarded child)
+const GUARDED_MEMBER_TABLE = 'db_test_cd_guarded_members';
+const GUARDED_HOLDER_REF_TABLE = 'db_test_cd_guarded_holders_ref';
+const GUARDED_HOLDER_ARR_TABLE = 'db_test_cd_guarded_holders_arr';
+const GUARDED_HOLDER_DYN_TABLE = 'db_test_cd_guarded_holders_dyn';
+
+/** The guarded table's refusal of a non-system query — the words a suite asserts on. */
+export const GUARDED_QUERY_REFUSAL = 'no user in scope';
+
 /**
  * ---------- Table Classes ----------
  */
@@ -261,6 +292,56 @@ export class MissionTable extends Table<Mission> {
   });
 }
 
+// Cascade under the write's authority: the guarded child and its three holders
+export class GuardedMemberTable extends Table<GuardedMember> {
+  name = GUARDED_MEMBER_TABLE;
+  columns: Table<GuardedMember>['columns'] = withRecordColumns<GuardedMember>({
+    name: new StringColumn('name', {
+      // The scoped-table contract without a dependency on it: a non-system query of this table
+      // would need the context's user to scope it to, and there is none — refuse it by name.
+      addToQuery: async (qb, runAsSystem) => {
+        if (!runAsSystem) {
+          throw new Error(GUARDED_QUERY_REFUSAL);
+        }
+      },
+    }),
+  });
+}
+export class GuardedHolderRefTable extends Table<GuardedHolderRef> {
+  name = GUARDED_HOLDER_REF_TABLE;
+  columns: Table<GuardedHolderRef>['columns'] = withRecordColumns<GuardedHolderRef>({
+    holderName: new StringColumn('holder_name'),
+    memberRef: new ReferenceColumn<GuardedMember>(
+      'member_id',
+      GUARDED_MEMBER_TABLE,
+      true // cascade: deleting the holder deletes the referenced GuardedMember
+    ),
+  });
+}
+export class GuardedHolderArrTable extends Table<GuardedHolderArr> {
+  name = GUARDED_HOLDER_ARR_TABLE;
+  columns: Table<GuardedHolderArr>['columns'] = withRecordColumns<GuardedHolderArr>({
+    holderName: new StringColumn('holder_name'),
+    memberRefs: new ReferenceArrayColumn<GuardedMember>(
+      'member_ids',
+      GUARDED_MEMBER_TABLE,
+      true // cascade: deleting the holder deletes every referenced GuardedMember
+    ),
+  });
+}
+export class GuardedHolderDynTable extends Table<GuardedHolderDyn> {
+  name = GUARDED_HOLDER_DYN_TABLE;
+  columns: Table<GuardedHolderDyn>['columns'] = withRecordColumns<GuardedHolderDyn>({
+    holderName: new StringColumn('holder_name'),
+    memberDynTableName: new DynamicReferenceTableNameColumn('member_dyn_table_name', 'member_dyn_ref'),
+    memberDynRef: new DynamicReferenceColumn<GuardedMember>(
+      'member_dyn_ref',
+      'member_dyn_table_name',
+      true // cascade: deleting the holder deletes the dynamically referenced GuardedMember
+    ),
+  });
+}
+
 export const cascadeDeleteTestTables = {
   MemberRef: new MemberRefTable() as Table<MemberRef>,
   GroupRef: new GroupRefTable() as Table<GroupRef>,
@@ -277,4 +358,8 @@ export const cascadeDeleteTestTables = {
   Pilot: new PilotTable() as Table<Pilot>,
   Robot: new RobotTable() as Table<Robot>,
   Mission: new MissionTable() as Table<Mission>,
+  GuardedMember: new GuardedMemberTable() as Table<GuardedMember>,
+  GuardedHolderRef: new GuardedHolderRefTable() as Table<GuardedHolderRef>,
+  GuardedHolderArr: new GuardedHolderArrTable() as Table<GuardedHolderArr>,
+  GuardedHolderDyn: new GuardedHolderDynTable() as Table<GuardedHolderDyn>,
 };