@mikro-orm/sql 7.0.0-dev.114 → 7.0.0-dev.116

package/AbstractSqlDriver.d.ts

@@ -15,23 +15,23 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     getPlatform(): Platform;
     createEntityManager(useContext?: boolean): this[typeof EntityManagerType];
     private createQueryBuilderFromOptions;
-    find<T extends object, P extends string = never, F extends string = PopulatePath.ALL, E extends string = never>(entityName: string, where: ObjectQuery<T>, options?: FindOptions<T, P, F, E>): Promise<EntityData<T>[]>;
-    findOne<T extends object, P extends string = never, F extends string = PopulatePath.ALL, E extends string = never>(entityName: string, where: ObjectQuery<T>, options?: FindOneOptions<T, P, F, E>): Promise<EntityData<T> | null>;
+    find<T extends object, P extends string = never, F extends string = PopulatePath.ALL, E extends string = never>(entityName: EntityName<T>, where: ObjectQuery<T>, options?: FindOptions<T, P, F, E>): Promise<EntityData<T>[]>;
+    findOne<T extends object, P extends string = never, F extends string = PopulatePath.ALL, E extends string = never>(entityName: EntityName<T>, where: ObjectQuery<T>, options?: FindOneOptions<T, P, F, E>): Promise<EntityData<T> | null>;
     protected hasToManyJoins<T extends object>(hint: PopulateOptions<T>, meta: EntityMetadata<T>): boolean;
-    findVirtual<T extends object>(entityName: string, where: ObjectQuery<T>, options: FindOptions<T, any, any, any>): Promise<EntityData<T>[]>;
-    countVirtual<T extends object>(entityName: string, where: ObjectQuery<T>, options: CountOptions<T, any>): Promise<number>;
-    protected findFromVirtual<T extends object>(entityName: string, where: ObjectQuery<T>, options: FindOptions<T, any> | CountOptions<T, any>, type: QueryType): Promise<EntityData<T>[] | number>;
+    findVirtual<T extends object>(entityName: EntityName<T>, where: ObjectQuery<T>, options: FindOptions<T, any, any, any>): Promise<EntityData<T>[]>;
+    countVirtual<T extends object>(entityName: EntityName<T>, where: ObjectQuery<T>, options: CountOptions<T, any>): Promise<number>;
+    protected findFromVirtual<T extends object>(entityName: EntityName<T>, where: ObjectQuery<T>, options: FindOptions<T, any> | CountOptions<T, any>, type: QueryType): Promise<EntityData<T>[] | number>;
     protected streamFromVirtual<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options: StreamOptions<T, any>): AsyncIterableIterator<EntityData<T>>;
     protected wrapVirtualExpressionInSubquery<T extends object>(meta: EntityMetadata<T>, expression: string, where: FilterQuery<T>, options: FindOptions<T, any>, type: QueryType): Promise<T[] | number>;
     protected wrapVirtualExpressionInSubqueryStream<T extends object>(meta: EntityMetadata<T>, expression: string, where: FilterQuery<T>, options: FindOptions<T, any, any, any>, type: QueryType.SELECT): AsyncIterableIterator<T>;
     mapResult<T extends object>(result: EntityData<T>, meta: EntityMetadata<T>, populate?: PopulateOptions<T>[], qb?: QueryBuilder<T, any, any, any>, map?: Dictionary): EntityData<T> | null;
     private mapJoinedProps;
-    count<T extends object>(entityName: string, where: any, options?: CountOptions<T>): Promise<number>;
-    nativeInsert<T extends object>(entityName: string, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
-    nativeInsertMany<T extends object>(entityName: string, data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>, transform?: (sql: string) => string): Promise<QueryResult<T>>;
-    nativeUpdate<T extends object>(entityName: string, where: FilterQuery<T>, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T> & UpsertOptions<T>): Promise<QueryResult<T>>;
-    nativeUpdateMany<T extends object>(entityName: string, where: FilterQuery<T>[], data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T> & UpsertManyOptions<T>): Promise<QueryResult<T>>;
-    nativeDelete<T extends object>(entityName: string, where: FilterQuery<T> | string | any, options?: DeleteOptions<T>): Promise<QueryResult<T>>;
+    count<T extends object>(entityName: EntityName<T>, where: any, options?: CountOptions<T>): Promise<number>;
+    nativeInsert<T extends object>(entityName: EntityName<T>, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
+    nativeInsertMany<T extends object>(entityName: EntityName<T>, data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>, transform?: (sql: string) => string): Promise<QueryResult<T>>;
+    nativeUpdate<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T> & UpsertOptions<T>): Promise<QueryResult<T>>;
+    nativeUpdateMany<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>[], data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T> & UpsertManyOptions<T>): Promise<QueryResult<T>>;
+    nativeDelete<T extends object>(entityName: EntityName<T>, where: FilterQuery<T> | string | any, options?: DeleteOptions<T>): Promise<QueryResult<T>>;
     /**
      * Fast comparison for collection snapshots that are represented by PK arrays.
      * Compares scalars via `===` and fallbacks to Utils.equals()` for more complex types like Buffer.
@@ -69,8 +69,8 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
         ctx?: Transaction;
         connectionType?: ConnectionType;
     }): ConnectionType;
-    protected extractManyToMany<T>(entityName: string, data: EntityDictionary<T>): EntityData<T>;
-    protected processManyToMany<T extends object>(meta: EntityMetadata<T> | undefined, pks: Primary<T>[], collections: EntityData<T>, clear: boolean, options?: DriverMethodOptions): Promise<void>;
+    protected extractManyToMany<T>(meta: EntityMetadata<T>, data: EntityDictionary<T>): EntityData<T>;
+    protected processManyToMany<T extends object>(meta: EntityMetadata<T>, pks: Primary<T>[], collections: EntityData<T>, clear: boolean, options?: DriverMethodOptions): Promise<void>;
     lockPessimistic<T extends object>(entity: T, options: LockOptions): Promise<void>;
     protected buildPopulateWhere<T extends object>(meta: EntityMetadata<T>, joinedProps: PopulateOptions<T>[], options: Pick<FindOptions<any>, 'populateWhere'>): ObjectQuery<T>;
     protected buildOrderBy<T extends object>(qb: QueryBuilder<T, any, any, any>, meta: EntityMetadata<T>, populate: PopulateOptions<T>[], options: Pick<FindOptions<any>, 'strategy' | 'orderBy' | 'populateOrderBy'>): QueryOrderMap<T>[];

package/AbstractSqlDriver.js

@@ -25,7 +25,8 @@ 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 qb = this.createQueryBuilder(meta.className, options.ctx, connectionType, false, options.logging, undefined, options.em);
+        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);
         const orderBy = this.buildOrderBy(qb, meta, populate, options);
         const populateWhere = this.buildPopulateWhere(meta, joinedProps, options);
@@ -44,8 +45,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
             .having(options.having)
             .indexHint(options.indexHint)
             .comment(options.comments)
-            .hintComment(options.hintComments)
-            .withSchema(this.getSchemaName(meta, options));
+            .hintComment(options.hintComments);
         if (isCursorPagination) {
             const { orderBy: newOrderBy, where } = this.processCursorOptions(meta, options, orderBy);
             qb.andWhere(where).orderBy(newOrderBy);
@@ -66,8 +66,8 @@ export class AbstractSqlDriver extends DatabaseDriver {
     }
     async find(entityName, where, options = {}) {
         options = { populate: [], orderBy: [], ...options };
-        const meta = this.metadata.find(entityName);
-        if (meta?.virtual) {
+        const meta = this.metadata.get(entityName);
+        if (meta.virtual) {
             return this.findVirtual(entityName, where, options);
         }
         const qb = await this.createQueryBuilderFromOptions(meta, where, options);
@@ -226,7 +226,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
                 return;
             }
             const pivotRefJoin = prop.kind === ReferenceKind.MANY_TO_MANY && ref;
-            const meta2 = this.metadata.find(prop.type);
+            const meta2 = prop.targetMeta;
             let path = parentJoinPath ? `${parentJoinPath}.${prop.name}` : `${meta.name}.${prop.name}`;
             if (!parentJoinPath) {
                 path = '[populate]' + path;
@@ -322,10 +322,10 @@ export class AbstractSqlDriver extends DatabaseDriver {
                     if (prop.kind === ReferenceKind.EMBEDDED && (prop.object || meta.embeddable)) {
                         const item = parseJsonSafe(relationPojo[prop.name]);
                         if (Array.isArray(item)) {
-                            relationPojo[prop.name] = item.map(row => row == null ? row : this.comparator.mapResult(prop.type, row));
+                            relationPojo[prop.name] = item.map(row => row == null ? row : this.comparator.mapResult(prop.targetMeta, row));
                         }
                         else {
-                            relationPojo[prop.name] = item == null ? item : this.comparator.mapResult(prop.type, item);
+                            relationPojo[prop.name] = item == null ? item : this.comparator.mapResult(prop.targetMeta, item);
                         }
                     }
                 }
@@ -382,19 +382,18 @@ export class AbstractSqlDriver extends DatabaseDriver {
     }
     async nativeInsert(entityName, data, options = {}) {
         options.convertCustomTypes ??= true;
-        const meta = this.metadata.find(entityName);
-        const collections = this.extractManyToMany(entityName, data);
-        const pks = meta?.primaryKeys ?? [this.config.getNamingStrategy().referenceColumnName()];
+        const meta = this.metadata.get(entityName);
+        const collections = this.extractManyToMany(meta, data);
         const qb = this.createQueryBuilder(entityName, options.ctx, 'write', options.convertCustomTypes, options.loggerContext).withSchema(this.getSchemaName(meta, options));
         const res = await this.rethrow(qb.insert(data).execute('run', false));
         res.row = res.row || {};
         let pk;
-        if (pks.length > 1) { // owner has composite pk
-            pk = Utils.getPrimaryKeyCond(data, pks);
+        if (meta.primaryKeys.length > 1) { // owner has composite pk
+            pk = Utils.getPrimaryKeyCond(data, meta.primaryKeys);
         }
         else {
             /* v8 ignore next */
-            res.insertId = data[pks[0]] ?? res.insertId ?? res.row[pks[0]];
+            res.insertId = data[meta.primaryKeys[0]] ?? res.insertId ?? res.row[meta.primaryKeys[0]];
             pk = [res.insertId];
         }
         await this.processManyToMany(meta, pk, collections, false, options);
@@ -403,23 +402,22 @@ export class AbstractSqlDriver extends DatabaseDriver {
     async nativeInsertMany(entityName, data, options = {}, transform) {
         options.processCollections ??= true;
         options.convertCustomTypes ??= true;
-        const meta = this.metadata.find(entityName)?.root;
-        const collections = options.processCollections ? data.map(d => this.extractManyToMany(entityName, d)) : [];
-        const pks = this.getPrimaryKeyFields(entityName);
+        const meta = this.metadata.get(entityName).root;
+        const collections = options.processCollections ? data.map(d => this.extractManyToMany(meta, d)) : [];
+        const pks = this.getPrimaryKeyFields(meta);
         const set = new Set();
         data.forEach(row => Utils.keys(row).forEach(k => set.add(k)));
-        const props = [...set].map(name => meta?.properties[name] ?? { name, fieldNames: [name] });
+        const props = [...set].map(name => meta.properties[name] ?? { name, fieldNames: [name] });
         let fields = Utils.flatten(props.map(prop => prop.fieldNames));
         const duplicates = Utils.findDuplicates(fields);
         const params = [];
         if (duplicates.length) {
             fields = Utils.unique(fields);
         }
-        /* v8 ignore next */
-        const tableName = meta ? this.getTableName(meta, options) : this.platform.quoteIdentifier(entityName);
+        const tableName = this.getTableName(meta, options);
         let sql = `insert into ${tableName} `;
         sql += fields.length > 0 ? '(' + fields.map(k => this.platform.quoteIdentifier(k)).join(', ') + ')' : `(${this.platform.quoteIdentifier(pks[0])})`;
-        if (meta && this.platform.usesOutputStatement()) {
+        if (this.platform.usesOutputStatement()) {
             const returningProps = meta.props
                 .filter(prop => prop.persist !== false && prop.defaultRaw || prop.autoincrement || prop.generated)
                 .filter(prop => !(prop.name in data[0]) || isRaw(data[0][prop.name]));
@@ -536,13 +534,13 @@ export class AbstractSqlDriver extends DatabaseDriver {
     }
     async nativeUpdate(entityName, where, data, options = {}) {
         options.convertCustomTypes ??= true;
-        const meta = this.metadata.find(entityName);
-        const pks = this.getPrimaryKeyFields(entityName);
-        const collections = this.extractManyToMany(entityName, data);
+        const meta = this.metadata.get(entityName);
+        const pks = this.getPrimaryKeyFields(meta);
+        const collections = this.extractManyToMany(meta, data);
         let res = { affectedRows: 0, insertId: 0, row: {} };
         if (Utils.isPrimaryKey(where) && pks.length === 1) {
             /* v8 ignore next */
-            where = { [meta?.primaryKeys[0] ?? pks[0]]: where };
+            where = { [meta.primaryKeys[0] ?? pks[0]]: where };
         }
         if (Utils.hasObjectKeys(data)) {
             const qb = this.createQueryBuilder(entityName, options.ctx, 'write', options.convertCustomTypes, options.loggerContext)
@@ -566,7 +564,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
                 qb.update(data).where(where);
                 // reload generated columns and version fields
                 const returning = [];
-                meta?.props
+                meta.props
                     .filter(prop => (prop.generated && !prop.primary) || prop.version)
                     .forEach(prop => returning.push(prop.name));
                 qb.returning(returning);
@@ -598,7 +596,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
             }
             return this.rethrow(qb.execute('run', false));
         }
-        const collections = options.processCollections ? data.map(d => this.extractManyToMany(entityName, d)) : [];
+        const collections = options.processCollections ? data.map(d => this.extractManyToMany(meta, d)) : [];
         const keys = new Set();
         const fields = new Set();
         const returning = new Set();
@@ -611,7 +609,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
             }
         }
         // reload generated columns and version fields
-        meta?.props
+        meta.props
             .filter(prop => prop.generated || prop.version || prop.primary)
             .forEach(prop => returning.add(prop.name));
         const pkCond = Utils.flatten(meta.primaryKeys.map(pk => meta.properties[pk].fieldNames)).map(pk => `${this.platform.quoteIdentifier(pk)} = ?`).join(' and ');
@@ -704,8 +702,8 @@ export class AbstractSqlDriver extends DatabaseDriver {
         return res;
     }
     async nativeDelete(entityName, where, options = {}) {
-        const meta = this.metadata.find(entityName);
-        const pks = this.getPrimaryKeyFields(entityName);
+        const meta = this.metadata.get(entityName);
+        const pks = this.getPrimaryKeyFields(meta);
         if (Utils.isPrimaryKey(where) && pks.length === 1) {
             where = { [pks[0]]: where };
         }
@@ -758,7 +756,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
             }
             if (coll.property.kind === ReferenceKind.ONE_TO_MANY) {
                 const cols = coll.property.referencedColumnNames;
-                const qb = this.createQueryBuilder(coll.property.type, options?.ctx, 'write')
+                const qb = this.createQueryBuilder(coll.property.targetMeta.class, options?.ctx, 'write')
                     .withSchema(this.getSchemaName(meta, options));
                 if (coll.getSnapshot() === undefined) {
                     if (coll.property.orphanRemoval) {
@@ -779,7 +777,6 @@ export class AbstractSqlDriver extends DatabaseDriver {
                 await this.rethrow(query.execute());
                 continue;
             }
-            /* v8 ignore next */
             const pivotMeta = this.metadata.find(coll.property.pivotEntity);
             let schema = pivotMeta.schema;
             if (schema === '*') {
@@ -807,10 +804,10 @@ export class AbstractSqlDriver extends DatabaseDriver {
         if (owners.length === 0) {
             return {};
         }
-        const pivotMeta = this.metadata.find(prop.pivotEntity);
+        const pivotMeta = this.metadata.get(prop.pivotEntity);
         const pivotProp1 = pivotMeta.relations[prop.owner ? 1 : 0];
         const pivotProp2 = pivotMeta.relations[prop.owner ? 0 : 1];
-        const ownerMeta = this.metadata.find(pivotProp2.type);
+        const ownerMeta = pivotProp2.targetMeta;
         const cond = {
             [pivotProp2.name]: { $in: ownerMeta.compositePK ? owners : owners.map(o => o[0]) },
         };
@@ -825,7 +822,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
         const fields = pivotJoin
             ? [pivotProp1.name, pivotProp2.name]
             : [pivotProp1.name, pivotProp2.name, ...childFields];
-        const res = await this.find(pivotMeta.className, where, {
+        const res = await this.find(pivotMeta.class, where, {
             ctx,
             ...options,
             fields,
@@ -870,8 +867,8 @@ export class AbstractSqlDriver extends DatabaseDriver {
     }
     async *stream(entityName, where, options) {
         options = { populate: [], orderBy: [], ...options };
-        const meta = this.metadata.find(entityName);
-        if (meta?.virtual) {
+        const meta = this.metadata.get(entityName);
+        if (meta.virtual) {
             yield* this.streamFromVirtual(entityName, where, options);
             return;
         }
@@ -1008,7 +1005,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
             if (ref && !hint.filter && (prop.kind === ReferenceKind.MANY_TO_ONE || (prop.kind === ReferenceKind.ONE_TO_ONE && prop.owner))) {
                 continue;
             }
-            const meta2 = this.metadata.find(prop.type);
+            const meta2 = prop.targetMeta;
             const pivotRefJoin = prop.kind === ReferenceKind.MANY_TO_MANY && ref;
             const tableAlias = qb.getNextAlias(prop.name);
             const field = `${options.parentTableAlias}.${prop.name}`;
@@ -1119,26 +1116,20 @@ export class AbstractSqlDriver extends DatabaseDriver {
         }
         return 'write';
     }
-    extractManyToMany(entityName, data) {
-        if (!this.metadata.has(entityName)) {
-            return {};
-        }
+    extractManyToMany(meta, data) {
         const ret = {};
-        this.metadata.find(entityName).relations.forEach(prop => {
+        for (const prop of meta.relations) {
             if (prop.kind === ReferenceKind.MANY_TO_MANY && data[prop.name]) {
                 ret[prop.name] = data[prop.name].map((item) => Utils.asArray(item));
                 delete data[prop.name];
             }
-        });
+        }
         return ret;
     }
     async processManyToMany(meta, pks, collections, clear, options) {
-        if (!meta) {
-            return;
-        }
         for (const prop of meta.relations) {
             if (collections[prop.name]) {
-                const pivotMeta = this.metadata.find(prop.pivotEntity);
+                const pivotMeta = this.metadata.get(prop.pivotEntity);
                 const persister = new PivotCollectionPersister(pivotMeta, this, options?.ctx, options?.schema, options?.loggerContext);
                 persister.enqueueUpdate(prop, collections[prop.name], clear, pks);
                 await this.rethrow(persister.execute());
@@ -1147,7 +1138,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
     }
     async lockPessimistic(entity, options) {
         const meta = helper(entity).__meta;
-        const qb = this.createQueryBuilder(entity.constructor.name, options.ctx, undefined, undefined, options.logging).withSchema(options.schema ?? meta.schema);
+        const qb = this.createQueryBuilder(meta.class, options.ctx, undefined, undefined, options.logging).withSchema(options.schema ?? meta.schema);
         const cond = Utils.getPrimaryKeyCond(entity, meta.primaryKeys);
         qb.select(raw('1')).where(cond).setLockMode(options.lockMode, options.lockTableAliases);
         await this.rethrow(qb.execute());
@@ -1205,7 +1196,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
                     throw new Error(`Trying to order by not existing property ${meta.className}.${field}`);
                 }
                 let path = parentPath;
-                const meta2 = this.metadata.find(prop.type);
+                const meta2 = prop.targetMeta;
                 if (prop.kind !== ReferenceKind.SCALAR && (![ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) || !prop.owner || Utils.isPlainObject(childOrder))) {
                     path += `.${field}`;
                 }
@@ -1254,7 +1245,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
             }
             const join = qb.getJoinForPath(path, { matchPopulateJoins: true });
             const propAlias = qb.getAliasForJoinPath(join ?? path, { matchPopulateJoins: true });
-            const meta2 = this.metadata.find(prop.type);
+            const meta2 = prop.targetMeta;
             if (prop.kind === ReferenceKind.MANY_TO_MANY && prop.fixedOrder && join) {
                 const alias = ref ? propAlias : join.ownerAlias;
                 orderBy.push({ [`${alias}.${prop.fixedOrderColumn}`]: QueryOrder.ASC });
@@ -1338,7 +1329,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
                 const prop = QueryHelper.findProperty(rootPropName, {
                     metadata: this.metadata,
                     platform: this.platform,
-                    entityName: meta.className,
+                    entityName: meta.class,
                     where: {},
                     aliasMap: qb.getAliasMap(),
                 });

package/PivotCollectionPersister.js

@@ -120,7 +120,7 @@ export class PivotCollectionPersister {
                 for (const item of chunk) {
                     cond.$or.push(item.getCondition());
                 }
-                await this.driver.nativeDelete(this.meta.className, cond, {
+                await this.driver.nativeDelete(this.meta.class, cond, {
                     ctx: this.ctx,
                     schema: this.schema,
                     loggerContext: this.loggerContext,
@@ -131,7 +131,7 @@ export class PivotCollectionPersister {
             const filtered = this.collectStatements(this.inserts);
             for (let i = 0; i < filtered.length; i += this.batchSize) {
                 const chunk = filtered.slice(i, i + this.batchSize);
-                await this.driver.nativeInsertMany(this.meta.className, chunk, {
+                await this.driver.nativeInsertMany(this.meta.class, chunk, {
                     ctx: this.ctx,
                     schema: this.schema,
                     convertCustomTypes: false,
@@ -144,7 +144,7 @@ export class PivotCollectionPersister {
             const filtered = this.collectStatements(this.upserts);
             for (let i = 0; i < filtered.length; i += this.batchSize) {
                 const chunk = filtered.slice(i, i + this.batchSize);
-                await this.driver.nativeUpdateMany(this.meta.className, [], chunk, {
+                await this.driver.nativeUpdateMany(this.meta.class, [], chunk, {
                     ctx: this.ctx,
                     schema: this.schema,
                     convertCustomTypes: false,

package/SqlEntityManager.d.ts

@@ -27,7 +27,7 @@ export declare class SqlEntityManager<Driver extends AbstractSqlDriver = Abstrac
     getKysely<TDB = undefined, TOptions extends GetKyselyOptions = GetKyselyOptions>(options?: TOptions): Kysely<TDB extends undefined ? InferKyselyDB<EntitiesFromManager<this>, TOptions> : TDB>;
     execute<T extends QueryResult | EntityData<AnyEntity> | EntityData<AnyEntity>[] = EntityData<AnyEntity>[]>(query: string | NativeQueryBuilder | RawQueryFragment, params?: any[], method?: 'all' | 'get' | 'run', loggerContext?: LoggingOptions): Promise<T>;
     getRepository<T extends object, U extends EntityRepository<T> = SqlEntityRepository<T>>(entityName: EntityName<T>): GetRepository<T, U>;
-    protected applyDiscriminatorCondition<Entity extends object>(entityName: string, where: FilterQuery<Entity>): FilterQuery<Entity>;
+    protected applyDiscriminatorCondition<Entity extends object>(entityName: EntityName<Entity>, where: FilterQuery<Entity>): FilterQuery<Entity>;
 }
 type EntitiesFromManager<TEntityManager extends EntityManager<any>> = NonNullable<TEntityManager['~entities']> extends any[] ? (Extract<NonNullable<TEntityManager['~entities']>[number], EntitySchemaWithMeta>) : never;
 export {};

package/dialects/postgresql/BasePostgreSqlPlatform.js

@@ -172,6 +172,7 @@ export class BasePostgreSqlPlatform extends AbstractSqlPlatform {
         const quote = (v) => v === '' || v.match(/["{},\\]/) ? JSON.stringify(v) : v;
         return `{${values.map(v => quote('' + v)).join(',')}}`;
     }
+    /* v8 ignore next */
     unmarshallArray(value) {
         if (value === '{}') {
             return [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.0.0-dev.114",
+  "version": "7.0.0-dev.116",
   "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": {
@@ -53,9 +53,9 @@
     "kysely": "0.28.9"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^6.6.2"
+    "@mikro-orm/core": "^6.6.3"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.0-dev.114"
+    "@mikro-orm/core": "7.0.0-dev.116"
   }
 }

package/plugin/transformer.js

@@ -706,7 +706,7 @@ export class MikroTransformer extends OperationNodeTransformer {
      * Find entity metadata by table name or entity name
      */
     findEntityMetadata(name) {
-        const byEntity = this.metadata.find(name);
+        const byEntity = this.metadata.getByClassName(name, false);
         if (byEntity) {
             return byEntity;
         }

package/query/CriteriaNode.d.ts

@@ -1,4 +1,4 @@
-import { type EntityKey, type EntityProperty, type MetadataStorage, type RawQueryFragmentSymbol } from '@mikro-orm/core';
+import { type EntityKey, type EntityProperty, type MetadataStorage, type RawQueryFragmentSymbol, type EntityName } from '@mikro-orm/core';
 import type { ICriteriaNode, ICriteriaNodeProcessOptions, IQueryBuilder } from '../typings.js';
 /**
  * Helper for working with deeply nested where/orderBy/having criteria. Uses composite pattern to build tree from the payload.
@@ -7,14 +7,14 @@ import type { ICriteriaNode, ICriteriaNodeProcessOptions, IQueryBuilder } from '
  */
 export declare class CriteriaNode<T extends object> implements ICriteriaNode<T> {
     protected readonly metadata: MetadataStorage;
-    readonly entityName: string;
+    readonly entityName: EntityName<T>;
     readonly parent?: ICriteriaNode<T> | undefined;
     readonly key?: (EntityKey<T> | RawQueryFragmentSymbol) | undefined;
     readonly strict: boolean;
     payload: any;
     prop?: EntityProperty<T>;
     index?: number;
-    constructor(metadata: MetadataStorage, entityName: string, parent?: ICriteriaNode<T> | undefined, key?: (EntityKey<T> | RawQueryFragmentSymbol) | undefined, validate?: boolean, strict?: boolean);
+    constructor(metadata: MetadataStorage, entityName: EntityName<T>, parent?: ICriteriaNode<T> | undefined, key?: (EntityKey<T> | RawQueryFragmentSymbol) | undefined, validate?: boolean, strict?: boolean);
     process(qb: IQueryBuilder<T>, options?: ICriteriaNodeProcessOptions): any;
     unwrap(): any;
     shouldInline(payload: any): boolean;

package/query/CriteriaNode.js

@@ -30,7 +30,7 @@ export class CriteriaNode {
                 const isProp = this.prop || meta.props.find(prop => (prop.fieldNames || []).includes(k));
                 // do not validate if the key is prefixed or type casted (e.g. `k::text`)
                 if (validate && !isProp && !k.includes('.') && !k.includes('::') && !Utils.isOperator(k)) {
-                    throw new Error(`Trying to query by not existing property ${entityName}.${k}`);
+                    throw new Error(`Trying to query by not existing property ${Utils.className(entityName)}.${k}`);
                 }
             }
         }
@@ -79,7 +79,7 @@ export class CriteriaNode {
     getPath(addIndex = false) {
         // use index on parent only if we are processing to-many relation
         const addParentIndex = this.prop && [ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(this.prop.kind);
-        const parentPath = this.parent?.getPath(addParentIndex) ?? this.entityName;
+        const parentPath = this.parent?.getPath(addParentIndex) ?? Utils.className(this.entityName);
         const index = addIndex && this.index != null ? `[${this.index}]` : '';
         // ignore group operators to allow easier mapping (e.g. for orderBy)
         const key = this.key && !RawQueryFragment.isKnownFragmentSymbol(this.key) && !['$and', '$or', '$not'].includes(this.key) ? '.' + this.key : '';
@@ -109,6 +109,7 @@ export class CriteriaNode {
         return this.strict;
     }
     /** @ignore */
+    /* v8 ignore next */
     [Symbol.for('nodejs.util.inspect.custom')]() {
         const o = {};
         ['entityName', 'key', 'index', 'payload']

package/query/CriteriaNodeFactory.d.ts

@@ -1,12 +1,12 @@
-import { type Dictionary, type EntityKey, type EntityMetadata, type MetadataStorage, type RawQueryFragmentSymbol } from '@mikro-orm/core';
+import { type Dictionary, type EntityKey, type EntityMetadata, type EntityName, type MetadataStorage, type RawQueryFragmentSymbol } from '@mikro-orm/core';
 import type { ICriteriaNode } from '../typings.js';
 /**
  * @internal
  */
 export declare class CriteriaNodeFactory {
-    static createNode<T extends object>(metadata: MetadataStorage, entityName: string, payload: any, parent?: ICriteriaNode<T>, key?: EntityKey<T> | RawQueryFragmentSymbol): ICriteriaNode<T>;
-    static createScalarNode<T extends object>(metadata: MetadataStorage, entityName: string, payload: any, parent?: ICriteriaNode<T>, key?: EntityKey<T> | RawQueryFragmentSymbol): ICriteriaNode<T>;
-    static createArrayNode<T extends object>(metadata: MetadataStorage, entityName: string, payload: any[], parent?: ICriteriaNode<T>, key?: EntityKey<T>): ICriteriaNode<T>;
-    static createObjectNode<T extends object>(metadata: MetadataStorage, entityName: string, payload: Dictionary, parent?: ICriteriaNode<T>, key?: EntityKey<T>): ICriteriaNode<T>;
-    static createObjectItemNode<T extends object>(metadata: MetadataStorage, entityName: string, node: ICriteriaNode<T>, payload: Dictionary, key: EntityKey<T> | RawQueryFragmentSymbol, meta?: EntityMetadata<T>): ICriteriaNode<T>;
+    static createNode<T extends object>(metadata: MetadataStorage, entityName: EntityName<T>, payload: any, parent?: ICriteriaNode<T>, key?: EntityKey<T> | RawQueryFragmentSymbol): ICriteriaNode<T>;
+    static createScalarNode<T extends object>(metadata: MetadataStorage, entityName: EntityName<T>, payload: any, parent?: ICriteriaNode<T>, key?: EntityKey<T> | RawQueryFragmentSymbol): ICriteriaNode<T>;
+    static createArrayNode<T extends object>(metadata: MetadataStorage, entityName: EntityName<T>, payload: any[], parent?: ICriteriaNode<T>, key?: EntityKey<T>): ICriteriaNode<T>;
+    static createObjectNode<T extends object>(metadata: MetadataStorage, entityName: EntityName<T>, payload: Dictionary, parent?: ICriteriaNode<T>, key?: EntityKey<T>): ICriteriaNode<T>;
+    static createObjectItemNode<T extends object>(metadata: MetadataStorage, entityName: EntityName<T>, node: ICriteriaNode<T>, payload: Dictionary, key: EntityKey<T> | RawQueryFragmentSymbol, meta?: EntityMetadata<T>): ICriteriaNode<T>;
 }

package/query/CriteriaNodeFactory.js

@@ -46,7 +46,7 @@ export class CriteriaNodeFactory {
     static createObjectItemNode(metadata, entityName, node, payload, key, meta) {
         const rawField = RawQueryFragment.isKnownFragmentSymbol(key);
         const prop = rawField ? null : meta?.properties[key];
-        const childEntity = prop && prop.kind !== ReferenceKind.SCALAR ? prop.type : entityName;
+        const childEntity = prop && prop.kind !== ReferenceKind.SCALAR ? prop.targetMeta.class : entityName;
         const isNotEmbedded = rawField || prop?.kind !== ReferenceKind.EMBEDDED;
         const val = payload[key];
         if (isNotEmbedded && prop?.customType instanceof JsonType) {

package/query/ObjectCriteriaNode.js

@@ -35,10 +35,10 @@ export class ObjectCriteriaNode extends CriteriaNode {
                         throw new Error('Mixing collection operators with other filters is not allowed.');
                     }
                     const payload = this.payload[key].unwrap();
-                    const qb2 = qb.clone(true);
+                    const qb2 = qb.clone(true, ['_schema']);
                     const sub = qb2
-                        .from(parentMeta.className)
-                        .innerJoin(this.key, qb2.getNextAlias(this.prop.type))
+                        .from(parentMeta.class)
+                        .innerJoin(this.key, qb2.getNextAlias(this.prop.targetMeta.class))
                         .select(parentMeta.primaryKeys);
                     if (key === '$every') {
                         sub.where({ $not: { [this.key]: payload } });
@@ -100,7 +100,7 @@ export class ObjectCriteriaNode extends CriteriaNode {
                 this.inlineCondition(field.replaceAll(ALIAS_REPLACEMENT, alias), o, payload);
             }
             else {
-                this.inlineCondition(`${alias}.${field}`, o, payload);
+                this.inlineCondition(`${alias ?? qb.alias}.${field}`, o, payload);
             }
             return o;
         }, {});
@@ -217,7 +217,7 @@ export class ObjectCriteriaNode extends CriteriaNode {
         return !primaryKeys && !nestedAlias && !operatorKeys && !embeddable;
     }
     autoJoin(qb, alias, options) {
-        const nestedAlias = qb.getNextAlias(this.prop?.pivotTable ?? this.entityName);
+        const nestedAlias = qb.getNextAlias(this.prop?.pivotEntity ?? this.entityName);
         const rawField = RawQueryFragment.isKnownFragmentSymbol(this.key);
         const scalar = Utils.isPrimaryKey(this.payload) || this.payload instanceof RegExp || this.payload instanceof Date || rawField;
         const operator = Utils.isPlainObject(this.payload) && Utils.getObjectQueryKeys(this.payload).every(k => Utils.isOperator(k, false));

package/query/QueryBuilder.d.ts

@@ -220,8 +220,8 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
      * Specifies FROM which entity's table select/update/delete will be executed, removing all previously set FROM-s.
      * Allows setting a main string alias of the selection data.
      */
-    from<Entity extends AnyEntity<Entity> = AnyEntity>(target: QueryBuilder<Entity>, aliasName?: string): SelectQueryBuilder<Entity, RootAlias, Hint, Context>;
-    from<Entity extends AnyEntity<Entity> = AnyEntity>(target: EntityName<Entity>): SelectQueryBuilder<Entity, RootAlias, Hint, Context>;
+    from<Entity extends object>(target: QueryBuilder<Entity>, aliasName?: string): SelectQueryBuilder<Entity, RootAlias, Hint, Context>;
+    from<Entity extends object>(target: EntityName<Entity>): SelectQueryBuilder<Entity, RootAlias, Hint, Context>;
     getNativeQuery(processVirtualEntity?: boolean): NativeQueryBuilder;
     /**
      * Returns the query with parameters as wildcards.
@@ -254,11 +254,11 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
     /**
      * @internal
      */
-    getNextAlias(entityName?: string): string;
+    getNextAlias(entityName?: string | EntityName): string;
     /**
      * @internal
      */
-    getAliasMap(): Dictionary<string>;
+    getAliasMap(): Dictionary<EntityName>;
     /**
      * Executes this QB and returns the raw results, mapped to the property names (unless disabled via last parameter).
      * Use `method` to specify what kind of result you want to get (array/single/meta).
@@ -307,10 +307,14 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
     getResultAndCount(): Promise<[Entity[], number]>;
     /**
      * Returns native query builder instance with sub-query aliased with given alias.
-     * You can provide `EntityName.propName` as alias, then the field name will be used based on the metadata
      */
     as(alias: string): NativeQueryBuilder;
-    clone(reset?: boolean | string[]): QueryBuilder<Entity>;
+    /**
+     * Returns native query builder instance with sub-query aliased with given alias.
+     * You can provide the target entity name as the first parameter and use the second parameter to point to an existing property to infer its field name.
+     */
+    as<T>(targetEntity: EntityName<T>, alias: EntityKey<T>): NativeQueryBuilder;
+    clone(reset?: boolean | string[], preserve?: string[]): QueryBuilder<Entity>;
     /**
      * Sets logger context for this query builder.
      */