@proteinjs/db 1.0.27 → 1.0.29

package/test/CrudTests.ts

@@ -13,7 +13,7 @@ export interface Employee extends Record {
   object?: string;
 }
 
-export class EmployeeTable extends Table<Employee> {
+export class EmployeeTestTable extends Table<Employee> {
   name = 'db_test_employee';
   columns = withRecordColumns<Employee>({
     name: new StringColumn('name'),
@@ -25,13 +25,35 @@ export class EmployeeTable extends Table<Employee> {
   });
 }
 
+export interface ReservedWordTest extends Record {
+  name: string;
+  order?: string;
+  select?: string;
+  join?: string;
+}
+
+export class ReservedWordTestTable extends Table<ReservedWordTest> {
+  name = 'db_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 getTestTable = (tableName: string) => {
-  const employeeTable = new EmployeeTable();
+  const employeeTable = new EmployeeTestTable();
   if (employeeTable.name == tableName) {
-    return new EmployeeTable();
+    return new EmployeeTestTable();
+  }
+
+  const reservedWordTestTable = new ReservedWordTestTable();
+  if (reservedWordTestTable.name == tableName) {
+    return new ReservedWordTestTable();
   }
 
   throw new Error(`Cannot find test table: ${tableName}`);
@@ -46,11 +68,13 @@ export const crudTests = (driver: DbDriver, dropTable: (table: Table<any>) => Pr
         await driver.start();
       }
 
-      await driver.getTableManager().loadTable(new EmployeeTable());
+      await driver.getTableManager().loadTable(new EmployeeTestTable());
+      await driver.getTableManager().loadTable(new ReservedWordTestTable());
     });
 
     afterAll(async () => {
-      await dropTable(new EmployeeTable());
+      await dropTable(new EmployeeTestTable());
+      await dropTable(new ReservedWordTestTable());
 
       if (driver.stop) {
         await driver.stop();
@@ -59,7 +83,7 @@ export const crudTests = (driver: DbDriver, dropTable: (table: Table<any>) => Pr
 
     test('Insert', async () => {
       const testEmployee: Omit<Employee, keyof Record> = { name: 'Veronica' };
-      const emplyeeTable: Table<Employee> = new EmployeeTable();
+      const emplyeeTable: Table<Employee> = new EmployeeTestTable();
       const insertedEmployee = await db.insert(emplyeeTable, testEmployee);
       const fetchedEmployee = await db.get(emplyeeTable, { id: insertedEmployee.id });
       expect(fetchedEmployee).toBeTruthy();
@@ -68,7 +92,7 @@ export const crudTests = (driver: DbDriver, dropTable: (table: Table<any>) => Pr
 
     test('Update', async () => {
       const testEmployee: Omit<Employee, keyof Record> = { name: 'Veronica' };
-      const emplyeeTable: Table<Employee> = new EmployeeTable();
+      const emplyeeTable: Table<Employee> = new EmployeeTestTable();
       const insertedEmployee = await db.insert(emplyeeTable, testEmployee);
       const updateCount = await db.update(
         emplyeeTable,
@@ -89,7 +113,7 @@ export const crudTests = (driver: DbDriver, dropTable: (table: Table<any>) => Pr
 
     test('Delete', async () => {
       const testEmployee: Omit<Employee, keyof Record> = { name: 'Veronica' };
-      const emplyeeTable: Table<Employee> = new EmployeeTable();
+      const emplyeeTable: Table<Employee> = new EmployeeTestTable();
       const insertedEmployee = await db.insert(emplyeeTable, testEmployee);
       let fetchedEmployee = await db.get(emplyeeTable, { id: insertedEmployee.id });
       expect(fetchedEmployee).toBeTruthy();
@@ -103,7 +127,7 @@ export const crudTests = (driver: DbDriver, dropTable: (table: Table<any>) => Pr
       const testEmployee1: Omit<Employee, keyof Record> = { name: 'Veronica', department: 'Cake Factory' };
       const testEmployee2: Omit<Employee, keyof Record> = { name: 'Brent', department: 'Cake Factory' };
       const testEmployee3: Omit<Employee, keyof Record> = { name: 'Sean', department: 'Pug Playhouse' };
-      const emplyeeTable: Table<Employee> = new EmployeeTable();
+      const emplyeeTable: Table<Employee> = new EmployeeTestTable();
       const fetchedEmployee1 = await db.insert(emplyeeTable, testEmployee1);
       const fetchedEmployee2 = await db.insert(emplyeeTable, testEmployee2);
       const fetchedEmployee3 = await db.insert(emplyeeTable, testEmployee3);
@@ -123,7 +147,7 @@ export const crudTests = (driver: DbDriver, dropTable: (table: Table<any>) => Pr
       const testEmployee1: Omit<Employee, keyof Record> = { name: 'Veronica', department: 'Cake Factory' };
       const testEmployee2: Omit<Employee, keyof Record> = { name: 'Brent', department: 'Cake Factory' };
       const testEmployee3: Omit<Employee, keyof Record> = { name: 'Sean', department: 'Pug Playhouse' };
-      const emplyeeTable: Table<Employee> = new EmployeeTable();
+      const emplyeeTable: Table<Employee> = new EmployeeTestTable();
       const fetchedEmployee1 = await db.insert(emplyeeTable, testEmployee1);
       const fetchedEmployee2 = await db.insert(emplyeeTable, testEmployee2);
       const fetchedEmployee3 = await db.insert(emplyeeTable, testEmployee3);
@@ -144,7 +168,7 @@ export const crudTests = (driver: DbDriver, dropTable: (table: Table<any>) => Pr
         jobTitle: null,
         isRemote: false,
       };
-      const emplyeeTable: Table<Employee> = new EmployeeTable();
+      const emplyeeTable: Table<Employee> = new EmployeeTestTable();
       const insertedEmployee = await db.insert(emplyeeTable, testEmployee);
       const fetchedEmployee = await db.get(emplyeeTable, { id: insertedEmployee.id });
 
@@ -160,7 +184,7 @@ export const crudTests = (driver: DbDriver, dropTable: (table: Table<any>) => Pr
         jobTitle: 'Cowboy',
         isRemote: false,
       };
-      const emplyeeTable: Table<Employee> = new EmployeeTable();
+      const emplyeeTable: Table<Employee> = new EmployeeTestTable();
       const insertedEmployee = await db.insert(emplyeeTable, testEmployee);
       const fetchedEmployee = await db.get(emplyeeTable, { id: insertedEmployee.id });
       expect(fetchedEmployee).toBeTruthy();
@@ -176,7 +200,7 @@ export const crudTests = (driver: DbDriver, dropTable: (table: Table<any>) => Pr
         jobTitle: null,
         isRemote: false,
       };
-      const emplyeeTable: Table<Employee> = new EmployeeTable();
+      const emplyeeTable: Table<Employee> = new EmployeeTestTable();
       const insertedEmployee = await db.insert(emplyeeTable, testEmployee);
 
       const qb = new QueryBuilder<Employee>(emplyeeTable.name)
@@ -194,7 +218,7 @@ export const crudTests = (driver: DbDriver, dropTable: (table: Table<any>) => Pr
       const testEmployee1: Omit<Employee, keyof Record> = { name: 'Veronica', jobTitle: 'Engineer' };
       const testEmployee2: Omit<Employee, keyof Record> = { name: 'Zenyatta', jobTitle: null };
       const testEmployee3: Omit<Employee, keyof Record> = { name: 'Cassidy', jobTitle: 'Cowboy' };
-      const emplyeeTable: Table<Employee> = new EmployeeTable();
+      const emplyeeTable: Table<Employee> = new EmployeeTestTable();
       const insertedEmployee1 = await db.insert(emplyeeTable, testEmployee1);
       const insertedEmployee2 = await db.insert(emplyeeTable, testEmployee2);
       const insertedEmployee3 = await db.insert(emplyeeTable, testEmployee3);
@@ -241,7 +265,7 @@ export const crudTests = (driver: DbDriver, dropTable: (table: Table<any>) => Pr
         jobTitle: 'Cowboy',
         startDate: new Date('2016-05-24T00:00:00Z'),
       };
-      const employeeTable: Table<Employee> = new EmployeeTable();
+      const employeeTable: Table<Employee> = new EmployeeTestTable();
 
       const insertedEmployee1 = await db.insert(employeeTable, testEmployee1);
       const insertedEmployee2 = await db.insert(employeeTable, testEmployee2);
@@ -279,7 +303,7 @@ export const crudTests = (driver: DbDriver, dropTable: (table: Table<any>) => Pr
         name: 'Cassidy',
         jobTitle: 'Cowboy',
       };
-      const emplyeeTable: Table<Employee> = new EmployeeTable();
+      const emplyeeTable: Table<Employee> = new EmployeeTestTable();
 
       const insertedEmployee1 = await db.insert(emplyeeTable, testEmployee1);
       const insertedEmployee2 = await db.insert(emplyeeTable, testEmployee2);
@@ -308,7 +332,7 @@ export const crudTests = (driver: DbDriver, dropTable: (table: Table<any>) => Pr
     test('CRUD operations with undefined values', async () => {
       const testEmployee1: Omit<Employee, keyof Record> = { name: 'Veronica', jobTitle: 'Software Engineer' };
       const testEmployee2: Omit<Employee, keyof Record> = { name: 'Brent', jobTitle: undefined };
-      const emplyeeTable: Table<Employee> = new EmployeeTable();
+      const emplyeeTable: Table<Employee> = new EmployeeTestTable();
 
       // Insert operation with undefined values
       await expect(db.insert(emplyeeTable, testEmployee2)).rejects.toThrow();
@@ -338,5 +362,127 @@ export const crudTests = (driver: DbDriver, dropTable: (table: Table<any>) => Pr
       });
       await db.delete(emplyeeTable, deleteValidQuery);
     });
+
+    test('Insert with reserved words', async () => {
+      const testRecord: Omit<ReservedWordTest, keyof Record> = { name: 'Test Name', order: '1', select: 'Option 1' };
+      const table: Table<ReservedWordTest> = new ReservedWordTestTable();
+      const insertedRecord = await db.insert(table, testRecord);
+      const fetchedRecord = await db.get(table, { id: insertedRecord.id });
+      expect(fetchedRecord).toBeTruthy();
+      await db.delete(table, { id: fetchedRecord.id });
+    });
+
+    test('Update with reserved words', async () => {
+      const testRecord: Omit<ReservedWordTest, keyof Record> = { name: 'Test Name', order: '1', select: 'Option 1' };
+      const table: Table<ReservedWordTest> = new ReservedWordTestTable();
+      const insertedRecord = await db.insert(table, testRecord);
+      const updateCount = await db.update(
+        table,
+        {
+          name: 'Updated Name',
+          order: '2',
+          join: 'Join Option',
+        },
+        { id: insertedRecord.id }
+      );
+      expect(updateCount).toBe(1);
+      const fetchedRecord = await db.get(table, { id: insertedRecord.id });
+      expect(fetchedRecord.name).toBe('Updated Name');
+      expect(fetchedRecord.order).toBe('2');
+      expect(fetchedRecord.join).toBe('Join Option');
+      await db.delete(table, { id: fetchedRecord.id });
+    });
+
+    test('Delete with reserved words', async () => {
+      const testRecord: Omit<ReservedWordTest, keyof Record> = { name: 'Test Name', order: '1', select: 'Option 1' };
+      const table: Table<ReservedWordTest> = new ReservedWordTestTable();
+      const insertedRecord = await db.insert(table, testRecord);
+      let fetchedRecord = await db.get(table, { id: insertedRecord.id });
+      expect(fetchedRecord).toBeTruthy();
+      const deleteCount = await db.delete(table, { id: fetchedRecord.id });
+      expect(deleteCount).toBe(1);
+      fetchedRecord = await db.get(table, { id: insertedRecord.id });
+      expect(fetchedRecord).toBeFalsy();
+    });
+
+    test('Query with reserved words', async () => {
+      const testRecord1: Omit<ReservedWordTest, keyof Record> = { name: 'Test Name 1', order: '1', select: 'Option 1' };
+      const testRecord2: Omit<ReservedWordTest, keyof Record> = { name: 'Test Name 2', order: '1', select: 'Option 1' };
+      const testRecord3: Omit<ReservedWordTest, keyof Record> = { name: 'Test Name 3', order: '2', select: 'Option 2' };
+      const table: Table<ReservedWordTest> = new ReservedWordTestTable();
+      const insertedRecord1 = await db.insert(table, testRecord1);
+      const insertedRecord2 = await db.insert(table, testRecord2);
+      const insertedRecord3 = await db.insert(table, testRecord3);
+      const fetchedRecords = await db.query(table, { order: '1', select: 'Option 1' });
+      expect(fetchedRecords.length).toBe(2);
+      expect(fetchedRecords[0].name).toBe('Test Name 1');
+      expect(fetchedRecords[1].name).toBe('Test Name 2');
+      const qb = new QueryBuilder<ReservedWordTest>(table.name).condition({
+        field: 'id',
+        operator: 'IN',
+        value: [insertedRecord1.id, insertedRecord2.id, insertedRecord3.id],
+      });
+      await db.delete(table, qb);
+    });
+
+    test('Query with sort and reserved words', async () => {
+      const testRecord1: Omit<ReservedWordTest, keyof Record> = { name: 'Test Name 1', order: '1', select: 'Option 1' };
+      const testRecord2: Omit<ReservedWordTest, keyof Record> = { name: 'Test Name 2', order: '2', select: 'Option 2' };
+      const testRecord3: Omit<ReservedWordTest, keyof Record> = { name: 'Test Name 3', order: '3', select: 'Option 3' };
+      const table: Table<ReservedWordTest> = new ReservedWordTestTable();
+
+      const insertedRecord1 = await db.insert(table, testRecord1);
+      const insertedRecord2 = await db.insert(table, testRecord2);
+      const insertedRecord3 = await db.insert(table, testRecord3);
+
+      const sortQuery = new QueryBuilder<ReservedWordTest>(table.name).sort([
+        { field: 'order', byValues: ['1', '2', '3'] },
+      ]);
+      const sortResults = await db.query(table, sortQuery);
+
+      // Assertions
+      expect(sortResults.length).toBe(3);
+      expect(sortResults[0].order).toBe('1');
+      expect(sortResults[1].order).toBe('2');
+      expect(sortResults[2].order).toBe('3');
+
+      // Clean up
+      const qb = new QueryBuilder<ReservedWordTest>(table.name).condition({
+        field: 'id',
+        operator: 'IN',
+        value: [insertedRecord1.id, insertedRecord2.id, insertedRecord3.id],
+      });
+      await db.delete(table, qb);
+    });
+
+    test('Query with reserved words and subquery', async () => {
+      const testRecord1: Omit<ReservedWordTest, keyof Record> = { name: 'Test Name 1', order: '1', select: 'Option 1' };
+      const testRecord2: Omit<ReservedWordTest, keyof Record> = { name: 'Test Name 2', order: '2', select: 'Option 2' };
+      const table: Table<ReservedWordTest> = new ReservedWordTestTable();
+
+      const insertedRecord1 = await db.insert(table, testRecord1);
+      const insertedRecord2 = await db.insert(table, testRecord2);
+
+      const subQb = new QueryBuilder<ReservedWordTest>(table.name).select({ fields: ['id'] }).condition({
+        field: 'select',
+        operator: '=',
+        value: 'Option 1',
+      });
+
+      const qb = new QueryBuilder<ReservedWordTest>(table.name).condition({
+        field: 'id',
+        operator: 'IN',
+        value: subQb,
+      });
+
+      // Execute the query
+      const results = await db.query(table, qb);
+      expect(results.length).toBe(1);
+      expect(results[0].name).toBe('Test Name 1');
+
+      // Clean up
+      await db.delete(table, { id: insertedRecord1.id });
+      await db.delete(table, { id: insertedRecord2.id });
+    }, 10000);
   };
 };

package/test/TableManagerTests.ts

@@ -20,7 +20,7 @@ interface User extends Record {
   active: boolean;
 }
 
-class UserTable extends Table<User> {
+class UserTestTable extends Table<User> {
   name = 'db_test_user';
   columns = withRecordColumns<User>({
     name: new StringColumn('name'),
@@ -87,7 +87,7 @@ export const tableManagerTests = (
 
     afterEach(async () => {
       await dropTable(new ColumnTypesTable());
-      await dropTable(new UserTable());
+      await dropTable(new UserTestTable());
     });
 
     afterAll(async () => {
@@ -97,7 +97,7 @@ export const tableManagerTests = (
     });
 
     test('create primary key', async () => {
-      const userTable = new UserTable();
+      const userTable = new UserTestTable();
       await tableManager.loadTable(userTable);
       expect(await tableManager.tableExists(userTable)).toBeTruthy();
       const primaryKey = await tableManager.schemaMetadata.getPrimaryKey(userTable);
@@ -106,7 +106,7 @@ export const tableManagerTests = (
     });
 
     test('create columns', async () => {
-      const userTable = new UserTable();
+      const userTable = new UserTestTable();
       await tableManager.loadTable(userTable);
       expect(await tableManager.tableExists(userTable)).toBeTruthy();
       expect(await tableManager.schemaMetadata.columnExists(userTable.columns.name.name, userTable)).toBeTruthy();
@@ -115,7 +115,7 @@ export const tableManagerTests = (
     });
 
     test('add column via alter', async () => {
-      const userTable = new UserTable();
+      const userTable = new UserTestTable();
       const dataColumn = new ObjectColumn('data');
       await tableManager.loadTable(userTable);
       expect(await tableManager.tableExists(userTable)).toBeTruthy();
@@ -133,7 +133,7 @@ export const tableManagerTests = (
     });
 
     test('columns created with correct types', async () => {
-      const userTable = new UserTable();
+      const userTable = new UserTestTable();
       const columnTypesTable = new ColumnTypesTable();
       await tableManager.loadTable(userTable);
       await tableManager.loadTable(columnTypesTable);
@@ -178,7 +178,7 @@ export const tableManagerTests = (
     });
 
     test('columns created with correct options', async () => {
-      const userTable = new UserTable();
+      const userTable = new UserTestTable();
       const columnTypesTable = new ColumnTypesTable();
       await tableManager.loadTable(userTable);
       await tableManager.loadTable(columnTypesTable);
@@ -203,7 +203,7 @@ export const tableManagerTests = (
         return;
       }
 
-      const userTable = new UserTable();
+      const userTable = new UserTestTable();
       await tableManager.loadTable(userTable);
       expect(await tableManager.tableExists(userTable)).toBeTruthy();
       expect(await tableManager.schemaMetadata.columnExists(userTable.columns.name.name, userTable)).toBeTruthy();
@@ -219,7 +219,7 @@ export const tableManagerTests = (
         return;
       }
 
-      const userTable = new UserTable();
+      const userTable = new UserTestTable();
       const columnTypesTable = new ColumnTypesTable();
       await tableManager.loadTable(userTable);
       await tableManager.loadTable(columnTypesTable);
@@ -287,7 +287,7 @@ export const tableManagerTests = (
     });
 
     test('alter unique constraint', async () => {
-      const userTable = new UserTable();
+      const userTable = new UserTestTable();
       const columnTypesTable = new ColumnTypesTable();
       await tableManager.loadTable(userTable);
       columnTypesTable.columns.text.options = { defaultValue: async () => 'asdf' };
@@ -409,7 +409,7 @@ export const tableManagerTests = (
         return;
       }
 
-      const userTable = new UserTable();
+      const userTable = new UserTestTable();
       const columnTypesTable = new ColumnTypesTable();
       await tableManager.loadTable(userTable);
       columnTypesTable.columns.text.options = { defaultValue: async () => 'asdf' };
@@ -528,7 +528,7 @@ export const tableManagerTests = (
     });
 
     test('create index', async () => {
-      const userTable = new UserTable();
+      const userTable = new UserTestTable();
       await tableManager.loadTable(userTable);
       expect(await tableManager.tableExists(userTable)).toBeTruthy();
       const indexes = await tableManager.schemaMetadata.getIndexes(userTable);
@@ -537,7 +537,7 @@ export const tableManagerTests = (
     });
 
     test('alter index', async () => {
-      const userTable = new UserTable();
+      const userTable = new UserTestTable();
       await tableManager.loadTable(userTable);
       expect(await tableManager.tableExists(userTable)).toBeTruthy();
       let indexes = await tableManager.schemaMetadata.getIndexes(userTable);