@proteinjs/db-driver-knex 1.0.2

package/src/KnexColumnTypeFactory.ts

@@ -0,0 +1,27 @@
+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 (column instanceof IntegerColumn)
+      return column.large ? 'bigint' : 'int';
+    else if (column instanceof UuidColumn)
+      return 'char';
+    else if (column instanceof StringColumn)
+      return column.maxLength === 'MAX' ? 'longtext' : 'varchar';
+    else if (column instanceof FloatColumn)
+      return 'float';
+    else if (column instanceof DecimalColumn)
+      return 'decimal';
+    else if (column instanceof BooleanColumn)
+      return 'tinyint';
+    else if (column instanceof DateColumn)
+      return 'date';
+    else if (column instanceof DateTimeColumn)
+      return 'datetime';
+    else if (column instanceof 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

@@ -0,0 +1,18 @@
+import { Loadable, SourceRepository } from '@proteinjs/reflection';
+
+export const getKnexConfig = () => {
+  const config = SourceRepository.get().object<KnexConfig>('@proteinjs/db-driver-knex/KnexConfig');
+  return Object.assign({
+    host: process.env.DB_HOST ? process.env.DB_HOST : 'localhost',
+    user: process.env.DB_USER ? process.env.DB_USER : 'root',
+    password: process.env.DB_PASSWORD ? process.env.DB_PASSWORD : '',
+    dbName: process.env.DB_NAME ? process.env.DB_NAME : 'dev',
+  }, config);
+}
+
+export type KnexConfig = Loadable & {
+  host?: string,
+  user?: string,
+  password?: string,
+  dbName?: string,
+}

package/src/KnexDriver.ts

@@ -0,0 +1,90 @@
+import knex from 'knex';
+import { DbDriver, DbDriverStatementConfig, SerializedRecord, TableManager } from '@proteinjs/db';
+import { KnexConfig, getKnexConfig } from './KnexConfig';
+import { Logger } from '@proteinjs/util';
+import { Statement } from '@proteinjs/db-query';
+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;
+
+	constructor(config?: KnexConfig) {
+		this.config = config ? config : getKnexConfig();
+		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);
+
+		return KnexDriver.KNEX;
+	}
+
+	getDbName() {
+		return this.config.dbName as string;
+	}
+
+	async createDbIfNotExists(): Promise<void> {
+		if (await this.dbExists(this.getDbName()))
+			return;
+
+		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)
+        return true;
+		}
+
+		return false;
+	}
+
+	async start() {
+		await this.setMaxAllowedPacketSize();
+	}
+
+	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');
+	}
+
+	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 runDml(generateStatement: (config: DbDriverStatementConfig) => Statement): Promise<number> {
+		const { affectedRows } = (await this.runQuery(generateStatement) as any);
+		return affectedRows;
+	}
+}

package/src/KnexSchemaOperations.ts

@@ -0,0 +1,130 @@
+import * as knex from 'knex';
+import { Logger } from '@proteinjs/util';
+import { Column, Table, SchemaOperations, TableChanges } from '@proteinjs/db';
+import { KnexDriver } from './KnexDriver';
+import { getColumnFactory } from './getColumnFactory';
+
+export class KnexSchemaOperations implements SchemaOperations {
+  private logger = new Logger(this.constructor.name);
+
+  constructor(
+    private knexDriver: KnexDriver
+  ){}
+
+  async createTable(table: Table<any>) {
+    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()).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}`);
+        }
+      }
+    }).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();
+    });
+	
+		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))) {
+      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))) {
+      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)
+        columnBuilder.nullable();
+      else
+        columnBuilder.notNullable();
+  
+      this.logger.info(`[${table.name}.${column.name}] Adding constraint nullable: ${column.options?.nullable}`);
+    }
+  
+    return columnBuilder;
+  }
+}

package/src/getColumnFactory.ts

@@ -0,0 +1,86 @@
+import knex from 'knex';
+import { BinaryColumn, BooleanColumn, Column, DateColumn, DateTimeColumn, DecimalColumn, FloatColumn, IntegerColumn, StringColumn, UuidColumn } from '@proteinjs/db';
+
+export const getColumnFactory = (column: Column<any, any>): ColumnFactory => {
+  if (column instanceof IntegerColumn)
+		return new IntegerColumnFactory();
+	else if (column instanceof UuidColumn)
+		return new UuidColumnFactory();
+	else if (column instanceof StringColumn)
+		return new StringColumnFactory();
+	else if (column instanceof FloatColumn)
+		return new FloatColumnFactory();
+	else if (column instanceof DecimalColumn)
+		return new DecimalColumnFactory();
+	else if (column instanceof BooleanColumn)
+		return new BooleanColumnFactory();
+	else if (column instanceof DateColumn)
+		return new DateColumnFactory();
+	else if (column instanceof DateTimeColumn)
+		return new DateTimeColumnFactory();
+	else if (column instanceof BinaryColumn)
+		return new BinaryColumnFactory();
+
+	throw new Error(`Invalid column type: ${column.constructor.name}, must extend a base column`);
+}
+
+export interface ColumnFactory {
+  create(column: Column<any, any>, tableBuilder: knex.TableBuilder): knex.ColumnBuilder;
+}
+
+export class IntegerColumnFactory implements ColumnFactory {
+	create(integerColumn: IntegerColumn, tableBuilder: knex.TableBuilder): knex.ColumnBuilder {
+		return integerColumn.large ? tableBuilder.bigInteger(integerColumn.name) : tableBuilder.integer(integerColumn.name);
+	}
+}
+
+// max length of longtext is 4,294,967,295 bytes (~4 GiB)
+export class StringColumnFactory implements ColumnFactory {
+	create(stringColumn: StringColumn, tableBuilder: knex.TableBuilder): knex.ColumnBuilder {
+		return stringColumn.maxLength === 'MAX' ? tableBuilder.text(stringColumn.name, 'longtext') : tableBuilder.string(stringColumn.name, stringColumn.maxLength);
+	}
+}
+
+export class FloatColumnFactory implements ColumnFactory {
+	create(floatColumn: FloatColumn, tableBuilder: knex.TableBuilder): knex.ColumnBuilder {
+		return tableBuilder.float(floatColumn.name);
+	}
+}
+
+export class DecimalColumnFactory implements ColumnFactory {
+	create(decimalColumn: DecimalColumn, tableBuilder: knex.TableBuilder): knex.ColumnBuilder {
+		return decimalColumn.large ? tableBuilder.decimal(decimalColumn.name, 38, 20) : tableBuilder.decimal(decimalColumn.name);
+	}
+}
+
+export class BooleanColumnFactory implements ColumnFactory {
+	create(booleanColumn: BooleanColumn, tableBuilder: knex.TableBuilder): knex.ColumnBuilder {
+		return tableBuilder.boolean(booleanColumn.name);
+	}
+}
+
+export class DateColumnFactory implements ColumnFactory {
+	create(dateColumn: DateColumn, tableBuilder: knex.TableBuilder): knex.ColumnBuilder {
+		return tableBuilder.date(dateColumn.name);
+	}
+}
+
+export class DateTimeColumnFactory implements ColumnFactory {
+	create(dateTimeColumn: DateTimeColumn, tableBuilder: knex.TableBuilder): knex.ColumnBuilder {
+		return tableBuilder.dateTime(dateTimeColumn.name);
+	}
+}
+
+// max length of longblob is 4,294,967,295 bytes (~4 GiB)
+// max length when undefined (aka blob) is 65,535 bytes (~64 KiB)
+export class BinaryColumnFactory implements ColumnFactory {
+	create(binaryColumn: BinaryColumn, tableBuilder: knex.TableBuilder): knex.ColumnBuilder {
+		return binaryColumn.maxLength == 'MAX' ? tableBuilder.specificType(binaryColumn.name, 'longblob') : tableBuilder.binary(binaryColumn.name, binaryColumn.maxLength);
+	}
+}
+
+export class UuidColumnFactory implements ColumnFactory {
+	create(uuidColumn: UuidColumn, tableBuilder: knex.TableBuilder): knex.ColumnBuilder {
+		return tableBuilder.uuid(uuidColumn.name);
+	}
+}

package/test/Crud.test.ts

@@ -0,0 +1,21 @@
+import { Table, crudTests } from '@proteinjs/db'
+import { KnexDriver } from '../src/KnexDriver'
+
+const knexDriver = new KnexDriver({
+	host: 'localhost',
+	user: 'root',
+	password: '',
+	dbName: 'test',
+});
+const dropTable = async (table: Table<any>) => {
+  if (await knexDriver.getKnex().schema.withSchema(knexDriver.getDbName()).hasTable(table.name))
+		await knexDriver.getKnex().schema.withSchema(knexDriver.getDbName()).dropTable(table.name);
+}
+
+describe(
+	'CRUD Tests',
+	crudTests(
+		knexDriver,
+		dropTable
+	)
+);

package/test/TableManager.test.ts

@@ -0,0 +1,23 @@
+import { Table, tableManagerTests } from '@proteinjs/db'
+import { KnexDriver } from '../src/KnexDriver'
+import { KnexColumnTypeFactory } from '../src/KnexColumnTypeFactory';
+
+const knexDriver = new KnexDriver({
+	host: 'localhost',
+	user: 'root',
+	password: '',
+	dbName: 'test',
+});
+const dropTable = async (table: Table<any>) => {
+  if (await knexDriver.getKnex().schema.withSchema(knexDriver.getDbName()).hasTable(table.name))
+		await knexDriver.getKnex().schema.withSchema(knexDriver.getDbName()).dropTable(table.name);
+}
+
+describe(
+	'Table Manager Tests',
+	tableManagerTests(
+		knexDriver,
+		dropTable,
+		new KnexColumnTypeFactory().getType
+	)
+);

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+    "compilerOptions": {
+        "rootDir": "./",
+        "target": "es5",
+        "module": "commonjs",
+        "declaration": true,
+        "declarationMap": true,
+        "sourceMap": true,
+        "outDir": "./dist/",
+        "strict": true,
+        "noImplicitAny": true,
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "forceConsistentCasingInFileNames": true,
+        "resolveJsonModule": true,
+        "typeRoots": [
+            "./node_modules/@types"
+        ],
+        "types": [
+            "node", "jest"
+        ]
+    }
+}