@mikro-orm/core 7.3.0-dev.2 → 7.3.0-dev.20

package/entity/defineEntity.d.ts

@@ -1,5 +1,5 @@
 import type { EntityManager } from '../EntityManager.js';
-import type { ColumnType, PropertyOptions, ReferenceOptions, EnumOptions, EmbeddedOptions, ManyToOneOptions, OneToManyOptions, OneToOneOptions, ManyToManyOptions, IndexColumnOptions } from '../metadata/types.js';
+import type { ColumnType, PropertyOptions, ReferenceOptions, EnumOptions, EmbeddedOptions, ManyToOneOptions, OneToManyOptions, OneToOneOptions, ManyToManyOptions, IndexColumnOptions, SequenceOptions } from '../metadata/types.js';
 import type { AnyString, GeneratedColumnCallback, Constructor, CheckCallback, FilterQuery, EntityName, Dictionary, EntityMetadata, PrimaryKeyProp, EntityRepositoryType, Hidden, Opt, Primary, EntityClass, EntitySchemaWithMeta, InferEntity, MaybeReturnType, Ref, LazyRef, IndexCallback, TriggerCallback, FormulaCallback, EntityCtor, IsNever, IWrappedEntity, DefineConfig, Config, MaybePromise, IndexHints, OptionalProps, ExtractDefineEntityProperties } from '../typings.js';
 import type { Raw } from '../utils/RawQueryFragment.js';
 import type { ScalarReference } from './Reference.js';
@@ -130,6 +130,7 @@ export interface PropertyChain<in out Value, in out Options> {
     unique(unique?: boolean): PropertyChain<Value, Options>;
     comment(comment: string): PropertyChain<Value, Options>;
     collation(collation: string): PropertyChain<Value, Options>;
+    sequence(sequence: SequenceOptions | number): PropertyChain<Value, Options>;
     accessor(accessor?: string | boolean): PropertyChain<Value, Options>;
     eager(eager?: boolean): HasKind<Options, 'm:1' | '1:m' | '1:1' | 'm:n'> extends true ? PropertyChain<Value, Options> : never;
     cascade(...cascade: Cascade[]): HasKind<Options, 'm:1' | '1:m' | '1:1' | 'm:n'> extends true ? PropertyChain<Value, Options> : never;
@@ -486,6 +487,12 @@ export declare class UniversalPropertyOptionsBuilder<in out Value, in out Option
      * Emits a `COLLATE` clause on the column definition; the accepted collation names are dialect-specific.
      */
     collation(collation: string): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
+    /**
+     * Set the start value and increment of an autoincrement column. (SQL only)
+     * A number is a shorthand for `{ startWith }`.
+     * Applied only when the column is created (and by `orm.schema.clear()`), never diffed by the schema generator.
+     */
+    sequence(sequence: SequenceOptions | number): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
     /** mysql only */
     extra(extra: string): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
     /**
@@ -593,7 +600,7 @@ type EntityTarget = {
     '~entity': any;
 } | EntityClass;
 declare const propertyBuilders: PropertyBuilders;
-type PropertyBuildersOverrideKeys = 'bigint' | 'array' | 'decimal' | 'json' | 'string' | 'text' | 'datetime' | 'time' | 'enum';
+type PropertyBuildersOverrideKeys = 'bigint' | 'array' | 'decimal' | 'double' | 'json' | 'string' | 'text' | 'datetime' | 'time' | 'enum';
 /** Map of factory functions for creating type-safe property builders (scalars, enums, embeddables, and relations). */
 export type PropertyBuilders = {
     [K in Exclude<keyof typeof types, PropertyBuildersOverrideKeys>]: () => UniversalPropertyOptionsBuilder<InferPropertyValueType<(typeof types)[K]>, EmptyOptions, IncludeKeysForProperty>;
@@ -601,6 +608,7 @@ export type PropertyBuilders = {
     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>;
+    double: <Mode extends 'number' | 'string' = 'number'>(mode?: Mode) => UniversalPropertyOptionsBuilder<InferPropertyValueType<typeof types.double<Mode>>, EmptyOptions, IncludeKeysForProperty>;
     json: <T>() => UniversalPropertyOptionsBuilder<T, EmptyOptions, IncludeKeysForProperty>;
     string: () => StringPropertyOptionsBuilder<InferPropertyValueType<typeof types.string>, EmptyOptions>;
     text: () => StringPropertyOptionsBuilder<InferPropertyValueType<typeof types.text>, EmptyOptions>;
@@ -630,6 +638,21 @@ type AllKeys<TProperties, TBase> = keyof TProperties | (IsNever<TBase> extends t
 type PartialWhere<TProperties, TBase> = string | FilterQuery<{
     [K in AllKeys<TProperties, TBase> & string]?: unknown;
 }>;
+type DefineEntityFilterMap = Dictionary<{
+    name: string;
+    cond: Dictionary | ((args: Dictionary, type: 'read' | 'update' | 'delete', em: any, options?: FindOptions<any, any, any, any> | FindOneOptions<any, any, any, any>, entityName?: string) => MaybePromise<FilterQuery<any>>);
+    default?: boolean;
+    entity?: EntityName<any> | EntityName<any>[];
+    args?: boolean;
+    strict?: boolean;
+    rls?: boolean | {
+        setting?: string;
+    };
+}>;
+type DefineEntityFilterMapLoose = Dictionary<{
+    name: string;
+    cond: Dictionary;
+}>;
 /** Metadata descriptor for `defineEntity()`, combining entity options with property definitions. */
 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, TDiscriminatorColumn extends string | undefined = undefined, TDiscriminatorValue extends string | number | undefined = undefined, TBaseDiscriminatorColumn extends string | undefined = undefined, TEmbeddable extends boolean = false, TForceUndefined extends boolean = false> extends Omit<Partial<EntityMetadata<InferEntityFromProperties<TProperties, TPK, TBase, TRepository>>>, 'properties' | 'extends' | 'primaryKeys' | 'hooks' | 'discriminator' | 'discriminatorColumn' | 'discriminatorValue' | 'versionProperty' | 'concurrencyCheckKeys' | 'serializedPrimaryKey' | 'indexes' | 'uniques' | 'triggers' | 'repository' | 'filters' | 'orderBy'> {
     name: TName;
@@ -641,20 +664,10 @@ export interface EntityMetadataWithProperties<TName extends string, TTableName e
         '~discriminatorColumn'?: TBaseDiscriminatorColumn;
     });
     properties: TProperties | ((properties: PropertyBuilders) => TProperties);
-    primaryKeys?: TPK & InferPrimaryKeyConstraint<TProperties>[];
+    primaryKeys?: TPK & NoInfer<InferPrimaryKeyConstraint<TProperties>>[];
     hooks?: DefineEntityHooks;
     repository?: () => TRepository;
-    filters?: Dictionary<{
-        name: string;
-        cond: Dictionary | ((args: Dictionary, type: 'read' | 'update' | 'delete', em: any, options?: FindOptions<any, any, any, any> | FindOneOptions<any, any, any, any>, entityName?: string) => MaybePromise<FilterQuery<any>>);
-        default?: boolean;
-        entity?: EntityName<any> | EntityName<any>[];
-        args?: boolean;
-        strict?: boolean;
-        rls?: boolean | {
-            setting?: string;
-        };
-    }>;
+    filters?: DefineEntityFilterMap | IsNever<TRepository, never, DefineEntityFilterMapLoose>;
     forceObject?: TForceObject;
     /** Hydrate `null` as `undefined` for this entity and infer nullable properties as `T | undefined`. */
     forceUndefined?: TForceUndefined;
@@ -669,16 +682,16 @@ export interface EntityMetadataWithProperties<TName extends string, TTableName e
     /** Alias for `discriminator`. */
     discriminatorColumn?: TDiscriminatorColumn;
     discriminatorValue?: TDiscriminatorValue;
-    versionProperty?: AllKeys<TProperties, TBase>;
-    concurrencyCheckKeys?: Set<AllKeys<TProperties, TBase>>;
-    serializedPrimaryKey?: AllKeys<TProperties, TBase>;
+    versionProperty?: NoInfer<AllKeys<TProperties, TBase>>;
+    concurrencyCheckKeys?: Set<NoInfer<AllKeys<TProperties, TBase>>>;
+    serializedPrimaryKey?: NoInfer<AllKeys<TProperties, TBase>>;
     indexes?: {
         properties?: NoInfer<AllKeys<TProperties, TBase>> | NoInfer<AllKeys<TProperties, TBase>>[];
         name?: string;
         type?: string;
         options?: Dictionary;
         expression?: string | IndexCallback<InferEntityFromProperties<TProperties, TPK, TBase>>;
-        where?: PartialWhere<TProperties, TBase>;
+        where?: NoInfer<PartialWhere<TProperties, TBase>>;
         columns?: IndexColumnOptions[];
         include?: NoInfer<AllKeys<TProperties, TBase>> | NoInfer<AllKeys<TProperties, TBase>>[];
         fillFactor?: number;
@@ -691,7 +704,7 @@ export interface EntityMetadataWithProperties<TName extends string, TTableName e
         name?: string;
         options?: Dictionary;
         expression?: string | IndexCallback<InferEntityFromProperties<TProperties, TPK, TBase>>;
-        where?: PartialWhere<TProperties, TBase>;
+        where?: NoInfer<PartialWhere<TProperties, TBase>>;
         deferMode?: DeferMode | `${DeferMode}`;
         columns?: IndexColumnOptions[];
         include?: NoInfer<AllKeys<TProperties, TBase>> | NoInfer<AllKeys<TProperties, TBase>>[];

package/entity/defineEntity.js

@@ -323,6 +323,14 @@ export class UniversalPropertyOptionsBuilder {
     collation(collation) {
         return this.assignOptions({ collation });
     }
+    /**
+     * Set the start value and increment of an autoincrement column. (SQL only)
+     * A number is a shorthand for `{ startWith }`.
+     * Applied only when the column is created (and by `orm.schema.clear()`), never diffed by the schema generator.
+     */
+    sequence(sequence) {
+        return this.assignOptions({ sequence: typeof sequence === 'number' ? { startWith: sequence } : sequence });
+    }
     /** mysql only */
     extra(extra) {
         return this.assignOptions({ extra });
@@ -511,6 +519,7 @@ const propertyBuilders = {
     bigint: (mode) => new UniversalPropertyOptionsBuilder({ type: new types.bigint(mode) }),
     array: (toJsValue = i => i, toDbValue = i => i) => new UniversalPropertyOptionsBuilder({ type: new types.array(toJsValue, toDbValue) }),
     decimal: (mode) => new UniversalPropertyOptionsBuilder({ type: new types.decimal(mode) }),
+    double: (mode) => new UniversalPropertyOptionsBuilder({ type: new types.double(mode) }),
     json: () => new UniversalPropertyOptionsBuilder({ type: types.json }),
     string: () => new StringPropertyOptionsBuilder({
         type: types.string,

package/entity/validators.js

@@ -24,7 +24,10 @@ export function validateProperty(prop, givenValue, entity) {
 }
 function getValue(o, prop) {
     if (prop.embedded && prop.embedded[0] in o) {
-        return o[prop.embedded[0]]?.[prop.embedded[1]];
+        const embeddable = o[prop.embedded[0]];
+        const variantProp = embeddable?.__meta?.properties[prop.embedded[1]];
+        // a same-named property of a different kind in another polymorphic variant
+        return variantProp && !Utils.isSameKind(variantProp, prop) ? undefined : embeddable?.[prop.embedded[1]];
     }
     /* v8 ignore next */
     if (prop.ref) {

package/errors.d.ts

@@ -10,6 +10,7 @@ export declare class ValidationError<T extends AnyEntity = AnyEntity> extends Er
     static fromWrongPropertyType(entity: AnyEntity, property: string, expectedType: string, givenType: string, givenValue: string): ValidationError;
     static fromWrongRepositoryType(entityName: string, repoType: string, method: string): ValidationError;
     static fromMergeWithoutPK(meta: EntityMetadata): ValidationError;
+    static referenceWithoutPK(entity: AnyEntity): ValidationError;
     static transactionRequired(): ValidationError;
     static entityNotManaged(entity: AnyEntity): ValidationError;
     static notEntity(owner: AnyEntity, prop: EntityProperty, data: any): ValidationError;
@@ -90,6 +91,12 @@ export declare class MetadataError<T extends AnyEntity = AnyEntity> extends Vali
     static triggersNotSupportedByDriver(meta: EntityMetadata): MetadataError;
     /** Thrown when row level security is declared on an entity using a driver that does not support it. */
     static rowLevelSecurityNotSupportedByDriver(meta: EntityMetadata): MetadataError;
+    /** Thrown when the `sequence` option is declared on a property that is not autoincrement. */
+    static sequenceWithoutAutoincrement(meta: EntityMetadata, prop: EntityProperty): MetadataError;
+    /** Thrown when the `sequence` option is combined with an identity option list in `generated`. */
+    static sequenceWithIdentityOptions(meta: EntityMetadata, prop: EntityProperty): MetadataError;
+    /** Thrown when `sequence.incrementBy` is declared on a platform without a per-column increment. */
+    static sequenceIncrementNotSupported(meta: EntityMetadata, prop: EntityProperty, platform: string): MetadataError;
     /** Thrown when row level security is declared on a non-root entity of an STI hierarchy. */
     static rowLevelSecurityOnNonRootStiEntity(meta: EntityMetadata): MetadataError;
     /** Thrown when two policies on the same entity are given the same explicit name. */

package/errors.js

@@ -28,6 +28,9 @@ export class ValidationError extends Error {
     static fromMergeWithoutPK(meta) {
         return new ValidationError(`You cannot merge entity '${meta.className}' without identifier!`);
     }
+    static referenceWithoutPK(entity) {
+        return new ValidationError(`Entity '${entity.constructor.name}' is only known by an alternate key and has no primary key, load it first`, entity);
+    }
     static transactionRequired() {
         return new ValidationError('An open transaction is required for this operation');
     }
@@ -293,6 +296,18 @@ export class MetadataError extends ValidationError {
     static rowLevelSecurityNotSupportedByDriver(meta) {
         return new MetadataError(`Entity ${meta.className} declares row level security which is not supported by the current driver. Row level security is only available with the PostgreSQL driver. To test a PostgreSQL app without a server, use the \`@mikro-orm/pglite\` driver instead of sqlite.`);
     }
+    /** Thrown when the `sequence` option is declared on a property that is not autoincrement. */
+    static sequenceWithoutAutoincrement(meta, prop) {
+        return MetadataError.fromMessage(meta, prop, `defines the 'sequence' option, but is not an autoincrement property`);
+    }
+    /** Thrown when the `sequence` option is combined with an identity option list in `generated`. */
+    static sequenceWithIdentityOptions(meta, prop) {
+        return MetadataError.fromMessage(meta, prop, `defines the 'sequence' option together with identity options in 'generated', use only one of them`);
+    }
+    /** Thrown when `sequence.incrementBy` is declared on a platform without a per-column increment. */
+    static sequenceIncrementNotSupported(meta, prop, platform) {
+        return MetadataError.fromMessage(meta, prop, `defines 'sequence.incrementBy', but ${platform} does not support a per-column increment`);
+    }
     /** Thrown when row level security is declared on a non-root entity of an STI hierarchy. */
     static rowLevelSecurityOnNonRootStiEntity(meta) {
         return new MetadataError(`Entity ${meta.className} declares row level security, but it is part of a single table inheritance hierarchy. Declare policies on the root entity ${meta.root.className} instead, as the whole hierarchy shares a single table.`);

package/hydration/ObjectHydrator.js

@@ -207,7 +207,7 @@ export class ObjectHydrator extends Hydrator {
             if (prop.customType?.ensureComparable(meta, prop)) {
                 registerCustomType(prop, this.safeKey(prop.name), 'convertToDatabaseValue', context);
                 ret.push(`  if (data${dataKey} != null && typeof data${dataKey} !== 'object' && convertCustomTypes) {`);
-                ret.push(`    data${dataKey} = convertToDatabaseValue_${this.safeKey(prop.name)}(entity${entityKey}.__helper.getPrimaryKey());`);
+                ret.push(`    data${dataKey} = convertToDatabaseValue_${this.safeKey(prop.name)}(entity${entityKey}.__helper.getTargetKeyValue(${prop.targetKey ? this.quote(prop.targetKey) : ''}));`);
                 ret.push(`  }`);
             }
             return ret;
@@ -313,6 +313,10 @@ export class ObjectHydrator extends Hydrator {
                             ? dataKey + this.wrap(childProp.embedded[1])
                             : this.wrap(childProp.name);
                         const prop2 = childMeta.properties[childProp.embedded[1]];
+                        // a same-named property of a different kind in another variant
+                        if (prop2 && !Utils.isSameKind(prop2, childProp)) {
+                            return;
+                        }
                         const prop3 = {
                             ...prop2,
                             name: childProp.name,
@@ -404,7 +408,7 @@ export class ObjectHydrator extends Hydrator {
         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 fnKey = `hydrator-${meta.uniqueName}-${type}-${normalizeAccessors}`;
+        const fnKey = `hydrator-${meta.compiledName}-${type}-${normalizeAccessors}`;
         const hydrator = Utils.createFunction(context, code, this.config.get('compiledFunctions'), fnKey);
         this.#hydrators[key].set(meta.class, hydrator);
         return hydrator;

package/metadata/MetadataDiscovery.d.ts

@@ -29,11 +29,21 @@ export declare class MetadataDiscovery {
     private initFieldName;
     private initManyToOneFieldName;
     private initManyToManyFieldName;
+    /**
+     * Walks up the TPT hierarchy to the entity whose M:N declaration this property inherits. A child redeclaring
+     * the property with a different target, pivot table, join columns or fixed order keeps its own pivot table.
+     */
+    private getPivotDeclaringMeta;
     private initManyToManyFields;
     private isExplicitTableName;
     private initManyToOneFields;
     private initOneToManyFields;
     private processEntity;
+    /**
+     * Groups the relations of all entities by target class name in one pass, so `findReferencingProperties()`
+     * does not go over the relations of every entity for each entity. Lists keep the order of `metadata` and `relations`.
+     */
+    private indexReferencingProperties;
     private findReferencingProperties;
     private initFactoryField;
     private ensureCorrectFKOrderInPivotEntity;