@mikro-orm/core 7.0.0-dev.3 → 7.0.0-dev.5

package/EntityManager.js

@@ -367,7 +367,7 @@ export class EntityManager {
                 if (!args && filter.cond.length > 0 && filter.args !== false) {
                     throw new Error(`No arguments provided for filter '${filter.name}'`);
                 }
-                cond = await filter.cond(args, type, this, findOptions);
+                cond = await filter.cond(args, type, this, findOptions, entityName);
             }
             else {
                 cond = filter.cond;
@@ -717,7 +717,7 @@ export class EntityManager {
                 convertCustomTypes: true,
                 connectionType: 'write',
             });
-            em.getHydrator().hydrate(entity, meta, data2, em.entityFactory, 'full');
+            em.getHydrator().hydrate(entity, meta, data2, em.entityFactory, 'full', false, true);
         }
         // recompute the data as there might be some values missing (e.g. those with db column defaults)
         const snapshot = this.comparator.prepareEntity(entity);
@@ -911,7 +911,7 @@ export class EntityManager {
                 if (!row) {
                     throw new Error(`Cannot find matching entity for condition ${JSON.stringify(cond)}`);
                 }
-                em.getHydrator().hydrate(entity, meta, row, em.entityFactory, 'full');
+                em.getHydrator().hydrate(entity, meta, row, em.entityFactory, 'full', false, true);
             }
             if (loadPK.size !== data2.length && Array.isArray(uniqueFields)) {
                 for (let i = 0; i < allData.length; i++) {

package/decorators/Check.d.ts

@@ -1,3 +1,3 @@
-import type { CheckConstraint } from '../typings.js';
-export declare function Check<T>(options: CheckOptions<T>): (target: any, propertyName?: string) => any;
+import type { CheckConstraint, EntityClass } from '../typings.js';
+export declare function Check<T>(options: CheckOptions<T>): (target: T, propertyName?: T extends EntityClass<unknown> ? undefined : keyof T) => any;
 export type CheckOptions<T = any> = CheckConstraint<T>;

package/decorators/Embeddable.d.ts

@@ -1,8 +1,8 @@
-import type { Dictionary } from '../typings.js';
-export declare function Embeddable(options?: EmbeddableOptions): <T>(target: T & Dictionary) => T & Dictionary;
-export type EmbeddableOptions = {
-    discriminatorColumn?: string;
+import type { AnyString, Dictionary, EntityClass } from '../typings.js';
+export declare function Embeddable<T>(options?: EmbeddableOptions<T>): (target: T) => T;
+export interface EmbeddableOptions<T> {
+    discriminatorColumn?: (T extends EntityClass<infer P> ? keyof P : string) | AnyString;
     discriminatorMap?: Dictionary<string>;
     discriminatorValue?: number | string;
     abstract?: boolean;
-};
+}

package/decorators/Embeddable.js

@@ -3,7 +3,7 @@ export function Embeddable(options = {}) {
     return function (target) {
         const meta = MetadataStorage.getMetadataFromDecorator(target);
         meta.class = target;
-        meta.name = target.name;
+        meta.name = meta.class.name;
         meta.embeddable = true;
         Object.assign(meta, options);
         return target;

package/decorators/Embedded.d.ts

@@ -2,7 +2,7 @@ import type { AnyEntity } from '../typings.js';
 export declare function Embedded<T extends object>(type?: EmbeddedOptions | (() => AnyEntity), options?: EmbeddedOptions): (target: AnyEntity, propertyName: string) => any;
 /** With `absolute` the prefix is set at the root of the entity (regardless of the nesting level) */
 export type EmbeddedPrefixMode = 'absolute' | 'relative';
-export type EmbeddedOptions = {
+export interface EmbeddedOptions {
     entity?: string | (() => AnyEntity | AnyEntity[]);
     type?: string;
     prefix?: string | boolean;
@@ -15,4 +15,4 @@ export type EmbeddedOptions = {
     serializedName?: string;
     groups?: string[];
     persist?: boolean;
-};
+}

package/decorators/Entity.d.ts

@@ -1,11 +1,11 @@
-import type { Constructor, Dictionary, FilterQuery } from '../typings.js';
+import type { AnyString, Constructor, Dictionary, EntityClass, FilterQuery } from '../typings.js';
 import type { FindOptions } from '../drivers/IDatabaseDriver.js';
-export declare function Entity(options?: EntityOptions<any>): <T>(target: T & Dictionary) => T & Dictionary;
+export declare function Entity<T extends EntityClass<unknown>>(options?: EntityOptions<T>): (target: T) => void;
 export type EntityOptions<T> = {
     tableName?: string;
     schema?: string;
     collection?: string;
-    discriminatorColumn?: string;
+    discriminatorColumn?: (T extends EntityClass<infer P> ? keyof P : string) | AnyString;
     discriminatorMap?: Dictionary<string>;
     discriminatorValue?: number | string;
     forceConstructor?: boolean;

package/decorators/Entity.js

@@ -8,6 +8,5 @@ export function Entity(options = {}) {
         if (!options.abstract || meta.discriminatorColumn) {
             meta.name = target.name;
         }
-        return target;
     };
 }

package/decorators/Enum.d.ts

@@ -1,6 +1,6 @@
 import type { PropertyOptions } from './Property.js';
 import type { AnyEntity, Dictionary } from '../typings.js';
-export declare function Enum<T extends object>(options?: EnumOptions<AnyEntity> | (() => Dictionary)): (target: AnyEntity, propertyName: string) => any;
+export declare function Enum<T extends object>(options?: EnumOptions<AnyEntity> | (() => Dictionary)): (target: T, propertyName: string) => any;
 export interface EnumOptions<T> extends PropertyOptions<T> {
     items?: (number | string)[] | (() => Dictionary);
     array?: boolean;

package/decorators/Formula.d.ts

@@ -1,5 +1,4 @@
-import type { AnyEntity } from '../typings.js';
 import type { PropertyOptions } from './Property.js';
-export declare function Formula<T extends object>(formula: string | ((alias: string) => string), options?: FormulaOptions<T>): (target: AnyEntity, propertyName: string) => any;
+export declare function Formula<T extends object>(formula: string | ((alias: string) => string), options?: FormulaOptions<T>): (target: T, propertyName: string) => any;
 export interface FormulaOptions<T> extends PropertyOptions<T> {
 }

package/decorators/Indexed.d.ts

@@ -1,17 +1,19 @@
-import type { AnyEntity, Dictionary } from '../typings.js';
+import type { EntityClass, Dictionary, AutoPath } from '../typings.js';
 import type { DeferMode } from '../enums.js';
-export declare function Index<T>(options?: IndexOptions<T>): (target: AnyEntity, propertyName?: string) => any;
-export declare function Unique<T>(options?: UniqueOptions<T>): (target: AnyEntity, propertyName?: string) => any;
-interface BaseOptions<T> {
+export declare function Index<T extends object, H extends string>(options?: IndexOptions<T, H>): (target: T, propertyName?: (T extends EntityClass<unknown> ? undefined : keyof T) | undefined) => any;
+export declare function Unique<T extends object, H extends string>(options?: UniqueOptions<T, H>): (target: T, propertyName?: (T extends EntityClass<unknown> ? undefined : keyof T) | undefined) => any;
+type MaybeArray<T> = T | T[];
+type Properties<T, H extends string> = MaybeArray<AutoPath<T, H>>;
+interface BaseOptions<T, H extends string> {
     name?: string;
-    properties?: keyof T | (keyof T)[];
+    properties?: (T extends EntityClass<infer P> ? Properties<P, H> : Properties<T, H>);
     options?: Dictionary;
     expression?: string;
 }
-export interface UniqueOptions<T> extends BaseOptions<T> {
+export interface UniqueOptions<T, H extends string = string> extends BaseOptions<T, H> {
     deferMode?: DeferMode | `${DeferMode}`;
 }
-export interface IndexOptions<T> extends BaseOptions<T> {
+export interface IndexOptions<T, H extends string = string> extends BaseOptions<T, H> {
     type?: string;
 }
 export {};

package/decorators/Indexed.js

@@ -3,7 +3,7 @@ import { Utils } from '../utils/Utils.js';
 function createDecorator(options, unique) {
     return function (target, propertyName) {
         const meta = MetadataStorage.getMetadataFromDecorator(propertyName ? target.constructor : target);
-        options.properties = options.properties || propertyName;
+        options.properties ??= propertyName;
         const key = unique ? 'uniques' : 'indexes';
         meta[key].push(options);
         if (!propertyName) {

package/decorators/ManyToMany.d.ts

@@ -1,7 +1,7 @@
 import type { ReferenceOptions } from './Property.js';
-import type { EntityName, AnyEntity, FilterQuery, AnyString } from '../typings.js';
+import type { EntityName, FilterQuery, AnyString } from '../typings.js';
 import { type QueryOrderMap } from '../enums.js';
-export declare function ManyToMany<T extends object, O>(entity?: ManyToManyOptions<T, O> | string | (() => EntityName<T>), mappedBy?: (string & keyof T) | ((e: T) => any), options?: Partial<ManyToManyOptions<T, O>>): (target: AnyEntity, propertyName: string) => any;
+export declare function ManyToMany<Target extends object, Owner extends object>(entity?: ManyToManyOptions<Owner, Target> | string | (() => EntityName<Target>), mappedBy?: (string & keyof Target) | ((e: Target) => any), options?: Partial<ManyToManyOptions<Owner, Target>>): (target: Owner, propertyName: keyof Owner) => any;
 export interface ManyToManyOptions<Owner, Target> extends ReferenceOptions<Owner, Target> {
     /** Set this side as owning. Owning side is where the foreign key is defined. This option is not required if you use `inversedBy` or `mappedBy` to distinguish owning and inverse side. */
     owner?: boolean;

package/decorators/ManyToOne.d.ts

@@ -1,7 +1,7 @@
 import type { ReferenceOptions } from './Property.js';
 import { type DeferMode } from '../enums.js';
-import type { AnyEntity, AnyString, EntityName } from '../typings.js';
-export declare function ManyToOne<T extends object, O>(entity?: ManyToOneOptions<T, O> | string | ((e?: any) => EntityName<T>), options?: Partial<ManyToOneOptions<T, O>>): (target: AnyEntity, propertyName: string) => any;
+import type { AnyString, EntityName } from '../typings.js';
+export declare function ManyToOne<Target extends object, Owner extends object>(entity?: ManyToOneOptions<Owner, Target> | string | ((e?: any) => EntityName<Target>), options?: Partial<ManyToOneOptions<Owner, Target>>): (target: Owner, propertyName: keyof Owner) => any;
 export interface ManyToOneOptions<Owner, Target> extends ReferenceOptions<Owner, Target> {
     /** Point to the inverse side property name. */
     inversedBy?: (string & keyof Target) | ((e: Target) => any);

package/decorators/OneToMany.d.ts

@@ -1,9 +1,9 @@
 import type { ReferenceOptions } from './Property.js';
 import { ReferenceKind, type QueryOrderMap } from '../enums.js';
-import type { EntityName, AnyEntity, FilterQuery } from '../typings.js';
-export declare function createOneToDecorator<Target, Owner>(entity: OneToManyOptions<Owner, Target> | string | ((e?: any) => EntityName<Target>), mappedBy: (string & keyof Target) | ((e: Target) => any) | undefined, options: Partial<OneToManyOptions<Owner, Target>>, kind: ReferenceKind): (target: AnyEntity, propertyName: string) => any;
-export declare function OneToMany<Target, Owner>(entity: string | ((e?: any) => EntityName<Target>), mappedBy: (string & keyof Target) | ((e: Target) => any), options?: Partial<OneToManyOptions<Owner, Target>>): (target: AnyEntity, propertyName: string) => void;
-export declare function OneToMany<Target, Owner>(options: OneToManyOptions<Owner, Target>): (target: AnyEntity, propertyName: string) => void;
+import type { EntityName, FilterQuery } from '../typings.js';
+export declare function createOneToDecorator<Target, Owner>(entity: OneToManyOptions<Owner, Target> | string | ((e?: any) => EntityName<Target>), mappedBy: (string & keyof Target) | ((e: Target) => any) | undefined, options: Partial<OneToManyOptions<Owner, Target>>, kind: ReferenceKind): (target: Owner, propertyName: string) => any;
+export declare function OneToMany<Target, Owner>(entity: string | ((e?: any) => EntityName<Target>), mappedBy: (string & keyof Target) | ((e: Target) => any), options?: Partial<OneToManyOptions<Owner, Target>>): (target: Owner, propertyName: string) => void;
+export declare function OneToMany<Target, Owner>(options: OneToManyOptions<Owner, Target>): (target: Owner, propertyName: string) => void;
 export interface OneToManyOptions<Owner, Target> extends ReferenceOptions<Owner, Target> {
     /** Remove the entity when it gets disconnected from the relationship (see {@doclink cascading | Cascading}). */
     orphanRemoval?: boolean;

package/decorators/OneToOne.d.ts

@@ -1,7 +1,7 @@
 import { type DeferMode } from '../enums.js';
 import { type OneToManyOptions } from './OneToMany.js';
 import type { AnyString, EntityName } from '../typings.js';
-export declare function OneToOne<Target, Owner>(entity?: OneToOneOptions<Owner, Target> | string | ((e: Owner) => EntityName<Target>), mappedByOrOptions?: (string & keyof Target) | ((e: Target) => any) | Partial<OneToOneOptions<Owner, Target>>, options?: Partial<OneToOneOptions<Owner, Target>>): (target: import("../typings.js").AnyEntity, propertyName: string) => any;
+export declare function OneToOne<Target, Owner>(entity?: OneToOneOptions<Owner, Target> | string | ((e: Owner) => EntityName<Target>), mappedByOrOptions?: (string & keyof Target) | ((e: Target) => any) | Partial<OneToOneOptions<Owner, Target>>, options?: Partial<OneToOneOptions<Owner, Target>>): (target: Owner, propertyName: string) => any;
 export interface OneToOneOptions<Owner, Target> extends Partial<Omit<OneToManyOptions<Owner, Target>, 'orderBy'>> {
     /** Set this side as owning. Owning side is where the foreign key is defined. This option is not required if you use `inversedBy` or `mappedBy` to distinguish owning and inverse side. */
     owner?: boolean;

package/decorators/PrimaryKey.d.ts

@@ -1,7 +1,6 @@
 import type { PropertyOptions } from './Property.js';
-import type { AnyEntity } from '../typings.js';
-export declare function PrimaryKey<T extends object>(options?: PrimaryKeyOptions<T>): (target: AnyEntity, propertyName: string) => any;
-export declare function SerializedPrimaryKey<T extends object>(options?: SerializedPrimaryKeyOptions<T>): (target: AnyEntity, propertyName: string) => any;
+export declare function PrimaryKey<T extends object>(options?: PrimaryKeyOptions<T>): (target: T, propertyName: string) => any;
+export declare function SerializedPrimaryKey<T extends object>(options?: SerializedPrimaryKeyOptions<T>): (target: T, propertyName: string) => any;
 export interface PrimaryKeyOptions<T> extends PropertyOptions<T> {
 }
 export interface SerializedPrimaryKeyOptions<T> extends PropertyOptions<T> {

package/decorators/Property.d.ts

@@ -3,7 +3,7 @@ import type { EntityName, Constructor, CheckCallback, GeneratedColumnCallback, A
 import type { Type, types } from '../types/index.js';
 import type { EntityManager } from '../EntityManager.js';
 import type { SerializeOptions } from '../serialization/EntitySerializer.js';
-export declare function Property<T extends object>(options?: PropertyOptions<T>): (target: any, propertyName: string) => any;
+export declare function Property<T extends object>(options?: PropertyOptions<T>): (target: T, propertyName: string) => any;
 export interface PropertyOptions<Owner> {
     /**
      * Alias for `fieldName`.

package/entity/EntityFactory.js

@@ -86,7 +86,9 @@ export class EntityFactory {
         }
         if (options.merge && wrapped.hasPrimaryKey()) {
             this.unitOfWork.register(entity, data, {
-                refresh: options.refresh && options.initialized,
+                // Always refresh to ensure the payload is in correct shape for joined strategy. When loading nested relations,
+                // they will be created early without `Type.ensureComparable` being properly handled, resulting in extra updates.
+                refresh: options.initialized,
                 newEntity: options.newEntity,
                 loaded: options.initialized,
             });

package/entity/EntityLoader.js

@@ -249,9 +249,13 @@ export class EntityLoader {
                 }
             }
         }
+        const orderBy = [...Utils.asArray(options.orderBy), ...propOrderBy].filter((order, idx, array) => {
+            // skip consecutive ordering with the same key to get around mongo issues
+            return idx === 0 || !Utils.equals(Object.keys(array[idx - 1]), Object.keys(order));
+        });
         const items = await this.em.find(prop.type, where, {
             filters, convertCustomTypes, lockMode, populateWhere, logging,
-            orderBy: [...Utils.asArray(options.orderBy), ...propOrderBy],
+            orderBy,
             populate: populate.children ?? populate.all ?? [],
             exclude: Array.isArray(options.exclude) ? Utils.extractChildElements(options.exclude, prop.name) : options.exclude,
             strategy, fields, schema, connectionType,

package/index.d.ts

@@ -2,7 +2,7 @@
  * @packageDocumentation
  * @module core
  */
-export { Constructor, ConnectionType, Dictionary, PrimaryKeyProp, Primary, IPrimaryKey, ObjectQuery, FilterQuery, IWrappedEntity, EntityName, EntityData, Highlighter, MaybePromise, AnyEntity, EntityClass, EntityProperty, EntityMetadata, QBFilterQuery, PopulateOptions, Populate, Loaded, New, LoadedReference, LoadedCollection, IMigrator, IMigrationGenerator, MigratorEvent, GetRepository, EntityRepositoryType, MigrationObject, DeepPartial, PrimaryProperty, Cast, IsUnknown, EntityDictionary, EntityDTO, MigrationDiff, GenerateOptions, FilterObject, IEntityGenerator, ISeedManager, EntityClassGroup, OptionalProps, EagerProps, HiddenProps, RequiredEntityData, CheckCallback, SimpleColumnMeta, Rel, Ref, ScalarRef, EntityRef, ISchemaGenerator, UmzugMigration, MigrateOptions, MigrationResult, MigrationRow, EntityKey, EntityValue, FilterKey, Opt, EntityType, FromEntityType, Selected, IsSubset, NoInfer, EntityProps, ExpandProperty, ExpandScalar, FilterItemValue, ExpandQuery, Scalar, ExpandHint, Hidden, FilterValue, MergeLoaded, MergeSelected, Config, DefineConfig, TypeConfig, ClearDatabaseOptions, CreateSchemaOptions, EnsureDatabaseOptions, UpdateSchemaOptions, DropSchemaOptions, RefreshDatabaseOptions, AutoPath, UnboxArray, MetadataProcessor, ImportsResolver, } from './typings.js';
+export { Constructor, ConnectionType, Dictionary, PrimaryKeyProp, Primary, IPrimaryKey, ObjectQuery, FilterQuery, IWrappedEntity, EntityName, EntityData, Highlighter, MaybePromise, AnyEntity, EntityClass, EntityProperty, EntityMetadata, QBFilterQuery, PopulateOptions, Populate, Loaded, New, LoadedReference, LoadedCollection, IMigrator, IMigrationGenerator, MigratorEvent, GetRepository, EntityRepositoryType, MigrationObject, DeepPartial, PrimaryProperty, Cast, IsUnknown, EntityDictionary, EntityDTO, MigrationDiff, GenerateOptions, FilterObject, IEntityGenerator, ISeedManager, EntityClassGroup, OptionalProps, EagerProps, HiddenProps, RequiredEntityData, CheckCallback, SimpleColumnMeta, Rel, Ref, ScalarRef, EntityRef, ISchemaGenerator, UmzugMigration, MigrateOptions, MigrationResult, MigrationRow, EntityKey, EntityValue, EntityDataValue, FilterKey, Opt, EntityType, FromEntityType, Selected, IsSubset, NoInfer, EntityProps, ExpandProperty, ExpandScalar, FilterItemValue, ExpandQuery, Scalar, ExpandHint, Hidden, FilterValue, MergeLoaded, MergeSelected, Config, DefineConfig, TypeConfig, ClearDatabaseOptions, CreateSchemaOptions, EnsureDatabaseOptions, UpdateSchemaOptions, DropSchemaOptions, RefreshDatabaseOptions, AutoPath, UnboxArray, MetadataProcessor, ImportsResolver, } from './typings.js';
 export * from './enums.js';
 export * from './errors.js';
 export * from './exceptions.js';

package/metadata/EntitySchema.d.ts

@@ -68,8 +68,8 @@ export declare class EntitySchema<Entity = any, Base = never> {
     addManyToMany<Target = AnyEntity>(name: EntityKey<Entity>, type: TypeType, options: ManyToManyOptions<Entity, Target>): void;
     addOneToMany<Target = AnyEntity>(name: EntityKey<Entity>, type: TypeType, options: OneToManyOptions<Entity, Target>): void;
     addOneToOne<Target = AnyEntity>(name: EntityKey<Entity>, type: TypeType, options: OneToOneOptions<Entity, Target>): void;
-    addIndex(options: IndexOptions<Entity>): void;
-    addUnique(options: UniqueOptions<Entity>): void;
+    addIndex<Key extends string>(options: IndexOptions<Entity, Key>): void;
+    addUnique<Key extends string>(options: UniqueOptions<Entity, Key>): void;
     setCustomRepository(repository: () => Constructor): void;
     setExtends(base: string | EntitySchema): void;
     setClass(proto: EntityClass<Entity>): void;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mikro-orm/core",
   "type": "module",
-  "version": "7.0.0-dev.3",
+  "version": "7.0.0-dev.5",
   "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.",
   "exports": {
     "./package.json": "./package.json",
@@ -55,7 +55,7 @@
     "dotenv": "16.4.7",
     "esprima": "4.0.1",
     "globby": "11.1.0",
-    "mikro-orm": "7.0.0-dev.3",
+    "mikro-orm": "7.0.0-dev.5",
     "reflect-metadata": "0.2.2"
   }
 }

package/typings.d.ts

@@ -28,6 +28,7 @@ export type EntityKey<T = unknown, B extends boolean = false> = string & {
     [K in keyof T]-?: CleanKeys<T, K, B> extends never ? never : K;
 }[keyof T];
 export type EntityValue<T> = T[EntityKey<T>];
+export type EntityDataValue<T> = EntityData<T>[EntityKey<T>];
 export type FilterKey<T> = keyof FilterQuery<T>;
 export type AsyncFunction<R = any, T = Dictionary> = (args: T) => Promise<T>;
 export type Compute<T> = {
@@ -240,7 +241,7 @@ type IsOptional<T, K extends keyof T, I> = T[K] extends Collection<any, any> ? t
 type RequiredKeys<T, K extends keyof T, I> = IsOptional<T, K, I> extends false ? CleanKeys<T, K> : never;
 type OptionalKeys<T, K extends keyof T, I> = IsOptional<T, K, I> extends false ? never : CleanKeys<T, K>;
 export type EntityData<T, C extends boolean = false> = {
-    [K in EntityKey<T>]?: EntityDataItem<T[K], C>;
+    [K in EntityKey<T>]?: EntityDataItem<T[K] & {}, C>;
 };
 export type RequiredEntityData<T, I = never, C extends boolean = false> = {
     [K in keyof T as RequiredKeys<T, K, I>]: T[K] | RequiredEntityDataProp<T[K], T, C> | Primary<T[K]>;
@@ -292,7 +293,9 @@ export type EntityDTO<T, C extends TypeConfig = never> = {
 } & {
     [K in keyof T as DTOOptionalKeys<T, K>]?: EntityDTOProp<T, T[K], C> | AddOptional<T[K]>;
 };
-export type CheckCallback<T> = (columns: Record<keyof T, string>) => string;
+type TargetKeys<T> = T extends EntityClass<infer P> ? keyof P : keyof T;
+type CheckKey<T> = IsUnknown<T> extends false ? TargetKeys<T> : string;
+export type CheckCallback<T> = (columns: Record<CheckKey<T>, string>) => string;
 export type GeneratedColumnCallback<T> = (columns: Record<keyof T, string>) => string;
 export interface CheckConstraint<T = any> {
     name?: string;
@@ -681,7 +684,7 @@ export interface MigrationObject {
 }
 export type FilterDef = {
     name: string;
-    cond: Dictionary | ((args: Dictionary, type: 'read' | 'update' | 'delete', em: any, options?: FindOptions<any, any, any, any> | FindOneOptions<any, any, any, any>) => Dictionary | Promise<Dictionary>);
+    cond: Dictionary | ((args: Dictionary, type: 'read' | 'update' | 'delete', em: any, options?: FindOptions<any, any, any, any> | FindOneOptions<any, any, any, any>, entityName?: EntityName<any>) => Dictionary | Promise<Dictionary>);
     default?: boolean;
     entity?: string[];
     args?: boolean;

package/unit-of-work/UnitOfWork.js

@@ -884,7 +884,7 @@ export class UnitOfWork {
                 collectionUpdates.push(coll);
             }
         }
-        await this.em.getDriver().syncCollections(collectionUpdates, { ctx });
+        await this.em.getDriver().syncCollections(collectionUpdates, { ctx, schema: this.em.schema });
         for (const coll of this.collectionUpdates) {
             coll.takeSnapshot();
         }

package/utils/AbstractSchemaGenerator.js

@@ -32,7 +32,7 @@ export class AbstractSchemaGenerator {
         }
         else {
             await this.ensureDatabase();
-            await this.dropSchema();
+            await this.dropSchema(options);
         }
         if (options?.createSchema !== false) {
             await this.createSchema(options);
@@ -103,7 +103,10 @@ export class AbstractSchemaGenerator {
         }
         return calc.sort()
             .map(cls => this.metadata.find(cls))
-            .filter(meta => schema ? [schema, '*'].includes(meta.schema) : meta.schema !== '*');
+            .filter(meta => {
+            const targetSchema = meta.schema ?? this.config.get('schema', this.platform.getDefaultSchemaName());
+            return schema ? [schema, '*'].includes(targetSchema) : meta.schema !== '*';
+        });
     }
     notImplemented() {
         throw new Error(`This method is not supported by ${this.driver.constructor.name} driver`);

package/utils/EntityComparator.js

@@ -74,7 +74,7 @@ export class EntityComparator {
                 lines.push(`  if (entity${this.wrap(pk)} != null && (entity${this.wrap(pk)}.__entity || entity${this.wrap(pk)}.__reference)) {`);
                 lines.push(`    const pk = entity${this.wrap(pk)}.__helper.getPrimaryKey();`);
                 if (meta.properties[pk].targetMeta.compositePK) {
-                    lines.push(`    if (typeof pk === 'object') {`);
+                    lines.push(`    if (typeof pk === 'object' && pk != null) {`);
                     lines.push(`      return [`);
                     for (const childPK of meta.properties[pk].targetMeta.primaryKeys) {
                         lines.push(`        pk${this.wrap(childPK)},`);

package/utils/RawQueryFragment.js

@@ -17,7 +17,12 @@ export class RawQueryFragment {
         this.#key = `[raw]: ${this.sql} (#${RawQueryFragment.#index++})`;
     }
     as(alias) {
-        return new RawQueryFragment(`${this.sql} as ${alias}`, this.params);
+        // TODO: to be removed in v7
+        /* istanbul ignore next */
+        if (alias.startsWith('`') || alias.startsWith('"')) {
+            return new RawQueryFragment(`${this.sql} as ${alias}`, this.params);
+        }
+        return new RawQueryFragment(`${this.sql} as ??`, [...this.params, alias]);
     }
     valueOf() {
         throw new Error(`Trying to modify raw SQL fragment: '${this.sql}'`);