@mikro-orm/sql 7.0.15-dev.1 → 7.0.15-dev.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.0.15-dev.1",
+  "version": "7.0.15-dev.11",
   "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.",
   "keywords": [
     "data-mapper",
@@ -53,7 +53,7 @@
     "@mikro-orm/core": "^7.0.14"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.15-dev.1"
+    "@mikro-orm/core": "7.0.15-dev.11"
   },
   "engines": {
     "node": ">= 22.17.0"

package/plugin/transformer.d.ts

@@ -1,5 +1,5 @@
-import { type EntityMetadata, type EntityProperty } from '@mikro-orm/core';
-import { type CommonTableExpressionNameNode, type DeleteQueryNode, type IdentifierNode, type InsertQueryNode, type JoinNode, type MergeQueryNode, type QueryId, type SelectQueryNode, type UpdateQueryNode, type WithNode, ColumnNode, OperationNodeTransformer, TableNode } from 'kysely';
+import { type EntityMetadata, type EntityProperty, type Type } from '@mikro-orm/core';
+import { type CommonTableExpressionNameNode, type DeleteQueryNode, type InsertQueryNode, type JoinNode, type MergeQueryNode, type OperationNode, type QueryId, type SelectQueryNode, type UpdateQueryNode, type WithNode, ColumnNode, IdentifierNode, OperationNodeTransformer, SelectionNode, TableNode, ValueNode } from 'kysely';
 import type { MikroKyselyPluginOptions } from './index.js';
 import type { SqlEntityManager } from '../SqlEntityManager.js';
 export declare class MikroTransformer extends OperationNodeTransformer {
@@ -28,10 +28,18 @@ export declare class MikroTransformer extends OperationNodeTransformer {
     processOnUpdateHooks(node: UpdateQueryNode, meta: EntityMetadata): UpdateQueryNode;
     processInsertValues(node: InsertQueryNode, meta: EntityMetadata): InsertQueryNode;
     processUpdateValues(node: UpdateQueryNode, meta: EntityMetadata): UpdateQueryNode;
+    processInputValueNode(prop: EntityProperty | undefined, fieldName: string | undefined, valueNode: ValueNode): OperationNode;
+    expandSelections(selections: readonly SelectionNode[]): readonly SelectionNode[];
+    expandSelection(sel: SelectionNode): SelectionNode[] | null;
+    expandStar(meta: EntityMetadata | undefined, table: TableNode | undefined, tableName: string | undefined): SelectionNode[] | null;
+    wrapRead(customType: Type<any>, fieldName: string, tableName: string | undefined): SelectionNode;
+    wrapWrite(prop: EntityProperty | undefined, fieldName: string | undefined, valueNode: ValueNode): OperationNode;
+    /** Resolve the customType for a specific field name (handles composite-PK FK fan-out via prop.customTypes[]). */
+    fieldType(prop: EntityProperty, fieldName: string): Type<any> | undefined;
+    findOwnerMeta(name: string | undefined): EntityMetadata | undefined;
     mapColumnsToProperties(columns: readonly ColumnNode[], meta: EntityMetadata): (EntityProperty | undefined)[];
     normalizeColumnName(identifier: IdentifierNode): string;
     findProperty(meta: EntityMetadata | undefined, columnName?: string): EntityProperty | undefined;
-    shouldConvertValues(): boolean;
     prepareInputValue(prop: EntityProperty | undefined, value: unknown, enabled: boolean): unknown;
     /**
      * Look up a table name/alias in the context stack.

package/plugin/transformer.js

@@ -1,5 +1,11 @@
 import { ReferenceKind, isRaw, } from '@mikro-orm/core';
-import { AliasNode, ColumnNode, ColumnUpdateNode, OperationNodeTransformer, PrimitiveValueListNode, ReferenceNode, SchemableIdentifierNode, TableNode, ValueListNode, ValueNode, ValuesNode, } from 'kysely';
+import { AliasNode, ColumnNode, ColumnUpdateNode, IdentifierNode, OperationNodeTransformer, PrimitiveValueListNode, RawNode, ReferenceNode, SchemableIdentifierNode, SelectAllNode, SelectionNode, TableNode, ValueListNode, ValueNode, ValuesNode, } from 'kysely';
+const EXPANDABLE_KINDS = new Set([
+    ReferenceKind.SCALAR,
+    ReferenceKind.EMBEDDED,
+    ReferenceKind.MANY_TO_ONE,
+    ReferenceKind.ONE_TO_ONE,
+]);
 export class MikroTransformer extends OperationNodeTransformer {
     /**
      * Context stack to support nested queries (subqueries, CTEs)
@@ -64,7 +70,14 @@ export class MikroTransformer extends OperationNodeTransformer {
                     this.processJoinNode(join, currentContext);
                 }
             }
-            return super.transformSelectQuery(node, queryId);
+            const transformed = super.transformSelectQuery(node, queryId);
+            if (this.#options.convertValues && transformed.selections?.length) {
+                const selections = this.expandSelections(transformed.selections);
+                if (selections !== transformed.selections) {
+                    return { ...transformed, selections };
+                }
+            }
+            return transformed;
         }
         finally {
             // Pop the context when exiting this query scope
@@ -365,32 +378,38 @@ export class MikroTransformer extends OperationNodeTransformer {
             return node;
         }
         const columnProps = this.mapColumnsToProperties(node.columns, meta);
-        const shouldConvert = this.shouldConvertValues();
+        const fieldNames = node.columns.map(c => this.normalizeColumnName(c.column));
+        // hasConvertToDatabaseValueSQL is set by MetadataDiscovery only when the SQL is non-trivial
+        // (i.e. it actually wraps `?`), so a no-op cast on sqlite won't force a row upgrade.
+        const needsSqlWrap = columnProps.some(p => p?.hasConvertToDatabaseValueSQL);
         let changed = false;
         const convertedRows = node.values.values.map(row => {
-            if (ValueListNode.is(row)) {
-                if (row.values.length !== columnProps.length) {
-                    return row;
-                }
+            if (ValueListNode.is(row) && row.values.length === columnProps.length) {
                 const values = row.values.map((valueNode, idx) => {
                     if (!ValueNode.is(valueNode)) {
                         return valueNode;
                     }
-                    const converted = this.prepareInputValue(columnProps[idx], valueNode.value, shouldConvert);
-                    if (converted === valueNode.value) {
-                        return valueNode;
+                    const newNode = this.processInputValueNode(columnProps[idx], fieldNames[idx], valueNode);
+                    if (newNode !== valueNode) {
+                        changed = true;
                     }
-                    changed = true;
-                    return valueNode.immediate ? ValueNode.createImmediate(converted) : ValueNode.create(converted);
+                    return newNode;
                 });
                 return ValueListNode.create(values);
             }
-            if (PrimitiveValueListNode.is(row)) {
-                if (row.values.length !== columnProps.length) {
-                    return row;
+            if (PrimitiveValueListNode.is(row) && row.values.length === columnProps.length) {
+                // upgrade to ValueListNode when any column needs SQL-side wrapping, since
+                // PrimitiveValueListNode can only hold primitives
+                if (needsSqlWrap) {
+                    changed = true;
+                    return ValueListNode.create(row.values.map((value, idx) => {
+                        const prop = columnProps[idx];
+                        const converted = this.prepareInputValue(prop, value, true);
+                        return this.wrapWrite(prop, fieldNames[idx], ValueNode.create(converted));
+                    }));
                 }
                 const values = row.values.map((value, idx) => {
-                    const converted = this.prepareInputValue(columnProps[idx], value, shouldConvert);
+                    const converted = this.prepareInputValue(columnProps[idx], value, true);
                     if (converted !== value) {
                         changed = true;
                     }
@@ -412,7 +431,6 @@ export class MikroTransformer extends OperationNodeTransformer {
         if (!node.updates?.length) {
             return node;
         }
-        const shouldConvert = this.shouldConvertValues();
         let changed = false;
         const updates = node.updates.map(updateNode => {
             if (!ValueNode.is(updateNode.value)) {
@@ -422,18 +440,12 @@ export class MikroTransformer extends OperationNodeTransformer {
                 ? this.normalizeColumnName(updateNode.column.column)
                 : undefined;
             const property = this.findProperty(meta, columnName);
-            const converted = this.prepareInputValue(property, updateNode.value.value, shouldConvert);
-            if (converted === updateNode.value.value) {
+            const newValue = this.processInputValueNode(property, columnName, updateNode.value);
+            if (newValue === updateNode.value) {
                 return updateNode;
             }
             changed = true;
-            const newValueNode = updateNode.value.immediate
-                ? ValueNode.createImmediate(converted)
-                : ValueNode.create(converted);
-            return {
-                ...updateNode,
-                value: newValueNode,
-            };
+            return { ...updateNode, value: newValue };
         });
         if (!changed) {
             return node;
@@ -443,6 +455,106 @@ export class MikroTransformer extends OperationNodeTransformer {
             updates,
         };
     }
+    processInputValueNode(prop, fieldName, valueNode) {
+        const converted = this.prepareInputValue(prop, valueNode.value, true);
+        const newValueNode = converted === valueNode.value
+            ? valueNode
+            : valueNode.immediate
+                ? ValueNode.createImmediate(converted)
+                : ValueNode.create(converted);
+        return this.wrapWrite(prop, fieldName, newValueNode);
+    }
+    expandSelections(selections) {
+        const out = [];
+        let changed = false;
+        for (const sel of selections) {
+            const replaced = this.expandSelection(sel);
+            if (replaced) {
+                out.push(...replaced);
+                changed = true;
+            }
+            else {
+                out.push(sel);
+            }
+        }
+        return changed ? out : selections;
+    }
+    expandSelection(sel) {
+        const inner = sel.selection;
+        if (SelectAllNode.is(inner)) {
+            return this.expandStar(this.findOwnerMeta(undefined), undefined, undefined);
+        }
+        if (!ReferenceNode.is(inner)) {
+            return null;
+        }
+        const table = inner.table;
+        const tableName = table ? this.getTableName(table) : undefined;
+        const meta = this.findOwnerMeta(tableName);
+        if (!meta) {
+            return null;
+        }
+        if (SelectAllNode.is(inner.column)) {
+            return this.expandStar(meta, table, tableName);
+        }
+        const fieldName = inner.column.column.name;
+        const prop = this.findProperty(meta, fieldName);
+        const ct = prop && this.fieldType(prop, fieldName);
+        return ct?.convertToJSValueSQL ? [this.wrapRead(ct, fieldName, tableName)] : null;
+    }
+    expandStar(meta, table, tableName) {
+        if (!meta || !meta.props.some(p => p.hasConvertToJSValueSQL)) {
+            return null;
+        }
+        const out = [];
+        for (const prop of meta.props) {
+            if (prop.persist === false || !prop.fieldNames?.length || !EXPANDABLE_KINDS.has(prop.kind)) {
+                continue;
+            }
+            for (const fieldName of prop.fieldNames) {
+                const ct = this.fieldType(prop, fieldName);
+                out.push(ct?.convertToJSValueSQL
+                    ? this.wrapRead(ct, fieldName, tableName)
+                    : SelectionNode.create(table ? ReferenceNode.create(ColumnNode.create(fieldName), table) : ColumnNode.create(fieldName)));
+            }
+        }
+        return out;
+    }
+    wrapRead(customType, fieldName, tableName) {
+        const key = this.#platform.quoteIdentifier(tableName ? `${tableName}.${fieldName}` : fieldName);
+        const sql = customType.convertToJSValueSQL(key, this.#platform);
+        return SelectionNode.create(AliasNode.create(RawNode.createWithSql(sql), IdentifierNode.create(fieldName)));
+    }
+    wrapWrite(prop, fieldName, valueNode) {
+        if (!prop?.hasConvertToDatabaseValueSQL || !fieldName || valueNode.value == null || isRaw(valueNode.value)) {
+            return valueNode;
+        }
+        const customType = this.fieldType(prop, fieldName);
+        if (!customType?.convertToDatabaseValueSQL) {
+            return valueNode;
+        }
+        const fragments = customType.convertToDatabaseValueSQL('?', this.#platform).split('?');
+        return RawNode.create(fragments, fragments.slice(0, -1).map(() => valueNode));
+    }
+    /** Resolve the customType for a specific field name (handles composite-PK FK fan-out via prop.customTypes[]). */
+    fieldType(prop, fieldName) {
+        return prop.customType ?? prop.customTypes?.[prop.fieldNames.indexOf(fieldName)];
+    }
+    findOwnerMeta(name) {
+        if (name) {
+            return this.lookupInContextStack(name) ?? this.#subqueryAliasMap.get(name) ?? this.findEntityMetadata(name);
+        }
+        let single;
+        for (const meta of this.#contextStack[this.#contextStack.length - 1].values()) {
+            if (!meta) {
+                continue;
+            }
+            if (single && single !== meta) {
+                return undefined;
+            }
+            single = meta;
+        }
+        return single;
+    }
     mapColumnsToProperties(columns, meta) {
         return columns.map(column => {
             const columnName = this.normalizeColumnName(column.column);
@@ -466,9 +578,6 @@ export class MikroTransformer extends OperationNodeTransformer {
         }
         return meta.props.find(prop => prop.fieldNames?.includes(columnName));
     }
-    shouldConvertValues() {
-        return !!this.#options.convertValues;
-    }
     prepareInputValue(prop, value, enabled) {
         if (!enabled || !prop || value == null) {
             return value;

package/query/QueryBuilder.js

@@ -1347,6 +1347,7 @@ export class QueryBuilder {
             aliased: [QueryType.SELECT, QueryType.COUNT].includes(this.type),
         });
         const criteriaNode = CriteriaNodeFactory.createNode(this.metadata, prop.targetMeta.class, cond);
+        const joinCountBefore = Object.keys(this.#state.joins).length;
         cond = criteriaNode.process(this, { ignoreBranching: true, alias });
         let aliasedName = `${fromAlias}.${prop.name}#${alias}`;
         path ??= `${Object.values(this.#state.joins).find(j => j.alias === fromAlias)?.path ?? Utils.className(entityName)}.${prop.name}`;
@@ -1376,6 +1377,20 @@ export class QueryBuilder {
             this.#state.joins[aliasedName] = this.helper.joinManyToOneReference(prop, ownerAlias, alias, type, cond, schema);
             this.#state.joins[aliasedName].path ??= path;
         }
+        // auto-joins added by cond processing that depend on the new alias would otherwise produce a
+        // forward reference (the auto-join's ON refers to alias, while alias's ON refers back to it);
+        // fold them into the new join so both aliases share scope in the outer ON clause (issue #7681)
+        const condJoin = this.#state.joins[aliasedName];
+        const joinKeys = Object.keys(this.#state.joins);
+        for (let i = joinCountBefore; i < joinKeys.length; i++) {
+            const j = this.#state.joins[joinKeys[i]];
+            if (j === condJoin || j.ownerAlias !== alias) {
+                continue;
+            }
+            const nested = (condJoin.nested ??= new Set());
+            j.type = j.type === JoinType.innerJoin ? JoinType.nestedInnerJoin : JoinType.nestedLeftJoin;
+            nested.add(j);
+        }
         return { prop, key: aliasedName };
     }
     prepareFields(fields, type = 'where', schema) {