@proteinjs/db 1.0.26 → 1.0.28

package/src/schema/SchemaMetadata.ts

@@ -20,9 +20,9 @@ export class SchemaMetadata {
   async columnExists(columnName: string, table: Table<any>): Promise<boolean> {
     const qb = QueryBuilder.fromObject(
       {
-        TABLE_SCHEMA: this.multiDbSupported ? this.dbDriver.getDbName() : undefined,
         TABLE_NAME: table.name,
         COLUMN_NAME: columnName,
+        ...(this.multiDbSupported ? { TABLE_SCHEMA: this.dbDriver.getDbName() } : {}),
       },
       'COLUMNS'
     );
@@ -34,8 +34,8 @@ export class SchemaMetadata {
   async getColumnMetadata(table: Table<any>): Promise<{ [columnName: string]: { type: string; isNullable: boolean } }> {
     const qb = QueryBuilder.fromObject(
       {
-        TABLE_SCHEMA: this.multiDbSupported ? this.dbDriver.getDbName() : undefined,
         TABLE_NAME: table.name,
+        ...(this.multiDbSupported ? { TABLE_SCHEMA: this.dbDriver.getDbName() } : {}),
       },
       'COLUMNS'
     );
@@ -52,9 +52,9 @@ export class SchemaMetadata {
   async getPrimaryKey(table: Table<any>): Promise<string[]> {
     const qb = QueryBuilder.fromObject(
       {
-        TABLE_SCHEMA: this.multiDbSupported ? this.dbDriver.getDbName() : undefined,
         TABLE_NAME: table.name,
         CONSTRAINT_NAME: 'PRIMARY',
+        ...(this.multiDbSupported ? { TABLE_SCHEMA: this.dbDriver.getDbName() } : {}),
       },
       'KEY_COLUMN_USAGE'
     );
@@ -73,8 +73,8 @@ export class SchemaMetadata {
   ): Promise<{ [columnName: string]: { referencedTableName: string; referencedColumnName: string } }> {
     const qb = QueryBuilder.fromObject(
       {
-        TABLE_SCHEMA: this.multiDbSupported ? this.dbDriver.getDbName() : undefined,
         TABLE_NAME: table.name,
+        ...(this.multiDbSupported ? { TABLE_SCHEMA: this.dbDriver.getDbName() } : {}),
       },
       'KEY_COLUMN_USAGE'
     );
@@ -98,8 +98,8 @@ export class SchemaMetadata {
   async getUniqueColumns(table: Table<any>): Promise<string[]> {
     const qb = QueryBuilder.fromObject(
       {
-        TABLE_SCHEMA: this.multiDbSupported ? this.dbDriver.getDbName() : undefined,
         TABLE_NAME: table.name,
+        ...(this.multiDbSupported ? { TABLE_SCHEMA: this.dbDriver.getDbName() } : {}),
       },
       'KEY_COLUMN_USAGE'
     );

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.referenceColumn).toBeNull();
+      expect(fetchedRecord.referenceArrayColumn).toHaveProperty('_ids', []);
+
+      // 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

@@ -3,7 +3,6 @@ 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 { log } from 'console';
 
 export interface Employee extends Record {
   name: string;
@@ -32,7 +31,7 @@ export class EmployeeTable extends Table<Employee> {
 export const getTestTable = (tableName: string) => {
   const employeeTable = new EmployeeTable();
   if (employeeTable.name == tableName) {
-    return employeeTable;
+    return new EmployeeTable();
   }
 
   throw new Error(`Cannot find test table: ${tableName}`);
@@ -280,16 +279,16 @@ export const crudTests = (driver: DbDriver, dropTable: (table: Table<any>) => Pr
         name: 'Cassidy',
         jobTitle: 'Cowboy',
       };
-      const employeeTable: Table<Employee> = new EmployeeTable();
+      const emplyeeTable: 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 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>(employeeTable.name).sort([
+      const sortQuery = new QueryBuilder<Employee>(emplyeeTable.name).sort([
         { field: 'name', byValues: ['Cassidy', 'Veronica', 'Kiriko'] },
       ]);
-      const sortResults = await db.query(employeeTable, sortQuery);
+      const sortResults = await db.query(emplyeeTable, sortQuery);
 
       // Assertions
       expect(sortResults.length).toBe(3);
@@ -298,12 +297,46 @@ export const crudTests = (driver: DbDriver, dropTable: (table: Table<any>) => Pr
       expect(sortResults[2].name).toBe('Kiriko');
 
       // 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('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);
     });
   };
 };