@mikro-orm/knex 6.1.13-dev.4 → 6.1.13-dev.41

package/AbstractSqlConnection.js

@@ -125,7 +125,13 @@ class AbstractSqlConnection extends core_1.Connection {
      */
     async loadFile(path) {
         const buf = await (0, fs_extra_1.readFile)(path);
-        await this.getKnex().raw(buf.toString());
+        try {
+            await this.getKnex().raw(buf.toString());
+        }
+        catch (e) {
+            /* istanbul ignore next */
+            throw this.platform.getExceptionConverter().convertException(e);
+        }
     }
     createKnexClient(type) {
         const driverOptions = this.config.get('driverOptions');
@@ -145,7 +151,7 @@ class AbstractSqlConnection extends core_1.Connection {
             client: type,
             connection: this.getConnectionOptions(),
             pool: this.config.get('pool'),
-        }, this.config.get('driverOptions'));
+        }, this.config.get('driverOptions'), this.options.driverOptions);
         const options = config.connection;
         const password = options.password;
         if (!(password instanceof Function)) {

package/AbstractSqlDriver.d.ts

@@ -1,5 +1,5 @@
 import type { Knex } from 'knex';
-import { type AnyEntity, type Collection, type Configuration, type ConnectionType, type Constructor, type CountOptions, DatabaseDriver, type DeleteOptions, type Dictionary, type DriverMethodOptions, type EntityData, type EntityDictionary, type EntityField, EntityManagerType, type EntityMetadata, type EntityName, type EntityProperty, type FilterQuery, type FindOneOptions, type FindOptions, type IDatabaseDriver, type LockOptions, type LoggingOptions, type NativeInsertUpdateManyOptions, type NativeInsertUpdateOptions, type ObjectQuery, type Options, type OrderDefinition, type PopulateOptions, type Primary, type QueryOrderMap, type QueryResult, type Transaction, type UpsertManyOptions, type UpsertOptions } from '@mikro-orm/core';
+import { type AnyEntity, type Collection, type Configuration, type ConnectionType, type Constructor, type CountOptions, DatabaseDriver, type DeleteOptions, type Dictionary, type DriverMethodOptions, type EntityData, type EntityDictionary, type EntityField, EntityManagerType, type EntityMetadata, type EntityName, type EntityProperty, type FilterQuery, type FindOneOptions, type FindOptions, type IDatabaseDriver, type LockOptions, type LoggingOptions, type NativeInsertUpdateManyOptions, type NativeInsertUpdateOptions, type ObjectQuery, type Options, type OrderDefinition, type PopulateOptions, type PopulatePath, type Primary, type QueryOrderMap, type QueryResult, type Transaction, type UpsertManyOptions, type UpsertOptions } from '@mikro-orm/core';
 import type { AbstractSqlConnection } from './AbstractSqlConnection';
 import type { AbstractSqlPlatform } from './AbstractSqlPlatform';
 import { QueryBuilder, QueryType } from './query';
@@ -13,8 +13,8 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     protected constructor(config: Configuration, platform: Platform, connection: Constructor<Connection>, connector: string[]);
     getPlatform(): Platform;
     createEntityManager<D extends IDatabaseDriver = IDatabaseDriver>(useContext?: boolean): D[typeof EntityManagerType];
-    find<T extends object, P extends string = never, F extends string = '*', E extends string = never>(entityName: string, where: FilterQuery<T>, options?: FindOptions<T, P, F, E>): Promise<EntityData<T>[]>;
-    findOne<T extends object, P extends string = never, F extends string = '*', E extends string = never>(entityName: string, where: FilterQuery<T>, options?: FindOneOptions<T, P, F, E>): Promise<EntityData<T> | null>;
+    find<T extends object, P extends string = never, F extends string = PopulatePath.ALL, E extends string = never>(entityName: string, where: FilterQuery<T>, options?: FindOptions<T, P, F, E>): Promise<EntityData<T>[]>;
+    findOne<T extends object, P extends string = never, F extends string = PopulatePath.ALL, E extends string = never>(entityName: string, where: FilterQuery<T>, options?: FindOneOptions<T, P, F, E>): Promise<EntityData<T> | null>;
     protected hasToManyJoins<T extends object>(hint: PopulateOptions<T>, meta: EntityMetadata<T>): boolean;
     findVirtual<T extends object>(entityName: string, where: FilterQuery<T>, options: FindOptions<T, any, any, any>): Promise<EntityData<T>[]>;
     countVirtual<T extends object>(entityName: string, where: FilterQuery<T>, options: CountOptions<T, any>): Promise<number>;
@@ -24,7 +24,7 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     private mapJoinedProps;
     count<T extends object>(entityName: string, where: any, options?: CountOptions<T>): Promise<number>;
     nativeInsert<T extends object>(entityName: string, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
-    nativeInsertMany<T extends object>(entityName: string, data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>): Promise<QueryResult<T>>;
+    nativeInsertMany<T extends object>(entityName: string, data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>, transform?: (sql: string) => string): Promise<QueryResult<T>>;
     nativeUpdate<T extends object>(entityName: string, where: FilterQuery<T>, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T> & UpsertOptions<T>): Promise<QueryResult<T>>;
     nativeUpdateMany<T extends object>(entityName: string, where: FilterQuery<T>[], data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T> & UpsertManyOptions<T>): Promise<QueryResult<T>>;
     nativeDelete<T extends object>(entityName: string, where: FilterQuery<T> | string | any, options?: DeleteOptions<T>): Promise<QueryResult<T>>;
@@ -55,7 +55,7 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
      */
     mapPropToFieldNames<T extends object>(qb: QueryBuilder<T>, prop: EntityProperty<T>, tableAlias?: string): Field<T>[];
     /** @internal */
-    createQueryBuilder<T extends object>(entityName: EntityName<T> | QueryBuilder<T>, ctx?: Transaction<Knex.Transaction>, preferredConnectionType?: ConnectionType, convertCustomTypes?: boolean, loggerContext?: LoggingOptions): QueryBuilder<T>;
+    createQueryBuilder<T extends object>(entityName: EntityName<T> | QueryBuilder<T>, ctx?: Transaction<Knex.Transaction>, preferredConnectionType?: ConnectionType, convertCustomTypes?: boolean, loggerContext?: LoggingOptions, alias?: string, em?: SqlEntityManager): QueryBuilder<T>;
     protected resolveConnectionType(args: {
         ctx?: Transaction<Knex.Transaction>;
         connectionType?: ConnectionType;

package/AbstractSqlDriver.js

@@ -321,7 +321,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         await this.processManyToMany(meta, pk, collections, false, options);
         return res;
     }
-    async nativeInsertMany(entityName, data, options = {}) {
+    async nativeInsertMany(entityName, data, options = {}, transform) {
         options.processCollections ??= true;
         options.convertCustomTypes ??= true;
         const meta = this.metadata.find(entityName)?.root;
@@ -340,6 +340,13 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         const tableName = meta ? this.getTableName(meta, options) : this.platform.quoteIdentifier(entityName);
         let sql = `insert into ${tableName} `;
         sql += fields.length > 0 ? '(' + fields.map(k => this.platform.quoteIdentifier(k)).join(', ') + ')' : `(${this.platform.quoteIdentifier(pks[0])})`;
+        if (meta && this.platform.usesOutputStatement()) {
+            const returningProps = meta.props
+                .filter(prop => prop.persist !== false && prop.defaultRaw || prop.autoincrement || prop.generated)
+                .filter(prop => !(prop.name in data[0]) || core_1.Utils.isRawSql(data[0][prop.name]));
+            const returningFields = core_1.Utils.flatten(returningProps.map(prop => prop.fieldNames));
+            sql += returningFields.length > 0 ? ` output ${returningFields.map(field => 'inserted.' + this.platform.quoteIdentifier(field)).join(', ')}` : '';
+        }
         if (fields.length > 0 || this.platform.usesDefaultKeyword()) {
             sql += ' values ';
         }
@@ -406,6 +413,9 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             /* istanbul ignore next */
             sql += returningFields.length > 0 ? ` returning ${returningFields.map(field => this.platform.quoteIdentifier(field)).join(', ')}` : '';
         }
+        if (transform) {
+            sql = transform(sql);
+        }
         const res = await this.execute(sql, params, 'run', options.ctx);
         let pk;
         /* istanbul ignore next */
@@ -943,17 +953,16 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         }
         if (tableAlias) {
             return prop.fieldNames.map(fieldName => {
-                const name = this.platform.quoteIdentifier(`${tableAlias}.${fieldName}`);
-                const alias = this.platform.quoteIdentifier(`${tableAlias}__${fieldName}`);
-                return (0, core_1.raw)(`${name} as ${alias}`);
+                return `${tableAlias}.${fieldName} as ${tableAlias}__${fieldName}`;
             });
         }
         return prop.fieldNames;
     }
     /** @internal */
-    createQueryBuilder(entityName, ctx, preferredConnectionType, convertCustomTypes, loggerContext) {
-        const connectionType = this.resolveConnectionType({ ctx, connectionType: preferredConnectionType });
-        const qb = new query_1.QueryBuilder(entityName, this.metadata, this, ctx, undefined, connectionType, undefined, loggerContext);
+    createQueryBuilder(entityName, ctx, preferredConnectionType, convertCustomTypes, loggerContext, alias, em) {
+        // do not compute the connectionType if EM is provided as it will be computed from it in the QB later on
+        const connectionType = em ? preferredConnectionType : this.resolveConnectionType({ ctx, connectionType: preferredConnectionType });
+        const qb = new query_1.QueryBuilder(entityName, this.metadata, this, ctx, alias, connectionType, em, loggerContext);
         if (!convertCustomTypes) {
             qb.unsetFlag(core_1.QueryFlag.CONVERT_CUSTOM_TYPES);
         }
@@ -963,10 +972,10 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         if (args.ctx) {
             return 'write';
         }
-        else if (args.connectionType) {
+        if (args.connectionType) {
             return args.connectionType;
         }
-        else if (this.config.get('preferReadReplicas') === true) {
+        if (this.config.get('preferReadReplicas')) {
             return 'read';
         }
         return 'write';
@@ -1083,7 +1092,9 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                     continue;
                 }
                 const order = typeof childOrder === 'object' ? childOrder[propName] : childOrder;
-                orderBy.push({ [`${propAlias}.${propName}`]: order });
+                if (order) {
+                    orderBy.push({ [`${propAlias}.${propName}`]: order });
+                }
             }
         }
         return orderBy;

package/MonkeyPatchable.d.ts

@@ -4,8 +4,13 @@ export declare const MonkeyPatchable: {
     MySqlDialect: any;
     MySqlColumnCompiler: any;
     MySqlQueryCompiler: any;
+    MsSqlColumnCompiler: any;
+    MsSqlTableCompiler: any;
+    MsSqlQueryCompiler: any;
+    MsSqlDialect: any;
     PostgresDialectTableCompiler: any;
     Sqlite3Dialect: any;
     Sqlite3DialectTableCompiler: any;
+    BetterSqlite3Dialect: any;
     TableCompiler: any;
 };

package/MonkeyPatchable.js

@@ -15,10 +15,20 @@ const mysql_columncompiler_1 = __importDefault(require("knex/lib/dialects/mysql/
 // @ts-ignore
 const mysql_querycompiler_1 = __importDefault(require("knex/lib/dialects/mysql/query/mysql-querycompiler"));
 // @ts-ignore
+const mssql_columncompiler_1 = __importDefault(require("knex/lib/dialects/mssql/schema/mssql-columncompiler"));
+// @ts-ignore
+const mssql_tablecompiler_1 = __importDefault(require("knex/lib/dialects/mssql/schema/mssql-tablecompiler"));
+// @ts-ignore
+const mssql_querycompiler_1 = __importDefault(require("knex/lib/dialects/mssql/query/mssql-querycompiler"));
+// @ts-ignore
+const mssql_1 = __importDefault(require("knex/lib/dialects/mssql"));
+// @ts-ignore
 const pg_tablecompiler_1 = __importDefault(require("knex/lib/dialects/postgres/schema/pg-tablecompiler"));
 // @ts-ignore
 const sqlite3_1 = __importDefault(require("knex/lib/dialects/sqlite3"));
 // @ts-ignore
+const better_sqlite3_1 = __importDefault(require("knex/lib/dialects/better-sqlite3"));
+// @ts-ignore
 const sqlite_tablecompiler_1 = __importDefault(require("knex/lib/dialects/sqlite3/schema/sqlite-tablecompiler"));
 // @ts-ignore
 const tablecompiler_1 = __importDefault(require("knex/lib/schema/tablecompiler"));
@@ -32,8 +42,13 @@ exports.MonkeyPatchable = {
     MySqlDialect: mysql_1.default,
     MySqlColumnCompiler: mysql_columncompiler_1.default,
     MySqlQueryCompiler: mysql_querycompiler_1.default,
+    MsSqlColumnCompiler: mssql_columncompiler_1.default,
+    MsSqlTableCompiler: mssql_tablecompiler_1.default,
+    MsSqlQueryCompiler: mssql_querycompiler_1.default,
+    MsSqlDialect: mssql_1.default,
     PostgresDialectTableCompiler: pg_tablecompiler_1.default,
     Sqlite3Dialect: sqlite3_1.default,
     Sqlite3DialectTableCompiler: sqlite_tablecompiler_1.default,
+    BetterSqlite3Dialect: better_sqlite3_1.default,
     TableCompiler: tablecompiler_1.default,
 };

package/README.md

@@ -2,7 +2,7 @@
   <a href="https://mikro-orm.io"><img src="https://raw.githubusercontent.com/mikro-orm/mikro-orm/master/docs/static/img/logo-readme.svg?sanitize=true" alt="MikroORM" /></a>
 </h1>
 
-TypeScript ORM for Node.js based on Data Mapper, [Unit of Work](https://mikro-orm.io/docs/unit-of-work/) and [Identity Map](https://mikro-orm.io/docs/identity-map/) patterns. Supports MongoDB, MySQL, MariaDB, PostgreSQL and SQLite databases. 
+TypeScript ORM for Node.js based on Data Mapper, [Unit of Work](https://mikro-orm.io/docs/unit-of-work/) and [Identity Map](https://mikro-orm.io/docs/identity-map/) patterns. Supports MongoDB, MySQL, MariaDB, PostgreSQL and SQLite (including libSQL) databases. 
 
 > Heavily inspired by [Doctrine](https://www.doctrine-project.org/) and [Hibernate](https://hibernate.org/).
 
@@ -175,21 +175,27 @@ First install the module via `yarn` or `npm` and do not forget to install the da
 > Since v4, you should install the driver package, but not the db connector itself, e.g. install `@mikro-orm/sqlite`, but not `sqlite3` as that is already included in the driver package.
 
 ```sh
-yarn add @mikro-orm/core @mikro-orm/mongodb     # for mongo
-yarn add @mikro-orm/core @mikro-orm/mysql       # for mysql/mariadb
-yarn add @mikro-orm/core @mikro-orm/mariadb     # for mysql/mariadb
-yarn add @mikro-orm/core @mikro-orm/postgresql  # for postgresql
-yarn add @mikro-orm/core @mikro-orm/sqlite      # for sqlite
+yarn add @mikro-orm/core @mikro-orm/mongodb       # for mongo
+yarn add @mikro-orm/core @mikro-orm/mysql         # for mysql/mariadb
+yarn add @mikro-orm/core @mikro-orm/mariadb       # for mysql/mariadb
+yarn add @mikro-orm/core @mikro-orm/postgresql    # for postgresql
+yarn add @mikro-orm/core @mikro-orm/mssql         # for mssql
+yarn add @mikro-orm/core @mikro-orm/sqlite        # for sqlite
+yarn add @mikro-orm/core @mikro-orm/better-sqlite # for better-sqlite
+yarn add @mikro-orm/core @mikro-orm/libsql        # for libsql
 ```
 
 or
 
 ```sh
-npm i -s @mikro-orm/core @mikro-orm/mongodb     # for mongo
-npm i -s @mikro-orm/core @mikro-orm/mysql       # for mysql/mariadb
-npm i -s @mikro-orm/core @mikro-orm/mariadb     # for mysql/mariadb
-npm i -s @mikro-orm/core @mikro-orm/postgresql  # for postgresql
-npm i -s @mikro-orm/core @mikro-orm/sqlite      # for sqlite
+npm i -s @mikro-orm/core @mikro-orm/mongodb       # for mongo
+npm i -s @mikro-orm/core @mikro-orm/mysql         # for mysql/mariadb
+npm i -s @mikro-orm/core @mikro-orm/mariadb       # for mysql/mariadb
+npm i -s @mikro-orm/core @mikro-orm/postgresql    # for postgresql
+npm i -s @mikro-orm/core @mikro-orm/mssql         # for mssql
+npm i -s @mikro-orm/core @mikro-orm/sqlite        # for sqlite
+npm i -s @mikro-orm/core @mikro-orm/better-sqlite # for better-sqlite
+npm i -s @mikro-orm/core @mikro-orm/libsql        # for libsql
 ```
 
 Next, if you want to use decorators for your entity definition, you will need to enable support for [decorators](https://www.typescriptlang.org/docs/handbook/decorators.html) as well as `esModuleInterop` in `tsconfig.json` via:

package/SqlEntityManager.d.ts

@@ -1,7 +1,7 @@
 import type { Knex } from 'knex';
 import { EntityManager, type AnyEntity, type ConnectionType, type EntityData, type EntityName, type EntityRepository, type GetRepository, type QueryResult, type FilterQuery, type LoggingOptions } from '@mikro-orm/core';
 import type { AbstractSqlDriver } from './AbstractSqlDriver';
-import { QueryBuilder } from './query';
+import type { QueryBuilder } from './query';
 import type { SqlEntityRepository } from './SqlEntityRepository';
 /**
  * @inheritDoc

package/SqlEntityManager.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SqlEntityManager = void 0;
 const core_1 = require("@mikro-orm/core");
-const query_1 = require("./query");
 /**
  * @inheritDoc
  */
@@ -12,7 +11,7 @@ class SqlEntityManager extends core_1.EntityManager {
      */
     createQueryBuilder(entityName, alias, type, loggerContext) {
         const context = this.getContext(false);
-        return new query_1.QueryBuilder(entityName, this.getMetadata(), this.getDriver(), context.getTransactionContext(), alias, type, context, loggerContext ?? context.loggerContext);
+        return this.driver.createQueryBuilder(entityName, context.getTransactionContext(), type, true, loggerContext ?? context.loggerContext, alias, this);
     }
     /**
      * Shortcut for `createQueryBuilder()`

package/dialects/index.d.ts

@@ -0,0 +1,4 @@
+export * from './mssql';
+export * from './mysql';
+export * from './postgresql';
+export * from './sqlite';

package/dialects/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./mssql"), exports);
+__exportStar(require("./mysql"), exports);
+__exportStar(require("./postgresql"), exports);
+__exportStar(require("./sqlite"), exports);

package/dialects/mssql/MsSqlColumnCompiler.d.ts

@@ -0,0 +1,4 @@
+import { MonkeyPatchable } from '../../MonkeyPatchable';
+export declare class MsSqlColumnCompiler extends MonkeyPatchable.MsSqlColumnCompiler {
+    enu(this: any, allowed: unknown[]): string;
+}

package/dialects/mssql/MsSqlColumnCompiler.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MsSqlColumnCompiler = void 0;
+const MonkeyPatchable_1 = require("../../MonkeyPatchable");
+class MsSqlColumnCompiler extends MonkeyPatchable_1.MonkeyPatchable.MsSqlColumnCompiler {
+    enu(allowed) {
+        return `nvarchar(100) check (${this.formatter.wrap(this.args[0])} in ('${(allowed.join("', '"))}'))`;
+    }
+}
+exports.MsSqlColumnCompiler = MsSqlColumnCompiler;

package/dialects/mssql/MsSqlKnexDialect.d.ts

@@ -0,0 +1,6 @@
+import { MonkeyPatchable } from '../../MonkeyPatchable';
+export declare class MsSqlKnexDialect extends MonkeyPatchable.MsSqlDialect {
+    tableCompiler(): any;
+    columnCompiler(): any;
+    queryCompiler(): any;
+}

package/dialects/mssql/MsSqlKnexDialect.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MsSqlKnexDialect = void 0;
+const MonkeyPatchable_1 = require("../../MonkeyPatchable");
+const MsSqlTableCompiler_1 = require("./MsSqlTableCompiler");
+const MsSqlColumnCompiler_1 = require("./MsSqlColumnCompiler");
+const MsSqlQueryCompiler_1 = require("./MsSqlQueryCompiler");
+class MsSqlKnexDialect extends MonkeyPatchable_1.MonkeyPatchable.MsSqlDialect {
+    tableCompiler() {
+        // eslint-disable-next-line prefer-rest-params
+        return new MsSqlTableCompiler_1.MsSqlTableCompiler(this, ...arguments);
+    }
+    columnCompiler() {
+        // eslint-disable-next-line prefer-rest-params
+        return new MsSqlColumnCompiler_1.MsSqlColumnCompiler(this, ...arguments);
+    }
+    queryCompiler() {
+        // eslint-disable-next-line prefer-rest-params
+        return new MsSqlQueryCompiler_1.MsSqlQueryCompiler(this, ...arguments);
+    }
+}
+exports.MsSqlKnexDialect = MsSqlKnexDialect;

package/dialects/mssql/MsSqlQueryCompiler.d.ts

@@ -0,0 +1,12 @@
+import { MonkeyPatchable } from '../../MonkeyPatchable';
+export declare class MsSqlQueryCompiler extends MonkeyPatchable.MsSqlQueryCompiler {
+    constructor(client: any, builder: any, formatter: any);
+    insert(this: any): any;
+    _mergeAnd(this: any): string;
+    _mergeWhenMatched(this: any, columns: any, updates: any): string;
+    _mergeWhenNotMatched(this: any, columns: any): string;
+    _getParameters(this: any, params: any): any;
+    _mergeInsertIsEmpty(this: any, insert: any): boolean;
+    _mergeOn(this: any, conflict: any): string;
+    _insertWithMerge(this: any): string;
+}

package/dialects/mssql/MsSqlQueryCompiler.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MsSqlQueryCompiler = void 0;
+/* istanbul ignore file */
+const MonkeyPatchable_1 = require("../../MonkeyPatchable");
+const core_1 = require("@mikro-orm/core");
+// upsert support from https://github.com/knex/knex/pull/6050
+class MsSqlQueryCompiler extends MonkeyPatchable_1.MonkeyPatchable.MsSqlQueryCompiler {
+    constructor(client, builder, formatter) {
+        const onConflict = builder._single.onConflict;
+        delete builder._single.onConflict;
+        super(client, builder, formatter);
+        this.single.onConflict = onConflict;
+    }
+    // Compiles an "insert" query, allowing for multiple
+    // inserts using a single query statement.
+    insert() {
+        if (this.single.onConflict) {
+            return this._insertWithMerge();
+        }
+        return super.insert();
+    }
+    _mergeAnd() {
+        const wheres = this.where();
+        if (!wheres) {
+            return '';
+        }
+        return `and ${wheres.slice(6)} `;
+    }
+    _mergeWhenMatched(columns, updates) {
+        let columnsData = [];
+        if (!updates || Array.isArray(updates)) {
+            columnsData = columns
+                .map((column) => `${this.formatter.columnize(column)}=tsource.${this.formatter.columnize(column)}`)
+                .join(', ');
+        }
+        if (typeof updates === 'string') {
+            columnsData = `${this.formatter.columnize(updates)}=tsource.${this.formatter.columnize(updates)}`;
+        }
+        if (!Array.isArray(updates) && typeof updates === 'object') {
+            columnsData = Object.entries(updates)
+                .map(([key, value]) => `${this.tableName}.${this.formatter.columnize(key)}=(${this._getParameters([value])})`);
+        }
+        const sql = ` when matched ${this._mergeAnd()}then update set ${columnsData}`;
+        return sql;
+    }
+    _mergeWhenNotMatched(columns) {
+        const destinationColumns = this.formatter.columnize(columns);
+        const sourceColumns = this.formatter.columnizeWithPrefix('tsource.', columns);
+        const sql = ` when not matched then insert (${destinationColumns}) values (${sourceColumns})`;
+        return sql;
+    }
+    _getParameters(params) {
+        const sql = this.client.parameterize(params, this.client.valueForUndefined, this.builder, this.bindingsHolder);
+        return sql;
+    }
+    _mergeInsertIsEmpty(insert) {
+        return (Array.isArray(insert) && insert.length === 0)
+            || (typeof insert === 'object' && core_1.Utils.isEmpty(insert));
+    }
+    _mergeOn(conflict) {
+        let sql = 'on 1=1';
+        if (Array.isArray(conflict)) {
+            const conflictColumn = this.formatter.columnize(conflict[0]);
+            sql = `on ${this.tableName}.${conflictColumn} = tsource.${conflictColumn}`;
+        }
+        return sql;
+    }
+    _insertWithMerge() {
+        const { insert = [], onConflict, ignore, merge, returning, options = {} } = this.single;
+        if (this._mergeInsertIsEmpty(insert)) {
+            return '';
+        }
+        const insertData = this._prepInsert(insert);
+        const insertParameters = insertData.values.map((value) => `(${this._getParameters(value)})`).join(', ');
+        const sourceColumns = this.formatter.columnize(insertData.columns);
+        const returningSql = returning
+            ? ` ${this._returning('insert', returning, options.includeTriggerModifications)}`
+            : '';
+        let sql = `merge into ${this.tableName} using (values ${insertParameters}) as tsource(${sourceColumns}) `;
+        sql += this._mergeOn(onConflict);
+        sql += this._mergeWhenNotMatched(insertData.columns);
+        if (!ignore) {
+            sql += this._mergeWhenMatched(insertData.columns, merge.updates);
+        }
+        sql += returningSql;
+        if (options.includeTriggerModifications) {
+            sql = this._buildTempTable(returning) + sql + this._buildReturningSelect(returning);
+        }
+        sql = this.with() + sql + ';';
+        return sql;
+    }
+}
+exports.MsSqlQueryCompiler = MsSqlQueryCompiler;

package/dialects/mssql/MsSqlTableCompiler.d.ts

@@ -0,0 +1,9 @@
+import { MonkeyPatchable } from '../../MonkeyPatchable';
+export declare class MsSqlTableCompiler extends MonkeyPatchable.MsSqlTableCompiler {
+    lowerCase: boolean;
+    addColumnsPrefix: string;
+    dropColumnPrefix: string;
+    alterColumnPrefix: string;
+    alterColumns(this: any, columns: any, colBuilder: any): void;
+    dropForeign(this: any, columns: any, constraintName: any): void;
+}

package/dialects/mssql/MsSqlTableCompiler.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MsSqlTableCompiler = void 0;
+const MonkeyPatchable_1 = require("../../MonkeyPatchable");
+class MsSqlTableCompiler extends MonkeyPatchable_1.MonkeyPatchable.MsSqlTableCompiler {
+    lowerCase = true;
+    addColumnsPrefix = 'add ';
+    dropColumnPrefix = 'drop column ';
+    alterColumnPrefix = 'alter column ';
+    alterColumns(columns, colBuilder) {
+        for (let i = 0, l = colBuilder.length; i < l; i++) {
+            const builder = colBuilder[i];
+            if (builder.modified.defaultTo) {
+                const schema = this.schemaNameRaw || 'dbo';
+                const baseQuery = `declare @constraint${i} varchar(100) = (select default_constraints.name from sys.all_columns`
+                    + ' join sys.tables on all_columns.object_id = tables.object_id'
+                    + ' join sys.schemas on tables.schema_id = schemas.schema_id'
+                    + ' join sys.default_constraints on all_columns.default_object_id = default_constraints.object_id'
+                    + ` where schemas.name = '${schema}' and tables.name = '${this.tableNameRaw}' and all_columns.name = '${builder.getColumnName()}')`
+                    + ` if @constraint${i} is not null exec('alter table ${this.tableNameRaw} drop constraint ' + @constraint${i})`;
+                this.pushQuery(baseQuery);
+            }
+        }
+        // in SQL server only one column can be altered at a time
+        columns.sql.forEach((sql) => {
+            this.pushQuery({
+                sql: `alter table ${this.tableName()} ${this.alterColumnPrefix.toLowerCase()}${sql}`,
+                bindings: columns.bindings,
+            });
+        });
+    }
+    dropForeign(columns, constraintName) {
+        /* istanbul ignore next */
+        constraintName = constraintName
+            ? this.formatter.wrap(constraintName)
+            : this._indexCommand('foreign', this.tableNameRaw, columns);
+        this.pushQuery(`alter table ${this.tableName()} drop constraint ${constraintName}`);
+    }
+}
+exports.MsSqlTableCompiler = MsSqlTableCompiler;

package/dialects/mssql/index.d.ts

@@ -0,0 +1 @@
+export * from './MsSqlKnexDialect';

package/dialects/mssql/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./MsSqlKnexDialect"), exports);

package/dialects/mysql/MariaDbKnexDialect.d.ts

@@ -0,0 +1,6 @@
+import { MySqlKnexDialect } from './MySqlKnexDialect';
+export declare class MariaDbKnexDialect extends MySqlKnexDialect {
+    get driverName(): string;
+    _driver(): any;
+    validateConnection(connection: any): any;
+}

package/dialects/mysql/MariaDbKnexDialect.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MariaDbKnexDialect = void 0;
+const MySqlKnexDialect_1 = require("./MySqlKnexDialect");
+class MariaDbKnexDialect extends MySqlKnexDialect_1.MySqlKnexDialect {
+    get driverName() {
+        return 'mariadb';
+    }
+    _driver() {
+        return require('mariadb/callback');
+    }
+    validateConnection(connection) {
+        return connection.isValid();
+    }
+}
+exports.MariaDbKnexDialect = MariaDbKnexDialect;

package/dialects/mysql/MySqlColumnCompiler.d.ts

@@ -0,0 +1,9 @@
+import BaseMySqlColumnCompiler from 'knex/lib/dialects/mysql/schema/mysql-columncompiler';
+export declare class MySqlColumnCompiler extends BaseMySqlColumnCompiler {
+    increments(this: any, options?: {
+        primaryKey: boolean;
+    }): string;
+    bigincrements(this: any, options?: {
+        primaryKey: boolean;
+    }): string;
+}

package/dialects/mysql/MySqlColumnCompiler.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MySqlColumnCompiler = void 0;
+// @ts-ignore
+const mysql_columncompiler_1 = __importDefault(require("knex/lib/dialects/mysql/schema/mysql-columncompiler"));
+class MySqlColumnCompiler extends mysql_columncompiler_1.default {
+    // we need the old behaviour to be able to add auto_increment to a column that is already PK
+    increments(options = { primaryKey: true }) {
+        return 'int unsigned not null auto_increment' + (this.tableCompiler._canBeAddPrimaryKey(options) ? ' primary key' : '');
+    }
+    /* istanbul ignore next */
+    bigincrements(options = { primaryKey: true }) {
+        return 'bigint unsigned not null auto_increment' + (this.tableCompiler._canBeAddPrimaryKey(options) ? ' primary key' : '');
+    }
+}
+exports.MySqlColumnCompiler = MySqlColumnCompiler;

package/dialects/mysql/MySqlConnection.d.ts

@@ -0,0 +1,8 @@
+import type { Knex } from 'knex';
+import { AbstractSqlConnection } from '../../AbstractSqlConnection';
+export declare class MySqlConnection extends AbstractSqlConnection {
+    createKnex(): void;
+    getDefaultClientUrl(): string;
+    getConnectionOptions(): Knex.MySqlConnectionConfig;
+    protected transformRawResult<T>(res: any, method: 'all' | 'get' | 'run'): T;
+}

package/dialects/mysql/MySqlConnection.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MySqlConnection = void 0;
+const MySqlKnexDialect_1 = require("./MySqlKnexDialect");
+const AbstractSqlConnection_1 = require("../../AbstractSqlConnection");
+class MySqlConnection extends AbstractSqlConnection_1.AbstractSqlConnection {
+    createKnex() {
+        this.client = this.createKnexClient(MySqlKnexDialect_1.MySqlKnexDialect);
+        this.connected = true;
+    }
+    getDefaultClientUrl() {
+        return 'mysql://root@127.0.0.1:3306';
+    }
+    getConnectionOptions() {
+        const ret = super.getConnectionOptions();
+        if (this.config.get('multipleStatements')) {
+            ret.multipleStatements = this.config.get('multipleStatements');
+        }
+        if (this.config.get('forceUtcTimezone')) {
+            ret.timezone = 'Z';
+        }
+        if (this.config.get('timezone')) {
+            ret.timezone = this.config.get('timezone');
+        }
+        ret.supportBigNumbers = true;
+        ret.dateStrings = true;
+        return ret;
+    }
+    transformRawResult(res, method) {
+        if (method === 'run' && ['OkPacket', 'ResultSetHeader'].includes(res[0].constructor.name)) {
+            return {
+                insertId: res[0].insertId,
+                affectedRows: res[0].affectedRows,
+                rows: [],
+            };
+        }
+        if (method === 'get') {
+            return res[0][0];
+        }
+        return res[0];
+    }
+}
+exports.MySqlConnection = MySqlConnection;