@mikro-orm/knex 6.2.2-dev.8 → 6.2.2

package/AbstractSqlDriver.js

@@ -122,7 +122,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         if (res instanceof query_1.QueryBuilder) {
             return this.wrapVirtualExpressionInSubquery(meta, res.getFormattedQuery(), where, options, type);
         }
-        if (core_1.Utils.isObject(res)) {
+        if (!(res instanceof Promise) && core_1.Utils.isObject(res)) {
             const { sql, bindings } = res.toSQL();
             const query = this.platform.formatQuery(sql, bindings);
             return this.wrapVirtualExpressionInSubquery(meta, query, where, options, type);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "6.2.2-dev.8",
+  "version": "6.2.2",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "main": "index.js",
   "module": "index.mjs",
@@ -63,9 +63,9 @@
     "sqlstring": "2.3.3"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^6.2.1"
+    "@mikro-orm/core": "^6.2.2"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "6.2.2-dev.8"
+    "@mikro-orm/core": "^6.0.0"
   }
 }

package/schema/DatabaseSchema.js

@@ -38,7 +38,11 @@ class DatabaseSchema {
     }
     setNativeEnums(nativeEnums) {
         this.nativeEnums = nativeEnums;
-        this.tables.forEach(t => t.nativeEnums = nativeEnums);
+        for (const nativeEnum of Object.values(nativeEnums)) {
+            if (nativeEnum.schema && nativeEnum.schema !== '*') {
+                this.namespaces.add(nativeEnum.schema);
+            }
+        }
     }
     getNativeEnums() {
         return this.nativeEnums;
@@ -72,13 +76,20 @@ class DatabaseSchema {
             for (const prop of meta.props) {
                 if (prop.nativeEnumName) {
                     let key = prop.nativeEnumName;
-                    const s = meta.schema ?? schema.name;
-                    if (s && s !== platform.getDefaultSchemaName()) {
-                        key = s + '.' + key;
+                    let enumName = prop.nativeEnumName;
+                    let enumSchema = meta.schema ?? schema.name;
+                    if (key.includes('.')) {
+                        const [explicitSchema, ...parts] = prop.nativeEnumName.split('.');
+                        enumName = parts.join('.');
+                        key = enumName;
+                        enumSchema = explicitSchema;
+                    }
+                    if (enumSchema && enumSchema !== '*' && enumSchema !== platform.getDefaultSchemaName()) {
+                        key = enumSchema + '.' + key;
                     }
                     nativeEnums[key] = {
-                        name: prop.nativeEnumName,
-                        schema: meta.schema ?? schema.name,
+                        name: enumName,
+                        schema: enumSchema,
                         items: prop.items?.map(val => '' + val) ?? [],
                     };
                 }
@@ -135,7 +146,11 @@ class DatabaseSchema {
                 || (!schema && !wildcardSchemaTables.includes(table.name)); // no schema specified and the table has fixed one provided
         });
         // remove namespaces of ignored tables
-        this.namespaces.forEach(ns => !this.tables.find(t => t.schema === ns) && this.namespaces.delete(ns));
+        for (const ns of this.namespaces) {
+            if (!this.tables.some(t => t.schema === ns) && !Object.values(this.nativeEnums).some(e => e.schema === ns)) {
+                this.namespaces.delete(ns);
+            }
+        }
     }
 }
 exports.DatabaseSchema = DatabaseSchema;

package/schema/SchemaComparator.d.ts

@@ -39,7 +39,7 @@ export declare class SchemaComparator {
      * Returns the difference between the columns
      * If there are differences this method returns field2, otherwise the boolean false.
      */
-    diffColumn(fromColumn: Column, toColumn: Column, tableName?: string): Set<string>;
+    diffColumn(fromColumn: Column, toColumn: Column, fromTable: DatabaseTable, tableName?: string): Set<string>;
     diffEnumItems(items1?: string[], items2?: string[]): boolean;
     diffComment(comment1?: string, comment2?: string): boolean;
     /**

package/schema/SchemaComparator.js

@@ -47,17 +47,23 @@ class SchemaComparator {
             }
             diff.removedNamespaces.add(namespace);
         }
-        for (const nativeEnum of Object.keys(toSchema.getNativeEnums())) {
-            if (fromSchema.hasNativeEnum(nativeEnum)) {
+        for (const [key, nativeEnum] of Object.entries(toSchema.getNativeEnums())) {
+            if (fromSchema.hasNativeEnum(key)) {
                 continue;
             }
-            diff.newNativeEnums.push(toSchema.getNativeEnum(nativeEnum));
+            if (nativeEnum.schema === '*' && fromSchema.hasNativeEnum(`${toSchema.name}.${key}`)) {
+                continue;
+            }
+            diff.newNativeEnums.push(nativeEnum);
         }
-        for (const nativeEnum of Object.keys(fromSchema.getNativeEnums())) {
-            if (toSchema.hasNativeEnum(nativeEnum)) {
+        for (const [key, nativeEnum] of Object.entries(fromSchema.getNativeEnums())) {
+            if (toSchema.hasNativeEnum(key)) {
+                continue;
+            }
+            if (key.startsWith(`${fromSchema.name}.`) && (fromSchema.name !== toSchema.name || toSchema.getNativeEnum(key.substring(fromSchema.name.length + 1))?.schema === '*')) {
                 continue;
             }
-            diff.removedNativeEnums.push(fromSchema.getNativeEnum(nativeEnum));
+            diff.removedNativeEnums.push(nativeEnum);
         }
         for (const table of toSchema.getTables()) {
             const tableName = table.getShortestName();
@@ -160,7 +166,7 @@ class SchemaComparator {
                 continue;
             }
             // See if column has changed properties in "to" table.
-            const changedProperties = this.diffColumn(column, toTable.getColumn(column.name), tableName);
+            const changedProperties = this.diffColumn(column, toTable.getColumn(column.name), fromTable, tableName);
             if (changedProperties.size === 0) {
                 continue;
             }
@@ -277,7 +283,7 @@ class SchemaComparator {
         const newFKs = Object.values(tableDifferences.toTable.getForeignKeys());
         for (const addedColumn of Object.values(tableDifferences.addedColumns)) {
             for (const removedColumn of Object.values(tableDifferences.removedColumns)) {
-                const diff = this.diffColumn(addedColumn, removedColumn);
+                const diff = this.diffColumn(addedColumn, removedColumn, tableDifferences.fromTable);
                 if (diff.size !== 0) {
                     continue;
                 }
@@ -372,11 +378,12 @@ class SchemaComparator {
      * Returns the difference between the columns
      * If there are differences this method returns field2, otherwise the boolean false.
      */
-    diffColumn(fromColumn, toColumn, tableName) {
+    diffColumn(fromColumn, toColumn, fromTable, tableName) {
         const changedProperties = new Set();
         const fromProp = this.mapColumnToProperty({ ...fromColumn, autoincrement: false });
         const toProp = this.mapColumnToProperty({ ...toColumn, autoincrement: false });
         const fromColumnType = fromColumn.mappedType.getColumnType(fromProp, this.platform).toLowerCase();
+        const fromNativeEnum = fromTable.nativeEnums[fromColumnType] ?? Object.values(fromTable.nativeEnums).find(e => e.name === fromColumnType && e.schema !== '*');
         const toColumnType = toColumn.mappedType.getColumnType(toProp, this.platform).toLowerCase();
         const log = (msg, params) => {
             if (tableName) {
@@ -386,6 +393,7 @@ class SchemaComparator {
             }
         };
         if (fromColumnType !== toColumnType &&
+            (!fromNativeEnum || `${fromNativeEnum.schema}.${fromNativeEnum.name}` !== toColumnType) &&
             !(fromColumn.ignoreSchemaChanges?.includes('type') || toColumn.ignoreSchemaChanges?.includes('type')) &&
             !fromColumn.generated && !toColumn.generated) {
             log(`'type' changed for column ${tableName}.${fromColumn.name}`, { fromColumnType, toColumnType });

package/schema/SqlSchemaGenerator.js

@@ -69,7 +69,7 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
                     continue;
                 }
                 created.push(enumName);
-                const sql = this.helper.getCreateNativeEnumSQL(enumName, enumOptions.items, options.schema ?? this.config.get('schema'));
+                const sql = this.helper.getCreateNativeEnumSQL(enumOptions.name, enumOptions.items, this.getSchemaName(enumOptions, options));
                 ret += await this.dump(this.knex.schema.raw(sql), '\n');
             }
         }
@@ -196,7 +196,7 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
         }
         if (this.platform.supportsNativeEnums()) {
             for (const newNativeEnum of schemaDiff.newNativeEnums) {
-                const sql = this.helper.getCreateNativeEnumSQL(newNativeEnum.name, newNativeEnum.items, newNativeEnum.schema ?? options.schema ?? this.config.get('schema'));
+                const sql = this.helper.getCreateNativeEnumSQL(newNativeEnum.name, newNativeEnum.items, this.getSchemaName(newNativeEnum, options));
                 ret += await this.dump(this.knex.schema.raw(sql), '\n');
             }
         }