@proteinjs/db 1.0.15 → 1.0.17

package/src/Table.ts

@@ -10,117 +10,120 @@ export const isTable = (obj: any) => obj.__serializerId === TableSerializerId;
 export const getTables = <T extends Record = any>() => SourceRepository.get().objects<Table<T>>('@proteinjs/db/Table');
 
 export const tableByName = (name: string) => {
-	const tables = getTables();
-	for (let table of tables) {
-		if (table.name == name)
-			return table;
-	}
+  const tables = getTables();
+  for (const table of tables) {
+    if (table.name == name) {
+      return table;
+    }
+  }
 
-	throw new Error(`Unable to find table: ${name}`);
-}
+  throw new Error(`Unable to find table: ${name}`);
+};
 
 export const getColumnPropertyName = (table: Table<any>, columnName: string) => {
-	for (let columnPropertyName in table.columns) {
-		const column = table.columns[columnPropertyName];
-		if (column.name == columnName)
-			return columnPropertyName;
-	}
+  for (const columnPropertyName in table.columns) {
+    const column = table.columns[columnPropertyName];
+    if (column.name == columnName) {
+      return columnPropertyName;
+    }
+  }
 
-	return null;
-}
+  return null;
+};
 
 export const getColumnByName = (table: Table<any>, columnName: string) => {
-	for (let columnPropertyName in table.columns) {
-		const column = table.columns[columnPropertyName];
-		if (column.name == columnName)
-			return column;
-	}
+  for (const columnPropertyName in table.columns) {
+    const column = table.columns[columnPropertyName];
+    if (column.name == columnName) {
+      return column;
+    }
+  }
 
-	return null;
-}
+  return null;
+};
 
 /**
  * primary key is `id`
  */
 export abstract class Table<T extends Record> implements Loadable, CustomSerializableObject {
-	public __serializerId = TableSerializerId;
-	abstract name: string;
-	abstract columns: Columns<T>;
-	public indexes: { columns: (keyof T)[], name?: string }[] = [];
-	/** When records are deleted, delete records having references pointing to deleted records */
-	public cascadeDeleteReferences: () => { table: string, referenceColumn: string }[] = () => [];
-	/** 
-	 * Options for configuring SourceRecords
-	 * @param doNotDeleteSourceRecordsFromDb if true, the SourceRecordLoader will not delete source records from the db if they no longer exist on the file system
-	 */
-	public sourceRecordOptions: SourceRecordOptions = { 
-		doNotDeleteSourceRecordsFromDb: false,
-	};
-	public auth?: {
-		db?: TableOperationsAuth,
-		service?: TableOperationsAuth,
-		ui?: {
-			recordTable?: Identity,
-			recordForm?: Identity,
-		},
-	};
+  public __serializerId = TableSerializerId;
+  abstract name: string;
+  abstract columns: Columns<T>;
+  public indexes: { columns: (keyof T)[]; name?: string }[] = [];
+  /** When records are deleted, delete records having references pointing to deleted records */
+  public cascadeDeleteReferences: () => { table: string; referenceColumn: string }[] = () => [];
+  /**
+   * Options for configuring SourceRecords
+   * @param doNotDeleteSourceRecordsFromDb if true, the SourceRecordLoader will not delete source records from the db if they no longer exist on the file system
+   */
+  public sourceRecordOptions: SourceRecordOptions = {
+    doNotDeleteSourceRecordsFromDb: false,
+  };
+  public auth?: {
+    db?: TableOperationsAuth;
+    service?: TableOperationsAuth;
+    ui?: {
+      recordTable?: Identity;
+      recordForm?: Identity;
+    };
+  };
 }
 
 type ExcludeFunctions<T> = {
-  [P in keyof T as T[P] extends Function ? never : P]: T[P]
-}
+  [P in keyof T as T[P] extends Function ? never : P]: T[P];
+};
 
 type RequiredProps<T> = {
-  [P in keyof ExcludeFunctions<T>]: ExcludeFunctions<T>[P] extends undefined ? never : P
-}[keyof ExcludeFunctions<T>]
+  [P in keyof ExcludeFunctions<T>]: ExcludeFunctions<T>[P] extends undefined ? never : P;
+}[keyof ExcludeFunctions<T>];
 
 type OptionalProps<T> = {
-  [P in keyof ExcludeFunctions<T>]: ExcludeFunctions<T>[P] extends undefined ? P : never
-}[keyof ExcludeFunctions<T>]
+  [P in keyof ExcludeFunctions<T>]: ExcludeFunctions<T>[P] extends undefined ? P : never;
+}[keyof ExcludeFunctions<T>];
 
 export type Columns<T> = {
-	[P in RequiredProps<T>]: Column<T[P], any>
+  [P in RequiredProps<T>]: Column<T[P], any>;
 } & {
-	[P in OptionalProps<T>]?: Column<T[P] | undefined, any>
-}
+  [P in OptionalProps<T>]?: Column<T[P] | undefined, any>;
+};
 
 export type Column<T, Serialized> = {
-	name: string,
-	/**
-	 * Use to rename column, will find column with `oldName` and change it to `name`.
-	 * 
-	 * Note: after name change has happened in prod, oldName can be removed.
-	 */
-	oldName?: string,
-	options?: ColumnOptions,
-	serialize?: (fieldValue: T|undefined) => Promise<Serialized|undefined>,
-	deserialize?: (serializedFieldValue: Serialized) => Promise<T|void>,
-	beforeDelete?: (table: Table<any>, columnPropertyName: string, records: any[]) => Promise<void>,
-}
+  name: string;
+  /**
+   * Use to rename column, will find column with `oldName` and change it to `name`.
+   *
+   * Note: after name change has happened in prod, oldName can be removed.
+   */
+  oldName?: string;
+  options?: ColumnOptions;
+  serialize?: (fieldValue: T | undefined) => Promise<Serialized | undefined>;
+  deserialize?: (serializedFieldValue: Serialized) => Promise<T | void>;
+  beforeDelete?: (table: Table<any>, columnPropertyName: string, records: any[]) => Promise<void>;
+};
 
 export type ColumnOptions = {
-	unique?: { unique: boolean, indexName?: string },
-	/**
-	 * The column in the reference table `table` is the primary key of the table (`id` unless otherwise specified in the Table definition)
-	 * 
-	 * Note: use a migration to drop or change an existing foreign key
-	 */
-	references?: { table: string },
-	nullable?: boolean,
-	/** Value stored on insert */
-	defaultValue?: (insertObj: any) => Promise<any>,
-	/** Value stored on update */
-	updateValue?: (updateObj: any) => Promise<any>,
-	/** Add conditions to query; called on every query of this table */
-	addToQuery?: (qb: QueryBuilder) => Promise<void>,
-	ui?: {
-		hidden?: boolean,
-	},
-}
-
-export type SourceRecordOptions = { 
-	doNotDeleteSourceRecordsFromDb?: boolean,
-	ui?: {
-		hideColumns?: boolean,
-	},
-}
+  unique?: { unique: boolean; indexName?: string };
+  /**
+   * The column in the reference table `table` is the primary key of the table (`id` unless otherwise specified in the Table definition)
+   *
+   * Note: use a migration to drop or change an existing foreign key
+   */
+  references?: { table: string };
+  nullable?: boolean;
+  /** Value stored on insert */
+  defaultValue?: (insertObj: any) => Promise<any>;
+  /** Value stored on update */
+  updateValue?: (updateObj: any) => Promise<any>;
+  /** Add conditions to query; called on every query of this table */
+  addToQuery?: (qb: QueryBuilder) => Promise<void>;
+  ui?: {
+    hidden?: boolean;
+  };
+};
+
+export type SourceRecordOptions = {
+  doNotDeleteSourceRecordsFromDb?: boolean;
+  ui?: {
+    hideColumns?: boolean;
+  };
+};

package/src/auth/TableAuth.ts

@@ -1,60 +1,70 @@
-import { UserAuth } from '@proteinjs/user-auth'
-import { Table } from '../Table'
+import { UserAuth } from '@proteinjs/user-auth';
+import { Table } from '../Table';
 
 /**
  * @public all users, including guests (do not need to be logged in), do not need any roles
  * @authenticated - users need to be logged in, do not need any roles
  * @roles string[] - authenticated users, having at least one of these roles
  */
-export type Identity = 'public'|'authenticated'|string[]
+export type Identity = 'public' | 'authenticated' | string[];
 
 /**
  * These Identities can perform these operations on this table.
  * If omitted, defaults to requiring the 'admin' role (default deny)
  */
 export type TableOperationsAuth = {
-	all?: Identity,
-	query?: Identity,
-	insert?: Identity,
-	update?: Identity,
-	delete?: Identity,
-}
+  all?: Identity;
+  query?: Identity;
+  insert?: Identity;
+  update?: Identity;
+  delete?: Identity;
+};
 
 /**
  * Util to check which table operations a user can perform
  */
 export class TableAuth {
-  private canAccess(table: Table<any>, api: 'db'|'service', operation: 'query'|'insert'|'update'|'delete'): boolean {
+  private canAccess(
+    table: Table<any>,
+    api: 'db' | 'service',
+    operation: 'query' | 'insert' | 'update' | 'delete'
+  ): boolean {
     const tableAuth = table.auth ? table.auth[api] : undefined;
-    if (!tableAuth || Object.keys(tableAuth).length == 0)
+    if (!tableAuth || Object.keys(tableAuth).length == 0) {
       return UserAuth.hasRole('admin');
+    }
 
-    return tableAuth.all === 'public' 
-      || tableAuth[operation] === 'public'
-      || (tableAuth.all === 'authenticated' && UserAuth.isLoggedIn())
-      || (tableAuth[operation] === 'authenticated' && UserAuth.isLoggedIn())
-      || (Array.isArray(tableAuth.all) && UserAuth.hasRoles(tableAuth.all, 'at least one'))
-      || (Array.isArray(tableAuth[operation]) && UserAuth.hasRoles(tableAuth[operation] as string[], 'at least one'))
-    ;
+    return (
+      tableAuth.all === 'public' ||
+      tableAuth[operation] === 'public' ||
+      (tableAuth.all === 'authenticated' && UserAuth.isLoggedIn()) ||
+      (tableAuth[operation] === 'authenticated' && UserAuth.isLoggedIn()) ||
+      (Array.isArray(tableAuth.all) && UserAuth.hasRoles(tableAuth.all, 'at least one')) ||
+      (Array.isArray(tableAuth[operation]) && UserAuth.hasRoles(tableAuth[operation] as string[], 'at least one'))
+    );
   }
 
-  canQuery(table: Table<any>, api: 'db'|'service' = 'db'): void {
-    if (!this.canAccess(table, api, 'query'))
+  canQuery(table: Table<any>, api: 'db' | 'service' = 'db'): void {
+    if (!this.canAccess(table, api, 'query')) {
       throw new Error(`User is not authorized to query table: ${table.name}`);
+    }
   }
 
-  canInsert(table: Table<any>, api: 'db'|'service' = 'db'): void {
-    if (!this.canAccess(table, api, 'insert'))
+  canInsert(table: Table<any>, api: 'db' | 'service' = 'db'): void {
+    if (!this.canAccess(table, api, 'insert')) {
       throw new Error(`User is not authorized to insert records into table: ${table.name}`);
+    }
   }
 
-  canUpdate(table: Table<any>, api: 'db'|'service' = 'db'): void {
-    if (!this.canAccess(table, api, 'update'))
+  canUpdate(table: Table<any>, api: 'db' | 'service' = 'db'): void {
+    if (!this.canAccess(table, api, 'update')) {
       throw new Error(`User is not authorized to update records in table: ${table.name}`);
+    }
   }
 
-  canDelete(table: Table<any>, api: 'db'|'service' = 'db'): void {
-    if (!this.canAccess(table, api, 'query'))
+  canDelete(table: Table<any>, api: 'db' | 'service' = 'db'): void {
+    if (!this.canAccess(table, api, 'query')) {
       throw new Error(`User is not authorized to delete records from table: ${table.name}`);
+    }
   }
-}
+}

package/src/auth/TableServiceAuth.ts

@@ -7,21 +7,23 @@ export class TableServiceAuth {
 
   canAccess(methodName: string, args: any[]): boolean {
     try {
-      const table: Table<any>|undefined = args[0];
-      if (!isTable(table))
+      const table: Table<any> | undefined = args[0];
+      if (!isTable(table)) {
         throw new Error(`[DbServiceAuth] Expected first arg to be a table`);
-      
+      }
+
       const tableAuth = new TableAuth();
-      if (methodName === 'get' || methodName == 'query' || methodName == 'getRowCount')
+      if (methodName === 'get' || methodName == 'query' || methodName == 'getRowCount') {
         tableAuth.canQuery(table as Table<any>, 'service');
-      else if (methodName === 'insert')
+      } else if (methodName === 'insert') {
         tableAuth.canInsert(table as Table<any>, 'service');
-      else if (methodName === 'update')
+      } else if (methodName === 'update') {
         tableAuth.canUpdate(table as Table<any>, 'service');
-      else if (methodName === 'delete')
+      } else if (methodName === 'delete') {
         tableAuth.canDelete(table as Table<any>, 'service');
-      else
+      } 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;
@@ -29,4 +31,4 @@ export class TableServiceAuth {
 
     return true;
   }
-}
+}

package/src/opt/moment.ts

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

package/src/reference/Reference.ts

@@ -6,12 +6,12 @@ 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 
+ * 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.
  */
@@ -21,14 +21,14 @@ export class Reference<T extends Record> implements CustomSerializableObject {
   constructor(
     public _table: string,
     public _id?: string,
-    public _object?: T,
+    public _object?: T
   ) {}
 
-  static fromObject<T extends Record>(table: string, object: T|(Partial<T> & { id: string })) {
+  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> {
+  async get(): Promise<T | undefined> {
     if (!this._object && this._id) {
       const table = tableByName(this._table);
       const db = getDb();
@@ -42,4 +42,4 @@ export class Reference<T extends Record> implements CustomSerializableObject {
     this._object = object;
     this._id = object.id;
   }
-}
+}

package/src/reference/ReferenceArray.ts

@@ -7,15 +7,15 @@ 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 
+ * 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.
  */
@@ -25,11 +25,11 @@ export class ReferenceArray<T extends Record> implements CustomSerializableObjec
   constructor(
     public _table: string,
     public _ids: string[],
-    public _objects?: T[],
+    public _objects?: T[]
   ) {}
 
-  static fromObjects<T extends Record>(table: string, objects: (T|(Partial<T> & { id: string }))[]) {
-    const ids = objects.map(object => object.id);
+  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[]);
   }
 
@@ -53,4 +53,4 @@ export class ReferenceArray<T extends Record> implements CustomSerializableObjec
   set(objects: T[]) {
     this._objects = objects;
   }
-}
+}

package/src/schema/SchemaMetadata.ts

@@ -6,113 +6,133 @@ export class SchemaMetadata {
   constructor(
     public dbDriver: DbDriver,
     private multiDbSupported = true
-  ){}
+  ) {}
 
   async tableExists(table: Table<any>): Promise<boolean> {
-		const qb = new QueryBuilder('TABLES')
+    const qb = new QueryBuilder('TABLES')
       .condition({ field: 'TABLE_SCHEMA', operator: '=', value: this.dbDriver.getDbName() })
-      .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;
-	}
+      .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;
+    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');
+
+  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)
+    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 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 results = await this.dbDriver.runQuery(generateStatement);
     const primaryKey: string[] = [];
-    for (const row of results)
+    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');
+
+  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 }} = {};
+    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'])
+      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 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 results = await this.dbDriver.runQuery(generateStatement);
     const uniqueColumns: string[] = [];
     for (const row of results) {
-      if (!(row['CONSTRAINT_NAME'] as string).endsWith('_unique'))
+      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[]}> {
+
+  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 }])
-    ;
+      .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 results: any[] = await this.dbDriver.runQuery(generateStatement);
     const indexes: { [keyName: string]: string[] } = {};
     for (const row of results) {
-      if (!indexes[row['INDEX_NAME']])
+      if (!indexes[row['INDEX_NAME']]) {
         indexes[row['INDEX_NAME']] = [];
-  
+      }
+
       indexes[row['INDEX_NAME']].push(row['COLUMN_NAME']);
     }
-  
+
     return indexes;
   }
-}
+}

package/src/schema/SchemaOperations.ts

@@ -7,7 +7,7 @@ export interface SchemaOperations {
 
 interface Index {
   name?: string;
-  columns: string|string[];
+  columns: string | string[];
   unique?: boolean;
 }
 
@@ -41,4 +41,4 @@ export interface TableChanges {
   columnsWithUniqueConstraintsToDrop: string[];
   indexesToCreate: Index[];
   indexesToDrop: Index[];
-}
+}