@proteinjs/db-driver-spanner 1.1.1 → 1.1.3

package/src/SpannerDriver.ts

@@ -8,111 +8,129 @@ import { SpannerColumnTypeFactory } from './SpannerColumnTypeFactory';
 import { SpannerSchemaMetadata } from './SpannerSchemaMetadata';
 
 export class SpannerDriver implements DbDriver {
-	private static SPANNER: Spanner;
-	private static SPANNER_INSTANCE: Instance;
-	private static SPANNER_DB: Database;
-	private logger = new Logger(this.constructor.name);
-	private config: SpannerConfig;
-
-	constructor(config: SpannerConfig) {
-		this.config = config;
-	}
-
-	private getSpanner(): Spanner {
-		if (!SpannerDriver.SPANNER) {
-			if (this.config.spannerOptions)
-				SpannerDriver.SPANNER = new Spanner(Object.assign({ projectId: this.config.projectId }, this.config.spannerOptions));
-			else
-				SpannerDriver.SPANNER = new Spanner({ projectId: this.config.projectId });
-		}
-
-		return SpannerDriver.SPANNER;
-	}
-
-	private getSpannerInstance(): Instance {
-		if (!SpannerDriver.SPANNER_INSTANCE)
-			SpannerDriver.SPANNER_INSTANCE = this.getSpanner().instance(this.config.instanceName);
-
-		return SpannerDriver.SPANNER_INSTANCE;
-	}
-
-	private getSpannerDb(): Database {
-		if (!SpannerDriver.SPANNER_DB)
-			SpannerDriver.SPANNER_DB = this.getSpannerInstance().database(this.config.databaseName);
-
-		return SpannerDriver.SPANNER_DB;
-	}
-
-	getDbName() {
-		return this.config.databaseName;
-	}
-
-	getTableManager(): TableManager {
-		const columnTypeFactory = new SpannerColumnTypeFactory();
-		const schemaOperations = new SpannerSchemaOperations(this);
-		const schemaMetadata = new SpannerSchemaMetadata(this, false);
-		return new TableManager(this, columnTypeFactory, schemaOperations, schemaMetadata);
-	}
-
-	async createDbIfNotExists(): Promise<void> {
-		if (await this.dbExists(this.getDbName()))
-			return;
-
-		await this.getSpannerInstance().createDatabase(this.getDbName());
-	}
-
-	private async dbExists(databaseName: string): Promise<boolean> {
-		const [exists] = await this.getSpannerInstance().database(databaseName).exists();
-		return exists;
-	}
-
-	async runQuery(generateStatement: (config: DbDriverStatementConfig) => Statement): Promise<any[]> {
-		const { sql, namedParams } = generateStatement({ useParams: true, useNamedParams: true, prefixTablesWithDb: false });
-		try {
-			this.logger.debug(`Executing query: ${sql}`);
-			const [rows] = await this.getSpannerDb().run({ sql, params: namedParams?.params });
-			return rows.map(row => row.toJSON());
-			// return JSON.parse(JSON.stringify((await this.getSpannerDb().run({ sql, params: namedParams?.params }))[0]));
-		} catch(error: any) {
-			this.logger.error(`Failed when executing query: ${sql}\nreason: ${error.details}`);
-			throw error;
-		}
-	}
-
-	/**
-	 * Execute a write operation.
-	 * 
-	 * @returns number of affected rows
-	 */
-	async runDml(generateStatement: (config: DbDriverStatementConfig) => Statement): Promise<number> {
-		const { sql, namedParams } = generateStatement({ useParams: true, useNamedParams: true, prefixTablesWithDb: false });
-		try {
-			return await this.getSpannerDb().runTransactionAsync(async (transaction) => {
-				this.logger.debug(`Executing dml: ${sql}`);
-				const [rowCount] = await transaction.runUpdate({
-					sql,
-					params: namedParams?.params,
-				});
-				await transaction.commit();
-				return rowCount;
-			});
-		} catch(error: any) {
-			this.logger.error(`Failed when executing dml: ${sql}\nreason: ${error.details}`);
-			throw error;
-		}
-	}
-
-	/**
-	 * Execute a schema write operation.
-	 */
-	async runUpdateSchema(sql: string): Promise<void> {
-		try {
-			this.logger.debug(`Executing schema update: ${sql}`)
-			const [operation] = await this.getSpannerDb().updateSchema(sql);
+  private static SPANNER: Spanner;
+  private static SPANNER_INSTANCE: Instance;
+  private static SPANNER_DB: Database;
+  private logger = new Logger(this.constructor.name);
+  private config: SpannerConfig;
+
+  constructor(config: SpannerConfig) {
+    this.config = config;
+  }
+
+  private getSpanner(): Spanner {
+    if (!SpannerDriver.SPANNER) {
+      if (this.config.spannerOptions) {
+        SpannerDriver.SPANNER = new Spanner(
+          Object.assign({ projectId: this.config.projectId }, this.config.spannerOptions)
+        );
+      } else {
+        SpannerDriver.SPANNER = new Spanner({ projectId: this.config.projectId });
+      }
+    }
+
+    return SpannerDriver.SPANNER;
+  }
+
+  private getSpannerInstance(): Instance {
+    if (!SpannerDriver.SPANNER_INSTANCE) {
+      SpannerDriver.SPANNER_INSTANCE = this.getSpanner().instance(this.config.instanceName);
+    }
+
+    return SpannerDriver.SPANNER_INSTANCE;
+  }
+
+  private getSpannerDb(): Database {
+    if (!SpannerDriver.SPANNER_DB) {
+      SpannerDriver.SPANNER_DB = this.getSpannerInstance().database(this.config.databaseName);
+    }
+
+    return SpannerDriver.SPANNER_DB;
+  }
+
+  getDbName() {
+    return this.config.databaseName;
+  }
+
+  getTableManager(): TableManager {
+    const columnTypeFactory = new SpannerColumnTypeFactory();
+    const schemaOperations = new SpannerSchemaOperations(this);
+    const schemaMetadata = new SpannerSchemaMetadata(this, false);
+    return new TableManager(this, columnTypeFactory, schemaOperations, schemaMetadata);
+  }
+
+  async createDbIfNotExists(): Promise<void> {
+    if (await this.dbExists(this.getDbName())) {
+      return;
+    }
+
+    await this.getSpannerInstance().createDatabase(this.getDbName());
+  }
+
+  private async dbExists(databaseName: string): Promise<boolean> {
+    const [exists] = await this.getSpannerInstance().database(databaseName).exists();
+    return exists;
+  }
+
+  async runQuery(generateStatement: (config: DbDriverStatementConfig) => Statement): Promise<any[]> {
+    const { sql, namedParams } = generateStatement({
+      useParams: true,
+      useNamedParams: true,
+      prefixTablesWithDb: false,
+    });
+    try {
+      this.logger.debug(`Executing query: ${sql}`);
+      const [rows] = await this.getSpannerDb().run({ sql, params: namedParams?.params });
+      return rows.map((row) => row.toJSON());
+      // return JSON.parse(JSON.stringify((await this.getSpannerDb().run({ sql, params: namedParams?.params }))[0]));
+    } catch (error: any) {
+      this.logger.error(
+        `Failed when executing query: ${sql}\nparams: ${JSON.stringify(namedParams, null, 2)}\nreason: ${error.details}`
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Execute a write operation.
+   *
+   * @returns number of affected rows
+   */
+  async runDml(generateStatement: (config: DbDriverStatementConfig) => Statement): Promise<number> {
+    const { sql, namedParams } = generateStatement({
+      useParams: true,
+      useNamedParams: true,
+      prefixTablesWithDb: false,
+    });
+    try {
+      return await this.getSpannerDb().runTransactionAsync(async (transaction) => {
+        this.logger.debug(`Executing dml: ${sql}`);
+        const [rowCount] = await transaction.runUpdate({
+          sql,
+          params: namedParams?.params,
+        });
+        await transaction.commit();
+        return rowCount;
+      });
+    } catch (error: any) {
+      this.logger.error(
+        `Failed when executing dml: ${sql}\nparams: ${JSON.stringify(namedParams, null, 2)}\nreason: ${error.details}`
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Execute a schema write operation.
+   */
+  async runUpdateSchema(sql: string): Promise<void> {
+    try {
+      this.logger.debug(`Executing schema update: ${sql}`);
+      const [operation] = await this.getSpannerDb().updateSchema(sql);
       await operation.promise();
-		} catch(error: any) {
-			this.logger.error(`Failed when executing schema update: ${sql}\nreason: ${error.details}`);
-			throw error;
-		}
-	}
-}
+    } catch (error: any) {
+      this.logger.error(`Failed when executing schema update: ${sql}\nreason: ${error.details}`);
+      throw error;
+    }
+  }
+}

package/src/SpannerSchemaMetadata.ts

@@ -2,58 +2,80 @@ import { ParameterizationConfig, QueryBuilder, SchemaMetadata, Table } from '@pr
 
 export class SpannerSchemaMetadata extends SchemaMetadata {
   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 getColumnMetadata(table: Table<any>): Promise<{[columnName: string]: { type: string, isNullable: boolean }}> {
-    const qb = QueryBuilder.fromObject({
-      'TABLE_NAME': table.name
-    }, 'COLUMNS');
+    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);
-    const columnMetadata: {[columnName: string]: { type: string, isNullable: boolean }} = {};
-    for (const row of results)
+    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_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['SPANNER_TYPE'], isNullable: row['IS_NULLABLE'] === 'YES' };
-  
+    }
+
     return columnMetadata;
   }
 
   async getPrimaryKey(table: Table<any>): Promise<string[]> {
-		const indexes = await this.getIndexes(table);
+    const indexes = await this.getIndexes(table);
     return indexes['PRIMARY_KEY'];
   }
 
-  async getForeignKeys(table: Table<any>): Promise<{[columnName: string]: { referencedTableName: string, referencedColumnName: string }}> {
-    const tableConstraintsQb = QueryBuilder.fromObject({
-      'TABLE_NAME': table.name,
-      'CONSTRAINT_TYPE': 'FOREIGN KEY'
-    }, 'TABLE_CONSTRAINTS');
-    const generateTableConstraintsStatement = (config: ParameterizationConfig) => tableConstraintsQb.toSql({ dbName: 'INFORMATION_SCHEMA', ...config });
-		const tableConstraints = await this.dbDriver.runQuery(generateTableConstraintsStatement);
-    const foreignKeys: {[columnName: string]: { referencedTableName: string, referencedColumnName: string }} = {};
+  async getForeignKeys(
+    table: Table<any>
+  ): Promise<{ [columnName: string]: { referencedTableName: string; referencedColumnName: string } }> {
+    const tableConstraintsQb = QueryBuilder.fromObject(
+      {
+        TABLE_NAME: table.name,
+        CONSTRAINT_TYPE: 'FOREIGN KEY',
+      },
+      'TABLE_CONSTRAINTS'
+    );
+    const generateTableConstraintsStatement = (config: ParameterizationConfig) =>
+      tableConstraintsQb.toSql({ dbName: 'INFORMATION_SCHEMA', ...config });
+    const tableConstraints = await this.dbDriver.runQuery(generateTableConstraintsStatement);
+    const foreignKeys: { [columnName: string]: { referencedTableName: string; referencedColumnName: string } } = {};
     for (const tableConstraint of tableConstraints) {
-      const referentialConstraintsQb = QueryBuilder.fromObject({
-        'CONSTRAINT_NAME': tableConstraint['CONSTRAINT_NAME']
-      }, 'REFERENTIAL_CONSTRAINTS');
-      const generateReferentialConstraintsStatement = (config: ParameterizationConfig) => referentialConstraintsQb.toSql({ dbName: 'INFORMATION_SCHEMA', ...config });
+      const referentialConstraintsQb = QueryBuilder.fromObject(
+        {
+          CONSTRAINT_NAME: tableConstraint['CONSTRAINT_NAME'],
+        },
+        'REFERENTIAL_CONSTRAINTS'
+      );
+      const generateReferentialConstraintsStatement = (config: ParameterizationConfig) =>
+        referentialConstraintsQb.toSql({ dbName: 'INFORMATION_SCHEMA', ...config });
       const referentialConstraints = await this.dbDriver.runQuery(generateReferentialConstraintsStatement);
       const referencedTableConstraintName = referentialConstraints[0]['UNIQUE_CONSTRAINT_NAME'];
-      
-      const referenceTableConstraintsQb = QueryBuilder.fromObject({
-        'CONSTRAINT_NAME': referencedTableConstraintName
-      }, 'TABLE_CONSTRAINTS');
-      const generateReferenceTableConstraintsStatement = (config: ParameterizationConfig) => referenceTableConstraintsQb.toSql({ dbName: 'INFORMATION_SCHEMA', ...config });
+
+      const referenceTableConstraintsQb = QueryBuilder.fromObject(
+        {
+          CONSTRAINT_NAME: referencedTableConstraintName,
+        },
+        'TABLE_CONSTRAINTS'
+      );
+      const generateReferenceTableConstraintsStatement = (config: ParameterizationConfig) =>
+        referenceTableConstraintsQb.toSql({ dbName: 'INFORMATION_SCHEMA', ...config });
       const referenceTableConstraints = await this.dbDriver.runQuery(generateReferenceTableConstraintsStatement);
       const referencedTableName = referenceTableConstraints[0]['TABLE_NAME'];
 
-      const keyColumnUsageQb = QueryBuilder.fromObject({
-        'TABLE_NAME': table.name,
-        'CONSTRAINT_NAME': tableConstraint['CONSTRAINT_NAME']
-      }, 'KEY_COLUMN_USAGE');
-      const generateKeyColumnUsageStatement = (config: ParameterizationConfig) => keyColumnUsageQb.toSql({ dbName: 'INFORMATION_SCHEMA', ...config });
+      const keyColumnUsageQb = QueryBuilder.fromObject(
+        {
+          TABLE_NAME: table.name,
+          CONSTRAINT_NAME: tableConstraint['CONSTRAINT_NAME'],
+        },
+        'KEY_COLUMN_USAGE'
+      );
+      const generateKeyColumnUsageStatement = (config: ParameterizationConfig) =>
+        keyColumnUsageQb.toSql({ dbName: 'INFORMATION_SCHEMA', ...config });
       const keyColumnUsages = await this.dbDriver.runQuery(generateKeyColumnUsageStatement);
       const referencingColumnName = keyColumnUsages[0]['COLUMN_NAME'];
 
@@ -62,7 +84,7 @@ export class SpannerSchemaMetadata extends SchemaMetadata {
         referencedColumnName: 'id',
       };
     }
-  
+
     return foreignKeys;
   }
 
@@ -70,34 +92,36 @@ export class SpannerSchemaMetadata extends SchemaMetadata {
     const indexes = await this.getIndexes(table);
     const uniqueColumns: string[] = [];
     for (const indexName in indexes) {
-      if (!indexName.endsWith('_unique'))
+      if (!indexName.endsWith('_unique')) {
         continue;
-  
+      }
+
       const indexedColumns = indexes[indexName];
       uniqueColumns.push(...indexedColumns);
     }
-  
+
     return uniqueColumns;
   }
 
-  async getIndexes(table: Table<any>): Promise<{[keyName: string]: string[]}> {
+  async getIndexes(table: Table<any>): Promise<{ [keyName: string]: string[] }> {
     const qb = new QueryBuilder('INDEX_COLUMNS')
       .condition({ field: 'TABLE_NAME', operator: '=', value: table.name })
-      .sort([{ field: 'ORDINAL_POSITION', desc: false }])
-    ;
+      .sort([{ field: 'ORDINAL_POSITION', 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 (!row['INDEX_NAME'])
+      if (!row['INDEX_NAME']) {
         continue;
+      }
 
-      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/SpannerSchemaOperations.ts

@@ -1,33 +1,39 @@
 import { Logger } from '@proteinjs/util';
-import { Table, SchemaOperations, TableChanges, StatementFactory, AlterTableParams, StatementUtil, getColumnByName } from '@proteinjs/db';
+import {
+  Table,
+  SchemaOperations,
+  TableChanges,
+  StatementFactory,
+  AlterTableParams,
+  StatementUtil,
+  getColumnByName,
+} from '@proteinjs/db';
 import { SpannerDriver } from './SpannerDriver';
 import { SpannerColumnTypeFactory } from './SpannerColumnTypeFactory';
 
 export class SpannerSchemaOperations implements SchemaOperations {
   private logger = new Logger(this.constructor.name);
 
-  constructor(
-    private spannerDriver: SpannerDriver
-  ){}
+  constructor(private spannerDriver: SpannerDriver) {}
 
   async createTable(table: Table<any>) {
-    const indexes: { name?: string, columns: string|string[], unique?: boolean }[] = [];
-    for (let index of table.indexes) {
+    const indexes: { name?: string; columns: string | string[]; unique?: boolean }[] = [];
+    for (const index of table.indexes) {
       indexes.push({ name: index.name, columns: index.columns as string[] });
     }
 
-    const serializedColumns: { name: string, type: string, nullable?: boolean }[] = [];
-    const foreignKeys: { table: string, column: string, referencedByColumn: string }[] = [];
+    const serializedColumns: { name: string; type: string; nullable?: boolean }[] = [];
+    const foreignKeys: { table: string; column: string; referencedByColumn: string }[] = [];
     for (const columnPropertyName in table.columns) {
       const column = table.columns[columnPropertyName];
       const columnType = new SpannerColumnTypeFactory().getType(column);
       serializedColumns.push({ name: column.name, type: columnType, nullable: column.options?.nullable });
-      this.logger.info(`[${table.name}] Creating column: ${column.name} (${column.constructor.name})`)
+      this.logger.info(`[${table.name}] Creating column: ${column.name} (${column.constructor.name})`);
       if (column.options?.unique?.unique) {
         indexes.push({ name: column.options.unique.indexName, columns: column.name, unique: true });
         this.logger.info(`[${table.name}.${column.name}] Adding unique constraint`);
       }
-  
+
       if (column.options?.references) {
         foreignKeys.push({ table: column.options.references.table, column: 'id', referencedByColumn: column.name });
         this.logger.info(`[${table.name}.${column.name}] Adding foreign key -> ${column.options.references.table}.id`);
@@ -36,12 +42,16 @@ export class SpannerSchemaOperations implements SchemaOperations {
     const createTableSql = new StatementFactory().createTable(table.name, serializedColumns, 'id', foreignKeys).sql;
     await this.spannerDriver.runUpdateSchema(createTableSql);
 
-    for (let index of indexes) {
+    for (const index of indexes) {
       const createIndexSql = new StatementFactory().createIndex(index, table.name).sql;
       const indexName = StatementUtil.getIndexName(table.name, index);
-      this.logger.info(`[${table.name}] Creating index: ${indexName} (${typeof index.columns === 'string' ? index.columns : index.columns.join(', ')})`);
+      this.logger.info(
+        `[${table.name}] Creating index: ${indexName} (${typeof index.columns === 'string' ? index.columns : index.columns.join(', ')})`
+      );
       await this.spannerDriver.runUpdateSchema(createIndexSql);
-      this.logger.info(`[${table.name}] Created index: ${indexName} (${typeof index.columns === 'string' ? index.columns : index.columns.join(', ')})`);
+      this.logger.info(
+        `[${table.name}] Created index: ${indexName} (${typeof index.columns === 'string' ? index.columns : index.columns.join(', ')})`
+      );
     }
   }
 
@@ -55,7 +65,7 @@ export class SpannerSchemaOperations implements SchemaOperations {
     };
     const indexesToDrop = tableChanges.indexesToDrop;
     const indexesToAdd = tableChanges.indexesToCreate;
-		for (const columnPropertyName of tableChanges.columnsToCreate) {
+    for (const columnPropertyName of tableChanges.columnsToCreate) {
       const column = table.columns[columnPropertyName];
       const columnType = new SpannerColumnTypeFactory().getType(column);
       alterParams.columnsToAdd?.push({ name: column.name, type: columnType, nullable: column.options?.nullable });
@@ -64,9 +74,13 @@ export class SpannerSchemaOperations implements SchemaOperations {
         indexesToAdd.push({ name: column.options.unique.indexName, columns: column.name, unique: true });
         this.logger.info(`[${table.name}.${column.name}] Adding unique constraint`);
       }
-  
+
       if (column.options?.references && tableChanges.columnsWithForeignKeysToCreate.includes(column.name)) {
-        alterParams.foreignKeysToAdd?.push({ table: column.options.references.table, column: 'id', referencedByColumn: column.name });
+        alterParams.foreignKeysToAdd?.push({
+          table: column.options.references.table,
+          column: 'id',
+          referencedByColumn: column.name,
+        });
         this.logger.info(`[${table.name}.${column.name}] Adding foreign key -> ${column.options.references.table}.id`);
       }
     }
@@ -78,7 +92,9 @@ export class SpannerSchemaOperations implements SchemaOperations {
 
     for (const foreignKey of tableChanges.foreignKeysToDrop) {
       alterParams.foreignKeysToDrop?.push(foreignKey);
-      this.logger.info(`[${table.name}.${foreignKey.referencedByColumn}] Dropping foreign key -> ${foreignKey.table}.${foreignKey.column}`);
+      this.logger.info(
+        `[${table.name}.${foreignKey.referencedByColumn}] Dropping foreign key -> ${foreignKey.table}.${foreignKey.column}`
+      );
     }
 
     for (const columnTypeChange of tableChanges.columnTypeChanges) {
@@ -101,22 +117,31 @@ export class SpannerSchemaOperations implements SchemaOperations {
     }
 
     const alterStatements = new StatementFactory().alterTable(alterParams);
-    for (let alterStatement of alterStatements)
+    for (const alterStatement of alterStatements) {
       await this.spannerDriver.runUpdateSchema(alterStatement.sql);
+    }
 
-    for (let index of tableChanges.indexesToDrop) {
+    for (const index of tableChanges.indexesToDrop) {
       const dropIndexSql = new StatementFactory().dropIndex(index, table.name).sql;
-      this.logger.info(`[${table.name}] Dropping index: ${index.name} (${typeof index.columns === 'string' ? index.columns : index.columns.join(', ')})`);
+      this.logger.info(
+        `[${table.name}] Dropping index: ${index.name} (${typeof index.columns === 'string' ? index.columns : index.columns.join(', ')})`
+      );
       await this.spannerDriver.runUpdateSchema(dropIndexSql);
-      this.logger.info(`[${table.name}] Dropped index: ${index.name} (${typeof index.columns === 'string' ? index.columns : index.columns.join(', ')})`);
+      this.logger.info(
+        `[${table.name}] Dropped index: ${index.name} (${typeof index.columns === 'string' ? index.columns : index.columns.join(', ')})`
+      );
     }
 
-    for (let index of tableChanges.indexesToCreate) {
+    for (const index of tableChanges.indexesToCreate) {
       const createIndexSql = new StatementFactory().createIndex(index, table.name).sql;
       const indexName = StatementUtil.getIndexName(table.name, index);
-      this.logger.info(`[${table.name}] Creating index: ${indexName} (${typeof index.columns === 'string' ? index.columns : index.columns.join(', ')})`);
+      this.logger.info(
+        `[${table.name}] Creating index: ${indexName} (${typeof index.columns === 'string' ? index.columns : index.columns.join(', ')})`
+      );
       await this.spannerDriver.runUpdateSchema(createIndexSql);
-      this.logger.info(`[${table.name}] Created index: ${indexName} (${typeof index.columns === 'string' ? index.columns : index.columns.join(', ')})`);
+      this.logger.info(
+        `[${table.name}] Created index: ${indexName} (${typeof index.columns === 'string' ? index.columns : index.columns.join(', ')})`
+      );
     }
-	}
-}
+  }
+}

package/test/Crud.test.ts

@@ -1,17 +1,11 @@
-import { crudTests } from '@proteinjs/db'
-import { SpannerDriver } from '../src/SpannerDriver'
-import { getDropTable } from './dropTable'
+import { crudTests } from '@proteinjs/db';
+import { SpannerDriver } from '../src/SpannerDriver';
+import { getDropTable } from './dropTable';
 
 const spannerDriver = new SpannerDriver({
-	projectId: 'proteinjs-test',
-	instanceName: 'proteinjs-test',
-	databaseName: 'test',
+  projectId: 'proteinjs-test',
+  instanceName: 'proteinjs-test',
+  databaseName: 'test',
 });
 
-describe(
-	'CRUD Tests',
-	crudTests(
-		spannerDriver,
-		getDropTable(spannerDriver)
-	)
-);
+describe('CRUD Tests', crudTests(spannerDriver, getDropTable(spannerDriver)));

package/test/TableManager.test.ts

@@ -1,24 +1,19 @@
-import { tableManagerTests } from '@proteinjs/db'
-import { SpannerDriver } from '../src/SpannerDriver'
+import { tableManagerTests } from '@proteinjs/db';
+import { SpannerDriver } from '../src/SpannerDriver';
 import { SpannerColumnTypeFactory } from '../src/SpannerColumnTypeFactory';
 import { getDropTable } from './dropTable';
 
 const spannerDriver = new SpannerDriver({
-	projectId: 'proteinjs-test',
-	instanceName: 'proteinjs-test',
-	databaseName: 'test',
+  projectId: 'proteinjs-test',
+  instanceName: 'proteinjs-test',
+  databaseName: 'test',
 });
 
 describe(
-	'Table Manager Tests',
-	tableManagerTests(
-		spannerDriver,
-		getDropTable(spannerDriver),
-		new SpannerColumnTypeFactory().getType,
-		{
-			alterColumnName: true,
-			alterColumnTypes: true,
-			alterNullableConstraint: true,
-		}
-	)
-);
+  'Table Manager Tests',
+  tableManagerTests(spannerDriver, getDropTable(spannerDriver), new SpannerColumnTypeFactory().getType, {
+    alterColumnName: true,
+    alterColumnTypes: true,
+    alterNullableConstraint: true,
+  })
+);