@mikro-orm/core 7.0.0-rc.2 → 7.0.0

package/entity/defineEntity.d.ts

@@ -1,6 +1,6 @@
 import type { EntityManager } from '../EntityManager.js';
 import type { ColumnType, PropertyOptions, ReferenceOptions, EnumOptions, EmbeddedOptions, ManyToOneOptions, OneToManyOptions, OneToOneOptions, ManyToManyOptions } from '../metadata/types.js';
-import type { AnyString, GeneratedColumnCallback, Constructor, CheckCallback, FilterQuery, EntityName, Dictionary, EntityMetadata, PrimaryKeyProp, EntityRepositoryType, Hidden, Opt, Primary, EntityClass, EntitySchemaWithMeta, InferEntity, MaybeReturnType, Ref, IndexCallback, FormulaCallback, EntityCtor, IsNever } from '../typings.js';
+import type { AnyString, GeneratedColumnCallback, Constructor, CheckCallback, FilterQuery, EntityName, Dictionary, EntityMetadata, PrimaryKeyProp, EntityRepositoryType, Hidden, Opt, Primary, EntityClass, EntitySchemaWithMeta, InferEntity, MaybeReturnType, Ref, IndexCallback, FormulaCallback, EntityCtor, IsNever, IWrappedEntity, DefineConfig, Config } from '../typings.js';
 import type { Raw } from '../utils/RawQueryFragment.js';
 import type { ScalarReference } from './Reference.js';
 import type { SerializeOptions } from '../serialization/EntitySerializer.js';
@@ -96,7 +96,7 @@ export interface PropertyChain<Value, Options> {
     serializer(serializer: (value: Value, options?: SerializeOptions<any>) => any): PropertyChain<Value, Options>;
     serializedName(serializedName: string): PropertyChain<Value, Options>;
     groups(...groups: string[]): PropertyChain<Value, Options>;
-    customOrder(...customOrder: (string[] | number[] | boolean[])): PropertyChain<Value, Options>;
+    customOrder(...customOrder: string[] | number[] | boolean[]): PropertyChain<Value, Options>;
     extra(extra: string): PropertyChain<Value, Options>;
     ignoreSchemaChanges(...ignoreSchemaChanges: ('type' | 'extra' | 'default')[]): PropertyChain<Value, Options>;
     index(index?: boolean | string): PropertyChain<Value, Options>;
@@ -409,7 +409,7 @@ export declare class UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys
     /**
      * Specify a custom order based on the values. (SQL only)
      */
-    customOrder(...customOrder: (string[] | number[] | boolean[])): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
+    customOrder(...customOrder: string[] | number[] | boolean[]): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
     /**
      * Specify comment of column for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}. (SQL only)
      */
@@ -501,68 +501,56 @@ export declare class OneToManyOptionsBuilderOnlyMappedBy<Value extends object> e
     kind: '1:m';
 }, IncludeKeysForOneToManyOptions> {
     /** Point to the owning side property name. */
-    mappedBy(mappedBy: (keyof Value) | ((e: Value) => any)): Pick<UniversalPropertyOptionsBuilder<Value, EmptyOptions & {
+    mappedBy(mappedBy: keyof Value | ((e: Value) => any)): Pick<UniversalPropertyOptionsBuilder<Value, EmptyOptions & {
         kind: '1:m';
     }, IncludeKeysForOneToManyOptions>, IncludeKeysForOneToManyOptions>;
 }
 type EntityTarget = {
     '~entity': any;
 } | EntityClass;
-declare const propertyBuilders: {
-    bigint: <Mode extends "bigint" | "number" | "string" = "bigint">(mode?: Mode) => UniversalPropertyOptionsBuilder<(Mode extends "bigint" ? bigint : Mode extends "number" ? number : string) & {}, EmptyOptions, IncludeKeysForProperty>;
-    array: <T = string>(toJsValue?: (i: string) => T, toDbValue?: (i: T) => string) => UniversalPropertyOptionsBuilder<T[], EmptyOptions, IncludeKeysForProperty>;
-    decimal: <Mode extends "number" | "string" = "string">(mode?: Mode) => UniversalPropertyOptionsBuilder<NonNullable<Mode extends "number" ? number : string>, EmptyOptions, IncludeKeysForProperty>;
+declare const propertyBuilders: PropertyBuilders;
+type PropertyBuildersOverrideKeys = 'bigint' | 'array' | 'decimal' | 'json' | 'datetime' | 'time' | 'enum';
+export type PropertyBuilders = {
+    [K in Exclude<keyof typeof types, PropertyBuildersOverrideKeys>]: () => UniversalPropertyOptionsBuilder<InferPropertyValueType<(typeof types)[K]>, EmptyOptions, IncludeKeysForProperty>;
+} & {
+    bigint: <Mode extends 'bigint' | 'number' | 'string' = 'bigint'>(mode?: Mode) => UniversalPropertyOptionsBuilder<InferPropertyValueType<typeof types.bigint<Mode>>, EmptyOptions, IncludeKeysForProperty>;
+    array: <T = string>(toJsValue?: (i: string) => T, toDbValue?: (i: T) => string) => UniversalPropertyOptionsBuilder<InferPropertyValueType<typeof types.array<T>>, EmptyOptions, IncludeKeysForProperty>;
+    decimal: <Mode extends 'number' | 'string' = 'string'>(mode?: Mode) => UniversalPropertyOptionsBuilder<InferPropertyValueType<typeof types.decimal<Mode>>, EmptyOptions, IncludeKeysForProperty>;
     json: <T>() => UniversalPropertyOptionsBuilder<T, EmptyOptions, IncludeKeysForProperty>;
     formula: <T>(formula: string | FormulaCallback<any>) => UniversalPropertyOptionsBuilder<T, EmptyOptions, IncludeKeysForProperty>;
-    datetime: (length?: number) => UniversalPropertyOptionsBuilder<Date, EmptyOptions, IncludeKeysForProperty>;
-    time: (length?: number) => UniversalPropertyOptionsBuilder<any, EmptyOptions, IncludeKeysForProperty>;
+    datetime: (length?: number) => UniversalPropertyOptionsBuilder<InferPropertyValueType<typeof types.datetime>, EmptyOptions, IncludeKeysForProperty>;
+    time: (length?: number) => UniversalPropertyOptionsBuilder<InferPropertyValueType<typeof types.time>, EmptyOptions, IncludeKeysForProperty>;
     type: <T extends PropertyValueType>(type: T) => UniversalPropertyOptionsBuilder<InferPropertyValueType<T>, EmptyOptions, IncludeKeysForProperty>;
     enum: <const T extends (number | string)[] | (() => Dictionary)>(items?: T) => UniversalPropertyOptionsBuilder<T extends () => Dictionary ? ValueOf<ReturnType<T>> : T extends (infer Value)[] ? Value : T, EmptyOptions, IncludeKeysForEnumOptions>;
     embedded: <Target extends EntityTarget | EntityTarget[]>(target: Target) => PropertyChain<InferEntity<Target extends (infer T)[] ? T : Target>, EmptyOptions & {
-        kind: "embedded";
+        kind: 'embedded';
     }>;
     manyToMany: <Target extends EntityTarget>(target: Target) => PropertyChain<InferEntity<Target>, EmptyOptions & {
-        kind: "m:n";
+        kind: 'm:n';
     }>;
     manyToOne: <Target extends EntityTarget | EntityTarget[]>(target: Target) => PropertyChain<InferEntity<Target extends (infer T)[] ? T : Target>, EmptyOptions & {
-        kind: "m:1";
+        kind: 'm:1';
     }>;
     oneToMany: <Target extends EntityTarget>(target: Target) => PropertyChain<InferEntity<Target>, EmptyOptions & {
-        kind: "1:m";
+        kind: '1:m';
     }>;
     oneToOne: <Target extends EntityTarget | EntityTarget[]>(target: Target) => PropertyChain<InferEntity<Target extends (infer T)[] ? T : Target>, EmptyOptions & {
-        kind: "1:1";
+        kind: '1:1';
     }>;
-    date: () => UniversalPropertyOptionsBuilder<string, EmptyOptions, IncludeKeysForProperty>;
-    blob: () => UniversalPropertyOptionsBuilder<NonNullable<Buffer<ArrayBufferLike> | Uint8Array<ArrayBufferLike> | null>, EmptyOptions, IncludeKeysForProperty>;
-    uint8array: () => UniversalPropertyOptionsBuilder<Uint8Array<ArrayBufferLike>, EmptyOptions, IncludeKeysForProperty>;
-    enumArray: () => UniversalPropertyOptionsBuilder<(string | number)[], EmptyOptions, IncludeKeysForProperty>;
-    integer: () => UniversalPropertyOptionsBuilder<number, EmptyOptions, IncludeKeysForProperty>;
-    smallint: () => UniversalPropertyOptionsBuilder<number, EmptyOptions, IncludeKeysForProperty>;
-    tinyint: () => UniversalPropertyOptionsBuilder<number, EmptyOptions, IncludeKeysForProperty>;
-    mediumint: () => UniversalPropertyOptionsBuilder<number, EmptyOptions, IncludeKeysForProperty>;
-    float: () => UniversalPropertyOptionsBuilder<number, EmptyOptions, IncludeKeysForProperty>;
-    double: () => UniversalPropertyOptionsBuilder<NonNullable<string | number>, EmptyOptions, IncludeKeysForProperty>;
-    boolean: () => UniversalPropertyOptionsBuilder<NonNullable<boolean | null | undefined>, EmptyOptions, IncludeKeysForProperty>;
-    character: () => UniversalPropertyOptionsBuilder<string, EmptyOptions, IncludeKeysForProperty>;
-    string: () => UniversalPropertyOptionsBuilder<string, EmptyOptions, IncludeKeysForProperty>;
-    uuid: () => UniversalPropertyOptionsBuilder<string, EmptyOptions, IncludeKeysForProperty>;
-    text: () => UniversalPropertyOptionsBuilder<string, EmptyOptions, IncludeKeysForProperty>;
-    interval: () => UniversalPropertyOptionsBuilder<string, EmptyOptions, IncludeKeysForProperty>;
-    unknown: () => UniversalPropertyOptionsBuilder<{}, EmptyOptions, IncludeKeysForProperty>;
 };
 /** Own keys + base entity keys (when TBase is not `never`). Guards against `keyof never = string | number | symbol`. */
 type AllKeys<TProperties, TBase> = keyof TProperties | (IsNever<TBase> extends true ? never : keyof TBase);
-export interface EntityMetadataWithProperties<TName extends string, TTableName extends string, TProperties extends Record<string, any>, TPK extends (keyof TProperties)[] | undefined = undefined, TBase = never, TRepository = never> extends Omit<Partial<EntityMetadata<InferEntityFromProperties<TProperties, TPK, TBase, TRepository>>>, 'properties' | 'extends' | 'primaryKeys' | 'hooks' | 'discriminatorColumn' | 'versionProperty' | 'concurrencyCheckKeys' | 'serializedPrimaryKey' | 'indexes' | 'uniques' | 'repository' | 'orderBy'> {
+export interface EntityMetadataWithProperties<TName extends string, TTableName extends string, TProperties extends Record<string, any>, TPK extends (keyof TProperties)[] | undefined = undefined, TBase = never, TRepository = never, TForceObject extends boolean = false> extends Omit<Partial<EntityMetadata<InferEntityFromProperties<TProperties, TPK, TBase, TRepository>>>, 'properties' | 'extends' | 'primaryKeys' | 'hooks' | 'discriminatorColumn' | 'versionProperty' | 'concurrencyCheckKeys' | 'serializedPrimaryKey' | 'indexes' | 'uniques' | 'repository' | 'orderBy'> {
     name: TName;
     tableName?: TTableName;
     extends?: {
         '~entity': TBase;
     } | EntityCtor<TBase>;
-    properties: TProperties | ((properties: typeof propertyBuilders) => TProperties);
+    properties: TProperties | ((properties: PropertyBuilders) => TProperties);
     primaryKeys?: TPK & InferPrimaryKey<TProperties>[];
     hooks?: DefineEntityHooks;
     repository?: () => TRepository;
+    forceObject?: TForceObject;
     inheritance?: 'tpt';
     orderBy?: {
         [K in Extract<AllKeys<TProperties, TBase>, string>]?: QueryOrderKeysFlat;
@@ -588,59 +576,17 @@ export interface EntityMetadataWithProperties<TName extends string, TTableName e
         deferMode?: DeferMode | `${DeferMode}`;
     }[];
 }
-export declare function defineEntity<const TName extends string, const TTableName extends string, const TProperties extends Record<string, any>, const TPK extends (keyof TProperties)[] | undefined = undefined, const TBase = never, const TRepository = never>(meta: EntityMetadataWithProperties<TName, TTableName, TProperties, TPK, TBase, TRepository>): EntitySchemaWithMeta<TName, TTableName, InferEntityFromProperties<TProperties, TPK, TBase, TRepository>, TBase, TProperties>;
+export declare function defineEntity<const TName extends string, const TTableName extends string, const TProperties extends Record<string, any>, const TPK extends (keyof TProperties)[] | undefined = undefined, const TBase = never, const TRepository = never, const TForceObject extends boolean = false>(meta: EntityMetadataWithProperties<TName, TTableName, TProperties, TPK, TBase, TRepository, TForceObject>): EntitySchemaWithMeta<TName, TTableName, InferEntityFromProperties<TProperties, TPK, TBase, TRepository, TForceObject>, TBase, TProperties>;
 export declare function defineEntity<const TEntity = any, const TProperties extends Record<string, any> = Record<string, any>, const TClassName extends string = string, const TTableName extends string = string, const TBase = never, const TClass extends EntityCtor = EntityCtor<TEntity>>(meta: Omit<Partial<EntityMetadata<TEntity>>, 'properties' | 'extends' | 'className' | 'tableName' | 'hooks'> & {
     class: TClass;
     className?: TClassName;
     tableName?: TTableName;
     extends?: TBase;
-    properties: TProperties | ((properties: typeof propertyBuilders) => TProperties);
+    properties: TProperties | ((properties: PropertyBuilders) => TProperties);
     hooks?: DefineEntityHooks<TEntity>;
 }): EntitySchemaWithMeta<TClassName, TTableName, TEntity, TBase, TProperties, TClass>;
 export declare namespace defineEntity {
-    var properties: {
-        bigint: <Mode extends "bigint" | "number" | "string" = "bigint">(mode?: Mode) => UniversalPropertyOptionsBuilder<(Mode extends "bigint" ? bigint : Mode extends "number" ? number : string) & {}, EmptyOptions, IncludeKeysForProperty>;
-        array: <T = string>(toJsValue?: (i: string) => T, toDbValue?: (i: T) => string) => UniversalPropertyOptionsBuilder<T[], EmptyOptions, IncludeKeysForProperty>;
-        decimal: <Mode extends "number" | "string" = "string">(mode?: Mode) => UniversalPropertyOptionsBuilder<NonNullable<Mode extends "number" ? number : string>, EmptyOptions, IncludeKeysForProperty>;
-        json: <T>() => UniversalPropertyOptionsBuilder<T, EmptyOptions, IncludeKeysForProperty>;
-        formula: <T>(formula: string | FormulaCallback<any>) => UniversalPropertyOptionsBuilder<T, EmptyOptions, IncludeKeysForProperty>;
-        datetime: (length?: number) => UniversalPropertyOptionsBuilder<Date, EmptyOptions, IncludeKeysForProperty>;
-        time: (length?: number) => UniversalPropertyOptionsBuilder<any, EmptyOptions, IncludeKeysForProperty>;
-        type: <T extends PropertyValueType>(type: T) => UniversalPropertyOptionsBuilder<InferPropertyValueType<T>, EmptyOptions, IncludeKeysForProperty>;
-        enum: <const T extends (number | string)[] | (() => Dictionary)>(items?: T) => UniversalPropertyOptionsBuilder<T extends () => Dictionary ? ValueOf<ReturnType<T>> : T extends (infer Value)[] ? Value : T, EmptyOptions, IncludeKeysForEnumOptions>;
-        embedded: <Target extends EntityTarget | EntityTarget[]>(target: Target) => PropertyChain<InferEntity<Target extends (infer T)[] ? T : Target>, EmptyOptions & {
-            kind: "embedded";
-        }>;
-        manyToMany: <Target extends EntityTarget>(target: Target) => PropertyChain<InferEntity<Target>, EmptyOptions & {
-            kind: "m:n";
-        }>;
-        manyToOne: <Target extends EntityTarget | EntityTarget[]>(target: Target) => PropertyChain<InferEntity<Target extends (infer T)[] ? T : Target>, EmptyOptions & {
-            kind: "m:1";
-        }>;
-        oneToMany: <Target extends EntityTarget>(target: Target) => PropertyChain<InferEntity<Target>, EmptyOptions & {
-            kind: "1:m";
-        }>;
-        oneToOne: <Target extends EntityTarget | EntityTarget[]>(target: Target) => PropertyChain<InferEntity<Target extends (infer T)[] ? T : Target>, EmptyOptions & {
-            kind: "1:1";
-        }>;
-        date: () => UniversalPropertyOptionsBuilder<string, EmptyOptions, IncludeKeysForProperty>;
-        blob: () => UniversalPropertyOptionsBuilder<NonNullable<Buffer<ArrayBufferLike> | Uint8Array<ArrayBufferLike> | null>, EmptyOptions, IncludeKeysForProperty>;
-        uint8array: () => UniversalPropertyOptionsBuilder<Uint8Array<ArrayBufferLike>, EmptyOptions, IncludeKeysForProperty>;
-        enumArray: () => UniversalPropertyOptionsBuilder<(string | number)[], EmptyOptions, IncludeKeysForProperty>;
-        integer: () => UniversalPropertyOptionsBuilder<number, EmptyOptions, IncludeKeysForProperty>;
-        smallint: () => UniversalPropertyOptionsBuilder<number, EmptyOptions, IncludeKeysForProperty>;
-        tinyint: () => UniversalPropertyOptionsBuilder<number, EmptyOptions, IncludeKeysForProperty>;
-        mediumint: () => UniversalPropertyOptionsBuilder<number, EmptyOptions, IncludeKeysForProperty>;
-        float: () => UniversalPropertyOptionsBuilder<number, EmptyOptions, IncludeKeysForProperty>;
-        double: () => UniversalPropertyOptionsBuilder<NonNullable<string | number>, EmptyOptions, IncludeKeysForProperty>;
-        boolean: () => UniversalPropertyOptionsBuilder<NonNullable<boolean | null | undefined>, EmptyOptions, IncludeKeysForProperty>;
-        character: () => UniversalPropertyOptionsBuilder<string, EmptyOptions, IncludeKeysForProperty>;
-        string: () => UniversalPropertyOptionsBuilder<string, EmptyOptions, IncludeKeysForProperty>;
-        uuid: () => UniversalPropertyOptionsBuilder<string, EmptyOptions, IncludeKeysForProperty>;
-        text: () => UniversalPropertyOptionsBuilder<string, EmptyOptions, IncludeKeysForProperty>;
-        interval: () => UniversalPropertyOptionsBuilder<string, EmptyOptions, IncludeKeysForProperty>;
-        unknown: () => UniversalPropertyOptionsBuilder<{}, EmptyOptions, IncludeKeysForProperty>;
-    };
+    var properties: PropertyBuilders;
 }
 export { propertyBuilders as p };
 type EntityHookValue<T, K extends keyof EventSubscriber<T>> = (keyof T | NonNullable<EventSubscriber<T>[K]>)[];
@@ -658,23 +604,34 @@ export interface DefineEntityHooks<T = any> {
 }
 type PropertyValueType = PropertyOptions<any>['type'];
 type InferPropertyValueType<T extends PropertyValueType> = T extends string ? InferTypeByString<T> : T extends NumberConstructor ? number : T extends StringConstructor ? string : T extends BooleanConstructor ? boolean : T extends DateConstructor ? Date : T extends ArrayConstructor ? string[] : T extends Constructor<infer TType> ? TType extends Type<infer TValue, any> ? NonNullable<TValue> : TType : T extends Type<infer TValue, any> ? NonNullable<TValue> : any;
-type InferTypeByString<T extends string> = T extends keyof typeof types ? InferJSType<typeof types[T]> : InferColumnType<T>;
+type InferTypeByString<T extends string> = T extends keyof typeof types ? InferJSType<(typeof types)[T]> : InferColumnType<T>;
 type InferJSType<T> = T extends typeof Type<infer TValue, any> ? NonNullable<TValue> : never;
 type InferColumnType<T extends string> = T extends 'int' | 'int4' | 'integer' | 'bigint' | 'int8' | 'int2' | 'tinyint' | 'smallint' | 'mediumint' ? number : T extends 'double' | 'double precision' | 'real' | 'float8' | 'decimal' | 'numeric' | 'float' | 'float4' ? number : T extends 'datetime' | 'time' | 'time with time zone' | 'timestamp' | 'timestamp with time zone' | 'timetz' | 'timestamptz' | 'date' | 'interval' ? Date : T extends 'ObjectId' | 'objectId' | 'character varying' | 'varchar' | 'char' | 'character' | 'uuid' | 'text' | 'tinytext' | 'mediumtext' | 'longtext' | 'enum' ? string : T extends 'boolean' | 'bool' | 'bit' ? boolean : T extends 'blob' | 'tinyblob' | 'mediumblob' | 'longblob' | 'bytea' ? Buffer : T extends 'point' | 'line' | 'lseg' | 'box' | 'circle' | 'path' | 'polygon' | 'geometry' ? number[] : T extends 'tsvector' | 'tsquery' ? string[] : T extends 'json' | 'jsonb' ? any : any;
-export type InferEntityFromProperties<Properties extends Record<string, any>, PK extends (keyof Properties)[] | undefined = undefined, Base = never, Repository = never> = {
+type BaseEntityMethodKeys = 'toObject' | 'toPOJO' | 'serialize' | 'assign' | 'populate' | 'init' | 'toReference';
+export type InferEntityFromProperties<Properties extends Record<string, any>, PK extends (keyof Properties)[] | undefined = undefined, Base = never, Repository = never, ForceObject extends boolean = false> = (IsNever<Base> extends true ? {} : Base extends {
+    toObject(...args: any[]): any;
+} ? Pick<IWrappedEntity<{
     -readonly [K in keyof Properties]: InferBuilderValue<MaybeReturnType<Properties[K]>>;
 } & {
     [PrimaryKeyProp]?: InferCombinedPrimaryKey<Properties, PK, Base>;
 } & (IsNever<Repository> extends true ? {} : {
     [EntityRepositoryType]?: Repository extends Constructor<infer R> ? R : Repository;
-}) & (IsNever<Base> extends true ? {} : Omit<Base, typeof PrimaryKeyProp>);
+}) & Omit<Base, typeof PrimaryKeyProp>>, BaseEntityMethodKeys> : {}) & {
+    -readonly [K in keyof Properties]: InferBuilderValue<MaybeReturnType<Properties[K]>>;
+} & {
+    [PrimaryKeyProp]?: InferCombinedPrimaryKey<Properties, PK, Base>;
+} & (IsNever<Repository> extends true ? {} : {
+    [EntityRepositoryType]?: Repository extends Constructor<infer R> ? R : Repository;
+}) & (IsNever<Base> extends true ? {} : Omit<Base, typeof PrimaryKeyProp>) & (ForceObject extends true ? {
+    [Config]?: DefineConfig<{
+        forceObject: true;
+    }>;
+} : {});
 type InferCombinedPrimaryKey<Properties extends Record<string, any>, PK, Base> = PK extends undefined ? CombinePrimaryKeys<InferPrimaryKey<Properties>, ExtractBasePrimaryKey<Base>> : PK;
 type ExtractBasePrimaryKey<Base> = Base extends {
     [PrimaryKeyProp]?: infer BasePK;
 } ? BasePK : never;
-type CombinePrimaryKeys<ChildPK, BasePK> = [
-    ChildPK
-] extends [never] ? BasePK : [BasePK] extends [never] ? IsUnion<ChildPK> extends true ? ChildPK[] : ChildPK : ChildPK | BasePK;
+type CombinePrimaryKeys<ChildPK, BasePK> = [ChildPK] extends [never] ? BasePK : [BasePK] extends [never] ? IsUnion<ChildPK> extends true ? ChildPK[] : ChildPK : ChildPK | BasePK;
 export type InferPrimaryKey<Properties extends Record<string, any>> = {
     [K in keyof Properties]: MaybeReturnType<Properties[K]> extends {
         '~options': {

package/entity/utils.js

@@ -17,15 +17,17 @@ function expandNestedPopulate(parentProp, parts, strategy, all) {
  * @internal
  */
 export function expandDotPaths(meta, populate, normalized = false) {
-    const ret = normalized ? populate : Utils.asArray(populate).map(field => {
-        if (typeof field === 'string') {
-            return { field };
-        }
-        /* v8 ignore next */
-        return typeof field === 'boolean' || field.field === PopulatePath.ALL
-            ? { all: !!field, field: meta.primaryKeys[0] }
-            : field;
-    });
+    const ret = normalized
+        ? populate
+        : Utils.asArray(populate).map(field => {
+            if (typeof field === 'string') {
+                return { field };
+            }
+            /* v8 ignore next */
+            return typeof field === 'boolean' || field.field === PopulatePath.ALL
+                ? { all: !!field, field: meta.primaryKeys[0] }
+                : field;
+        });
     for (const p of ret) {
         if (!p.field.includes('.')) {
             continue;
@@ -35,8 +37,8 @@ export function expandDotPaths(meta, populate, normalized = false) {
         p.children ??= [];
         const prop = meta.properties[p.field];
         if (parts[0] === PopulatePath.ALL) {
-            prop.targetMeta.props
-                .filter(prop => prop.lazy || prop.kind !== ReferenceKind.SCALAR)
+            prop
+                .targetMeta.props.filter(prop => prop.lazy || prop.kind !== ReferenceKind.SCALAR)
                 .forEach(prop => p.children.push({ field: prop.name, strategy: p.strategy }));
         }
         else if (prop.kind === ReferenceKind.EMBEDDED) {
@@ -67,6 +69,21 @@ export function getLoadingStrategy(strategy, kind) {
     }
     return strategy;
 }
+function findPopulateEntry(populate, parts) {
+    let current = populate;
+    for (let i = 0; i < parts.length; i++) {
+        const entry = current.find(p => p.field.split(':')[0] === parts[i]);
+        if (!entry) {
+            return undefined;
+        }
+        if (i === parts.length - 1) {
+            return entry;
+        }
+        current = (entry.children ?? []);
+    }
+    /* v8 ignore next */
+    return undefined;
+}
 /**
  * Applies per-relation overrides from `populateHints` to the normalized populate tree.
  * @internal
@@ -85,18 +102,3 @@ export function applyPopulateHints(populate, hints) {
         }
     }
 }
-function findPopulateEntry(populate, parts) {
-    let current = populate;
-    for (let i = 0; i < parts.length; i++) {
-        const entry = current.find(p => p.field.split(':')[0] === parts[i]);
-        if (!entry) {
-            return undefined;
-        }
-        if (i === parts.length - 1) {
-            return entry;
-        }
-        current = (entry.children ?? []);
-    }
-    /* v8 ignore next */
-    return undefined;
-}

package/entity/validators.js

@@ -52,7 +52,8 @@ export function validateParams(params, type = 'search condition', field) {
 }
 /** @internal */
 export function validatePrimaryKey(entity, meta) {
-    const pkExists = meta.primaryKeys.every(pk => entity[pk] != null) || (meta.serializedPrimaryKey && entity[meta.serializedPrimaryKey] != null);
+    const pkExists = meta.primaryKeys.every(pk => entity[pk] != null) ||
+        (meta.serializedPrimaryKey && entity[meta.serializedPrimaryKey] != null);
     if (!entity || !pkExists) {
         throw ValidationError.fromMergeWithoutPK(meta);
     }

package/enums.d.ts

@@ -45,7 +45,8 @@ export declare enum QueryOperator {
     $size = "size",// collection operators, sql only
     $hasKey = "?",// postgres only, json
     $hasKeys = "?&",// postgres only, json
-    $hasSomeKeys = "?|"
+    $hasSomeKeys = "?|",// postgres only, json
+    $elemMatch = "elemMatch"
 }
 export declare const ARRAY_OPERATORS: string[];
 export declare const JSON_KEY_OPERATORS: string[];

package/enums.js

@@ -48,23 +48,10 @@ export var QueryOperator;
     QueryOperator["$hasKey"] = "?";
     QueryOperator["$hasKeys"] = "?&";
     QueryOperator["$hasSomeKeys"] = "?|";
+    QueryOperator["$elemMatch"] = "elemMatch";
 })(QueryOperator || (QueryOperator = {}));
-export const ARRAY_OPERATORS = [
-    '$eq',
-    '$gt',
-    '$gte',
-    '$lt',
-    '$lte',
-    '$ne',
-    '$overlap',
-    '$contains',
-    '$contained',
-];
-export const JSON_KEY_OPERATORS = [
-    '$hasKey',
-    '$hasKeys',
-    '$hasSomeKeys',
-];
+export const ARRAY_OPERATORS = ['$eq', '$gt', '$gte', '$lt', '$lte', '$ne', '$overlap', '$contains', '$contained'];
+export const JSON_KEY_OPERATORS = ['$hasKey', '$hasKeys', '$hasSomeKeys'];
 export var QueryOrder;
 (function (QueryOrder) {
     QueryOrder["ASC"] = "ASC";
@@ -100,7 +87,16 @@ export var QueryFlag;
     QueryFlag["IDENTITY_INSERT"] = "IDENTITY_INSERT";
     QueryFlag["OUTPUT_TABLE"] = "OUTPUT_TABLE";
 })(QueryFlag || (QueryFlag = {}));
-export const SCALAR_TYPES = new Set(['string', 'number', 'boolean', 'bigint', 'Uint8Array', '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";

package/errors.d.ts

@@ -56,17 +56,17 @@ export declare class MetadataError<T extends AnyEntity = AnyEntity> extends Vali
     static duplicateFieldName(entityName: EntityName, names: [string, string][]): MetadataError;
     static multipleDecorators(entityName: string, propertyName: string): MetadataError;
     static missingMetadata(entity: string): MetadataError;
-    static invalidPrimaryKey(meta: EntityMetadata, prop: EntityProperty, requiredName: string): MetadataError<Partial<any>>;
-    static invalidManyToManyWithPivotEntity(meta1: EntityMetadata, prop1: EntityProperty, meta2: EntityMetadata, prop2: EntityProperty): MetadataError<Partial<any>>;
-    static targetIsAbstract(meta: EntityMetadata, prop: EntityProperty): MetadataError<Partial<any>>;
-    static nonPersistentCompositeProp(meta: EntityMetadata, prop: EntityProperty): MetadataError<Partial<any>>;
-    static propertyTargetsEntityType(meta: EntityMetadata, prop: EntityProperty, target: EntityMetadata): MetadataError<Partial<any>>;
-    static fromMissingOption(meta: EntityMetadata, prop: EntityProperty, option: string): MetadataError<Partial<any>>;
-    static targetKeyOnManyToMany(meta: EntityMetadata, prop: EntityProperty): MetadataError<Partial<any>>;
-    static targetKeyNotUnique(meta: EntityMetadata, prop: EntityProperty, target?: EntityMetadata): MetadataError<Partial<any>>;
-    static targetKeyNotFound(meta: EntityMetadata, prop: EntityProperty, target?: EntityMetadata): MetadataError<Partial<any>>;
-    static incompatiblePolymorphicTargets(meta: EntityMetadata, prop: EntityProperty, target1: EntityMetadata, target2: EntityMetadata, reason: string): MetadataError<Partial<any>>;
-    static dangerousPropertyName(meta: EntityMetadata, prop: EntityProperty): MetadataError<Partial<any>>;
+    static invalidPrimaryKey(meta: EntityMetadata, prop: EntityProperty, requiredName: string): MetadataError;
+    static invalidManyToManyWithPivotEntity(meta1: EntityMetadata, prop1: EntityProperty, meta2: EntityMetadata, prop2: EntityProperty): MetadataError;
+    static targetIsAbstract(meta: EntityMetadata, prop: EntityProperty): MetadataError;
+    static nonPersistentCompositeProp(meta: EntityMetadata, prop: EntityProperty): MetadataError;
+    static propertyTargetsEntityType(meta: EntityMetadata, prop: EntityProperty, target: EntityMetadata): MetadataError;
+    static fromMissingOption(meta: EntityMetadata, prop: EntityProperty, option: string): MetadataError;
+    static targetKeyOnManyToMany(meta: EntityMetadata, prop: EntityProperty): MetadataError;
+    static targetKeyNotUnique(meta: EntityMetadata, prop: EntityProperty, target?: EntityMetadata): MetadataError;
+    static targetKeyNotFound(meta: EntityMetadata, prop: EntityProperty, target?: EntityMetadata): MetadataError;
+    static incompatiblePolymorphicTargets(meta: EntityMetadata, prop: EntityProperty, target1: EntityMetadata, target2: EntityMetadata, reason: string): MetadataError;
+    static dangerousPropertyName(meta: EntityMetadata, prop: EntityProperty): MetadataError;
     static viewEntityWithoutExpression(meta: EntityMetadata): MetadataError;
     static mixedInheritanceStrategies(root: EntityMetadata, child: EntityMetadata): MetadataError;
     static tptNotSupportedByDriver(meta: EntityMetadata): MetadataError;

package/errors.js

@@ -34,12 +34,12 @@ export class ValidationError extends Error {
         return new ValidationError(`Entity ${entity.constructor.name} is not managed. An entity is managed if its fetched from the database or registered as new through EntityManager.persist()`);
     }
     static notEntity(owner, prop, data) {
-        const type = Object.prototype.toString.call(data).match(/\[object (\w+)]/)[1].toLowerCase();
+        const type = /\[object (\w+)]/.exec(Object.prototype.toString.call(data))[1].toLowerCase();
         return new ValidationError(`Entity of type ${prop.type} expected for property ${owner.constructor.name}.${prop.name}, ${inspect(data)} of type ${type} given. If you are using Object.assign(entity, data), use em.assign(entity, data) instead.`);
     }
     static notDiscoveredEntity(data, meta, action = 'persist') {
         /* v8 ignore next */
-        const type = meta?.className ?? Object.prototype.toString.call(data).match(/\[object (\w+)]/)[1].toLowerCase();
+        const type = meta?.className ?? /\[object (\w+)]/.exec(Object.prototype.toString.call(data))[1].toLowerCase();
         let err = `Trying to ${action} not discovered entity of type ${type}.`;
         if (meta) {
             err += ` Entity with this name was discovered, but not the prototype you are passing to the ORM. If using EntitySchema, be sure to point to the implementation via \`class\`.`;
@@ -56,7 +56,7 @@ export class ValidationError extends Error {
         return new ValidationError(`Invalid enum array items provided in ${entityName}: ${inspect(invalid)}`);
     }
     static invalidType(type, value, mode) {
-        const valueType = Object.prototype.toString.call(value).match(/\[object (\w+)]/)[1].toLowerCase();
+        const valueType = /\[object (\w+)]/.exec(Object.prototype.toString.call(value))[1].toLowerCase();
         if (value instanceof Date) {
             value = value.toISOString();
         }
@@ -69,8 +69,8 @@ export class ValidationError extends Error {
     static cannotModifyInverseCollection(owner, property) {
         const inverseCollection = `${owner.constructor.name}.${property.name}`;
         const ownerCollection = `${property.type}.${property.mappedBy}`;
-        const error = `You cannot modify inverse side of M:N collection ${inverseCollection} when the owning side is not initialized. `
-            + `Consider working with the owning side instead (${ownerCollection}).`;
+        const error = `You cannot modify inverse side of M:N collection ${inverseCollection} when the owning side is not initialized. ` +
+            `Consider working with the owning side instead (${ownerCollection}).`;
         return new ValidationError(error, owner);
     }
     static cannotModifyReadonlyCollection(owner, property) {
@@ -79,7 +79,7 @@ export class ValidationError extends Error {
     static cannotRemoveFromCollectionWithoutOrphanRemoval(owner, property) {
         const options = [
             ' - add `orphanRemoval: true` to the collection options',
-            ' - add `deleteRule: \'cascade\'` to the owning side options',
+            " - add `deleteRule: 'cascade'` to the owning side options",
             ' - add `nullable: true` to the owning side options',
         ].join('\n');
         return new ValidationError(`Removing items from collection ${owner.constructor.name}.${property.name} without \`orphanRemoval: true\` would break non-null constraint on the owning side. You have several options: \n${options}`, owner);
@@ -91,7 +91,7 @@ export class ValidationError extends Error {
         return new ValidationError('You cannot call em.flush() from inside lifecycle hook handlers');
     }
     static cannotUseGlobalContext() {
-        return new ValidationError('Using global EntityManager instance methods for context specific actions is disallowed. If you need to work with the global instance\'s identity map, use `allowGlobalContext` configuration option or `fork()` instead.');
+        return new ValidationError("Using global EntityManager instance methods for context specific actions is disallowed. If you need to work with the global instance's identity map, use `allowGlobalContext` configuration option or `fork()` instead.");
     }
     static cannotUseOperatorsInsideEmbeddables(entityName, propName, payload) {
         return new ValidationError(`Using operators inside embeddables is not allowed, move the operator above. (property: ${Utils.className(entityName)}.${propName}, payload: ${inspect(payload)})`);
@@ -164,7 +164,7 @@ export class MetadataError extends ValidationError {
         return new MetadataError(`Entity ${meta.className} has wrong ${type} definition: '${prop}' does not exist. You need to use property name, not column name.`);
     }
     static multipleVersionFields(meta, fields) {
-        return new MetadataError(`Entity ${meta.className} has multiple version properties defined: '${fields.join('\', \'')}'. Only one version property is allowed per entity.`);
+        return new MetadataError(`Entity ${meta.className} has multiple version properties defined: '${fields.join("', '")}'. Only one version property is allowed per entity.`);
     }
     static invalidVersionFieldType(meta) {
         const prop = meta.properties[meta.versionProperty];

package/events/EventManager.d.ts

@@ -2,10 +2,7 @@ import type { EntityMetadata } from '../typings.js';
 import type { EventArgs, EventSubscriber, FlushEventArgs, TransactionEventArgs } from './EventSubscriber.js';
 import { EventType, type TransactionEventType } from '../enums.js';
 export declare class EventManager {
-    private readonly listeners;
-    private readonly entities;
-    private readonly cache;
-    private readonly subscribers;
+    #private;
     constructor(subscribers: Iterable<EventSubscriber>);
     registerSubscriber(subscriber: EventSubscriber): void;
     getSubscribers(): Set<EventSubscriber>;

package/events/EventManager.js

@@ -1,31 +1,31 @@
 import { Utils } from '../utils/Utils.js';
 import { EventType, EventTypeMap } from '../enums.js';
 export class EventManager {
-    listeners = {};
-    entities = new Map();
-    cache = new Map();
-    subscribers = new Set();
+    #listeners = {};
+    #entities = new Map();
+    #cache = new Map();
+    #subscribers = new Set();
     constructor(subscribers) {
         for (const subscriber of subscribers) {
             this.registerSubscriber(subscriber);
         }
     }
     registerSubscriber(subscriber) {
-        if (this.subscribers.has(subscriber)) {
+        if (this.#subscribers.has(subscriber)) {
             return;
         }
-        this.subscribers.add(subscriber);
-        this.entities.set(subscriber, this.getSubscribedEntities(subscriber));
-        this.cache.clear();
+        this.#subscribers.add(subscriber);
+        this.#entities.set(subscriber, this.getSubscribedEntities(subscriber));
+        this.#cache.clear();
         Utils.keys(EventType)
             .filter(event => event in subscriber)
             .forEach(event => {
-            this.listeners[event] ??= new Set();
-            this.listeners[event].add(subscriber);
+            this.#listeners[event] ??= new Set();
+            this.#listeners[event].add(subscriber);
         });
     }
     getSubscribers() {
-        return this.subscribers;
+        return this.#subscribers;
     }
     dispatchEvent(event, args, meta) {
         const listeners = [];
@@ -35,42 +35,45 @@ export class EventManager {
         const hooks = (meta?.hooks[event] || []);
         listeners.push(...hooks.map(hook => {
             const prototypeHook = meta?.prototype[hook];
-            const handler = typeof hook === 'function' ? hook : entity[hook] ?? prototypeHook;
+            const handler = typeof hook === 'function' ? hook : (entity[hook] ?? prototypeHook);
             return handler.bind(entity);
         }));
-        for (const listener of this.listeners[event] ?? new Set()) {
-            const entities = this.entities.get(listener);
+        for (const listener of this.#listeners[event] ?? new Set()) {
+            const entities = this.#entities.get(listener);
             if (entities.size === 0 || !entity || entities.has(entity.constructor.name)) {
                 listeners.push(listener[event].bind(listener));
             }
         }
         if (event === EventType.onInit) {
-            return listeners.forEach(listener => listener(args));
+            for (const listener of listeners) {
+                void listener(args);
+            }
+            return;
         }
         return Utils.runSerial(listeners, listener => listener(args));
     }
     hasListeners(event, meta) {
         const cacheKey = meta._id + EventTypeMap[event];
-        if (this.cache.has(cacheKey)) {
-            return this.cache.get(cacheKey);
+        if (this.#cache.has(cacheKey)) {
+            return this.#cache.get(cacheKey);
         }
         const hasHooks = meta.hooks[event]?.length;
         if (hasHooks) {
-            this.cache.set(cacheKey, true);
+            this.#cache.set(cacheKey, true);
             return true;
         }
-        for (const listener of this.listeners[event] ?? new Set()) {
-            const entities = this.entities.get(listener);
+        for (const listener of this.#listeners[event] ?? new Set()) {
+            const entities = this.#entities.get(listener);
             if (entities.size === 0 || entities.has(meta.className)) {
-                this.cache.set(cacheKey, true);
+                this.#cache.set(cacheKey, true);
                 return true;
             }
         }
-        this.cache.set(cacheKey, false);
+        this.#cache.set(cacheKey, false);
         return false;
     }
     clone() {
-        return new EventManager(this.subscribers);
+        return new EventManager(this.#subscribers);
     }
     getSubscribedEntities(listener) {
         if (!listener.getSubscribedEntities) {

package/events/index.d.ts

@@ -1,3 +1,3 @@
-export * from './EventSubscriber.js';
+export type * from './EventSubscriber.js';
 export * from './EventManager.js';
 export * from './TransactionEventBroadcaster.js';

package/events/index.js

@@ -1,3 +1,2 @@
-export * from './EventSubscriber.js';
 export * from './EventManager.js';
 export * from './TransactionEventBroadcaster.js';

package/exceptions.js

@@ -9,10 +9,17 @@ export class DriverException extends Error {
     errmsg;
     constructor(previous) {
         super(previous.message);
-        Object.getOwnPropertyNames(previous).forEach(k => this[k] = previous[k]);
+        Object.getOwnPropertyNames(previous).forEach(k => (this[k] = previous[k]));
         this.name = this.constructor.name;
         Error.captureStackTrace(this, this.constructor);
-        this.stack += '\n\n' + previous.stack.split('\n').filter(l => l.trim().startsWith('at ')).join('\n');
+        if (previous.stack) {
+            this.stack +=
+                '\n\n' +
+                    previous.stack
+                        .split('\n')
+                        .filter(l => l.trim().startsWith('at '))
+                        .join('\n');
+        }
     }
 }
 /**

package/hydration/ObjectHydrator.d.ts

@@ -3,8 +3,7 @@ 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, normalizeAccessors?: boolean) => void;
 export declare class ObjectHydrator extends Hydrator {
-    private readonly hydrators;
-    private tmpIndex;
+    #private;
     /**
      * @inheritDoc
      */