@mikro-orm/knex 6.1.10-dev.2 → 6.1.10-dev.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "6.1.10-dev.2",
+  "version": "6.1.10-dev.3",
   "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",
@@ -66,6 +66,6 @@
     "@mikro-orm/core": "^6.1.9"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "6.1.10-dev.2"
+    "@mikro-orm/core": "6.1.10-dev.3"
   }
 }

package/schema/DatabaseSchema.d.ts

@@ -16,9 +16,23 @@ export declare class DatabaseSchema {
     getTables(): DatabaseTable[];
     getTable(name: string): DatabaseTable | undefined;
     hasTable(name: string): boolean;
-    setNativeEnums(nativeEnums: Dictionary<unknown[]>): void;
-    getNativeEnums(): Dictionary<unknown[]>;
+    setNativeEnums(nativeEnums: Dictionary<{
+        name: string;
+        schema?: string;
+        items: string[];
+    }>): void;
+    getNativeEnums(): Dictionary<{
+        name: string;
+        schema?: string;
+        items: string[];
+    }>;
+    getNativeEnum(name: string): {
+        name: string;
+        schema?: string;
+        items: string[];
+    };
     hasNamespace(namespace: string): boolean;
+    hasNativeEnum(name: string): boolean;
     getNamespaces(): string[];
     static create(connection: AbstractSqlConnection, platform: AbstractSqlPlatform, config: Configuration, schemaName?: string, schemas?: string[]): Promise<DatabaseSchema>;
     static fromMetadata(metadata: EntityMetadata[], platform: AbstractSqlPlatform, config: Configuration, schemaName?: string): DatabaseSchema;

package/schema/DatabaseSchema.js

@@ -43,9 +43,15 @@ class DatabaseSchema {
     getNativeEnums() {
         return this.nativeEnums;
     }
+    getNativeEnum(name) {
+        return this.nativeEnums[name];
+    }
     hasNamespace(namespace) {
         return this.namespaces.has(namespace);
     }
+    hasNativeEnum(name) {
+        return name in this.nativeEnums;
+    }
     getNamespaces() {
         return [...this.namespaces];
     }
@@ -63,9 +69,20 @@ class DatabaseSchema {
         const schema = new DatabaseSchema(platform, schemaName ?? config.get('schema'));
         const nativeEnums = {};
         for (const meta of metadata) {
-            meta.props
-                .filter(prop => prop.nativeEnumName)
-                .forEach(prop => nativeEnums[prop.nativeEnumName] = prop.items?.map(val => '' + val) ?? []);
+            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;
+                    }
+                    nativeEnums[key] = {
+                        name: prop.nativeEnumName,
+                        schema: meta.schema ?? schema.name,
+                        items: prop.items?.map(val => '' + val) ?? [],
+                    };
+                }
+            }
         }
         schema.setNativeEnums(nativeEnums);
         for (const meta of metadata) {

package/schema/DatabaseTable.d.ts

@@ -13,7 +13,11 @@ export declare class DatabaseTable {
     private indexes;
     private checks;
     private foreignKeys;
-    nativeEnums: Dictionary<unknown[]>;
+    nativeEnums: Dictionary<{
+        name: string;
+        schema?: string;
+        items: string[];
+    }>;
     comment?: string;
     constructor(platform: AbstractSqlPlatform, name: string, schema?: string | undefined);
     getColumns(): Column[];

package/schema/SchemaComparator.js

@@ -23,7 +23,17 @@ class SchemaComparator {
      * stored in toSchema.
      */
     compare(fromSchema, toSchema, inverseDiff) {
-        const diff = { newTables: {}, removedTables: {}, changedTables: {}, orphanedForeignKeys: [], newNamespaces: new Set(), removedNamespaces: new Set(), fromSchema };
+        const diff = {
+            newTables: {},
+            removedTables: {},
+            changedTables: {},
+            orphanedForeignKeys: [],
+            newNativeEnums: [],
+            removedNativeEnums: [],
+            newNamespaces: new Set(),
+            removedNamespaces: new Set(),
+            fromSchema,
+        };
         const foreignKeysToTable = {};
         for (const namespace of toSchema.getNamespaces()) {
             if (fromSchema.hasNamespace(namespace) || namespace === this.platform.getDefaultSchemaName()) {
@@ -37,6 +47,18 @@ class SchemaComparator {
             }
             diff.removedNamespaces.add(namespace);
         }
+        for (const nativeEnum of Object.keys(toSchema.getNativeEnums())) {
+            if (fromSchema.hasNativeEnum(nativeEnum)) {
+                continue;
+            }
+            diff.newNativeEnums.push(toSchema.getNativeEnum(nativeEnum));
+        }
+        for (const nativeEnum of Object.keys(fromSchema.getNativeEnums())) {
+            if (toSchema.hasNativeEnum(nativeEnum)) {
+                continue;
+            }
+            diff.removedNativeEnums.push(fromSchema.getNativeEnum(nativeEnum));
+        }
         for (const table of toSchema.getTables()) {
             const tableName = table.getShortestName();
             if (!fromSchema.hasTable(tableName)) {

package/schema/SqlSchemaGenerator.js

@@ -68,7 +68,7 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
                     continue;
                 }
                 created.push(enumName);
-                const sql = this.helper.getCreateNativeEnumSQL(enumName, enumOptions, options.schema ?? this.config.get('schema'));
+                const sql = this.helper.getCreateNativeEnumSQL(enumName, enumOptions.items, options.schema ?? this.config.get('schema'));
                 ret += await this.dump(this.knex.schema.raw(sql), '\n');
             }
         }
@@ -180,7 +180,6 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
         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) {
@@ -191,6 +190,12 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
                 ret += await this.dump(this.knex.schema.createSchemaIfNotExists(newNamespace));
             }
         }
+        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'));
+                ret += await this.dump(this.knex.schema.raw(sql), '\n');
+            }
+        }
         if (!options.safe) {
             for (const orphanedForeignKey of schemaDiff.orphanedForeignKeys) {
                 const [schemaName, tableName] = this.splitTableName(orphanedForeignKey.localTableName);
@@ -227,6 +232,12 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
                 ret += await this.dump(builder);
             }
         }
+        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(this.knex.schema.raw(sql), '\n');
+            }
+        }
         if (options.dropTables && !options.safe) {
             for (const removedNamespace of schemaDiff.removedNamespaces) {
                 ret += await this.dump(this.knex.schema.dropSchema(removedNamespace));
@@ -296,22 +307,16 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
         const ret = [];
         const [schemaName, tableName] = this.splitTableName(diff.name);
         if (this.platform.supportsNativeEnums()) {
-            const createdNativeEnums = [];
             const changedNativeEnums = [];
-            for (const { column, changedProperties, fromColumn } of Object.values(diff.changedColumns)) {
+            for (const { column, changedProperties } of Object.values(diff.changedColumns)) {
                 if (!column.nativeEnumName) {
                     continue;
                 }
-                if (changedProperties.has('enumItems') && column.nativeEnumName in diff.fromTable.nativeEnums) {
-                    changedNativeEnums.push([column.nativeEnumName, column.enumItems, diff.fromTable.getColumn(column.name).enumItems]);
-                }
-                else if (changedProperties.has('type') && !(column.nativeEnumName in diff.fromTable.nativeEnums)) {
-                    createdNativeEnums.push([column.nativeEnumName, column.enumItems]);
+                const key = schemaName && schemaName !== this.platform.getDefaultSchemaName() ? 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(createdNativeEnums).forEach(([enumName, items]) => {
-                ret.push(this.knex.schema.raw(this.helper.getCreateNativeEnumSQL(enumName, items, schemaName)));
-            });
             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());

package/typings.d.ts

@@ -107,10 +107,19 @@ export interface TableDifference {
 }
 export interface SchemaDifference {
     newNamespaces: Set<string>;
+    newNativeEnums: {
+        name: string;
+        schema?: string;
+        items: string[];
+    }[];
     newTables: Dictionary<DatabaseTable>;
     changedTables: Dictionary<TableDifference>;
     removedTables: Dictionary<DatabaseTable>;
     removedNamespaces: Set<string>;
+    removedNativeEnums: {
+        name: string;
+        schema?: string;
+    }[];
     orphanedForeignKeys: ForeignKey[];
     fromSchema: DatabaseSchema;
 }