@proteinjs/db 1.0.14 → 1.0.16

package/src/source/SourceRecord.ts

@@ -3,24 +3,27 @@ import { Columns, Table, getTables } from '../Table';
 import { Record as DbRecord, withRecordColumns } from '../Record';
 import { BooleanColumn } from '../Columns';
 
-export const getSourceRecordLoaders = <T extends SourceRecord = SourceRecord>() => SourceRepository.get().objects<SourceRecordLoader<T>>('@proteinjs/db/SourceRecordLoader');
+export const getSourceRecordLoaders = <T extends SourceRecord = SourceRecord>() =>
+  SourceRepository.get().objects<SourceRecordLoader<T>>('@proteinjs/db/SourceRecordLoader');
 
 export function getSourceRecordTables() {
   const tables = getTables();
   const sourceRecordTables: Table<any>[] = [];
-  for (let table of tables) {
-    if (isSourceRecordTable(table))
+  for (const table of tables) {
+    if (isSourceRecordTable(table)) {
       sourceRecordTables.push(table);
+    }
   }
 
   return sourceRecordTables;
 }
 
 export function isSourceRecordTable(table: Table<any>) {
-  for (let columnPropertyName in table.columns) {
+  for (const columnPropertyName in table.columns) {
     const column = table.columns[columnPropertyName];
-    if (column.name == getSourceRecordColumns().isLoadedFromSource.name)
+    if (column.name == getSourceRecordColumns().isLoadedFromSource.name) {
       return true;
+    }
   }
 
   return false;
@@ -34,42 +37,58 @@ const getSourceRecordColumns = (hideFromUi = true) => {
   return {
     isLoadedFromSource: new BooleanColumn('is_loaded_from_source', { ui: { hidden: hideFromUi } }),
   };
-}
+};
 
 /**
  * Wrapper function to add default Record and SourceRecord columns to your table's columns.
- * 
+ *
  * Note: using this requires an explicit dependency on moment@2.29.4 in your package (since transient dependencies are brittle by typescript's standards)
- * 
+ *
  * @param columns your columns
  * @param hideFromUi if true, source record columns are hidden from RecordTable and RecordForm
  * @returns recordColumns & sourceRecordColumns & your columns
  */
-export function withSourceRecordColumns<T extends SourceRecord>(columns: Columns<Omit<T, keyof SourceRecord>>, hideFromUi?: boolean): Columns<SourceRecord> & Columns<Omit<T, keyof SourceRecord>> {
-  return Object.assign(Object.assign({}, getSourceRecordColumns(hideFromUi)), withRecordColumns<DbRecord>(columns) as any);
+export function withSourceRecordColumns<T extends SourceRecord>(
+  columns: Columns<Omit<T, keyof SourceRecord>>,
+  hideFromUi?: boolean
+): Columns<SourceRecord> & Columns<Omit<T, keyof SourceRecord>> {
+  return Object.assign(
+    Object.assign({}, getSourceRecordColumns(hideFromUi)),
+    withRecordColumns<DbRecord>(columns) as any
+  );
 }
 
 type InferRecordFromTable<T> = T extends Table<infer R> ? R : never;
-type InferRecordWithoutTimestamps<T> = Omit<InferRecordFromTable<T>, 'created'|'updated'>;
-type RequiredProperties<T> = Pick<T, {
-  [K in keyof T]: T extends Record<K, T[K]> ? K : never
-}[keyof T]>;
-type OptionalProperties<T> = Pick<T, {
-  [K in keyof T]: T extends Record<K, T[K]> ? never : K
-}[keyof T]>;
+type InferRecordWithoutTimestamps<T> = Omit<InferRecordFromTable<T>, 'created' | 'updated'>;
+type RequiredProperties<T> = Pick<
+  T,
+  {
+    [K in keyof T]: T extends Record<K, T[K]> ? K : never;
+  }[keyof T]
+>;
+type OptionalProperties<T> = Pick<
+  T,
+  {
+    [K in keyof T]: T extends Record<K, T[K]> ? never : K;
+  }[keyof T]
+>;
 
 /**
  * Use this to load a record from source into the db.
- * 
+ *
  * On Db.init, the record will be inserted if it doesn't exist, and updated if it does exist to mirror what is in source.
- * 
+ *
  * If the SourceRecordLoader is deleted from source, the record will be deleted from the db on server startup. This will also be the behavior if id is changed - the record with the old id will be deleted.
  */
 export interface SourceRecordLoader<T extends SourceRecord> extends Loadable {
-  table: Table<T>,
+  table: Table<T>;
   record: {
-    [P in keyof RequiredProperties<InferRecordWithoutTimestamps<Table<T>>>]: RequiredProperties<InferRecordWithoutTimestamps<Table<T>>>[P];
+    [P in keyof RequiredProperties<InferRecordWithoutTimestamps<Table<T>>>]: RequiredProperties<
+      InferRecordWithoutTimestamps<Table<T>>
+    >[P];
   } & {
-    [P in keyof OptionalProperties<InferRecordWithoutTimestamps<Table<T>>>]?: OptionalProperties<InferRecordWithoutTimestamps<Table<T>>>[P];
-  }
-}
+    [P in keyof OptionalProperties<InferRecordWithoutTimestamps<Table<T>>>]?: OptionalProperties<
+      InferRecordWithoutTimestamps<Table<T>>
+    >[P];
+  };
+}

package/src/source/SourceRecordLoader.ts

@@ -5,7 +5,9 @@ import { Table } from '../Table';
 import { getSystemDb } from '../Db';
 import { SourceRecordRepo } from './SourceRecordRepo';
 
-type SourceRecordsMap = {[tableName: string]: { table: Table<any>, records: Omit<SourceRecord, 'created'|'updated'>[], recordIds: string[] }}
+type SourceRecordsMap = {
+  [tableName: string]: { table: Table<any>; records: Omit<SourceRecord, 'created' | 'updated'>[]; recordIds: string[] };
+};
 
 export class SourceRecordLoader {
   private logger = new Logger(this.constructor.name);
@@ -13,7 +15,7 @@ export class SourceRecordLoader {
   async load() {
     const sourceRecordsMap = await this.getSourceRecordsMap();
     const db = getSystemDb();
-    for (let tableName in sourceRecordsMap) {
+    for (const tableName in sourceRecordsMap) {
       let insertCount = 0;
       let updateCount = 0;
       let deleteCount = 0;
@@ -21,12 +23,13 @@ export class SourceRecordLoader {
       const sourceRecordIds = sourceRecordsMap[tableName].recordIds;
       if (!table.sourceRecordOptions.doNotDeleteSourceRecordsFromDb) {
         const qb = QueryBuilder.fromObject<SourceRecord>({ isLoadedFromSource: true }, table.name);
-        if (sourceRecordIds.length > 0)
+        if (sourceRecordIds.length > 0) {
           qb.condition({ field: 'id', operator: 'NOT IN', value: sourceRecordIds });
-        
+        }
+
         deleteCount = await db.delete(table, qb);
       }
-  
+
       const sourceRecords = sourceRecordsMap[tableName].records;
       for (let sourceRecord of sourceRecords) {
         sourceRecord.isLoadedFromSource = true;
@@ -38,31 +41,39 @@ export class SourceRecordLoader {
           sourceRecord = { ...sourceRecord, ...dbSourceRecord };
           insertCount += 1;
         }
-  
-        new SourceRecordRepo().loadSourceRecord(table.name, sourceRecord as any)
+
+        new SourceRecordRepo().loadSourceRecord(table.name, sourceRecord as any);
       }
-      
-      this.logger.info(`(${table.name}) Loaded ${sourceRecords.length} ${sourceRecords.length == 1 ? 'record' : 'records'} from source (inserts: ${insertCount}, updates: ${updateCount}, deletes: ${deleteCount})`);
+
+      this.logger.info(
+        `(${table.name}) Loaded ${sourceRecords.length} ${sourceRecords.length == 1 ? 'record' : 'records'} from source (inserts: ${insertCount}, updates: ${updateCount}, deletes: ${deleteCount})`
+      );
     }
   }
 
   private async getSourceRecordsMap() {
     const sourceRecordsMap: SourceRecordsMap = {};
     const sourceRecordTables = getSourceRecordTables();
-    for (let sourceRecordTable of sourceRecordTables) {
-      if (!sourceRecordsMap[sourceRecordTable.name])
-        sourceRecordsMap[sourceRecordTable.name] = { table: sourceRecordTable, records: [], recordIds: []};
+    for (const sourceRecordTable of sourceRecordTables) {
+      if (!sourceRecordsMap[sourceRecordTable.name]) {
+        sourceRecordsMap[sourceRecordTable.name] = { table: sourceRecordTable, records: [], recordIds: [] };
+      }
     }
 
     const sourceRecordLoaders = getSourceRecordLoaders();
-    for (let sourceRecordLoader of sourceRecordLoaders) {
-      if (!sourceRecordsMap[sourceRecordLoader.table.name])
-        sourceRecordsMap[sourceRecordLoader.table.name] = { table: sourceRecordLoader.table, records: [], recordIds: []};
-  
+    for (const sourceRecordLoader of sourceRecordLoaders) {
+      if (!sourceRecordsMap[sourceRecordLoader.table.name]) {
+        sourceRecordsMap[sourceRecordLoader.table.name] = {
+          table: sourceRecordLoader.table,
+          records: [],
+          recordIds: [],
+        };
+      }
+
       sourceRecordsMap[sourceRecordLoader.table.name].records.push(sourceRecordLoader.record);
       sourceRecordsMap[sourceRecordLoader.table.name].recordIds.push(sourceRecordLoader.record.id);
     }
-  
+
     return sourceRecordsMap;
   }
-}
+}

package/src/source/SourceRecordRepo.ts

@@ -1,7 +1,7 @@
 import { SourceRecord } from './SourceRecord';
 
 export class SourceRecordRepo {
-  private static SOURCE_RECORD_MAP: {[key: string]: SourceRecord} = {};
+  private static SOURCE_RECORD_MAP: { [key: string]: SourceRecord } = {};
 
   private getKey(tableName: string, recordId: string) {
     return `${tableName}:${recordId}`;
@@ -11,7 +11,7 @@ export class SourceRecordRepo {
     SourceRecordRepo.SOURCE_RECORD_MAP[this.getKey(tableName, sourceRecord.id)] = sourceRecord;
   }
 
-  getSourceRecord<T extends SourceRecord = SourceRecord>(tableName: string, sourceRecordId: string): T|undefined {
+  getSourceRecord<T extends SourceRecord = SourceRecord>(tableName: string, sourceRecordId: string): T | undefined {
     return SourceRecordRepo.SOURCE_RECORD_MAP[this.getKey(tableName, sourceRecordId)] as T;
   }
-}
+}

package/src/tables/MigrationTable.ts

@@ -5,19 +5,19 @@ import { SourceRecord, withSourceRecordColumns } from '../source/SourceRecord';
 
 export interface Migration extends SourceRecord {
   description: string;
-  status?: 'proposed'|'running'|'success'|'failure';
+  status?: 'proposed' | 'running' | 'success' | 'failure';
   failureMessage?: string;
   failureStack?: string;
   startTime?: Moment;
   endTime?: Moment;
   duration?: string;
   output?: any;
-  run: () => Promise<any|void>;
+  run: () => Promise<any | void>;
 }
 
 export class MigrationTable extends Table<Migration> {
   public name = 'migration';
-	public columns = withSourceRecordColumns<Migration>({
+  public columns = withSourceRecordColumns<Migration>({
     description: new StringColumn('description', {}, 4000),
     status: new StringColumn('status', { defaultValue: async () => 'proposed' }),
     failureMessage: new StringColumn('failure_message', {}, 4000),
@@ -26,11 +26,11 @@ export class MigrationTable extends Table<Migration> {
     endTime: new DateTimeColumn('end_time'),
     duration: new StringColumn('duration'),
     output: new ObjectColumn('output'),
-	});
+  });
   public sourceRecordOptions = {
     doNotDeleteSourceRecordsFromDb: true,
     ui: {
       hideColumns: true,
     },
   };
-}
+}

package/src/tables/tables.ts

@@ -3,4 +3,4 @@ import { Migration, MigrationTable } from './MigrationTable';
 
 export const tables = {
   Migration: new MigrationTable() as Table<Migration>,
-}
+};

package/test/CrudTests.ts

@@ -5,46 +5,48 @@ import { StringColumn } from '../src/Columns';
 import { Table } from '../src/Table';
 
 export interface Employee extends Record {
-	name: string;
+  name: string;
   department?: string;
+  object?: string;
 }
 
 export class EmployeeTable extends Table<Employee> {
-	name = 'db_test_employee';
-	columns = withRecordColumns<Employee>({
-		name: new StringColumn('name'),
+  name = 'db_test_employee';
+  columns = withRecordColumns<Employee>({
+    name: new StringColumn('name'),
     department: new StringColumn('department'),
-	});
+    object: new StringColumn('object'),
+  });
 }
 
-export const crudTests = (
-  driver: DbDriver, 
-  dropTable: (table: Table<any>) => Promise<void>,
-) => {
+export const crudTests = (driver: DbDriver, dropTable: (table: Table<any>) => Promise<void>) => {
   return () => {
     const getTable = (tableName: string) => {
       const employeeTable = new EmployeeTable();
-      if (employeeTable.name == tableName)
+      if (employeeTable.name == tableName) {
         return employeeTable;
-  
+      }
+
       throw new Error('Cannot find test table');
     };
     const db = new Db(driver, getTable);
-  
+
     beforeAll(async () => {
-      if (driver.start)
+      if (driver.start) {
         await driver.start();
+      }
 
       await driver.getTableManager().loadTable(new EmployeeTable());
-    })
-    
+    });
+
     afterAll(async () => {
       await dropTable(new EmployeeTable());
-      
-      if (driver.stop)
+
+      if (driver.stop) {
         await driver.stop();
+      }
     });
-  
+
     test('Insert', async () => {
       const testEmployee: Omit<Employee, keyof Record> = { name: 'Veronica' };
       const emplyeeTable: Table<Employee> = new EmployeeTable();
@@ -53,18 +55,28 @@ export const crudTests = (
       expect(fetchedEmployee).toBeTruthy();
       await db.delete(emplyeeTable, { id: fetchedEmployee.id });
     });
-  
+
     test('Update', async () => {
       const testEmployee: Omit<Employee, keyof Record> = { name: 'Veronica' };
       const emplyeeTable: Table<Employee> = new EmployeeTable();
       const insertedEmployee = await db.insert(emplyeeTable, testEmployee);
-      const updateCount = await db.update(emplyeeTable, { department: 'Cake Factory' }, { id: insertedEmployee.id });
+      const updateCount = await db.update(
+        emplyeeTable,
+        {
+          name: 'Veronican',
+          department: 'Cake Factory',
+          object:
+            '{"cookie":{"originalMaxAge":5184000000,"expires":"2024-07-08T06:16:07.134Z","httpOnly":true,"path":"/"},"passport":{"user":"brent@n3xa.io"}}',
+        },
+        { id: insertedEmployee.id }
+      );
       expect(updateCount).toBe(1);
       const fetchedEmployee = await db.get(emplyeeTable, { id: insertedEmployee.id });
+      expect(fetchedEmployee.name).toBe('Veronican');
       expect(fetchedEmployee.department).toBe('Cake Factory');
       await db.delete(emplyeeTable, { id: fetchedEmployee.id });
     });
-  
+
     test('Delete', async () => {
       const testEmployee: Omit<Employee, keyof Record> = { name: 'Veronica' };
       const emplyeeTable: Table<Employee> = new EmployeeTable();
@@ -76,7 +88,7 @@ export const crudTests = (
       fetchedEmployee = await db.get(emplyeeTable, { id: insertedEmployee.id });
       expect(fetchedEmployee).toBeFalsy();
     });
-  
+
     test('Query', async () => {
       const testEmployee1: Omit<Employee, keyof Record> = { name: 'Veronica', department: 'Cake Factory' };
       const testEmployee2: Omit<Employee, keyof Record> = { name: 'Brent', department: 'Cake Factory' };
@@ -89,10 +101,14 @@ export const crudTests = (
       expect(fetchedEmployees.length).toBe(2);
       expect(fetchedEmployees[0].name).toBe('Veronica');
       expect(fetchedEmployees[1].name).toBe('Brent');
-      const qb = new QueryBuilder<Employee>(emplyeeTable.name).condition({ field: 'id', operator: 'IN', value: [fetchedEmployee1.id, fetchedEmployee2.id, fetchedEmployee3.id] });
+      const qb = new QueryBuilder<Employee>(emplyeeTable.name).condition({
+        field: 'id',
+        operator: 'IN',
+        value: [fetchedEmployee1.id, fetchedEmployee2.id, fetchedEmployee3.id],
+      });
       await db.delete(emplyeeTable, qb);
     });
-  
+
     test('Get row count', async () => {
       const testEmployee1: Omit<Employee, keyof Record> = { name: 'Veronica', department: 'Cake Factory' };
       const testEmployee2: Omit<Employee, keyof Record> = { name: 'Brent', department: 'Cake Factory' };
@@ -103,8 +119,12 @@ export const crudTests = (
       const fetchedEmployee3 = await db.insert(emplyeeTable, testEmployee3);
       const rowCount = await db.getRowCount(emplyeeTable, { department: 'Cake Factory' });
       expect(rowCount).toBe(2);
-      const qb = new QueryBuilder<Employee>(emplyeeTable.name).condition({ field: 'id', operator: 'IN', value: [fetchedEmployee1.id, fetchedEmployee2.id, fetchedEmployee3.id] });
+      const qb = new QueryBuilder<Employee>(emplyeeTable.name).condition({
+        field: 'id',
+        operator: 'IN',
+        value: [fetchedEmployee1.id, fetchedEmployee2.id, fetchedEmployee3.id],
+      });
       await db.delete(emplyeeTable, qb);
     });
   };
-}
+};