@mikro-orm/sql 7.0.0-dev.153 → 7.0.0-dev.155

package/AbstractSqlDriver.d.ts

@@ -62,7 +62,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?: readonly Field<T>[]): Field<T>[];
+    mapPropToFieldNames<T extends object>(qb: QueryBuilder<T, any, any, any>, prop: EntityProperty<T>, tableAlias: string, 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, preferredConnectionType?: ConnectionType, convertCustomTypes?: boolean, loggerContext?: LoggingOptions, alias?: string, em?: SqlEntityManager): QueryBuilder<T, any, any, any>;
     protected resolveConnectionType(args: {
@@ -78,7 +78,7 @@ 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>[];
 }
 interface FieldsForJoinedLoadOptions<T extends object> {
     explicitFields?: readonly Field<T>[];

package/AbstractSqlDriver.js

@@ -25,9 +25,10 @@ export class AbstractSqlDriver extends DatabaseDriver {
         const connectionType = this.resolveConnectionType({ ctx: options.ctx, connectionType: options.connectionType });
         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(meta.class, options.ctx, connectionType, false, options.logging, undefined, options.em)
-            .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);
         Utils.asArray(options.flags).forEach(flag => qb.setFlag(flag));
@@ -361,10 +362,11 @@ export class AbstractSqlDriver extends 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 && !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)
@@ -373,7 +375,7 @@ export class AbstractSqlDriver extends 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);
@@ -1008,7 +1010,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
             // alias all fields in the primary table
             meta.props
                 .filter(prop => this.shouldHaveColumn(meta, prop, populate, options.explicitFields, options.exclude))
-                .forEach(prop => fields.push(...this.mapPropToFieldNames(qb, prop, options.parentTableAlias, options.explicitFields)));
+                .forEach(prop => fields.push(...this.mapPropToFieldNames(qb, prop, options.parentTableAlias, meta, options.schema, options.explicitFields)));
         }
         for (const hint of joinedProps) {
             const [propName, ref] = hint.field.split(':', 2);
@@ -1074,14 +1076,14 @@ export class AbstractSqlDriver extends DatabaseDriver {
     /**
      * @internal
      */
-    mapPropToFieldNames(qb, prop, tableAlias, explicitFields) {
+    mapPropToFieldNames(qb, prop, tableAlias, meta, schema, explicitFields) {
         if (prop.kind === ReferenceKind.EMBEDDED && !prop.object) {
             return Object.entries(prop.embeddedProps).flatMap(([name, childProp]) => {
                 const childFields = explicitFields ? 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}__${prop.fieldNames[0]}`);
@@ -1101,7 +1103,17 @@ export class AbstractSqlDriver extends DatabaseDriver {
         }
         if (prop.formula) {
             const alias = this.platform.quoteIdentifier(tableAlias);
-            return [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 [raw(`${(prop.formula(table, columns))} as ${aliased}`)];
         }
         return prop.fieldNames.map(fieldName => {
             return `${tableAlias}.${fieldName} as ${tableAlias}__${fieldName}`;
@@ -1323,7 +1335,7 @@ export class AbstractSqlDriver extends 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);
@@ -1368,6 +1380,8 @@ export class AbstractSqlDriver extends 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;
@@ -1375,7 +1389,15 @@ export class AbstractSqlDriver extends DatabaseDriver {
                 if (prop.formula) {
                     const a = this.platform.quoteIdentifier(alias);
                     const aliased = this.platform.quoteIdentifier(prop.fieldNames[0]);
-                    ret.push(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(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/sql",
-  "version": "7.0.0-dev.153",
+  "version": "7.0.0-dev.155",
   "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.",
   "type": "module",
   "exports": {
@@ -56,6 +56,6 @@
     "@mikro-orm/core": "^6.6.4"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.0-dev.153"
+    "@mikro-orm/core": "7.0.0-dev.155"
   }
 }

package/query/QueryBuilder.js

@@ -209,6 +209,8 @@ export 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;
@@ -221,29 +223,29 @@ export 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;
     }
     /**
@@ -1177,12 +1179,15 @@ export 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(QueryFlag.INCLUDE_LAZY_FORMULAS)))
                 .map(prop => {
                 const alias = this.platform.quoteIdentifier(this.mainAlias.aliasName);
                 const aliased = this.platform.quoteIdentifier(prop.fieldNames[0]);
-                return `${prop.formula(alias)} as ${aliased}`;
+                const table = this.helper.createFormulaTable(alias.toString(), meta, schema);
+                return `${(prop.formula(table, columns))} as ${aliased}`;
             })
                 .filter(field => !this._fields.some(f => {
                 if (isRaw(f)) {

package/query/QueryBuilderHelper.d.ts

@@ -1,4 +1,4 @@
-import { type Dictionary, type EntityData, type EntityKey, type EntityMetadata, type EntityName, type EntityProperty, type FlatQueryOrderMap, LockMode, type QBFilterQuery, type QBQueryOrderMap, Raw, type RawQueryFragmentSymbol } from '@mikro-orm/core';
+import { type Dictionary, type EntityData, type EntityKey, type EntityMetadata, type EntityName, type EntityProperty, type FlatQueryOrderMap, type FormulaTable, LockMode, type QBFilterQuery, type QBQueryOrderMap, Raw, type RawQueryFragmentSymbol } from '@mikro-orm/core';
 import { JoinType, QueryType } from './enums.js';
 import type { Field, JoinOptions } from '../typings.js';
 import type { AbstractSqlDriver } from '../AbstractSqlDriver.js';
@@ -16,7 +16,7 @@ export declare class QueryBuilderHelper {
     private readonly metadata;
     constructor(entityName: EntityName, alias: string, aliasMap: Dictionary<Alias<any>>, subQueries: Dictionary<string>, driver: AbstractSqlDriver);
     mapper(field: string | Raw | RawQueryFragmentSymbol, type?: QueryType): string;
-    mapper(field: string | Raw | RawQueryFragmentSymbol, type?: QueryType, value?: any, alias?: string | null): string;
+    mapper(field: string | Raw | RawQueryFragmentSymbol, 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;
@@ -59,6 +59,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

@@ -21,7 +21,7 @@ export class QueryBuilderHelper {
         this.platform = this.driver.getPlatform();
         this.metadata = this.driver.getMetadata();
     }
-    mapper(field, type = QueryType.SELECT, value, alias) {
+    mapper(field, type = QueryType.SELECT, value, alias, schema) {
         if (isRaw(field)) {
             return raw(field.sql, field.params);
         }
@@ -83,7 +83,10 @@ export class QueryBuilderHelper {
             const alias2 = this.platform.quoteIdentifier(a).toString();
             const aliased = this.platform.quoteIdentifier(prop.fieldNames[0]).toString();
             const as = alias === null ? '' : ` as ${aliased}`;
-            let value = prop.formula(alias2);
+            const meta = this.aliasMap[a]?.meta ?? 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 + '.', '');
             }
@@ -201,7 +204,10 @@ export 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]?.meta ?? 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.platform.quoteIdentifier(right)}`);
                     return;
                 }
@@ -773,4 +779,15 @@ export 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,
+        };
+    }
 }