@mikro-orm/core 7.0.0-dev.63 → 7.0.0-dev.65

package/decorators/Entity.d.ts

@@ -1,35 +0,0 @@
-import type { AnyString, Constructor, Dictionary, EntityClass, ObjectQuery } from '../typings.js';
-import type { FindOptions } from '../drivers/IDatabaseDriver.js';
-export declare function Entity<T extends EntityClass<unknown>>(options?: EntityOptions<T>): (target: T) => void;
-export type EntityOptions<T, E = T extends EntityClass<infer P> ? P : T> = {
-    /** Override default collection/table name. Alias for `collection`. */
-    tableName?: string;
-    /** Sets the schema name. */
-    schema?: string;
-    /** Override default collection/table name. Alias for `tableName`. */
-    collection?: string;
-    /** For {@doclink inheritance-mapping#single-table-inheritance | Single Table Inheritance}. */
-    discriminatorColumn?: (T extends EntityClass<infer P> ? keyof P : string) | AnyString;
-    /** For {@doclink inheritance-mapping#single-table-inheritance | Single Table Inheritance}. */
-    discriminatorMap?: Dictionary<string>;
-    /** For {@doclink inheritance-mapping#single-table-inheritance | Single Table Inheritance}. */
-    discriminatorValue?: number | string;
-    /**	Enforce use of constructor when creating managed entity instances. */
-    forceConstructor?: boolean;
-    /** Specify constructor parameters to be used in `em.create` or when `forceConstructor` is enabled. Those should be names of declared entity properties in the same order as your constructor uses them. The ORM tries to infer those automatically, use this option in case the inference fails. */
-    constructorParams?: (T extends EntityClass<infer P> ? keyof P : string)[];
-    /** Specify comment to table. (SQL only) */
-    comment?: string;
-    /**	Marks entity as abstract, such entities are inlined during discovery. */
-    abstract?: boolean;
-    /** Disables change tracking - such entities are ignored during flush. */
-    readonly?: boolean;
-    /** Marks entity as {@doclink virtual-entities | virtual}. This is set automatically when you use `expression` option. */
-    virtual?: boolean;
-    /** Used to make ORM aware of externally defined triggers. This is needed for MS SQL Server multi inserts, ignored in other dialects. */
-    hasTriggers?: boolean;
-    /** SQL query that maps to a {@doclink virtual-entities | virtual entity}. */
-    expression?: string | ((em: any, where: ObjectQuery<E>, options: FindOptions<E, any, any, any>, stream?: boolean) => object);
-    /** Set {@doclink repositories#custom-repository | custom repository class}. */
-    repository?: () => Constructor;
-};

package/decorators/Entity.js

@@ -1,12 +0,0 @@
-import { MetadataStorage } from '../metadata/MetadataStorage.js';
-import { Utils } from '../utils/Utils.js';
-export function Entity(options = {}) {
-    return function (target) {
-        const meta = MetadataStorage.getMetadataFromDecorator(target);
-        Utils.mergeConfig(meta, options);
-        meta.class = target;
-        if (!options.abstract || meta.discriminatorColumn) {
-            meta.name = target.name;
-        }
-    };
-}

package/decorators/Enum.d.ts

@@ -1,9 +0,0 @@
-import type { PropertyOptions } from './Property.js';
-import type { AnyEntity, Dictionary } from '../typings.js';
-export declare function Enum<T extends object>(options?: EnumOptions<AnyEntity> | (() => Dictionary)): (target: T, propertyName: string) => any;
-export interface EnumOptions<T> extends PropertyOptions<T> {
-    items?: (number | string)[] | (() => Dictionary);
-    array?: boolean;
-    /** for postgres, by default it uses text column with check constraint */
-    nativeEnumName?: string;
-}

package/decorators/Enum.js

@@ -1,16 +0,0 @@
-import { MetadataStorage } from '../metadata/MetadataStorage.js';
-import { ReferenceKind } from '../enums.js';
-import { Utils } from '../utils/Utils.js';
-export function Enum(options = {}) {
-    return function (target, propertyName) {
-        const meta = MetadataStorage.getMetadataFromDecorator(target.constructor);
-        options = options instanceof Function ? { items: options } : options;
-        meta.properties[propertyName] = {
-            name: propertyName,
-            kind: ReferenceKind.SCALAR,
-            enum: true,
-            ...options,
-        };
-        return Utils.propertyDecoratorReturnValue();
-    };
-}

package/decorators/Filter.d.ts

@@ -1,2 +0,0 @@
-import type { Dictionary, FilterDef } from '../typings.js';
-export declare function Filter<T>(options: FilterDef): <U>(target: U & Dictionary) => U & Dictionary;

package/decorators/Filter.js

@@ -1,8 +0,0 @@
-import { MetadataStorage } from '../metadata/MetadataStorage.js';
-export function Filter(options) {
-    return function (target) {
-        const meta = MetadataStorage.getMetadataFromDecorator(target);
-        meta.filters[options.name] = options;
-        return target;
-    };
-}

package/decorators/Formula.d.ts

@@ -1,4 +0,0 @@
-import type { PropertyOptions } from './Property.js';
-export declare function Formula<T extends object>(formula: string | ((alias: string) => string), options?: FormulaOptions<T>): (target: T, propertyName: string) => any;
-export interface FormulaOptions<T> extends PropertyOptions<T> {
-}

package/decorators/Formula.js

@@ -1,15 +0,0 @@
-import { MetadataStorage } from '../metadata/MetadataStorage.js';
-import { ReferenceKind } from '../enums.js';
-import { Utils } from '../utils/Utils.js';
-export function Formula(formula, options = {}) {
-    return function (target, propertyName) {
-        const meta = MetadataStorage.getMetadataFromDecorator(target.constructor);
-        meta.properties[propertyName] = {
-            name: propertyName,
-            kind: ReferenceKind.SCALAR,
-            formula,
-            ...options,
-        };
-        return Utils.propertyDecoratorReturnValue();
-    };
-}

package/decorators/Indexed.d.ts

@@ -1,19 +0,0 @@
-import type { EntityClass, Dictionary, AutoPath, IndexCallback } from '../typings.js';
-import type { DeferMode } from '../enums.js';
-export declare function Index<T extends object, H extends string>(options?: IndexOptions<T, H>): (target: T, propertyName?: (T extends EntityClass<unknown> ? undefined : keyof T) | undefined) => any;
-export declare function Unique<T extends object, H extends string>(options?: UniqueOptions<T, H>): (target: T, propertyName?: (T extends EntityClass<unknown> ? undefined : keyof T) | undefined) => any;
-type MaybeArray<T> = T | T[];
-type Properties<T, H extends string> = MaybeArray<AutoPath<T, H>>;
-interface BaseOptions<T, H extends string> {
-    name?: string;
-    properties?: (T extends EntityClass<infer P> ? Properties<P, H> : Properties<T, H>);
-    options?: Dictionary;
-    expression?: string | (T extends EntityClass<infer P> ? IndexCallback<P> : IndexCallback<T>);
-}
-export interface UniqueOptions<T, H extends string = string> extends BaseOptions<T, H> {
-    deferMode?: DeferMode | `${DeferMode}`;
-}
-export interface IndexOptions<T, H extends string = string> extends BaseOptions<T, H> {
-    type?: string;
-}
-export {};

package/decorators/Indexed.js

@@ -1,20 +0,0 @@
-import { MetadataStorage } from '../metadata/MetadataStorage.js';
-import { Utils } from '../utils/Utils.js';
-function createDecorator(options, unique) {
-    return function (target, propertyName) {
-        const meta = MetadataStorage.getMetadataFromDecorator(propertyName ? target.constructor : target);
-        options.properties ??= propertyName;
-        const key = unique ? 'uniques' : 'indexes';
-        meta[key].push(options);
-        if (!propertyName) {
-            return target;
-        }
-        return Utils.propertyDecoratorReturnValue();
-    };
-}
-export function Index(options = {}) {
-    return createDecorator(options, false);
-}
-export function Unique(options = {}) {
-    return createDecorator(options, true);
-}

package/decorators/ManyToMany.d.ts

@@ -1,42 +0,0 @@
-import type { ReferenceOptions } from './Property.js';
-import type { EntityName, FilterQuery, AnyString } from '../typings.js';
-import { type QueryOrderMap } from '../enums.js';
-export declare function ManyToMany<Target extends object, Owner extends object>(entity?: ManyToManyOptions<Owner, Target> | string | (() => EntityName<Target>), mappedBy?: (string & keyof Target) | ((e: Target) => any), options?: Partial<ManyToManyOptions<Owner, Target>>): (target: Owner, propertyName: keyof Owner) => any;
-export interface ManyToManyOptions<Owner, Target> extends ReferenceOptions<Owner, Target> {
-    /** Set this side as owning. Owning side is where the foreign key is defined. This option is not required if you use `inversedBy` or `mappedBy` to distinguish owning and inverse side. */
-    owner?: boolean;
-    /** Point to the inverse side property name. */
-    inversedBy?: (string & keyof Target) | ((e: Target) => any);
-    /** Point to the owning side property name. */
-    mappedBy?: (string & keyof Target) | ((e: Target) => any);
-    /** Condition for {@doclink collections#declarative-partial-loading | Declarative partial loading}. */
-    where?: FilterQuery<Target>;
-    /** Set default ordering. */
-    orderBy?: QueryOrderMap<Target> | QueryOrderMap<Target>[];
-    /** Force stable insertion order of items in the collection (see {@doclink collections | Collections}). */
-    fixedOrder?: boolean;
-    /** Override default order column name (`id`) for fixed ordering. */
-    fixedOrderColumn?: string;
-    /** Override default name for pivot table (see {@doclink naming-strategy | Naming Strategy}). */
-    pivotTable?: string;
-    /** Set pivot entity for this relation (see {@doclink collections#custom-pivot-table-entity | Custom pivot table entity}). */
-    pivotEntity?: string | (() => EntityName<any>);
-    /** Override the default database column name on the owning side (see {@doclink naming-strategy | Naming Strategy}). This option is only for simple properties represented by a single column. */
-    joinColumn?: string;
-    /** Override the default database column name on the owning side (see {@doclink naming-strategy | Naming Strategy}). This option is suitable for composite keys, where one property is represented by multiple columns. */
-    joinColumns?: string[];
-    /** Override the default database column name on the inverse side (see {@doclink naming-strategy | Naming Strategy}). This option is only for simple properties represented by a single column. */
-    inverseJoinColumn?: string;
-    /** Override the default database column name on the inverse side (see {@doclink naming-strategy | Naming Strategy}). This option is suitable for composite keys, where one property is represented by multiple columns. */
-    inverseJoinColumns?: string[];
-    /** Override the default database column name on the target entity (see {@doclink naming-strategy | Naming Strategy}). This option is only for simple properties represented by a single column. */
-    referenceColumnName?: string;
-    /** Override the default database column name on the target entity (see {@doclink naming-strategy | Naming Strategy}). This option is suitable for composite keys, where one property is represented by multiple columns. */
-    referencedColumnNames?: string[];
-    /** What to do when the target entity gets deleted. */
-    deleteRule?: 'cascade' | 'no action' | 'set null' | 'set default' | AnyString;
-    /** What to do when the reference to the target entity gets updated. */
-    updateRule?: 'cascade' | 'no action' | 'set null' | 'set default' | AnyString;
-    /** Enable/disable foreign key constraint creation on this relation */
-    createForeignKeyConstraint?: boolean;
-}

package/decorators/ManyToMany.js

@@ -1,14 +0,0 @@
-import { MetadataStorage } from '../metadata/MetadataStorage.js';
-import { MetadataValidator } from '../metadata/MetadataValidator.js';
-import { Utils } from '../utils/Utils.js';
-import { ReferenceKind } from '../enums.js';
-export function ManyToMany(entity, mappedBy, options = {}) {
-    return function (target, propertyName) {
-        options = Utils.processDecoratorParameters({ entity, mappedBy, options });
-        const meta = MetadataStorage.getMetadataFromDecorator(target.constructor);
-        MetadataValidator.validateSingleDecorator(meta, propertyName, ReferenceKind.MANY_TO_MANY);
-        const property = { name: propertyName, kind: ReferenceKind.MANY_TO_MANY };
-        meta.properties[propertyName] = Object.assign(meta.properties[propertyName] ?? {}, property, options);
-        return Utils.propertyDecoratorReturnValue();
-    };
-}

package/decorators/ManyToOne.d.ts

@@ -1,34 +0,0 @@
-import type { ReferenceOptions } from './Property.js';
-import { type DeferMode } from '../enums.js';
-import type { AnyString, EntityName } from '../typings.js';
-export declare function ManyToOne<Target extends object, Owner extends object>(entity?: ManyToOneOptions<Owner, Target> | string | ((e?: any) => EntityName<Target>), options?: Partial<ManyToOneOptions<Owner, Target>>): (target: Owner, propertyName: keyof Owner) => any;
-export interface ManyToOneOptions<Owner, Target> extends ReferenceOptions<Owner, Target> {
-    /** Point to the inverse side property name. */
-    inversedBy?: (string & keyof Target) | ((e: Target) => any);
-    /** Wrap the entity in {@apilink Reference} wrapper. */
-    ref?: boolean;
-    /** Use this relation as a primary key. */
-    primary?: boolean;
-    /** Map this relation to the primary key value instead of an entity. */
-    mapToPk?: boolean;
-    /** Override the default database column name on the owning side (see {@doclink naming-strategy | Naming Strategy}). This option is only for simple properties represented by a single column. */
-    joinColumn?: string;
-    /** Override the default database column name on the owning side (see {@doclink naming-strategy | Naming Strategy}). This option is suitable for composite keys, where one property is represented by multiple columns. */
-    joinColumns?: string[];
-    /** When a part of a composite column is shared in other properties, use this option to specify what columns are considered as owned by this property. This is useful when your composite property is nullable, but parts of it are not. */
-    ownColumns?: string[];
-    /** Override the default database column name on the target entity (see {@doclink naming-strategy | Naming Strategy}). This option is only for simple properties represented by a single column. */
-    referenceColumnName?: string;
-    /** Override the default database column name on the target entity (see {@doclink naming-strategy | Naming Strategy}). This option is suitable for composite keys, where one property is represented by multiple columns. */
-    referencedColumnNames?: string[];
-    /** What to do when the target entity gets deleted. */
-    deleteRule?: 'cascade' | 'no action' | 'set null' | 'set default' | AnyString;
-    /** What to do when the reference to the target entity gets updated. */
-    updateRule?: 'cascade' | 'no action' | 'set null' | 'set default' | AnyString;
-    /** Set the constraint type. Immediate constraints are checked for each statement, while deferred ones are only checked at the end of the transaction. Only for postgres unique constraints. */
-    deferMode?: DeferMode | `${DeferMode}`;
-    /** Enable/disable foreign key constraint creation on this relation */
-    createForeignKeyConstraint?: boolean;
-    /** Set a custom foreign key constraint name, overriding NamingStrategy.indexName(). */
-    foreignKeyName?: string;
-}

package/decorators/ManyToOne.js

@@ -1,14 +0,0 @@
-import { MetadataStorage } from '../metadata/MetadataStorage.js';
-import { MetadataValidator } from '../metadata/MetadataValidator.js';
-import { Utils } from '../utils/Utils.js';
-import { ReferenceKind } from '../enums.js';
-export function ManyToOne(entity = {}, options = {}) {
-    return function (target, propertyName) {
-        options = Utils.processDecoratorParameters({ entity, options });
-        const meta = MetadataStorage.getMetadataFromDecorator(target.constructor);
-        MetadataValidator.validateSingleDecorator(meta, propertyName, ReferenceKind.MANY_TO_ONE);
-        const property = { name: propertyName, kind: ReferenceKind.MANY_TO_ONE };
-        meta.properties[propertyName] = Object.assign(meta.properties[propertyName] ?? {}, property, options);
-        return Utils.propertyDecoratorReturnValue();
-    };
-}

package/decorators/OneToMany.d.ts

@@ -1,28 +0,0 @@
-import type { ReferenceOptions } from './Property.js';
-import { ReferenceKind, type QueryOrderMap } from '../enums.js';
-import type { EntityName, FilterQuery } from '../typings.js';
-export declare function createOneToDecorator<Target, Owner>(entity: OneToManyOptions<Owner, Target> | string | ((e?: any) => EntityName<Target>), mappedBy: (string & keyof Target) | ((e: Target) => any) | undefined, options: Partial<OneToManyOptions<Owner, Target>>, kind: ReferenceKind): (target: Owner, propertyName: string) => any;
-export declare function OneToMany<Target, Owner>(entity: string | ((e?: any) => EntityName<Target>), mappedBy: (string & keyof Target) | ((e: Target) => any), options?: Partial<OneToManyOptions<Owner, Target>>): (target: Owner, propertyName: string) => void;
-export declare function OneToMany<Target, Owner>(options: OneToManyOptions<Owner, Target>): (target: Owner, propertyName: string) => void;
-export interface OneToManyOptions<Owner, Target> extends ReferenceOptions<Owner, Target> {
-    /** Remove the entity when it gets disconnected from the relationship (see {@doclink cascading | Cascading}). */
-    orphanRemoval?: boolean;
-    /** Set default ordering. */
-    orderBy?: QueryOrderMap<Target> | QueryOrderMap<Target>[];
-    /** Condition for {@doclink collections#declarative-partial-loading | Declarative partial loading}. */
-    where?: FilterQuery<Target>;
-    /** Override the default database column name on the owning side (see {@doclink naming-strategy | Naming Strategy}). This option is only for simple properties represented by a single column. */
-    joinColumn?: string;
-    /** Override the default database column name on the owning side (see {@doclink naming-strategy | Naming Strategy}). This option is suitable for composite keys, where one property is represented by multiple columns. */
-    joinColumns?: string[];
-    /** Override the default database column name on the inverse side (see {@doclink naming-strategy | Naming Strategy}). This option is only for simple properties represented by a single column. */
-    inverseJoinColumn?: string;
-    /** Override the default database column name on the inverse side (see {@doclink naming-strategy | Naming Strategy}). This option is suitable for composite keys, where one property is represented by multiple columns. */
-    inverseJoinColumns?: string[];
-    /** Override the default database column name on the target entity (see {@doclink naming-strategy | Naming Strategy}). This option is only for simple properties represented by a single column. */
-    referenceColumnName?: string;
-    /** Override the default database column name on the target entity (see {@doclink naming-strategy | Naming Strategy}). This option is suitable for composite keys, where one property is represented by multiple columns. */
-    referencedColumnNames?: string[];
-    /** Point to the owning side property name. */
-    mappedBy: (string & keyof Target) | ((e: Target) => any);
-}

package/decorators/OneToMany.js

@@ -1,17 +0,0 @@
-import { MetadataStorage } from '../metadata/MetadataStorage.js';
-import { MetadataValidator } from '../metadata/MetadataValidator.js';
-import { Utils } from '../utils/Utils.js';
-import { ReferenceKind } from '../enums.js';
-export function createOneToDecorator(entity, mappedBy, options, kind) {
-    return function (target, propertyName) {
-        options = Utils.processDecoratorParameters({ entity, mappedBy, options });
-        const meta = MetadataStorage.getMetadataFromDecorator(target.constructor);
-        MetadataValidator.validateSingleDecorator(meta, propertyName, kind);
-        const property = { name: propertyName, kind };
-        meta.properties[propertyName] = Object.assign(meta.properties[propertyName] ?? {}, property, options);
-        return Utils.propertyDecoratorReturnValue();
-    };
-}
-export function OneToMany(entity, mappedBy, options = {}) {
-    return createOneToDecorator(entity, mappedBy, options, ReferenceKind.ONE_TO_MANY);
-}

package/decorators/OneToOne.d.ts

@@ -1,28 +0,0 @@
-import { type DeferMode } from '../enums.js';
-import { type OneToManyOptions } from './OneToMany.js';
-import type { AnyString, EntityName } from '../typings.js';
-export declare function OneToOne<Target, Owner>(entity?: OneToOneOptions<Owner, Target> | string | ((e: Owner) => EntityName<Target>), mappedByOrOptions?: (string & keyof Target) | ((e: Target) => any) | Partial<OneToOneOptions<Owner, Target>>, options?: Partial<OneToOneOptions<Owner, Target>>): (target: Owner, propertyName: string) => any;
-export interface OneToOneOptions<Owner, Target> extends Partial<Omit<OneToManyOptions<Owner, Target>, 'orderBy'>> {
-    /** Set this side as owning. Owning side is where the foreign key is defined. This option is not required if you use `inversedBy` or `mappedBy` to distinguish owning and inverse side. */
-    owner?: boolean;
-    /** Point to the inverse side property name. */
-    inversedBy?: (string & keyof Target) | ((e: Target) => any);
-    /** Wrap the entity in {@apilink Reference} wrapper. */
-    ref?: boolean;
-    /** Use this relation as a primary key. */
-    primary?: boolean;
-    /** Map this relation to the primary key value instead of an entity. */
-    mapToPk?: boolean;
-    /** When a part of a composite column is shared in other properties, use this option to specify what columns are considered as owned by this property. This is useful when your composite property is nullable, but parts of it are not. */
-    ownColumns?: string[];
-    /** What to do when the target entity gets deleted. */
-    deleteRule?: 'cascade' | 'no action' | 'set null' | 'set default' | AnyString;
-    /** What to do when the reference to the target entity gets updated. */
-    updateRule?: 'cascade' | 'no action' | 'set null' | 'set default' | AnyString;
-    /** Set the constraint type. Immediate constraints are checked for each statement, while deferred ones are only checked at the end of the transaction. Only for postgres unique constraints. */
-    deferMode?: DeferMode | `${DeferMode}`;
-    /** Set a custom foreign key constraint name, overriding NamingStrategy.indexName(). */
-    foreignKeyName?: string;
-    /** Enable/disable foreign key constraint creation on this relation */
-    createForeignKeyConstraint?: boolean;
-}

package/decorators/OneToOne.js

@@ -1,7 +0,0 @@
-import { ReferenceKind } from '../enums.js';
-import { createOneToDecorator } from './OneToMany.js';
-export function OneToOne(entity, mappedByOrOptions, options = {}) {
-    const mappedBy = typeof mappedByOrOptions === 'object' ? mappedByOrOptions.mappedBy : mappedByOrOptions;
-    options = typeof mappedByOrOptions === 'object' ? { ...mappedByOrOptions, ...options } : options;
-    return createOneToDecorator(entity, mappedBy, options, ReferenceKind.ONE_TO_ONE);
-}

package/decorators/PrimaryKey.d.ts

@@ -1,8 +0,0 @@
-import type { PropertyOptions } from './Property.js';
-export declare function PrimaryKey<T extends object>(options?: PrimaryKeyOptions<T>): (target: T, propertyName: string) => any;
-export declare function SerializedPrimaryKey<T extends object>(options?: SerializedPrimaryKeyOptions<T>): (target: T, propertyName: string) => any;
-export interface PrimaryKeyOptions<T> extends PropertyOptions<T> {
-}
-export interface SerializedPrimaryKeyOptions<T> extends PropertyOptions<T> {
-    type?: any;
-}

package/decorators/PrimaryKey.js

@@ -1,20 +0,0 @@
-import { MetadataStorage } from '../metadata/MetadataStorage.js';
-import { MetadataValidator } from '../metadata/MetadataValidator.js';
-import { ReferenceKind } from '../enums.js';
-import { Utils } from '../utils/Utils.js';
-function createDecorator(options, serialized) {
-    return function (target, propertyName) {
-        const meta = MetadataStorage.getMetadataFromDecorator(target.constructor);
-        MetadataValidator.validateSingleDecorator(meta, propertyName, ReferenceKind.SCALAR);
-        const k = serialized ? 'serializedPrimaryKey' : 'primary';
-        options[k] = true;
-        meta.properties[propertyName] = { name: propertyName, kind: ReferenceKind.SCALAR, ...options };
-        return Utils.propertyDecoratorReturnValue();
-    };
-}
-export function PrimaryKey(options = {}) {
-    return createDecorator(options, false);
-}
-export function SerializedPrimaryKey(options = {}) {
-    return createDecorator(options, true);
-}