@proteinjs/db 1.0.2

package/src/auth/TableServiceAuth.ts

@@ -0,0 +1,32 @@
+import { Logger } from '@proteinjs/util';
+import { Table } from '../Table';
+import { TableAuth } from './TableAuth';
+
+export class TableServiceAuth {
+  private logger = new Logger(this.constructor.name);
+
+  canAccess(methodName: string, args: any[]): boolean {
+    try {
+      const table: Table<any>|undefined = args[0];
+      if (!(table instanceof Table))
+        throw new Error(`[DbServiceAuth] Expected first arg to be a table`);
+      
+      const tableAuth = new TableAuth();
+      if (methodName === 'get' || methodName == 'query' || methodName == 'getRowCount')
+        tableAuth.canQuery(table, 'service');
+      else if (methodName === 'insert')
+        tableAuth.canInsert(table, 'service');
+      else if (methodName === 'update')
+        tableAuth.canUpdate(table, 'service');
+      else if (methodName === 'delete')
+        tableAuth.canDelete(table, 'service');
+      else
+        throw new Error(`User is not authorized to access unsupported Db service api: ${methodName}`);
+    } catch (error: any) {
+      this.logger.error(error.stack);
+      return false;
+    }
+
+    return true;
+  }
+}

package/src/opt/moment.ts

@@ -0,0 +1,4 @@
+import moment from 'moment';
+import { Moment } from 'moment';
+
+export { Moment, moment };

package/src/reference/Reference.ts

@@ -0,0 +1,45 @@
+import { CustomSerializableObject } from '@proteinjs/serializer';
+import { getDb } from '../Db';
+import { Record } from '../Record';
+import { tableByName } from '../Table';
+import { ReferenceSerializerId } from '../serializers/ReferenceSerializer';
+
+/**
+ * The object returned by Db functions for each field of type ReferenceColumn in a record.
+ * The reason for this is to make loading of reference records on-demand. For theoretically 
+ * infinitely-nested references, this is necessary. For everything else, this is optimal.
+ * 
+ * Note: updating the reference via set does not automatically persist those changes in the db.
+ * You still need to call Db.update on the record as you would when changing any other field on the record.
+ * 
+ * Note: all instance members are internal state, made public for ReferenceArraySerializer.
+ * Only get() and set() should be used.
+ */
+export class Reference<T extends Record> implements CustomSerializableObject {
+  public __serializerId = ReferenceSerializerId;
+
+  constructor(
+    public _table: string,
+    public _id?: string,
+    public _object?: T,
+  ) {}
+
+  static fromObject<T extends Record>(table: string, object: T|(Partial<T> & { id: string })) {
+    return new Reference<T>(table, object.id, object as T);
+  }
+
+  async get(): Promise<T|undefined> {
+    if (!this._object && this._id) {
+      const table = tableByName(this._table);
+      const db = getDb();
+      this._object = await db.get(table, { id: this._id });
+    }
+
+    return this._object;
+  }
+
+  set(object: T) {
+    this._object = object;
+    this._id = object.id;
+  }
+}

package/src/reference/ReferenceArray.ts

@@ -0,0 +1,56 @@
+import { CustomSerializableObject } from '@proteinjs/serializer';
+import { getDb } from '../Db';
+import { Record } from '../Record';
+import { tableByName } from '../Table';
+import { ReferenceArraySerializerId } from '../serializers/ReferenceArraySerializer';
+import { QueryBuilderFactory } from '../QueryBuilderFactory';
+
+/**
+ * The object returned by Db functions for each field of type ReferenceArrayColumn in a record.
+ * The reason for this is to make loading of reference records on-demand. For theoretically 
+ * infinitely-nested references, this is necessary. For everything else, this is optimal.
+ * 
+ * Note: generally only get() needs to be called. Array operations performed on the returned array will be
+ * persisted in ReferenceArray.
+ * 
+ * Note: updating items in the returned array does not automatically persist those changes in the db.
+ * You still need to call Db.update on the record as you would when changing any other field on the record.
+ * 
+ * Note: all instance members are internal state, made public for ReferenceArraySerializer.
+ * Only get() and set() should be used.
+ */
+export class ReferenceArray<T extends Record> implements CustomSerializableObject {
+  public __serializerId = ReferenceArraySerializerId;
+
+  constructor(
+    public _table: string,
+    public _ids: string[],
+    public _objects?: T[],
+  ) {}
+
+  static fromObjects<T extends Record>(table: string, objects: (T|(Partial<T> & { id: string }))[]) {
+    const ids = objects.map(object => object.id);
+    return new ReferenceArray<T>(table, ids, objects as T[]);
+  }
+
+  async get(): Promise<T[]> {
+    if (!this._objects) {
+      if (this._ids.length < 1) {
+        this._objects = [];
+      } else {
+        const table = tableByName(this._table);
+        const db = getDb();
+        const qb = new QueryBuilderFactory().getQueryBuilder(table);
+        qb.condition({ field: 'id', operator: 'IN', value: this._ids });
+        qb.sort([{ field: 'id', byValues: this._ids }]);
+        this._objects = await db.query(table, qb);
+      }
+    }
+
+    return this._objects;
+  }
+
+  set(objects: T[]) {
+    this._objects = objects;
+  }
+}

package/src/schema/SchemaMetadata.ts

@@ -0,0 +1,115 @@
+import { ParameterizationConfig, QueryBuilder } from '@proteinjs/db-query';
+import { Table } from '../Table';
+import { DbDriver } from '../Db';
+
+export class SchemaMetadata {
+  constructor(
+    public dbDriver: DbDriver,
+    private multiDbSupported = true
+  ){}
+
+  async tableExists(table: Table<any>): Promise<boolean> {
+		const qb = new QueryBuilder('TABLES').condition({ field: 'TABLE_NAME', operator: '=', value: table.name });
+		const generateStatement = (config: ParameterizationConfig) => qb.toSql({ dbName: 'INFORMATION_SCHEMA', ...config });
+		const results = await this.dbDriver.runQuery(generateStatement);
+		return results.length > 0;
+	}
+
+  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,
+    }, 'COLUMNS');
+		const generateStatement = (config: ParameterizationConfig) => qb.toSql({ dbName: 'INFORMATION_SCHEMA', ...config });
+		const results = await this.dbDriver.runQuery(generateStatement);
+		return results.length > 0;
+  }
+  
+  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
+    }, 'COLUMNS');
+    const generateStatement = (config: ParameterizationConfig) => qb.toSql({ dbName: 'INFORMATION_SCHEMA', ...config });
+		const results = await this.dbDriver.runQuery(generateStatement);
+    const columnMetadata: {[columnName: string]: { type: string, isNullable: boolean }} = {};
+    for (const row of results)
+      columnMetadata[row['COLUMN_NAME']] = { type: row['DATA_TYPE'], isNullable: row['IS_NULLABLE'] === 'YES' };
+  
+    return columnMetadata;
+  }
+  
+  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',
+    }, 'KEY_COLUMN_USAGE');
+    const generateStatement = (config: ParameterizationConfig) => qb.toSql({ dbName: 'INFORMATION_SCHEMA' });
+		const results = await this.dbDriver.runQuery(generateStatement);
+    const primaryKey: string[] = [];
+    for (const row of results)
+      primaryKey.push(row['COLUMN_NAME']);
+  
+    return primaryKey;
+  }
+  
+  async getForeignKeys(table: Table<any>): Promise<{[columnName: string]: { referencedTableName: string, referencedColumnName: string }}> {
+    const qb = QueryBuilder.fromObject({
+      'TABLE_SCHEMA': this.multiDbSupported ? this.dbDriver.getDbName() : undefined,
+      'TABLE_NAME': table.name
+    }, 'KEY_COLUMN_USAGE');
+    const generateStatement = (config: ParameterizationConfig) => qb.toSql({ dbName: 'INFORMATION_SCHEMA', ...config });
+		const results = await this.dbDriver.runQuery(generateStatement);
+    const foreignKeys: {[columnName: string]: { referencedTableName: string, referencedColumnName: string }} = {};
+    for (const row of results) {
+      if (!row['REFERENCED_TABLE_NAME'])
+        continue;
+  
+      foreignKeys[row['COLUMN_NAME']] = {
+        referencedTableName: row['REFERENCED_TABLE_NAME'],
+        referencedColumnName: row['REFERENCED_COLUMN_NAME'],
+      };
+    }
+  
+    return foreignKeys;
+  }
+  
+  async getUniqueColumns(table: Table<any>): Promise<string[]> {
+    const qb = QueryBuilder.fromObject({
+      'TABLE_SCHEMA': this.multiDbSupported ? this.dbDriver.getDbName() : undefined,
+      'TABLE_NAME': table.name
+    }, 'KEY_COLUMN_USAGE');
+    const generateStatement = (config: ParameterizationConfig) => qb.toSql({ dbName: 'INFORMATION_SCHEMA', ...config });
+		const results = await this.dbDriver.runQuery(generateStatement);
+    const uniqueColumns: string[] = [];
+    for (const row of results) {
+      if (!(row['CONSTRAINT_NAME'] as string).endsWith('_unique'))
+        continue;
+  
+      uniqueColumns.push(row['COLUMN_NAME']);
+    }
+  
+    return uniqueColumns;
+  }
+  
+  async getIndexes(table: Table<any>): Promise<{[keyName: string]: string[]}> {
+    const qb = new QueryBuilder('STATISTICS')
+      .condition({ field: 'TABLE_SCHEMA', operator: '=', value: this.dbDriver.getDbName() })
+      .condition({ field: 'TABLE_NAME', operator: '=', value: table.name })
+      .sort([{ field: 'SEQ_IN_INDEX', desc: false }])
+    ;
+    const generateStatement = (config: ParameterizationConfig) => qb.toSql({ dbName: 'INFORMATION_SCHEMA', ...config });
+		const results: any[] = await this.dbDriver.runQuery(generateStatement);
+    const indexes: { [keyName: string]: string[] } = {};
+    for (const row of results) {
+      if (!indexes[row['INDEX_NAME']])
+        indexes[row['INDEX_NAME']] = [];
+  
+      indexes[row['INDEX_NAME']].push(row['COLUMN_NAME']);
+    }
+  
+    return indexes;
+  }
+}

package/src/schema/SchemaOperations.ts

@@ -0,0 +1,44 @@
+import { Table } from '../Table';
+
+export interface SchemaOperations {
+  createTable(table: Table<any>): Promise<void>;
+  alterTable(table: Table<any>, changes: TableChanges): Promise<void>;
+}
+
+interface Index {
+  name?: string;
+  columns: string|string[];
+  unique?: boolean;
+}
+
+interface ForeignKey {
+  table: string; // table that is referenced
+  column: string; // column that is referenced
+  referencedByColumn: string; // column the constraint is applied to
+}
+
+interface ColumnTypeChange {
+  name: string;
+  newType: string;
+}
+
+interface ColumnNullableChange {
+  name: string;
+  nullable: boolean;
+}
+
+export interface TableChanges {
+  columnsToCreate: string[];
+  columnsToRename: string[];
+  columnsToAlter: string[];
+  columnTypeChanges: ColumnTypeChange[];
+  columnNullableChanges: ColumnNullableChange[];
+  columnsWithForeignKeysToCreate: string[];
+  foreignKeysToCreate: ForeignKey[];
+  columnsWithForeignKeysToDrop: string[];
+  foreignKeysToDrop: ForeignKey[];
+  columnsWithUniqueConstraintsToCreate: string[];
+  columnsWithUniqueConstraintsToDrop: string[];
+  indexesToCreate: Index[];
+  indexesToDrop: Index[];
+}

package/src/schema/TableManager.ts

@@ -0,0 +1,198 @@
+import { Logger } from '@proteinjs/util';
+import { Column, Table, getTables, tableByName } from '../Table';
+import { SchemaOperations, TableChanges } from './SchemaOperations';
+import { SchemaMetadata } from './SchemaMetadata';
+import { DbDriver } from '../Db';
+
+export interface ColumnTypeFactory {
+  getType(column: Column<any, any>): string;
+}
+
+export class TableManager {
+	private logger = new Logger(this.constructor.name);
+	public columnTypeFactory: ColumnTypeFactory;
+	public schemaOperations: SchemaOperations;
+	public schemaMetadata: SchemaMetadata;
+
+	constructor(
+		dbDriver: DbDriver,
+		columnTypeFactory: ColumnTypeFactory,
+		schemaOperations: SchemaOperations,
+		schemaMetadata?: SchemaMetadata
+	){
+		this.columnTypeFactory = columnTypeFactory;
+		this.schemaOperations = schemaOperations;
+		this.schemaMetadata = schemaMetadata ? schemaMetadata : new SchemaMetadata(dbDriver);
+	}
+
+	async tableExists(table: Table<any>) {
+		return await this.schemaMetadata.tableExists(table);
+	}
+
+	async loadTables(): Promise<void> {
+		const tables = getTables();
+		for (const table of tables)
+			await this.loadTable(table);
+	}
+
+	async loadTable(table: Table<any>): Promise<void> {
+		if (await this.tableExists(table)) {
+			const tableChanges = await this.getTableChanges(table);
+			if (this.shouldAlterTable(tableChanges)) {
+				this.logger.info(`Altering table: ${table.name}`);
+				await this.schemaOperations.alterTable(table, tableChanges);
+				this.logger.info(`Finished altering table: ${table.name}`);
+			}
+		} else {
+			this.logger.info(`Creating table: ${table.name}`);
+			await this.schemaOperations.createTable(table);
+			this.logger.info(`Finished creating table: ${table.name}`);
+		}
+	}
+
+	private shouldAlterTable(tableChanges: TableChanges) {
+		if (
+			tableChanges.columnsToCreate.length == 0 && 
+			tableChanges.columnsToRename.length == 0 && 
+			tableChanges.columnsToAlter.length == 0 &&
+			tableChanges.columnsWithForeignKeysToDrop.length == 0 &&
+			tableChanges.columnsWithUniqueConstraintsToDrop.length == 0 &&
+			tableChanges.indexesToCreate.length == 0 &&
+			tableChanges.indexesToDrop.length == 0
+		)
+			return false;
+
+		return true;
+	}
+
+	private async getTableChanges(table: Table<any>) {
+		const { indexesToCreate, indexesToDrop } = await this.getIndexOperations(table);
+		const tableChanges: TableChanges = {
+			columnsToCreate: [],
+			columnsToRename: [],
+			columnsToAlter: [],
+			columnTypeChanges: [],
+			columnNullableChanges: [],
+			columnsWithForeignKeysToCreate: [],
+			foreignKeysToCreate: [],
+			columnsWithForeignKeysToDrop: [],
+			foreignKeysToDrop: [],
+			columnsWithUniqueConstraintsToCreate: [],
+			columnsWithUniqueConstraintsToDrop: [],
+			indexesToCreate,
+			indexesToDrop,
+		};
+
+		const columnMetadata = await this.schemaMetadata.getColumnMetadata(table);
+		const uniqueColumns = await this.schemaMetadata.getUniqueColumns(table);
+		const foreignKeys = await this.schemaMetadata.getForeignKeys(table);
+		for (const columnPropertyName in table.columns) {
+			const column = table.columns[columnPropertyName];
+			if (columnMetadata[column.name]) {
+				let alter = false;
+				const columnType = this.columnTypeFactory.getType(column);
+				const existingColumnType = columnMetadata[column.name].type;
+				if (columnType != existingColumnType) {
+					// console.log(`columnType != existingColumnType`);
+					tableChanges.columnTypeChanges.push({ name: column.name, newType: columnType });
+					alter = true;
+				}
+				
+				if (
+					(column.options?.nullable && !columnMetadata[column.name].isNullable) ||
+					(column.options?.nullable === false && columnMetadata[column.name].isNullable)
+				) {
+					// console.log(`column.options?.nullable`)
+					tableChanges.columnNullableChanges.push({ name: column.name, nullable: column.options.nullable === true });
+					alter = true;
+				}
+				
+				if (
+					column.options?.unique?.unique === false && uniqueColumns.includes(column.name)
+				) {
+					// console.log(`column.options?.unique?.unique`)
+					tableChanges.columnsWithUniqueConstraintsToDrop.push(column.name);
+					alter = true;
+				} else if (
+					column.options?.unique?.unique && !uniqueColumns.includes(column.name)
+				) {
+					tableChanges.columnsWithUniqueConstraintsToCreate.push(column.name);
+					alter = true;
+				}
+				
+				if (
+					!column.options?.references && foreignKeys[column.name] ||
+					column.options?.references && foreignKeys[column.name] && foreignKeys[column.name].referencedTableName != column.options.references.table
+				) {
+					// console.log(`column.options?.references`)
+					tableChanges.columnsWithForeignKeysToDrop.push(column.name);
+					tableChanges.foreignKeysToDrop.push({ table: foreignKeys[column.name].referencedTableName, column: foreignKeys[column.name].referencedColumnName, referencedByColumn: column.name });
+					alter = true;
+				} else if (
+					column.options?.references && !foreignKeys[column.name]
+				) {
+					tableChanges.columnsWithForeignKeysToCreate.push(column.name);
+					tableChanges.foreignKeysToCreate.push({ table: column.options.references.table, column: 'id', referencedByColumn: column.name });
+					alter = true;
+				}
+	
+				if (alter)
+					tableChanges.columnsToAlter.push(columnPropertyName);
+	
+				continue;
+			}
+	
+			if (column.oldName && columnMetadata[column.oldName]) {
+				tableChanges.columnsToRename.push(columnPropertyName);
+				continue;
+			}		
+	
+			tableChanges.columnsToCreate.push(columnPropertyName);
+		}
+
+		return tableChanges;
+	}
+
+	private async getIndexOperations(table: Table<any>) {
+    const existingIndexes = await this.schemaMetadata.getIndexes(table);
+    const indexesToDrop: {
+			name?: string;
+			columns: string|string[];
+			unique?: boolean;
+		}[] = [];
+    const indexesToCreate: {
+			name?: string;
+			columns: string|string[];
+			unique?: boolean;
+		}[] = [];
+    const currentIndexMap: {[serializedColumns: string]: boolean} = {};
+    const existingIndexMap: {[serializedColumns: string]: boolean} = {};
+		for (const keyName in existingIndexes)
+      existingIndexMap[JSON.stringify(existingIndexes[keyName])] = true;
+  
+    if (table.indexes) {
+      for (const index of table.indexes) {
+        const serializedColumns = JSON.stringify(index.columns);
+        currentIndexMap[serializedColumns] = true;
+        if (!existingIndexMap[serializedColumns])
+          indexesToCreate.push({ name: index.name, columns: index.columns as string[] });
+      }
+    }
+  
+    for (const keyName in existingIndexes) {
+      const existingIndex = existingIndexes[keyName];
+      const serializedColumns = JSON.stringify(existingIndex);
+      if (
+				!currentIndexMap[serializedColumns] && 
+				keyName != 'PRIMARY' &&
+				keyName != 'PRIMARY_KEY' &&
+				!keyName.endsWith('_unique') &&
+				!keyName.endsWith('_foreign') &&
+				!keyName.startsWith('IDX_')
+			)
+        indexesToDrop.push({ name: keyName, columns: existingIndex });
+    }
+  
+    return { indexesToCreate, indexesToDrop };
+  }
+}

package/src/serializers/GraphSerializer.ts

@@ -0,0 +1,22 @@
+import { ThirdPartyLibCustomSerializer } from '@proteinjs/serializer';
+import { graphSerializer, Graph } from '@proteinjs/util';
+
+type SerializedGraph = {
+  value: string,
+}
+
+export class GraphSerializer implements ThirdPartyLibCustomSerializer {
+  id = '@proteinjs/serializer/GraphSerializer';
+  
+  matches(obj: any) {
+    return obj instanceof Graph;
+  }
+
+  serialize(graph: Graph): SerializedGraph {
+    return { value: graphSerializer.serialize(graph) };
+  }
+
+  deserialize(serializedGraph: SerializedGraph): Graph {
+    return graphSerializer.deserialize(serializedGraph.value);
+  }
+}

package/src/serializers/QueryBuilderSerializer.ts

@@ -0,0 +1,39 @@
+import { CustomSerializer } from '@proteinjs/serializer';
+import { Graph } from '@proteinjs/util';
+import { QueryBuilder } from '@proteinjs/db-query';
+
+type SerializedQueryBuilder = {
+  tableName: string,
+  graph: Graph,
+  idCounter: number,
+  rootId: string,
+  currentContextIds: string[],
+  paginationNodeId?: string,
+}
+
+export const QueryBuilderSerializerId = '@proteinjs/db/QueryBuilderSerializer';
+
+export class QueryBuilderSerializer implements CustomSerializer {
+  id = QueryBuilderSerializerId;
+  
+  serialize(qb: QueryBuilder<any>): SerializedQueryBuilder {
+    return { 
+      tableName: qb.tableName,
+      graph: qb.graph,
+      idCounter: qb.idCounter,
+      rootId: qb.rootId,
+      currentContextIds: qb.currentContextIds,
+      paginationNodeId: qb.paginationNodeId,
+    };
+  }
+  
+  deserialize(serializedQb: SerializedQueryBuilder): QueryBuilder<any> {
+    const qb = new QueryBuilder(serializedQb.tableName);
+    qb.graph = serializedQb.graph;
+    qb.idCounter = serializedQb.idCounter;
+    qb.rootId = serializedQb.rootId;
+    qb.currentContextIds = serializedQb.currentContextIds;
+    qb.paginationNodeId = serializedQb.paginationNodeId;
+    return qb;
+  }
+}

package/src/serializers/ReferenceArraySerializer.ts

@@ -0,0 +1,26 @@
+import { CustomSerializer } from '@proteinjs/serializer';
+import { ReferenceArray } from '../reference/ReferenceArray';
+
+type SerializedReferenceArray = {
+  _table: string,
+  _ids: string[],
+  _objects: any,
+}
+
+export const ReferenceArraySerializerId = '@proteinjs/db/ReferenceArraySerializer';
+
+export class ReferenceArraySerializer implements CustomSerializer {
+  id = ReferenceArraySerializerId;
+  
+  serialize(referenceArray: ReferenceArray<any>): SerializedReferenceArray {
+    return {
+      _table: referenceArray._table,
+      _ids: referenceArray._ids,
+      _objects: referenceArray._objects,
+    };
+  }
+  
+  deserialize(serializedReferenceArray: SerializedReferenceArray): ReferenceArray<any> {
+    return new ReferenceArray(serializedReferenceArray._table, serializedReferenceArray._ids, serializedReferenceArray._objects);
+  }
+}

package/src/serializers/ReferenceSerializer.ts

@@ -0,0 +1,26 @@
+import { CustomSerializer } from '@proteinjs/serializer';
+import { Reference } from '../reference/Reference';
+
+type SerializedReference = {
+  _table: string,
+  _id?: string,
+  _object?: any,
+}
+
+export const ReferenceSerializerId = '@proteinjs/db/ReferenceSerializer';
+
+export class ReferenceSerializer implements CustomSerializer {
+  id = ReferenceSerializerId;
+  
+  serialize(reference: Reference<any>): SerializedReference {
+    return {
+      _table: reference._table,
+      _id: reference._id,
+      _object: reference._object,
+    };
+  }
+  
+  deserialize(serializedReference: SerializedReference): Reference<any> {
+    return new Reference(serializedReference._table, serializedReference._id, serializedReference._object);
+  }
+}

package/src/serializers/TableSerializer.ts

@@ -0,0 +1,20 @@
+import { CustomSerializer } from '@proteinjs/serializer';
+import { Table, tableByName } from '../Table';
+
+type SerializedTable = {
+  tableName: string,
+}
+
+export const TableSerializerId = '@proteinjs/db/TableSerializer';
+
+export class TableSerializer implements CustomSerializer {
+  id = TableSerializerId;
+  
+  serialize(table: Table<any>): SerializedTable {
+    return { tableName: table.name };
+  }
+  
+  deserialize(serializedTable: SerializedTable): Table<any> {
+    return tableByName(serializedTable.tableName);
+  }
+}

package/src/services/DbService.ts

@@ -0,0 +1,19 @@
+import { Service, serviceFactory } from '@proteinjs/service';
+import { Table } from '../Table';
+import { Record } from '../Record';
+import { QueryBuilder } from '@proteinjs/db-query';
+
+export const getDbService = serviceFactory<DbService>('@proteinjs/db/DbService');
+
+export type Query<T> = ObjectQuery<T> | QueryBuilder<T>
+export type ObjectQuery<T> = Partial<{[P in keyof T]: any}>
+
+export interface DbService<R extends Record = Record> extends Service {
+  tableExists<T extends R>(table: Table<T>): Promise<boolean>;
+  get<T extends R>(table: Table<T>, query: Query<T>): Promise<T>;
+  insert<T extends R>(table: Table<T>, record: Omit<T, keyof R>): Promise<T>;
+  update<T extends R>(table: Table<T>, record: Partial<T>, query?: Query<T>): Promise<number>;
+  delete<T extends R>(table: Table<T>, query: Query<T>): Promise<number>;
+  query<T extends R>(table: Table<T>, query: Query<T>): Promise<T[]>;
+  getRowCount<T extends R>(table: Table<T>, query?: Query<T>): Promise<number>;
+}

package/src/services/MigrationRunnerService.ts

@@ -0,0 +1,7 @@
+import { Service, serviceFactory } from '@proteinjs/service';
+
+export const getMigrationRunnerService = serviceFactory<MigrationRunnerService>('@proteinjs/db/MigrationRunnerService');
+
+export interface MigrationRunnerService extends Service {
+  runMigration(id: string): Promise<void>;
+}