@mikro-orm/core 7.0.0-dev.8 → 7.0.0-dev.80

package/entity/validators.js

@@ -0,0 +1,65 @@
+import { Utils } from '../utils/Utils.js';
+import { ValidationError } from '../errors.js';
+import { isRaw } from '../utils/RawQueryFragment.js';
+import { SCALAR_TYPES } from '../enums.js';
+/** @internal */
+export function validateProperty(prop, givenValue, entity) {
+    if (givenValue == null || isRaw(givenValue)) {
+        return;
+    }
+    const expectedType = prop.runtimeType;
+    const propName = prop.embedded ? prop.name.replace(/~/g, '.') : prop.name;
+    const givenType = Utils.getObjectType(givenValue);
+    if (prop.enum && prop.items) {
+        /* v8 ignore next */
+        if (!prop.items.some(it => it === givenValue)) {
+            throw ValidationError.fromWrongPropertyType(entity, propName, expectedType, givenType, givenValue);
+        }
+    }
+    else {
+        if (givenType !== expectedType && SCALAR_TYPES.has(expectedType)) {
+            throw ValidationError.fromWrongPropertyType(entity, propName, expectedType, givenType, givenValue);
+        }
+    }
+}
+function getValue(o, prop) {
+    if (prop.embedded && prop.embedded[0] in o) {
+        return o[prop.embedded[0]]?.[prop.embedded[1]];
+    }
+    /* v8 ignore next */
+    if (prop.ref) {
+        return o[prop.name]?.unwrap();
+    }
+    return o[prop.name];
+}
+/** @internal */
+export function validateEntity(entity, meta) {
+    for (const prop of meta.validateProps) {
+        validateProperty(prop, getValue(entity, prop), entity);
+    }
+}
+/** @internal */
+export function validateParams(params, type = 'search condition', field) {
+    if (Utils.isPrimaryKey(params) || Utils.isEntity(params)) {
+        return;
+    }
+    if (Array.isArray(params)) {
+        return params.forEach(item => validateParams(item, type, field));
+    }
+    if (Utils.isPlainObject(params)) {
+        Object.keys(params).forEach(k => validateParams(params[k], type, k));
+    }
+}
+/** @internal */
+export function validatePrimaryKey(entity, meta) {
+    const pkExists = meta.primaryKeys.every(pk => entity[pk] != null) || (meta.serializedPrimaryKey && entity[meta.serializedPrimaryKey] != null);
+    if (!entity || !pkExists) {
+        throw ValidationError.fromMergeWithoutPK(meta);
+    }
+}
+/** @internal */
+export function validateEmptyWhere(where) {
+    if (Utils.isEmpty(where)) {
+        throw new Error(`You cannot call 'EntityManager.findOne()' with empty 'where' parameter`);
+    }
+}

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,9 +85,11 @@ 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 const SCALAR_TYPES: Set<string>;
 export declare enum ReferenceKind {
     SCALAR = "scalar",
     ONE_TO_ONE = "1:1",
@@ -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,12 +159,22 @@ 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;
-    isolationLevel?: IsolationLevel;
+    propagation?: TransactionPropagation | `${TransactionPropagation}`;
+    isolationLevel?: IsolationLevel | `${IsolationLevel}`;
     readOnly?: boolean;
     clear?: boolean;
-    flushMode?: FlushMode;
+    flushMode?: FlushMode | `${FlushMode}`;
     ignoreNestedTransactions?: boolean;
     loggerContext?: LogContext;
 }
@@ -171,3 +184,5 @@ export declare enum DeferMode {
     INITIALLY_IMMEDIATE = "immediate",
     INITIALLY_DEFERRED = "deferred"
 }
+/** With `absolute` the prefix is set at the root of the entity (regardless of the nesting level) */
+export type EmbeddedPrefixMode = 'absolute' | 'relative';

package/enums.js

@@ -95,9 +95,11 @@ 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 const SCALAR_TYPES = new Set(['string', 'number', 'boolean', 'bigint', 'Uint8Array', 'Date', 'Buffer', 'RegExp']);
 export var ReferenceKind;
 (function (ReferenceKind) {
     ReferenceKind["SCALAR"] = "scalar";
@@ -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

@@ -8,7 +8,6 @@ export declare class ValidationError<T extends AnyEntity = AnyEntity> extends Er
     getEntity(): AnyEntity | undefined;
     static fromWrongPropertyType(entity: AnyEntity, property: string, expectedType: string, givenType: string, givenValue: string): ValidationError;
     static fromWrongRepositoryType(entityName: string, repoType: string, method: string): ValidationError;
-    static fromCollectionNotInitialized(entity: AnyEntity, prop: EntityProperty): ValidationError;
     static fromMergeWithoutPK(meta: EntityMetadata): ValidationError;
     static transactionRequired(): ValidationError;
     static entityNotManaged(entity: AnyEntity): ValidationError;
@@ -24,6 +23,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> {
@@ -43,7 +43,6 @@ export declare class MetadataError<T extends AnyEntity = AnyEntity> extends Vali
     static fromWrongOwnership(meta: EntityMetadata, prop: EntityProperty, key: 'inversedBy' | 'mappedBy'): MetadataError;
     static fromWrongReferenceKind(meta: EntityMetadata, owner: EntityProperty, prop: EntityProperty): MetadataError;
     static fromInversideSidePrimary(meta: EntityMetadata, owner: EntityProperty, prop: EntityProperty): MetadataError;
-    static entityNotFound(name: string, path: string): MetadataError;
     static unknownIndexProperty(meta: EntityMetadata, prop: string, type: string): MetadataError;
     static multipleVersionFields(meta: EntityMetadata, fields: string[]): MetadataError;
     static invalidVersionFieldType(meta: EntityMetadata): MetadataError;
@@ -66,3 +65,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

@@ -23,11 +23,6 @@ export class ValidationError extends Error {
         const msg = `Trying to use EntityRepository.${method}() with '${entityName}' entity while the repository is of type '${repoType}'`;
         return new ValidationError(msg);
     }
-    static fromCollectionNotInitialized(entity, prop) {
-        const entityName = entity.constructor.name;
-        const msg = `${entityName}.${prop.name} is not initialized, define it as '${prop.name} = new Collection<${prop.type}>(this);'`;
-        return new ValidationError(msg);
-    }
     static fromMergeWithoutPK(meta) {
         return new ValidationError(`You cannot merge entity '${meta.className}' without identifier!`);
     }
@@ -94,6 +89,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}'`);
     }
@@ -151,10 +149,6 @@ export class MetadataError extends ValidationError {
     static fromInversideSidePrimary(meta, owner, prop) {
         return new MetadataError(`${meta.className}.${prop.name} cannot be primary key as it is defined as inverse side. Maybe you should swap the use of 'inversedBy' and 'mappedBy'.`);
     }
-    /* v8 ignore next 3 */
-    static entityNotFound(name, path) {
-        return new MetadataError(`Entity '${name}' not found in ${path}`);
-    }
     static unknownIndexProperty(meta, prop, type) {
         return new MetadataError(`Entity ${meta.className} has wrong ${type} definition: '${prop}' does not exist. You need to use property name, not column name.`);
     }
@@ -220,3 +214,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/Hydrator.js

@@ -1,4 +1,4 @@
-/* v8 ignore start */
+/* v8 ignore next */
 export class Hydrator {
     metadata;
     platform;
@@ -45,4 +45,3 @@ export class Hydrator {
         entity[prop.name] = data[prop.name];
     }
 }
-/* v8 ignore stop */

package/hydration/ObjectHydrator.d.ts

@@ -1,22 +1,22 @@
 import type { EntityData, EntityMetadata } from '../typings.js';
 import { Hydrator } from './Hydrator.js';
 import type { EntityFactory } from '../entity/EntityFactory.js';
-type EntityHydrator<T extends object> = (entity: T, data: EntityData<T>, factory: EntityFactory, newEntity: boolean, convertCustomTypes: boolean, schema?: string, parentSchema?: string) => void;
+type EntityHydrator<T extends object> = (entity: T, data: EntityData<T>, factory: EntityFactory, newEntity: boolean, convertCustomTypes: boolean, schema?: string, parentSchema?: string, normalizeAccessors?: boolean) => void;
 export declare class ObjectHydrator extends Hydrator {
     private readonly hydrators;
     private tmpIndex;
     /**
      * @inheritDoc
      */
-    hydrate<T extends object>(entity: T, meta: EntityMetadata<T>, data: EntityData<T>, factory: EntityFactory, type: 'full' | 'reference', newEntity?: boolean, convertCustomTypes?: boolean, schema?: string, parentSchema?: string): void;
+    hydrate<T extends object>(entity: T, meta: EntityMetadata<T>, data: EntityData<T>, factory: EntityFactory, type: 'full' | 'reference', newEntity?: boolean, convertCustomTypes?: boolean, schema?: string, parentSchema?: string, normalizeAccessors?: boolean): void;
     /**
      * @inheritDoc
      */
-    hydrateReference<T extends object>(entity: T, meta: EntityMetadata<T>, data: EntityData<T>, factory: EntityFactory, convertCustomTypes?: boolean, schema?: string, parentSchema?: string): void;
+    hydrateReference<T extends object>(entity: T, meta: EntityMetadata<T>, data: EntityData<T>, factory: EntityFactory, convertCustomTypes?: boolean, schema?: string, parentSchema?: string, normalizeAccessors?: boolean): void;
     /**
      * @internal Highly performance-sensitive method.
      */
-    getEntityHydrator<T extends object>(meta: EntityMetadata<T>, type: 'full' | 'reference'): EntityHydrator<T>;
+    getEntityHydrator<T extends object>(meta: EntityMetadata<T>, type: 'full' | 'reference', normalizeAccessors?: boolean): EntityHydrator<T>;
     private createCollectionItemMapper;
     private wrap;
     private safeKey;

package/hydration/ObjectHydrator.js

@@ -6,37 +6,40 @@ import { ReferenceKind } from '../enums.js';
 import { RawQueryFragment } 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.className);
         if (exists) {
             return exists;
         }
@@ -48,7 +51,7 @@ export class ObjectHydrator extends Hydrator {
         context.set('Reference', Reference);
         const registerCustomType = (prop, convertorKey, method, context) => {
             context.set(`${method}_${convertorKey}`, (val) => {
-                /* v8 ignore next 3 */
+                /* v8 ignore next */
                 if (RawQueryFragment.isKnownFragment(val)) {
                     return val;
                 }
@@ -63,7 +66,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 +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);
@@ -126,17 +136,17 @@ export class ObjectHydrator extends Hydrator {
             ret.push(`  } else if (typeof data${dataKey} !== 'undefined') {`);
             ret.push(`    if (isPrimaryKey(data${dataKey}, true)) {`);
             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('${prop.type}', data${dataKey}, { merge: true, convertCustomTypes, normalizeAccessors, schema }));`);
             }
             else {
-                ret.push(`      entity${entityKey} = factory.createReference('${prop.type}', data${dataKey}, { merge: true, convertCustomTypes, schema });`);
+                ret.push(`      entity${entityKey} = factory.createReference('${prop.type}', data${dataKey}, { merge: true, convertCustomTypes, normalizeAccessors, schema });`);
             }
             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}('${prop.type}', 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}('${prop.type}', data${dataKey}, { initialized: true, merge: true, newEntity, convertCustomTypes, normalizeAccessors, schema });`);
             }
             ret.push(`    }`);
             ret.push(`  }`);
@@ -245,7 +255,7 @@ export class ObjectHydrator extends Hydrator {
                     // 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)
@@ -256,6 +266,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));
@@ -265,7 +276,7 @@ export class ObjectHydrator extends Hydrator {
             }
             else {
                 ret.push(`    if (entity${entityKey} == null) {`);
-                ret.push(`      entity${entityKey} = factory.createEmbeddable('${prop.targetMeta.className}', embeddedData, { newEntity, convertCustomTypes });`);
+                ret.push(`      entity${entityKey} = factory.createEmbeddable('${prop.targetMeta.className}', embeddedData, { newEntity, convertCustomTypes, normalizeAccessors });`);
                 ret.push(`    }`);
                 meta.props
                     .filter(p => p.embedded?.[0] === prop.name)
@@ -303,7 +314,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));
@@ -333,11 +344,11 @@ 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.className, hydrator);
         return hydrator;
     }
     createCollectionItemMapper(prop) {
@@ -350,9 +361,9 @@ 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 });`);
+        lines.push(`    if (isPrimaryKey(value, ${meta.compositePK})) return factory.createReference('${prop.type}', 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('${prop.type}', 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, 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, } 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/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/metadata/EntitySchema.d.ts

@@ -1,15 +1,7 @@
 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 { 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;
@@ -31,7 +23,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>;
@@ -41,7 +33,7 @@ export type EntitySchemaMetadata<Entity, Base = never> = Omit<Partial<EntityMeta
     class: EntityClass<Entity>;
     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>;
@@ -63,7 +55,7 @@ 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;
@@ -71,10 +63,12 @@ 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;
+    setExtends(base: EntityName<any>): void;
     setClass(proto: EntityClass<Entity>): void;
     get meta(): EntityMetadata<Entity>;
     get name(): EntityName<Entity>;
+    get tableName(): string;
+    get properties(): Record<string, any>;
     /**
      * @internal
      */
@@ -83,5 +77,7 @@ export declare class EntitySchema<Entity = any, Base = never> {
     private initPrimaryKeys;
     private normalizeType;
     private createProperty;
+    private rename;
+    private renameCompositeOptions;
 }
 export {};