@mikro-orm/knex 6.4.6-dev.9 → 7.0.0-dev.1

package/schema/SqlSchemaGenerator.js

@@ -52,13 +52,13 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
     }
     async getCreateSchemaSQL(options = {}) {
         const toSchema = this.getTargetSchema(options.schema);
-        let ret = '';
+        const ret = [];
         for (const namespace of toSchema.getNamespaces()) {
             if (namespace === this.platform.getDefaultSchemaName()) {
                 continue;
             }
             const sql = this.helper.getCreateNamespaceSQL(namespace);
-            ret += await this.dump(sql, '\n');
+            this.append(ret, sql);
         }
         if (this.platform.supportsNativeEnums()) {
             const created = [];
@@ -69,14 +69,17 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
                 }
                 created.push(enumName);
                 const sql = this.helper.getCreateNativeEnumSQL(enumOptions.name, enumOptions.items, this.getSchemaName(enumOptions, options));
-                ret += await this.dump(sql, '\n');
+                this.append(ret, sql);
             }
         }
-        for (const tableDef of toSchema.getTables()) {
-            ret += await this.dump(this.helper.createTable(tableDef));
+        for (const table of toSchema.getTables()) {
+            this.append(ret, this.helper.createTable(table), true);
         }
-        for (const tableDef of toSchema.getTables()) {
-            ret += await this.dump(this.helper.createSchemaBuilder(tableDef.schema).alterTable(tableDef.name, table => this.createForeignKeys(table, tableDef, options.schema)));
+        if (this.helper.supportsSchemaConstraints()) {
+            for (const table of toSchema.getTables()) {
+                const fks = Object.values(table.getForeignKeys()).map(fk => this.helper.createForeignKey(table, fk));
+                this.append(ret, fks, true);
+            }
         }
         return this.wrapSchema(ret, options);
     }
@@ -109,6 +112,18 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
                 .truncate();
         }
         await this.execute(this.helper.enableForeignKeysSQL());
+        // const parts: string[] = [this.helper.disableForeignKeysSQL()];
+        //
+        // for (const meta of this.getOrderedMetadata(options?.schema).reverse()) {
+        //   const query = this.driver.createQueryBuilder(meta.className, this.em?.getTransactionContext(), 'write', false)
+        //     .withSchema(options?.schema)
+        //     .truncate()
+        //     .getFormattedQuery();
+        //   parts.push(query);
+        // }
+        //
+        // parts.push(this.helper.enableForeignKeysSQL());
+        // await this.execute(parts.join(';\n'));
         this.clearIdentityMap();
     }
     async getDropSchemaSQL(options = {}) {
@@ -116,37 +131,43 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
         const metadata = this.getOrderedMetadata(options.schema).reverse();
         const schemas = this.getTargetSchema(options.schema).getNamespaces();
         const schema = await DatabaseSchema_1.DatabaseSchema.create(this.connection, this.platform, this.config, options.schema, schemas);
-        let ret = '';
-        // remove FKs explicitly if we can't use cascading statement and we don't disable FK checks (we need this for circular relations)
+        const ret = [];
+        // remove FKs explicitly if we can't use a cascading statement and we don't disable FK checks (we need this for circular relations)
         for (const meta of metadata) {
-            const table = schema.getTable(meta.tableName);
-            if (!this.platform.usesCascadeStatement() && table && (!this.options.disableForeignKeys || options.dropForeignKeys)) {
-                for (const fk of Object.values(table.getForeignKeys())) {
-                    const builder = this.helper.createSchemaBuilder(table.schema).alterTable(table.name, tbl => {
-                        tbl.dropForeign(fk.columnNames, fk.constraintName);
-                    });
-                    ret += await this.dump(builder, '\n');
+            if (!this.platform.usesCascadeStatement() && (!this.options.disableForeignKeys || options.dropForeignKeys)) {
+                const table = schema.getTable(meta.tableName);
+                if (!table) {
+                    continue;
+                }
+                const foreignKeys = Object.values(table.getForeignKeys());
+                for (const fk of foreignKeys) {
+                    this.append(ret, this.helper.dropForeignKey(table.getShortestName(), fk.constraintName));
                 }
             }
         }
         for (const meta of metadata) {
-            ret += await this.dump(this.dropTable(meta.collection, this.getSchemaName(meta, options)), '\n');
+            this.append(ret, this.helper.dropTableIfExists(meta.tableName, this.getSchemaName(meta, options)));
         }
         if (this.platform.supportsNativeEnums()) {
             for (const columnName of Object.keys(schema.getNativeEnums())) {
                 const sql = this.helper.getDropNativeEnumSQL(columnName, options.schema ?? this.config.get('schema'));
-                ret += await this.dump(sql, '\n');
+                this.append(ret, sql);
             }
         }
         if (options.dropMigrationsTable) {
-            ret += await this.dump(this.dropTable(this.config.get('migrations').tableName, this.config.get('schema')), '\n');
+            this.append(ret, this.helper.dropTableIfExists(this.config.get('migrations').tableName, this.config.get('schema')));
         }
-        return this.wrapSchema(ret + '\n', options);
+        return this.wrapSchema(ret, options);
     }
     getSchemaName(meta, options) {
         const schemaName = options.schema ?? this.config.get('schema');
         /* istanbul ignore next */
-        return meta.schema && meta.schema === '*' ? schemaName : (meta.schema ?? schemaName);
+        const resolvedName = meta.schema && meta.schema === '*' ? schemaName : (meta.schema ?? schemaName);
+        // skip default schema name
+        if (resolvedName === this.platform.getDefaultSchemaName()) {
+            return undefined;
+        }
+        return resolvedName;
     }
     async updateSchema(options = {}) {
         const sql = await this.getUpdateSchemaSQL(options);
@@ -168,8 +189,8 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
         const diffUp = comparator.compare(fromSchema, toSchema);
         const diffDown = comparator.compare(toSchema, fromSchema, diffUp);
         return {
-            up: await this.diffToSQL(diffUp, options),
-            down: this.platform.supportsDownMigrations() ? await this.diffToSQL(diffDown, options) : '',
+            up: this.diffToSQL(diffUp, options),
+            down: this.platform.supportsDownMigrations() ? this.diffToSQL(diffDown, options) : '',
         };
     }
     async prepareSchemaForComparison(options) {
@@ -183,70 +204,74 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
         toSchema.prune(options.schema, wildcardSchemaTables);
         return { fromSchema, toSchema };
     }
-    async diffToSQL(schemaDiff, options) {
-        let ret = '';
+    diffToSQL(schemaDiff, options) {
+        const ret = [];
+        globalThis.idx = 0;
         if (this.platform.supportsSchemas()) {
             for (const newNamespace of schemaDiff.newNamespaces) {
                 const sql = this.helper.getCreateNamespaceSQL(newNamespace);
-                ret += await this.dump(sql, '\n');
+                this.append(ret, sql);
             }
         }
         if (this.platform.supportsNativeEnums()) {
             for (const newNativeEnum of schemaDiff.newNativeEnums) {
                 const sql = this.helper.getCreateNativeEnumSQL(newNativeEnum.name, newNativeEnum.items, this.getSchemaName(newNativeEnum, options));
-                ret += await this.dump(sql, '\n');
+                this.append(ret, sql);
             }
         }
         if (!options.safe && this.options.createForeignKeyConstraints) {
             for (const orphanedForeignKey of schemaDiff.orphanedForeignKeys) {
-                const [schemaName, tableName] = this.helper.splitTableName(orphanedForeignKey.localTableName);
-                ret += await this.dump(this.helper.createSchemaBuilder(schemaName).alterTable(tableName, table => {
-                    return table.dropForeign(orphanedForeignKey.columnNames, orphanedForeignKey.constraintName);
-                }));
+                const [schemaName, tableName] = this.helper.splitTableName(orphanedForeignKey.localTableName, true);
+                /* istanbul ignore if */
+                const name = (schemaName ? schemaName + '.' : '') + tableName;
+                this.append(ret, this.helper.dropForeignKey(name, orphanedForeignKey.constraintName));
+            }
+            if (schemaDiff.orphanedForeignKeys.length > 0) {
+                ret.push('');
             }
         }
         for (const newTable of Object.values(schemaDiff.newTables)) {
-            ret += await this.dump(this.helper.createTable(newTable, true));
-        }
-        for (const newTable of Object.values(schemaDiff.newTables)) {
-            ret += await this.dump(this.helper.createSchemaBuilder(newTable.schema).alterTable(newTable.name, table => {
-                this.createForeignKeys(table, newTable, options.schema);
-            }));
+            this.append(ret, this.helper.createTable(newTable, true), true);
+        }
+        if (this.helper.supportsSchemaConstraints()) {
+            for (const newTable of Object.values(schemaDiff.newTables)) {
+                const sql = [];
+                if (this.options.createForeignKeyConstraints) {
+                    const fks = Object.values(newTable.getForeignKeys()).map(fk => this.helper.createForeignKey(newTable, fk));
+                    this.append(sql, fks);
+                }
+                for (const check of newTable.getChecks()) {
+                    this.append(sql, this.helper.createCheck(newTable, check));
+                }
+                this.append(ret, sql, true);
+            }
         }
         if (options.dropTables && !options.safe) {
             for (const table of Object.values(schemaDiff.removedTables)) {
-                ret += await this.dump(this.dropTable(table.name, table.schema));
+                this.append(ret, this.helper.dropTableIfExists(table.name, table.schema));
+            }
+            if (core_1.Utils.hasObjectKeys(schemaDiff.removedTables)) {
+                ret.push('');
             }
         }
         for (const changedTable of Object.values(schemaDiff.changedTables)) {
-            for (const builder of this.preAlterTable(changedTable, options.safe)) {
-                ret += await this.dump(builder);
-            }
+            this.append(ret, this.preAlterTable(changedTable, options.safe), true);
         }
         for (const changedTable of Object.values(schemaDiff.changedTables)) {
-            for (const builder of this.alterTable(changedTable, options.safe)) {
-                let diff = await this.dump(builder);
-                if (diff.includes('CREATE TABLE `_knex_temp_alter') && this.helper.getAlterTable) {
-                    diff = await this.helper.getAlterTable(changedTable, options.wrap);
-                }
-                ret += diff;
-            }
+            this.append(ret, this.helper.alterTable(changedTable, options.safe), true);
         }
         for (const changedTable of Object.values(schemaDiff.changedTables)) {
-            for (const builder of this.postAlterTable(changedTable, options.safe)) {
-                ret += await this.dump(builder);
-            }
+            this.append(ret, this.helper.getPostAlterTable(changedTable, options.safe), true);
         }
         if (!options.safe && this.platform.supportsNativeEnums()) {
             for (const removedNativeEnum of schemaDiff.removedNativeEnums) {
-                const sql = this.helper.getDropNativeEnumSQL(removedNativeEnum.name, removedNativeEnum.schema);
-                ret += await this.dump(sql, '\n');
+                this.append(ret, this.helper.getDropNativeEnumSQL(removedNativeEnum.name, removedNativeEnum.schema));
             }
         }
         if (options.dropTables && !options.safe) {
             for (const removedNamespace of schemaDiff.removedNamespaces) {
                 const sql = this.helper.getDropNamespaceSQL(removedNamespace);
-                ret += await this.dump(sql, '\n');
+                this.append(ret, sql);
             }
         }
         return this.wrapSchema(ret, options);
@@ -256,144 +281,13 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
      */
     preAlterTable(diff, safe) {
         const ret = [];
-        const push = (sql) => sql ? ret.push(this.knex.schema.raw(sql)) : undefined;
-        push(this.helper.getPreAlterTable(diff, safe));
-        const [schemaName, tableName] = this.helper.splitTableName(diff.name);
-        ret.push(this.helper.createSchemaBuilder(schemaName).alterTable(tableName, table => {
-            for (const foreignKey of Object.values(diff.removedForeignKeys)) {
-                table.dropForeign(foreignKey.columnNames, foreignKey.constraintName);
-            }
-            for (const foreignKey of Object.values(diff.changedForeignKeys)) {
-                table.dropForeign(foreignKey.columnNames, foreignKey.constraintName);
-            }
-        }));
-        return ret;
-    }
-    postAlterTable(diff, safe) {
-        const ret = [];
-        const push = (sql) => sql ? ret.push(this.knex.schema.raw(sql)) : undefined;
-        push(this.helper.getPostAlterTable(diff, safe));
-        return ret;
-    }
-    alterTable(diff, safe) {
-        const ret = [];
-        const [schemaName, tableName] = this.helper.splitTableName(diff.name);
-        if (this.platform.supportsNativeEnums()) {
-            const changedNativeEnums = [];
-            for (const { column, changedProperties } of Object.values(diff.changedColumns)) {
-                if (!column.nativeEnumName) {
-                    continue;
-                }
-                const key = schemaName && schemaName !== this.platform.getDefaultSchemaName() && !column.nativeEnumName.includes('.')
-                    ? schemaName + '.' + column.nativeEnumName
-                    : column.nativeEnumName;
-                if (changedProperties.has('enumItems') && key in diff.fromTable.nativeEnums) {
-                    changedNativeEnums.push([column.nativeEnumName, column.enumItems, diff.fromTable.nativeEnums[key].items]);
-                }
-            }
-            core_1.Utils.removeDuplicates(changedNativeEnums).forEach(([enumName, itemsNew, itemsOld]) => {
-                // postgres allows only adding new items, the values are case insensitive
-                itemsOld = itemsOld.map(v => v.toLowerCase());
-                const newItems = itemsNew.filter(val => !itemsOld.includes(val.toLowerCase()));
-                if (enumName.includes('.')) {
-                    const [enumSchemaName, rawEnumName] = enumName.split('.');
-                    ret.push(...newItems.map(val => this.knex.schema.raw(this.helper.getAlterNativeEnumSQL(rawEnumName, enumSchemaName, val, itemsNew, itemsOld))));
-                    return;
-                }
-                ret.push(...newItems.map(val => this.knex.schema.raw(this.helper.getAlterNativeEnumSQL(enumName, schemaName, val, itemsNew, itemsOld))));
-            });
+        this.append(ret, this.helper.getPreAlterTable(diff, safe));
+        for (const foreignKey of Object.values(diff.removedForeignKeys)) {
+            ret.push(this.helper.dropForeignKey(diff.toTable.getShortestName(), foreignKey.constraintName));
+        }
+        for (const foreignKey of Object.values(diff.changedForeignKeys)) {
+            ret.push(this.helper.dropForeignKey(diff.toTable.getShortestName(), foreignKey.constraintName));
         }
-        ret.push(this.helper.createSchemaBuilder(schemaName).alterTable(tableName, table => {
-            for (const index of Object.values(diff.removedIndexes)) {
-                this.dropIndex(table, index);
-            }
-            for (const index of Object.values(diff.changedIndexes)) {
-                this.dropIndex(table, index);
-            }
-            for (const check of Object.values(diff.removedChecks)) {
-                this.dropCheck(table, check);
-            }
-            for (const check of Object.values(diff.changedChecks)) {
-                this.dropCheck(table, check);
-            }
-            /* istanbul ignore else */
-            if (!safe && Object.values(diff.removedColumns).length > 0) {
-                this.helper.pushTableQuery(table, this.helper.getDropColumnsSQL(tableName, Object.values(diff.removedColumns), schemaName));
-            }
-        }));
-        ret.push(this.helper.createSchemaBuilder(schemaName).alterTable(tableName, table => {
-            for (const column of Object.values(diff.addedColumns)) {
-                const col = this.helper.createTableColumn(table, column, diff.fromTable, undefined, true);
-                this.helper.configureColumn(column, col, this.knex);
-                const foreignKey = Object.values(diff.addedForeignKeys).find(fk => fk.columnNames.length === 1 && fk.columnNames[0] === column.name);
-                if (foreignKey && this.options.createForeignKeyConstraints) {
-                    delete diff.addedForeignKeys[foreignKey.constraintName];
-                    const builder = col.references(foreignKey.referencedColumnNames[0])
-                        .inTable(this.helper.getReferencedTableName(foreignKey.referencedTableName))
-                        .withKeyName(foreignKey.constraintName)
-                        .onUpdate(foreignKey.updateRule)
-                        .onDelete(foreignKey.deleteRule);
-                    if (foreignKey.deferMode) {
-                        builder.deferrable(foreignKey.deferMode);
-                    }
-                }
-            }
-            for (const { column, changedProperties } of Object.values(diff.changedColumns)) {
-                if (changedProperties.size === 1 && changedProperties.has('comment')) {
-                    continue;
-                }
-                if (changedProperties.size === 1 && changedProperties.has('enumItems') && column.nativeEnumName) {
-                    continue;
-                }
-                const col = this.helper.createTableColumn(table, column, diff.fromTable, changedProperties, true)?.alter();
-                if (col) {
-                    this.helper.configureColumn(column, col, this.knex, changedProperties);
-                }
-            }
-            for (const { column } of Object.values(diff.changedColumns).filter(diff => diff.changedProperties.has('autoincrement'))) {
-                this.helper.pushTableQuery(table, this.helper.getAlterColumnAutoincrement(tableName, column, schemaName));
-            }
-            for (const { column, changedProperties } of Object.values(diff.changedColumns).filter(diff => diff.changedProperties.has('comment'))) {
-                if (['type', 'nullable', 'autoincrement', 'unsigned', 'default', 'enumItems'].some(t => changedProperties.has(t))) {
-                    continue; // will be handled via knex
-                }
-                this.helper.pushTableQuery(table, this.helper.getChangeColumnCommentSQL(tableName, column, schemaName));
-            }
-            for (const [oldColumnName, column] of Object.entries(diff.renamedColumns)) {
-                this.helper.pushTableQuery(table, this.helper.getRenameColumnSQL(tableName, oldColumnName, column, schemaName));
-            }
-            for (const foreignKey of Object.values(diff.addedForeignKeys)) {
-                this.helper.createForeignKey(table, foreignKey, undefined);
-            }
-            for (const foreignKey of Object.values(diff.changedForeignKeys)) {
-                this.helper.createForeignKey(table, foreignKey, undefined);
-            }
-            for (const index of Object.values(diff.addedIndexes)) {
-                this.helper.createIndex(table, index, diff.toTable);
-            }
-            for (const index of Object.values(diff.changedIndexes)) {
-                this.helper.createIndex(table, index, diff.toTable, true);
-            }
-            for (const [oldIndexName, index] of Object.entries(diff.renamedIndexes)) {
-                if (index.unique) {
-                    this.dropIndex(table, index, oldIndexName);
-                    this.helper.createIndex(table, index, diff.toTable);
-                }
-                else {
-                    this.helper.pushTableQuery(table, this.helper.getRenameIndexSQL(diff.name, index, oldIndexName));
-                }
-            }
-            for (const check of Object.values(diff.addedChecks)) {
-                this.helper.createCheck(table, check);
-            }
-            for (const check of Object.values(diff.changedChecks)) {
-                this.helper.createCheck(table, check);
-            }
-            if ('changedComment' in diff) {
-                const comment = diff.changedComment ? this.platform.quoteValue(diff.changedComment).replace(/^'|'$/g, '') : '';
-                table.comment(comment);
-            }
-        }));
         return ret;
     }
     /**
@@ -401,8 +295,9 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
      */
     async createDatabase(name) {
         name ??= this.config.get('dbName');
-        const sql = this.helper.getCreateDatabaseSQL('' + this.knex.ref(name));
+        const sql = this.helper.getCreateDatabaseSQL('' + this.platform.quoteIdentifier(name));
         if (sql) {
+            // console.log(sql);
             await this.execute(sql);
         }
         this.config.set('dbName', name);
@@ -436,55 +331,36 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
         if (this.platform.supportsMultipleStatements()) {
             for (const group of groups) {
                 const query = group.join('\n');
+                // console.log(query);
                 await this.driver.execute(query);
             }
             return;
         }
+        // console.log(groups);
         await core_1.Utils.runSerial(groups.flat(), line => this.driver.execute(line));
     }
+    async dropTableIfExists(name, schema) {
+        const sql = this.helper.dropTableIfExists(name, schema);
+        return this.execute(sql);
+    }
     wrapSchema(sql, options) {
-        if (options.wrap === false || sql.trim() === '') {
-            return sql;
+        const array = core_1.Utils.asArray(sql);
+        if (array.length === 0) {
+            return '';
+        }
+        if (array[array.length - 1] === '') {
+            array.pop();
+        }
+        if (options.wrap === false) {
+            return array.join('\n') + '\n';
         }
         let ret = this.helper.getSchemaBeginning(this.config.get('charset'), this.options.disableForeignKeys);
-        ret += sql;
+        ret += array.join('\n') + '\n';
         ret += this.helper.getSchemaEnd(this.options.disableForeignKeys);
         return ret;
     }
-    dropIndex(table, index, oldIndexName = index.keyName) {
-        if (index.primary) {
-            table.dropPrimary(oldIndexName);
-        }
-        else if (index.unique && index.constraint) {
-            table.dropUnique(index.columnNames, oldIndexName);
-        }
-        else {
-            table.dropIndex(index.columnNames, oldIndexName);
-        }
-    }
-    dropCheck(table, check) {
-        table.dropChecks(check.name);
-    }
-    dropTable(name, schema) {
-        let builder = this.helper.createSchemaBuilder(schema).dropTableIfExists(name);
-        if (this.platform.usesCascadeStatement()) {
-            builder = this.knex.schema.raw(builder.toQuery() + ' cascade');
-        }
-        return builder;
-    }
-    createForeignKeys(table, tableDef, schema) {
-        if (!this.helper.supportsSchemaConstraints()) {
-            return;
-        }
-        for (const fk of Object.values(tableDef.getForeignKeys())) {
-            this.helper.createForeignKey(table, fk, schema);
-        }
-    }
-    async dump(builder, append = '\n\n') {
-        return this.helper.dump(builder, append);
-    }
-    get knex() {
-        return this.connection.getKnex();
+    append(array, sql, pad) {
+        return this.helper.append(array, sql, pad);
     }
 }
 exports.SqlSchemaGenerator = SqlSchemaGenerator;

package/typings.d.ts

@@ -1,17 +1,15 @@
 import type { DeferMode, CheckCallback, Dictionary, EntityProperty, GroupOperator, RawQueryFragment, QBFilterQuery, QueryOrderMap, Type, QueryFlag, AnyEntity, EntityName } from '@mikro-orm/core';
-import type { Knex } from 'knex';
 import type { JoinType, QueryType } from './query/enums';
 import type { DatabaseSchema, DatabaseTable } from './schema';
+import type { QueryBuilder } from './query/QueryBuilder';
+import type { NativeQueryBuilder } from './query/NativeQueryBuilder';
 export interface Table {
     table_name: string;
     schema_name?: string;
     table_comment?: string;
 }
-export type KnexStringRef = Knex.Ref<string, {
-    [alias: string]: string;
-}>;
 type AnyString = string & {};
-export type Field<T> = AnyString | keyof T | RawQueryFragment | KnexStringRef | Knex.QueryBuilder;
+export type Field<T> = AnyString | keyof T | RawQueryFragment | QueryBuilder | NativeQueryBuilder;
 export interface JoinOptions {
     table: string;
     schema?: string;
@@ -40,6 +38,7 @@ export interface Column {
     precision?: number;
     scale?: number;
     default?: string | null;
+    defaultConstraint?: string;
     comment?: string;
     generated?: string;
     nativeEnumName?: string;
@@ -72,7 +71,7 @@ export interface IndexDef {
     type?: string | Readonly<{
         indexType?: string;
         storageEngineIndexType?: 'hash' | 'btree';
-        predicate?: Knex.QueryBuilder;
+        predicate?: string;
     }>;
     deferMode?: DeferMode;
 }
@@ -128,7 +127,7 @@ export interface SchemaDifference {
 }
 export interface IQueryBuilder<T> {
     readonly alias: string;
-    readonly type?: QueryType;
+    readonly type: QueryType;
     _fields?: Field<T>[];
     /** @internal */
     helper: any;
@@ -146,7 +145,7 @@ export interface IQueryBuilder<T> {
     joinAndSelect(field: string, alias: string, cond?: QBFilterQuery): this;
     leftJoinAndSelect(field: string, alias: string, cond?: QBFilterQuery, fields?: string[]): this;
     innerJoinAndSelect(field: string, alias: string, cond?: QBFilterQuery, fields?: string[]): this;
-    withSubQuery(subQuery: Knex.QueryBuilder, alias: string): this;
+    withSubQuery(subQuery: RawQueryFragment | NativeQueryBuilder, alias: string): this;
     where(cond: QBFilterQuery<T>, operator?: keyof typeof GroupOperator): this;
     where(cond: string, params?: any[], operator?: keyof typeof GroupOperator): this;
     andWhere(cond: QBFilterQuery<T>): this;
@@ -185,13 +184,4 @@ export interface ICriteriaNode<T extends object> {
     getPath(addIndex?: boolean): string;
     getPivotPath(path: string): string;
 }
-export type MySqlIncrementOptions = {
-    primaryKey?: boolean;
-    unsigned?: boolean;
-    type?: Column['type'];
-};
-export interface MySqlTableBuilder extends Knex.TableBuilder {
-    increments(columnName?: string, options?: MySqlIncrementOptions): Knex.ColumnBuilder;
-    bigIncrements(columnName?: string, options?: MySqlIncrementOptions): Knex.ColumnBuilder;
-}
 export {};

package/MonkeyPatchable.d.ts

@@ -1,18 +0,0 @@
-export declare const MonkeyPatchable: {
-    Client: any;
-    QueryExecutioner: any;
-    MySqlDialect: any;
-    MySqlColumnCompiler: any;
-    MySqlQueryCompiler: any;
-    MsSqlColumnCompiler: any;
-    MsSqlTableCompiler: any;
-    MsSqlQueryCompiler: any;
-    MsSqlDialect: any;
-    PostgresDialect: any;
-    PostgresDialectTableCompiler: any;
-    PostgresQueryCompiler: any;
-    Sqlite3Dialect: any;
-    Sqlite3DialectTableCompiler: any;
-    BetterSqlite3Dialect: any;
-    TableCompiler: any;
-};

package/MonkeyPatchable.js

@@ -1,60 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MonkeyPatchable = void 0;
-// @ts-ignore
-const client_1 = __importDefault(require("knex/lib/client"));
-// @ts-ignore
-const query_executioner_1 = __importDefault(require("knex/lib/execution/internal/query-executioner"));
-// @ts-ignore
-const mysql2_1 = __importDefault(require("knex/lib/dialects/mysql2"));
-// @ts-ignore
-const mysql_columncompiler_1 = __importDefault(require("knex/lib/dialects/mysql/schema/mysql-columncompiler"));
-// @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 postgres_1 = __importDefault(require("knex/lib/dialects/postgres"));
-// @ts-ignore
-const pg_tablecompiler_1 = __importDefault(require("knex/lib/dialects/postgres/schema/pg-tablecompiler"));
-// @ts-ignore
-const pg_querycompiler_1 = __importDefault(require("knex/lib/dialects/postgres/query/pg-querycompiler"));
-// @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"));
-// These specific portions of knex are overridden by the different
-// database packages. We need to be sure the knex files they get to
-// monkey patch are the same version as our overall knex instance
-// which is why we need to import them in this package.
-exports.MonkeyPatchable = {
-    Client: client_1.default,
-    QueryExecutioner: query_executioner_1.default,
-    MySqlDialect: mysql2_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,
-    PostgresDialect: postgres_1.default,
-    PostgresDialectTableCompiler: pg_tablecompiler_1.default,
-    PostgresQueryCompiler: pg_querycompiler_1.default,
-    Sqlite3Dialect: sqlite3_1.default,
-    Sqlite3DialectTableCompiler: sqlite_tablecompiler_1.default,
-    BetterSqlite3Dialect: better_sqlite3_1.default,
-    TableCompiler: tablecompiler_1.default,
-};

package/dialects/mssql/MsSqlColumnCompiler.d.ts

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

package/dialects/mssql/MsSqlColumnCompiler.js

@@ -1,10 +0,0 @@
-"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

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