@proteinjs/db 1.0.2

package/src/source/SourceRecord.ts

@@ -0,0 +1,75 @@
+import { Loadable, SourceRepository } from '@proteinjs/reflection';
+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 function getSourceRecordTables() {
+  const tables = getTables();
+  const sourceRecordTables: Table<any>[] = [];
+  for (let table of tables) {
+    if (isSourceRecordTable(table))
+      sourceRecordTables.push(table);
+  }
+
+  return sourceRecordTables;
+}
+
+export function isSourceRecordTable(table: Table<any>) {
+  for (let columnPropertyName in table.columns) {
+    const column = table.columns[columnPropertyName];
+    if (column.name == getSourceRecordColumns().isLoadedFromSource.name)
+      return true;
+  }
+
+  return false;
+}
+
+export interface SourceRecord extends DbRecord {
+  isLoadedFromSource?: boolean;
+}
+
+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);
+}
+
+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]>;
+
+/**
+ * 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>,
+  record: {
+    [P in keyof RequiredProperties<InferRecordWithoutTimestamps<Table<T>>>]: RequiredProperties<InferRecordWithoutTimestamps<Table<T>>>[P];
+  } & {
+    [P in keyof OptionalProperties<InferRecordWithoutTimestamps<Table<T>>>]?: OptionalProperties<InferRecordWithoutTimestamps<Table<T>>>[P];
+  }
+}

package/src/source/SourceRecordLoader.ts

@@ -0,0 +1,68 @@
+import { Logger } from '@proteinjs/util';
+import { QueryBuilder } from '@proteinjs/db-query';
+import { getSourceRecordLoaders, SourceRecord, getSourceRecordTables } from './SourceRecord';
+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[] }}
+
+export class SourceRecordLoader {
+  private logger = new Logger(this.constructor.name);
+
+  async load() {
+    const sourceRecordsMap = await this.getSourceRecordsMap();
+    const db = getSystemDb();
+    for (let tableName in sourceRecordsMap) {
+      let insertCount = 0;
+      let updateCount = 0;
+      let deleteCount = 0;
+      const table = sourceRecordsMap[tableName].table;
+      const sourceRecordIds = sourceRecordsMap[tableName].recordIds;
+      if (!table.sourceRecordOptions.doNotDeleteSourceRecordsFromDb) {
+        const qb = QueryBuilder.fromObject<SourceRecord>({ isLoadedFromSource: true }, table.name);
+        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;
+        const count = await db.update(table, sourceRecord);
+        if (count > 0) {
+          updateCount += count;
+        } else {
+          const dbSourceRecord = await db.insert(table, sourceRecord);
+          sourceRecord = { ...sourceRecord, ...dbSourceRecord };
+          insertCount += 1;
+        }
+  
+        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})`);
+    }
+  }
+
+  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: []};
+    }
+
+    const sourceRecordLoaders = getSourceRecordLoaders();
+    for (let 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

@@ -0,0 +1,17 @@
+import { SourceRecord } from './SourceRecord';
+
+export class SourceRecordRepo {
+  private static SOURCE_RECORD_MAP: {[key: string]: SourceRecord} = {};
+
+  private getKey(tableName: string, recordId: string) {
+    return `${tableName}:${recordId}`;
+  }
+
+  loadSourceRecord(tableName: string, sourceRecord: SourceRecord): void {
+    SourceRecordRepo.SOURCE_RECORD_MAP[this.getKey(tableName, sourceRecord.id)] = sourceRecord;
+  }
+
+  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

@@ -0,0 +1,36 @@
+import { Moment } from '../opt/moment';
+import { DateTimeColumn, ObjectColumn, StringColumn } from '../Columns';
+import { Table } from '../Table';
+import { SourceRecord, withSourceRecordColumns } from '../source/SourceRecord';
+
+export interface Migration extends SourceRecord {
+  description: string;
+  status?: 'proposed'|'running'|'success'|'failure';
+  failureMessage?: string;
+  failureStack?: string;
+  startTime?: Moment;
+  endTime?: Moment;
+  duration?: string;
+  output?: any;
+  run: () => Promise<any|void>;
+}
+
+export class MigrationTable extends Table<Migration> {
+  public name = 'migration';
+	public columns = withSourceRecordColumns<Migration>({
+    description: new StringColumn('description', {}, 4000),
+    status: new StringColumn('status', { defaultValue: async () => 'proposed' }),
+    failureMessage: new StringColumn('failure_message', {}, 4000),
+    failureStack: new StringColumn('failure_stack', {}, 'MAX'),
+    startTime: new DateTimeColumn('start_time'),
+    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

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

package/test/CrudTests.ts

@@ -0,0 +1,110 @@
+import { QueryBuilder } from '@proteinjs/db-query';
+import { DbDriver, Db } from '../src/Db';
+import { withRecordColumns, Record } from '../src/Record';
+import { StringColumn } from '../src/Columns';
+import { Table } from '../src/Table';
+
+export interface Employee extends Record {
+	name: string;
+  department?: string;
+}
+
+export class EmployeeTable extends Table<Employee> {
+	name = 'db_test_employee';
+	columns = withRecordColumns<Employee>({
+		name: new StringColumn('name'),
+    department: new StringColumn('department'),
+	});
+}
+
+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);
+  
+    beforeAll(async () => {
+      if (driver.start)
+        await driver.start();
+
+      await driver.getTableManager().loadTable(new EmployeeTable());
+    })
+    
+    afterAll(async () => {
+      await dropTable(new EmployeeTable());
+      
+      if (driver.stop)
+        await driver.stop();
+    });
+  
+    test('Insert', async () => {
+      const testEmployee: Omit<Employee, keyof Record> = { name: 'Veronica' };
+      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();
+      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 });
+      expect(updateCount).toBe(1);
+      const fetchedEmployee = await db.get(emplyeeTable, { id: insertedEmployee.id });
+      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();
+      const insertedEmployee = await db.insert(emplyeeTable, testEmployee);
+      let fetchedEmployee = await db.get(emplyeeTable, { id: insertedEmployee.id });
+      expect(fetchedEmployee).toBeTruthy();
+      const deleteCount = await db.delete(emplyeeTable, { id: fetchedEmployee.id });
+      expect(deleteCount).toBe(1);
+      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' };
+      const testEmployee3: Omit<Employee, keyof Record> = { name: 'Sean', department: 'Pug Playhouse' };
+      const emplyeeTable: Table<Employee> = new EmployeeTable();
+      const fetchedEmployee1 = await db.insert(emplyeeTable, testEmployee1);
+      const fetchedEmployee2 = await db.insert(emplyeeTable, testEmployee2);
+      const fetchedEmployee3 = await db.insert(emplyeeTable, testEmployee3);
+      const fetchedEmployees = await db.query(emplyeeTable, { department: 'Cake Factory' });
+      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] });
+      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' };
+      const testEmployee3: Omit<Employee, keyof Record> = { name: 'Sean', department: 'Pug Playhouse' };
+      const emplyeeTable: Table<Employee> = new EmployeeTable();
+      const fetchedEmployee1 = await db.insert(emplyeeTable, testEmployee1);
+      const fetchedEmployee2 = await db.insert(emplyeeTable, testEmployee2);
+      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] });
+      await db.delete(emplyeeTable, qb);
+    });
+  };
+}