@mikro-orm/knex 6.0.0-dev.4 → 6.0.0-dev.40

package/{dist/schema → schema}/SchemaHelper.js

@@ -24,25 +24,51 @@ class SchemaHelper {
     supportsSchemaConstraints() {
         return true;
     }
-    async getPrimaryKeys(connection, indexes, tableName, schemaName) {
-        const pk = indexes.find(i => i.primary);
-        return pk ? pk.columnNames : [];
+    async getPrimaryKeys(connection, indexes = [], tableName, schemaName) {
+        const pks = indexes.filter(i => i.primary).map(pk => pk.columnNames);
+        return core_1.Utils.flatten(pks);
     }
     async getForeignKeys(connection, tableName, schemaName) {
         const fks = await connection.execute(this.getForeignKeysSQL(tableName, schemaName));
         return this.mapForeignKeys(fks, tableName, schemaName);
     }
+    getTableKey(t) {
+        const unquote = (str) => str.replace(/['"`]/g, '');
+        const parts = t.table_name.split('.');
+        if (parts.length > 1) {
+            return `${unquote(parts[0])}.${unquote(parts[1])}`;
+        }
+        if (t.schema_name) {
+            return `${unquote(t.schema_name)}.${unquote(t.table_name)}`;
+        }
+        return unquote(t.table_name);
+    }
     async getEnumDefinitions(connection, checks, tableName, schemaName) {
         return {};
     }
+    async loadInformationSchema(schema, connection, tables) {
+        for (const t of tables) {
+            const table = schema.addTable(t.table_name, t.schema_name);
+            table.comment = t.table_comment;
+            const cols = await this.getColumns(connection, table.name, table.schema);
+            const indexes = await this.getIndexes(connection, table.name, table.schema);
+            const checks = await this.getChecks(connection, table.name, table.schema, cols);
+            const pks = await this.getPrimaryKeys(connection, indexes, table.name, table.schema);
+            const fks = await this.getForeignKeys(connection, table.name, table.schema);
+            const enums = await this.getEnumDefinitions(connection, checks, table.name, table.schema);
+            table.init(cols, indexes, checks, pks, fks, enums);
+        }
+    }
     getListTablesSQL(schemaName) {
         throw new Error('Not supported by given driver');
     }
-    getRenameColumnSQL(tableName, oldColumnName, to) {
+    getRenameColumnSQL(tableName, oldColumnName, to, schemaName) {
         tableName = this.platform.quoteIdentifier(tableName);
         oldColumnName = this.platform.quoteIdentifier(oldColumnName);
         const columnName = this.platform.quoteIdentifier(to.name);
-        return `alter table ${tableName} rename column ${oldColumnName} to ${columnName}`;
+        const schemaReference = (schemaName !== undefined && schemaName !== 'public') ? ('"' + schemaName + '".') : '';
+        const tableReference = schemaReference + tableName;
+        return `alter table ${tableReference} rename column ${oldColumnName} to ${columnName}`;
     }
     getCreateIndexSQL(tableName, index) {
         /* istanbul ignore if */
@@ -59,13 +85,22 @@ class SchemaHelper {
     getRenameIndexSQL(tableName, index, oldIndexName) {
         return [this.getDropIndexSQL(tableName, { ...index, keyName: oldIndexName }), this.getCreateIndexSQL(tableName, index)].join(';\n');
     }
+    hasNonDefaultPrimaryKeyName(table) {
+        const pkIndex = table.getPrimaryKey();
+        if (!pkIndex || !this.platform.supportsCustomPrimaryKeyNames()) {
+            return false;
+        }
+        const defaultName = this.platform.getDefaultPrimaryName(table.name, pkIndex.columnNames);
+        return pkIndex?.keyName !== defaultName;
+    }
     createTableColumn(table, column, fromTable, changedProperties) {
         const compositePK = fromTable.getPrimaryKey()?.composite;
         if (column.autoincrement && !compositePK && (!changedProperties || changedProperties.has('autoincrement') || changedProperties.has('type'))) {
+            const primaryKey = !changedProperties && !this.hasNonDefaultPrimaryKeyName(fromTable);
             if (column.mappedType instanceof core_1.BigIntType) {
-                return table.bigIncrements(column.name, { primaryKey: !changedProperties });
+                return table.bigIncrements(column.name, { primaryKey });
             }
-            return table.increments(column.name, { primaryKey: !changedProperties });
+            return table.increments(column.name, { primaryKey });
         }
         if (column.mappedType instanceof core_1.EnumType && column.enumItems?.every(item => core_1.Utils.isString(item))) {
             return table.enum(column.name, column.enumItems);
@@ -100,13 +135,16 @@ class SchemaHelper {
     getChangeColumnCommentSQL(tableName, to) {
         return '';
     }
+    async getNamespaces(connection) {
+        return [];
+    }
     async getColumns(connection, tableName, schemaName) {
         throw new Error('Not supported by given driver');
     }
     async getIndexes(connection, tableName, schemaName) {
         throw new Error('Not supported by given driver');
     }
-    async getChecks(connection, tableName, schemaName) {
+    async getChecks(connection, tableName, schemaName, columns) {
         throw new Error('Not supported by given driver');
     }
     async mapIndexes(indexes) {

package/{dist/schema/SchemaGenerator.d.ts → schema/SqlSchemaGenerator.d.ts}

@@ -1,20 +1,13 @@
+import type { MikroORM, ISchemaGenerator } from '@mikro-orm/core';
 import { AbstractSchemaGenerator } from '@mikro-orm/core';
 import type { SchemaDifference } from '../typings';
 import { DatabaseSchema } from './DatabaseSchema';
 import type { AbstractSqlDriver } from '../AbstractSqlDriver';
-import { SqlEntityManager } from '../SqlEntityManager';
-/**
- * Should be renamed to `SqlSchemaGenerator` in v6
- */
-export declare class SchemaGenerator extends AbstractSchemaGenerator<AbstractSqlDriver> {
+export declare class SqlSchemaGenerator extends AbstractSchemaGenerator<AbstractSqlDriver> implements ISchemaGenerator {
     private readonly helper;
-    private readonly knex;
     private readonly options;
-    /**
-     * @deprecated For back compatibility, we also support EM as the parameter.
-     */
-    constructor(em: SqlEntityManager);
-    generate(): Promise<string>;
+    protected lastEnsuredDatabase?: string;
+    static register(orm: MikroORM): void;
     createSchema(options?: {
         wrap?: boolean;
         schema?: string;
@@ -34,6 +27,10 @@ export declare class SchemaGenerator extends AbstractSchemaGenerator<AbstractSql
         dropDb?: boolean;
         schema?: string;
     }): Promise<void>;
+    clearDatabase(options?: {
+        schema?: string;
+        truncate?: boolean;
+    }): Promise<void>;
     getDropSchemaSQL(options?: {
         wrap?: boolean;
         dropMigrationsTable?: boolean;
@@ -95,7 +92,8 @@ export declare class SchemaGenerator extends AbstractSchemaGenerator<AbstractSql
     private createCheck;
     private dropCheck;
     private dropTable;
-    private configureColumn;
     private createForeignKeys;
     private dump;
+    private get knex();
 }
+export { SqlSchemaGenerator as SchemaGenerator };

package/{dist/schema/SchemaGenerator.js → schema/SqlSchemaGenerator.js}

@@ -1,29 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SchemaGenerator = void 0;
+exports.SchemaGenerator = exports.SqlSchemaGenerator = void 0;
 const core_1 = require("@mikro-orm/core");
 const DatabaseSchema_1 = require("./DatabaseSchema");
 const SchemaComparator_1 = require("./SchemaComparator");
-const SqlEntityManager_1 = require("../SqlEntityManager");
-/**
- * Should be renamed to `SqlSchemaGenerator` in v6
- */
-class SchemaGenerator extends core_1.AbstractSchemaGenerator {
-    /**
-     * `orm.getSchemaGenerator()` should be preferred way of getting the SchemaGenerator instance.
-     */
-    constructor(driver) {
-        super(driver instanceof SqlEntityManager_1.SqlEntityManager ? driver.getDriver() : driver);
+class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
+    constructor() {
+        super(...arguments);
         this.helper = this.platform.getSchemaHelper();
-        this.knex = this.connection.getKnex();
         this.options = this.config.get('schemaGenerator');
     }
-    async generate() {
-        const [dropSchema, createSchema] = await Promise.all([
-            this.getDropSchemaSQL({ wrap: false }),
-            this.getCreateSchemaSQL({ wrap: false }),
-        ]);
-        return this.wrapSchema(dropSchema + createSchema);
+    static register(orm) {
+        orm.config.registerExtension('@mikro-orm/schema-generator', () => new SqlSchemaGenerator(orm.em));
     }
     async createSchema(options) {
         await this.ensureDatabase();
@@ -35,7 +23,11 @@ class SchemaGenerator extends core_1.AbstractSchemaGenerator {
      */
     async ensureDatabase() {
         const dbName = this.config.get('dbName');
+        if (this.lastEnsuredDatabase === dbName) {
+            return true;
+        }
         const exists = await this.helper.databaseExists(this.connection, dbName);
+        this.lastEnsuredDatabase = dbName;
         if (!exists) {
             this.config.set('dbName', this.helper.getManagementDbName());
             await this.driver.reconnect();
@@ -48,7 +40,8 @@ class SchemaGenerator extends core_1.AbstractSchemaGenerator {
     }
     getTargetSchema(schema) {
         const metadata = this.getOrderedMetadata(schema);
-        return DatabaseSchema_1.DatabaseSchema.fromMetadata(metadata, this.platform, this.config, schema ?? this.platform.getDefaultSchemaName());
+        const schemaName = schema ?? this.config.get('schema') ?? this.platform.getDefaultSchemaName();
+        return DatabaseSchema_1.DatabaseSchema.fromMetadata(metadata, this.platform, this.config, schemaName);
     }
     async getCreateSchemaSQL(options = {}) {
         const wrap = options.wrap ?? this.options.disableForeignKeys;
@@ -69,7 +62,6 @@ class SchemaGenerator extends core_1.AbstractSchemaGenerator {
         return this.wrapSchema(ret, { wrap });
     }
     async dropSchema(options = {}) {
-        options.wrap ?? (options.wrap = true);
         if (options.dropDb) {
             const name = this.config.get('dbName');
             return this.dropDatabase(name);
@@ -77,10 +69,44 @@ class SchemaGenerator extends core_1.AbstractSchemaGenerator {
         const sql = await this.getDropSchemaSQL(options);
         await this.execute(sql);
     }
+    async clearDatabase(options) {
+        // truncate by default, so no value is considered as true
+        /* istanbul ignore if */
+        if (options?.truncate === false) {
+            return super.clearDatabase(options);
+        }
+        await this.execute(this.helper.disableForeignKeysSQL());
+        for (const meta of this.getOrderedMetadata(options?.schema).reverse()) {
+            await this.driver.createQueryBuilder(meta.className, this.em?.getTransactionContext(), 'write', false)
+                .withSchema(options?.schema)
+                .truncate();
+        }
+        await this.execute(this.helper.enableForeignKeysSQL());
+        if (this.em) {
+            const allowGlobalContext = this.config.get('allowGlobalContext');
+            this.config.set('allowGlobalContext', true);
+            this.em.clear();
+            this.config.set('allowGlobalContext', allowGlobalContext);
+        }
+    }
     async getDropSchemaSQL(options = {}) {
+        await this.ensureDatabase();
         const wrap = options.wrap ?? this.options.disableForeignKeys;
         const metadata = this.getOrderedMetadata(options.schema).reverse();
+        const schema = await DatabaseSchema_1.DatabaseSchema.create(this.connection, this.platform, this.config, options.schema);
         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)
+        for (const meta of metadata) {
+            const table = schema.getTable(meta.tableName);
+            if (!this.platform.usesCascadeStatement() && table && !wrap) {
+                for (const fk of Object.values(table.getForeignKeys())) {
+                    const builder = this.createSchemaBuilder(table.schema).alterTable(table.name, tbl => {
+                        tbl.dropForeign(fk.columnNames, fk.constraintName);
+                    });
+                    ret += await this.dump(builder, '\n');
+                }
+            }
+        }
         for (const meta of metadata) {
             ret += await this.dump(this.dropTable(meta.collection, this.getSchemaName(meta, options)), '\n');
         }
@@ -90,20 +116,23 @@ class SchemaGenerator extends core_1.AbstractSchemaGenerator {
         return this.wrapSchema(ret + '\n', { wrap });
     }
     getSchemaName(meta, options) {
+        const schemaName = options.schema ?? this.config.get('schema');
         /* istanbul ignore next */
-        return meta.schema === '*' ? options.schema : meta.schema;
+        return meta.schema && meta.schema === '*' ? schemaName : (meta.schema ?? schemaName);
     }
     async updateSchema(options = {}) {
         const sql = await this.getUpdateSchemaSQL(options);
         await this.execute(sql);
     }
     async getUpdateSchemaSQL(options = {}) {
+        await this.ensureDatabase();
         const { fromSchema, toSchema } = await this.prepareSchemaForComparison(options);
         const comparator = new SchemaComparator_1.SchemaComparator(this.platform);
         const diffUp = comparator.compare(fromSchema, toSchema);
         return this.diffToSQL(diffUp, options);
     }
     async getUpdateSchemaMigrationSQL(options = {}) {
+        await this.ensureDatabase();
         const { fromSchema, toSchema } = await this.prepareSchemaForComparison(options);
         const comparator = new SchemaComparator_1.SchemaComparator(this.platform);
         const diffUp = comparator.compare(fromSchema, toSchema);
@@ -114,9 +143,9 @@ class SchemaGenerator extends core_1.AbstractSchemaGenerator {
         };
     }
     async prepareSchemaForComparison(options) {
-        options.wrap ?? (options.wrap = this.options.disableForeignKeys);
-        options.safe ?? (options.safe = false);
-        options.dropTables ?? (options.dropTables = true);
+        options.wrap ??= this.options.disableForeignKeys;
+        options.safe ??= false;
+        options.dropTables ??= true;
         const toSchema = this.getTargetSchema(options.schema);
         const fromSchema = options.fromSchema ?? await DatabaseSchema_1.DatabaseSchema.create(this.connection, this.platform, this.config, options.schema);
         const wildcardSchemaTables = Object.values(this.metadata.getAll()).filter(meta => meta.schema === '*').map(meta => meta.tableName);
@@ -240,7 +269,7 @@ class SchemaGenerator extends core_1.AbstractSchemaGenerator {
             }
             for (const column of Object.values(diff.addedColumns)) {
                 const col = this.helper.createTableColumn(table, column, diff.fromTable);
-                this.configureColumn(column, col);
+                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];
@@ -262,7 +291,7 @@ class SchemaGenerator extends core_1.AbstractSchemaGenerator {
                     continue;
                 }
                 const col = this.helper.createTableColumn(table, column, diff.fromTable, changedProperties).alter();
-                this.configureColumn(column, col, changedProperties);
+                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));
@@ -274,7 +303,7 @@ class SchemaGenerator extends core_1.AbstractSchemaGenerator {
                 this.helper.pushTableQuery(table, this.helper.getChangeColumnCommentSQL(tableName, column));
             }
             for (const [oldColumnName, column] of Object.entries(diff.renamedColumns)) {
-                this.helper.pushTableQuery(table, this.helper.getRenameColumnSQL(tableName, oldColumnName, column));
+                this.helper.pushTableQuery(table, this.helper.getRenameColumnSQL(tableName, oldColumnName, column, schemaName));
             }
             for (const foreignKey of Object.values(diff.addedForeignKeys)) {
                 this.createForeignKey(table, foreignKey);
@@ -283,15 +312,15 @@ class SchemaGenerator extends core_1.AbstractSchemaGenerator {
                 this.createForeignKey(table, foreignKey);
             }
             for (const index of Object.values(diff.addedIndexes)) {
-                this.createIndex(table, index, diff.name);
+                this.createIndex(table, index, diff.toTable);
             }
             for (const index of Object.values(diff.changedIndexes)) {
-                this.createIndex(table, index, diff.name, true);
+                this.createIndex(table, index, diff.toTable, true);
             }
             for (const [oldIndexName, index] of Object.entries(diff.renamedIndexes)) {
                 if (index.unique) {
                     this.dropIndex(table, index, oldIndexName);
-                    this.createIndex(table, index, diff.name);
+                    this.createIndex(table, index, diff.toTable);
                 }
                 else {
                     this.helper.pushTableQuery(table, this.helper.getRenameIndexSQL(diff.name, index, oldIndexName));
@@ -304,7 +333,8 @@ class SchemaGenerator extends core_1.AbstractSchemaGenerator {
                 this.createCheck(table, check);
             }
             if ('changedComment' in diff) {
-                table.comment(diff.changedComment ?? '');
+                const comment = diff.changedComment ? this.platform.quoteValue(diff.changedComment).replace(/^'|'$/g, '') : '';
+                table.comment(comment);
             }
         }));
         return ret;
@@ -323,14 +353,20 @@ class SchemaGenerator extends core_1.AbstractSchemaGenerator {
         await this.driver.execute(this.helper.getDropDatabaseSQL('' + this.knex.ref(name)));
     }
     async execute(sql, options = {}) {
-        options.wrap ?? (options.wrap = false);
+        options.wrap ??= false;
         const lines = this.wrapSchema(sql, options).split('\n').filter(i => i.trim());
-        for (const line of lines) {
-            await this.driver.execute(line);
+        if (lines.length === 0) {
+            return;
         }
+        if (this.platform.supportsMultipleStatements()) {
+            const query = lines.join('\n');
+            await this.driver.execute(query);
+            return;
+        }
+        await core_1.Utils.runSerial(lines, line => this.driver.execute(line));
     }
     wrapSchema(sql, options = {}) {
-        options.wrap ?? (options.wrap = this.options.disableForeignKeys);
+        options.wrap ??= this.options.disableForeignKeys;
         if (!options.wrap || sql.trim() === '') {
             return sql;
         }
@@ -350,16 +386,18 @@ class SchemaGenerator extends core_1.AbstractSchemaGenerator {
         return this.createSchemaBuilder(tableDef.schema).createTable(tableDef.name, table => {
             tableDef.getColumns().forEach(column => {
                 const col = this.helper.createTableColumn(table, column, tableDef);
-                this.configureColumn(column, col);
+                this.helper.configureColumn(column, col, this.knex);
             });
             for (const index of tableDef.getIndexes()) {
-                this.createIndex(table, index, tableDef.name, !tableDef.getColumns().some(c => c.autoincrement));
+                const createPrimary = !tableDef.getColumns().some(c => c.autoincrement && c.primary) || this.helper.hasNonDefaultPrimaryKeyName(tableDef);
+                this.createIndex(table, index, tableDef, createPrimary);
             }
             for (const check of tableDef.getChecks()) {
                 this.createCheck(table, check);
             }
             if (tableDef.comment) {
-                table.comment(tableDef.comment);
+                const comment = this.platform.quoteValue(tableDef.comment).replace(/^'|'$/g, '');
+                table.comment(comment);
             }
             if (!this.helper.supportsSchemaConstraints()) {
                 for (const fk of Object.values(tableDef.getForeignKeys())) {
@@ -369,13 +407,12 @@ class SchemaGenerator extends core_1.AbstractSchemaGenerator {
             this.helper.finalizeTable(table, this.config.get('charset'), this.config.get('collate'));
         });
     }
-    createIndex(table, index, tableName, createPrimary = false) {
+    createIndex(table, index, tableDef, createPrimary = false) {
         if (index.primary && !createPrimary) {
             return;
         }
         if (index.primary) {
-            /* istanbul ignore next */
-            const keyName = tableName.includes('.') ? tableName.split('.').pop() + '_pkey' : undefined;
+            const keyName = this.helper.hasNonDefaultPrimaryKeyName(tableDef) ? index.keyName : undefined;
             table.primary(index.columnNames, keyName);
         }
         else if (index.unique) {
@@ -384,6 +421,12 @@ class SchemaGenerator extends core_1.AbstractSchemaGenerator {
         else if (index.expression) {
             this.helper.pushTableQuery(table, index.expression);
         }
+        else if (index.type === 'fulltext') {
+            const columns = index.columnNames.map(name => ({ name, type: tableDef.getColumn(name).type }));
+            if (this.platform.supportsCreatingFullTextIndex()) {
+                this.helper.pushTableQuery(table, this.platform.getFullTextIndexExpression(index.keyName, tableDef.schema, tableDef.name, columns));
+            }
+        }
         else {
             table.index(index.columnNames, index.keyName, index.type);
         }
@@ -412,9 +455,6 @@ class SchemaGenerator extends core_1.AbstractSchemaGenerator {
         }
         return builder;
     }
-    configureColumn(column, col, changedProperties) {
-        return this.helper.configureColumn(column, col, this.knex, changedProperties);
-    }
     createForeignKeys(table, tableDef, schema) {
         if (!this.helper.supportsSchemaConstraints()) {
             return;
@@ -433,5 +473,9 @@ class SchemaGenerator extends core_1.AbstractSchemaGenerator {
         const tmp = dump.replace(/pragma table_.+/ig, '').replace(/\n\n+/g, '\n').trim();
         return tmp ? tmp + append : '';
     }
+    get knex() {
+        return this.connection.getKnex();
+    }
 }
-exports.SchemaGenerator = SchemaGenerator;
+exports.SqlSchemaGenerator = SqlSchemaGenerator;
+exports.SchemaGenerator = SqlSchemaGenerator;

package/{dist/schema → schema}/index.d.ts

@@ -1,5 +1,5 @@
 export * from './DatabaseSchema';
 export * from './DatabaseTable';
-export * from './SchemaGenerator';
+export * from './SqlSchemaGenerator';
 export * from './SchemaHelper';
 export * from './SchemaComparator';

package/{dist/schema → schema}/index.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[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];
@@ -12,6 +16,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./DatabaseSchema"), exports);
 __exportStar(require("./DatabaseTable"), exports);
-__exportStar(require("./SchemaGenerator"), exports);
+__exportStar(require("./SqlSchemaGenerator"), exports);
 __exportStar(require("./SchemaHelper"), exports);
 __exportStar(require("./SchemaComparator"), exports);

package/{dist/typings.d.ts → typings.d.ts}

@@ -7,10 +7,11 @@ export interface Table {
     schema_name?: string;
     table_comment?: string;
 }
-export declare type KnexStringRef = Knex.Ref<string, {
+export type KnexStringRef = Knex.Ref<string, {
     [alias: string]: string;
 }>;
-export declare type Field<T> = string | keyof T | KnexStringRef | Knex.QueryBuilder;
+type AnyString = string & {};
+export type Field<T> = AnyString | keyof T | KnexStringRef | Knex.QueryBuilder;
 export interface JoinOptions {
     table: string;
     schema?: string;
@@ -24,6 +25,7 @@ export interface JoinOptions {
     path?: string;
     prop: EntityProperty;
     cond: Dictionary;
+    cond_?: Dictionary;
 }
 export interface Column {
     name: string;
@@ -42,6 +44,7 @@ export interface Column {
     unique?: boolean;
     /** mysql only */
     extra?: string;
+    ignoreSchemaChanges?: ('type' | 'extra')[];
 }
 export interface ForeignKey {
     columnNames: string[];
@@ -52,7 +55,7 @@ export interface ForeignKey {
     updateRule?: string;
     deleteRule?: string;
 }
-export interface Index {
+export interface IndexDef {
     columnNames: string[];
     keyName: string;
     unique: boolean;
@@ -65,7 +68,7 @@ export interface Index {
         predicate?: Knex.QueryBuilder;
     }>;
 }
-export interface Check<T = unknown> {
+export interface CheckDef<T = unknown> {
     name: string;
     expression: string | CheckCallback<T>;
     definition?: string;
@@ -81,17 +84,18 @@ export interface TableDifference {
     name: string;
     changedComment?: string;
     fromTable: DatabaseTable;
+    toTable: DatabaseTable;
     addedColumns: Dictionary<Column>;
     changedColumns: Dictionary<ColumnDifference>;
     removedColumns: Dictionary<Column>;
     renamedColumns: Dictionary<Column>;
-    addedIndexes: Dictionary<Index>;
-    changedIndexes: Dictionary<Index>;
-    removedIndexes: Dictionary<Index>;
-    renamedIndexes: Dictionary<Index>;
-    addedChecks: Dictionary<Check>;
-    changedChecks: Dictionary<Check>;
-    removedChecks: Dictionary<Check>;
+    addedIndexes: Dictionary<IndexDef>;
+    changedIndexes: Dictionary<IndexDef>;
+    removedIndexes: Dictionary<IndexDef>;
+    renamedIndexes: Dictionary<IndexDef>;
+    addedChecks: Dictionary<CheckDef>;
+    changedChecks: Dictionary<CheckDef>;
+    removedChecks: Dictionary<CheckDef>;
     addedForeignKeys: Dictionary<ForeignKey>;
     changedForeignKeys: Dictionary<ForeignKey>;
     removedForeignKeys: Dictionary<ForeignKey>;
@@ -107,7 +111,7 @@ export interface SchemaDifference {
 }
 export interface IQueryBuilder<T> {
     readonly alias: string;
-    readonly type: QueryType;
+    readonly type?: QueryType;
     _fields?: Field<T>[];
     select(fields: Field<T> | Field<T>[], distinct?: boolean): this;
     addSelect(fields: string | string[]): this;
@@ -133,18 +137,19 @@ export interface IQueryBuilder<T> {
     getAliasForJoinPath(path: string): string | undefined;
     getNextAlias(entityName?: string): string;
 }
-export interface ICriteriaNode {
+export interface ICriteriaNode<T extends object> {
     readonly entityName: string;
-    readonly parent?: ICriteriaNode | undefined;
+    readonly parent?: ICriteriaNode<T> | undefined;
     readonly key?: string | undefined;
     payload: any;
     prop?: EntityProperty;
     index?: number;
-    process<T>(qb: IQueryBuilder<T>, alias?: string): any;
+    process(qb: IQueryBuilder<T>, alias?: string): any;
     shouldInline(payload: any): boolean;
-    willAutoJoin<T>(qb: IQueryBuilder<T>, alias?: string): boolean;
+    willAutoJoin(qb: IQueryBuilder<T>, alias?: string): boolean;
     shouldRename(payload: any): boolean;
     renameFieldToPK<T>(qb: IQueryBuilder<T>): string;
     getPath(addIndex?: boolean): string;
     getPivotPath(path: string): string;
 }
+export {};