@proteinjs/db 1.0.28 → 1.1.0

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();
+export const getCrudTestTable = (tableName: string) => {
+  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}`);
@@ -39,18 +61,20 @@ export const getTestTable = (tableName: string) => {
 
 export const crudTests = (driver: DbDriver, dropTable: (table: Table<any>) => Promise<void>) => {
   return () => {
-    const db = new Db(driver, getTestTable);
+    const db = new Db(driver, getCrudTestTable);
 
     beforeAll(async () => {
       if (driver.start) {
         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,29 +265,29 @@ 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 emplyeeTable: Table<Employee> = new EmployeeTestTable();
 
-      const insertedEmployee1 = await db.insert(employeeTable, testEmployee1);
-      const insertedEmployee2 = await db.insert(employeeTable, testEmployee2);
-      const insertedEmployee3 = await db.insert(employeeTable, testEmployee3);
+      const insertedEmployee1 = await db.insert(emplyeeTable, testEmployee1);
+      const insertedEmployee2 = await db.insert(emplyeeTable, testEmployee2);
+      const insertedEmployee3 = await db.insert(emplyeeTable, testEmployee3);
 
-      const betweenQuery = new QueryBuilder<Employee>(employeeTable.name).condition({
+      const betweenQuery = new QueryBuilder<Employee>(emplyeeTable.name).condition({
         field: 'startDate',
         operator: 'BETWEEN',
         value: ['2000-06-05T00:00:00Z', '2024-06-05T00:00:00Z'],
       });
-      const betweenResults = await db.query(employeeTable, betweenQuery);
+      const betweenResults = await db.query(emplyeeTable, betweenQuery);
       expect(betweenResults.length).toBe(2);
       expect(betweenResults.some((emp) => emp.name === 'Kiriko')).toBe(true);
       expect(betweenResults.some((emp) => emp.name === 'Cassidy')).toBe(true);
 
       // Clean up
-      const qb = new QueryBuilder<Employee>(employeeTable.name).condition({
+      const qb = new QueryBuilder<Employee>(emplyeeTable.name).condition({
         field: 'id',
         operator: 'IN',
         value: [insertedEmployee1.id, insertedEmployee2.id, insertedEmployee3.id],
       });
-      await db.delete(employeeTable, qb);
+      await db.delete(emplyeeTable, qb);
     });
 
     test('Query with sort', async () => {
@@ -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,160 @@ 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);
+
+    test('Case sensitivity', async () => {
+      const testEmployee: Omit<Employee, keyof Record> = {
+        name: 'Veronica',
+        jobTitle: 'Software ENGINEER',
+        isRemote: true,
+        startDate: new Date('2024-04-01T00:00:00Z'),
+      };
+      const emplyeeTable: Table<Employee> = new EmployeeTestTable();
+      const insertedEmployee = await db.insert(emplyeeTable, testEmployee);
+
+      const queryNameInsensitive = new QueryBuilder<Employee>(emplyeeTable.name).condition(
+        {
+          field: 'jobTitle',
+          operator: '=',
+          value: 'SOFTWARE engineer',
+        },
+        undefined,
+        false
+      );
+      const nameResultsIns = await db.query(emplyeeTable, queryNameInsensitive);
+      expect(nameResultsIns.length).toBe(1);
+
+      const queryNameSensitive = new QueryBuilder<Employee>(emplyeeTable.name).condition({
+        field: 'jobTitle',
+        operator: '=',
+        value: 'SOFTWARE ENGINEER',
+      });
+      const nameResultsSens = await db.query(emplyeeTable, queryNameSensitive);
+      expect(nameResultsSens.length).toBe(0);
+
+      await db.delete(emplyeeTable, { id: insertedEmployee.id });
+    });
   };
 };

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);