@proteinjs/db-driver-knex 1.0.14 → 1.0.16

package/jest.config.js

@@ -1,18 +1,9 @@
 module.exports = {
-	"roots": [
-	  	"<rootDir>/test"
-	],
-	"transform": {
-	  	"^.+\\.tsx?$": "ts-jest"
-	},
-	"testRegex": "(/__tests__/.*|(\\.|/)(test|spec))\\.tsx?$",
-	"moduleFileExtensions": [
-		"ts",
-		"tsx",
-		"js",
-		"jsx",
-		"json",
-		"node"
-	],
-	"testEnvironment": "node"
-}
+  roots: ['<rootDir>/test'],
+  transform: {
+    '^.+\\.tsx?$': 'ts-jest',
+  },
+  testRegex: '(/__tests__/.*|(\\.|/)(test|spec))\\.tsx?$',
+  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json', 'node'],
+  testEnvironment: 'node',
+};

package/package.json

@@ -1,47 +1,52 @@
 {
-    "name": "@proteinjs/db-driver-knex",
-    "version": "1.0.14",
-    "description": "Db driver for Knex",
-    "publishConfig": {
-        "access": "public"
-    },
-    "repository": {
-        "type": "git",
-        "url": "git+https://github.com/proteinjs/db.git"
-    },
-    "bugs": {
-        "url": "https://github.com/proteinjs/db/issues"
-    },
-    "homepage": "https://github.com/proteinjs/db#readme",
-    "author": "Brent Bahry",
-    "license": "ISC",
-    "scripts": {
-        "clean": "rm -rf dist/ node_modules/ generated/",
-        "build": "reflection-build && tsc",
-        "watch": "reflection-watch",
-        "test": "jest"
-    },
-    "dependencies": {
-        "@proteinjs/db": "^1.0.15",
-        "@proteinjs/db-query": "1.0.8",
-        "@proteinjs/reflection": "1.1.1",
-        "@proteinjs/util": "1.1.0",
-        "knex": "0.21.5",
-        "moment": "2.27.0",
-        "mysql": "2.18.1",
-        "uuid": "8.3.0"
-    },
-    "devDependencies": {
-        "@proteinjs/reflection-build": "1.0.16",
-        "@types/jest": "29.5.5",
-        "@types/knex": "0.16.1",
-        "@types/node": "14.0.27",
-        "@types/uuid": "8.3.0",
-        "jest": "29.7.0",
-        "ts-jest": "29.1.1",
-        "typescript": "5.2.2"
-    },
-    "main": "./dist/generated/index.js",
-    "types": "./dist/generated/index.d.ts",
-    "gitHead": "e20c78719dd34d0c574e9f636a1d3b41925c4844"
+  "name": "@proteinjs/db-driver-knex",
+  "version": "1.0.16",
+  "description": "Db driver for Knex",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/proteinjs/db.git"
+  },
+  "bugs": {
+    "url": "https://github.com/proteinjs/db/issues"
+  },
+  "homepage": "https://github.com/proteinjs/db#readme",
+  "author": "Brent Bahry",
+  "license": "ISC",
+  "scripts": {
+    "clean": "rm -rf dist/ node_modules/ generated/",
+    "build": "reflection-build && tsc",
+    "watch": "reflection-watch",
+    "test": "jest"
+  },
+  "dependencies": {
+    "@proteinjs/db": "^1.0.17",
+    "@proteinjs/db-query": "^1.0.10",
+    "@proteinjs/reflection": "1.1.1",
+    "@proteinjs/util": "1.1.0",
+    "knex": "0.21.5",
+    "moment": "2.27.0",
+    "mysql": "2.18.1",
+    "uuid": "8.3.0"
+  },
+  "devDependencies": {
+    "@proteinjs/reflection-build": "1.0.16",
+    "@types/jest": "29.5.5",
+    "@types/knex": "0.16.1",
+    "@types/node": "14.0.27",
+    "@types/uuid": "8.3.0",
+    "@typescript-eslint/eslint-plugin": "7.8.0",
+    "@typescript-eslint/parser": "7.8.0",
+    "eslint": "8.57.0",
+    "eslint-config-prettier": "9.1.0",
+    "eslint-plugin-prettier": "5.1.3",
+    "jest": "29.7.0",
+    "ts-jest": "29.1.1",
+    "typescript": "5.2.2"
+  },
+  "main": "./dist/generated/index.js",
+  "types": "./dist/generated/index.d.ts",
+  "gitHead": "e168c40fd3f7c538d5d5ddcedb0bb4f5550ca81f"
 }

package/src/KnexColumnTypeFactory.ts

@@ -1,28 +1,40 @@
 import { isInstanceOf } from '@proteinjs/util';
-import { BinaryColumn, BooleanColumn, Column, DateColumn, DateTimeColumn, DecimalColumn, FloatColumn, IntegerColumn, StringColumn, UuidColumn } from '@proteinjs/db';
+import {
+  BinaryColumn,
+  BooleanColumn,
+  Column,
+  DateColumn,
+  DateTimeColumn,
+  DecimalColumn,
+  FloatColumn,
+  IntegerColumn,
+  StringColumn,
+  UuidColumn,
+} from '@proteinjs/db';
 
 // note: this might be specific to maria db
 export class KnexColumnTypeFactory {
   getType(column: Column<any, any>): string {
-    if (isInstanceOf(column, IntegerColumn))
+    if (isInstanceOf(column, IntegerColumn)) {
       return (column as IntegerColumn).large ? 'bigint' : 'int';
-    else if (isInstanceOf(column, UuidColumn))
+    } else if (isInstanceOf(column, UuidColumn)) {
       return 'char';
-    else if (isInstanceOf(column, StringColumn))
+    } else if (isInstanceOf(column, StringColumn)) {
       return (column as StringColumn).maxLength === 'MAX' ? 'longtext' : 'varchar';
-    else if (isInstanceOf(column, FloatColumn))
+    } else if (isInstanceOf(column, FloatColumn)) {
       return 'float';
-    else if (isInstanceOf(column, DecimalColumn))
+    } else if (isInstanceOf(column, DecimalColumn)) {
       return 'decimal';
-    else if (isInstanceOf(column, BooleanColumn))
+    } else if (isInstanceOf(column, BooleanColumn)) {
       return 'tinyint';
-    else if (isInstanceOf(column, DateColumn))
+    } else if (isInstanceOf(column, DateColumn)) {
       return 'date';
-    else if (isInstanceOf(column, DateTimeColumn))
+    } else if (isInstanceOf(column, DateTimeColumn)) {
       return 'datetime';
-    else if (isInstanceOf(column, BinaryColumn))
+    } else if (isInstanceOf(column, BinaryColumn)) {
       return (column as BinaryColumn).maxLength === 'MAX' ? 'longblob' : 'blob';
-    
+    }
+
     throw new Error(`Invalid column type: ${column.constructor.name}, must extend a base column`);
   }
-}
+}

package/src/KnexConfig.ts

@@ -1,6 +1,6 @@
 export type KnexConfig = {
-  host: string,
-  user: string,
-  password: string,
-  dbName: string,
-}
+  host: string;
+  user: string;
+  password: string;
+  dbName: string;
+};

package/src/KnexDriver.ts

@@ -7,84 +7,87 @@ import { KnexSchemaOperations } from './KnexSchemaOperations';
 import { KnexColumnTypeFactory } from './KnexColumnTypeFactory';
 
 export class KnexDriver implements DbDriver {
-	private static KNEX: knex;
-	private logger = new Logger(this.constructor.name);
-	private config: KnexConfig;
-	private knexConfig: any;
+  private static KNEX: knex;
+  private logger = new Logger(this.constructor.name);
+  private config: KnexConfig;
+  private knexConfig: any;
 
-	constructor(config: KnexConfig) {
-		this.config = config;
-		this.knexConfig = {
-			client: 'mysql',
-			connection: {
-				host: this.config.host,
-				user: this.config.user,
-				password: this.config.password,
-			}
-		};
-	}
+  constructor(config: KnexConfig) {
+    this.config = config;
+    this.knexConfig = {
+      client: 'mysql',
+      connection: {
+        host: this.config.host,
+        user: this.config.user,
+        password: this.config.password,
+      },
+    };
+  }
 
-	getKnex(): knex {
-		if (!KnexDriver.KNEX)
-			KnexDriver.KNEX = knex(this.knexConfig);
+  getKnex(): knex {
+    if (!KnexDriver.KNEX) {
+      KnexDriver.KNEX = knex(this.knexConfig);
+    }
 
-		return KnexDriver.KNEX;
-	}
+    return KnexDriver.KNEX;
+  }
 
-	getDbName() {
-		return this.config.dbName as string;
-	}
+  getDbName() {
+    return this.config.dbName as string;
+  }
 
-	async createDbIfNotExists(): Promise<void> {
-		if (await this.dbExists(this.getDbName()))
-			return;
+  async createDbIfNotExists(): Promise<void> {
+    if (await this.dbExists(this.getDbName())) {
+      return;
+    }
 
-		await this.getKnex().raw(`CREATE DATABASE ${this.getDbName()};`);
-	}
+    await this.getKnex().raw(`CREATE DATABASE ${this.getDbName()};`);
+  }
 
-	private async dbExists(databaseName: string): Promise<boolean> {
-		const result: any = await this.getKnex().raw('SHOW DATABASES;');
-		for (const existingDatabase of result[0]) {
-			if (existingDatabase['Database'] == databaseName)
+  private async dbExists(databaseName: string): Promise<boolean> {
+    const result: any = await this.getKnex().raw('SHOW DATABASES;');
+    for (const existingDatabase of result[0]) {
+      if (existingDatabase['Database'] == databaseName) {
         return true;
-		}
+      }
+    }
 
-		return false;
-	}
+    return false;
+  }
 
-	async start() {
-		await this.setMaxAllowedPacketSize();
-	}
+  async start() {
+    await this.setMaxAllowedPacketSize();
+  }
 
-	async stop() {
-		await this.getKnex().destroy();
-	}
+  async stop() {
+    await this.getKnex().destroy();
+  }
 
-	private async setMaxAllowedPacketSize(): Promise<void> {
-		await this.getKnex().raw('SET GLOBAL max_allowed_packet=1073741824;');
-		await this.getKnex().destroy();
-		KnexDriver.KNEX = knex(this.knexConfig);
-		this.logger.info('Set global max_allowed_packet size to 1gb');
-	}
+  private async setMaxAllowedPacketSize(): Promise<void> {
+    await this.getKnex().raw('SET GLOBAL max_allowed_packet=1073741824;');
+    await this.getKnex().destroy();
+    KnexDriver.KNEX = knex(this.knexConfig);
+    this.logger.info('Set global max_allowed_packet size to 1gb');
+  }
 
-	getTableManager(): TableManager {
-		const columnTypeFactory = new KnexColumnTypeFactory();
-		const schemaOperations = new KnexSchemaOperations(this);
-		return new TableManager(this, columnTypeFactory, schemaOperations);
-	}
+  getTableManager(): TableManager {
+    const columnTypeFactory = new KnexColumnTypeFactory();
+    const schemaOperations = new KnexSchemaOperations(this);
+    return new TableManager(this, columnTypeFactory, schemaOperations);
+  }
 
-	async runQuery(generateStatement: (config: DbDriverStatementConfig) => Statement): Promise<SerializedRecord[]> {
-		const { sql, params } = generateStatement({ useParams: true, prefixTablesWithDb: true });
-		try {
-			return (await this.getKnex().raw(sql, params as any))[0]; // returns 2 arrays, first is records, second is metadata per record
-		} catch(error: any) {
-			this.logger.error(`Failed when executing query: ${sql}`);
-			throw error;
-		}
-	}
+  async runQuery(generateStatement: (config: DbDriverStatementConfig) => Statement): Promise<SerializedRecord[]> {
+    const { sql, params } = generateStatement({ useParams: true, prefixTablesWithDb: true });
+    try {
+      return (await this.getKnex().raw(sql, params as any))[0]; // returns 2 arrays, first is records, second is metadata per record
+    } catch (error: any) {
+      this.logger.error(`Failed when executing query: ${sql}`);
+      throw error;
+    }
+  }
 
-	async runDml(generateStatement: (config: DbDriverStatementConfig) => Statement): Promise<number> {
-		const { affectedRows } = (await this.runQuery(generateStatement) as any);
-		return affectedRows;
-	}
-}
+  async runDml(generateStatement: (config: DbDriverStatementConfig) => Statement): Promise<number> {
+    const { affectedRows } = (await this.runQuery(generateStatement)) as any;
+    return affectedRows;
+  }
+}

package/src/KnexSchemaOperations.ts

@@ -7,9 +7,7 @@ import { getColumnFactory } from './getColumnFactory';
 export class KnexSchemaOperations implements SchemaOperations {
   private logger = new Logger(this.constructor.name);
 
-  constructor(
-    private knexDriver: KnexDriver
-  ){}
+  constructor(private knexDriver: KnexDriver) {}
 
   async createTable(table: Table<any>) {
     let resolve: any;
@@ -18,113 +16,138 @@ export class KnexSchemaOperations implements SchemaOperations {
       resolve = rs;
       reject = rj;
     });
-  
-    await this.knexDriver.getKnex().schema.withSchema(this.knexDriver.getDbName()).createTable(table.name, (tableBuilder: knex.TableBuilder) => {
-      for (const columnPropertyName in table.columns) {
-        const column = table.columns[columnPropertyName];
-        this.createColumn(column, table, tableBuilder);
-        this.logger.info(`[${table.name}] Creating column: ${column.name}`);
-      }
-  
-      tableBuilder.primary(['id']);
-      this.logger.info(`[${table.name}] Creating primary key: id`);
-  
-      if (table.indexes) {
-        for (const index of table.indexes) {
-          const columnNames = index.columns.map((columnPropertyName) => table.columns[columnPropertyName as string].name)
-          tableBuilder.index(columnNames, index.name);
-          this.logger.info(`[${table.name}] Creating index: ${columnNames}`);
+
+    await this.knexDriver
+      .getKnex()
+      .schema.withSchema(this.knexDriver.getDbName())
+      .createTable(table.name, (tableBuilder: knex.TableBuilder) => {
+        for (const columnPropertyName in table.columns) {
+          const column = table.columns[columnPropertyName];
+          this.createColumn(column, table, tableBuilder);
+          this.logger.info(`[${table.name}] Creating column: ${column.name}`);
         }
-      }
-    }).catch((reason: any) => {
-      reject(`Failed to create table: ${table.name}. reason: ${reason}`);
-    }).then(() => {
-      resolve();
-    });
-  
+
+        tableBuilder.primary(['id']);
+        this.logger.info(`[${table.name}] Creating primary key: id`);
+
+        if (table.indexes) {
+          for (const index of table.indexes) {
+            const columnNames = index.columns.map(
+              (columnPropertyName) => table.columns[columnPropertyName as string].name
+            );
+            tableBuilder.index(columnNames, index.name);
+            this.logger.info(`[${table.name}] Creating index: ${columnNames}`);
+          }
+        }
+      })
+      .catch((reason: any) => {
+        reject(`Failed to create table: ${table.name}. reason: ${reason}`);
+      })
+      .then(() => {
+        resolve();
+      });
+
     return p;
   }
 
   async alterTable(table: Table<any>, tableChanges: TableChanges) {
-		let resolve: any;
-		let reject: any;
-		const p = new Promise<void>((rs, rj) => {
-			resolve = rs;
-			reject = rj;
-		});
-			
-		await this.knexDriver.getKnex().schema.withSchema(this.knexDriver.getDbName()).table(table.name, (tableBuilder: knex.TableBuilder) => {
-			for (const columnPropertyName of tableChanges.columnsToCreate) {
-				const column = table.columns[columnPropertyName];
-        this.logger.info(`[${table.name}] Creating column: ${column.name}`);
-				this.createColumn(column, table, tableBuilder, tableChanges);
-			}
-	
-			for (const column of tableChanges.columnsWithUniqueConstraintsToDrop) {
-				tableBuilder.dropUnique([column]);
-				this.logger.info(`[${table.name}.${column}] Dropping unique constraint`);
-			}
-	
-			for (const column of tableChanges.columnsWithForeignKeysToDrop) {
-				tableBuilder.dropForeign([column]);
-				this.logger.info(`[${table.name}.${column}] Dropping foreign key`);
-			}
-	
-			for (const index of tableChanges.indexesToDrop) {
-				tableBuilder.dropIndex(index.columns);
-				this.logger.info(`[${table.name}] Dropping index: ${JSON.stringify(index)}`);
-			}
-	
-			for (const columnPropertyName of tableChanges.columnsToAlter) {
-				const column = table.columns[columnPropertyName];
-        this.logger.info(`[${table.name}.${column.name}] Altering column type to: ${column.constructor.name}`);
-				this.createColumn(column, table, tableBuilder, tableChanges).alter();
-			}
-	
-			for (const columnPropertyName of tableChanges.columnsToRename) {
-				const column = table.columns[columnPropertyName];
-				if (!column.oldName)
-					continue;
-	
-				tableBuilder.renameColumn(column.oldName, column.name);
-				this.logger.info(`[${table.name}] Renaming column: ${column.oldName} -> ${column.name}`);
-			}
-	
-			for (const index of tableChanges.indexesToCreate) {
-				tableBuilder.index(index.columns);
-				this.logger.info(`[${table.name}] Creating index: ${JSON.stringify(index)}`);
-			}
-		}).catch((reason: any) => {
-			reject(`Failed to alter table: ${table.name}. reason: ${reason}`);
-		}).then(() => {
-      resolve();
+    let resolve: any;
+    let reject: any;
+    const p = new Promise<void>((rs, rj) => {
+      resolve = rs;
+      reject = rj;
     });
-	
-		return p;
-	}
 
-  private createColumn(column: Column<any, any>, table: Table<any>, tableBuilder: knex.TableBuilder, tableChanges?: TableChanges) {
+    await this.knexDriver
+      .getKnex()
+      .schema.withSchema(this.knexDriver.getDbName())
+      .table(table.name, (tableBuilder: knex.TableBuilder) => {
+        for (const columnPropertyName of tableChanges.columnsToCreate) {
+          const column = table.columns[columnPropertyName];
+          this.logger.info(`[${table.name}] Creating column: ${column.name}`);
+          this.createColumn(column, table, tableBuilder, tableChanges);
+        }
+
+        for (const column of tableChanges.columnsWithUniqueConstraintsToDrop) {
+          tableBuilder.dropUnique([column]);
+          this.logger.info(`[${table.name}.${column}] Dropping unique constraint`);
+        }
+
+        for (const column of tableChanges.columnsWithForeignKeysToDrop) {
+          tableBuilder.dropForeign([column]);
+          this.logger.info(`[${table.name}.${column}] Dropping foreign key`);
+        }
+
+        for (const index of tableChanges.indexesToDrop) {
+          tableBuilder.dropIndex(index.columns);
+          this.logger.info(`[${table.name}] Dropping index: ${JSON.stringify(index)}`);
+        }
+
+        for (const columnPropertyName of tableChanges.columnsToAlter) {
+          const column = table.columns[columnPropertyName];
+          this.logger.info(`[${table.name}.${column.name}] Altering column type to: ${column.constructor.name}`);
+          this.createColumn(column, table, tableBuilder, tableChanges).alter();
+        }
+
+        for (const columnPropertyName of tableChanges.columnsToRename) {
+          const column = table.columns[columnPropertyName];
+          if (!column.oldName) {
+            continue;
+          }
+
+          tableBuilder.renameColumn(column.oldName, column.name);
+          this.logger.info(`[${table.name}] Renaming column: ${column.oldName} -> ${column.name}`);
+        }
+
+        for (const index of tableChanges.indexesToCreate) {
+          tableBuilder.index(index.columns);
+          this.logger.info(`[${table.name}] Creating index: ${JSON.stringify(index)}`);
+        }
+      })
+      .catch((reason: any) => {
+        reject(`Failed to alter table: ${table.name}. reason: ${reason}`);
+      })
+      .then(() => {
+        resolve();
+      });
+
+    return p;
+  }
+
+  private createColumn(
+    column: Column<any, any>,
+    table: Table<any>,
+    tableBuilder: knex.TableBuilder,
+    tableChanges?: TableChanges
+  ) {
     const columnFactory = getColumnFactory(column);
     const columnBuilder = columnFactory.create(column, tableBuilder);
-    if (column.options?.unique?.unique && (!tableChanges || tableChanges.columnsWithUniqueConstraintsToCreate.includes(column.name))) {
+    if (
+      column.options?.unique?.unique &&
+      (!tableChanges || tableChanges.columnsWithUniqueConstraintsToCreate.includes(column.name))
+    ) {
       columnBuilder.unique(column.options.unique.indexName);
       this.logger.info(`[${table.name}.${column.name}] Adding unique constraint`);
     }
-  
-    if (column.options?.references && (!tableChanges || tableChanges.columnsWithForeignKeysToCreate.includes(column.name))) {
+
+    if (
+      column.options?.references &&
+      (!tableChanges || tableChanges.columnsWithForeignKeysToCreate.includes(column.name))
+    ) {
       columnBuilder.references('id').inTable(`${this.knexDriver.getDbName()}.${column.options.references.table}`);
       this.logger.info(`[${table.name}.${column.name}] Adding foreign key -> ${column.options.references.table}.id`);
     }
-  
+
     if (typeof column.options?.nullable !== 'undefined') {
-      if (column.options?.nullable)
+      if (column.options?.nullable) {
         columnBuilder.nullable();
-      else
+      } else {
         columnBuilder.notNullable();
-  
+      }
+
       this.logger.info(`[${table.name}.${column.name}] Adding constraint nullable: ${column.options?.nullable}`);
     }
-  
+
     return columnBuilder;
   }
-}
+}