@proteinjs/db 1.0.15 → 1.0.17

package/src/Db.ts

@@ -12,191 +12,232 @@ import { TableManager } from './schema/TableManager';
 import { TableAuth } from './auth/TableAuth';
 import { TableServiceAuth } from './auth/TableServiceAuth';
 
-export const getDb = <R extends Record = Record>() => typeof self === 'undefined' ? new Db<R>() : getDbService() as Db<R>;
+export const getDb = <R extends Record = Record>() =>
+  typeof self === 'undefined' ? new Db<R>() : (getDbService() as Db<R>);
 export const getSystemDb = <R extends Record = Record>() => new Db<R>(undefined, undefined, true);
 
-export type DbDriverStatementConfig = ParameterizationConfig & { prefixTablesWithDb?: boolean }
+export type DbDriverStatementConfig = ParameterizationConfig & { prefixTablesWithDb?: boolean };
 
 export interface DefaultDbDriverFactory extends Loadable {
-    getDbDriver(): DbDriver;
+  getDbDriver(): DbDriver;
 }
 
 export interface DbDriver {
-    getDbName(): string;
-    createDbIfNotExists(): Promise<void>;
-    start?(): Promise<void>;
-    stop?(): Promise<void>;
-    getTableManager(): TableManager;
-    runQuery(generateStatement: (config: DbDriverStatementConfig) => Statement): Promise<SerializedRecord[]>;
-    runDml(generateStatement: (config: DbDriverStatementConfig) => Statement): Promise<number>; // returns the number of affected rows
+  getDbName(): string;
+  createDbIfNotExists(): Promise<void>;
+  start?(): Promise<void>;
+  stop?(): Promise<void>;
+  getTableManager(): TableManager;
+  runQuery(generateStatement: (config: DbDriverStatementConfig) => Statement): Promise<SerializedRecord[]>;
+  runDml(generateStatement: (config: DbDriverStatementConfig) => Statement): Promise<number>; // returns the number of affected rows
 }
 
 export class Db<R extends Record = Record> implements DbService<R> {
-    private static defaultDbDriver: DbDriver;
-    private dbDriver: DbDriver;
-    private logger = new Logger(this.constructor.name);
-    private statementConfigFactory: StatementConfigFactory;
-    private auth = new TableAuth();
-    public serviceMetadata: Service['serviceMetadata'] = {
-        auth: {
-            canAccess: (methodName, args) => new TableServiceAuth().canAccess(methodName, args),
-        },
-    };
-
-    constructor(
-        dbDriver?: DbDriver,
-        getTable?: (tableName: string) => Table<any>,
-        private ignoreAuth?: boolean
-    ) {
-        this.dbDriver = dbDriver ? dbDriver : this.getDefaultDbDriver();
-        this.statementConfigFactory = new StatementConfigFactory(this.dbDriver.getDbName(), getTable);
+  private static defaultDbDriver: DbDriver;
+  private dbDriver: DbDriver;
+  private logger = new Logger(this.constructor.name);
+  private statementConfigFactory: StatementConfigFactory;
+  private auth = new TableAuth();
+  public serviceMetadata: Service['serviceMetadata'] = {
+    auth: {
+      canAccess: (methodName, args) => new TableServiceAuth().canAccess(methodName, args),
+    },
+  };
+
+  constructor(
+    dbDriver?: DbDriver,
+    getTable?: (tableName: string) => Table<any>,
+    private ignoreAuth?: boolean
+  ) {
+    this.dbDriver = dbDriver ? dbDriver : this.getDefaultDbDriver();
+    this.statementConfigFactory = new StatementConfigFactory(this.dbDriver.getDbName(), getTable);
+  }
+
+  private getDefaultDbDriver(): DbDriver {
+    if (!Db.defaultDbDriver) {
+      const defaultDbDriverFactory = SourceRepository.get().object<DefaultDbDriverFactory>(
+        '@proteinjs/db/DefaultDbDriverFactory'
+      );
+      if (!defaultDbDriverFactory) {
+        throw new Error(
+          `Unable to find a @proteinjs/db/DefaultDbDriverFactory implementation. Either implement DefaultDbDriverFactory or pass in a db driver when instantiating Db.`
+        );
+      }
+
+      Db.defaultDbDriver = defaultDbDriverFactory.getDbDriver();
     }
 
-    private getDefaultDbDriver(): DbDriver {
-        if (!Db.defaultDbDriver) {
-            const defaultDbDriverFactory = SourceRepository.get().object<DefaultDbDriverFactory>('@proteinjs/db/DefaultDbDriverFactory');
-            if (!defaultDbDriverFactory)
-                throw new Error(`Unable to find a @proteinjs/db/DefaultDbDriverFactory implementation. Either implement DefaultDbDriverFactory or pass in a db driver when instantiating Db.`);
+    return Db.defaultDbDriver;
+  }
 
-            Db.defaultDbDriver = defaultDbDriverFactory.getDbDriver();
-        }
+  async init(): Promise<void> {
+    await this.dbDriver.createDbIfNotExists();
+    await this.dbDriver.getTableManager().loadTables();
+    await new SourceRecordLoader().load();
+  }
 
-        return Db.defaultDbDriver;
-    }
+  async tableExists<T extends R>(table: Table<T>): Promise<boolean> {
+    return await this.dbDriver.getTableManager().tableExists(table);
+  }
 
-    async init(): Promise<void> {
-        await this.dbDriver.createDbIfNotExists();
-        await this.dbDriver.getTableManager().loadTables();
-        await new SourceRecordLoader().load();
-    }
+  async get<T extends R>(table: Table<T>, query: Query<T>): Promise<T> {
+    return (await this.query(table, query))[0];
+  }
 
-    async tableExists<T extends R>(table: Table<T>): Promise<boolean> {
-        return await this.dbDriver.getTableManager().tableExists(table);
+  async insert<T extends R>(table: Table<T>, record: Omit<T, keyof R>): Promise<T> {
+    if (!this.ignoreAuth) {
+      this.auth.canInsert(table);
     }
 
-    async get<T extends R>(table: Table<T>, query: Query<T>): Promise<T> {
-        return (await this.query(table, query))[0];
+    const recordCopy = Object.assign({}, record);
+    await this.addDefaultFieldValues(table, recordCopy);
+    const recordSearializer = new RecordSerializer(table);
+    const serializedRecord = await recordSearializer.serialize(recordCopy);
+    const generateInsert = (config: DbDriverStatementConfig) =>
+      new StatementFactory<T>().insert(
+        table.name,
+        serializedRecord as Partial<T>,
+        this.statementConfigFactory.getStatementConfig(config)
+      );
+    await this.dbDriver.runDml(generateInsert);
+    return recordCopy as T;
+  }
+
+  private async addDefaultFieldValues<T extends R>(table: Table<T>, record: any) {
+    for (const columnPropertyName in table.columns) {
+      const column = (table.columns as any)[columnPropertyName] as Column<any, any>;
+      if (column.options?.defaultValue && typeof record[columnPropertyName] === 'undefined') {
+        record[columnPropertyName] = await column.options.defaultValue(record);
+      }
     }
+  }
 
-    async insert<T extends R>(table: Table<T>, record: Omit<T, keyof R>): Promise<T> {
-        if (!this.ignoreAuth)
-            this.auth.canInsert(table);
-
-        const recordCopy = Object.assign({}, record);
-        await this.addDefaultFieldValues(table, recordCopy);
-        const recordSearializer = new RecordSerializer(table);
-        const serializedRecord = await recordSearializer.serialize(recordCopy);
-        const generateInsert = (config: DbDriverStatementConfig) => new StatementFactory<T>().insert(table.name, serializedRecord as Partial<T>, this.statementConfigFactory.getStatementConfig(config));
-        await this.dbDriver.runDml(generateInsert);
-        return recordCopy as T;
+  async update<T extends R>(table: Table<T>, record: Partial<T>, query?: Query<T>): Promise<number> {
+    if (!this.ignoreAuth) {
+      this.auth.canUpdate(table);
     }
 
-    private async addDefaultFieldValues<T extends R>(table: Table<T>, record: any) {
-        for (let columnPropertyName in table.columns) {
-            const column = (table.columns as any)[columnPropertyName] as Column<any, any>;
-            if (column.options?.defaultValue && typeof record[columnPropertyName] === 'undefined')
-                record[columnPropertyName] = await column.options.defaultValue(record);
-        }
+    if (!query && !record.id) {
+      throw new Error(`Update must be called with either a QueryBuilder or a record with an id property`);
     }
 
-    async update<T extends R>(table: Table<T>, record: Partial<T>, query?: Query<T>): Promise<number> {
-        if (!this.ignoreAuth)
-            this.auth.canUpdate(table);
-
-        if (!query && !record.id)
-            throw new Error(`Update must be called with either a QueryBuilder or a record with an id property`);
-
-        const recordCopy = Object.assign({}, record);
-        await this.addUpdateFieldValues(table, recordCopy);
-        const recordSearializer = new RecordSerializer<T>(table);
-        const serializedRecord = await recordSearializer.serialize(recordCopy);
-        const qb = new QueryBuilderFactory().getQueryBuilder(table, query);
-        if (!query)
-            qb.condition({ field: 'id', operator: '=', value: recordCopy.id as T[keyof T] });
-            
-        delete serializedRecord['id'];
-        const generateUpdate = (config: DbDriverStatementConfig) => new StatementFactory<T>().update(table.name, serializedRecord as Partial<T>, qb, this.statementConfigFactory.getStatementConfig(config));
-        return await this.dbDriver.runDml(generateUpdate);
+    const recordCopy = Object.assign({}, record);
+    await this.addUpdateFieldValues(table, recordCopy);
+    const recordSearializer = new RecordSerializer<T>(table);
+    const serializedRecord = await recordSearializer.serialize(recordCopy);
+    const qb = new QueryBuilderFactory().getQueryBuilder(table, query);
+    if (!query) {
+      qb.condition({ field: 'id', operator: '=', value: recordCopy.id as T[keyof T] });
     }
 
-    private async addUpdateFieldValues<T extends R>(table: Table<T>, record: any) {
-        for (let columnPropertyName in table.columns) {
-            const column = (table.columns as any)[columnPropertyName] as Column<any, any>;
-            if (column.options?.updateValue)
-                record[columnPropertyName] = await column.options.updateValue(record);
-        }
+    delete serializedRecord['id'];
+    const generateUpdate = (config: DbDriverStatementConfig) =>
+      new StatementFactory<T>().update(
+        table.name,
+        serializedRecord as Partial<T>,
+        qb,
+        this.statementConfigFactory.getStatementConfig(config)
+      );
+    return await this.dbDriver.runDml(generateUpdate);
+  }
+
+  private async addUpdateFieldValues<T extends R>(table: Table<T>, record: any) {
+    for (const columnPropertyName in table.columns) {
+      const column = (table.columns as any)[columnPropertyName] as Column<any, any>;
+      if (column.options?.updateValue) {
+        record[columnPropertyName] = await column.options.updateValue(record);
+      }
     }
+  }
 
-    async delete<T extends R>(table: Table<T>, query: Query<T>): Promise<number> {
-        if (!this.ignoreAuth)
-            this.auth.canDelete(table);
-        
-        const recordsToDelete = await this.query(table, query);
-        if (recordsToDelete.length == 0)
-            return 0;
-
-        const recordsToDeleteIds = recordsToDelete.map(record => record.id);
-        const deleteQb = new QueryBuilderFactory().getQueryBuilder(table);
-        deleteQb.condition({ field: 'id', operator: 'IN', value: recordsToDeleteIds as T[keyof T][] });
-        const generateDelete = (config: DbDriverStatementConfig) => new StatementFactory<T>().delete(table.name, deleteQb, this.statementConfigFactory.getStatementConfig(config));
-        await this.beforeDelete(table, recordsToDelete);
-        const deletedRowCount = await this.dbDriver.runDml(generateDelete);
-        await this.cascadeDeletions(table, recordsToDeleteIds);
-        return deletedRowCount;
+  async delete<T extends R>(table: Table<T>, query: Query<T>): Promise<number> {
+    if (!this.ignoreAuth) {
+      this.auth.canDelete(table);
     }
 
-    private async beforeDelete(table: Table<any>, recordsToDelete: Record[]) {
-        for (let columnPropertyName in table.columns) {
-            const column = (table.columns as any)[columnPropertyName] as Column<any, any>;
-            if (typeof column.beforeDelete !== 'undefined')
-                await column.beforeDelete(table, columnPropertyName, recordsToDelete);
-        }
+    const recordsToDelete = await this.query(table, query);
+    if (recordsToDelete.length == 0) {
+      return 0;
     }
 
-    private async cascadeDeletions(table: Table<any>, deletedRecordIds: string[]) {
-        if (table.cascadeDeleteReferences().length < 1)
-            return;
-
-        for (let cascadeDeleteReference of table.cascadeDeleteReferences()) {
-            const referenceTable = tableByName(cascadeDeleteReference.table);
-            const referenceColumnPropertyName = getColumnPropertyName(referenceTable, cascadeDeleteReference.referenceColumn);
-            this.logger.info(`Executing cascade delete for table: ${table.name}, referenceTable: ${referenceTable.name}, referenceColumnPropertyName: ${referenceColumnPropertyName}, deletedRecordIds: ${JSON.stringify(deletedRecordIds)}`);
-            const cascadeDeleteQb = new QueryBuilderFactory().getQueryBuilder(referenceTable);
-            cascadeDeleteQb.condition({ field: referenceColumnPropertyName as string, operator: 'IN', value: deletedRecordIds });
-            const deleteCount = await this.delete(referenceTable, cascadeDeleteQb);
-            this.logger.info(`Cascade deleted ${deleteCount} record${deleteCount == 1 ? '' : 's'}`);
-        }
+    const recordsToDeleteIds = recordsToDelete.map((record) => record.id);
+    const deleteQb = new QueryBuilderFactory().getQueryBuilder(table);
+    deleteQb.condition({ field: 'id', operator: 'IN', value: recordsToDeleteIds as T[keyof T][] });
+    const generateDelete = (config: DbDriverStatementConfig) =>
+      new StatementFactory<T>().delete(table.name, deleteQb, this.statementConfigFactory.getStatementConfig(config));
+    await this.beforeDelete(table, recordsToDelete);
+    const deletedRowCount = await this.dbDriver.runDml(generateDelete);
+    await this.cascadeDeletions(table, recordsToDeleteIds);
+    return deletedRowCount;
+  }
+
+  private async beforeDelete(table: Table<any>, recordsToDelete: Record[]) {
+    for (const columnPropertyName in table.columns) {
+      const column = (table.columns as any)[columnPropertyName] as Column<any, any>;
+      if (typeof column.beforeDelete !== 'undefined') {
+        await column.beforeDelete(table, columnPropertyName, recordsToDelete);
+      }
     }
+  }
 
-    async query<T extends R>(table: Table<T>, query: Query<T>): Promise<T[]> {
-        if (!this.ignoreAuth)
-            this.auth.canQuery(table);
+  private async cascadeDeletions(table: Table<any>, deletedRecordIds: string[]) {
+    if (table.cascadeDeleteReferences().length < 1) {
+      return;
+    }
 
-        const qb = new QueryBuilderFactory().getQueryBuilder(table, query);
-        this.addColumnQueries(table, qb);
-        const generateQuery = (config: DbDriverStatementConfig) => qb.toSql(this.statementConfigFactory.getStatementConfig(config));
-        const serializedRecords = await this.dbDriver.runQuery(generateQuery);
-        const recordSearializer = new RecordSerializer(table);
-        return await Promise.all(serializedRecords.map(async (serializedRecord) => recordSearializer.deserialize(serializedRecord)));
+    for (const cascadeDeleteReference of table.cascadeDeleteReferences()) {
+      const referenceTable = tableByName(cascadeDeleteReference.table);
+      const referenceColumnPropertyName = getColumnPropertyName(referenceTable, cascadeDeleteReference.referenceColumn);
+      this.logger.info(
+        `Executing cascade delete for table: ${table.name}, referenceTable: ${referenceTable.name}, referenceColumnPropertyName: ${referenceColumnPropertyName}, deletedRecordIds: ${JSON.stringify(deletedRecordIds)}`
+      );
+      const cascadeDeleteQb = new QueryBuilderFactory().getQueryBuilder(referenceTable);
+      cascadeDeleteQb.condition({
+        field: referenceColumnPropertyName as string,
+        operator: 'IN',
+        value: deletedRecordIds,
+      });
+      const deleteCount = await this.delete(referenceTable, cascadeDeleteQb);
+      this.logger.info(`Cascade deleted ${deleteCount} record${deleteCount == 1 ? '' : 's'}`);
     }
+  }
 
-    async getRowCount<T extends R>(table: Table<T>, query?: Query<T>): Promise<number> {
-        if (!this.ignoreAuth)
-            this.auth.canQuery(table);
+  async query<T extends R>(table: Table<T>, query: Query<T>): Promise<T[]> {
+    if (!this.ignoreAuth) {
+      this.auth.canQuery(table);
+    }
 
-        const qb = new QueryBuilderFactory().getQueryBuilder(table, query);
-        qb.aggregate({ function: 'COUNT', resultProp: 'count' });
-        this.addColumnQueries(table, qb);
-        const generateQuery = (config: DbDriverStatementConfig) => qb.toSql(this.statementConfigFactory.getStatementConfig(config));
-        const result = await this.dbDriver.runQuery(generateQuery);
-        return result[0]['count'];
+    const qb = new QueryBuilderFactory().getQueryBuilder(table, query);
+    this.addColumnQueries(table, qb);
+    const generateQuery = (config: DbDriverStatementConfig) =>
+      qb.toSql(this.statementConfigFactory.getStatementConfig(config));
+    const serializedRecords = await this.dbDriver.runQuery(generateQuery);
+    const recordSearializer = new RecordSerializer(table);
+    return await Promise.all(
+      serializedRecords.map(async (serializedRecord) => recordSearializer.deserialize(serializedRecord))
+    );
+  }
+
+  async getRowCount<T extends R>(table: Table<T>, query?: Query<T>): Promise<number> {
+    if (!this.ignoreAuth) {
+      this.auth.canQuery(table);
     }
 
-    private async addColumnQueries<T extends R>(table: Table<T>, qb: QueryBuilder<T>) {
-        for (let columnPropertyName in table.columns) {
-            const column = (table.columns as any)[columnPropertyName] as Column<any, any>;
-            if (column.options?.addToQuery)
-                column.options.addToQuery(qb);
-        }
+    const qb = new QueryBuilderFactory().getQueryBuilder(table, query);
+    qb.aggregate({ function: 'COUNT', resultProp: 'count' });
+    this.addColumnQueries(table, qb);
+    const generateQuery = (config: DbDriverStatementConfig) =>
+      qb.toSql(this.statementConfigFactory.getStatementConfig(config));
+    const result = await this.dbDriver.runQuery(generateQuery);
+    return result[0]['count'];
+  }
+
+  private async addColumnQueries<T extends R>(table: Table<T>, qb: QueryBuilder<T>) {
+    for (const columnPropertyName in table.columns) {
+      const column = (table.columns as any)[columnPropertyName] as Column<any, any>;
+      if (column.options?.addToQuery) {
+        column.options.addToQuery(qb);
+      }
     }
-}
+  }
+}

package/src/MigrationRunner.ts

@@ -7,7 +7,8 @@ import { Migration, MigrationTable } from './tables/MigrationTable';
 import { Service } from '@proteinjs/service';
 import { Logger } from '@proteinjs/util';
 
-export const getMigrationRunner = () => typeof self === 'undefined' ? new MigrationRunner() : getMigrationRunnerService() as MigrationRunner;
+export const getMigrationRunner = () =>
+  typeof self === 'undefined' ? new MigrationRunner() : (getMigrationRunnerService() as MigrationRunner);
 
 export class MigrationRunner implements MigrationRunnerService {
   private logger = new Logger(this.constructor.name);
@@ -18,8 +19,9 @@ export class MigrationRunner implements MigrationRunnerService {
   async runMigration(id: string): Promise<void> {
     const migrationTable: Table<Migration> = new MigrationTable();
     const migration = new SourceRecordRepo().getSourceRecord<Migration>(migrationTable.name, id);
-    if (!migration)
+    if (!migration) {
       throw new Error(`Unable to find migration source record for id: ${id}`);
+    }
 
     const db = getDb();
     migration.status = 'running';
@@ -38,12 +40,14 @@ export class MigrationRunner implements MigrationRunnerService {
     }
     migration.duration = this.duration(migration.startTime, migration.endTime);
     await db.update(migrationTable, migration);
-    this.logger.info(`[${migration.status}] (${migration.duration}) Finished running migration (${migration.id}) ${migration.description}`);
+    this.logger.info(
+      `[${migration.status}] (${migration.duration}) Finished running migration (${migration.id}) ${migration.description}`
+    );
   }
 
   private duration(start: Moment, end: Moment): string {
     const duration = moment.duration(end.diff(start));
-    let parts: string[] = [];
+    const parts: string[] = [];
 
     const days = duration.days();
     const hours = duration.hours();
@@ -51,12 +55,22 @@ export class MigrationRunner implements MigrationRunnerService {
     const seconds = duration.seconds();
     const milliseconds = duration.milliseconds();
 
-    if (days > 0) parts.push(`${days} day${days > 1 ? 's' : ''}`);
-    if (hours > 0) parts.push(`${hours} hour${hours > 1 ? 's' : ''}`);
-    if (minutes > 0) parts.push(`${minutes} min${minutes > 1 ? 's' : ''}`);
-    if (seconds > 0) parts.push(`${seconds} sec${seconds > 1 ? 's' : ''}`);
-    if (days == 0 && hours == 0 && minutes == 0 && seconds == 0) parts.push(`${milliseconds} ms`);
+    if (days > 0) {
+      parts.push(`${days} day${days > 1 ? 's' : ''}`);
+    }
+    if (hours > 0) {
+      parts.push(`${hours} hour${hours > 1 ? 's' : ''}`);
+    }
+    if (minutes > 0) {
+      parts.push(`${minutes} min${minutes > 1 ? 's' : ''}`);
+    }
+    if (seconds > 0) {
+      parts.push(`${seconds} sec${seconds > 1 ? 's' : ''}`);
+    }
+    if (days == 0 && hours == 0 && minutes == 0 && seconds == 0) {
+      parts.push(`${milliseconds} ms`);
+    }
 
     return parts.join(' ');
   }
-}
+}

package/src/QueryBuilderFactory.ts

@@ -6,14 +6,11 @@ import { QueryBuilder } from '@proteinjs/db-query';
 
 export class QueryBuilderFactory {
   getQueryBuilder<T extends Record>(table: Table<T>, query?: Query<T>): QueryBuilder<T> {
-    const qb = query ? 
-      isInstanceOf(query, QueryBuilder) ? 
-        query as QueryBuilder<T>
-        :
-        QueryBuilder.fromObject<T>(query as T, table.name)
-      :
-      new QueryBuilder<T>(table.name)
-    ;
+    const qb = query
+      ? isInstanceOf(query, QueryBuilder)
+        ? (query as QueryBuilder<T>)
+        : QueryBuilder.fromObject<T>(query as T, table.name)
+      : new QueryBuilder<T>(table.name);
     return qb;
   }
-}
+}

package/src/Record.ts

@@ -3,50 +3,53 @@ import { Column, Table, Columns } from './Table';
 import { moment } from './opt/moment';
 
 export interface Record {
-	id: string;
-	created: moment.Moment;
-	updated: moment.Moment;
+  id: string;
+  created: moment.Moment;
+  updated: moment.Moment;
 }
 
 const recordColumns: Columns<Record> = {
   id: new UuidColumn('id', { ui: { hidden: true } }),
-  created: new DateTimeColumn('created', { 
+  created: new DateTimeColumn('created', {
     defaultValue: async () => moment(),
   }),
-  updated: new DateTimeColumn('updated', { 
-    defaultValue: async () => moment(), 
+  updated: new DateTimeColumn('updated', {
+    defaultValue: async () => moment(),
     updateValue: async () => moment(),
   }),
-}
+};
 
 /**
  * Wrapper function to add default Record columns to your table's columns (should always use).
- * 
+ *
  * 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
  * @returns recordColumns & your columns
  */
-export function withRecordColumns<T extends Record>(columns: Columns<Omit<T, keyof Record>>): Columns<Record> & Columns<Omit<T, keyof Record>> {
+export function withRecordColumns<T extends Record>(
+  columns: Columns<Omit<T, keyof Record>>
+): Columns<Record> & Columns<Omit<T, keyof Record>> {
   return Object.assign(Object.assign({}, recordColumns), columns);
 }
 
-export type SerializedRecord = { [columnName: string]: any }
+export type SerializedRecord = { [columnName: string]: any };
 
 export class RecordSerializer<T extends Record> {
   private table: Table<T>;
-  
-	constructor(table: Table<T>) {
+
+  constructor(table: Table<T>) {
     this.table = table;
   }
 
   async serialize(record: any): Promise<SerializedRecord> {
     const serialized: any = {};
     const fieldSerializer = new FieldSerializer(this.table);
-    for (let fieldPropertyName in record) {
-      if (typeof record[fieldPropertyName] === 'function')
+    for (const fieldPropertyName in record) {
+      if (typeof record[fieldPropertyName] === 'function') {
         continue;
-      
+      }
+
       const fieldValue = await record[fieldPropertyName];
       const { columnName, serializedFieldValue } = await fieldSerializer.serialize(fieldPropertyName, fieldValue);
       serialized[columnName] = serializedFieldValue;
@@ -57,7 +60,7 @@ export class RecordSerializer<T extends Record> {
   async deserialize(serializedRecord: SerializedRecord): Promise<T> {
     const deserialized: any = {};
     const fieldSerializer = new FieldSerializer(this.table);
-    for (let columnName in serializedRecord) {
+    for (const columnName in serializedRecord) {
       const serializedFieldValue = serializedRecord[columnName];
       const { fieldPropertyName, fieldValue } = await fieldSerializer.deserialize(columnName, serializedFieldValue);
       deserialized[fieldPropertyName] = fieldValue;
@@ -67,29 +70,31 @@ export class RecordSerializer<T extends Record> {
 }
 
 export class FieldSerializer<T extends Record> {
-  constructor(
-    private table: Table<T>
-  ){}
+  constructor(private table: Table<T>) {}
 
   async serialize(fieldPropertyName: string, fieldValue: any) {
-    const columns: {[prop: string]: Column<any, any>} = this.table.columns;
+    const columns: { [prop: string]: Column<any, any> } = this.table.columns;
     const column = columns[fieldPropertyName];
-    if (!column)
-      throw new Error(`[FieldSerializer.serialize] (${this.table.name}) no column matches fieldPropertyName: ${fieldPropertyName}`);
+    if (!column) {
+      throw new Error(
+        `[FieldSerializer.serialize] (${this.table.name}) no column matches fieldPropertyName: ${fieldPropertyName}`
+      );
+    }
 
     let serializedFieldValue = fieldValue;
-    if (column.serialize)
+    if (column.serialize) {
       serializedFieldValue = await column.serialize(fieldValue);
+    }
 
     return { columnName: column.name, serializedFieldValue };
   }
 
   async deserialize(columnName: string, serializedFieldValue: any) {
-    const columns: {[prop: string]: Column<any, any>} = this.table.columns;
+    const columns: { [prop: string]: Column<any, any> } = this.table.columns;
     let fieldPropertyName = columnName;
     let column = columns[columnName]; // the scenario that the column name is the same as the property name
     if (!column) {
-      for (let columnPropertyName in columns) {
+      for (const columnPropertyName in columns) {
         const checkColumn = (this.table.columns as any)[columnPropertyName];
         if (checkColumn && columnName == checkColumn.name) {
           fieldPropertyName = columnPropertyName;
@@ -104,10 +109,11 @@ export class FieldSerializer<T extends Record> {
       return { fieldPropertyName, fieldValue: undefined };
     }
 
-    let fieldValue = serializedFieldValue
-    if (column.deserialize)
+    let fieldValue = serializedFieldValue;
+    if (column.deserialize) {
       fieldValue = await column.deserialize(serializedFieldValue);
+    }
 
     return { fieldPropertyName, fieldValue };
   }
-}
+}

package/src/StatementConfigFactory.ts

@@ -6,31 +6,29 @@ export class StatementConfigFactory {
   private dbName: string;
   private getTable: (tableName: string) => Table<any>;
 
-  constructor(
-    dbName: string,
-    getTable?: (tableName: string) => Table<any>
-  ) {
+  constructor(dbName: string, getTable?: (tableName: string) => Table<any>) {
     this.dbName = dbName;
     this.getTable = getTable ? getTable : tableByName;
   }
 
   getStatementConfig(config: DbDriverStatementConfig): StatementConfig {
     return {
-        dbName: config.prefixTablesWithDb ? this.dbName : undefined,
-        resolveFieldName: this.getResolveFieldName(),
-        useParams: config.useParams,
-        useNamedParams: config.useNamedParams
+      dbName: config.prefixTablesWithDb ? this.dbName : undefined,
+      resolveFieldName: this.getResolveFieldName(),
+      useParams: config.useParams,
+      useNamedParams: config.useNamedParams,
     };
   }
 
   private getResolveFieldName() {
-      return (tableName: string, propertyName: string): string => {
-        const table = this.getTable(tableName);
-        const column = table.columns[propertyName];
-        if (!column)
-          throw new Error(`(${table.name}) Column does not exist for property: ${propertyName}`);
-
-        return column.name;
+    return (tableName: string, propertyName: string): string => {
+      const table = this.getTable(tableName);
+      const column = table.columns[propertyName];
+      if (!column) {
+        throw new Error(`(${table.name}) Column does not exist for property: ${propertyName}`);
       }
+
+      return column.name;
+    };
   }
-}
+}