@proteinjs/db 1.0.25 → 1.0.27

package/test/ColumnTypesTests.ts

@@ -0,0 +1,153 @@
+import { Db, DbDriver } from '../src/Db';
+import { Moment } from 'moment';
+import { ReferenceArray } from '../src/reference/ReferenceArray';
+import { Reference } from '../src/reference/Reference';
+import {
+  IntegerColumn,
+  StringColumn,
+  FloatColumn,
+  DecimalColumn,
+  BooleanColumn,
+  DateColumn,
+  DateTimeColumn,
+  BinaryColumn,
+  UuidColumn,
+  PasswordColumn,
+  ObjectColumn,
+  ArrayColumn,
+  ReferenceArrayColumn,
+  ReferenceColumn,
+} from '../src/Columns';
+import { withRecordColumns, Record } from '../src/Record';
+import { Table } from '../src/Table';
+
+export interface TestRecord extends Record {
+  integerColumn?: number | null;
+  stringColumn?: string | null;
+  floatColumn?: number | null;
+  decimalColumn?: number | null;
+  booleanColumn?: boolean | null;
+  dateColumn?: Date | null;
+  dateTimeColumn?: Moment | null;
+  binaryColumn?: number | null;
+  uuidColumn?: string | null;
+  passwordColumn?: string | null;
+  objectColumn?: any | null;
+  arrayColumn?: any[] | null;
+  referenceArrayColumn?: ReferenceArray<any> | null;
+  referenceColumn?: Reference<any> | null;
+}
+
+export class TestTable extends Table<TestRecord> {
+  public name = 'db_test_table';
+  public columns = withRecordColumns<TestRecord>({
+    integerColumn: new IntegerColumn('integer_column'),
+    stringColumn: new StringColumn('string_column', {}, 255),
+    floatColumn: new FloatColumn('float_column'),
+    decimalColumn: new DecimalColumn('decimal_column'),
+    booleanColumn: new BooleanColumn('boolean_column'),
+    dateColumn: new DateColumn('date_column'),
+    dateTimeColumn: new DateTimeColumn('date_time_column'),
+    binaryColumn: new BinaryColumn('binary_column'),
+    uuidColumn: new UuidColumn('uuid_column'),
+    passwordColumn: new PasswordColumn('password_column'),
+    objectColumn: new ObjectColumn('object_column'),
+    arrayColumn: new ArrayColumn('array_column'),
+    referenceArrayColumn: new ReferenceArrayColumn('reference_array_column', 'reference_table', false),
+    referenceColumn: new ReferenceColumn('reference_column', 'reference_table', false),
+  });
+}
+
+/**
+ * Used for testing purposes only.
+ *  */
+export const getColumnTypeTestTable = (tableName: string) => {
+  const testTable = new TestTable();
+  if (testTable.name === tableName) {
+    return new TestTable();
+  }
+  throw new Error(`Cannot find test table: ${tableName}`);
+};
+
+export const columnTypeTests = (driver: DbDriver, dropTable: (table: Table<any>) => Promise<void>) => {
+  return () => {
+    const db = new Db(driver, getColumnTypeTestTable);
+
+    beforeAll(async () => {
+      if (driver.start) {
+        await driver.start();
+      }
+
+      await driver.getTableManager().loadTable(new TestTable());
+    });
+
+    afterAll(async () => {
+      await dropTable(new TestTable());
+    });
+
+    test('Insert record with all null values', async () => {
+      const testRecord: Omit<TestRecord, keyof Record> = {
+        integerColumn: null,
+        stringColumn: null,
+        floatColumn: null,
+        decimalColumn: null,
+        booleanColumn: null,
+        dateColumn: null,
+        dateTimeColumn: null,
+        binaryColumn: null,
+        uuidColumn: null,
+        passwordColumn: null,
+        objectColumn: null,
+        arrayColumn: null,
+        referenceArrayColumn: null,
+        referenceColumn: null,
+      };
+
+      const testTable: Table<TestRecord> = new TestTable();
+      const insertedRecord = await db.insert(testTable, testRecord);
+      const fetchedRecord = await db.get(testTable, { id: insertedRecord.id });
+
+      expect(fetchedRecord).toBeTruthy();
+      expect(fetchedRecord.integerColumn).toBeNull();
+      expect(fetchedRecord.stringColumn).toBeNull();
+      expect(fetchedRecord.floatColumn).toBeNull();
+      expect(fetchedRecord.decimalColumn).toBeNull();
+      expect(fetchedRecord.booleanColumn).toBeNull();
+      expect(fetchedRecord.dateColumn).toBeNull();
+      expect(fetchedRecord.dateTimeColumn).toBeNull();
+      expect(fetchedRecord.binaryColumn).toBeNull();
+      expect(fetchedRecord.uuidColumn).toBeNull();
+      expect(fetchedRecord.passwordColumn).toBeNull();
+      expect(fetchedRecord.objectColumn).toBeNull();
+      expect(fetchedRecord.arrayColumn).toBeNull();
+      expect(fetchedRecord.referenceArrayColumn).toBeNull();
+      expect(fetchedRecord.referenceColumn).toBeNull();
+
+      // Clean up
+      await db.delete(testTable, { id: fetchedRecord.id });
+    });
+
+    test('Insert record with all undefined values', async () => {
+      const testRecord: Omit<TestRecord, keyof Record> = {
+        integerColumn: undefined,
+        stringColumn: undefined,
+        floatColumn: undefined,
+        decimalColumn: undefined,
+        booleanColumn: undefined,
+        dateColumn: undefined,
+        dateTimeColumn: undefined,
+        binaryColumn: undefined,
+        uuidColumn: undefined,
+        passwordColumn: undefined,
+        objectColumn: undefined,
+        arrayColumn: undefined,
+        referenceArrayColumn: undefined,
+        referenceColumn: undefined,
+      };
+
+      const testTable: Table<TestRecord> = new TestTable();
+
+      await expect(db.insert(testTable, testRecord)).rejects.toThrow();
+    });
+  };
+};

package/test/CrudTests.ts

@@ -1,12 +1,15 @@
 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';
 
 export interface Employee extends Record {
   name: string;
   department?: string;
+  jobTitle?: string | null;
+  isRemote?: boolean;
+  startDate?: Date;
   object?: string;
 }
 
@@ -15,21 +18,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 new 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 +136,207 @@ 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 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 sortQuery = new QueryBuilder<Employee>(emplyeeTable.name).sort([
+        { field: 'name', byValues: ['Cassidy', 'Veronica', 'Kiriko'] },
+      ]);
+      const sortResults = await db.query(emplyeeTable, 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>(emplyeeTable.name).condition({
+        field: 'id',
+        operator: 'IN',
+        value: [insertedEmployee1.id, insertedEmployee2.id, insertedEmployee3.id],
+      });
+      await db.delete(emplyeeTable, qb);
+    });
+
+    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();
+
+      // Insert operation with undefined values
+      await expect(db.insert(emplyeeTable, testEmployee2)).rejects.toThrow();
+
+      // Insert valid employee
+      const insertedEmployee1 = await db.insert(emplyeeTable, testEmployee1);
+
+      // Attempt to build query with undefined value
+      expect(() => {
+        new QueryBuilder<Employee>(emplyeeTable.name).condition({ field: 'jobTitle', operator: '=', value: undefined });
+      }).toThrow();
+
+      // Attempt to query
+      await expect(db.query(emplyeeTable, { id: insertedEmployee1, jobTitle: undefined })).rejects.toThrow();
+
+      // Update operation with undefined values
+      await expect(db.update(emplyeeTable, { id: insertedEmployee1.id, jobTitle: undefined })).rejects.toThrow();
+
+      // Attempt to delete
+      await expect(db.delete(emplyeeTable, { id: insertedEmployee1, jobTitle: undefined })).rejects.toThrow();
+
+      // Clean up
+      const deleteValidQuery = new QueryBuilder<Employee>(emplyeeTable.name).condition({
+        field: 'id',
+        operator: 'IN',
+        value: [insertedEmployee1.id],
+      });
+      await db.delete(emplyeeTable, deleteValidQuery);
+    });
   };
 };