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

package/entity/index.d.ts

@@ -11,3 +11,5 @@ export * from './Reference.js';
 export * from './BaseEntity.js';
 export * from './WrappedEntity.js';
 export * from './wrap.js';
+export * from './defineEntity.js';
+export * from './utils.js';

package/entity/index.js

@@ -11,3 +11,5 @@ export * from './Reference.js';
 export * from './BaseEntity.js';
 export * from './WrappedEntity.js';
 export * from './wrap.js';
+export * from './defineEntity.js';
+export * from './utils.js';

package/entity/utils.d.ts

@@ -1,5 +1,12 @@
 import type { EntityMetadata, PopulateOptions } from '../typings.js';
+import { LoadStrategy, ReferenceKind } from '../enums.js';
 /**
  * @internal
  */
 export declare function expandDotPaths<Entity>(meta: EntityMetadata<Entity>, populate?: readonly (string | PopulateOptions<Entity>)[], normalized?: boolean): PopulateOptions<Entity>[];
+/**
+ * Returns the loading strategy based on the provided hint.
+ * If `BALANCED` strategy is used, it will return JOINED if the property is a to-one relation.
+ * @internal
+ */
+export declare function getLoadingStrategy(strategy: LoadStrategy | `${LoadStrategy}`, kind: ReferenceKind): LoadStrategy.SELECT_IN | LoadStrategy.JOINED;

package/entity/utils.js

@@ -1,5 +1,5 @@
-import { PopulatePath, ReferenceKind } from '../enums.js';
-import { Utils } from '@mikro-orm/core';
+import { LoadStrategy, PopulatePath, ReferenceKind } from '../enums.js';
+import { Utils } from '../utils/Utils.js';
 /**
  * Expands `books.perex` like populate to use `children` array instead of the dot syntax
  */
@@ -34,7 +34,6 @@ export function expandDotPaths(meta, populate, normalized = false) {
         p.field = f;
         p.children ??= [];
         const prop = meta.properties[p.field];
-        p.strategy ??= prop.strategy;
         if (parts[0] === PopulatePath.ALL) {
             prop.targetMeta.props
                 .filter(prop => prop.lazy || prop.kind !== ReferenceKind.SCALAR)
@@ -55,3 +54,16 @@ export function expandDotPaths(meta, populate, normalized = false) {
     }
     return ret;
 }
+/**
+ * Returns the loading strategy based on the provided hint.
+ * If `BALANCED` strategy is used, it will return JOINED if the property is a to-one relation.
+ * @internal
+ */
+export function getLoadingStrategy(strategy, kind) {
+    if (strategy === LoadStrategy.BALANCED) {
+        return [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(kind)
+            ? LoadStrategy.JOINED
+            : LoadStrategy.SELECT_IN;
+    }
+    return strategy;
+}

package/enums.d.ts

@@ -66,7 +66,7 @@ export declare enum QueryOrderNumeric {
     ASC = 1,
     DESC = -1
 }
-export type QueryOrderKeysFlat = QueryOrder | QueryOrderNumeric | keyof typeof QueryOrder;
+export type QueryOrderKeysFlat = QueryOrder | QueryOrderNumeric | `${QueryOrder}`;
 export type QueryOrderKeys<T> = QueryOrderKeysFlat | QueryOrderMap<T>;
 export type QueryOrderMap<T> = {
     [K in EntityKey<T>]?: QueryOrderKeys<ExpandProperty<T[K]>>;
@@ -85,7 +85,9 @@ export declare enum QueryFlag {
     INCLUDE_LAZY_FORMULAS = "INCLUDE_LAZY_FORMULAS",
     AUTO_JOIN_ONE_TO_ONE_OWNER = "AUTO_JOIN_ONE_TO_ONE_OWNER",
     INFER_POPULATE = "INFER_POPULATE",
-    IDENTITY_INSERT = "IDENTITY_INSERT"
+    DISABLE_NESTED_INNER_JOIN = "DISABLE_NESTED_INNER_JOIN",
+    IDENTITY_INSERT = "IDENTITY_INSERT",// mssql only
+    OUTPUT_TABLE = "OUTPUT_TABLE"
 }
 export declare const SCALAR_TYPES: string[];
 export declare enum ReferenceKind {
@@ -108,7 +110,8 @@ export declare enum Cascade {
 }
 export declare enum LoadStrategy {
     SELECT_IN = "select-in",
-    JOINED = "joined"
+    JOINED = "joined",
+    BALANCED = "balanced"
 }
 export declare enum DataloaderType {
     NONE = 0,
@@ -156,8 +159,18 @@ export declare enum EventType {
 }
 export declare const EventTypeMap: Record<EventType, number>;
 export type TransactionEventType = EventType.beforeTransactionStart | EventType.afterTransactionStart | EventType.beforeTransactionCommit | EventType.afterTransactionCommit | EventType.beforeTransactionRollback | EventType.afterTransactionRollback;
+export declare enum TransactionPropagation {
+    REQUIRED = "required",
+    REQUIRES_NEW = "requires_new",
+    NESTED = "nested",
+    NOT_SUPPORTED = "not_supported",
+    SUPPORTS = "supports",
+    MANDATORY = "mandatory",
+    NEVER = "never"
+}
 export interface TransactionOptions {
     ctx?: Transaction;
+    propagation?: TransactionPropagation;
     isolationLevel?: IsolationLevel;
     readOnly?: boolean;
     clear?: boolean;

package/enums.js

@@ -95,7 +95,9 @@ export var QueryFlag;
     QueryFlag["INCLUDE_LAZY_FORMULAS"] = "INCLUDE_LAZY_FORMULAS";
     QueryFlag["AUTO_JOIN_ONE_TO_ONE_OWNER"] = "AUTO_JOIN_ONE_TO_ONE_OWNER";
     QueryFlag["INFER_POPULATE"] = "INFER_POPULATE";
+    QueryFlag["DISABLE_NESTED_INNER_JOIN"] = "DISABLE_NESTED_INNER_JOIN";
     QueryFlag["IDENTITY_INSERT"] = "IDENTITY_INSERT";
+    QueryFlag["OUTPUT_TABLE"] = "OUTPUT_TABLE";
 })(QueryFlag || (QueryFlag = {}));
 export const SCALAR_TYPES = ['string', 'number', 'boolean', 'bigint', 'Date', 'Buffer', 'RegExp'];
 export var ReferenceKind;
@@ -122,6 +124,7 @@ export var LoadStrategy;
 (function (LoadStrategy) {
     LoadStrategy["SELECT_IN"] = "select-in";
     LoadStrategy["JOINED"] = "joined";
+    LoadStrategy["BALANCED"] = "balanced";
 })(LoadStrategy || (LoadStrategy = {}));
 export var DataloaderType;
 (function (DataloaderType) {
@@ -175,6 +178,16 @@ export const EventTypeMap = Object.keys(EventType).reduce((a, b, i) => {
     a[b] = i;
     return a;
 }, {});
+export var TransactionPropagation;
+(function (TransactionPropagation) {
+    TransactionPropagation["REQUIRED"] = "required";
+    TransactionPropagation["REQUIRES_NEW"] = "requires_new";
+    TransactionPropagation["NESTED"] = "nested";
+    TransactionPropagation["NOT_SUPPORTED"] = "not_supported";
+    TransactionPropagation["SUPPORTS"] = "supports";
+    TransactionPropagation["MANDATORY"] = "mandatory";
+    TransactionPropagation["NEVER"] = "never";
+})(TransactionPropagation || (TransactionPropagation = {}));
 export class PlainObject {
 }
 export var DeferMode;

package/errors.d.ts

@@ -24,6 +24,7 @@ export declare class ValidationError<T extends AnyEntity = AnyEntity> extends Er
     static cannotCommit(): ValidationError;
     static cannotUseGlobalContext(): ValidationError;
     static cannotUseOperatorsInsideEmbeddables(className: string, propName: string, payload: unknown): ValidationError;
+    static cannotUseGroupOperatorsInsideScalars(className: string, propName: string, payload: unknown): ValidationError;
     static invalidEmbeddableQuery(className: string, propName: string, embeddableType: string): ValidationError;
 }
 export declare class CursorError<T extends AnyEntity = AnyEntity> extends ValidationError<T> {
@@ -66,3 +67,8 @@ export declare class NotFoundError<T extends AnyEntity = AnyEntity> extends Vali
     static findOneFailed(name: string, where: Dictionary | IPrimaryKey): NotFoundError;
     static findExactlyOneFailed(name: string, where: Dictionary | IPrimaryKey): NotFoundError;
 }
+export declare class TransactionStateError extends ValidationError {
+    static requiredTransactionNotFound(propagation: string): TransactionStateError;
+    static transactionNotAllowed(propagation: string): TransactionStateError;
+    static invalidPropagation(propagation: string): TransactionStateError;
+}

package/errors.js

@@ -94,6 +94,9 @@ export class ValidationError extends Error {
     static cannotUseOperatorsInsideEmbeddables(className, propName, payload) {
         return new ValidationError(`Using operators inside embeddables is not allowed, move the operator above. (property: ${className}.${propName}, payload: ${inspect(payload)})`);
     }
+    static cannotUseGroupOperatorsInsideScalars(className, propName, payload) {
+        return new ValidationError(`Using group operators ($and/$or) inside scalar properties is not allowed, move the operator above. (property: ${className}.${propName}, payload: ${inspect(payload)})`);
+    }
     static invalidEmbeddableQuery(className, propName, embeddableType) {
         return new ValidationError(`Invalid query for entity '${className}', property '${propName}' does not exist in embeddable '${embeddableType}'`);
     }
@@ -220,3 +223,14 @@ export class NotFoundError extends ValidationError {
         return new NotFoundError(`Wrong number of ${name} entities found for query ${inspect(where)}, expected exactly one`);
     }
 }
+export class TransactionStateError extends ValidationError {
+    static requiredTransactionNotFound(propagation) {
+        return new TransactionStateError(`No existing transaction found for transaction marked with propagation "${propagation}"`);
+    }
+    static transactionNotAllowed(propagation) {
+        return new TransactionStateError(`Existing transaction found for transaction marked with propagation "${propagation}"`);
+    }
+    static invalidPropagation(propagation) {
+        return new TransactionStateError(`Unsupported transaction propagation type: ${propagation}`);
+    }
+}

package/events/EventSubscriber.d.ts

@@ -13,7 +13,9 @@ export interface FlushEventArgs extends Omit<EventArgs<any>, 'entity' | 'changeS
     uow: UnitOfWork;
 }
 export interface TransactionEventArgs extends Omit<EventArgs<any>, 'entity' | 'meta' | 'changeSet'> {
-    transaction?: Transaction;
+    transaction?: Transaction & {
+        savepointName?: string;
+    };
     uow?: UnitOfWork;
 }
 export interface EventSubscriber<T = any> {

package/hydration/ObjectHydrator.js

@@ -63,7 +63,7 @@ export class ObjectHydrator extends Hydrator {
             const ret = [];
             const idx = this.tmpIndex++;
             const nullVal = this.config.get('forceUndefined') ? 'undefined' : 'null';
-            if (prop.getter && !prop.setter) {
+            if (prop.getter && !prop.setter && prop.persist === false) {
                 return [];
             }
             if (prop.ref) {
@@ -71,7 +71,14 @@ export class ObjectHydrator extends Hydrator {
                 ret.push(`  const oldValue_${idx} = entity${entityKey};`);
             }
             ret.push(`  if (data${dataKey} === null) {`);
-            ret.push(`    entity${entityKey} = ${nullVal};`);
+            if (prop.ref) {
+                ret.push(`    entity${entityKey} = new ScalarReference();`);
+                ret.push(`    entity${entityKey}.bind(entity, '${prop.name}');`);
+                ret.push(`    entity${entityKey}.set(${nullVal});`);
+            }
+            else {
+                ret.push(`    entity${entityKey} = ${nullVal};`);
+            }
             ret.push(`  } else if (typeof data${dataKey} !== 'undefined') {`);
             if (prop.customType) {
                 registerCustomType(prop, convertorKey, 'convertToJSValue', context);
@@ -256,6 +263,7 @@ export class ObjectHydrator extends Hydrator {
                             ...prop2,
                             name: childProp.name,
                             embedded: childProp.embedded,
+                            embeddedProps: childProp.embeddedProps,
                         };
                         // eslint-disable-next-line @typescript-eslint/no-use-before-define
                         ret.push(...hydrateProperty(prop3, childProp.object, [...path, childProp.embedded[1]], childDataKey).map(l => '    ' + l));

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, IndexCallback, 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, RequiredNullable, } from './typings.js';
 export * from './enums.js';
 export * from './errors.js';
 export * from './exceptions.js';

package/index.js

@@ -2,7 +2,7 @@
  * @packageDocumentation
  * @module core
  */
-export { PrimaryKeyProp, EntityMetadata, EntityRepositoryType, OptionalProps, EagerProps, HiddenProps, Config, } from './typings.js';
+export { PrimaryKeyProp, EntityMetadata, EntityRepositoryType, OptionalProps, EagerProps, HiddenProps, Opt, Hidden, Config, DefineConfig, RequiredNullable, } from './typings.js';
 export * from './enums.js';
 export * from './errors.js';
 export * from './exceptions.js';

package/metadata/EntitySchema.d.ts

@@ -31,7 +31,7 @@ export type EntitySchemaProperty<Target, Owner> = ({
     kind: ReferenceKind.MANY_TO_MANY | 'm:n';
 } & TypeDef<Target> & ManyToManyOptions<Owner, Target>) | ({
     kind: ReferenceKind.EMBEDDED | 'embedded';
-} & EmbeddedTypeDef<Target> & EmbeddedOptions & PropertyOptions<Owner>) | ({
+} & EmbeddedTypeDef<Target> & EmbeddedOptions<Owner, Target> & PropertyOptions<Owner>) | ({
     enum: true;
 } & EnumOptions<Owner>) | (TypeDef<Target> & PropertyOptions<Owner>);
 type OmitBaseProps<Entity, Base> = IsNever<Base> extends true ? Entity : Omit<Entity, keyof Base>;
@@ -63,13 +63,13 @@ export declare class EntitySchema<Entity = any, Base = never> {
     addVersion(name: EntityKey<Entity>, type: TypeType, options?: PropertyOptions<Entity>): void;
     addPrimaryKey(name: EntityKey<Entity>, type: TypeType, options?: PrimaryKeyOptions<Entity>): void;
     addSerializedPrimaryKey(name: EntityKey<Entity>, type: TypeType, options?: SerializedPrimaryKeyOptions<Entity>): void;
-    addEmbedded<Target = AnyEntity>(name: EntityKey<Entity>, options: EmbeddedOptions): void;
+    addEmbedded<Target = AnyEntity>(name: EntityKey<Entity>, options: EmbeddedOptions<Entity, Target>): void;
     addManyToOne<Target = AnyEntity>(name: EntityKey<Entity>, type: TypeType, options: ManyToOneOptions<Entity, Target>): void;
     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;
@@ -83,5 +83,7 @@ export declare class EntitySchema<Entity = any, Base = never> {
     private initPrimaryKeys;
     private normalizeType;
     private createProperty;
+    private rename;
+    private renameCompositeOptions;
 }
 export {};

package/metadata/EntitySchema.js

@@ -34,23 +34,7 @@ export class EntitySchema {
         return schema;
     }
     addProperty(name, type, options = {}) {
-        const rename = (data, from, to) => {
-            if (from in options && !(to in options)) {
-                // @ts-ignore
-                options[to] = [options[from]];
-                // @ts-ignore
-                delete options[from];
-            }
-        };
-        if (name !== options.name) {
-            Utils.renameKey(options, 'name', 'fieldName');
-        }
-        rename(options, 'fieldName', 'fieldNames');
-        rename(options, 'ref', 'ref');
-        rename(options, 'joinColumn', 'joinColumns');
-        rename(options, 'inverseJoinColumn', 'inverseJoinColumns');
-        rename(options, 'referenceColumnName', 'referencedColumnNames');
-        rename(options, 'columnType', 'columnTypes');
+        this.renameCompositeOptions(name, options);
         const prop = { name, kind: ReferenceKind.SCALAR, ...options, type: this.normalizeType(options, type) };
         if (type && Type.isMappedType(type.prototype)) {
             prop.type = type;
@@ -94,6 +78,7 @@ export class EntitySchema {
         this.addProperty(name, type, options);
     }
     addEmbedded(name, options) {
+        this.renameCompositeOptions(name, options);
         Utils.defaultValue(options, 'prefix', true);
         if (options.array) {
             options.object = true; // force object mode for arrays
@@ -114,6 +99,8 @@ export class EntitySchema {
         if (prop.fieldNames && !prop.joinColumns) {
             prop.joinColumns = prop.fieldNames;
         }
+        // By default, the foreign key constraint is created on the relation
+        Utils.defaultValue(prop, 'createForeignKeyConstraint', true);
         this.addProperty(name, type, prop);
     }
     addManyToMany(name, type, options) {
@@ -123,6 +110,8 @@ export class EntitySchema {
         }
         if (options.owner) {
             Utils.renameKey(options, 'mappedBy', 'inversedBy');
+            // By default, the foreign key constraint is created on the relation
+            Utils.defaultValue(options, 'createForeignKeyConstraint', true);
         }
         const prop = this.createProperty(ReferenceKind.MANY_TO_MANY, options);
         this.addProperty(name, type, prop);
@@ -135,8 +124,12 @@ export class EntitySchema {
         const prop = this.createProperty(ReferenceKind.ONE_TO_ONE, options);
         Utils.defaultValue(prop, 'owner', !!prop.inversedBy || !prop.mappedBy);
         Utils.defaultValue(prop, 'unique', prop.owner);
-        if (prop.owner && options.mappedBy) {
-            Utils.renameKey(prop, 'mappedBy', 'inversedBy');
+        if (prop.owner) {
+            if (options.mappedBy) {
+                Utils.renameKey(prop, 'mappedBy', 'inversedBy');
+            }
+            // By default, the foreign key constraint is created on the relation
+            Utils.defaultValue(prop, 'createForeignKeyConstraint', true);
         }
         if (prop.joinColumns && !prop.fieldNames) {
             prop.fieldNames = prop.joinColumns;
@@ -289,4 +282,25 @@ export class EntitySchema {
             ...options,
         };
     }
+    rename(data, from, to) {
+        if (from in data && !(to in data)) {
+            // @ts-ignore
+            data[to] = [data[from]];
+            // @ts-ignore
+            delete data[from];
+        }
+    }
+    renameCompositeOptions(name, options = {}) {
+        if (name !== options.name && !options.fieldNames) {
+            Utils.renameKey(options, 'name', 'fieldName');
+        }
+        else if (options.name && (options.fieldNames?.length ?? 0) > 1) {
+            delete options.name;
+        }
+        this.rename(options, 'fieldName', 'fieldNames');
+        this.rename(options, 'joinColumn', 'joinColumns');
+        this.rename(options, 'inverseJoinColumn', 'inverseJoinColumns');
+        this.rename(options, 'referenceColumnName', 'referencedColumnNames');
+        this.rename(options, 'columnType', 'columnTypes');
+    }
 }

package/metadata/MetadataDiscovery.d.ts

@@ -54,7 +54,6 @@ export declare class MetadataDiscovery {
     private initAutoincrement;
     private initCheckConstraints;
     private initGeneratedColumn;
-    private createColumnMappingObject;
     private getDefaultVersionValue;
     private inferDefaultValue;
     private initDefaultValue;

package/metadata/MetadataDiscovery.js

@@ -1,5 +1,5 @@
 import { basename, extname } from 'node:path';
-import globby from 'globby';
+import { glob } from 'tinyglobby';
 import { EntityMetadata, } from '../typings.js';
 import { Utils } from '../utils/Utils.js';
 import { MetadataValidator } from './MetadataValidator.js';
@@ -7,7 +7,7 @@ import { MetadataStorage } from './MetadataStorage.js';
 import { EntitySchema } from './EntitySchema.js';
 import { Cascade, ReferenceKind } from '../enums.js';
 import { MetadataError } from '../errors.js';
-import { ArrayType, BigIntType, BlobType, DecimalType, DoubleType, EnumArrayType, IntervalType, JsonType, t, Type, Uint8ArrayType, UnknownType, } from '../types/index.js';
+import { ArrayType, BigIntType, BlobType, DateType, DecimalType, DoubleType, EnumArrayType, IntervalType, JsonType, t, Type, Uint8ArrayType, UnknownType, } from '../types/index.js';
 import { colors } from '../logging/colors.js';
 import { raw, RawQueryFragment } from '../utils/RawQueryFragment.js';
 export class MetadataDiscovery {
@@ -181,7 +181,7 @@ export class MetadataDiscovery {
     }
     async discoverDirectories(paths) {
         paths = paths.map(path => Utils.normalizePath(path));
-        const files = await globby(paths, { cwd: Utils.normalizePath(this.config.get('baseDir')) });
+        const files = await glob(paths, { cwd: Utils.normalizePath(this.config.get('baseDir')) });
         this.logger.log('discovery', `- processing ${colors.cyan('' + files.length)} files`);
         const found = [];
         for (const filepath of files) {
@@ -264,7 +264,8 @@ export class MetadataDiscovery {
                 // initialize global metadata for given entity
                 MetadataStorage.getMetadata(entity.meta.className, filepath);
             }
-            return entity;
+            const meta = Utils.copy(entity.meta, false);
+            return EntitySchema.fromMetadata(meta);
         }
         const path = entity[MetadataStorage.PATH_SYMBOL];
         if (path) {
@@ -618,7 +619,7 @@ export class MetadataDiscovery {
         }
         data.properties[meta.name + '_owner'] = this.definePivotProperty(prop, meta.name + '_owner', meta.className, targetType + '_inverse', true, meta.className === targetType);
         data.properties[targetType + '_inverse'] = this.definePivotProperty(prop, targetType + '_inverse', targetType, meta.name + '_owner', false, meta.className === targetType);
-        return this.metadata.set(data.className, data);
+        return this.metadata.set(data.className, EntitySchema.fromMetadata(data).init().meta);
     }
     defineFixedOrderProperty(prop, targetType) {
         const pk = prop.fixedOrderColumn || this.namingStrategy.referenceColumnName();
@@ -653,6 +654,7 @@ export class MetadataDiscovery {
             autoincrement: false,
             updateRule: prop.updateRule,
             deleteRule: prop.deleteRule,
+            createForeignKeyConstraint: prop.createForeignKeyConstraint,
         };
         if (selfReferencing && !this.platform.supportsMultipleCascadePaths()) {
             ret.updateRule ??= 'no action';
@@ -765,6 +767,7 @@ export class MetadataDiscovery {
                     delete prop.default;
                     if (properties[prop.name] && properties[prop.name].type !== prop.type) {
                         properties[prop.name].type = `${properties[prop.name].type} | ${prop.type}`;
+                        properties[prop.name].runtimeType = 'any';
                         return properties[prop.name];
                     }
                     return properties[prop.name] = prop;
@@ -819,9 +822,16 @@ export class MetadataDiscovery {
             }
             return prop.embedded ? isParentObject(meta.properties[prop.embedded[0]]) : false;
         };
+        const isParentArray = (prop) => {
+            if (prop.array) {
+                return true;
+            }
+            return prop.embedded ? isParentArray(meta.properties[prop.embedded[0]]) : false;
+        };
         const rootProperty = getRootProperty(embeddedProp);
         const parentProperty = meta.properties[embeddedProp.embedded?.[0] ?? ''];
         const object = isParentObject(embeddedProp);
+        const array = isParentArray(embeddedProp);
         this.initFieldName(embeddedProp, rootProperty !== embeddedProp && object);
         // the prefix of the parent cannot be a boolean; it already passed here
         const prefix = this.getPrefix(embeddedProp, parentProperty);
@@ -834,7 +844,8 @@ export class MetadataDiscovery {
             meta.propertyOrder.set(name, (order += 0.01));
             embeddedProp.embeddedProps[prop.name] = meta.properties[name];
             meta.properties[name].persist ??= embeddedProp.persist;
-            if (embeddedProp.nullable) {
+            const refInArray = array && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && prop.owner;
+            if (embeddedProp.nullable || refInArray) {
                 meta.properties[name].nullable = true;
             }
             if (meta.properties[name].fieldNames) {
@@ -872,6 +883,7 @@ export class MetadataDiscovery {
                 meta.properties[name].persist = false; // only virtual as we store the whole object
                 meta.properties[name].userDefined = false; // mark this as a generated/internal property, so we can distinguish from user-defined non-persist properties
                 meta.properties[name].object = true;
+                this.initCustomType(meta, meta.properties[name], false, true);
             }
             this.initEmbeddables(meta, meta.properties[name], visited);
         }
@@ -905,11 +917,13 @@ export class MetadataDiscovery {
         }
         if (!meta.root.discriminatorMap) {
             meta.root.discriminatorMap = {};
-            const children = metadata.filter(m => m.root.className === meta.root.className && !m.abstract);
-            children.forEach(m => {
+            const children = metadata
+                .filter(m => m.root.className === meta.root.className && !m.abstract)
+                .sort((a, b) => a.className.localeCompare(b.className));
+            for (const m of children) {
                 const name = m.discriminatorValue ?? this.namingStrategy.classToTableName(m.className);
                 meta.root.discriminatorMap[name] = m.className;
-            });
+            }
         }
         meta.discriminatorValue = Object.entries(meta.root.discriminatorMap).find(([, className]) => className === meta.className)?.[0];
         if (!meta.root.properties[meta.root.discriminatorColumn]) {
@@ -922,7 +936,7 @@ export class MetadataDiscovery {
         }
         let i = 1;
         Object.values(meta.properties).forEach(prop => {
-            const newProp = Utils.copy(prop, false);
+            const newProp = { ...prop };
             if (meta.root.properties[prop.name] && meta.root.properties[prop.name].type !== prop.type) {
                 const name = newProp.name;
                 this.initFieldName(newProp, newProp.object);
@@ -944,6 +958,7 @@ export class MetadataDiscovery {
         meta.collection = meta.root.collection;
         meta.root.indexes = Utils.unique([...meta.root.indexes, ...meta.indexes]);
         meta.root.uniques = Utils.unique([...meta.root.uniques, ...meta.uniques]);
+        meta.root.checks = Utils.unique([...meta.root.checks, ...meta.checks]);
     }
     createDiscriminatorProperty(meta) {
         meta.addProperty({
@@ -962,7 +977,7 @@ export class MetadataDiscovery {
         }
     }
     initCheckConstraints(meta) {
-        const map = this.createColumnMappingObject(meta);
+        const map = meta.createColumnMappingObject();
         for (const check of meta.checks) {
             const columns = check.property ? meta.properties[check.property].fieldNames : [];
             check.name ??= this.namingStrategy.indexName(meta.tableName, columns, 'check');
@@ -997,20 +1012,12 @@ export class MetadataDiscovery {
             }
             return;
         }
-        const map = this.createColumnMappingObject(meta);
+        const map = meta.createColumnMappingObject();
         if (prop.generated instanceof Function) {
             prop.generated = prop.generated(map);
         }
     }
-    createColumnMappingObject(meta) {
-        return Object.values(meta.properties).reduce((o, prop) => {
-            if (prop.fieldNames) {
-                o[prop.name] = prop.fieldNames[0];
-            }
-            return o;
-        }, {});
-    }
-    getDefaultVersionValue(prop) {
+    getDefaultVersionValue(meta, prop) {
         if (typeof prop.defaultRaw !== 'undefined') {
             return prop.defaultRaw;
         }
@@ -1018,7 +1025,9 @@ export class MetadataDiscovery {
         if (prop.default != null) {
             return '' + this.platform.quoteVersionValue(prop.default, prop);
         }
-        if (prop.type.toLowerCase() === 'date') {
+        this.initCustomType(meta, prop, true);
+        const type = prop.customType?.runtimeType ?? prop.runtimeType ?? prop.type;
+        if (type === 'Date') {
             prop.length ??= this.platform.getDefaultVersionLength();
             return this.platform.getCurrentTimestampSQL(prop.length);
         }
@@ -1061,7 +1070,7 @@ export class MetadataDiscovery {
             prop.defaultRaw = this.platform.formatQuery(raw.sql, raw.params);
             return;
         }
-        if (prop.customType instanceof ArrayType && Array.isArray(prop.default)) {
+        if (Array.isArray(prop.default) && prop.customType) {
             val = prop.customType.convertToDatabaseValue(prop.default, this.platform);
         }
         prop.defaultRaw = typeof val === 'string' ? `'${val}'` : '' + val;
@@ -1089,13 +1098,13 @@ export class MetadataDiscovery {
         if (prop.version) {
             this.initDefaultValue(prop);
             meta.versionProperty = prop.name;
-            prop.defaultRaw = this.getDefaultVersionValue(prop);
+            prop.defaultRaw = this.getDefaultVersionValue(meta, prop);
         }
         if (prop.concurrencyCheck && !prop.primary) {
             meta.concurrencyCheckKeys.add(prop.name);
         }
     }
-    initCustomType(meta, prop) {
+    initCustomType(meta, prop, simple = false, objectEmbeddable = false) {
         // `prop.type` might be actually instance of custom type class
         if (Type.isMappedType(prop.type) && !prop.customType) {
             prop.customType = prop.type;
@@ -1106,21 +1115,31 @@ export class MetadataDiscovery {
             prop.customType = new prop.type();
             prop.type = prop.customType.constructor.name;
         }
+        if (simple) {
+            return;
+        }
         if (!prop.customType && ['json', 'jsonb'].includes(prop.type?.toLowerCase())) {
             prop.customType = new JsonType();
         }
         if (prop.kind === ReferenceKind.SCALAR && !prop.customType && prop.columnTypes && ['json', 'jsonb'].includes(prop.columnTypes[0])) {
             prop.customType = new JsonType();
         }
+        if (prop.kind === ReferenceKind.EMBEDDED && !prop.customType && (prop.object || prop.array)) {
+            prop.customType = new JsonType();
+        }
         if (!prop.customType && prop.array && prop.items) {
             prop.customType = new EnumArrayType(`${meta.className}.${prop.name}`, prop.items);
         }
+        const isArray = prop.type?.toLowerCase() === 'array' || prop.type?.toString().endsWith('[]');
+        if (objectEmbeddable && !prop.customType && isArray) {
+            prop.customType = new JsonType();
+        }
         // for number arrays we make sure to convert the items to numbers
         if (!prop.customType && prop.type === 'number[]') {
             prop.customType = new ArrayType(i => +i);
         }
         // `string[]` can be returned via ts-morph, while reflect metadata will give us just `array`
-        if (!prop.customType && (prop.type?.toLowerCase() === 'array' || prop.type?.toString().endsWith('[]'))) {
+        if (!prop.customType && isArray) {
             prop.customType = new ArrayType();
         }
         if (!prop.customType && prop.type?.toLowerCase() === 'buffer') {
@@ -1131,9 +1150,9 @@ export class MetadataDiscovery {
         }
         const mappedType = this.getMappedType(prop);
         if (prop.fieldNames?.length === 1 && !prop.customType) {
-            [BigIntType, DoubleType, DecimalType, IntervalType]
+            [BigIntType, DoubleType, DecimalType, IntervalType, DateType]
                 .filter(type => mappedType instanceof type)
-                .forEach(type => prop.customType = new type());
+                .forEach((type) => prop.customType = new type());
         }
         if (prop.customType && !prop.columnTypes) {
             const mappedType = this.getMappedType({ columnTypes: [prop.customType.getColumnType(prop, this.platform)] });
@@ -1144,6 +1163,9 @@ export class MetadataDiscovery {
                 prop.runtimeType ??= prop.customType.runtimeType;
             }
         }
+        else if (prop.runtimeType === 'object') {
+            prop.runtimeType = mappedType.runtimeType;
+        }
         else {
             prop.runtimeType ??= mappedType.runtimeType;
         }
@@ -1158,7 +1180,7 @@ export class MetadataDiscovery {
                 prop.customType.mode = prop.runtimeType.toLowerCase();
             }
         }
-        if (Type.isMappedType(prop.customType) && prop.kind === ReferenceKind.SCALAR && !prop.type?.toString().endsWith('[]')) {
+        if (Type.isMappedType(prop.customType) && prop.kind === ReferenceKind.SCALAR && !isArray) {
             prop.type = prop.customType.name;
         }
         if (!prop.customType && [ReferenceKind.ONE_TO_ONE, ReferenceKind.MANY_TO_ONE].includes(prop.kind) && this.metadata.get(prop.type).compositePK) {