@proteinjs/db 1.32.3 → 1.34.0

package/test/util/tables/cascadeDeleteTestTables.ts

@@ -67,6 +67,19 @@ export interface Task extends Record {
   assigneeRef?: Reference<Worker> | null;
 }
 
+// --- Reverse: DynamicReferenceColumn across multiple target tables (Mission -> Pilot | Robot)
+export interface Pilot extends Record {
+  name: string;
+}
+export interface Robot extends Record {
+  name: string;
+}
+export interface Mission extends Record {
+  title: string;
+  assigneeTableName?: string | null;
+  assigneeRef?: Reference<Pilot | Robot> | null;
+}
+
 /**
  * ---------- Table Names ----------
  */
@@ -94,6 +107,11 @@ const GROUP_ARR_REV_TABLE = 'db_test_cd_groups_arr_rev';
 const WORKER_TABLE = 'db_test_cd_workers';
 const TASK_TABLE = 'db_test_cd_tasks';
 
+// Reverse (DynamicReferenceColumn, multiple targets)
+const PILOT_TABLE = 'db_test_cd_pilots';
+const ROBOT_TABLE = 'db_test_cd_robots';
+const MISSION_TABLE = 'db_test_cd_missions';
+
 /**
  * ---------- Table Classes ----------
  */
@@ -216,6 +234,33 @@ export class TaskTable extends Table<Task> {
   });
 }
 
+// Reverse: DynamicReferenceColumn across multiple target tables
+export class PilotTable extends Table<Pilot> {
+  name = PILOT_TABLE;
+  columns = withRecordColumns<Pilot>({
+    name: new StringColumn('name'),
+  });
+}
+export class RobotTable extends Table<Robot> {
+  name = ROBOT_TABLE;
+  columns = withRecordColumns<Robot>({
+    name: new StringColumn('name'),
+  });
+}
+export class MissionTable extends Table<Mission> {
+  name = MISSION_TABLE;
+  columns = withRecordColumns<Mission>({
+    title: new StringColumn('title'),
+    assigneeTableName: new DynamicReferenceTableNameColumn('assignee_table_name', 'assignee_ref'),
+    assigneeRef: new DynamicReferenceColumn<Pilot | Robot>(
+      'assignee_ref',
+      'assignee_table_name',
+      false,
+      { reverseCascadeDelete: true } // reverse: deleting a Pilot OR a Robot deletes its Missions
+    ),
+  });
+}
+
 export const cascadeDeleteTestTables = {
   MemberRef: new MemberRefTable() as Table<MemberRef>,
   GroupRef: new GroupRefTable() as Table<GroupRef>,
@@ -229,4 +274,7 @@ export const cascadeDeleteTestTables = {
   GroupArrRev: new GroupArrRevTable() as Table<GroupArrRev>,
   Worker: new WorkerTable() as Table<Worker>,
   Task: new TaskTable() as Table<Task>,
+  Pilot: new PilotTable() as Table<Pilot>,
+  Robot: new RobotTable() as Table<Robot>,
+  Mission: new MissionTable() as Table<Mission>,
 };

package/test/util/tables/sourceRecordSyncTestTables.ts

@@ -0,0 +1,84 @@
+import {
+  Record as DbRecord,
+  SourceRecord,
+  StringColumn,
+  Table,
+  withRecordColumns,
+  withSourceRecordColumns,
+} from '@proteinjs/db';
+
+/**
+ * Fixtures for the source-record sync suites ({@link sourceRecordSyncTests}): a machine-account-
+ * shaped mixed table (natural-key adoption + flag-on-removed), a default-policy table (removed =
+ * deleted), a misdeclared natural-key table (non-unique column), and the two-generation table
+ * pair driving the unique-index duplicate preflight.
+ *
+ * The `sourceRecordOptions` literals are `as`-cast to the table's options type (not inferred):
+ * the cast also compiles against PRE-change `@proteinjs/db`, so the suites can run red-before-
+ * green against the old loader (which ignores these options) instead of failing at compile time.
+ */
+
+export interface SyncMachineAccount extends SourceRecord {
+  email: string;
+  displayName?: string | null;
+  /** Declared by the loaders ('active') and patched by onSourceRemoved ('deactivated'). */
+  status?: string | null;
+  /** Runtime-owned: never declared, must survive every boot sync (the credential stand-in). */
+  runtimeNote?: string | null;
+}
+
+/** The machine-account shape: natural-key adoption by email, removed rows flagged not deleted. */
+export class SyncMachineAccountTable extends Table<SyncMachineAccount> {
+  name = 'db_test_sync_machine_account';
+  columns = withSourceRecordColumns<SyncMachineAccount>({
+    email: new StringColumn('email', {
+      unique: { unique: true, indexName: 'db_test_sync_machine_account_email_unique' },
+    }),
+    displayName: new StringColumn('display_name'),
+    status: new StringColumn('status'),
+    runtimeNote: new StringColumn('runtime_note'),
+  });
+  sourceRecordOptions = {
+    naturalKey: 'email',
+    onSourceRemoved: { update: { status: 'deactivated' } },
+  } as Table<SyncMachineAccount>['sourceRecordOptions'];
+}
+
+export interface SyncDefaultPolicyRecord extends SourceRecord {
+  email: string;
+  displayName?: string | null;
+}
+
+/** Default options: id-keyed, removed source rows are deleted (today's behavior). */
+export class SyncDefaultPolicyTable extends Table<SyncDefaultPolicyRecord> {
+  name = 'db_test_sync_default_policy';
+  columns = withSourceRecordColumns<SyncDefaultPolicyRecord>({
+    email: new StringColumn('email'),
+    displayName: new StringColumn('display_name'),
+  });
+}
+
+export interface DupePreflightRecord extends DbRecord {
+  email: string;
+}
+
+/** Generation 1: no uniqueness — the table under which duplicate rows accumulate. */
+export class DupePreflightTable extends Table<DupePreflightRecord> {
+  name = 'db_test_dupe_preflight';
+  columns = withRecordColumns<DupePreflightRecord>({
+    email: new StringColumn('email'),
+  });
+}
+
+/** Generation 2: same table, email now unique — loading it runs the alter-path preflight. */
+export class DupePreflightUniqueEmailTable extends Table<DupePreflightRecord> {
+  name = 'db_test_dupe_preflight';
+  columns = withRecordColumns<DupePreflightRecord>({
+    email: new StringColumn('email', { unique: { unique: true, indexName: 'db_test_dupe_preflight_email_unique' } }),
+  });
+}
+
+export const sourceRecordSyncTestTables = {
+  SyncMachineAccount: new SyncMachineAccountTable() as Table<SyncMachineAccount>,
+  SyncDefaultPolicy: new SyncDefaultPolicyTable() as Table<SyncDefaultPolicyRecord>,
+};