@mikro-orm/knex 6.0.0-dev.64 → 6.0.0-dev.66

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "6.0.0-dev.64",
+  "version": "6.0.0-dev.66",
   "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": "^5.7.2"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "~6.0.0-dev.64"
+    "@mikro-orm/core": "~6.0.0-dev.66"
   }
 }

package/query/QueryBuilderHelper.js

@@ -22,6 +22,7 @@ class QueryBuilderHelper {
         if (core_1.Utils.isRawSql(field)) {
             return this.knex.raw(field.sql, field.params);
         }
+        /* istanbul ignore next */
         if (typeof field !== 'string') {
             return field;
         }
@@ -516,12 +517,7 @@ class QueryBuilderHelper {
             if (fieldName instanceof core_1.RawQueryFragment) {
                 return fieldName.sql;
             }
-            if (this.isPrefixed(fieldName)) {
-                ret = fieldName;
-            }
-            else {
-                ret = alias + fieldName;
-            }
+            ret = alias + fieldName;
         }
         else {
             const [a, ...rest] = field.split('.');

package/schema/DatabaseSchema.d.ts

@@ -10,14 +10,17 @@ export declare class DatabaseSchema {
     readonly name: string;
     private tables;
     private namespaces;
+    private nativeEnums;
     constructor(platform: AbstractSqlPlatform, name: string);
     addTable(name: string, schema: string | undefined | null, comment?: string): DatabaseTable;
     getTables(): DatabaseTable[];
     getTable(name: string): DatabaseTable | undefined;
     hasTable(name: string): boolean;
+    setNativeEnums(nativeEnums: Dictionary<unknown[]>): void;
+    getNativeEnums(): Dictionary<unknown[]>;
     hasNamespace(namespace: string): boolean;
     getNamespaces(): string[];
-    static create(connection: AbstractSqlConnection, platform: AbstractSqlPlatform, config: Configuration, schemaName?: string): Promise<DatabaseSchema>;
+    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;
     private static getSchemaName;
     private static shouldHaveColumn;

package/schema/DatabaseSchema.js

@@ -12,10 +12,12 @@ class DatabaseSchema {
         this.name = name;
         this.tables = [];
         this.namespaces = new Set();
+        this.nativeEnums = {}; // for postgres
     }
     addTable(name, schema, comment) {
         const namespaceName = schema ?? this.name;
         const table = new DatabaseTable_1.DatabaseTable(this.platform, name, namespaceName);
+        table.nativeEnums = this.nativeEnums;
         table.comment = comment;
         this.tables.push(table);
         if (namespaceName != null) {
@@ -32,24 +34,38 @@ class DatabaseSchema {
     hasTable(name) {
         return !!this.getTable(name);
     }
+    setNativeEnums(nativeEnums) {
+        this.nativeEnums = nativeEnums;
+        this.tables.forEach(t => t.nativeEnums = nativeEnums);
+    }
+    getNativeEnums() {
+        return this.nativeEnums;
+    }
     hasNamespace(namespace) {
         return this.namespaces.has(namespace);
     }
     getNamespaces() {
         return [...this.namespaces];
     }
-    static async create(connection, platform, config, schemaName) {
-        const schema = new DatabaseSchema(platform, schemaName ?? config.get('schema'));
+    static async create(connection, platform, config, schemaName, schemas) {
+        const schema = new DatabaseSchema(platform, schemaName ?? config.get('schema') ?? platform.getDefaultSchemaName());
         const allTables = await connection.execute(platform.getSchemaHelper().getListTablesSQL());
         const parts = config.get('migrations').tableName.split('.');
         const migrationsTableName = parts[1] ?? parts[0];
         const migrationsSchemaName = parts.length > 1 ? parts[0] : config.get('schema', platform.getDefaultSchemaName());
         const tables = allTables.filter(t => t.table_name !== migrationsTableName || (t.schema_name && t.schema_name !== migrationsSchemaName));
-        await platform.getSchemaHelper().loadInformationSchema(schema, connection, tables);
+        await platform.getSchemaHelper().loadInformationSchema(schema, connection, tables, schemas && schemas.length > 0 ? schemas : undefined);
         return schema;
     }
     static fromMetadata(metadata, platform, config, schemaName) {
         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) ?? []);
+        }
+        schema.setNativeEnums(nativeEnums);
         for (const meta of metadata) {
             const table = schema.addTable(meta.collection, this.getSchemaName(meta, config, schemaName));
             table.comment = meta.comment;

package/schema/DatabaseTable.d.ts

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

package/schema/DatabaseTable.js

@@ -14,6 +14,7 @@ class DatabaseTable {
         this.indexes = [];
         this.checks = [];
         this.foreignKeys = {};
+        this.nativeEnums = {}; // for postgres
         Object.defineProperties(this, {
             platform: { enumerable: false, writable: true },
         });
@@ -41,7 +42,7 @@ class DatabaseTable {
             const type = v.name in enums ? 'enum' : v.type;
             v.mappedType = this.platform.getMappedType(type);
             v.default = v.default?.toString().startsWith('nextval(') ? null : v.default;
-            v.enumItems = enums[v.name] || [];
+            v.enumItems ??= enums[v.name] || [];
             o[v.name] = v;
             return o;
         }, {});
@@ -73,12 +74,13 @@ class DatabaseTable {
                 unsigned: prop.unsigned && this.platform.isNumericColumn(mappedType),
                 autoincrement: prop.autoincrement ?? primary,
                 primary,
+                nativeEnumName: prop.nativeEnumName,
                 nullable: !!prop.nullable,
                 length: prop.length,
                 precision: prop.precision,
                 scale: prop.scale,
                 default: prop.defaultRaw,
-                enumItems: prop.items?.every(core_1.Utils.isString) ? prop.items : undefined,
+                enumItems: prop.nativeEnumName || prop.items?.every(core_1.Utils.isString) ? prop.items : undefined,
                 comment: prop.comment,
                 extra: prop.extra,
                 ignoreSchemaChanges: prop.ignoreSchemaChanges,

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;

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;

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';

package/schema/SqlSchemaGenerator.js

@@ -93,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) {
@@ -110,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');
         }
@@ -149,10 +156,12 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
         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) {
@@ -256,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);
@@ -292,6 +307,9 @@ 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);
             }
@@ -339,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;
     }
     /**
@@ -367,7 +392,7 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
         }
         await core_1.Utils.runSerial(lines, line => this.driver.execute(line));
     }
-    wrapSchema(sql, options = {}) {
+    wrapSchema(sql, options) {
         options.wrap ??= this.options.disableForeignKeys;
         if (!options.wrap || sql.trim() === '') {
             return sql;

package/typings.d.ts

@@ -39,6 +39,7 @@ export interface Column {
     scale?: number;
     default?: string | null;
     comment?: string;
+    nativeEnumName?: string;
     enumItems?: string[];
     primary?: boolean;
     unique?: boolean;