@proteinjs/db 1.0.24 → 1.0.26

package/test/CrudTests.ts

@@ -1,12 +1,16 @@
 import { QueryBuilder } from '@proteinjs/db-query';
 import { DbDriver, Db } from '../src/Db';
 import { withRecordColumns, Record } from '../src/Record';
-import { StringColumn } from '../src/Columns';
+import { BooleanColumn, DateColumn, StringColumn } from '../src/Columns';
 import { Table } from '../src/Table';
+import { log } from 'console';
 
 export interface Employee extends Record {
   name: string;
   department?: string;
+  jobTitle?: string | null;
+  isRemote?: boolean;
+  startDate?: Date;
   object?: string;
 }
 
@@ -15,21 +19,28 @@ export class EmployeeTable extends Table<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'),
   });
 }
 
+/**
+ * Used for testing purposes only.
+ *  */
+export const getTestTable = (tableName: string) => {
+  const employeeTable = new EmployeeTable();
+  if (employeeTable.name == tableName) {
+    return employeeTable;
+  }
+
+  throw new Error(`Cannot find test table: ${tableName}`);
+};
+
 export const crudTests = (driver: DbDriver, dropTable: (table: Table<any>) => Promise<void>) => {
   return () => {
-    const getTable = (tableName: string) => {
-      const employeeTable = new EmployeeTable();
-      if (employeeTable.name == tableName) {
-        return employeeTable;
-      }
-
-      throw new Error('Cannot find test table');
-    };
-    const db = new Db(driver, getTable);
+    const db = new Db(driver, getTestTable);
 
     beforeAll(async () => {
       if (driver.start) {
@@ -126,5 +137,173 @@ export const crudTests = (driver: DbDriver, dropTable: (table: Table<any>) => Pr
       });
       await db.delete(emplyeeTable, qb);
     });
+
+    test('Insert with null values', async () => {
+      const testEmployee: Omit<Employee, keyof Record> = {
+        name: 'Veronica',
+        department: 'Cake Factory',
+        jobTitle: null,
+        isRemote: false,
+      };
+      const emplyeeTable: Table<Employee> = new EmployeeTable();
+      const insertedEmployee = await db.insert(emplyeeTable, testEmployee);
+      const fetchedEmployee = await db.get(emplyeeTable, { id: insertedEmployee.id });
+
+      expect(fetchedEmployee).toBeTruthy();
+      expect(fetchedEmployee.jobTitle).toBeNull();
+
+      await db.delete(emplyeeTable, { id: fetchedEmployee.id });
+    });
+
+    test('Update with null values', async () => {
+      const testEmployee: Omit<Employee, keyof Record> = {
+        name: 'Cassidy',
+        jobTitle: 'Cowboy',
+        isRemote: false,
+      };
+      const emplyeeTable: Table<Employee> = new EmployeeTable();
+      const insertedEmployee = await db.insert(emplyeeTable, testEmployee);
+      const fetchedEmployee = await db.get(emplyeeTable, { id: insertedEmployee.id });
+      expect(fetchedEmployee).toBeTruthy();
+
+      const nullUpdateCount = await db.update(emplyeeTable, { jobTitle: null }, { id: insertedEmployee.id });
+      expect(nullUpdateCount).toBe(1);
+      await db.delete(emplyeeTable, { id: fetchedEmployee.id });
+    });
+
+    test('Query with null values', async () => {
+      const testEmployee: Omit<Employee, keyof Record> = {
+        name: 'Cassidy',
+        jobTitle: null,
+        isRemote: false,
+      };
+      const emplyeeTable: Table<Employee> = new EmployeeTable();
+      const insertedEmployee = await db.insert(emplyeeTable, testEmployee);
+
+      const qb = new QueryBuilder<Employee>(emplyeeTable.name)
+        .condition({
+          field: 'jobTitle',
+          operator: 'IS NULL',
+        })
+        .condition({ field: 'id', operator: '=', value: insertedEmployee.id });
+      const rows = await db.query(emplyeeTable, qb);
+      expect(rows.length).toEqual(1);
+      await db.delete(emplyeeTable, { id: insertedEmployee.id });
+    });
+
+    test('Query with IN and NOT IN operators, including null values', async () => {
+      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 insertedEmployee1 = await db.insert(emplyeeTable, testEmployee1);
+      const insertedEmployee2 = await db.insert(emplyeeTable, testEmployee2);
+      const insertedEmployee3 = await db.insert(emplyeeTable, testEmployee3);
+
+      const inQuery = new QueryBuilder<Employee>(emplyeeTable.name).condition({
+        field: 'jobTitle',
+        operator: 'IN',
+        value: ['Engineer', null],
+      });
+      const inResults = await db.query(emplyeeTable, inQuery);
+      expect(inResults.length).toBe(1);
+      expect(inResults.some((emp) => emp.jobTitle === 'Engineer')).toBe(true);
+
+      const notInQuery = new QueryBuilder<Employee>(emplyeeTable.name).condition({
+        field: 'jobTitle',
+        operator: 'NOT IN',
+        value: ['Engineer', null],
+      });
+      const notInResults = await db.query(emplyeeTable, notInQuery);
+      expect(notInResults.length).toBe(0);
+
+      // Clean up
+      const qb = new QueryBuilder<Employee>(emplyeeTable.name).condition({
+        field: 'id',
+        operator: 'IN',
+        value: [insertedEmployee1.id, insertedEmployee2.id, insertedEmployee3.id],
+      });
+      await db.delete(emplyeeTable, qb);
+    });
+
+    test('Query with BETWEEN operator', async () => {
+      const testEmployee1: Omit<Employee, keyof Record> = {
+        name: 'Veronica',
+        jobTitle: 'Engineer',
+        startDate: new Date('1997-10-24T00:00:00Z'),
+      };
+      const testEmployee2: Omit<Employee, keyof Record> = {
+        name: 'Kiriko',
+        jobTitle: null,
+        startDate: new Date('2022-10-04T00:00:00Z'),
+      };
+      const testEmployee3: Omit<Employee, keyof Record> = {
+        name: 'Cassidy',
+        jobTitle: 'Cowboy',
+        startDate: new Date('2016-05-24T00:00:00Z'),
+      };
+      const employeeTable: Table<Employee> = new EmployeeTable();
+
+      const insertedEmployee1 = await db.insert(employeeTable, testEmployee1);
+      const insertedEmployee2 = await db.insert(employeeTable, testEmployee2);
+      const insertedEmployee3 = await db.insert(employeeTable, testEmployee3);
+
+      const betweenQuery = new QueryBuilder<Employee>(employeeTable.name).condition({
+        field: 'startDate',
+        operator: 'BETWEEN',
+        value: ['2000-06-05T00:00:00Z', '2024-06-05T00:00:00Z'],
+      });
+      const betweenResults = await db.query(employeeTable, 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({
+        field: 'id',
+        operator: 'IN',
+        value: [insertedEmployee1.id, insertedEmployee2.id, insertedEmployee3.id],
+      });
+      await db.delete(employeeTable, qb);
+    });
+
+    test('Query with sort', async () => {
+      const testEmployee1: Omit<Employee, keyof Record> = {
+        name: 'Veronica',
+        jobTitle: 'Engineer',
+      };
+      const testEmployee2: Omit<Employee, keyof Record> = {
+        name: 'Kiriko',
+        jobTitle: null,
+      };
+      const testEmployee3: Omit<Employee, keyof Record> = {
+        name: 'Cassidy',
+        jobTitle: 'Cowboy',
+      };
+      const employeeTable: Table<Employee> = new EmployeeTable();
+
+      const insertedEmployee1 = await db.insert(employeeTable, testEmployee1);
+      const insertedEmployee2 = await db.insert(employeeTable, testEmployee2);
+      const insertedEmployee3 = await db.insert(employeeTable, testEmployee3);
+
+      const sortQuery = new QueryBuilder<Employee>(employeeTable.name).sort([
+        { field: 'name', byValues: ['Cassidy', 'Veronica', 'Kiriko'] },
+      ]);
+      const sortResults = await db.query(employeeTable, sortQuery);
+
+      // Assertions
+      expect(sortResults.length).toBe(3);
+      expect(sortResults[0].name).toBe('Cassidy');
+      expect(sortResults[1].name).toBe('Veronica');
+      expect(sortResults[2].name).toBe('Kiriko');
+
+      // Clean up
+      const qb = new QueryBuilder<Employee>(employeeTable.name).condition({
+        field: 'id',
+        operator: 'IN',
+        value: [insertedEmployee1.id, insertedEmployee2.id, insertedEmployee3.id],
+      });
+      await db.delete(employeeTable, qb);
+    });
   };
 };