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

package/query/QueryBuilder.js

@@ -1,4 +1,4 @@
-import { helper, isRaw, LoadStrategy, LockMode, PopulateHint, QueryFlag, QueryHelper, raw, RawQueryFragment, Reference, ReferenceKind, serialize, Utils, ValidationError, inspect, } from '@mikro-orm/core';
+import { helper, inspect, isRaw, LoadStrategy, LockMode, PopulateHint, QueryFlag, QueryHelper, raw, RawQueryFragment, Reference, ReferenceKind, serialize, Utils, ValidationError, } from '@mikro-orm/core';
 import { JoinType, QueryType } from './enums.js';
 import { QueryBuilderHelper } from './QueryBuilderHelper.js';
 import { CriteriaNodeFactory } from './CriteriaNodeFactory.js';
@@ -138,7 +138,7 @@ export class QueryBuilder {
             this._fields = Utils.asArray(field);
         }
         else if (distinct || this.hasToManyJoins()) {
-            this._fields = this.mainAlias.metadata.primaryKeys;
+            this._fields = this.mainAlias.meta.primaryKeys;
         }
         else {
             this._fields = [raw('*')];
@@ -274,7 +274,7 @@ export class QueryBuilder {
                 continue;
             }
             filterOptions = QueryHelper.mergePropertyFilters(join.prop.filters, filterOptions);
-            const cond = await em.applyFilters(join.prop.type, join.cond, filterOptions, 'read');
+            const cond = await em.applyFilters(join.prop.targetMeta.class, join.cond, filterOptions, 'read');
             if (Utils.hasObjectKeys(cond) || RawQueryFragment.hasObjectFragments(cond)) {
                 // remove nested filters, we only care about scalars here, nesting would require another join branch
                 for (const key of Object.keys(cond)) {
@@ -331,7 +331,7 @@ export class QueryBuilder {
         if ([QueryType.UPDATE, QueryType.DELETE].includes(this.type) && criteriaNode.willAutoJoin(this, undefined, { ignoreBranching })) {
             // use sub-query to support joining
             this.setFlag(this.type === QueryType.UPDATE ? QueryFlag.UPDATE_SUB_QUERY : QueryFlag.DELETE_SUB_QUERY);
-            this.select(this.mainAlias.metadata.primaryKeys, true);
+            this.select(this.mainAlias.meta.primaryKeys, true);
         }
         if (topLevel) {
             this._cond = criteriaNode.process(this, { ignoreBranching });
@@ -379,6 +379,7 @@ export class QueryBuilder {
                 type: 'orderBy',
             });
             this._orderBy.push(CriteriaNodeFactory.createNode(this.metadata, this.mainAlias.entityName, processed).process(this, { matchPopulateJoins: true, type: 'orderBy' }));
+            // this._orderBy.push(CriteriaNodeFactory.createNode<Entity>(this.metadata, Utils.className(this.mainAlias.entityName), processed).process(this, { matchPopulateJoins: true, type: 'orderBy' }));
         });
         return this;
     }
@@ -409,7 +410,7 @@ export class QueryBuilder {
         return this.having(cond, params, '$or');
     }
     onConflict(fields = []) {
-        const meta = this.mainAlias.metadata;
+        const meta = this.mainAlias.meta;
         this.ensureNotFinalized();
         this._onConflict ??= [];
         this._onConflict.push({
@@ -536,11 +537,10 @@ export class QueryBuilder {
             this.fromSubQuery(target, aliasName);
         }
         else {
-            const entityName = Utils.className(target);
-            if (aliasName && this._mainAlias && entityName !== this._mainAlias.aliasName) {
+            if (aliasName && this._mainAlias && Utils.className(target) !== this._mainAlias.aliasName) {
                 throw new Error(`Cannot override the alias to '${aliasName}' since a query already contains references to '${this._mainAlias.aliasName}'`);
             }
-            this.fromEntityName(entityName, aliasName);
+            this.fromEntityName(target, aliasName);
         }
         return this;
     }
@@ -571,7 +571,7 @@ export class QueryBuilder {
         if (this.lockMode) {
             this.helper.getLockSQL(qb, this.lockMode, this.lockTables, this._joins);
         }
-        this.helper.finalize(this.type, qb, this.mainAlias.metadata, this._data, this._returning);
+        this.helper.finalize(this.type, qb, this.mainAlias.meta, this._data, this._returning);
         return this._query.qb = qb;
     }
     /**
@@ -613,7 +613,7 @@ export class QueryBuilder {
      * @internal
      */
     getAliasForJoinPath(path, options) {
-        if (!path || path === this.mainAlias.entityName) {
+        if (!path || path === Utils.className(this.mainAlias.entityName)) {
             return this.mainAlias.aliasName;
         }
         const join = typeof path === 'string' ? this.getJoinForPath(path, options) : path;
@@ -657,6 +657,7 @@ export class QueryBuilder {
      * @internal
      */
     getNextAlias(entityName = 'e') {
+        entityName = Utils.className(entityName);
         return this.driver.config.getNamingStrategy().aliasName(entityName, this.aliasCounter++);
     }
     /**
@@ -688,7 +689,7 @@ export class QueryBuilder {
         }
         const loggerContext = { id: this.em?.id, ...this.loggerContext };
         const res = await this.getConnection().execute(query.sql, query.params, method, this.context, loggerContext);
-        const meta = this.mainAlias.metadata;
+        const meta = this.mainAlias.meta;
         if (!options.mapResults || !meta) {
             await this.em?.storeCache(this._cache, cached, res);
             return res;
@@ -702,7 +703,7 @@ export class QueryBuilder {
             const map = {};
             mapped = res.map(r => this.driver.mapResult(r, meta, this._populate, this, map));
             if (options.mergeResults && joinedProps.length > 0) {
-                mapped = this.driver.mergeJoinedResult(mapped, this.mainAlias.metadata, joinedProps);
+                mapped = this.driver.mergeJoinedResult(mapped, this.mainAlias.meta, joinedProps);
             }
         }
         else {
@@ -743,7 +744,7 @@ export class QueryBuilder {
         const query = this.toQuery();
         const loggerContext = { id: this.em?.id, ...this.loggerContext };
         const res = this.getConnection().stream(query.sql, query.params, this.context, loggerContext);
-        const meta = this.mainAlias.metadata;
+        const meta = this.mainAlias.meta;
         if (options.rawResults || !meta) {
             yield* res;
             return;
@@ -760,7 +761,7 @@ export class QueryBuilder {
                 continue;
             }
             if (stack.length > 0 && hash(stack[stack.length - 1]) !== hash(mapped)) {
-                const res = this.driver.mergeJoinedResult(stack, this.mainAlias.metadata, joinedProps);
+                const res = this.driver.mergeJoinedResult(stack, this.mainAlias.meta, joinedProps);
                 for (const row of res) {
                     yield this.mapResult(row, options.mapResults);
                 }
@@ -769,7 +770,7 @@ export class QueryBuilder {
             stack.push(mapped);
         }
         if (stack.length > 0) {
-            const merged = this.driver.mergeJoinedResult(stack, this.mainAlias.metadata, joinedProps);
+            const merged = this.driver.mergeJoinedResult(stack, this.mainAlias.meta, joinedProps);
             yield this.mapResult(merged[0], options.mapResults);
         }
     }
@@ -856,28 +857,25 @@ export class QueryBuilder {
             await this.clone().getCount(),
         ];
     }
-    /**
-     * 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) {
+    as(aliasOrTargetEntity, alias) {
         const qb = this.getNativeQuery();
-        if (alias.includes('.')) {
-            const [a, f] = alias.split('.');
-            const meta = this.metadata.find(a);
+        let finalAlias = aliasOrTargetEntity;
+        /* v8 ignore next */
+        if (typeof aliasOrTargetEntity === 'string' && aliasOrTargetEntity.includes('.')) {
+            throw new Error('qb.as(alias) no longer supports target entity name prefix, use qb.as(TargetEntity, key) signature instead');
+        }
+        if (alias) {
+            const meta = this.metadata.get(aliasOrTargetEntity);
             /* v8 ignore next */
-            alias = meta?.properties[f]?.fieldNames[0] ?? alias;
+            finalAlias = meta.properties[alias]?.fieldNames[0] ?? alias;
         }
-        qb.as(alias);
+        qb.as(finalAlias);
         // tag the instance, so it is possible to detect it easily
-        Object.defineProperty(qb, '__as', { enumerable: false, value: alias });
+        Object.defineProperty(qb, '__as', { enumerable: false, value: finalAlias });
         return qb;
     }
-    clone(reset) {
+    clone(reset, preserve) {
         const qb = new QueryBuilder(this.mainAlias.entityName, this.metadata, this.driver, this.context, this.mainAlias.aliasName, this.connectionType, this.em);
-        if (reset === true) {
-            return qb;
-        }
         reset = reset || [];
         // clone array/object properties
         const properties = [
@@ -886,13 +884,13 @@ export class QueryBuilder {
             '_comments', '_hintComments', 'aliasCounter',
         ];
         for (const prop of Object.keys(this)) {
-            if (reset.includes(prop) || ['_helper', '_query'].includes(prop)) {
+            if (!preserve?.includes(prop) && (reset === true || reset.includes(prop) || ['_helper', '_query'].includes(prop))) {
                 continue;
             }
             qb[prop] = properties.includes(prop) ? Utils.copy(this[prop]) : this[prop];
         }
         /* v8 ignore next */
-        if (this._fields && !reset.includes('_fields')) {
+        if (this._fields && reset !== true && !reset.includes('_fields')) {
             qb._fields = [...this._fields];
         }
         qb._aliases = { ...this._aliases };
@@ -939,8 +937,8 @@ export class QueryBuilder {
                 kind: ReferenceKind.MANY_TO_ONE,
             };
             if (field instanceof QueryBuilder) {
-                prop.type = field.mainAlias.entityName;
-                prop.targetMeta = field.mainAlias.metadata;
+                prop.type = Utils.className(field.mainAlias.entityName);
+                prop.targetMeta = field.mainAlias.meta;
                 field = field.getNativeQuery();
             }
             if (isRaw(field)) {
@@ -972,7 +970,7 @@ export class QueryBuilder {
         if (!prop) {
             throw new Error(`Trying to join ${q(field)}, but ${q(fromField)} is not a defined relation on ${meta.className}.`);
         }
-        this.createAlias(prop.type, alias);
+        this.createAlias(prop.targetMeta.class, alias);
         cond = QueryHelper.processWhere({
             where: cond,
             entityName: this.mainAlias.entityName,
@@ -981,10 +979,10 @@ export class QueryBuilder {
             aliasMap: this.getAliasMap(),
             aliased: [QueryType.SELECT, QueryType.COUNT].includes(this.type),
         });
-        const criteriaNode = CriteriaNodeFactory.createNode(this.metadata, prop.targetMeta.className, cond);
+        const criteriaNode = CriteriaNodeFactory.createNode(this.metadata, prop.targetMeta.class, cond);
         cond = criteriaNode.process(this, { ignoreBranching: true, alias });
         let aliasedName = `${fromAlias}.${prop.name}#${alias}`;
-        path ??= `${(Object.values(this._joins).find(j => j.alias === fromAlias)?.path ?? entityName)}.${prop.name}`;
+        path ??= `${(Object.values(this._joins).find(j => j.alias === fromAlias)?.path ?? Utils.className(entityName))}.${prop.name}`;
         if (prop.kind === ReferenceKind.ONE_TO_MANY) {
             this._joins[aliasedName] = this.helper.joinOneToReference(prop, fromAlias, alias, type, cond, schema);
             this._joins[aliasedName].path ??= path;
@@ -1062,9 +1060,7 @@ export class QueryBuilder {
             }
             ret.push(getFieldName(field));
         });
-        const meta = this.mainAlias.metadata;
-        /* v8 ignore next */
-        const requiresSQLConversion = meta?.props.filter(p => p.hasConvertToJSValueSQL && p.persist !== false) ?? [];
+        const requiresSQLConversion = this.mainAlias.meta.props.filter(p => p.hasConvertToJSValueSQL && p.persist !== false);
         if (this.flags.has(QueryFlag.CONVERT_CUSTOM_TYPES) && (fields.includes('*') || fields.includes(`${this.mainAlias.aliasName}.*`)) && requiresSQLConversion.length > 0) {
             for (const p of requiresSQLConversion) {
                 ret.push(this.helper.mapper(p.name, this.type));
@@ -1099,14 +1095,14 @@ export class QueryBuilder {
     }
     getQueryBase(processVirtualEntity) {
         const qb = this.platform.createNativeQueryBuilder().setFlags(this.flags);
-        const { subQuery, aliasName, entityName, metadata } = this.mainAlias;
+        const { subQuery, aliasName, entityName, meta } = this.mainAlias;
         const requiresAlias = this.finalized && (this._explicitAlias || this.helper.isTableNameAliasRequired(this.type));
         const alias = requiresAlias ? aliasName : undefined;
         const schema = this.getSchema(this.mainAlias);
         const tableName = subQuery ? subQuery.as(aliasName) : this.helper.getTableName(entityName);
         const joinSchema = this._schema ?? this.em?.schema ?? schema;
-        if (metadata?.virtual && processVirtualEntity) {
-            qb.from(raw(this.fromVirtual(metadata)), { indexHint: this._indexHint });
+        if (meta.virtual && processVirtualEntity) {
+            qb.from(raw(this.fromVirtual(meta)), { indexHint: this._indexHint });
         }
         else {
             qb.from(tableName, {
@@ -1150,19 +1146,19 @@ export class QueryBuilder {
         return qb;
     }
     applyDiscriminatorCondition() {
-        const meta = this.mainAlias.metadata;
-        if (!meta?.discriminatorValue) {
+        const meta = this.mainAlias.meta;
+        if (!meta.discriminatorValue) {
             return;
         }
-        const types = Object.values(meta.root.discriminatorMap).map(cls => this.metadata.find(cls));
+        const types = Object.values(meta.root.discriminatorMap).map(cls => this.metadata.get(cls));
         const children = [];
         const lookUpChildren = (ret, type) => {
             const children = types.filter(meta2 => meta2.extends === type);
-            children.forEach(m => lookUpChildren(ret, m.className));
+            children.forEach(m => lookUpChildren(ret, m.class));
             ret.push(...children.filter(c => c.discriminatorValue));
             return children;
         };
-        lookUpChildren(children, meta.className);
+        lookUpChildren(children, meta.class);
         this.andWhere({
             [meta.root.discriminatorColumn]: children.length > 0 ? { $in: [meta.discriminatorValue, ...children.map(c => c.discriminatorValue)] } : meta.discriminatorValue,
         });
@@ -1174,7 +1170,7 @@ export class QueryBuilder {
         if (!this._type) {
             this.select('*');
         }
-        const meta = this.mainAlias.metadata;
+        const meta = this.mainAlias.meta;
         this.applyDiscriminatorCondition();
         this.processPopulateHint();
         this.processNestedJoins();
@@ -1214,7 +1210,7 @@ export class QueryBuilder {
         if (this.populateHintFinalized) {
             return;
         }
-        const meta = this.mainAlias.metadata;
+        const meta = this.mainAlias.meta;
         if (meta && this.flags.has(QueryFlag.AUTO_JOIN_ONE_TO_ONE_OWNER)) {
             const relationsToPopulate = this._populate.map(({ field }) => field);
             meta.relations
@@ -1232,12 +1228,12 @@ export class QueryBuilder {
             }
             if (meta && this.helper.isOneToOneInverse(fromField)) {
                 const prop = meta.properties[fromField];
-                const alias = this.getNextAlias(prop.pivotEntity ?? prop.type);
+                const alias = this.getNextAlias(prop.pivotEntity ?? prop.targetMeta.class);
                 const aliasedName = `${fromAlias}.${prop.name}#${alias}`;
                 this._joins[aliasedName] = this.helper.joinOneToReference(prop, this.mainAlias.aliasName, alias, JoinType.leftJoin);
                 this._joins[aliasedName].path = `${(Object.values(this._joins).find(j => j.alias === fromAlias)?.path ?? meta.className)}.${prop.name}`;
                 this._populateMap[aliasedName] = this._joins[aliasedName].alias;
-                this.createAlias(prop.type, alias);
+                this.createAlias(prop.targetMeta.class, alias);
             }
         });
         this.processPopulateWhere(false);
@@ -1463,8 +1459,8 @@ export class QueryBuilder {
         });
     }
     getSchema(alias) {
-        const { metadata } = alias;
-        const metaSchema = metadata?.schema && metadata.schema !== '*' ? metadata.schema : undefined;
+        const { meta } = alias;
+        const metaSchema = meta.schema && meta.schema !== '*' ? meta.schema : undefined;
         const schema = this._schema ?? metaSchema ?? this.em?.schema ?? this.em?.config.getSchema(true);
         if (schema === this.platform.getDefaultSchemaName()) {
             return undefined;
@@ -1472,8 +1468,8 @@ export class QueryBuilder {
         return schema;
     }
     createAlias(entityName, aliasName, subQuery) {
-        const metadata = this.metadata.find(entityName);
-        const alias = { aliasName, entityName, metadata, subQuery };
+        const meta = this.metadata.find(entityName);
+        const alias = { aliasName, entityName, meta, subQuery };
         this._aliases[aliasName] = alias;
         return alias;
     }
@@ -1531,7 +1527,7 @@ export class QueryBuilder {
         if (!Utils.isEmpty(this._orderBy)) {
             object.orderBy = this._orderBy;
         }
-        const name = this._mainAlias ? `${prefix}QueryBuilder<${this._mainAlias?.entityName}>` : 'QueryBuilder';
+        const name = this._mainAlias ? `${prefix}QueryBuilder<${Utils.className(this._mainAlias?.entityName)}>` : 'QueryBuilder';
         const ret = inspect(object, { depth });
         return ret === '[Object]' ? `[${name}]` : name + ' ' + ret;
     }

package/query/QueryBuilderHelper.d.ts

@@ -1,4 +1,4 @@
-import { type Dictionary, type EntityData, type EntityKey, type EntityMetadata, 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, 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';
@@ -14,7 +14,7 @@ export declare class QueryBuilderHelper {
     private readonly driver;
     private readonly platform;
     private readonly metadata;
-    constructor(entityName: string, alias: string, aliasMap: Dictionary<Alias<any>>, subQueries: Dictionary<string>, driver: AbstractSqlDriver);
+    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;
     processData(data: Dictionary, convertCustomTypes: boolean, multi?: boolean): any;
@@ -28,7 +28,7 @@ export declare class QueryBuilderHelper {
     };
     mapJoinColumns(type: QueryType, join: JoinOptions): (string | Raw)[];
     isOneToOneInverse(field: string, meta?: EntityMetadata): boolean;
-    getTableName(entityName: string): string;
+    getTableName(entityName: EntityName): string;
     /**
      * Checks whether the RE can be rewritten to simple LIKE query
      */
@@ -62,8 +62,8 @@ export declare class QueryBuilderHelper {
 }
 export interface Alias<T> {
     aliasName: string;
-    entityName: string;
-    metadata?: EntityMetadata<T>;
+    entityName: EntityName<T>;
+    meta: EntityMetadata<T>;
     subQuery?: NativeQueryBuilder;
 }
 export interface OnConflictClause<T> {

package/query/QueryBuilderHelper.js

@@ -128,7 +128,7 @@ export class QueryBuilderHelper {
     }
     joinOneToReference(prop, ownerAlias, alias, type, cond = {}, schema) {
         const prop2 = prop.targetMeta.properties[prop.mappedBy || prop.inversedBy];
-        const table = this.getTableName(prop.type);
+        const table = this.getTableName(prop.targetMeta.class);
         const joinColumns = prop.owner ? prop.referencedColumnNames : prop2.joinColumns;
         const inverseJoinColumns = prop.referencedColumnNames;
         const primaryKeys = prop.owner ? prop.joinColumns : prop2.referencedColumnNames;
@@ -142,7 +142,7 @@ export class QueryBuilderHelper {
     joinManyToOneReference(prop, ownerAlias, alias, type, cond = {}, schema) {
         return {
             prop, type, cond, ownerAlias, alias,
-            table: this.getTableName(prop.type),
+            table: this.getTableName(prop.targetMeta.class),
             schema: prop.targetMeta?.schema === '*' ? '*' : this.driver.getSchemaName(prop.targetMeta, { schema }),
             joinColumns: prop.referencedColumnNames,
             primaryKeys: prop.fieldNames,
@@ -167,7 +167,7 @@ export class QueryBuilderHelper {
         if (type === JoinType.pivotJoin) {
             return ret;
         }
-        const prop2 = prop.owner ? pivotMeta.relations[1] : pivotMeta.relations[0];
+        const prop2 = pivotMeta.relations[prop.owner ? 1 : 0];
         ret[`${pivotAlias}.${prop2.name}#${alias}`] = this.joinManyToOneReference(prop2, pivotAlias, alias, type, cond, schema);
         ret[`${pivotAlias}.${prop2.name}#${alias}`].path = path;
         const tmp = prop2.referencedTableName.split('.');
@@ -264,7 +264,7 @@ export class QueryBuilderHelper {
     }
     getTableName(entityName) {
         const meta = this.metadata.find(entityName);
-        return meta ? meta.collection : entityName;
+        return meta?.tableName ?? Utils.className(entityName);
     }
     /**
      * Checks whether the RE can be rewritten to simple LIKE query
@@ -644,7 +644,7 @@ export class QueryBuilderHelper {
     getLockSQL(qb, lockMode, lockTables = [], joinsMap) {
         const meta = this.metadata.find(this.entityName);
         if (lockMode === LockMode.OPTIMISTIC && meta && !meta.versionProperty) {
-            throw OptimisticLockError.lockFailed(this.entityName);
+            throw OptimisticLockError.lockFailed(Utils.className(this.entityName));
         }
         if (lockMode !== LockMode.OPTIMISTIC && lockTables.length === 0 && joinsMap) {
             const joins = Object.values(joinsMap);
@@ -739,9 +739,9 @@ export class QueryBuilderHelper {
     }
     getProperty(field, alias) {
         const entityName = this.aliasMap[alias]?.entityName || this.entityName;
-        const meta = this.metadata.find(entityName);
+        const meta = this.metadata.get(entityName);
         // check if `alias` is not matching an embedded property name instead of alias, e.g. `address.city`
-        if (alias && meta) {
+        if (alias) {
             const prop = meta.properties[alias];
             if (prop?.kind === ReferenceKind.EMBEDDED) {
                 // we want to select the full object property so hydration works as expected
@@ -753,13 +753,10 @@ export class QueryBuilderHelper {
                 return nest(prop);
             }
         }
-        if (meta) {
-            if (meta.properties[field]) {
-                return meta.properties[field];
-            }
-            return meta.relations.find(prop => prop.fieldNames?.some(name => field === name));
+        if (meta.properties[field]) {
+            return meta.properties[field];
         }
-        return undefined;
+        return meta.relations.find(prop => prop.fieldNames?.some(name => field === name));
     }
     isTableNameAliasRequired(type) {
         return [QueryType.SELECT, QueryType.COUNT].includes(type);

package/query/ScalarCriteriaNode.js

@@ -12,7 +12,7 @@ export class ScalarCriteriaNode extends CriteriaNode {
         if (this.shouldJoin(qb, nestedAlias)) {
             const path = this.getPath();
             const parentPath = this.parent.getPath(); // the parent is always there, otherwise `shouldJoin` would return `false`
-            const nestedAlias = qb.getAliasForJoinPath(path) || qb.getNextAlias(this.prop?.pivotTable ?? this.entityName);
+            const nestedAlias = qb.getAliasForJoinPath(path) || qb.getNextAlias(this.prop?.pivotEntity ?? this.entityName);
             const field = this.aliased(this.prop.name, options?.alias);
             const type = this.prop.kind === ReferenceKind.MANY_TO_MANY ? JoinType.pivotJoin : JoinType.leftJoin;
             qb.join(field, nestedAlias, undefined, type, path);

package/schema/SqlSchemaGenerator.js

@@ -114,7 +114,7 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         await this.execute(this.helper.disableForeignKeysSQL());
         const schema = options?.schema ?? this.config.get('schema', this.platform.getDefaultSchemaName());
         for (const meta of this.getOrderedMetadata(schema).reverse()) {
-            await this.driver.createQueryBuilder(meta.className, this.em?.getTransactionContext(), 'write', false)
+            await this.driver.createQueryBuilder(meta.class, this.em?.getTransactionContext(), 'write', false)
                 .withSchema(schema)
                 .truncate()
                 .execute();
@@ -197,7 +197,7 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         const toSchema = this.getTargetSchema(options.schema);
         const schemas = toSchema.getNamespaces();
         const fromSchema = options.fromSchema ?? (await DatabaseSchema.create(this.connection, this.platform, this.config, options.schema, schemas, undefined, this.options.skipTables));
-        const wildcardSchemaTables = Object.values(this.metadata.getAll()).filter(meta => meta.schema === '*').map(meta => meta.tableName);
+        const wildcardSchemaTables = [...this.metadata.getAll().values()].filter(meta => meta.schema === '*').map(meta => meta.tableName);
         fromSchema.prune(options.schema, wildcardSchemaTables);
         toSchema.prune(options.schema, wildcardSchemaTables);
         return { fromSchema, toSchema };