@mikro-orm/knex 6.6.5-dev.4 → 6.6.5-dev.6

package/AbstractSqlDriver.d.ts

@@ -61,7 +61,7 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     /**
      * @internal
      */
-    mapPropToFieldNames<T extends object>(qb: QueryBuilder<T, any, any, any>, prop: EntityProperty<T>, tableAlias?: string, explicitFields?: Field<T>[]): Field<T>[];
+    mapPropToFieldNames<T extends object>(qb: QueryBuilder<T, any, any, any>, prop: EntityProperty<T>, tableAlias: string | undefined, meta: EntityMetadata<T>, schema?: string, explicitFields?: readonly Field<T>[]): Field<T>[];
     /** @internal */
     createQueryBuilder<T extends object>(entityName: EntityName<T> | QueryBuilder<T, any, any, any>, ctx?: Transaction<Knex.Transaction>, preferredConnectionType?: ConnectionType, convertCustomTypes?: boolean, loggerContext?: LoggingOptions, alias?: string, em?: SqlEntityManager): QueryBuilder<T, any, any, any>;
     protected resolveConnectionType(args: {
@@ -77,5 +77,5 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     protected buildJoinedPropsOrderBy<T extends object>(qb: QueryBuilder<T, any, any, any>, meta: EntityMetadata<T>, populate: PopulateOptions<T>[], options?: Pick<FindOptions<any>, 'strategy' | 'orderBy' | 'populateOrderBy'>, parentPath?: string): QueryOrderMap<T>[];
     protected normalizeFields<T extends object>(fields: Field<T>[], prefix?: string): string[];
     protected processField<T extends object>(meta: EntityMetadata<T>, prop: EntityProperty<T> | undefined, field: string, ret: Field<T>[]): void;
-    protected buildFields<T extends object>(meta: EntityMetadata<T>, populate: PopulateOptions<T>[], joinedProps: PopulateOptions<T>[], qb: QueryBuilder<T, any, any, any>, alias: string, options: Pick<FindOptions<T, any, any, any>, 'strategy' | 'fields' | 'exclude'>): Field<T>[];
+    protected buildFields<T extends object>(meta: EntityMetadata<T>, populate: PopulateOptions<T>[], joinedProps: PopulateOptions<T>[], qb: QueryBuilder<T, any, any, any>, alias: string, options: Pick<FindOptions<T, any, any, any>, 'strategy' | 'fields' | 'exclude'>, schema?: string): Field<T>[];
 }

package/AbstractSqlDriver.js

@@ -31,9 +31,10 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         }
         const populate = this.autoJoinOneToOneOwner(meta, options.populate, options.fields);
         const joinedProps = this.joinedProps(meta, populate, options);
+        const schema = this.getSchemaName(meta, options);
         const qb = this.createQueryBuilder(entityName, options.ctx, options.connectionType, false, options.logging)
-            .withSchema(this.getSchemaName(meta, options));
-        const fields = this.buildFields(meta, populate, joinedProps, qb, qb.alias, options);
+            .withSchema(schema);
+        const fields = this.buildFields(meta, populate, joinedProps, qb, qb.alias, options, schema);
         const orderBy = this.buildOrderBy(qb, meta, populate, options);
         const populateWhere = this.buildPopulateWhere(meta, joinedProps, options);
         core_1.Utils.asArray(options.flags).forEach(flag => qb.setFlag(flag));
@@ -250,7 +251,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                     relationPojo[prop.name] = root[alias];
                 }
             });
-            const mapToPk = !!(ref || prop.mapToPk);
+            const mapToPk = !hint.dataOnly && !!(ref || prop.mapToPk);
             const targetProps = mapToPk
                 ? meta2.getPrimaryProps()
                 : meta2.props.filter(prop => this.platform.shouldHaveColumn(prop, hint.children || []));
@@ -320,10 +321,11 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         options = { populate: [], ...options };
         const populate = options.populate;
         const joinedProps = this.joinedProps(meta, populate, options);
+        const schema = this.getSchemaName(meta, options);
         const qb = this.createQueryBuilder(entityName, options.ctx, options.connectionType, false, options.logging);
         const populateWhere = this.buildPopulateWhere(meta, joinedProps, options);
         if (meta && !core_1.Utils.isEmpty(populate)) {
-            this.buildFields(meta, populate, joinedProps, qb, qb.alias, options);
+            this.buildFields(meta, populate, joinedProps, qb, qb.alias, options, schema);
         }
         qb.__populateWhere = options._populateWhere;
         qb.indexHint(options.indexHint)
@@ -332,7 +334,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             .groupBy(options.groupBy)
             .having(options.having)
             .populate(populate, joinedProps.length > 0 ? populateWhere : undefined, joinedProps.length > 0 ? options.populateFilter : undefined)
-            .withSchema(this.getSchemaName(meta, options))
+            .withSchema(schema)
             .where(where);
         if (options.em) {
             await qb.applyJoinedFilters(options.em, options.filters);
@@ -437,19 +439,21 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                     }
                     if (prop.fieldNames.length > 1) {
                         const newFields = [];
-                        const allParam = [...core_1.Utils.asArray(row[prop.name]) ?? prop.fieldNames.map(() => null)];
+                        const rawParam = core_1.Utils.asArray(row[prop.name]) ?? prop.fieldNames.map(() => null);
+                        // Deep flatten nested arrays when needed (for deeply nested composite keys like Tag -> Comment -> Post -> User)
+                        const needsFlatten = rawParam.length !== prop.fieldNames.length && rawParam.some(v => Array.isArray(v));
+                        const allParam = needsFlatten ? core_1.Utils.flatten(rawParam, true) : rawParam;
                         // TODO(v7): instead of making this conditional here, the entity snapshot should respect `ownColumns`,
                         //  but that means changing the compiled PK getters, which might be seen as breaking
                         const columns = allParam.length > 1 ? prop.fieldNames : prop.ownColumns;
-                        const newParam = [];
+                        const param = [];
                         columns.forEach((field, idx) => {
                             if (usedDups.includes(field)) {
                                 return;
                             }
                             newFields.push(field);
-                            newParam.push(allParam[idx]);
+                            param.push(allParam[idx]);
                         });
-                        const param = core_1.Utils.flatten(newParam);
                         newFields.forEach((field, idx) => {
                             if (!duplicates.includes(field) || !usedDups.includes(field)) {
                                 params.push(param[idx]);
@@ -801,7 +805,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             fields,
             exclude: childExclude,
             orderBy: this.getPivotOrderBy(prop, pivotProp1, orderBy, options?.orderBy),
-            populate: [{ field: populateField, strategy: core_1.LoadStrategy.JOINED, joinType: query_1.JoinType.innerJoin, children: populate }],
+            populate: [{ field: populateField, strategy: core_1.LoadStrategy.JOINED, joinType: query_1.JoinType.innerJoin, children: populate, dataOnly: pivotProp1.mapToPk && !pivotJoin }],
             populateWhere: undefined,
             // @ts-ignore
             _populateWhere: 'infer',
@@ -950,7 +954,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             // alias all fields in the primary table
             meta.props
                 .filter(prop => this.shouldHaveColumn(meta, prop, populate, explicitFields, exclude))
-                .forEach(prop => fields.push(...this.mapPropToFieldNames(qb, prop, parentTableAlias, explicitFields)));
+                .forEach(prop => fields.push(...this.mapPropToFieldNames(qb, prop, parentTableAlias, meta, undefined, explicitFields)));
         }
         for (const hint of joinedProps) {
             const [propName, ref] = hint.field.split(':', 2);
@@ -989,10 +993,10 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                 }
             });
             const childExclude = exclude ? core_1.Utils.extractChildElements(exclude, prop.name) : exclude;
-            if (!ref && !prop.mapToPk) {
+            if (!ref && (!prop.mapToPk || hint.dataOnly)) {
                 fields.push(...this.getFieldsForJoinedLoad(qb, meta2, childExplicitFields.length === 0 ? undefined : childExplicitFields, childExclude, hint.children, options, tableAlias, path));
             }
-            else if (hint.filter || prop.mapToPk || (ref && [core_1.ReferenceKind.MANY_TO_ONE, core_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind))) {
+            else if (hint.filter || (prop.mapToPk && !hint.dataOnly) || (ref && [core_1.ReferenceKind.MANY_TO_ONE, core_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind))) {
                 fields.push(...prop.referencedColumnNames.map(col => qb.helper.mapper(`${tableAlias}.${col}`, qb.type, undefined, `${tableAlias}__${col}`)));
             }
         }
@@ -1001,14 +1005,14 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
     /**
      * @internal
      */
-    mapPropToFieldNames(qb, prop, tableAlias, explicitFields) {
+    mapPropToFieldNames(qb, prop, tableAlias, meta, schema, explicitFields) {
         if (prop.kind === core_1.ReferenceKind.EMBEDDED && !prop.object) {
             return Object.entries(prop.embeddedProps).flatMap(([name, childProp]) => {
                 const childFields = explicitFields ? core_1.Utils.extractChildElements(explicitFields, prop.name) : [];
                 if (!this.shouldHaveColumn(prop.targetMeta, { ...childProp, name }, [], childFields.length > 0 ? childFields : undefined)) {
                     return [];
                 }
-                return this.mapPropToFieldNames(qb, childProp, tableAlias, childFields);
+                return this.mapPropToFieldNames(qb, childProp, tableAlias, meta, schema, childFields);
             });
         }
         const aliased = this.platform.quoteIdentifier(tableAlias ? `${tableAlias}__${prop.fieldNames[0]}` : prop.fieldNames[0]);
@@ -1028,7 +1032,17 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         }
         if (prop.formula) {
             const alias = this.platform.quoteIdentifier(tableAlias ?? qb.alias);
-            return [(0, core_1.raw)(`${prop.formula(alias)} as ${aliased}`)];
+            const effectiveSchema = schema ?? (meta.schema !== '*' ? meta.schema : undefined);
+            const qualifiedName = effectiveSchema ? `${effectiveSchema}.${meta.tableName}` : meta.tableName;
+            const table = {
+                alias: alias.toString(),
+                name: meta.tableName,
+                schema: effectiveSchema,
+                qualifiedName,
+                toString: () => alias.toString(),
+            };
+            const columns = meta.createColumnMappingObject();
+            return [(0, core_1.raw)(`${(prop.formula(table, columns))} as ${aliased}`)];
         }
         if (tableAlias) {
             return prop.fieldNames.map(fieldName => {
@@ -1258,7 +1272,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         }
         ret.push(prop.name);
     }
-    buildFields(meta, populate, joinedProps, qb, alias, options) {
+    buildFields(meta, populate, joinedProps, qb, alias, options, schema) {
         const lazyProps = meta.props.filter(prop => prop.lazy && !populate.some(p => this.isPopulated(meta, prop, p)));
         const hasLazyFormulas = meta.props.some(p => p.lazy && p.formula);
         const requiresSQLConversion = meta.props.some(p => p.customType?.convertToJSValueSQL && p.persist !== false);
@@ -1303,6 +1317,8 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             ret.push('*');
         }
         if (ret.length > 0 && !hasExplicitFields && addFormulas) {
+            const columns = meta.createColumnMappingObject();
+            const effectiveSchema = schema ?? (meta.schema !== '*' ? meta.schema : undefined);
             for (const prop of meta.props) {
                 if (lazyProps.includes(prop)) {
                     continue;
@@ -1310,7 +1326,15 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                 if (prop.formula) {
                     const a = this.platform.quoteIdentifier(alias);
                     const aliased = this.platform.quoteIdentifier(prop.fieldNames[0]);
-                    ret.push((0, core_1.raw)(`${prop.formula(a)} as ${aliased}`));
+                    const qualifiedName = effectiveSchema ? `${effectiveSchema}.${meta.tableName}` : meta.tableName;
+                    const table = {
+                        alias: a.toString(),
+                        name: meta.tableName,
+                        schema: effectiveSchema,
+                        qualifiedName,
+                        toString: () => a.toString(),
+                    };
+                    ret.push((0, core_1.raw)(`${(prop.formula(table, columns))} as ${aliased}`));
                 }
                 if (!prop.object && (prop.hasConvertToDatabaseValueSQL || prop.hasConvertToJSValueSQL)) {
                     ret.push(prop.name);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "6.6.5-dev.4",
+  "version": "6.6.5-dev.6",
   "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,7 +66,7 @@
     "@mikro-orm/core": "^6.6.4"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "6.6.5-dev.4",
+    "@mikro-orm/core": "6.6.5-dev.6",
     "better-sqlite3": "*",
     "libsql": "*",
     "mariadb": "*"

package/query/QueryBuilder.js

@@ -222,6 +222,8 @@ class QueryBuilder {
         const fields = [];
         const populate = [];
         const joinKey = Object.keys(this._joins).find(join => join.endsWith(`#${alias}`));
+        const targetMeta = prop.targetMeta;
+        const schema = this._schema ?? (targetMeta.schema !== '*' ? targetMeta.schema : undefined);
         if (joinKey) {
             const path = this._joins[joinKey].path.split('.').slice(1);
             let children = this._populate;
@@ -234,29 +236,29 @@ class QueryBuilder {
             }
             populate.push(...children);
         }
-        for (const p of prop.targetMeta.getPrimaryProps()) {
-            fields.push(...this.driver.mapPropToFieldNames(this, p, alias));
+        for (const p of targetMeta.getPrimaryProps()) {
+            fields.push(...this.driver.mapPropToFieldNames(this, p, alias, targetMeta, schema));
         }
         if (explicitFields) {
             for (const field of explicitFields) {
                 const [a, f] = this.helper.splitField(field);
-                const p = prop.targetMeta.properties[f];
+                const p = targetMeta.properties[f];
                 if (p) {
-                    fields.push(...this.driver.mapPropToFieldNames(this, p, alias));
+                    fields.push(...this.driver.mapPropToFieldNames(this, p, alias, targetMeta, schema));
                 }
                 else {
                     fields.push(`${a}.${f} as ${a}__${f}`);
                 }
             }
         }
-        prop.targetMeta.props
+        targetMeta.props
             .filter(prop => {
             if (!explicitFields) {
                 return this.platform.shouldHaveColumn(prop, populate);
             }
             return prop.primary && !explicitFields.includes(prop.name) && !explicitFields.includes(`${alias}.${prop.name}`);
         })
-            .forEach(prop => fields.push(...this.driver.mapPropToFieldNames(this, prop, alias)));
+            .forEach(prop => fields.push(...this.driver.mapPropToFieldNames(this, prop, alias, targetMeta, schema)));
         return fields;
     }
     /**
@@ -1164,12 +1166,15 @@ class QueryBuilder {
         this.processPopulateHint();
         this.processNestedJoins();
         if (meta && (this._fields?.includes('*') || this._fields?.includes(`${this.mainAlias.aliasName}.*`))) {
+            const schema = this.getSchema(this.mainAlias);
+            const columns = meta.createColumnMappingObject();
             meta.props
                 .filter(prop => prop.formula && (!prop.lazy || this.flags.has(core_1.QueryFlag.INCLUDE_LAZY_FORMULAS)))
                 .map(prop => {
-                const alias = this.knex.ref(this.mainAlias.aliasName).toString();
-                const aliased = this.knex.ref(prop.fieldNames[0]).toString();
-                return `${prop.formula(alias)} as ${aliased}`;
+                const alias = this.platform.quoteIdentifier(this.mainAlias.aliasName);
+                const aliased = this.platform.quoteIdentifier(prop.fieldNames[0]);
+                const table = this.helper.createFormulaTable(alias.toString(), meta, schema);
+                return `${(prop.formula(table, columns))} as ${aliased}`;
             })
                 .filter(field => !this._fields.some(f => {
                 if (f instanceof core_1.RawQueryFragment) {

package/query/QueryBuilderHelper.d.ts

@@ -1,5 +1,5 @@
 import type { Knex } from 'knex';
-import { type Dictionary, type EntityData, type EntityKey, type EntityMetadata, type EntityProperty, type FlatQueryOrderMap, LockMode, type QBFilterQuery, RawQueryFragment } from '@mikro-orm/core';
+import { type Dictionary, type EntityData, type EntityKey, type EntityMetadata, type EntityProperty, type FlatQueryOrderMap, type FormulaTable, LockMode, type QBFilterQuery, RawQueryFragment } from '@mikro-orm/core';
 import { JoinType, QueryType } from './enums';
 import type { Field, JoinOptions } from '../typings';
 import type { AbstractSqlDriver } from '../AbstractSqlDriver';
@@ -17,7 +17,7 @@ export declare class QueryBuilderHelper {
     private readonly metadata;
     constructor(entityName: string, alias: string, aliasMap: Dictionary<Alias<any>>, subQueries: Dictionary<string>, knex: Knex, driver: AbstractSqlDriver);
     mapper(field: string | Knex.Raw, type?: QueryType): string;
-    mapper(field: string | Knex.Raw, type?: QueryType, value?: any, alias?: string | null): string;
+    mapper(field: string | Knex.Raw, type?: QueryType, value?: any, alias?: string | null, schema?: string): string;
     processData(data: Dictionary, convertCustomTypes: boolean, multi?: boolean): any;
     joinOneToReference(prop: EntityProperty, ownerAlias: string, alias: string, type: JoinType, cond?: Dictionary, schema?: string): JoinOptions;
     joinManyToOneReference(prop: EntityProperty, ownerAlias: string, alias: string, type: JoinType, cond?: Dictionary, schema?: string): JoinOptions;
@@ -60,6 +60,7 @@ export declare class QueryBuilderHelper {
     getProperty(field: string, alias?: string): EntityProperty | undefined;
     isTableNameAliasRequired(type?: QueryType): boolean;
     processOnConflictCondition(cond: QBFilterQuery, schema?: string): QBFilterQuery;
+    createFormulaTable(alias: string, meta: EntityMetadata, schema?: string): FormulaTable;
 }
 export interface Alias<T> {
     aliasName: string;

package/query/QueryBuilderHelper.js

@@ -26,7 +26,7 @@ class QueryBuilderHelper {
         this.platform = this.driver.getPlatform();
         this.metadata = this.driver.getMetadata();
     }
-    mapper(field, type = enums_1.QueryType.SELECT, value, alias) {
+    mapper(field, type = enums_1.QueryType.SELECT, value, alias, schema) {
         if (core_1.Utils.isRawSql(field)) {
             return this.knex.raw(field.sql, field.params);
         }
@@ -87,7 +87,10 @@ class QueryBuilderHelper {
             const alias2 = this.knex.ref(a).toString();
             const aliased = this.knex.ref(prop.fieldNames[0]).toString();
             const as = alias === null ? '' : ` as ${aliased}`;
-            let value = prop.formula(alias2);
+            const meta = this.aliasMap[a]?.metadata ?? this.metadata.get(this.entityName);
+            const table = this.createFormulaTable(alias2, meta, schema);
+            const columns = meta.createColumnMappingObject();
+            let value = prop.formula(table, columns);
             if (!this.isTableNameAliasRequired(type)) {
                 value = value.replaceAll(alias2 + '.', '');
             }
@@ -208,7 +211,10 @@ class QueryBuilderHelper {
                 const right = `${join.alias}.${join.joinColumns[idx]}`;
                 if (join.prop.formula) {
                     const alias = this.platform.quoteIdentifier(join.ownerAlias);
-                    const left = join.prop.formula(alias);
+                    const ownerMeta = this.aliasMap[join.ownerAlias]?.metadata ?? this.metadata.get(this.entityName);
+                    const table = this.createFormulaTable(alias.toString(), ownerMeta, schema);
+                    const columns = ownerMeta.createColumnMappingObject();
+                    const left = join.prop.formula(table, columns);
                     conditions.push(`${left} = ${this.knex.ref(right)}`);
                     return;
                 }
@@ -770,5 +776,16 @@ class QueryBuilderHelper {
         }
         return cond;
     }
+    createFormulaTable(alias, meta, schema) {
+        const effectiveSchema = schema ?? (meta.schema !== '*' ? meta.schema : undefined);
+        const qualifiedName = effectiveSchema ? `${effectiveSchema}.${meta.tableName}` : meta.tableName;
+        return {
+            alias,
+            name: meta.tableName,
+            schema: effectiveSchema,
+            qualifiedName,
+            toString: () => alias,
+        };
+    }
 }
 exports.QueryBuilderHelper = QueryBuilderHelper;