@proteinjs/db 1.11.0 → 1.12.0

package/src/Columns.ts

@@ -1,6 +1,6 @@
 import moment from 'moment';
 import { v1 as uuidv1 } from 'uuid';
-import { Column, ColumnOptions, Table, tableByName } from './Table';
+import { Column, ColumnOptions, getColumnPropertyName, Table, tableByName } from './Table';
 import { Record } from './Record';
 import { ReferenceArray } from './reference/ReferenceArray';
 import { Db } from './Db';
@@ -350,3 +350,192 @@ export class ReferenceColumn<T extends Record> extends StringColumn<Reference<T>
     await new Db().delete(referenceTable, qb);
   }
 }
+
+/** Column type for storing table names that links to a DynamicReferenceColumn */
+export class DynamicReferenceTableNameColumn extends StringColumn<string> {
+  constructor(
+    name: string,
+    public referenceColumnName: string,
+    options?: ColumnOptions
+  ) {
+    const enhancedOptions = {
+      ...options,
+      defaultValue: async (table: Table<any>, record: any) => {
+        const colPropertyName = getColumnPropertyName(table, name);
+        const refColPropertyName = getColumnPropertyName(table, referenceColumnName);
+        if (!colPropertyName) {
+          throw new Error(`Column ${name} in table ${table.name} not found when setting default value`);
+        }
+        if (!refColPropertyName) {
+          throw new Error(`Column ${referenceColumnName} in table ${table.name} not found when setting default value`);
+        }
+
+        // No reference is being set, so we can return early
+        if (!record[refColPropertyName]) {
+          return options?.defaultValue ? await options.defaultValue(table, record) : record[colPropertyName] ?? null;
+        }
+
+        // Get the table name from the reference column
+        const { _table: referenceTableName } = record[refColPropertyName];
+
+        if (!referenceTableName) {
+          throw new Error(
+            `When inserting, table name must be set in Reference object for DynamicReferenceColumn ${referenceColumnName}`
+          );
+        }
+
+        // Assign the table name and return it, unless an defaultValue function is provided via options
+        record[colPropertyName] = referenceTableName;
+        return options?.defaultValue ? await options.defaultValue(table, record) : referenceTableName;
+      },
+      updateValue: async (table: Table<any>, updateObj: any) => {
+        const colPropertyName = getColumnPropertyName(table, name);
+        const refColPropertyName = getColumnPropertyName(table, referenceColumnName);
+        if (!colPropertyName) {
+          throw new Error(`Column ${name} in table ${table.name} not found when setting default value`);
+        }
+        if (!refColPropertyName) {
+          throw new Error(`Column ${referenceColumnName} in table ${table.name} not found when setting default value`);
+        }
+
+        // The reference column is not being updated, so we can return early
+        if (!updateObj[refColPropertyName]) {
+          return options?.updateValue?.(table, updateObj) ?? updateObj[colPropertyName] ?? undefined;
+        }
+
+        // Get the table name from the new reference column
+        const { _table: newTableName } = updateObj[refColPropertyName];
+
+        if (!newTableName) {
+          throw new Error(
+            `When inserting, table name must be set in Reference object for DynamicReferenceColumn ${referenceColumnName}`
+          );
+        }
+
+        // Assign the new table name and return it, unless an updateValue function is provided via options
+        updateObj[colPropertyName] = newTableName;
+        return options?.updateValue?.(table, updateObj) ?? newTableName;
+      },
+    };
+
+    super(
+      name,
+      Object.assign(
+        {
+          ui: {
+            hidden: true,
+          },
+        },
+        enhancedOptions
+      )
+    );
+  }
+}
+
+/**
+ * Creates a dynamic reference column that can link to records in any table
+ *
+ * The reference is stored as two columns:
+ * 1. A `DynamicReferenceTableNameColumn` storing the reference's table name, which is managed internally and should not be set or updated
+ * 2. A `DynamicReferenceColumn` which is a reference to a record
+ *
+ * @example
+ * {
+ *   referenceTableName: new DynamicReferenceTableNameColumn('reference_table_name', 'dynamic_reference'),
+ *   dynamicReference: new DynamicReferenceColumn<EntityType>(
+ *     'dynamic_reference',
+ *     'reference_table_name',    // Name of column containing table name
+ *   )
+ * }
+ */
+
+export class DynamicReferenceColumn<T extends Record> extends StringColumn<Reference<T>> {
+  constructor(
+    name: string,
+    public dynamicRefTableColName: string,
+    public cascadeDelete: boolean = false,
+    options?: ColumnOptions
+  ) {
+    super(
+      name,
+      Object.assign(
+        {
+          ui: {
+            hidden: true,
+          },
+        },
+        options
+      ),
+      36
+    );
+  }
+
+  async serialize(fieldValue: Reference<T> | null | undefined): Promise<string | null> {
+    if (fieldValue === undefined || fieldValue == null || !fieldValue._id) {
+      return null;
+    }
+
+    if (!fieldValue._table || fieldValue._table.trim() === '') {
+      throw new Error(`Table name must be provided for DynamicReferenceColumn ${this.name}`);
+    }
+
+    return fieldValue._id;
+  }
+
+  async deserialize(serializedFieldValue: string, serializedRecord: any): Promise<Reference<T> | null> {
+    const reference = new Reference('', serializedFieldValue);
+    if (reference._id === null) {
+      return null;
+    }
+
+    const tableName = serializedRecord[this.dynamicRefTableColName];
+    if (!tableName) {
+      throw new Error(`Table name not found in column ${this.dynamicRefTableColName} for reference ${this.name}`);
+    }
+
+    return new Reference<T>(tableName, serializedFieldValue);
+  }
+
+  async beforeDelete(
+    table: Table<any>,
+    columnPropertyName: string,
+    records: any[],
+    getTable?: (tableName: string) => Table<any>,
+    db?: Db
+  ): Promise<void> {
+    if (!this.cascadeDelete) {
+      return;
+    }
+
+    const getTableFn = getTable ? getTable : tableByName;
+    const dbInstance = db ? db : new Db();
+
+    // Get all referenced record IDs grouped by table
+    const recordsToDelete = new Map<string, string[]>();
+
+    for (const record of records) {
+      const reference = record[columnPropertyName] as Reference<Record>;
+      if (!reference?._id || !reference._table) {
+        continue;
+      }
+
+      if (!recordsToDelete.has(reference._table)) {
+        recordsToDelete.set(reference._table, []);
+      }
+      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);
+      }
+    }
+  }
+}

package/src/Db.ts

@@ -75,7 +75,7 @@ export class Db<R extends Record = Record> implements DbService<R> {
 
   constructor(
     dbDriver?: DbDriver,
-    getTable?: (tableName: string) => Table<any>,
+    private getTable?: (tableName: string) => Table<any>,
     transactionContextFactory?: DefaultTransactionContextFactory,
     private runAsSystem: boolean = false
   ) {
@@ -169,8 +169,8 @@ export class Db<R extends Record = Record> implements DbService<R> {
     }
 
     recordCopy = await this.tableWatcherRunner.runBeforeUpdateTableWatchers(table, recordCopy, qb);
-    const recordSearializer = new RecordSerializer<T>(table);
-    const serializedRecord = await recordSearializer.serialize(recordCopy);
+    const recordSerializer = new RecordSerializer<T>(table);
+    const serializedRecord = await recordSerializer.serialize(recordCopy);
     delete serializedRecord['id'];
     const generateUpdate = (config: DbDriverDmlStatementConfig) =>
       new StatementFactory<T>().update(
@@ -212,7 +212,13 @@ export class Db<R extends Record = Record> implements DbService<R> {
     for (const columnPropertyName in table.columns) {
       const column = (table.columns as any)[columnPropertyName] as Column<any, any>;
       if (typeof column.beforeDelete !== 'undefined') {
-        await column.beforeDelete(table, columnPropertyName, recordsToDelete);
+        await column.beforeDelete(
+          table,
+          columnPropertyName,
+          recordsToDelete,
+          this.getTable,
+          new Db(this.dbDriver, this.getTable, this.transactionContextFactory)
+        );
       }
     }
   }
@@ -257,9 +263,9 @@ export class Db<R extends Record = Record> implements DbService<R> {
     const generateQuery = (config: DbDriverQueryStatementConfig) =>
       qb.toSql(this.statementConfigFactory.getStatementConfig(config));
     const serializedRecords = await this.dbDriver.runQuery(generateQuery, this.currentTransaction);
-    const recordSearializer = new RecordSerializer(table);
+    const recordSerializer = new RecordSerializer(table);
     return await Promise.all(
-      serializedRecords.map(async (serializedRecord) => recordSearializer.deserialize(serializedRecord))
+      serializedRecords.map(async (serializedRecord) => recordSerializer.deserialize(serializedRecord))
     );
   }
 

package/src/Record.ts

@@ -87,7 +87,11 @@ export class RecordSerializer<T extends Record> {
     for (const columnName in serializedRecord) {
       const serializedFieldValue = serializedRecord[columnName];
       try {
-        const { fieldPropertyName, fieldValue } = await fieldSerializer.deserialize(columnName, serializedFieldValue);
+        const { fieldPropertyName, fieldValue } = await fieldSerializer.deserialize(
+          columnName,
+          serializedFieldValue,
+          serializedRecord
+        );
         deserialized[fieldPropertyName] = fieldValue;
       } catch (MissingFieldError) {
         omittedFields.push(columnName);
@@ -121,7 +125,7 @@ export class FieldSerializer<T extends Record> {
     return { columnName: column.name, serializedFieldValue };
   }
 
-  async deserialize(columnName: string, serializedFieldValue: any) {
+  async deserialize(columnName: string, serializedFieldValue: any, serializedRecord: SerializedRecord) {
     const columns: { [prop: string]: Column<any, any> } = this.table.columns;
     let fieldPropertyName = columnName;
     let column = columns[columnName]; // the scenario that the column name is the same as the property name
@@ -143,7 +147,7 @@ export class FieldSerializer<T extends Record> {
 
     let fieldValue = serializedFieldValue;
     if (column.deserialize) {
-      fieldValue = await column.deserialize(serializedFieldValue);
+      fieldValue = await column.deserialize(serializedFieldValue, serializedRecord);
     }
 
     return { fieldPropertyName, fieldValue };

package/src/Table.ts

@@ -1,9 +1,10 @@
 import { Loadable, SourceRepository } from '@proteinjs/reflection';
 import { CustomSerializableObject } from '@proteinjs/serializer';
-import { Record } from './Record';
+import { Record, RecordSerializer } from './Record';
 import { TableSerializerId } from './serializers/TableSerializer';
 import { QueryBuilder } from '@proteinjs/db-query';
 import { Identity, TableOperationsAuth } from './auth/TableAuth';
+import { Db } from './Db';
 
 export const isTable = (obj: any) => obj.__serializerId === TableSerializerId;
 
@@ -51,7 +52,7 @@ export const addDefaultFieldValues = async (table: Table<any>, record: any, runA
         column.options?.forceDefaultValue === true ||
         (typeof column.options?.forceDefaultValue === 'function' && column.options.forceDefaultValue(runAsSystem)))
     ) {
-      record[columnPropertyName] = await column.options.defaultValue(record);
+      record[columnPropertyName] = await column.options.defaultValue(table, record);
     }
   }
 };
@@ -60,7 +61,10 @@ export const addUpdateFieldValues = async (table: Table<any>, record: any) => {
   for (const columnPropertyName in table.columns) {
     const column = (table.columns as any)[columnPropertyName] as Column<any, any>;
     if (column.options?.updateValue) {
-      record[columnPropertyName] = await column.options.updateValue(record);
+      const value = await column.options.updateValue(table, record);
+      if (value !== undefined) {
+        record[columnPropertyName] = value;
+      }
     }
   }
 };
@@ -120,8 +124,14 @@ export type Column<T, Serialized> = {
   oldName?: string;
   options?: ColumnOptions;
   serialize?: (fieldValue: T | null | undefined) => Promise<Serialized | null | undefined>;
-  deserialize?: (serializedFieldValue: Serialized | null) => Promise<T | null | void>;
-  beforeDelete?: (table: Table<any>, columnPropertyName: string, records: any[]) => Promise<void>;
+  deserialize?: (serializedFieldValue: Serialized | null, serializedRecord: any) => Promise<T | null | void>;
+  beforeDelete?: (
+    table: Table<any>,
+    columnPropertyName: string,
+    records: any[],
+    getTable?: (tableName: string) => Table<any>,
+    db?: Db
+  ) => Promise<void>;
 };
 
 export type ColumnOptions = {
@@ -134,11 +144,11 @@ export type ColumnOptions = {
   references?: { table: string };
   nullable?: boolean;
   /** Value stored on insert */
-  defaultValue?: (insertObj: any) => Promise<any>;
+  defaultValue?: (table: Table<any>, insertObj: any) => Promise<any>;
   /** If true, the `defaultValue` function will always provide the value and override any existing value */
   forceDefaultValue?: boolean | ((runAsSystem: boolean) => boolean);
   /** Value stored on update */
-  updateValue?: (updateObj: any) => Promise<any>;
+  updateValue?: (table: Table<any>, updateObj: any) => Promise<any>;
   /** Add conditions to query; called on every query of this table */
   addToQuery?: (qb: QueryBuilder, runAsSystem: boolean) => Promise<void>;
   ui?: {

package/src/schema/TableManager.ts

@@ -3,6 +3,7 @@ import { Column, Table, getTables } from '../Table';
 import { SchemaOperations, TableChanges } from './SchemaOperations';
 import { SchemaMetadata } from './SchemaMetadata';
 import { DbDriver } from '../Db';
+import { DynamicReferenceColumn, DynamicReferenceTableNameColumn } from '../Columns';
 
 export interface ColumnTypeFactory {
   getType(column: Column<any, any>): string;
@@ -37,6 +38,8 @@ export class TableManager {
   }
 
   async loadTable(table: Table<any>): Promise<void> {
+    this.validateDynamicReferenceColumns(table);
+
     if (await this.tableExists(table)) {
       const tableChanges = await this.getTableChanges(table);
       if (this.shouldAlterTable(tableChanges)) {
@@ -51,6 +54,64 @@ export class TableManager {
     }
   }
 
+  private validateDynamicReferenceColumns(table: Table<any>): void {
+    const isDynamicRefColumn = (column: any): column is DynamicReferenceColumn<any> =>
+      typeof column.dynamicRefTableColName === 'string';
+
+    const isDynamicRefTableNameColumn = (column: any): column is DynamicReferenceTableNameColumn =>
+      typeof column.referenceColumnName === 'string';
+
+    // Quick check if there are any dynamic reference columns
+    const hasDynamicColumns = Object.values(table.columns).some(
+      (column) => isDynamicRefColumn(column) || isDynamicRefTableNameColumn(column)
+    );
+
+    if (!hasDynamicColumns) {
+      return;
+    }
+
+    interface DynamicRefColumnInfo {
+      columnName: string;
+      tableColumnName: string;
+    }
+
+    const dynamicRefColumns: DynamicRefColumnInfo[] = [];
+    const dynamicRefTableNameColumns: string[] = [];
+
+    // First pass: collect all dynamic reference columns
+    Object.entries(table.columns).forEach(([propertyName, column]) => {
+      if (isDynamicRefColumn(column)) {
+        dynamicRefColumns.push({
+          columnName: column.name,
+          tableColumnName: column.dynamicRefTableColName,
+        });
+      } else if (isDynamicRefTableNameColumn(column)) {
+        dynamicRefTableNameColumns.push(column.name);
+      }
+    });
+
+    // Second pass: validate that each DynamicReferenceColumn has its required table name column
+    dynamicRefColumns.forEach(({ columnName, tableColumnName }) => {
+      if (!dynamicRefTableNameColumns.includes(tableColumnName)) {
+        throw new Error(
+          `Table ${table.name} has a DynamicReferenceColumn '${columnName}' but is missing its required DynamicReferenceTableNameColumn '${tableColumnName}'`
+        );
+      }
+    });
+
+    // Third pass: validate that each DynamicReferenceTableNameColumn is used by a DynamicReferenceColumn
+    dynamicRefTableNameColumns.forEach((tableNameColumnName) => {
+      const hasMatchingRefColumn = dynamicRefColumns.some(
+        ({ tableColumnName }) => tableColumnName === tableNameColumnName
+      );
+      if (!hasMatchingRefColumn) {
+        throw new Error(
+          `Table ${table.name} has a DynamicReferenceTableNameColumn '${tableNameColumnName}' but no DynamicReferenceColumn references it`
+        );
+      }
+    });
+  }
+
   private shouldAlterTable(tableChanges: TableChanges) {
     if (
       tableChanges.columnsToCreate.length == 0 &&

package/src/transaction/TransactionRunner.ts

@@ -6,6 +6,12 @@ export const getTransactionRunner = () =>
   typeof self === 'undefined' ? new TransactionRunner() : (getTransactionRunnerService() as TransactionRunner);
 
 export class TransactionRunner implements TransactionRunnerService {
+  public serviceMetadata = {
+    auth: {
+      allUsers: true,
+    },
+  };
+
   async run(ops: Operation<any>[]): Promise<void> {
     const db = getDb();