@mikro-orm/knex 6.0.0-dev.2 → 6.0.0-dev.200

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

@@ -1,20 +1,12 @@
-import { AbstractSchemaGenerator } from '@mikro-orm/core';
+import { AbstractSchemaGenerator, type MikroORM, type ISchemaGenerator } 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 +26,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;
@@ -83,7 +79,7 @@ export declare class SchemaGenerator extends AbstractSchemaGenerator<AbstractSql
      * creates new database and connects to it
      */
     createDatabase(name: string): Promise<void>;
-    dropDatabase(name: string): Promise<void>;
+    dropDatabase(name?: string): Promise<void>;
     execute(sql: string, options?: {
         wrap?: boolean;
     }): Promise<void>;
@@ -95,7 +91,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,15 @@
 "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);
-        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);
+class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
+    helper = this.platform.getSchemaHelper();
+    options = this.config.get('schemaGenerator');
+    lastEnsuredDatabase;
+    static register(orm) {
+        orm.config.registerExtension('@mikro-orm/schema-generator', () => new SqlSchemaGenerator(orm.em));
     }
     async createSchema(options) {
         await this.ensureDatabase();
@@ -35,7 +21,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 +38,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 +60,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,51 +67,99 @@ 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 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)
+        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');
         }
+        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(this.knex.schema.raw(sql), '\n');
+            }
+        }
         if (options.dropMigrationsTable) {
             ret += await this.dump(this.dropTable(this.config.get('migrations').tableName, this.config.get('schema')), '\n');
         }
         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 = {}) {
+        if (!options.fromSchema) {
+            await this.ensureDatabase();
+        }
         const { fromSchema, toSchema } = await this.prepareSchemaForComparison(options);
         const comparator = new SchemaComparator_1.SchemaComparator(this.platform);
         const diffUp = comparator.compare(fromSchema, toSchema);
-        const diffDown = comparator.compare(toSchema, fromSchema);
+        const diffDown = comparator.compare(toSchema, fromSchema, diffUp);
         return {
             up: await this.diffToSQL(diffUp, options),
             down: this.platform.supportsDownMigrations() ? await this.diffToSQL(diffDown, options) : '',
         };
     }
     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 schemas = toSchema.getNamespaces();
+        const fromSchema = options.fromSchema ?? await DatabaseSchema_1.DatabaseSchema.create(this.connection, this.platform, this.config, options.schema, schemas);
         const wildcardSchemaTables = Object.values(this.metadata.getAll()).filter(meta => meta.schema === '*').map(meta => meta.tableName);
         fromSchema.prune(options.schema, wildcardSchemaTables);
         toSchema.prune(options.schema, wildcardSchemaTables);
+        toSchema.setNativeEnums(fromSchema.getNativeEnums());
         return { fromSchema, toSchema };
     }
     async diffToSQL(schemaDiff, options) {
@@ -177,7 +215,7 @@ class SchemaGenerator extends core_1.AbstractSchemaGenerator {
         if (schema && schemaName === '*') {
             return `${schema}.${referencedTableName.replace(/^\*\./, '')}`;
         }
-        if (schemaName === this.platform.getDefaultSchemaName()) {
+        if (!schemaName || schemaName === this.platform.getDefaultSchemaName()) {
             return tableName;
         }
         return `${schemaName}.${tableName}`;
@@ -225,6 +263,12 @@ class SchemaGenerator extends core_1.AbstractSchemaGenerator {
     alterTable(diff, safe) {
         const ret = [];
         const [schemaName, tableName] = this.splitTableName(diff.name);
+        const changedNativeEnums = [];
+        for (const { column, changedProperties } of Object.values(diff.changedColumns)) {
+            if (column.nativeEnumName && changedProperties.has('enumItems') && column.nativeEnumName in diff.fromTable.nativeEnums) {
+                changedNativeEnums.push([column.nativeEnumName, column.enumItems, diff.fromTable.getColumn(column.name).enumItems]);
+            }
+        }
         ret.push(this.createSchemaBuilder(schemaName).alterTable(tableName, table => {
             for (const index of Object.values(diff.removedIndexes)) {
                 this.dropIndex(table, index);
@@ -238,9 +282,17 @@ class SchemaGenerator extends core_1.AbstractSchemaGenerator {
             for (const check of Object.values(diff.changedChecks)) {
                 this.dropCheck(table, check);
             }
+            /* istanbul ignore else */
+            if (!safe) {
+                for (const column of Object.values(diff.removedColumns)) {
+                    this.helper.pushTableQuery(table, `alter table ${this.platform.quoteIdentifier(tableName)} drop column ${this.platform.quoteIdentifier(column.name)}`);
+                }
+            }
+        }));
+        ret.push(this.createSchemaBuilder(schemaName).alterTable(tableName, table => {
             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];
@@ -251,30 +303,27 @@ class SchemaGenerator extends core_1.AbstractSchemaGenerator {
                         .onDelete(foreignKey.deleteRule);
                 }
             }
-            /* istanbul ignore else */
-            if (!safe) {
-                for (const column of Object.values(diff.removedColumns)) {
-                    table.dropColumn(column.name);
-                }
-            }
             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).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));
+                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));
+                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));
+                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 +332,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,9 +353,17 @@ 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);
             }
         }));
+        if (this.platform.supportsNativeEnums()) {
+            changedNativeEnums.forEach(([enumName, itemsNew, itemsOld]) => {
+                // postgres allows only adding new items
+                const newItems = itemsNew.filter(val => !itemsOld.includes(val));
+                ret.push(...newItems.map(val => this.knex.schema.raw(this.helper.getAlterNativeEnumSQL(enumName, schemaName, val))));
+            });
+        }
         return ret;
     }
     /**
@@ -318,19 +375,26 @@ class SchemaGenerator extends core_1.AbstractSchemaGenerator {
         await this.driver.reconnect();
     }
     async dropDatabase(name) {
+        name ??= this.config.get('dbName');
         this.config.set('dbName', this.helper.getManagementDbName());
         await this.driver.reconnect();
         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);
+    wrapSchema(sql, options) {
+        options.wrap ??= this.options.disableForeignKeys;
         if (!options.wrap || sql.trim() === '') {
             return sql;
         }
@@ -350,16 +414,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,30 +435,49 @@ 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) {
-            table.unique(index.columnNames, { indexName: index.keyName });
+            // JSON columns can have unique index but not unique constraint, and we need to distinguish those, so we can properly drop them
+            if (index.columnNames.some(column => column.includes('.'))) {
+                const columns = this.platform.getJsonIndexDefinition(index);
+                table.index(columns.map(column => this.knex.raw(`(${column})`)), index.keyName, { indexType: 'unique' });
+            }
+            else {
+                table.unique(index.columnNames, { indexName: index.keyName });
+            }
         }
         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);
+            // JSON columns can have unique index but not unique constraint, and we need to distinguish those, so we can properly drop them
+            if (index.columnNames.some(column => column.includes('.'))) {
+                const columns = this.platform.getJsonIndexDefinition(index);
+                table.index(columns.map(column => this.knex.raw(`(${column})`)), index.keyName, index.type);
+            }
+            else {
+                table.index(index.columnNames, index.keyName, index.type);
+            }
         }
     }
     dropIndex(table, index, oldIndexName = index.keyName) {
         if (index.primary) {
             table.dropPrimary(oldIndexName);
         }
-        else if (index.unique) {
+        else if (index.unique && index.constraint) {
             table.dropUnique(index.columnNames, oldIndexName);
         }
         else {
@@ -412,9 +497,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 +515,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}

@@ -1,20 +1,21 @@
 import type { Knex } from 'knex';
-import type { CheckCallback, Dictionary, EntityProperty, GroupOperator, QBFilterQuery, QueryOrderMap, Type } from '@mikro-orm/core';
-import type { QueryType } from './query/enums';
+import type { CheckCallback, Dictionary, EntityProperty, GroupOperator, RawQueryFragment, QBFilterQuery, QueryOrderMap, Type, QueryFlag } from '@mikro-orm/core';
+import type { JoinType, QueryType } from './query/enums';
 import type { DatabaseSchema, DatabaseTable } from './schema';
 export interface Table {
     table_name: string;
     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 | RawQueryFragment | KnexStringRef | Knex.QueryBuilder;
 export interface JoinOptions {
     table: string;
     schema?: string;
-    type: 'leftJoin' | 'innerJoin' | 'pivotJoin';
+    type: JoinType;
     alias: string;
     ownerAlias: string;
     inverseAlias?: string;
@@ -24,6 +25,8 @@ export interface JoinOptions {
     path?: string;
     prop: EntityProperty;
     cond: Dictionary;
+    cond_?: Dictionary;
+    subquery?: string;
 }
 export interface Column {
     name: string;
@@ -37,11 +40,14 @@ export interface Column {
     scale?: number;
     default?: string | null;
     comment?: string;
+    generated?: string;
+    nativeEnumName?: string;
     enumItems?: string[];
     primary?: boolean;
     unique?: boolean;
     /** mysql only */
     extra?: string;
+    ignoreSchemaChanges?: ('type' | 'extra')[];
 }
 export interface ForeignKey {
     columnNames: string[];
@@ -52,20 +58,22 @@ export interface ForeignKey {
     updateRule?: string;
     deleteRule?: string;
 }
-export interface Index {
+export interface IndexDef {
     columnNames: string[];
     keyName: string;
     unique: boolean;
+    constraint: boolean;
     primary: boolean;
     composite?: boolean;
     expression?: string;
+    options?: Dictionary;
     type?: string | Readonly<{
         indexType?: string;
         storageEngineIndexType?: 'hash' | 'btree';
         predicate?: Knex.QueryBuilder;
     }>;
 }
-export interface Check<T = unknown> {
+export interface CheckDef<T = unknown> {
     name: string;
     expression: string | CheckCallback<T>;
     definition?: string;
@@ -81,17 +89,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 +116,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;
@@ -116,10 +125,12 @@ export interface IQueryBuilder<T> {
     delete(cond?: QBFilterQuery): this;
     truncate(): this;
     count(field?: string | string[], distinct?: boolean): this;
-    join(field: string, alias: string, cond?: QBFilterQuery, type?: 'leftJoin' | 'innerJoin' | 'pivotJoin', path?: string): this;
+    join(field: string, alias: string, cond?: QBFilterQuery, type?: JoinType, path?: string): this;
+    innerJoin(field: string, alias: string, cond?: QBFilterQuery): this;
     leftJoin(field: string, alias: string, cond?: QBFilterQuery): this;
     joinAndSelect(field: string, alias: string, cond?: QBFilterQuery): this;
-    leftJoinAndSelect(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;
     where(cond: QBFilterQuery<T>, operator?: keyof typeof GroupOperator): this;
     where(cond: string, params?: any[], operator?: keyof typeof GroupOperator): this;
@@ -130,21 +141,33 @@ export interface IQueryBuilder<T> {
     orderBy(orderBy: QueryOrderMap<T>): this;
     groupBy(fields: (string | keyof T) | (string | keyof T)[]): this;
     having(cond?: QBFilterQuery | string, params?: any[]): this;
-    getAliasForJoinPath(path: string): string | undefined;
+    getAliasForJoinPath(path: string, options?: ICriteriaNodeProcessOptions): string | undefined;
+    getJoinForPath(path?: string, options?: ICriteriaNodeProcessOptions): JoinOptions | undefined;
     getNextAlias(entityName?: string): string;
+    clone(reset?: boolean): IQueryBuilder<T>;
+    setFlag(flag: QueryFlag): this;
+    unsetFlag(flag: QueryFlag): this;
+    hasFlag(flag: QueryFlag): boolean;
 }
-export interface ICriteriaNode {
+export interface ICriteriaNodeProcessOptions {
+    alias?: string;
+    matchPopulateJoins?: boolean;
+    ignoreBranching?: boolean;
+    preferNoBranch?: boolean;
+}
+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>, options?: ICriteriaNodeProcessOptions): 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 {};