@mikro-orm/knex 6.0.0-dev.8 → 6.0.0-dev.80

package/schema/SchemaComparator.js

@@ -425,8 +425,10 @@ class SchemaComparator {
         return index1.primary === index2.primary && index1.unique === index2.unique;
     }
     diffCheck(check1, check2) {
-        const unquote = (str) => str?.replace(/['"`]/g, '');
-        return unquote(check1.expression) !== unquote(check2.expression);
+        // check constraint definition might be normalized by the driver,
+        // e.g. quotes might be added (https://github.com/mikro-orm/mikro-orm/issues/3827)
+        const simplify = (str) => str?.replace(/['"`()]/g, '').toLowerCase();
+        return simplify(check1.expression) !== simplify(check2.expression);
     }
     hasSameDefaultValue(from, to) {
         if (from.default == null || from.default.toString().toLowerCase() === 'null' || from.default.toString().startsWith('nextval(')) {
@@ -437,6 +439,11 @@ class SchemaComparator {
             const defaultValueTo = !['0', 'false', 'f', 'n', 'no', 'off'].includes('' + to.default);
             return defaultValueFrom === defaultValueTo;
         }
+        if (to.mappedType instanceof core_1.JsonType) {
+            const defaultValueFrom = (0, core_1.parseJsonSafe)(from.default.replace(/^'(.*)'$/, '$1'));
+            const defaultValueTo = (0, core_1.parseJsonSafe)(to.default?.replace(/^'(.*)'$/, '$1'));
+            return core_1.Utils.equals(defaultValueFrom, defaultValueTo);
+        }
         if (to.mappedType instanceof core_1.DateTimeType && from.default && to.default) {
             // normalize now/current_timestamp defaults, also remove `()` from the end of default expression
             const defaultValueFrom = from.default.toLowerCase().replace('current_timestamp', 'now').replace(/\(\)$/, '');

package/schema/SchemaHelper.d.ts

@@ -18,7 +18,9 @@ export declare abstract class SchemaHelper {
     getForeignKeys(connection: AbstractSqlConnection, tableName: string, schemaName?: string): Promise<Dictionary>;
     protected getTableKey(t: Table): string;
     getEnumDefinitions(connection: AbstractSqlConnection, checks: CheckDef[], tableName: string, schemaName?: string): Promise<Dictionary<string[]>>;
-    loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[]): Promise<void>;
+    getDropNativeEnumSQL(name: string, schema?: string): string;
+    getAlterNativeEnumSQL(name: string, schema?: string, value?: string): string;
+    loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[], schemas?: string[]): Promise<void>;
     getListTablesSQL(schemaName?: string): string;
     getRenameColumnSQL(tableName: string, oldColumnName: string, to: Column, schemaName?: string): string;
     getCreateIndexSQL(tableName: string, index: IndexDef): string;
@@ -29,8 +31,8 @@ export declare abstract class SchemaHelper {
     configureColumn(column: Column, col: Knex.ColumnBuilder, knex: Knex, changedProperties?: Set<string>): Knex.ColumnBuilder;
     configureColumnDefault(column: Column, col: Knex.ColumnBuilder, knex: Knex, changedProperties?: Set<string>): Knex.ColumnBuilder;
     getPreAlterTable(tableDiff: TableDifference, safe: boolean): string;
-    getAlterColumnAutoincrement(tableName: string, column: Column): string;
-    getChangeColumnCommentSQL(tableName: string, to: Column): string;
+    getAlterColumnAutoincrement(tableName: string, column: Column, schemaName?: string): string;
+    getChangeColumnCommentSQL(tableName: string, to: Column, schemaName?: string): string;
     getNamespaces(connection: AbstractSqlConnection): Promise<string[]>;
     getColumns(connection: AbstractSqlConnection, tableName: string, schemaName?: string): Promise<Column[]>;
     getIndexes(connection: AbstractSqlConnection, tableName: string, schemaName?: string): Promise<IndexDef[]>;

package/schema/SchemaHelper.js

@@ -46,7 +46,13 @@ class SchemaHelper {
     async getEnumDefinitions(connection, checks, tableName, schemaName) {
         return {};
     }
-    async loadInformationSchema(schema, connection, tables) {
+    getDropNativeEnumSQL(name, schema) {
+        throw new Error('Not supported by given driver');
+    }
+    getAlterNativeEnumSQL(name, schema, value) {
+        throw new Error('Not supported by given driver');
+    }
+    async loadInformationSchema(schema, connection, tables, schemas) {
         for (const t of tables) {
             const table = schema.addTable(t.table_name, t.schema_name);
             table.comment = t.table_comment;
@@ -122,17 +128,17 @@ class SchemaHelper {
             core_1.Utils.runIfNotEmpty(() => col.defaultTo(column.default == null ? null : knex.raw(column.default)), guard('default'));
         }
         else {
-            core_1.Utils.runIfNotEmpty(() => col.defaultTo(column.default == null ? null : knex.raw(column.default)), column.default !== undefined);
+            core_1.Utils.runIfNotEmpty(() => col.defaultTo(knex.raw(column.default)), column.default != null && column.default !== 'null');
         }
         return col;
     }
     getPreAlterTable(tableDiff, safe) {
         return '';
     }
-    getAlterColumnAutoincrement(tableName, column) {
+    getAlterColumnAutoincrement(tableName, column, schemaName) {
         return '';
     }
-    getChangeColumnCommentSQL(tableName, to) {
+    getChangeColumnCommentSQL(tableName, to, schemaName) {
         return '';
     }
     async getNamespaces(connection) {

package/schema/SqlSchemaGenerator.d.ts

@@ -1,4 +1,4 @@
-import type { MikroORM, ISchemaGenerator } from '@mikro-orm/core';
+import type { ISchemaGenerator, MikroORM } from '@mikro-orm/core';
 import { AbstractSchemaGenerator } from '@mikro-orm/core';
 import type { SchemaDifference } from '../typings';
 import { DatabaseSchema } from './DatabaseSchema';
@@ -8,8 +8,6 @@ export declare class SqlSchemaGenerator extends AbstractSchemaGenerator<Abstract
     private readonly options;
     protected lastEnsuredDatabase?: string;
     static register(orm: MikroORM): void;
-    /** @deprecated use `dropSchema` and `createSchema` commands respectively */
-    generate(): Promise<string>;
     createSchema(options?: {
         wrap?: boolean;
         schema?: string;
@@ -82,10 +80,10 @@ export declare class SqlSchemaGenerator extends AbstractSchemaGenerator<Abstract
      * 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<undefined>;
+    }): Promise<void>;
     private wrapSchema;
     private createSchemaBuilder;
     private createTable;

package/schema/SqlSchemaGenerator.js

@@ -13,14 +13,6 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
     static register(orm) {
         orm.config.registerExtension('@mikro-orm/schema-generator', () => new SqlSchemaGenerator(orm.em));
     }
-    /** @deprecated use `dropSchema` and `createSchema` commands respectively */
-    async generate() {
-        const [dropSchema, createSchema] = await Promise.all([
-            this.getDropSchemaSQL({ wrap: false }),
-            this.getCreateSchemaSQL({ wrap: false }),
-        ]);
-        return this.wrapSchema(dropSchema + createSchema);
-    }
     async createSchema(options) {
         await this.ensureDatabase();
         const sql = await this.getCreateSchemaSQL(options);
@@ -101,7 +93,8 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
         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);
+        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) {
@@ -118,6 +111,12 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
         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');
         }
@@ -140,7 +139,9 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
         return this.diffToSQL(diffUp, options);
     }
     async getUpdateSchemaMigrationSQL(options = {}) {
-        await this.ensureDatabase();
+        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);
@@ -151,14 +152,16 @@ class SqlSchemaGenerator 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 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) {
@@ -262,6 +265,12 @@ class SqlSchemaGenerator 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);
@@ -298,17 +307,20 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
                 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.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, schemaName));
@@ -345,6 +357,13 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
                 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;
     }
     /**
@@ -356,24 +375,26 @@ class SqlSchemaGenerator 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());
         if (lines.length === 0) {
             return;
         }
         if (this.platform.supportsMultipleStatements()) {
             const query = lines.join('\n');
-            return void await this.driver.execute(query);
+            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;
         }

package/typings.d.ts

@@ -25,6 +25,7 @@ export interface JoinOptions {
     path?: string;
     prop: EntityProperty;
     cond: Dictionary;
+    cond_?: Dictionary;
 }
 export interface Column {
     name: string;
@@ -38,6 +39,7 @@ export interface Column {
     scale?: number;
     default?: string | null;
     comment?: string;
+    nativeEnumName?: string;
     enumItems?: string[];
     primary?: boolean;
     unique?: boolean;
@@ -122,7 +124,8 @@ export interface IQueryBuilder<T> {
     join(field: string, alias: string, cond?: QBFilterQuery, type?: 'leftJoin' | 'innerJoin' | 'pivotJoin', path?: string): 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;
@@ -136,16 +139,16 @@ 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;