@proteinjs/db 1.19.0 → 1.20.1

package/index.ts

@@ -25,11 +25,4 @@ export * from './src/services/DbService';
 export * from './src/services/MigrationRunnerService';
 export * from './src/services/TransactionRunnerService';
 
-export * from './test/reusable/TableManagerTests';
-export * from './test/reusable/CrudTests';
-export * from './test/reusable/ColumnTypesTests';
-export * from './test/reusable/DynamicReferenceColumn';
-export * from './test/reusable/TransactionTests';
-export * from './test/reusable/CascadeDeleteTests';
-
 export * from '@proteinjs/db-query';

package/package.json

@@ -1,6 +1,25 @@
 {
   "name": "@proteinjs/db",
-  "version": "1.19.0",
+  "version": "1.20.1",
+  "main": "./dist/generated/index.js",
+  "types": "./dist/generated/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/generated/index.d.ts",
+      "default": "./dist/generated/index.js"
+    },
+    "./test": {
+      "types": "./dist/generated/test/index.d.ts",
+      "default": "./dist/generated/test/index.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "test": [
+        "dist/generated/test/index.d.ts"
+      ]
+    }
+  },
   "description": "Db",
   "publishConfig": {
     "access": "public"
@@ -17,24 +36,24 @@
   "license": "MIT",
   "scripts": {
     "clean": "rm -rf dist/ node_modules/ generated/",
-    "build": "reflection-build && REFLECTION_SOURCE_DIRS=test,src reflection-build && tsc",
+    "build": "reflection-build && REFLECTION_SOURCE_DIRS=test,src REFLECTION_EXPORT_FROM=test/index.ts reflection-build && tsc",
     "watch": "reflection-watch",
     "test": "jest"
   },
   "dependencies": {
-    "@proteinjs/db-query": "^1.4.0",
-    "@proteinjs/logger": "1.0.11",
+    "@proteinjs/db-query": "^1.4.1",
+    "@proteinjs/logger": "1.0.12",
     "@proteinjs/reflection": "1.1.10",
-    "@proteinjs/serializer": "1.1.1",
-    "@proteinjs/server-api": "2.0.1",
-    "@proteinjs/service": "1.2.7",
-    "@proteinjs/user-auth": "1.1.6",
+    "@proteinjs/serializer": "1.1.2",
+    "@proteinjs/server-api": "2.0.2",
+    "@proteinjs/service": "1.2.8",
+    "@proteinjs/user-auth": "1.1.7",
     "@proteinjs/util": "1.5.0",
     "moment": "2.29.4",
     "uuid": "8.3.0"
   },
   "devDependencies": {
-    "@proteinjs/reflection-build": "1.3.0",
+    "@proteinjs/reflection-build": "1.4.1",
     "@types/jest": "29.5.5",
     "@types/node": "14.0.27",
     "@types/uuid": "8.3.0",
@@ -46,12 +65,5 @@
     "jest": "29.7.0",
     "ts-jest": "29.1.1",
     "typescript": "5.2.2"
-  },
-  "main": "./dist/generated/index.js",
-  "types": "./dist/generated/index.d.ts",
-  "exports": {
-    ".": "./dist/generated/index.js",
-    "./test": "./dist/generated/test/index.js"
-  },
-  "gitHead": "5f31f973e8ce8d8810b344b15c22ec0b99018a06"
+  }
 }

package/src/Db.ts

@@ -33,6 +33,9 @@ export const getDb = <R extends Record = Record>() =>
   typeof self === 'undefined' ? new Db<R>() : (getDbService() as Db<R>);
 export const getDbAsSystem = <R extends Record = Record>() => new Db<R>(undefined, undefined, undefined, true);
 
+const getEnvVar = (key: string): string | undefined =>
+  typeof process !== 'undefined' && process.env ? process.env[key] : undefined;
+
 export type DbDriverQueryStatementConfig = ParameterizationConfig & {
   prefixTablesWithDb?: boolean;
   getDriverColumnType?: (tableName: string, columnName: string) => string;
@@ -65,7 +68,8 @@ export interface DbDriver {
 export class Db<R extends Record = Record> implements DbService<R> {
   private static defaultDbDriver: DbDriver;
   private dbDriver: DbDriver;
-  private logger = new Logger({ name: this.constructor.name });
+  private getTable: (tableName: string) => Table<any>;
+  private logger = new Logger({ name: this.constructor.name, logLevel: getEnvVar('DB_LOG_LEVEL') as any });
   private statementConfigFactory: StatementConfigFactory;
   private auth = new TableAuth();
   private tableWatcherRunner = new TableWatcherRunner<R>();
@@ -79,11 +83,12 @@ export class Db<R extends Record = Record> implements DbService<R> {
 
   constructor(
     dbDriver?: DbDriver,
-    private getTable?: (tableName: string) => Table<any>,
+    getTable?: (tableName: string) => Table<any>,
     transactionContextFactory?: DefaultTransactionContextFactory,
     private runAsSystem: boolean = false
   ) {
     this.dbDriver = dbDriver ? dbDriver : Db.getDefaultDbDriver();
+    this.getTable = getTable ?? tableByName;
     this.statementConfigFactory = new StatementConfigFactory(this.dbDriver.getDbName(), getTable);
     this.transactionContextFactory = transactionContextFactory
       ? transactionContextFactory
@@ -241,7 +246,7 @@ export class Db<R extends Record = Record> implements DbService<R> {
     }
 
     for (const cascadeDeleteReference of table.cascadeDeleteReferences()) {
-      const referenceTable = tableByName(cascadeDeleteReference.table);
+      const referenceTable = this.getTable(cascadeDeleteReference.table);
       const referenceColumnPropertyName = getColumnPropertyName(referenceTable, cascadeDeleteReference.referenceColumn);
       this.logger.info({
         message: `Executing cascade delete for table: ${table.name}`,

package/src/TableWatcherRunner.ts

@@ -4,9 +4,12 @@ import { Record } from './Record';
 import { Table } from './Table';
 import { QueryBuilder } from '@proteinjs/db-query';
 
+const getEnvVar = (key: string): string | undefined =>
+  typeof process !== 'undefined' && process.env ? process.env[key] : undefined;
+
 export class TableWatcherRunner<R extends Record = Record> {
   private static tableWatcherMap: TableWatcherMap;
-  private logger = new Logger({ name: this.constructor.name });
+  private logger = new Logger({ name: this.constructor.name, logLevel: getEnvVar('DB_LOG_LEVEL') as any });
 
   constructor() {
     if (!TableWatcherRunner.tableWatcherMap) {

package/src/schema/TableManager.ts

@@ -5,12 +5,15 @@ import { SchemaMetadata } from './SchemaMetadata';
 import { DbDriver } from '../Db';
 import { DynamicReferenceColumn, DynamicReferenceTableNameColumn } from '../Columns';
 
+const getEnvVar = (key: string): string | undefined =>
+  typeof process !== 'undefined' && process.env ? process.env[key] : undefined;
+
 export interface ColumnTypeFactory {
   getType(column: Column<any, any>): string;
 }
 
 export class TableManager {
-  private logger = new Logger({ name: this.constructor.name });
+  private logger = new Logger({ name: this.constructor.name, logLevel: getEnvVar('DB_LOG_LEVEL') as any });
   public columnTypeFactory: ColumnTypeFactory;
   public schemaOperations: SchemaOperations;
   public schemaMetadata: SchemaMetadata;

package/test/index.ts

@@ -0,0 +1,13 @@
+export * from './reusable/TableManagerTests';
+export * from './reusable/CrudTests';
+export * from './reusable/ColumnTypesTests';
+export * from './reusable/DynamicReferenceColumnTests';
+export * from './reusable/TransactionTests';
+export * from './reusable/CascadeDeleteTests';
+
+export * from './util/tables/cascadeDeleteTestTables';
+export * from './util/tables/columnTypesTestTables';
+export * from './util/tables/crudTestTables';
+export * from './util/tables/dynamicReferenceColumnTestTables';
+export * from './util/tables/tableManagerTestTables';
+export * from './util/tables/transactionTestTables';

package/test/reusable/CascadeDeleteTests.ts

@@ -4,261 +4,29 @@ import {
   ReferenceArrayColumn,
   DynamicReferenceColumn,
   DynamicReferenceTableNameColumn,
-} from '../../src/Columns';
-import { Db, DbDriver } from '../../src/Db';
-import { Table } from '../../src/Table';
-import { withRecordColumns, Record } from '../../src/Record';
-import { Reference } from '../../src/reference/Reference';
-import { ReferenceArray } from '../../src/reference/ReferenceArray';
+  Db,
+  DbDriver,
+  Table,
+  withRecordColumns,
+  Record,
+  Reference,
+  ReferenceArray,
+  DefaultTransactionContextFactory,
+} from '@proteinjs/db';
 import { QueryBuilder } from '@proteinjs/db-query';
-import { DefaultTransactionContextFactory } from '../../src/transaction/TransactionContextFactory';
-
-/**
- * ---------- Test Entities ----------
- * (Isolated per scenario so we never mount multiple cascade columns
- *  to the same target on a single table.)
- */
-
-// --- Cascade: ReferenceColumn (GroupRef -> MemberRef)
-interface MemberRef extends Record {
-  name: string;
-}
-interface GroupRef extends Record {
-  groupName: string;
-  memberRef?: Reference<MemberRef> | null;
-}
-
-// --- Cascade: ReferenceArrayColumn (GroupArr -> MemberArr[])
-interface MemberArr extends Record {
-  name: string;
-}
-interface GroupArr extends Record {
-  groupName: string;
-  memberRefs?: ReferenceArray<MemberArr> | null;
-}
-
-// --- Cascade: DynamicReferenceColumn (GroupDyn -> MemberDyn)
-interface MemberDyn extends Record {
-  name: string;
-}
-interface GroupDyn extends Record {
-  groupName: string;
-  memberDynTableName?: string | null;
-  memberDynRef?: Reference<MemberDyn> | null;
-}
-
-// --- Reverse: ReferenceColumn (Comment -> Post)
-interface Post extends Record {
-  title: string;
-}
-interface Comment extends Record {
-  text: string;
-  postRef?: Reference<Post> | null;
-}
-
-// --- Reverse: ReferenceArrayColumn (GroupArrRev -> MemberArrRev[])
-interface MemberArrRev extends Record {
-  name: string;
-}
-interface GroupArrRev extends Record {
-  groupName: string;
-  memberRefs?: ReferenceArray<MemberArrRev> | null;
-}
-
-// --- Reverse: DynamicReferenceColumn (Task -> Worker)
-interface Worker extends Record {
-  name: string;
-}
-interface Task extends Record {
-  title: string;
-  assigneeTableName?: string | null;
-  assigneeRef?: Reference<Worker> | null;
-}
-
-/**
- * ---------- Table Names ----------
- */
-// Cascade (ReferenceColumn)
-const MEMBER_REF_TABLE = 'db_test_cd_members_ref';
-const GROUP_REF_TABLE = 'db_test_cd_groups_ref';
-
-// Cascade (ReferenceArrayColumn)
-const MEMBER_ARR_TABLE = 'db_test_cd_members_arr';
-const GROUP_ARR_TABLE = 'db_test_cd_groups_arr';
-
-// Cascade (DynamicReferenceColumn)
-const MEMBER_DYN_TABLE = 'db_test_cd_members_dyn';
-const GROUP_DYN_TABLE = 'db_test_cd_groups_dyn';
-
-// Reverse (ReferenceColumn)
-const POST_TABLE = 'db_test_cd_posts';
-const COMMENT_TABLE = 'db_test_cd_comments';
-
-// Reverse (ReferenceArrayColumn)
-const MEMBER_ARR_REV_TABLE = 'db_test_cd_members_arr_rev';
-const GROUP_ARR_REV_TABLE = 'db_test_cd_groups_arr_rev';
-
-// Reverse (DynamicReferenceColumn)
-const WORKER_TABLE = 'db_test_cd_workers';
-const TASK_TABLE = 'db_test_cd_tasks';
-
-/**
- * ---------- Table Classes ----------
- */
-// Cascade: ReferenceColumn
-export class MemberRefTable extends Table<MemberRef> {
-  name = MEMBER_REF_TABLE;
-  columns = withRecordColumns<MemberRef>({
-    name: new StringColumn('name'),
-  });
-}
-export class GroupRefTable extends Table<GroupRef> {
-  name = GROUP_REF_TABLE;
-  columns = withRecordColumns<GroupRef>({
-    groupName: new StringColumn('group_name'),
-    memberRef: new ReferenceColumn<MemberRef>(
-      'member_id',
-      MEMBER_REF_TABLE,
-      true // cascade: deleting GroupRef deletes the referenced MemberRef
-    ),
-  });
-}
-
-// Cascade: ReferenceArrayColumn
-export class MemberArrTable extends Table<MemberArr> {
-  name = MEMBER_ARR_TABLE;
-  columns = withRecordColumns<MemberArr>({
-    name: new StringColumn('name'),
-  });
-}
-export class GroupArrTable extends Table<GroupArr> {
-  name = GROUP_ARR_TABLE;
-  columns = withRecordColumns<GroupArr>({
-    groupName: new StringColumn('group_name'),
-    memberRefs: new ReferenceArrayColumn<MemberArr>(
-      'member_ids',
-      MEMBER_ARR_TABLE,
-      true // cascade: deleting GroupArr deletes all referenced MemberArr
-    ),
-  });
-}
-
-// Cascade: DynamicReferenceColumn
-export class MemberDynTable extends Table<MemberDyn> {
-  name = MEMBER_DYN_TABLE;
-  columns = withRecordColumns<MemberDyn>({
-    name: new StringColumn('name'),
-  });
-}
-export class GroupDynTable extends Table<GroupDyn> {
-  name = GROUP_DYN_TABLE;
-  columns = withRecordColumns<GroupDyn>({
-    groupName: new StringColumn('group_name'),
-    memberDynTableName: new DynamicReferenceTableNameColumn('member_dyn_table_name', 'member_dyn_ref'),
-    memberDynRef: new DynamicReferenceColumn<MemberDyn>(
-      'member_dyn_ref',
-      'member_dyn_table_name',
-      true // cascade: deleting GroupDyn deletes dynamically referenced MemberDyn
-    ),
-  });
-}
-
-// Reverse: ReferenceColumn
-export class PostTable extends Table<Post> {
-  name = POST_TABLE;
-  columns = withRecordColumns<Post>({
-    title: new StringColumn('title'),
-  });
-}
-export class CommentTable extends Table<Comment> {
-  name = COMMENT_TABLE;
-  columns = withRecordColumns<Comment>({
-    text: new StringColumn('text'),
-    postRef: new ReferenceColumn<Post>(
-      'post_id',
-      POST_TABLE,
-      false,
-      { reverseCascadeDelete: true } // reverse: deleting Post deletes Comment
-    ),
-  });
-}
-
-// Reverse: ReferenceArrayColumn
-export class MemberArrRevTable extends Table<MemberArrRev> {
-  name = MEMBER_ARR_REV_TABLE;
-  columns = withRecordColumns<MemberArrRev>({
-    name: new StringColumn('name'),
-  });
-}
-export class GroupArrRevTable extends Table<GroupArrRev> {
-  name = GROUP_ARR_REV_TABLE;
-  columns = withRecordColumns<GroupArrRev>({
-    groupName: new StringColumn('group_name'),
-    memberRefs: new ReferenceArrayColumn<MemberArrRev>(
-      'member_ids',
-      MEMBER_ARR_REV_TABLE,
-      false,
-      { reverseCascadeDelete: true } // reverse: deleting any MemberArrRev deletes the GroupArrRev
-    ),
-  });
-}
-
-// Reverse: DynamicReferenceColumn
-export class WorkerTable extends Table<Worker> {
-  name = WORKER_TABLE;
-  columns = withRecordColumns<Worker>({
-    name: new StringColumn('name'),
-  });
-}
-export class TaskTable extends Table<Task> {
-  name = TASK_TABLE;
-  columns = withRecordColumns<Task>({
-    title: new StringColumn('title'),
-    assigneeTableName: new DynamicReferenceTableNameColumn('assignee_table_name', 'assignee_ref'),
-    assigneeRef: new DynamicReferenceColumn<Worker>(
-      'assignee_ref',
-      'assignee_table_name',
-      false,
-      { reverseCascadeDelete: true } // reverse: deleting Worker deletes Task
-    ),
-  });
-}
-
-/** getTable resolver for Db */
-export const getCascadeDeleteTestTable = (tableName: string) => {
-  switch (tableName) {
-    // Cascade
-    case MEMBER_REF_TABLE:
-      return new MemberRefTable();
-    case GROUP_REF_TABLE:
-      return new GroupRefTable();
-    case MEMBER_ARR_TABLE:
-      return new MemberArrTable();
-    case GROUP_ARR_TABLE:
-      return new GroupArrTable();
-    case MEMBER_DYN_TABLE:
-      return new MemberDynTable();
-    case GROUP_DYN_TABLE:
-      return new GroupDynTable();
-
-    // Reverse
-    case POST_TABLE:
-      return new PostTable();
-    case COMMENT_TABLE:
-      return new CommentTable();
-    case MEMBER_ARR_REV_TABLE:
-      return new MemberArrRevTable();
-    case GROUP_ARR_REV_TABLE:
-      return new GroupArrRevTable();
-    case WORKER_TABLE:
-      return new WorkerTable();
-    case TASK_TABLE:
-      return new TaskTable();
-
-    default:
-      throw new Error(`Cannot find test table: ${tableName}`);
-  }
-};
+import { DbTestEnvironment } from '../util/DbTestEnvironment';
+import {
+  cascadeDeleteTestTables,
+  GroupArr,
+  GroupDyn,
+  GroupRef,
+  MemberArr,
+  MemberArrRev,
+  MemberDyn,
+  MemberRef,
+  Post,
+  Worker,
+} from '../util/tables/cascadeDeleteTestTables';
 
 /**
  * Public test suite factory.
@@ -269,69 +37,19 @@ export const cascadeDeleteTests = (
   dropTable: (table: Table<any>) => Promise<void>
 ) => {
   return () => {
-    const db = new Db(driver, getCascadeDeleteTestTable, transactionContextFactory);
-
-    beforeAll(async () => {
-      if (driver.start) {
-        await driver.start();
-      }
-    });
-
-    beforeEach(async () => {
-      // Ensure tables exist and are in a known state for each test
-      await driver.getTableManager().loadTable(new MemberRefTable());
-      await driver.getTableManager().loadTable(new GroupRefTable());
-
-      await driver.getTableManager().loadTable(new MemberArrTable());
-      await driver.getTableManager().loadTable(new GroupArrTable());
-
-      await driver.getTableManager().loadTable(new MemberDynTable());
-      await driver.getTableManager().loadTable(new GroupDynTable());
-
-      await driver.getTableManager().loadTable(new PostTable());
-      await driver.getTableManager().loadTable(new CommentTable());
+    const db = new Db(driver, undefined, transactionContextFactory);
+    const testEnv = new DbTestEnvironment(driver, dropTable);
 
-      await driver.getTableManager().loadTable(new MemberArrRevTable());
-      await driver.getTableManager().loadTable(new GroupArrRevTable());
-
-      await driver.getTableManager().loadTable(new WorkerTable());
-      await driver.getTableManager().loadTable(new TaskTable());
-    });
-
-    afterEach(async () => {
-      // Drop referencing tables first, then referenced
-      await dropTable(new GroupRefTable());
-      await dropTable(new MemberRefTable());
-
-      await dropTable(new GroupArrTable());
-      await dropTable(new MemberArrTable());
-
-      await dropTable(new GroupDynTable());
-      await dropTable(new MemberDynTable());
-
-      await dropTable(new CommentTable());
-      await dropTable(new PostTable());
-
-      await dropTable(new GroupArrRevTable());
-      await dropTable(new MemberArrRevTable());
-
-      await dropTable(new TaskTable());
-      await dropTable(new WorkerTable());
-    });
-
-    afterAll(async () => {
-      if (driver.stop) {
-        await driver.stop();
-      }
-    });
+    beforeAll(async () => await testEnv.beforeAll(), 10000);
+    afterAll(async () => await testEnv.afterAll(), 10000);
 
     /**
      * -------------------- Cascade Delete (holder → referenced) --------------------
      */
     describe('Cascade Delete', () => {
       test('ReferenceColumn: deleting holder deletes referenced record', async () => {
-        const memberTable = new MemberRefTable();
-        const groupTable = new GroupRefTable();
+        const memberTable = cascadeDeleteTestTables.MemberRef;
+        const groupTable = cascadeDeleteTestTables.GroupRef;
 
         const m = await db.insert(memberTable, { name: 'Alice' });
         const g = await db.insert(groupTable, {
@@ -352,8 +70,8 @@ export const cascadeDeleteTests = (
       });
 
       test('ReferenceArrayColumn: deleting holder deletes all referenced records', async () => {
-        const memberTable = new MemberArrTable();
-        const groupTable = new GroupArrTable();
+        const memberTable = cascadeDeleteTestTables.MemberArr;
+        const groupTable = cascadeDeleteTestTables.GroupArr;
 
         const m1 = await db.insert(memberTable, { name: 'Bob' });
         const m2 = await db.insert(memberTable, { name: 'Charlie' });
@@ -378,8 +96,8 @@ export const cascadeDeleteTests = (
       });
 
       test('DynamicReferenceColumn: deleting holder deletes dynamically referenced record', async () => {
-        const memberTable = new MemberDynTable();
-        const groupTable = new GroupDynTable();
+        const memberTable = cascadeDeleteTestTables.MemberDyn;
+        const groupTable = cascadeDeleteTestTables.GroupDyn;
 
         const m = await db.insert(memberTable, { name: 'Dina' });
         const g = await db.insert(groupTable, {
@@ -406,8 +124,8 @@ export const cascadeDeleteTests = (
      */
     describe('Reverse Cascade Delete', () => {
       test('ReferenceColumn: deleting referenced record deletes the holder', async () => {
-        const postTable = new PostTable();
-        const commentTable = new CommentTable();
+        const postTable = cascadeDeleteTestTables.Post;
+        const commentTable = cascadeDeleteTestTables.Comment;
 
         const post = await db.insert(postTable, { title: 'Hello World' });
         await db.insert(commentTable, {
@@ -428,8 +146,8 @@ export const cascadeDeleteTests = (
       });
 
       test('ReferenceArrayColumn: deleting a referenced record deletes the holder', async () => {
-        const memberTable = new MemberArrRevTable();
-        const groupTable = new GroupArrRevTable();
+        const memberTable = cascadeDeleteTestTables.MemberArrRev;
+        const groupTable = cascadeDeleteTestTables.GroupArrRev;
 
         const m1 = await db.insert(memberTable, { name: 'Alice' });
         const m2 = await db.insert(memberTable, { name: 'Bob' });
@@ -452,8 +170,8 @@ export const cascadeDeleteTests = (
       });
 
       test('DynamicReferenceColumn: deleting referenced record deletes the holder', async () => {
-        const workerTable = new WorkerTable();
-        const taskTable = new TaskTable();
+        const workerTable = cascadeDeleteTestTables.Worker;
+        const taskTable = cascadeDeleteTestTables.Task;
 
         const worker = await db.insert(workerTable, { name: 'Wally Worker' });
         await db.insert(taskTable, {