@proteinjs/db 1.19.0 → 1.20.0

package/test/reusable/DynamicReferenceColumnTests.ts

@@ -0,0 +1,342 @@
+import { Db, DbDriver, Reference, Table } from '@proteinjs/db';
+import { QueryBuilder } from '@proteinjs/db-query';
+import { DbTestEnvironment } from '../util/DbTestEnvironment';
+import {
+  Designer,
+  dynamicReferenceTestTables,
+  Engineer,
+  ProjectAssignment,
+  ProjectManager,
+} from '../util/tables/dynamicReferenceColumnTestTables';
+
+export const dynamicReferenceColumnTests = (driver: DbDriver, dropTable: (table: Table<any>) => Promise<void>) => {
+  return () => {
+    const db = new Db(driver);
+    const testEnv = new DbTestEnvironment(driver, dropTable);
+
+    beforeAll(async () => await testEnv.beforeAll(), 10000);
+    afterAll(async () => await testEnv.afterAll(), 10000);
+
+    test('should handle references to different types', async () => {
+      // Create an engineer
+      const engineer = await db.insert(dynamicReferenceTestTables.Engineer, {
+        name: 'John Doe',
+        yearsOfExperience: 5,
+      });
+
+      // Create a designer
+      const designer = await db.insert(dynamicReferenceTestTables.Designer, {
+        name: 'Jane Smith',
+        specialization: 'UI/UX',
+      });
+
+      // Assign both to different projects
+      const engineerAssignment = await db.insert(dynamicReferenceTestTables.ProjectAssignment, {
+        projectName: 'Backend API',
+        employeeRef: new Reference(dynamicReferenceTestTables.Engineer.name, engineer.id),
+        startDate: '2024-01-01',
+      });
+
+      const designerAssignment = await db.insert(dynamicReferenceTestTables.ProjectAssignment, {
+        projectName: 'Website Redesign',
+        employeeRef: new Reference(dynamicReferenceTestTables.Designer.name, designer.id),
+        startDate: '2024-01-15',
+      });
+
+      // Verify engineer assignment
+      const fetchedEngineerAssignment = await db.get(dynamicReferenceTestTables.ProjectAssignment, {
+        id: engineerAssignment.id,
+      });
+      expect(fetchedEngineerAssignment.employeeRef?._table).toBe(dynamicReferenceTestTables.Engineer.name);
+      expect(fetchedEngineerAssignment.employeeRef?._id).toBe(engineer.id);
+      expect(fetchedEngineerAssignment.employeeTableName).toBe(dynamicReferenceTestTables.Engineer.name);
+
+      // Verify designer assignment
+      const fetchedDesignerAssignment = await db.get(dynamicReferenceTestTables.ProjectAssignment, {
+        id: designerAssignment.id,
+      });
+      expect(fetchedDesignerAssignment.employeeRef?._table).toBe(dynamicReferenceTestTables.Designer.name);
+      expect(fetchedDesignerAssignment.employeeRef?._id).toBe(designer.id);
+      expect(fetchedDesignerAssignment.employeeTableName).toBe(dynamicReferenceTestTables.Designer.name);
+    });
+
+    test('should cascade delete multiple types of records when references are deleted', async () => {
+      // Create employees
+      const engineer = await db.insert(dynamicReferenceTestTables.Engineer, {
+        name: 'John Doe',
+        yearsOfExperience: 5,
+      });
+
+      const projectManager = await db.insert(dynamicReferenceTestTables.ProjectManager, {
+        name: 'Alice Brown',
+        certificate: 'Scrum Master',
+      });
+
+      const designer = await db.insert(dynamicReferenceTestTables.Designer, {
+        name: 'Jane Smith',
+        specialization: 'UI/UX',
+      });
+
+      // Create assignments
+      const engineerAssignment = await db.insert(dynamicReferenceTestTables.ProjectAssignment, {
+        projectName: 'Backend API',
+        employeeRef: new Reference<Engineer>(dynamicReferenceTestTables.Engineer.name, engineer.id),
+        startDate: '2024-01-01',
+      });
+
+      const pmAssignment = await db.insert(dynamicReferenceTestTables.ProjectAssignment, {
+        projectName: 'Project Planning',
+        employeeRef: new Reference<ProjectManager>(dynamicReferenceTestTables.ProjectManager.name, projectManager.id),
+        startDate: '2024-01-10',
+      });
+
+      const designerAssignment = await db.insert(dynamicReferenceTestTables.ProjectAssignment, {
+        projectName: 'Website Redesign',
+        employeeRef: new Reference<Designer>(dynamicReferenceTestTables.Designer.name, designer.id),
+        startDate: '2024-01-15',
+      });
+
+      // Delete the engineer's and PM's assignments - should cascade delete both
+      const deleteQuery = new QueryBuilder<ProjectAssignment>(
+        dynamicReferenceTestTables.ProjectAssignment.name
+      ).condition({
+        field: 'id',
+        operator: 'IN',
+        value: [engineerAssignment.id, pmAssignment.id],
+      });
+      const recordsDeleted = await db.delete(dynamicReferenceTestTables.ProjectAssignment, deleteQuery);
+
+      expect(recordsDeleted).toBe(2);
+
+      // Verify engineer and PM were deleted but designer remains
+      const remainingEngineers = await db.query(dynamicReferenceTestTables.Engineer, { id: engineer.id });
+      expect(remainingEngineers.length).toBe(0); // Engineer should be deleted
+
+      const remainingPMs = await db.query(dynamicReferenceTestTables.ProjectManager, { id: projectManager.id });
+      expect(remainingPMs.length).toBe(0); // PM should be deleted
+
+      const remainingDesigners = await db.query(dynamicReferenceTestTables.Designer, { id: designer.id });
+      expect(remainingDesigners.length).toBe(1); // Designer should still exist
+      expect(remainingDesigners[0].id).toBe(designer.id);
+
+      // Only designer assignment should still exist
+      const remainingAssignmentsQuery = new QueryBuilder<ProjectAssignment>(
+        dynamicReferenceTestTables.ProjectAssignment.name
+      ).condition({
+        field: 'id',
+        operator: 'IN',
+        value: [engineerAssignment.id, pmAssignment.id, designerAssignment.id],
+      });
+      const remainingAssignments = await db.query(
+        dynamicReferenceTestTables.ProjectAssignment,
+        remainingAssignmentsQuery
+      );
+      expect(remainingAssignments.length).toBe(1);
+      expect(remainingAssignments[0].id).toBe(designerAssignment.id);
+    });
+
+    test('should allow changing table name when updating reference to new type', async () => {
+      // Create employees
+      const engineer = await db.insert(dynamicReferenceTestTables.Engineer, {
+        name: 'John Doe',
+        yearsOfExperience: 5,
+      });
+
+      const designer = await db.insert(dynamicReferenceTestTables.Designer, {
+        name: 'Jane Smith',
+        specialization: 'UI/UX',
+      });
+
+      // Create initial assignment to engineer
+      const assignment = await db.insert(dynamicReferenceTestTables.ProjectAssignment, {
+        projectName: 'Full Stack App',
+        employeeRef: new Reference(dynamicReferenceTestTables.Engineer.name, engineer.id),
+        startDate: '2024-01-01',
+      });
+
+      // Reassign to designer
+      await db.update(
+        dynamicReferenceTestTables.ProjectAssignment,
+        {
+          employeeRef: new Reference(dynamicReferenceTestTables.Designer.name, designer.id),
+        },
+        { id: assignment.id }
+      );
+
+      // Verify reassignment
+      const updatedAssignment = await db.get(dynamicReferenceTestTables.ProjectAssignment, { id: assignment.id });
+      expect(updatedAssignment.employeeRef).toBeDefined();
+      expect(updatedAssignment.employeeRef?._table).toBe(dynamicReferenceTestTables.Designer.name);
+      expect(updatedAssignment.employeeRef?._id).toBe(designer.id);
+      expect(updatedAssignment.employeeTableName).toBe(dynamicReferenceTestTables.Designer.name);
+    });
+
+    describe('DynamicReferenceTableNameColumn behavior', () => {
+      test('should handle defaultValue logic correctly', async () => {
+        // Test case 1: Reference column is populated
+        const engineer = await db.insert(dynamicReferenceTestTables.Engineer, {
+          name: 'John Doe',
+          yearsOfExperience: 5,
+        });
+
+        const assignment = await db.insert(dynamicReferenceTestTables.ProjectAssignment, {
+          projectName: 'Test Project',
+          employeeRef: new Reference(dynamicReferenceTestTables.Engineer.name, engineer.id),
+          startDate: '2024-01-01',
+        });
+
+        // Verify table name was set correctly from reference
+        expect(assignment.employeeTableName).toBe(dynamicReferenceTestTables.Engineer.name);
+
+        // Test case 2: Reference column is null
+        const assignmentNoRef = await db.insert(dynamicReferenceTestTables.ProjectAssignment, {
+          projectName: 'No Reference Project',
+          employeeRef: null,
+          startDate: '2024-01-01',
+        });
+
+        // Verify table name is null when reference is null
+        expect(assignmentNoRef.employeeTableName).toBeNull();
+
+        // Test case 3: Reference without table name should throw
+        await expect(
+          db.insert(dynamicReferenceTestTables.ProjectAssignment, {
+            projectName: 'Invalid Reference',
+            employeeRef: new Reference('', engineer.id), // Empty table name
+            startDate: '2024-01-01',
+          })
+        ).rejects.toThrow(/table name must be set in Reference object/);
+      });
+
+      test('should handle updateValue logic correctly', async () => {
+        // Create initial records
+        const engineer = await db.insert(dynamicReferenceTestTables.Engineer, {
+          name: 'John Doe',
+          yearsOfExperience: 5,
+        });
+
+        const designer = await db.insert(dynamicReferenceTestTables.Designer, {
+          name: 'Jane Smith',
+          specialization: 'UI/UX',
+        });
+
+        const assignment = await db.insert(dynamicReferenceTestTables.ProjectAssignment, {
+          projectName: 'Initial Project',
+          employeeRef: new Reference(dynamicReferenceTestTables.Engineer.name, engineer.id),
+          startDate: '2024-01-01',
+        });
+
+        // Test case 1: Update reference to new table
+        await db.update(
+          dynamicReferenceTestTables.ProjectAssignment,
+          {
+            employeeRef: new Reference(dynamicReferenceTestTables.Designer.name, designer.id),
+          },
+          { id: assignment.id }
+        );
+
+        const updatedAssignment = await db.get(dynamicReferenceTestTables.ProjectAssignment, { id: assignment.id });
+        expect(updatedAssignment.employeeTableName).toBe(dynamicReferenceTestTables.Designer.name);
+
+        // Test case 2: Update without changing reference
+        await db.update(
+          dynamicReferenceTestTables.ProjectAssignment,
+          {
+            projectName: 'Updated Project Name',
+          },
+          { id: assignment.id }
+        );
+
+        const unchangedAssignment = await db.get(dynamicReferenceTestTables.ProjectAssignment, { id: assignment.id });
+        expect(unchangedAssignment.employeeTableName).toBe(dynamicReferenceTestTables.Designer.name); // Should retain previous value
+
+        // Test case 3: Update with invalid reference should throw
+        await expect(
+          db.update(
+            dynamicReferenceTestTables.ProjectAssignment,
+            {
+              employeeRef: new Reference('', designer.id), // Empty table name
+            },
+            { id: assignment.id }
+          )
+        ).rejects.toThrow(/table name must be set in Reference object/);
+      });
+
+      test('should handle null references correctly', async () => {
+        // Create initial assignment with reference
+        const engineer = await db.insert(dynamicReferenceTestTables.Engineer, {
+          name: 'John Doe',
+          yearsOfExperience: 5,
+        });
+
+        const assignment = await db.insert(dynamicReferenceTestTables.ProjectAssignment, {
+          projectName: 'Initial Project',
+          employeeRef: new Reference(dynamicReferenceTestTables.Engineer.name, engineer.id),
+          startDate: '2024-01-01',
+        });
+
+        // Update to null reference
+        await db.update(
+          dynamicReferenceTestTables.ProjectAssignment,
+          {
+            employeeRef: null,
+          },
+          { id: assignment.id }
+        );
+
+        const nullRefAssignment = await db.get(dynamicReferenceTestTables.ProjectAssignment, { id: assignment.id });
+        expect(nullRefAssignment.employeeRef).toBeNull();
+        expect(nullRefAssignment.employeeTableName).toBe(dynamicReferenceTestTables.Engineer.name); // Should retain previous value
+      });
+
+      test('should handle custom defaultValue override for projectLead', async () => {
+        const engineer = await db.insert(dynamicReferenceTestTables.Engineer, {
+          name: 'John Doe',
+          yearsOfExperience: 5,
+        });
+
+        // Even with a reference provided, should use the custom default value
+        const assignment = await db.insert(dynamicReferenceTestTables.ProjectAssignment, {
+          projectName: 'Custom Default Test',
+          projectLeadRef: new Reference(dynamicReferenceTestTables.Engineer.name, engineer.id),
+          startDate: '2024-01-01',
+        });
+
+        // Should use our custom default value instead of the reference's table name
+        expect(assignment.projectLeadTableName).toBe('TEST_DEFAULT_VALUE');
+      });
+
+      test('should handle custom updateValue override for projectLead', async () => {
+        const engineer = await db.insert(dynamicReferenceTestTables.Engineer, {
+          name: 'John Doe',
+          yearsOfExperience: 5,
+        });
+
+        const designer = await db.insert(dynamicReferenceTestTables.Designer, {
+          name: 'Jane Smith',
+          specialization: 'UI/UX',
+        });
+
+        // Create initial assignment
+        const assignment = await db.insert(dynamicReferenceTestTables.ProjectAssignment, {
+          projectName: 'Initial Project',
+          projectLeadRef: new Reference(dynamicReferenceTestTables.Engineer.name, engineer.id),
+          startDate: '2024-01-01',
+        });
+
+        // Update the reference
+        await db.update(
+          dynamicReferenceTestTables.ProjectAssignment,
+          {
+            projectLeadRef: new Reference(dynamicReferenceTestTables.Designer.name, designer.id),
+          },
+          { id: assignment.id }
+        );
+
+        const updatedAssignment = await db.get(dynamicReferenceTestTables.ProjectAssignment, { id: assignment.id });
+        // Should use our custom update value instead of the new reference's table name
+        expect(updatedAssignment.projectLeadTableName).toBe('TEST_UPDATE_VALUE');
+      });
+    });
+  };
+};

package/test/reusable/TableManagerTests.ts

@@ -1,6 +1,4 @@
 import {
-  BinaryColumn,
-  BooleanColumn,
   DateColumn,
   DateTimeColumn,
   DecimalColumn,
@@ -9,87 +7,18 @@ import {
   ObjectColumn,
   StringColumn,
   UuidColumn,
-} from '../../src/Columns';
-import { DbDriver } from '../../src/Db';
-import { Record, withRecordColumns } from '../../src/Record';
-import { Column, Table } from '../../src/Table';
-
-interface User extends Record {
-  name: string;
-  email: string;
-  active: boolean;
-}
-
-class UserTestTable extends Table<User> {
-  name = 'db_test_user';
-  columns = withRecordColumns<User>({
-    name: new StringColumn('name'),
-    email: new StringColumn('email'),
-    active: new BooleanColumn('active'),
-  });
-  indexes = [
-    { name: 'db_test_user_email_index', columns: ['email'] as (keyof User)[] },
-    { name: 'db_test_user_active_email_index', columns: ['active', 'email'] as (keyof User)[] },
-  ];
-}
-
-interface MappedIndexUser extends Record {
-  emailAddress: string;
-  accountStatus: string;
-  createdOn: Date;
-}
-
-class MappedIndexUserTable extends Table<MappedIndexUser> {
-  name = 'db_test_mapped_index_user';
-  columns = withRecordColumns<MappedIndexUser>({
-    emailAddress: new StringColumn('email_address'),
-    accountStatus: new StringColumn('account_status'),
-    createdOn: new DateColumn('created_on'),
-  });
-  indexes = [
-    {
-      name: 'db_test_mapped_index_user_email_index',
-      columns: ['emailAddress'] as (keyof MappedIndexUser)[],
-    },
-    {
-      name: 'db_test_mapped_index_user_status_email_index',
-      columns: ['accountStatus', 'emailAddress'] as (keyof MappedIndexUser)[],
-    },
-  ];
-}
-
-interface ColumnTypes extends Record {
-  integer: number;
-  bigInteger: number;
-  text: string;
-  string: string;
-  float: number;
-  decimal: number;
-  boolean: boolean;
-  date: Date;
-  dateTime: moment.Moment;
-  binary: boolean;
-  object: any;
-  uuid: string;
-}
-
-class ColumnTypesTable extends Table<ColumnTypes> {
-  name = 'db_test_column_types';
-  columns = withRecordColumns<ColumnTypes>({
-    integer: new IntegerColumn('integer', { nullable: true }),
-    bigInteger: new IntegerColumn('big_integer', { nullable: false }, true),
-    string: new StringColumn('string', { references: { table: 'db_test_user' } }),
-    text: new StringColumn('text', undefined, 'MAX'),
-    float: new FloatColumn('float', { defaultValue: async () => 0.5 }),
-    decimal: new DecimalColumn('decimal'),
-    boolean: new BooleanColumn('boolean'),
-    date: new DateColumn('date'),
-    dateTime: new DateTimeColumn('date_time'),
-    binary: new BinaryColumn('binary'),
-    object: new ObjectColumn('object'),
-    uuid: new UuidColumn('uuid', { unique: { unique: true } }),
-  });
-}
+  DbDriver,
+  Column,
+  Table,
+} from '@proteinjs/db';
+import { DbTestEnvironment } from '../util/DbTestEnvironment';
+import {
+  ColumnTypesTable,
+  MappedIndexUser,
+  MappedIndexUserTable,
+  tableManagerTestTables,
+  UserTestTable,
+} from '../util/tables/tableManagerTestTables';
 
 export const tableManagerTests = (
   driver: DbDriver,
@@ -103,23 +32,15 @@ export const tableManagerTests = (
 ) => {
   return () => {
     const tableManager = driver.getTableManager();
+    const testEnv = new DbTestEnvironment(driver, dropTable);
 
-    beforeAll(async () => {
-      if (driver.start) {
-        await driver.start();
-      }
-    });
+    beforeAll(async () => await testEnv.beforeAll(), 10000);
+    afterAll(async () => await testEnv.afterAll(), 10000);
 
     afterEach(async () => {
-      await dropTable(new ColumnTypesTable());
-      await dropTable(new UserTestTable());
-      await dropTable(new MappedIndexUserTable());
-    });
-
-    afterAll(async () => {
-      if (driver.stop) {
-        await driver.stop();
-      }
+      await dropTable(tableManagerTestTables.ColumnTypes);
+      await dropTable(tableManagerTestTables.User);
+      await dropTable(tableManagerTestTables.MappedIndexUser);
     });
 
     test('create primary key', async () => {

package/test/reusable/TransactionTests.ts

@@ -1,64 +1,11 @@
 import { QueryBuilder } from '@proteinjs/db-query';
-import { DbDriver, Db } from '../../src/Db';
-import { withRecordColumns, Record } from '../../src/Record';
-import { BooleanColumn, DateColumn, StringColumn } from '../../src/Columns';
-import { Table } from '../../src/Table';
-import { DefaultTransactionContextFactory } from '../../src/transaction/TransactionContextFactory';
-
-interface Employee extends Record {
-  name: string;
-  department?: string;
-  jobTitle?: string | null;
-  isRemote?: boolean;
-  startDate?: Date;
-  object?: string;
-}
-
-class EmployeeTestTable extends Table<Employee> {
-  name = 'db_transaction_test_employee';
-  columns = withRecordColumns<Employee>({
-    name: new StringColumn('name'),
-    department: new StringColumn('department'),
-    isRemote: new BooleanColumn('is_remote'),
-    jobTitle: new StringColumn('job_title'),
-    startDate: new DateColumn('start_date'),
-    object: new StringColumn('object'),
-  });
-}
-
-interface ReservedWordTest extends Record {
-  name: string;
-  order?: string;
-  select?: string;
-  join?: string;
-}
-
-class ReservedWordTestTable extends Table<ReservedWordTest> {
-  name = 'db_transaction_test_reserved_word';
-  columns = withRecordColumns<ReservedWordTest>({
-    name: new StringColumn('name'),
-    order: new StringColumn('order'),
-    select: new StringColumn('select'),
-    join: new StringColumn('join'),
-  });
-}
-
-/**
- * Used for testing purposes only.
- *  */
-export const getTransactionTestTable = (tableName: string) => {
-  const employeeTable = new EmployeeTestTable();
-  if (employeeTable.name == tableName) {
-    return new EmployeeTestTable();
-  }
-
-  const reservedWordTestTable = new ReservedWordTestTable();
-  if (reservedWordTestTable.name == tableName) {
-    return new ReservedWordTestTable();
-  }
-
-  throw new Error(`Cannot find test table: ${tableName}`);
-};
+import { DbDriver, Db, Record, Table, DefaultTransactionContextFactory } from '@proteinjs/db';
+import { DbTestEnvironment } from '../util/DbTestEnvironment';
+import {
+  TransactionEmployee,
+  TransactionReservedWordTest,
+  transactionTestTables,
+} from '../util/tables/transactionTestTables';
 
 export const transactionTests = (
   driver: DbDriver,
@@ -66,36 +13,22 @@ export const transactionTests = (
   dropTable: (table: Table<any>) => Promise<void>
 ) => {
   return () => {
-    const db = new Db(driver, getTransactionTestTable, transactionContextFactory);
-
-    beforeAll(async () => {
-      if (driver.start) {
-        await driver.start();
-      }
-
-      await driver.getTableManager().loadTable(new EmployeeTestTable());
-      await driver.getTableManager().loadTable(new ReservedWordTestTable());
-    });
-
-    afterAll(async () => {
-      await dropTable(new EmployeeTestTable());
-      await dropTable(new ReservedWordTestTable());
+    const db = new Db(driver, undefined, transactionContextFactory);
+    const testEnv = new DbTestEnvironment(driver, dropTable);
 
-      if (driver.stop) {
-        await driver.stop();
-      }
-    });
+    beforeAll(async () => await testEnv.beforeAll(), 10000);
+    afterAll(async () => await testEnv.afterAll(), 10000);
 
     test('Transaction with successful operations', async () => {
-      const testEmployee1: Omit<Employee, keyof Record> = {
+      const testEmployee1: Omit<TransactionEmployee, keyof Record> = {
         name: 'Veronica',
         department: 'Engineering',
       };
-      const testEmployee2: Omit<Employee, keyof Record> = {
+      const testEmployee2: Omit<TransactionEmployee, keyof Record> = {
         name: 'Brent',
         department: 'Engineering',
       };
-      const emplyeeTable: Table<Employee> = new EmployeeTestTable();
+      const emplyeeTable: Table<TransactionEmployee> = transactionTestTables.TransactionEmployee;
 
       // Execute multiple operations in a transaction
       const results = await db.runTransaction(async () => {
@@ -117,7 +50,7 @@ export const transactionTests = (
       expect(updatedEmp2.department).toBe('Engineering');
 
       // Clean up
-      const qb = new QueryBuilder<Employee>(emplyeeTable.name).condition({
+      const qb = new QueryBuilder<TransactionEmployee>(emplyeeTable.name).condition({
         field: 'id',
         operator: 'IN',
         value: [results.emp1.id, results.emp2.id],
@@ -126,15 +59,15 @@ export const transactionTests = (
     });
 
     test('Transaction rollback on error', async () => {
-      const testEmployee1: Omit<Employee, keyof Record> = {
+      const testEmployee1: Omit<TransactionEmployee, keyof Record> = {
         name: 'Veronica',
         department: 'Engineering',
       };
-      const testEmployee2: Omit<Employee, keyof Record> = {
+      const testEmployee2: Omit<TransactionEmployee, keyof Record> = {
         name: 'Brent',
         department: undefined, // This will cause an error
       };
-      const emplyeeTable: Table<Employee> = new EmployeeTestTable();
+      const emplyeeTable: Table<TransactionEmployee> = transactionTestTables.TransactionEmployee;
 
       let insertedId: string | undefined;
 
@@ -156,11 +89,11 @@ export const transactionTests = (
     });
 
     test('Nested transactions are not allowed', async () => {
-      const testEmployee: Omit<Employee, keyof Record> = {
+      const testEmployee: Omit<TransactionEmployee, keyof Record> = {
         name: 'Veronica',
         department: 'Engineering',
       };
-      const emplyeeTable: Table<Employee> = new EmployeeTestTable();
+      const emplyeeTable: Table<TransactionEmployee> = transactionTestTables.TransactionEmployee;
 
       await expect(
         db.runTransaction(async () => {
@@ -176,11 +109,11 @@ export const transactionTests = (
     });
 
     test('Transaction isolation', async () => {
-      const testEmployee: Omit<Employee, keyof Record> = {
+      const testEmployee: Omit<TransactionEmployee, keyof Record> = {
         name: 'Veronica',
         department: 'Engineering',
       };
-      const emplyeeTable: Table<Employee> = new EmployeeTestTable();
+      const emplyeeTable: Table<TransactionEmployee> = transactionTestTables.TransactionEmployee;
 
       // Start a transaction but don't commit immediately
       const transactionPromise = db.runTransaction(async () => {
@@ -202,18 +135,18 @@ export const transactionTests = (
     });
 
     test('Transaction with multiple table operations', async () => {
-      const testEmployee: Omit<Employee, keyof Record> = {
+      const testEmployee: Omit<TransactionEmployee, keyof Record> = {
         name: 'Veronica',
         department: 'Engineering',
       };
-      const testReservedWord: Omit<ReservedWordTest, keyof Record> = {
+      const testReservedWord: Omit<TransactionReservedWordTest, keyof Record> = {
         name: 'Test',
         order: '1',
         select: 'Option 1',
       };
 
-      const emplyeeTable: Table<Employee> = new EmployeeTestTable();
-      const reservedWordTable: Table<ReservedWordTest> = new ReservedWordTestTable();
+      const emplyeeTable: Table<TransactionEmployee> = transactionTestTables.TransactionEmployee;
+      const reservedWordTable: Table<TransactionReservedWordTest> = transactionTestTables.TransactionReservedWord;
 
       // Execute operations on multiple tables in a transaction
       const results = await db.runTransaction(async () => {