@mikro-orm/sql 7.0.0-dev.97 → 7.0.0-dev.98

package/plugin/transformer.js

@@ -0,0 +1,883 @@
+import { ReferenceKind, isRaw, } from '@mikro-orm/core';
+import { AliasNode, ColumnNode, ColumnUpdateNode, OperationNodeTransformer, PrimitiveValueListNode, ReferenceNode, SchemableIdentifierNode, TableNode, ValueListNode, ValueNode, ValuesNode, } from 'kysely';
+export class MikroTransformer extends OperationNodeTransformer {
+    em;
+    options;
+    /**
+     * Context stack to support nested queries (subqueries, CTEs)
+     * Each level of query scope has its own Map of table aliases/names to EntityMetadata
+     * Top of stack (highest index) is the current scope
+     */
+    contextStack = [];
+    /**
+     * Subquery alias map: maps subquery/CTE alias to its source table metadata
+     * Used to resolve columns from subqueries/CTEs to their original table definitions
+     */
+    subqueryAliasMap = new Map();
+    metadata;
+    platform;
+    /**
+     * Global map of all entities involved in the query.
+     * Populated during AST transformation and used for result transformation.
+     */
+    entityMap = new Map();
+    constructor(em, options = {}) {
+        super();
+        this.em = em;
+        this.options = options;
+        this.metadata = em.getMetadata();
+        this.platform = em.getDriver().getPlatform();
+    }
+    reset() {
+        this.subqueryAliasMap.clear();
+        this.entityMap.clear();
+    }
+    getOutputEntityMap() {
+        return this.entityMap;
+    }
+    transformSelectQuery(node, queryId) {
+        // Push a new context for this query scope (starts with inherited parent context)
+        const currentContext = new Map();
+        this.contextStack.push(currentContext);
+        try {
+            // Process WITH clause (CTEs) first - they define names available in this scope
+            if (node.with) {
+                this.processWithNode(node.with, currentContext);
+            }
+            // Process FROM clause - main tables in this scope
+            if (node.from?.froms) {
+                for (const from of node.from.froms) {
+                    this.processFromItem(from, currentContext);
+                }
+            }
+            // Process JOINs - additional tables joined into this scope
+            if (node.joins) {
+                for (const join of node.joins) {
+                    this.processJoinNode(join, currentContext);
+                }
+            }
+            return super.transformSelectQuery(node, queryId);
+        }
+        finally {
+            // Pop the context when exiting this query scope
+            this.contextStack.pop();
+        }
+    }
+    transformInsertQuery(node, queryId) {
+        const currentContext = new Map();
+        this.contextStack.push(currentContext);
+        try {
+            let entityMeta;
+            if (node.into) {
+                const tableName = this.getTableName(node.into);
+                if (tableName) {
+                    const meta = this.findEntityMetadata(tableName);
+                    if (meta) {
+                        entityMeta = meta;
+                        currentContext.set(meta.tableName, meta);
+                        this.entityMap.set(meta.tableName, meta);
+                    }
+                }
+            }
+            const nodeWithHooks = this.options.processOnCreateHooks && entityMeta
+                ? this.processOnCreateHooks(node, entityMeta)
+                : node;
+            const nodeWithConvertedValues = this.options.convertValues && entityMeta
+                ? this.processInsertValues(nodeWithHooks, entityMeta)
+                : nodeWithHooks;
+            // Handle ON CONFLICT clause
+            let finalNode = nodeWithConvertedValues;
+            if (node.onConflict?.updates && entityMeta) {
+                // Create a temporary UpdateQueryNode to reuse processOnUpdateHooks and processUpdateValues
+                // We only care about the updates part
+                const tempUpdateNode = {
+                    kind: 'UpdateQueryNode',
+                    table: node.into, // Dummy table
+                    updates: node.onConflict.updates,
+                };
+                const updatesWithHooks = this.options.processOnUpdateHooks
+                    ? this.processOnUpdateHooks(tempUpdateNode, entityMeta).updates
+                    : node.onConflict.updates;
+                const tempUpdateNodeWithHooks = {
+                    ...tempUpdateNode,
+                    updates: updatesWithHooks,
+                };
+                const updatesWithConvertedValues = this.options.convertValues
+                    ? this.processUpdateValues(tempUpdateNodeWithHooks, entityMeta).updates
+                    : updatesWithHooks;
+                if (updatesWithConvertedValues && updatesWithConvertedValues !== node.onConflict.updates) {
+                    // Construct the new OnConflictNode with updated values
+                    finalNode = {
+                        ...finalNode,
+                        onConflict: {
+                            ...node.onConflict,
+                            updates: updatesWithConvertedValues,
+                        },
+                    };
+                }
+            }
+            return super.transformInsertQuery(finalNode, queryId);
+        }
+        finally {
+            this.contextStack.pop();
+        }
+    }
+    transformUpdateQuery(node, queryId) {
+        const currentContext = new Map();
+        this.contextStack.push(currentContext);
+        try {
+            let entityMeta;
+            if (node.table && TableNode.is(node.table)) {
+                const tableName = this.getTableName(node.table);
+                if (tableName) {
+                    const meta = this.findEntityMetadata(tableName);
+                    if (meta) {
+                        entityMeta = meta;
+                        currentContext.set(meta.tableName, meta);
+                        this.entityMap.set(meta.tableName, meta);
+                    }
+                }
+            }
+            // Process FROM clause in UPDATE queries (for UPDATE with JOIN)
+            if (node.from) {
+                for (const fromItem of node.from.froms) {
+                    this.processFromItem(fromItem, currentContext);
+                }
+            }
+            // Also process JOINs in UPDATE queries
+            if (node.joins) {
+                for (const join of node.joins) {
+                    this.processJoinNode(join, currentContext);
+                }
+            }
+            const nodeWithHooks = this.options.processOnUpdateHooks && entityMeta
+                ? this.processOnUpdateHooks(node, entityMeta)
+                : node;
+            const nodeWithConvertedValues = this.options.convertValues && entityMeta
+                ? this.processUpdateValues(nodeWithHooks, entityMeta)
+                : nodeWithHooks;
+            return super.transformUpdateQuery(nodeWithConvertedValues, queryId);
+        }
+        finally {
+            this.contextStack.pop();
+        }
+    }
+    transformDeleteQuery(node, queryId) {
+        const currentContext = new Map();
+        this.contextStack.push(currentContext);
+        try {
+            const froms = node.from?.froms;
+            if (froms && froms.length > 0) {
+                const firstFrom = froms[0];
+                if (TableNode.is(firstFrom)) {
+                    const tableName = this.getTableName(firstFrom);
+                    if (tableName) {
+                        const meta = this.findEntityMetadata(tableName);
+                        if (meta) {
+                            currentContext.set(meta.tableName, meta);
+                            this.entityMap.set(meta.tableName, meta);
+                        }
+                    }
+                }
+            }
+            // Also process JOINs in DELETE queries
+            if (node.joins) {
+                for (const join of node.joins) {
+                    this.processJoinNode(join, currentContext);
+                }
+            }
+            return super.transformDeleteQuery(node, queryId);
+        }
+        finally {
+            this.contextStack.pop();
+        }
+    }
+    transformMergeQuery(node, queryId) {
+        const currentContext = new Map();
+        this.contextStack.push(currentContext);
+        try {
+            return super.transformMergeQuery(node, queryId);
+        }
+        finally {
+            this.contextStack.pop();
+        }
+    }
+    transformIdentifier(node, queryId) {
+        node = super.transformIdentifier(node, queryId);
+        const parent = this.nodeStack[this.nodeStack.length - 2];
+        // Transform table names when tableNamingStrategy is 'entity'
+        if (this.options.tableNamingStrategy === 'entity' && parent && SchemableIdentifierNode.is(parent)) {
+            const meta = this.findEntityMetadata(node.name);
+            if (meta) {
+                return {
+                    ...node,
+                    name: meta.tableName,
+                };
+            }
+        }
+        // Transform column names when columnNamingStrategy is 'property'
+        // Support ColumnNode, ColumnUpdateNode, and ReferenceNode (for JOIN conditions)
+        if (this.options.columnNamingStrategy === 'property' && parent && (ColumnNode.is(parent) || ColumnUpdateNode.is(parent) || ReferenceNode.is(parent))) {
+            const ownerMeta = this.findOwnerEntityInContext();
+            if (ownerMeta) {
+                const prop = ownerMeta.properties[node.name];
+                const fieldName = prop?.fieldNames?.[0];
+                if (fieldName) {
+                    return {
+                        ...node,
+                        name: fieldName,
+                    };
+                }
+            }
+        }
+        return node;
+    }
+    /**
+     * Find owner entity metadata for the current identifier in the context stack.
+     * Supports both aliased and non-aliased table references.
+     * Searches up the context stack to support correlated subqueries.
+     * Also checks subquery/CTE aliases to resolve to their source tables.
+     */
+    findOwnerEntityInContext() {
+        // Check if current column has a table reference (e.g., u.firstName)
+        const reference = this.nodeStack.find(it => ReferenceNode.is(it));
+        if (reference?.table && TableNode.is(reference.table)) {
+            const tableName = this.getTableName(reference.table);
+            if (tableName) {
+                // First, check in subquery alias map (for CTE/subquery columns)
+                if (this.subqueryAliasMap.has(tableName)) {
+                    return this.subqueryAliasMap.get(tableName);
+                }
+                // Find entity metadata to get the actual table name
+                // Context uses table names (meta.tableName) as keys, not entity names
+                const entityMeta = this.findEntityMetadata(tableName);
+                if (entityMeta) {
+                    // Search in context stack using the actual table name
+                    const meta = this.lookupInContextStack(entityMeta.tableName);
+                    if (meta) {
+                        return meta;
+                    }
+                    // Also try with the entity name (for cases where context uses entity name)
+                    const metaByEntityName = this.lookupInContextStack(tableName);
+                    if (metaByEntityName) {
+                        return metaByEntityName;
+                    }
+                }
+                else {
+                    // If entity metadata not found, try direct lookup (for CTE/subquery cases)
+                    const meta = this.lookupInContextStack(tableName);
+                    if (meta) {
+                        return meta;
+                    }
+                }
+            }
+        }
+        // If no explicit table reference, use the first entity in current context
+        if (this.contextStack.length > 0) {
+            const currentContext = this.contextStack[this.contextStack.length - 1];
+            for (const [alias, meta] of currentContext.entries()) {
+                if (meta) {
+                    return meta;
+                }
+                // If the context value is undefined but the alias is in subqueryAliasMap,
+                // use the mapped metadata (for CTE/subquery cases)
+                if (!meta && this.subqueryAliasMap.has(alias)) {
+                    const mappedMeta = this.subqueryAliasMap.get(alias);
+                    if (mappedMeta) {
+                        return mappedMeta;
+                    }
+                }
+            }
+        }
+        return undefined;
+    }
+    processOnCreateHooks(node, meta) {
+        if (!node.columns || !node.values || !ValuesNode.is(node.values)) {
+            return node;
+        }
+        const existingProps = new Set();
+        for (const col of node.columns) {
+            const prop = this.findProperty(meta, this.normalizeColumnName(col.column));
+            if (prop) {
+                existingProps.add(prop.name);
+            }
+        }
+        const missingProps = meta.props.filter(prop => prop.onCreate && !existingProps.has(prop.name));
+        if (missingProps.length === 0) {
+            return node;
+        }
+        const newColumns = [...node.columns];
+        for (const prop of missingProps) {
+            newColumns.push(ColumnNode.create(prop.name));
+        }
+        const newRows = node.values.values.map(row => {
+            const valuesToAdd = missingProps.map(prop => {
+                const val = prop.onCreate(undefined, this.em);
+                return val;
+            });
+            if (ValueListNode.is(row)) {
+                const newValues = [...row.values, ...valuesToAdd.map(v => ValueNode.create(v))];
+                return ValueListNode.create(newValues);
+            }
+            if (PrimitiveValueListNode.is(row)) {
+                const newValues = [...row.values, ...valuesToAdd];
+                return PrimitiveValueListNode.create(newValues);
+            }
+            return row;
+        });
+        return {
+            ...node,
+            columns: Object.freeze(newColumns),
+            values: ValuesNode.create(newRows),
+        };
+    }
+    processOnUpdateHooks(node, meta) {
+        if (!node.updates) {
+            return node;
+        }
+        const existingProps = new Set();
+        for (const update of node.updates) {
+            if (ColumnNode.is(update.column)) {
+                const prop = this.findProperty(meta, this.normalizeColumnName(update.column.column));
+                if (prop) {
+                    existingProps.add(prop.name);
+                }
+            }
+        }
+        const missingProps = meta.props.filter(prop => prop.onUpdate && !existingProps.has(prop.name));
+        if (missingProps.length === 0) {
+            return node;
+        }
+        const newUpdates = [...node.updates];
+        for (const prop of missingProps) {
+            const val = prop.onUpdate(undefined, this.em);
+            newUpdates.push(ColumnUpdateNode.create(ColumnNode.create(prop.name), ValueNode.create(val)));
+        }
+        return {
+            ...node,
+            updates: Object.freeze(newUpdates),
+        };
+    }
+    processInsertValues(node, meta) {
+        if (!node.columns?.length || !node.values || !ValuesNode.is(node.values)) {
+            return node;
+        }
+        const columnProps = this.mapColumnsToProperties(node.columns, meta);
+        const shouldConvert = this.shouldConvertValues();
+        let changed = false;
+        const convertedRows = node.values.values.map(row => {
+            if (ValueListNode.is(row)) {
+                if (row.values.length !== columnProps.length) {
+                    return row;
+                }
+                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;
+                    }
+                    changed = true;
+                    return valueNode.immediate ? ValueNode.createImmediate(converted) : ValueNode.create(converted);
+                });
+                return ValueListNode.create(values);
+            }
+            if (PrimitiveValueListNode.is(row)) {
+                if (row.values.length !== columnProps.length) {
+                    return row;
+                }
+                const values = row.values.map((value, idx) => {
+                    const converted = this.prepareInputValue(columnProps[idx], value, shouldConvert);
+                    if (converted !== value) {
+                        changed = true;
+                    }
+                    return converted;
+                });
+                return PrimitiveValueListNode.create(values);
+            }
+            return row;
+        });
+        if (!changed) {
+            return node;
+        }
+        return {
+            ...node,
+            values: ValuesNode.create(convertedRows),
+        };
+    }
+    processUpdateValues(node, meta) {
+        if (!node.updates?.length) {
+            return node;
+        }
+        const shouldConvert = this.shouldConvertValues();
+        let changed = false;
+        const updates = node.updates.map(updateNode => {
+            if (!ValueNode.is(updateNode.value)) {
+                return updateNode;
+            }
+            const columnName = ColumnNode.is(updateNode.column)
+                ? 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) {
+                return updateNode;
+            }
+            changed = true;
+            const newValueNode = updateNode.value.immediate
+                ? ValueNode.createImmediate(converted)
+                : ValueNode.create(converted);
+            return {
+                ...updateNode,
+                value: newValueNode,
+            };
+        });
+        if (!changed) {
+            return node;
+        }
+        return {
+            ...node,
+            updates,
+        };
+    }
+    mapColumnsToProperties(columns, meta) {
+        return columns.map(column => {
+            const columnName = this.normalizeColumnName(column.column);
+            return this.findProperty(meta, columnName);
+        });
+    }
+    normalizeColumnName(identifier) {
+        const name = identifier.name;
+        if (!name.includes('.')) {
+            return name;
+        }
+        const parts = name.split('.');
+        return parts[parts.length - 1] ?? name;
+    }
+    findProperty(meta, columnName) {
+        if (!meta || !columnName) {
+            return undefined;
+        }
+        if (meta.properties[columnName]) {
+            return meta.properties[columnName];
+        }
+        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;
+        }
+        if (typeof value === 'object' && value !== null) {
+            if (isRaw(value)) {
+                return value;
+            }
+            if ('kind' in value) {
+                return value;
+            }
+        }
+        if (prop.customType && !isRaw(value)) {
+            return prop.customType.convertToDatabaseValue(value, this.platform, { fromQuery: true, key: prop.name, mode: 'query-data' });
+        }
+        if (value instanceof Date) {
+            return this.platform.processDateProperty(value);
+        }
+        return value;
+    }
+    /**
+     * Look up a table name/alias in the context stack.
+     * Searches from current scope (top of stack) to parent scopes (bottom).
+     * This supports correlated subqueries and references to outer query tables.
+     */
+    lookupInContextStack(tableNameOrAlias) {
+        // Search from top of stack (current scope) to bottom (parent scopes)
+        for (let i = this.contextStack.length - 1; i >= 0; i--) {
+            const context = this.contextStack[i];
+            if (context.has(tableNameOrAlias)) {
+                return context.get(tableNameOrAlias);
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Process WITH node (CTE definitions)
+     */
+    processWithNode(withNode, context) {
+        for (const cte of withNode.expressions) {
+            const cteName = this.getCTEName(cte.name);
+            if (cteName) {
+                // CTEs are not entities, so map to undefined
+                // They will be transformed recursively by transformSelectQuery
+                context.set(cteName, undefined);
+                // Also try to extract the source table from the CTE's expression
+                // This helps resolve columns in subsequent queries that use the CTE
+                if (cte.expression?.kind === 'SelectQueryNode') {
+                    const sourceMeta = this.extractSourceTableFromSelectQuery(cte.expression);
+                    if (sourceMeta) {
+                        this.subqueryAliasMap.set(cteName, sourceMeta);
+                        // Add CTE to entityMap so it can be used for result transformation if needed
+                        // (though CTEs usually don't appear in result rows directly, but their columns might)
+                        this.entityMap.set(cteName, sourceMeta);
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Extract CTE name from CommonTableExpressionNameNode
+     */
+    getCTEName(nameNode) {
+        if (TableNode.is(nameNode.table)) {
+            return this.getTableName(nameNode.table);
+        }
+        return undefined;
+    }
+    /**
+     * Process a FROM item (can be TableNode or AliasNode)
+     */
+    processFromItem(from, // OperationNode type - can be TableNode, AliasNode, or SelectQueryNode
+    context) {
+        if (AliasNode.is(from)) {
+            if (TableNode.is(from.node)) {
+                // Regular table with alias
+                const tableName = this.getTableName(from.node);
+                if (tableName && from.alias) {
+                    const meta = this.findEntityMetadata(tableName);
+                    const aliasName = this.extractAliasName(from.alias);
+                    if (aliasName) {
+                        context.set(aliasName, meta);
+                        if (meta) {
+                            this.entityMap.set(aliasName, meta);
+                        }
+                        // Also map the alias in subqueryAliasMap if the table name is a CTE
+                        if (this.subqueryAliasMap.has(tableName)) {
+                            this.subqueryAliasMap.set(aliasName, this.subqueryAliasMap.get(tableName));
+                        }
+                    }
+                }
+            }
+            else if (from.node?.kind === 'SelectQueryNode') {
+                // Subquery with alias
+                const aliasName = this.extractAliasName(from.alias);
+                if (aliasName) {
+                    context.set(aliasName, undefined);
+                    // Try to extract the source table from the subquery
+                    const sourceMeta = this.extractSourceTableFromSelectQuery(from.node);
+                    if (sourceMeta) {
+                        this.subqueryAliasMap.set(aliasName, sourceMeta);
+                    }
+                }
+            }
+            else {
+                // Other types with alias
+                const aliasName = this.extractAliasName(from.alias);
+                if (aliasName) {
+                    context.set(aliasName, undefined);
+                }
+            }
+        }
+        else if (TableNode.is(from)) {
+            // Table without alias
+            const tableName = this.getTableName(from);
+            if (tableName) {
+                const meta = this.findEntityMetadata(tableName);
+                context.set(tableName, meta);
+                if (meta) {
+                    this.entityMap.set(tableName, meta);
+                }
+            }
+        }
+    }
+    /**
+     * Process a JOIN node
+     */
+    processJoinNode(join, context) {
+        const joinTable = join.table;
+        if (AliasNode.is(joinTable)) {
+            if (TableNode.is(joinTable.node)) {
+                // Regular table with alias in JOIN
+                const tableName = this.getTableName(joinTable.node);
+                if (tableName && joinTable.alias) {
+                    const meta = this.findEntityMetadata(tableName);
+                    const aliasName = this.extractAliasName(joinTable.alias);
+                    if (aliasName) {
+                        context.set(aliasName, meta);
+                        if (meta) {
+                            this.entityMap.set(aliasName, meta);
+                        }
+                        // Also map the alias in subqueryAliasMap if the table name is a CTE
+                        if (this.subqueryAliasMap.has(tableName)) {
+                            this.subqueryAliasMap.set(aliasName, this.subqueryAliasMap.get(tableName));
+                        }
+                    }
+                }
+            }
+            else if (joinTable.node?.kind === 'SelectQueryNode') {
+                // Subquery with alias in JOIN
+                const aliasName = this.extractAliasName(joinTable.alias);
+                if (aliasName) {
+                    context.set(aliasName, undefined);
+                    // Try to extract the source table from the subquery
+                    const sourceMeta = this.extractSourceTableFromSelectQuery(joinTable.node);
+                    if (sourceMeta) {
+                        this.subqueryAliasMap.set(aliasName, sourceMeta);
+                    }
+                }
+            }
+            else {
+                // Other types with alias
+                const aliasName = this.extractAliasName(joinTable.alias);
+                if (aliasName) {
+                    context.set(aliasName, undefined);
+                }
+            }
+        }
+        else if (TableNode.is(joinTable)) {
+            // Table without alias in JOIN
+            const tableName = this.getTableName(joinTable);
+            if (tableName) {
+                const meta = this.findEntityMetadata(tableName);
+                // Use table name (meta.tableName) as key to match transformUpdateQuery behavior
+                if (meta) {
+                    context.set(meta.tableName, meta);
+                    this.entityMap.set(meta.tableName, meta);
+                    // Also set with entity name for backward compatibility
+                    context.set(tableName, meta);
+                }
+                else {
+                    context.set(tableName, undefined);
+                }
+            }
+        }
+    }
+    /**
+     * Extract the primary source table from a SELECT query
+     * This helps resolve columns from subqueries to their original entity tables
+     */
+    extractSourceTableFromSelectQuery(selectQuery) {
+        if (!selectQuery.from?.froms || selectQuery.from.froms.length === 0) {
+            return undefined;
+        }
+        // Get the first FROM table
+        const firstFrom = selectQuery.from.froms[0];
+        let sourceTable;
+        if (AliasNode.is(firstFrom) && TableNode.is(firstFrom.node)) {
+            sourceTable = firstFrom.node;
+        }
+        else if (TableNode.is(firstFrom)) {
+            sourceTable = firstFrom;
+        }
+        if (sourceTable) {
+            const tableName = this.getTableName(sourceTable);
+            if (tableName) {
+                return this.findEntityMetadata(tableName);
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Extract alias name from an alias node
+     */
+    extractAliasName(alias) {
+        if (typeof alias === 'object' && 'name' in alias) {
+            return alias.name;
+        }
+        return undefined;
+    }
+    /**
+     * Extract table name from a TableNode
+     */
+    getTableName(node) {
+        if (!node) {
+            return undefined;
+        }
+        if (TableNode.is(node) && SchemableIdentifierNode.is(node.table)) {
+            const identifier = node.table.identifier;
+            if (typeof identifier === 'object' && 'name' in identifier) {
+                return identifier.name;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Find entity metadata by table name or entity name
+     */
+    findEntityMetadata(name) {
+        const byEntity = this.metadata.find(name);
+        if (byEntity) {
+            return byEntity;
+        }
+        const allMetadata = Array.from(this.metadata);
+        const byTable = allMetadata.find(m => m.tableName === name);
+        if (byTable) {
+            return byTable;
+        }
+        return undefined;
+    }
+    /**
+     * Transform result rows by mapping database column names to property names
+     * This is called for SELECT queries when columnNamingStrategy is 'property'
+     */
+    transformResult(rows, entityMap) {
+        // Only transform if columnNamingStrategy is 'property' or convertValues is true, and we have data
+        if ((this.options.columnNamingStrategy !== 'property' && !this.options.convertValues) || !rows || rows.length === 0) {
+            return rows;
+        }
+        // If no entities found (e.g. raw query without known tables), return rows as is
+        if (entityMap.size === 0) {
+            return rows;
+        }
+        // Build a global mapping from database field names to property objects
+        const fieldToPropertyMap = this.buildGlobalFieldMap(entityMap);
+        const relationFieldMap = this.buildGlobalRelationFieldMap(entityMap);
+        // Transform each row
+        return rows.map(row => this.transformRow(row, fieldToPropertyMap, relationFieldMap));
+    }
+    buildGlobalFieldMap(entityMap) {
+        const map = {};
+        for (const [alias, meta] of entityMap.entries()) {
+            Object.assign(map, this.buildFieldToPropertyMap(meta, alias));
+        }
+        return map;
+    }
+    buildGlobalRelationFieldMap(entityMap) {
+        const map = {};
+        for (const [alias, meta] of entityMap.entries()) {
+            Object.assign(map, this.buildRelationFieldMap(meta, alias));
+        }
+        return map;
+    }
+    /**
+     * Build a mapping from database field names to property objects
+     * Format: { 'field_name': EntityProperty }
+     */
+    buildFieldToPropertyMap(meta, alias) {
+        const map = {};
+        for (const prop of meta.props) {
+            if (prop.fieldNames && prop.fieldNames.length > 0) {
+                for (const fieldName of prop.fieldNames) {
+                    if (!(fieldName in map)) {
+                        map[fieldName] = prop;
+                    }
+                    if (alias) {
+                        const dotted = `${alias}.${fieldName}`;
+                        if (!(dotted in map)) {
+                            map[dotted] = prop;
+                        }
+                        const underscored = `${alias}_${fieldName}`;
+                        if (!(underscored in map)) {
+                            map[underscored] = prop;
+                        }
+                        const doubleUnderscored = `${alias}__${fieldName}`;
+                        if (!(doubleUnderscored in map)) {
+                            map[doubleUnderscored] = prop;
+                        }
+                    }
+                }
+            }
+            if (!(prop.name in map)) {
+                map[prop.name] = prop;
+            }
+        }
+        return map;
+    }
+    /**
+     * Build a mapping for relation fields
+     * For ManyToOne relations, we need to map from the foreign key field to the relation property
+     * Format: { 'foreign_key_field': 'relationPropertyName' }
+     */
+    buildRelationFieldMap(meta, alias) {
+        const map = {};
+        for (const prop of meta.props) {
+            // For ManyToOne/OneToOne relations, find the foreign key field
+            if (prop.kind === ReferenceKind.MANY_TO_ONE || prop.kind === ReferenceKind.ONE_TO_ONE) {
+                if (prop.fieldNames && prop.fieldNames.length > 0) {
+                    const fieldName = prop.fieldNames[0];
+                    map[fieldName] = prop.name;
+                    if (alias) {
+                        map[`${alias}.${fieldName}`] = prop.name;
+                        map[`${alias}_${fieldName}`] = prop.name;
+                        map[`${alias}__${fieldName}`] = prop.name;
+                    }
+                }
+            }
+        }
+        return map;
+    }
+    /**
+     * Transform a single row by mapping column names to property names
+     */
+    transformRow(row, fieldToPropertyMap, relationFieldMap) {
+        const transformed = { ...row };
+        // First pass: map regular fields from fieldName to propertyName and convert values
+        for (const [fieldName, prop] of Object.entries(fieldToPropertyMap)) {
+            if (!(fieldName in transformed)) {
+                continue;
+            }
+            const converted = this.prepareOutputValue(prop, transformed[fieldName]);
+            if (this.options.columnNamingStrategy === 'property' && prop.name !== fieldName) {
+                if (!(prop.name in transformed)) {
+                    transformed[prop.name] = converted;
+                }
+                else {
+                    transformed[prop.name] = converted;
+                }
+                delete transformed[fieldName];
+                continue;
+            }
+            if (this.options.convertValues) {
+                transformed[fieldName] = converted;
+            }
+        }
+        // Second pass: handle relation fields
+        // Only run if columnNamingStrategy is 'property', as we don't want to rename FKs otherwise
+        if (this.options.columnNamingStrategy === 'property') {
+            for (const [fieldName, relationPropertyName] of Object.entries(relationFieldMap)) {
+                if (fieldName in transformed && !(relationPropertyName in transformed)) {
+                    // Move the foreign key value to the relation property name
+                    transformed[relationPropertyName] = transformed[fieldName];
+                    delete transformed[fieldName];
+                }
+            }
+        }
+        return transformed;
+    }
+    prepareOutputValue(prop, value) {
+        if (!this.options.convertValues || !prop || value == null) {
+            return value;
+        }
+        if (prop.customType) {
+            return prop.customType.convertToJSValue(value, this.platform);
+        }
+        // Aligned with EntityComparator.getResultMapper logic
+        if (prop.runtimeType === 'boolean') {
+            // Use !! conversion like EntityComparator: value == null ? value : !!value
+            return value == null ? value : !!value;
+        }
+        if (prop.runtimeType === 'Date' && !this.platform.isNumericProperty(prop)) {
+            // Aligned with EntityComparator: exclude numeric timestamp properties
+            // If already Date instance or null, return as is
+            if (value == null || value instanceof Date) {
+                return value;
+            }
+            // Handle timezone like EntityComparator.parseDate
+            const tz = this.platform.getTimezone();
+            if (!tz || tz === 'local') {
+                return this.platform.parseDate(value);
+            }
+            // For non-local timezone, check if value already has timezone info
+            // Number (timestamp) doesn't need timezone handling, string needs check
+            if (typeof value === 'number' || (typeof value === 'string' && (value.includes('+') || value.lastIndexOf('-') > 10 || value.endsWith('Z')))) {
+                return this.platform.parseDate(value);
+            }
+            // Append timezone if not present (only for string values)
+            return this.platform.parseDate(value + tz);
+        }
+        // For all other runtimeTypes (number, string, bigint, Buffer, object, any, etc.)
+        // EntityComparator just assigns directly without conversion
+        return value;
+    }
+}