@proteinjs/db 1.0.14 → 1.0.16

package/src/schema/TableManager.ts

@@ -9,190 +9,200 @@ export interface ColumnTypeFactory {
 }
 
 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>) {
+  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;
-		}[] = [];
+      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)
+      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])
+        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_')
-			)
+        !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

@@ -2,12 +2,12 @@ import { ThirdPartyLibCustomSerializer } from '@proteinjs/serializer';
 import { graphSerializer, Graph, isInstanceOf } from '@proteinjs/util';
 
 type SerializedGraph = {
-  value: string,
-}
+  value: string;
+};
 
 export class GraphSerializer implements ThirdPartyLibCustomSerializer {
   id = '@proteinjs/serializer/GraphSerializer';
-  
+
   matches(obj: any) {
     return isInstanceOf(obj, Graph);
   }
@@ -19,4 +19,4 @@ export class GraphSerializer implements ThirdPartyLibCustomSerializer {
   deserialize(serializedGraph: SerializedGraph): Graph {
     return graphSerializer.deserialize(serializedGraph.value);
   }
-}
+}

package/src/serializers/QueryBuilderSerializer.ts

@@ -3,21 +3,21 @@ 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,
-}
+  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 { 
+    return {
       tableName: qb.tableName,
       graph: qb.graph,
       idCounter: qb.idCounter,
@@ -26,7 +26,7 @@ export class QueryBuilderSerializer implements CustomSerializer {
       paginationNodeId: qb.paginationNodeId,
     };
   }
-  
+
   deserialize(serializedQb: SerializedQueryBuilder): QueryBuilder<any> {
     const qb = new QueryBuilder(serializedQb.tableName);
     qb.graph = serializedQb.graph;
@@ -36,4 +36,4 @@ export class QueryBuilderSerializer implements CustomSerializer {
     qb.paginationNodeId = serializedQb.paginationNodeId;
     return qb;
   }
-}
+}

package/src/serializers/ReferenceArraySerializer.ts

@@ -2,16 +2,16 @@ import { CustomSerializer } from '@proteinjs/serializer';
 import { ReferenceArray } from '../reference/ReferenceArray';
 
 type SerializedReferenceArray = {
-  _table: string,
-  _ids: string[],
-  _objects: any,
-}
+  _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,
@@ -19,8 +19,12 @@ export class ReferenceArraySerializer implements CustomSerializer {
       _objects: referenceArray._objects,
     };
   }
-  
+
   deserialize(serializedReferenceArray: SerializedReferenceArray): ReferenceArray<any> {
-    return new ReferenceArray(serializedReferenceArray._table, serializedReferenceArray._ids, serializedReferenceArray._objects);
+    return new ReferenceArray(
+      serializedReferenceArray._table,
+      serializedReferenceArray._ids,
+      serializedReferenceArray._objects
+    );
   }
-}
+}

package/src/serializers/ReferenceSerializer.ts

@@ -2,16 +2,16 @@ import { CustomSerializer } from '@proteinjs/serializer';
 import { Reference } from '../reference/Reference';
 
 type SerializedReference = {
-  _table: string,
-  _id?: string,
-  _object?: any,
-}
+  _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,
@@ -19,8 +19,8 @@ export class ReferenceSerializer implements CustomSerializer {
       _object: reference._object,
     };
   }
-  
+
   deserialize(serializedReference: SerializedReference): Reference<any> {
     return new Reference(serializedReference._table, serializedReference._id, serializedReference._object);
   }
-}
+}

package/src/serializers/TableSerializer.ts

@@ -2,19 +2,19 @@ import { CustomSerializer } from '@proteinjs/serializer';
 import { Table, tableByName } from '../Table';
 
 type SerializedTable = {
-  tableName: string,
-}
+  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

@@ -5,8 +5,8 @@ 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 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>;
@@ -16,4 +16,4 @@ export interface DbService<R extends Record = Record> extends Service {
   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

@@ -4,4 +4,4 @@ export const getMigrationRunnerService = serviceFactory<MigrationRunnerService>(
 
 export interface MigrationRunnerService extends Service {
   runMigration(id: string): Promise<void>;
-}
+}