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

package/AbstractSqlDriver.js

@@ -187,6 +187,10 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                 path += '[pivot]';
             }
             const relationAlias = qb.getAliasForJoinPath(path, { matchPopulateJoins: true });
+            /* istanbul ignore next */
+            if (!relationAlias) {
+                return;
+            }
             // pivot ref joins via joined strategy need to be handled separately here, as they dont join the target entity
             if (pivotRefJoin) {
                 let item;
@@ -212,10 +216,10 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             }));
             if (!hasPK) {
                 if ([core_1.ReferenceKind.MANY_TO_MANY, core_1.ReferenceKind.ONE_TO_MANY].includes(prop.kind)) {
-                    result[prop.name] ??= [];
+                    result[prop.name] = [];
                 }
                 if ([core_1.ReferenceKind.MANY_TO_ONE, core_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
-                    result[prop.name] ??= null;
+                    result[prop.name] = null;
                 }
                 return;
             }
@@ -709,12 +713,12 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                 const alias = qb.getNextAlias(prop.targetMeta.tableName);
                 qb.leftJoin(`${targetAlias}.${hint.field}`, alias);
                 // eslint-disable-next-line dot-notation
-                Object.values(qb['_joins']).forEach(join => {
+                for (const join of Object.values(qb['_joins'])) {
                     const [propName] = hint.field.split(':', 2);
                     if (join.alias === alias && join.prop.name === propName) {
                         fields.push(...qb.helper.mapJoinColumns(qb.type, join));
                     }
-                });
+                }
             });
         }
         qb.select(fields)
@@ -724,19 +728,30 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         if (owners.length === 1 && (options.offset != null || options.limit != null)) {
             qb.limit(options.limit, options.offset);
         }
+        // console.log('pivot qb', qb, qb._fields);
         const res = owners.length ? await this.rethrow(qb.execute('all', { mergeResults: false, mapResults: false })) : [];
-        const items = res.map((row) => super.mapResult(row, prop.targetMeta));
+        // console.log(res);
+        // const items = res.map((row: Dictionary) => super.mapResult(row, prop.targetMeta));
+        const tmp = {};
+        // const items = res.map((row: Dictionary) => this.mapResult(row, prop.targetMeta!, populate, qb, tmp));
+        // const items = res.map((row: Dictionary) => this.mapResult(row, pivotMeta, populate, qb, tmp));
+        const items = res.map((row) => {
+            const root = super.mapResult(row, prop.targetMeta);
+            this.mapJoinedProps(root, prop.targetMeta, populate, qb, root, tmp, pivotMeta.className + '.' + pivotProp1.name);
+            return root;
+        });
+        // console.log(prop.name, prop.targetMeta!.className, items);
         qb.clearRawFragmentsCache();
         const map = {};
         const pkProps = ownerMeta.getPrimaryProps();
-        owners.forEach(owner => {
+        for (const owner of owners) {
             const key = core_1.Utils.getPrimaryKeyHash(prop.joinColumns.map((_col, idx) => {
                 const pkProp = pkProps[idx];
                 return pkProp.customType ? pkProp.customType.convertToJSValue(owner[idx], this.platform) : owner[idx];
             }));
-            return map[key] = [];
-        });
-        items.forEach((item) => {
+            map[key] = [];
+        }
+        for (const item of items) {
             const key = core_1.Utils.getPrimaryKeyHash(prop.joinColumns.map((col, idx) => {
                 const pkProp = pkProps[idx];
                 return pkProp.customType ? pkProp.customType.convertToJSValue(item[`fk__${col}`], this.platform) : item[`fk__${col}`];
@@ -746,7 +761,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             prop.inverseJoinColumns.forEach((col, idx) => {
                 core_1.Utils.renameKey(item, `fk__${col}`, prop.targetMeta.primaryKeys[idx]);
             });
-        });
+        }
         return map;
     }
     getPivotOrderBy(prop, pivotProp, pivotAlias, orderBy) {
@@ -784,13 +799,14 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
      */
     joinedProps(meta, populate, options) {
         return populate.filter(hint => {
-            const [propName] = hint.field.split(':', 2);
+            const [propName, ref] = hint.field.split(':', 2);
             const prop = meta.properties[propName] || {};
             if (hint.filter && hint.strategy === core_1.LoadStrategy.JOINED) {
                 return true;
             }
             if ((options?.strategy || hint.strategy || prop.strategy || this.config.get('loadStrategy')) !== core_1.LoadStrategy.JOINED) {
-                return false;
+                // force joined strategy for explicit 1:1 owner populate hint as it would require a join anyway
+                return prop.kind === core_1.ReferenceKind.ONE_TO_ONE && !prop.owner;
             }
             return ![core_1.ReferenceKind.SCALAR, core_1.ReferenceKind.EMBEDDED].includes(prop.kind);
         });
@@ -861,6 +877,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             const prop = meta.properties[propName];
             // ignore ref joins of known FKs unless it's a filter hint
             if (ref && !hint.filter && (prop.kind === core_1.ReferenceKind.MANY_TO_ONE || (prop.kind === core_1.ReferenceKind.ONE_TO_ONE && !prop.owner))) {
+                // // console.log('wat', hint);
                 return;
             }
             const meta2 = this.metadata.find(prop.type);
@@ -894,9 +911,11 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                 fields.push(...this.getFieldsForJoinedLoad(qb, meta2, childExplicitFields.length === 0 ? undefined : childExplicitFields, childExclude, hint.children, options, tableAlias, path));
             }
             else if (hint.filter) {
-                fields.push(field);
+                // fields.push(field);
+                fields.push(...prop.referencedColumnNames.map(col => qb.helper.mapper(`${tableAlias}.${col}`, qb.type, undefined, `${tableAlias}__${col}`)));
             }
         });
+        // // console.log(fields, joinedProps);
         return fields;
     }
     /**

package/package.json

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

package/query/QueryBuilder.js

@@ -1072,6 +1072,7 @@ class QueryBuilder {
                 const alias = this.getNextAlias(prop.pivotEntity ?? prop.type);
                 const aliasedName = `${fromAlias}.${prop.name}#${alias}`;
                 this._joins[aliasedName] = this.helper.joinOneToReference(prop, this.mainAlias.aliasName, alias, enums_1.JoinType.leftJoin);
+                this._joins[aliasedName].path = `${(Object.values(this._joins).find(j => j.alias === fromAlias)?.path ?? meta.className)}.${prop.name}`;
                 this._populateMap[aliasedName] = this._joins[aliasedName].alias;
             }
         });
@@ -1131,6 +1132,10 @@ class QueryBuilder {
                     if (join.cond[k]) {
                         join.cond = { [op ?? '$and']: [join.cond, { [k]: cond[k] }] };
                     }
+                    else if (op === '$or') {
+                        join.cond.$or ??= [];
+                        join.cond.$or.push({ [k]: cond[k] });
+                    }
                     else {
                         join.cond = { ...join.cond, [k]: cond[k] };
                     }

package/query/QueryBuilderHelper.js

@@ -193,8 +193,10 @@ class QueryBuilderHelper {
                         conditions.push(`${left} = ${this.knex.ref(right)}`);
                         return;
                     }
-                    const left = `${join.ownerAlias}.${primaryKey}`;
-                    conditions.push(`${this.knex.ref(left)} = ${this.knex.ref(right)}`);
+                    const left = join.prop.object && join.prop.fieldNameRaw
+                        ? join.prop.fieldNameRaw.replaceAll(core_1.ALIAS_REPLACEMENT, join.ownerAlias)
+                        : this.knex.ref(`${join.ownerAlias}.${primaryKey}`);
+                    conditions.push(`${left} = ${this.knex.ref(right)}`);
                 });
             }
             if (join.prop.targetMeta?.discriminatorValue && !join.path?.endsWith('[pivot]')) {
@@ -295,7 +297,7 @@ class QueryBuilderHelper {
         if (join.prop && [core_1.ReferenceKind.MANY_TO_ONE, core_1.ReferenceKind.ONE_TO_ONE].includes(join.prop.kind)) {
             return join.prop.fieldNames.map((fieldName, idx) => {
                 const columns = join.prop.owner ? join.joinColumns : join.inverseJoinColumns;
-                return this.mapper(`${join.alias}.${columns[idx]}`, type, undefined, fieldName);
+                return this.mapper(`${join.alias}.${columns[idx]}`, type, undefined, `${join.alias}__${columns[idx]}`);
             });
         }
         return [

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