@mikro-orm/core 7.0.0-dev.19 → 7.0.0-dev.190

package/hydration/ObjectHydrator.js

@@ -3,40 +3,43 @@ import { Collection } from '../entity/Collection.js';
 import { Reference, ScalarReference } from '../entity/Reference.js';
 import { parseJsonSafe, Utils } from '../utils/Utils.js';
 import { ReferenceKind } from '../enums.js';
-import { RawQueryFragment } from '../utils/RawQueryFragment.js';
+import { Raw } from '../utils/RawQueryFragment.js';
 export class ObjectHydrator extends Hydrator {
     hydrators = {
-        full: new Map(),
-        reference: new Map(),
+        'full~true': new Map(),
+        'full~false': new Map(),
+        'reference~true': new Map(),
+        'reference~false': new Map(),
     };
     tmpIndex = 0;
     /**
      * @inheritDoc
      */
-    hydrate(entity, meta, data, factory, type, newEntity = false, convertCustomTypes = false, schema, parentSchema) {
-        const hydrate = this.getEntityHydrator(meta, type);
+    hydrate(entity, meta, data, factory, type, newEntity = false, convertCustomTypes = false, schema, parentSchema, normalizeAccessors) {
+        const hydrate = this.getEntityHydrator(meta, type, normalizeAccessors);
         const running = this.running;
         // the running state is used to consider propagation as hydration, saving the values directly to the entity data,
         // but we don't want that for new entities, their propagation should result in entity updates when flushing
         this.running = !newEntity;
-        Utils.callCompiledFunction(hydrate, entity, data, factory, newEntity, convertCustomTypes, schema, parentSchema);
+        Utils.callCompiledFunction(hydrate, entity, data, factory, newEntity, convertCustomTypes, schema, parentSchema, normalizeAccessors);
         this.running = running;
     }
     /**
      * @inheritDoc
      */
-    hydrateReference(entity, meta, data, factory, convertCustomTypes = false, schema, parentSchema) {
-        const hydrate = this.getEntityHydrator(meta, 'reference');
+    hydrateReference(entity, meta, data, factory, convertCustomTypes = false, schema, parentSchema, normalizeAccessors) {
+        const hydrate = this.getEntityHydrator(meta, 'reference', normalizeAccessors);
         const running = this.running;
         this.running = true;
-        Utils.callCompiledFunction(hydrate, entity, data, factory, false, convertCustomTypes, schema, parentSchema);
+        Utils.callCompiledFunction(hydrate, entity, data, factory, false, convertCustomTypes, schema, parentSchema, normalizeAccessors);
         this.running = running;
     }
     /**
      * @internal Highly performance-sensitive method.
      */
-    getEntityHydrator(meta, type) {
-        const exists = this.hydrators[type].get(meta.className);
+    getEntityHydrator(meta, type, normalizeAccessors = false) {
+        const key = `${type}~${normalizeAccessors}`;
+        const exists = this.hydrators[key].get(meta.class);
         if (exists) {
             return exists;
         }
@@ -48,22 +51,22 @@ export class ObjectHydrator extends Hydrator {
         context.set('Reference', Reference);
         const registerCustomType = (prop, convertorKey, method, context) => {
             context.set(`${method}_${convertorKey}`, (val) => {
-                /* v8 ignore next 3 */
-                if (RawQueryFragment.isKnownFragment(val)) {
+                /* v8 ignore next */
+                if (Raw.isKnownFragment(val)) {
                     return val;
                 }
                 return prop.customType[method](val, this.platform, { mode: 'serialization' });
             });
             return convertorKey;
         };
-        const hydrateScalar = (prop, object, path, dataKey) => {
+        const hydrateScalar = (prop, path, dataKey) => {
             const entityKey = path.map(k => this.wrap(k)).join('');
             const tz = this.platform.getTimezone();
             const convertorKey = path.filter(k => !k.match(/\[idx_\d+]/)).map(k => this.safeKey(k)).join('_');
             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 +74,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);
@@ -125,23 +135,27 @@ export class ObjectHydrator extends Hydrator {
             ret.push(`  if (data${dataKey} === null) {\n    entity${entityKey} = ${nullVal};`);
             ret.push(`  } else if (typeof data${dataKey} !== 'undefined') {`);
             ret.push(`    if (isPrimaryKey(data${dataKey}, true)) {`);
+            const targetKey = this.safeKey(`${prop.targetMeta.tableName}_${this.tmpIndex++}`);
+            context.set(targetKey, prop.targetMeta.class);
+            // When targetKey is set, pass the key option to createReference so it uses the alternate key
+            const keyOption = prop.targetKey ? `, key: '${prop.targetKey}'` : '';
             if (prop.ref) {
-                ret.push(`      entity${entityKey} = Reference.create(factory.createReference('${prop.type}', data${dataKey}, { merge: true, convertCustomTypes, schema }));`);
+                ret.push(`      entity${entityKey} = Reference.create(factory.createReference(${targetKey}, data${dataKey}, { merge: true, convertCustomTypes, normalizeAccessors, schema${keyOption} }));`);
             }
             else {
-                ret.push(`      entity${entityKey} = factory.createReference('${prop.type}', data${dataKey}, { merge: true, convertCustomTypes, schema });`);
+                ret.push(`      entity${entityKey} = factory.createReference(${targetKey}, data${dataKey}, { merge: true, convertCustomTypes, normalizeAccessors, schema${keyOption} });`);
             }
             ret.push(`    } else if (data${dataKey} && typeof data${dataKey} === 'object') {`);
             if (prop.ref) {
-                ret.push(`      entity${entityKey} = Reference.create(factory.${method}('${prop.type}', data${dataKey}, { initialized: true, merge: true, newEntity, convertCustomTypes, schema }));`);
+                ret.push(`      entity${entityKey} = Reference.create(factory.${method}(${targetKey}, data${dataKey}, { initialized: true, merge: true, newEntity, convertCustomTypes, normalizeAccessors, schema }));`);
             }
             else {
-                ret.push(`      entity${entityKey} = factory.${method}('${prop.type}', data${dataKey}, { initialized: true, merge: true, newEntity, convertCustomTypes, schema });`);
+                ret.push(`      entity${entityKey} = factory.${method}(${targetKey}, data${dataKey}, { initialized: true, merge: true, newEntity, convertCustomTypes, normalizeAccessors, schema });`);
             }
             ret.push(`    }`);
             ret.push(`  }`);
             if (prop.kind === ReferenceKind.ONE_TO_ONE) {
-                const meta2 = this.metadata.get(prop.type);
+                const meta2 = this.metadata.get(prop.targetMeta.class);
                 const prop2 = meta2.properties[prop.inversedBy || prop.mappedBy];
                 if (prop2 && !prop2.mapToPk) {
                     ret.push(`  if (data${dataKey} && entity${entityKey} && !entity${entityKey}.${this.safeKey(prop2.name)}) {`);
@@ -159,7 +173,7 @@ export class ObjectHydrator extends Hydrator {
         };
         const hydrateToMany = (prop, dataKey, entityKey) => {
             const ret = [];
-            ret.push(...this.createCollectionItemMapper(prop));
+            ret.push(...this.createCollectionItemMapper(prop, context));
             ret.push(`  if (data${dataKey} && !Array.isArray(data${dataKey}) && typeof data${dataKey} === 'object') {`);
             ret.push(`    data${dataKey} = [data${dataKey}];`);
             ret.push(`  }`);
@@ -242,10 +256,11 @@ export class ObjectHydrator extends Hydrator {
                 prop.targetMeta.polymorphs.forEach(childMeta => {
                     const childProp = prop.embeddedProps[prop.targetMeta.discriminatorColumn];
                     const childDataKey = prop.object ? dataKey + this.wrap(childProp.embedded[1]) : this.wrap(childProp.name);
+                    context.set(childMeta.className, childMeta.class);
                     // weak comparison as we can have numbers that might have been converted to strings due to being object keys
                     ret.push(`    if (data${childDataKey} == '${childMeta.discriminatorValue}') {`);
                     ret.push(`      if (entity${entityKey} == null) {`);
-                    ret.push(`        entity${entityKey} = factory.createEmbeddable('${childMeta.className}', embeddedData, { newEntity, convertCustomTypes });`);
+                    ret.push(`        entity${entityKey} = factory.createEmbeddable(${childMeta.className}, embeddedData, { newEntity, convertCustomTypes, normalizeAccessors });`);
                     ret.push(`      }`);
                     meta.props
                         .filter(p => p.embedded?.[0] === prop.name)
@@ -265,8 +280,10 @@ export class ObjectHydrator extends Hydrator {
                 });
             }
             else {
+                const targetKey = this.safeKey(`${prop.targetMeta.tableName}_${this.tmpIndex++}`);
+                context.set(targetKey, prop.targetMeta.class);
                 ret.push(`    if (entity${entityKey} == null) {`);
-                ret.push(`      entity${entityKey} = factory.createEmbeddable('${prop.targetMeta.className}', embeddedData, { newEntity, convertCustomTypes });`);
+                ret.push(`      entity${entityKey} = factory.createEmbeddable(${targetKey}, embeddedData, { newEntity, convertCustomTypes, normalizeAccessors });`);
                 ret.push(`    }`);
                 meta.props
                     .filter(p => p.embedded?.[0] === prop.name)
@@ -304,7 +321,7 @@ export class ObjectHydrator extends Hydrator {
         };
         const hydrateProperty = (prop, object = prop.object, path = [prop.name], dataKey) => {
             const entityKey = path.map(k => this.wrap(k)).join('');
-            dataKey = dataKey ?? (object ? entityKey : this.wrap(prop.name));
+            dataKey = dataKey ?? (object ? entityKey : this.wrap(normalizeAccessors ? (prop.accessor ?? prop.name) : prop.name));
             const ret = [];
             if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && !prop.mapToPk) {
                 ret.push(...hydrateToOne(prop, dataKey, entityKey));
@@ -324,7 +341,7 @@ export class ObjectHydrator extends Hydrator {
                 }
             }
             else { // ReferenceKind.SCALAR
-                ret.push(...hydrateScalar(prop, object, path, dataKey));
+                ret.push(...hydrateScalar(prop, path, dataKey));
             }
             if (this.config.get('forceUndefined')) {
                 ret.push(`  if (data${dataKey} === null) entity${entityKey} = undefined;`);
@@ -334,15 +351,15 @@ export class ObjectHydrator extends Hydrator {
         for (const prop of props) {
             lines.push(...hydrateProperty(prop));
         }
-        const code = `// compiled hydrator for entity ${meta.className} (${type})\n`
-            + `return function(entity, data, factory, newEntity, convertCustomTypes, schema) {\n`
+        const code = `// compiled hydrator for entity ${meta.className} (${type + normalizeAccessors ? ' normalized' : ''})\n`
+            + `return function(entity, data, factory, newEntity, convertCustomTypes, schema, parentSchema, normalizeAccessors) {\n`
             + `${lines.join('\n')}\n}`;
         const hydrator = Utils.createFunction(context, code);
-        this.hydrators[type].set(meta.className, hydrator);
+        this.hydrators[key].set(meta.class, hydrator);
         return hydrator;
     }
-    createCollectionItemMapper(prop) {
-        const meta = this.metadata.get(prop.type);
+    createCollectionItemMapper(prop, context) {
+        const meta = this.metadata.get(prop.targetMeta.class);
         const lines = [];
         lines.push(`  const createCollectionItem_${this.safeKey(prop.name)} = (value, entity) => {`);
         const prop2 = prop.targetMeta.properties[prop.mappedBy];
@@ -351,9 +368,11 @@ export class ObjectHydrator extends Hydrator {
             lines.push(`      value = { ...value, ['${prop2.name}']: Reference.wrapReference(entity, { ref: ${prop2.ref} }) };`);
             lines.push(`    }`);
         }
-        lines.push(`    if (isPrimaryKey(value, ${meta.compositePK})) return factory.createReference('${prop.type}', value, { convertCustomTypes, schema, merge: true });`);
+        const targetKey = this.safeKey(`${prop.targetMeta.tableName}_${this.tmpIndex++}`);
+        context.set(targetKey, prop.targetMeta.class);
+        lines.push(`    if (isPrimaryKey(value, ${meta.compositePK})) return factory.createReference(${targetKey}, value, { convertCustomTypes, schema, normalizeAccessors, merge: true });`);
         lines.push(`    if (value && value.__entity) return value;`);
-        lines.push(`    return factory.create('${prop.type}', value, { newEntity, convertCustomTypes, schema, merge: true });`);
+        lines.push(`    return factory.create(${targetKey}, value, { newEntity, convertCustomTypes, schema, normalizeAccessors, merge: true });`);
         lines.push(`  }`);
         return lines;
     }

package/index.d.ts

@@ -2,7 +2,8 @@
  * @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, 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 { EntityMetadata, PrimaryKeyProp, EntityRepositoryType, OptionalProps, EagerProps, HiddenProps, Config } from './typings.js';
+export type { Constructor, ConnectionType, Dictionary, Primary, IPrimaryKey, ObjectQuery, FilterQuery, IWrappedEntity, EntityName, EntityData, Highlighter, MaybePromise, AnyEntity, EntityClass, EntityProperty, QBFilterQuery, PopulateOptions, Populate, Loaded, New, LoadedReference, LoadedCollection, IMigrator, IMigrationGenerator, MigratorEvent, GetRepository, MigrationObject, DeepPartial, PrimaryProperty, Cast, IsUnknown, EntityDictionary, EntityDTO, MigrationDiff, GenerateOptions, FilterObject, IEntityGenerator, ISeedManager, RequiredEntityData, CheckCallback, IndexCallback, FormulaCallback, FormulaTable, SimpleColumnMeta, Rel, Ref, ScalarRef, EntityRef, ISchemaGenerator, UmzugMigration, MigrateOptions, MigrationResult, MigrationRow, EntityKey, EntityValue, EntityDataValue, FilterKey, EntityType, FromEntityType, Selected, IsSubset, NoInfer, EntityProps, ExpandProperty, ExpandScalar, FilterItemValue, ExpandQuery, Scalar, ExpandHint, FilterValue, MergeLoaded, MergeSelected, TypeConfig, AnyString, ClearDatabaseOptions, CreateSchemaOptions, EnsureDatabaseOptions, UpdateSchemaOptions, DropSchemaOptions, RefreshDatabaseOptions, AutoPath, UnboxArray, MetadataProcessor, ImportsResolver, RequiredNullable, DefineConfig, Opt, Hidden, EntitySchemaWithMeta, InferEntity, CheckConstraint, GeneratedColumnCallback, FilterDef, EntityCtor, } from './typings.js';
 export * from './enums.js';
 export * from './errors.js';
 export * from './exceptions.js';
@@ -22,4 +23,3 @@ export * from './types/index.js';
 export * from './naming-strategy/index.js';
 export * from './metadata/index.js';
 export * from './cache/index.js';
-export * from './decorators/index.js';

package/index.js

@@ -2,7 +2,7 @@
  * @packageDocumentation
  * @module core
  */
-export { PrimaryKeyProp, EntityMetadata, EntityRepositoryType, OptionalProps, EagerProps, HiddenProps, Config, } from './typings.js';
+export { EntityMetadata, PrimaryKeyProp, EntityRepositoryType, OptionalProps, EagerProps, HiddenProps, Config } from './typings.js';
 export * from './enums.js';
 export * from './errors.js';
 export * from './exceptions.js';
@@ -22,4 +22,3 @@ export * from './types/index.js';
 export * from './naming-strategy/index.js';
 export * from './metadata/index.js';
 export * from './cache/index.js';
-export * from './decorators/index.js';

package/logging/DefaultLogger.d.ts

@@ -29,5 +29,5 @@ export declare class DefaultLogger implements Logger {
     logQuery(context: {
         query: string;
     } & LogContext): void;
-    static create(options: LoggerOptions): DefaultLogger;
+    static create(this: void, options: LoggerOptions): DefaultLogger;
 }

package/logging/DefaultLogger.js

@@ -60,6 +60,7 @@ export class DefaultLogger {
         if (namespace === 'deprecated') {
             const { ignoreDeprecations = false } = this.options;
             return Array.isArray(ignoreDeprecations)
+                /* v8 ignore next */
                 ? !ignoreDeprecations.includes(context?.label ?? '')
                 : !ignoreDeprecations;
         }

package/logging/SimpleLogger.d.ts

@@ -14,5 +14,5 @@ export declare class SimpleLogger extends DefaultLogger {
     logQuery(context: {
         query: string;
     } & LogContext): void;
-    static create(options: LoggerOptions): SimpleLogger;
+    static create(this: void, options: LoggerOptions): SimpleLogger;
 }

package/logging/colors.d.ts

@@ -5,5 +5,5 @@ export declare const colors: {
     yellow: (text: string) => string;
     grey: (text: string) => string;
     cyan: (text: string) => string;
-    enabled: () => boolean | "" | undefined;
+    enabled: () => boolean;
 };

package/logging/colors.js

@@ -1,9 +1,10 @@
-const bool = (v) => v && ['true', 't', '1'].includes(v.toLowerCase());
-const boolIfDefined = (v) => v != null ? bool(v) : true;
-const enabled = () => !bool(process.env.NO_COLOR)
-    && !bool(process.env.MIKRO_ORM_NO_COLOR)
-    && boolIfDefined(process.env.FORCE_COLOR)
-    && boolIfDefined(process.env.MIKRO_ORM_COLORS);
+import { getEnv } from '../utils/env-vars.js';
+const bool = (k) => ['true', 't', '1'].includes(getEnv(k)?.toLowerCase() ?? '');
+const boolIfDefined = (k) => getEnv(k) != null ? bool(k) : true;
+const enabled = () => !bool('NO_COLOR')
+    && !bool('MIKRO_ORM_NO_COLOR')
+    && boolIfDefined('FORCE_COLOR')
+    && boolIfDefined('MIKRO_ORM_COLORS');
 const wrap = (fn) => (text) => enabled() ? fn(text) : text;
 /** @internal */
 export const colors = {

package/logging/index.d.ts

@@ -2,3 +2,4 @@ export * from './colors.js';
 export * from './Logger.js';
 export * from './DefaultLogger.js';
 export * from './SimpleLogger.js';
+export * from './inspect.js';

package/logging/index.js

@@ -2,3 +2,4 @@ export * from './colors.js';
 export * from './Logger.js';
 export * from './DefaultLogger.js';
 export * from './SimpleLogger.js';
+export * from './inspect.js';

package/logging/inspect.d.ts

@@ -0,0 +1,2 @@
+/** @internal */
+export declare function inspect(value: unknown, options?: Record<string, any>): string;

package/logging/inspect.js

@@ -0,0 +1,11 @@
+let nodeInspect;
+/** @internal */
+export function inspect(value, options) {
+    nodeInspect ??= globalThis.process?.getBuiltinModule?.('node:util').inspect;
+    /* v8 ignore else */
+    if (nodeInspect) {
+        return nodeInspect(value, options);
+    }
+    /* v8 ignore next */
+    return JSON.stringify(value, null, 2);
+}

package/metadata/EntitySchema.d.ts

@@ -1,25 +1,17 @@
-import { EntityMetadata, type AnyEntity, type EntityKey, type Constructor, type DeepPartial, type EntityName, type EntityProperty, type CleanKeys, type ExpandProperty, type IsNever, type EntityClass } from '../typings.js';
-import type { EmbeddedOptions } from '../decorators/Embedded.js';
-import type { EnumOptions } from '../decorators/Enum.js';
-import type { IndexOptions, UniqueOptions } from '../decorators/Indexed.js';
-import type { ManyToManyOptions } from '../decorators/ManyToMany.js';
-import type { ManyToOneOptions } from '../decorators/ManyToOne.js';
-import type { OneToManyOptions } from '../decorators/OneToMany.js';
-import type { OneToOneOptions } from '../decorators/OneToOne.js';
-import type { PrimaryKeyOptions, SerializedPrimaryKeyOptions } from '../decorators/PrimaryKey.js';
-import type { PropertyOptions } from '../decorators/Property.js';
+import { EntityMetadata, type AnyEntity, type EntityKey, type Constructor, type DeepPartial, type EntityName, type EntityProperty, type CleanKeys, type ExpandProperty, type IsNever, type EntityCtor } from '../typings.js';
 import { ReferenceKind } from '../enums.js';
 import { Type } from '../types/Type.js';
+import type { PropertyOptions, ManyToOneOptions, OneToOneOptions, OneToManyOptions, ManyToManyOptions, EmbeddedOptions, EnumOptions, PrimaryKeyOptions, SerializedPrimaryKeyOptions, IndexOptions, UniqueOptions } from './types.js';
 type TypeType = string | NumberConstructor | StringConstructor | BooleanConstructor | DateConstructor | ArrayConstructor | Constructor<Type<any>> | Type<any>;
 type TypeDef<Target> = {
     type: TypeType;
 } | {
-    entity: string | (() => string | EntityName<Target>);
+    entity: () => EntityName<Target>;
 };
 type EmbeddedTypeDef<Target> = {
     type: TypeType;
 } | {
-    entity: string | (() => string | EntityName<Target> | EntityName<Target>[]);
+    entity: () => EntityName<Target> | EntityName[];
 };
 export type EntitySchemaProperty<Target, Owner> = ({
     kind: ReferenceKind.MANY_TO_ONE | 'm:1';
@@ -35,28 +27,30 @@ export type EntitySchemaProperty<Target, Owner> = ({
     enum: true;
 } & EnumOptions<Owner>) | (TypeDef<Target> & PropertyOptions<Owner>);
 type OmitBaseProps<Entity, Base> = IsNever<Base> extends true ? Entity : Omit<Entity, keyof Base>;
-export type EntitySchemaMetadata<Entity, Base = never> = Omit<Partial<EntityMetadata<Entity>>, 'name' | 'properties' | 'extends'> & ({
+export type EntitySchemaMetadata<Entity, Base = never, Class extends EntityCtor = EntityCtor<Entity>> = Omit<Partial<EntityMetadata<Entity>>, 'name' | 'properties' | 'extends'> & ({
     name: string;
 } | {
-    class: EntityClass<Entity>;
+    class: Class;
     name?: string;
 }) & {
-    extends?: string | EntitySchema<Base>;
+    extends?: EntityName<Base>;
 } & {
     properties?: {
         [Key in keyof OmitBaseProps<Entity, Base> as CleanKeys<OmitBaseProps<Entity, Base>, Key>]-?: EntitySchemaProperty<ExpandProperty<NonNullable<Entity[Key]>>, Entity>;
     };
 };
-export declare class EntitySchema<Entity = any, Base = never> {
+export declare class EntitySchema<Entity = any, Base = never, Class extends EntityCtor = EntityCtor<Entity>> {
     /**
      * When schema links the entity class via `class` option, this registry allows the lookup from opposite side,
      * so we can use the class in `entities` option just like the EntitySchema instance.
      */
-    static REGISTRY: Map<Partial<any>, EntitySchema<any, never>>;
+    static REGISTRY: Map<Partial<any>, EntitySchema<any, never, EntityCtor<any>>>;
+    /** @internal Type-level marker for fast entity type inference */
+    readonly '~entity': Entity;
     private readonly _meta;
     private internal;
     private initialized;
-    constructor(meta: EntitySchemaMetadata<Entity, Base>);
+    constructor(meta: EntitySchemaMetadata<Entity, Base, Class>);
     static fromMetadata<T = AnyEntity, U = never>(meta: EntityMetadata<T> | DeepPartial<EntityMetadata<T>>): EntitySchema<T, U>;
     addProperty(name: EntityKey<Entity>, type?: TypeType, options?: PropertyOptions<Entity> | EntityProperty<Entity>): void;
     addEnum(name: EntityKey<Entity>, type?: TypeType, options?: EnumOptions<Entity>): void;
@@ -71,10 +65,14 @@ export declare class EntitySchema<Entity = any, Base = never> {
     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;
-    get meta(): EntityMetadata<Entity>;
-    get name(): EntityName<Entity>;
+    setExtends(base: EntityName): void;
+    setClass(cls: Class): void;
+    get meta(): EntityMetadata<Entity, Class>;
+    get name(): string | EntityName<Entity>;
+    get tableName(): string;
+    get class(): Class;
+    get properties(): Record<string, any>;
+    new(...params: ConstructorParameters<Class>): Entity;
     /**
      * @internal
      */

package/metadata/EntitySchema.js

@@ -10,7 +10,7 @@ export class EntitySchema {
      * so we can use the class in `entities` option just like the EntitySchema instance.
      */
     static REGISTRY = new Map();
-    _meta = new EntityMetadata();
+    _meta;
     internal = false;
     initialized = false;
     constructor(meta) {
@@ -18,15 +18,14 @@ export class EntitySchema {
         if (meta.name) {
             meta.abstract ??= false;
         }
+        this._meta = new EntityMetadata({
+            className: meta.name,
+            ...meta,
+        });
+        this._meta.root ??= this._meta;
         if (meta.class && !meta.internal) {
             EntitySchema.REGISTRY.set(meta.class, this);
         }
-        if (meta.tableName || meta.collection) {
-            Utils.renameKey(meta, 'tableName', 'collection');
-            meta.tableName = meta.collection;
-        }
-        Object.assign(this._meta, { className: meta.name }, meta);
-        this._meta.root ??= this._meta;
     }
     static fromMetadata(meta) {
         const schema = new EntitySchema({ ...meta, internal: true });
@@ -35,12 +34,12 @@ export class EntitySchema {
     }
     addProperty(name, type, options = {}) {
         this.renameCompositeOptions(name, options);
-        const prop = { name, kind: ReferenceKind.SCALAR, ...options, type: this.normalizeType(options, type) };
+        const prop = { name, kind: ReferenceKind.SCALAR, ...options, ...this.normalizeType(options, type) };
         if (type && Type.isMappedType(type.prototype)) {
             prop.type = type;
         }
-        if (Utils.isString(prop.formula)) {
-            const formula = prop.formula; // tmp var is needed here
+        if (typeof prop.formula === 'string') {
+            const formula = prop.formula;
             prop.formula = () => formula;
         }
         if (prop.formula) {
@@ -75,7 +74,7 @@ export class EntitySchema {
     }
     addSerializedPrimaryKey(name, type, options = {}) {
         this._meta.serializedPrimaryKey = name;
-        this.addProperty(name, type, options);
+        this.addProperty(name, type, { serializedPrimaryKey: true, ...options });
     }
     addEmbedded(name, options) {
         this.renameCompositeOptions(name, options);
@@ -85,8 +84,8 @@ export class EntitySchema {
         }
         this._meta.properties[name] = {
             name,
-            type: this.normalizeType(options),
             kind: ReferenceKind.EMBEDDED,
+            ...this.normalizeType(options),
             ...options,
         };
     }
@@ -99,6 +98,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) {
@@ -108,6 +109,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);
@@ -120,8 +123,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;
@@ -143,21 +150,29 @@ export class EntitySchema {
     setExtends(base) {
         this._meta.extends = base;
     }
-    setClass(proto) {
-        const sameClass = this._meta.className === proto.name;
-        this._meta.class = proto;
-        this._meta.prototype = proto.prototype;
-        this._meta.className = proto.name;
+    setClass(cls) {
+        const oldClass = this._meta.class;
+        const sameClass = this._meta.class === cls;
+        this._meta.class = cls;
+        this._meta.prototype = cls.prototype;
+        this._meta.className = this._meta.name ?? cls.name;
         if (!sameClass || !this._meta.constructorParams) {
-            const tokens = Utils.tokenize(proto);
-            this._meta.constructorParams = Utils.getParamNames(tokens, 'constructor');
-            this._meta.toJsonParams = Utils.getParamNames(tokens, 'toJSON').filter(p => p !== '...args');
+            this._meta.constructorParams = Utils.getConstructorParams(cls);
         }
         if (!this.internal) {
-            EntitySchema.REGISTRY.set(proto, this);
+            // Remove old class from registry if it's being replaced with a different class
+            if (oldClass && oldClass !== cls && EntitySchema.REGISTRY.get(oldClass) === this) {
+                EntitySchema.REGISTRY.delete(oldClass);
+            }
+            EntitySchema.REGISTRY.set(cls, this);
         }
-        if (Object.getPrototypeOf(proto) !== BaseEntity) {
-            this._meta.extends = this._meta.extends || Object.getPrototypeOf(proto).name || undefined;
+        const base = Object.getPrototypeOf(cls);
+        // Only set extends if the parent is NOT the auto-generated class for this same entity.
+        // When the user extends the auto-generated class (from defineEntity without a class option)
+        // and registers their custom class via setClass, we don't want to discover the
+        // auto-generated class as a separate parent entity.
+        if (base !== BaseEntity && base.name !== this._meta.className) {
+            this._meta.extends ??= base.name ? base : undefined;
         }
     }
     get meta() {
@@ -166,6 +181,18 @@ export class EntitySchema {
     get name() {
         return this._meta.className;
     }
+    get tableName() {
+        return this._meta.tableName;
+    }
+    get class() {
+        return this._meta.class;
+    }
+    get properties() {
+        return this._meta.properties;
+    }
+    new(...params) {
+        return new this._meta.class(...params);
+    }
     /**
      * @internal
      */
@@ -173,11 +200,6 @@ export class EntitySchema {
         if (this.initialized) {
             return this;
         }
-        if (!this._meta.class) {
-            const name = this.name;
-            this._meta.class = ({ [name]: class {
-                } })[name];
-        }
         this.setClass(this._meta.class);
         if (this._meta.abstract && !this._meta.discriminatorColumn) {
             delete this._meta.name;
@@ -185,7 +207,7 @@ export class EntitySchema {
         const tableName = this._meta.collection ?? this._meta.tableName;
         if (tableName?.includes('.') && !this._meta.schema) {
             this._meta.schema = tableName.substring(0, tableName.indexOf('.'));
-            this._meta.collection = tableName.substring(tableName.indexOf('.') + 1);
+            this._meta.tableName = tableName.substring(tableName.indexOf('.') + 1);
         }
         this.initProperties();
         this.initPrimaryKeys();
@@ -251,12 +273,15 @@ export class EntitySchema {
     }
     normalizeType(options, type) {
         if ('entity' in options) {
-            if (Utils.isString(options.entity)) {
-                type = options.type = options.entity;
+            /* v8 ignore next */
+            if (typeof options.entity === 'string') {
+                throw new Error(`Relation target needs to be an entity class or EntitySchema instance, string '${options.entity}' given instead for ${this._meta.className}.${options.name}.`);
             }
             else if (options.entity) {
                 const tmp = options.entity();
                 type = options.type = Array.isArray(tmp) ? tmp.map(t => Utils.className(t)).sort().join(' | ') : Utils.className(tmp);
+                const target = tmp instanceof EntitySchema ? tmp.meta.class : tmp;
+                return { type, target };
             }
         }
         if (type instanceof Function) {
@@ -265,7 +290,7 @@ export class EntitySchema {
         if (['String', 'Number', 'Boolean', 'Array'].includes(type)) {
             type = type.toLowerCase();
         }
-        return type;
+        return { type };
     }
     createProperty(kind, options) {
         return {