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

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,30 +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}`;
-}

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,24 +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}`;
-}

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);
-}

package/decorators/Property.d.ts

@@ -1,250 +0,0 @@
-import { type Cascade, type LoadStrategy } from '../enums.js';
-import type { EntityName, Constructor, CheckCallback, GeneratedColumnCallback, AnyString, AnyEntity } from '../typings.js';
-import type { Type, types } from '../types/index.js';
-import type { EntityManager } from '../EntityManager.js';
-import type { SerializeOptions } from '../serialization/EntitySerializer.js';
-export declare function Property<T extends object>(options?: PropertyOptions<T>): (target: T, propertyName: string) => any;
-export interface PropertyOptions<Owner> {
-    /**
-     * Alias for `fieldName`.
-     */
-    name?: string;
-    /**
-     * Specify database column name for this property.
-     *
-     * @see https://mikro-orm.io/docs/naming-strategy
-     */
-    fieldName?: string;
-    /**
-     * Specify database column names for this property.
-     * Same as `fieldName` but for composite FKs.
-     *
-     * @see https://mikro-orm.io/docs/naming-strategy
-     */
-    fieldNames?: string[];
-    /**
-     * Specify an exact database column type for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}. This option is only for simple properties represented by a single column. (SQL only)
-     */
-    columnType?: ColumnType | AnyString;
-    /**
-     * Specify an exact database column type for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}. This option is suitable for composite keys, where one property is represented by multiple columns. (SQL only)
-     */
-    columnTypes?: (ColumnType | AnyString)[];
-    /**
-     * Explicitly specify the runtime type.
-     *
-     * @see https://mikro-orm.io/docs/metadata-providers
-     * @see https://mikro-orm.io/docs/custom-types
-     */
-    type?: keyof typeof types | 'ObjectId' | Date | Constructor<AnyEntity> | Constructor<Type<any>> | Type<any> | (() => unknown) | ColumnType | AnyString;
-    /**
-     * Runtime type of the property. This is the JS type that your property is mapped to, e.g. `string` or `number`, and is normally inferred automatically via `reflect-metadata`.
-     * In some cases, the inference won't work, and you might need to specify the `runtimeType` explicitly - the most common one is when you use a union type with null like `foo: number | null`.
-     */
-    runtimeType?: string;
-    /**
-     * Set length of database column, used for datetime/timestamp/varchar column types for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}. (SQL only)
-     */
-    length?: number;
-    /**
-     * Set precision of database column to represent the number of significant digits. (SQL only)
-     */
-    precision?: number;
-    /**
-     * Set scale of database column to represents the number of digits after the decimal point. (SQL only)
-     */
-    scale?: number;
-    /**
-     * Explicitly specify the auto increment of the primary key.
-     */
-    autoincrement?: boolean;
-    /**
-     * Add the property to the `returning` statement.
-     */
-    returning?: boolean;
-    /**
-     * Automatically set the property value when entity gets created, executed during flush operation.
-     * @param entity
-     */
-    onCreate?: (entity: Owner, em: EntityManager) => any;
-    /**
-     * Automatically update the property value every time entity gets updated, executed during flush operation.
-     * @param entity
-     */
-    onUpdate?: (entity: Owner, em: EntityManager) => any;
-    /**
-     * Specify default column value for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}.
-     * This is a runtime value, assignable to the entity property. (SQL only)
-     */
-    default?: string | string[] | number | number[] | boolean | null;
-    /**
-     * Specify SQL functions for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}. (SQL only)
-     * Since v4 you should use defaultRaw for SQL functions. e.g. now()
-     */
-    defaultRaw?: string;
-    /**
-     * Set to map some SQL snippet for the entity.
-     *
-     * @see https://mikro-orm.io/docs/defining-entities#formulas Formulas
-     */
-    formula?: string | ((alias: string) => string);
-    /**
-     * For generated columns. This will be appended to the column type after the `generated always` clause.
-     */
-    generated?: string | GeneratedColumnCallback<Owner>;
-    /**
-     * Set column as nullable for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}.
-     */
-    nullable?: boolean;
-    /**
-     * Set column as unsigned for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}. (SQL only)
-     */
-    unsigned?: boolean;
-    /**
-     * Set false to define {@link https://mikro-orm.io/docs/serializing#shadow-properties Shadow Property}.
-     */
-    persist?: boolean;
-    /**
-     * Set false to disable hydration of this property. Useful for persisted getters.
-     */
-    hydrate?: boolean;
-    /**
-     * Enable `ScalarReference` wrapper for lazy values. Use this in combination with `lazy: true` to have a type-safe accessor object in place of the value.
-     */
-    ref?: boolean;
-    /**
-     * Set false to disable change tracking on a property level.
-     *
-     * @see https://mikro-orm.io/docs/unit-of-work#change-tracking-and-performance-considerations
-     */
-    trackChanges?: boolean;
-    /**
-     * Set to true to omit the property when {@link https://mikro-orm.io/docs/serializing Serializing}.
-     */
-    hidden?: boolean;
-    /**
-     * Set to true to enable {@link https://mikro-orm.io/docs/transactions#optimistic-locking Optimistic Locking} via version field. (SQL only)
-     */
-    version?: boolean;
-    /**
-     * Set to true to enable {@link https://mikro-orm.io/docs/transactions#optimistic-locking Optimistic Locking} via concurrency fields.
-     */
-    concurrencyCheck?: boolean;
-    /**
-     * Explicitly specify index on a property.
-     */
-    index?: boolean | string;
-    /**
-     * Set column as unique for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}. (SQL only)
-     */
-    unique?: boolean | string;
-    /**
-     * Specify column with check constraints. (Postgres driver only)
-     *
-     * @see https://mikro-orm.io/docs/defining-entities#check-constraints
-     */
-    check?: string | CheckCallback<Owner>;
-    /**
-     * Set to omit the property from the select clause for lazy loading.
-     *
-     * @see https://mikro-orm.io/docs/defining-entities#lazy-scalar-properties
-     */
-    lazy?: boolean;
-    /**
-     * Set true to define entity's unique primary key identifier.
-     * Alias for `@PrimaryKey()` decorator
-     *
-     * @see https://mikro-orm.io/docs/decorators#primarykey
-     */
-    primary?: boolean;
-    /**
-     * Set true to define the properties as setter. (virtual)
-     *
-     * @example
-     * ```
-     * @Property({ setter: true })
-     * set address(value: string) {
-     *     this._address = value.toLocaleLowerCase();
-     * }
-     * ```
-     */
-    setter?: boolean;
-    /**
-     * Set true to define the properties as getter. (virtual)
-     *
-     * @example
-     * ```
-     * @Property({ getter: true })
-     * get fullName() {
-     *   return this.firstName + this.lastName;
-     * }
-     * ```
-     */
-    getter?: boolean;
-    /**
-     * When defining a property over a method (not a getter, a regular function), you can use this option to point
-     * to the method name.
-     *
-     * @example
-     * ```
-     * @Property({ getter: true })
-     * getFullName() {
-     *   return this.firstName + this.lastName;
-     * }
-     * ```
-     */
-    getterName?: keyof Owner;
-    /**
-     * Set to define serialized primary key for MongoDB. (virtual)
-     * Alias for `@SerializedPrimaryKey()` decorator.
-     *
-     * @see https://mikro-orm.io/docs/decorators#serializedprimarykey
-     */
-    serializedPrimaryKey?: boolean;
-    /**
-     * Set to use serialize property. Allow to specify a callback that will be used when serializing a property.
-     *
-     * @see https://mikro-orm.io/docs/serializing#property-serializers
-     */
-    serializer?: (value: any, options?: SerializeOptions<any>) => any;
-    /**
-     * Specify name of key for the serialized value.
-     */
-    serializedName?: string;
-    /**
-     * Specify serialization groups for `serialize()` calls. If a property does not specify any group, it will be included,
-     * otherwise only properties with a matching group are included.
-     */
-    groups?: string[];
-    /**
-     * Specify a custom order based on the values. (SQL only)
-     */
-    customOrder?: string[] | number[] | boolean[];
-    /**
-     * Specify comment of column for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}. (SQL only)
-     */
-    comment?: string;
-    /** mysql only */
-    extra?: string;
-    /**
-     * Set to avoid a perpetual diff from the {@link https://mikro-orm.io/docs/schema-generator Schema Generator} when columns are generated.
-     *
-     * @see https://mikro-orm.io/docs/defining-entities#sql-generated-columns
-     */
-    ignoreSchemaChanges?: ('type' | 'extra' | 'default')[];
-}
-export interface ReferenceOptions<Owner, Target> extends PropertyOptions<Owner> {
-    /** Set target entity type. */
-    entity?: string | (() => EntityName<Target>);
-    /** Set what actions on owning entity should be cascaded to the relationship. Defaults to [Cascade.PERSIST, Cascade.MERGE] (see {@doclink cascading}). */
-    cascade?: Cascade[];
-    /** Always load the relationship. Discouraged for use with to-many relations for performance reasons. */
-    eager?: boolean;
-    /** Override the default loading strategy for this property. This option has precedence over the global `loadStrategy`, but can be overridden by `FindOptions.strategy`. */
-    strategy?: LoadStrategy | `${LoadStrategy}`;
-}
-/**
- * Inspired by https://github.com/typeorm/typeorm/blob/941b584ba135617e55d6685caef671172ec1dc03/src/driver/types/ColumnTypes.ts
- * @ignore
- */
-export type ColumnType = 'int' | 'int4' | 'integer' | 'bigint' | 'int8' | 'int2' | 'tinyint' | 'smallint' | 'mediumint' | 'double' | 'double precision' | 'real' | 'float8' | 'decimal' | 'numeric' | 'float' | 'float4' | 'datetime' | 'time' | 'time with time zone' | 'timestamp' | 'timestamp with time zone' | 'timetz' | 'timestamptz' | 'date' | 'interval' | 'character varying' | 'varchar' | 'char' | 'character' | 'uuid' | 'text' | 'tinytext' | 'mediumtext' | 'longtext' | 'boolean' | 'bool' | 'bit' | 'enum' | 'blob' | 'tinyblob' | 'mediumblob' | 'longblob' | 'bytea' | 'point' | 'line' | 'lseg' | 'box' | 'circle' | 'path' | 'polygon' | 'geometry' | 'tsvector' | 'tsquery' | 'json' | 'jsonb';

package/decorators/Property.js

@@ -1,32 +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 Property(options = {}) {
-    return function (target, propertyName) {
-        const meta = MetadataStorage.getMetadataFromDecorator(target.constructor);
-        const desc = Object.getOwnPropertyDescriptor(target, propertyName) || {};
-        MetadataValidator.validateSingleDecorator(meta, propertyName, ReferenceKind.SCALAR);
-        const name = options.name || propertyName;
-        if (propertyName !== name && !(desc.value instanceof Function)) {
-            Utils.renameKey(options, 'name', 'fieldName');
-        }
-        options.name = propertyName;
-        const { check, ...opts } = options;
-        const prop = { kind: ReferenceKind.SCALAR, ...opts };
-        prop.getter = !!desc.get;
-        prop.setter = !!desc.set;
-        if (desc.value instanceof Function) {
-            prop.getter = true;
-            prop.persist = false;
-            prop.type = 'method';
-            prop.getterName = propertyName;
-            prop.name = name;
-        }
-        if (check) {
-            meta.checks.push({ property: prop.name, expression: check });
-        }
-        meta.properties[prop.name] = prop;
-        return Utils.propertyDecoratorReturnValue();
-    };
-}

package/decorators/Transactional.d.ts

@@ -1,13 +0,0 @@
-import type { TransactionOptions } from '../enums.js';
-import type { ContextProvider } from '../typings.js';
-type TransactionalOptions<T> = TransactionOptions & {
-    context?: ContextProvider<T>;
-};
-/**
- * This decorator wraps the method with `em.transactional()`, so you can provide `TransactionOptions` just like with `em.transactional()`.
- * The difference is that you can specify the context in which the transaction begins by providing `context` option,
- * and if omitted, the transaction will begin in the current context implicitly.
- * It works on async functions and can be nested with `em.transactional()`.
- */
-export declare function Transactional<T extends object>(options?: TransactionalOptions<T>): MethodDecorator;
-export {};

package/decorators/Transactional.js

@@ -1,28 +0,0 @@
-import { RequestContext } from '../utils/RequestContext.js';
-import { resolveContextProvider } from '../utils/resolveContextProvider.js';
-import { TransactionContext } from '../utils/TransactionContext.js';
-/**
- * This decorator wraps the method with `em.transactional()`, so you can provide `TransactionOptions` just like with `em.transactional()`.
- * The difference is that you can specify the context in which the transaction begins by providing `context` option,
- * and if omitted, the transaction will begin in the current context implicitly.
- * It works on async functions and can be nested with `em.transactional()`.
- */
-export function Transactional(options = {}) {
-    return function (target, propertyKey, descriptor) {
-        const originalMethod = descriptor.value;
-        if (originalMethod.constructor.name !== 'AsyncFunction') {
-            throw new Error('@Transactional() should be use with async functions');
-        }
-        descriptor.value = async function (...args) {
-            const { context, ...txOptions } = options;
-            const em = (await resolveContextProvider(this, context))
-                || TransactionContext.getEntityManager()
-                || RequestContext.getEntityManager();
-            if (!em) {
-                throw new Error(`@Transactional() decorator can only be applied to methods of classes with \`orm: MikroORM\` property, \`em: EntityManager\` property, or with a callback parameter like \`@Transactional(() => orm)\` that returns one of those types. The parameter will contain a reference to current \`this\`. Returning an EntityRepository from it is also supported.`);
-            }
-            return em.transactional(() => originalMethod.apply(this, args), txOptions);
-        };
-        return descriptor;
-    };
-}

package/decorators/hooks.d.ts

@@ -1,16 +0,0 @@
-export declare function BeforeCreate(): (target: any, method: string) => void;
-export declare function AfterCreate(): (target: any, method: string) => void;
-export declare function BeforeUpdate(): (target: any, method: string) => void;
-export declare function AfterUpdate(): (target: any, method: string) => void;
-export declare function BeforeUpsert(): (target: any, method: string) => void;
-export declare function AfterUpsert(): (target: any, method: string) => void;
-export declare function OnInit(): (target: any, method: string) => void;
-export declare function OnLoad(): (target: any, method: string) => void;
-/**
- * Called before deleting entity, but only when providing initialized entity to EM#remove()
- */
-export declare function BeforeDelete(): (target: any, method: string) => void;
-/**
- * Called after deleting entity, but only when providing initialized entity to EM#remove()
- */
-export declare function AfterDelete(): (target: any, method: string) => void;

package/decorators/hooks.js

@@ -1,47 +0,0 @@
-import { MetadataStorage } from '../metadata/MetadataStorage.js';
-import { EventType } from '../enums.js';
-function hook(type) {
-    return function (target, method) {
-        const meta = MetadataStorage.getMetadataFromDecorator(target.constructor);
-        if (!meta.hooks[type]) {
-            meta.hooks[type] = [];
-        }
-        meta.hooks[type].push(method);
-    };
-}
-export function BeforeCreate() {
-    return hook(EventType.beforeCreate);
-}
-export function AfterCreate() {
-    return hook(EventType.afterCreate);
-}
-export function BeforeUpdate() {
-    return hook(EventType.beforeUpdate);
-}
-export function AfterUpdate() {
-    return hook(EventType.afterUpdate);
-}
-export function BeforeUpsert() {
-    return hook(EventType.beforeUpsert);
-}
-export function AfterUpsert() {
-    return hook(EventType.afterUpsert);
-}
-export function OnInit() {
-    return hook(EventType.onInit);
-}
-export function OnLoad() {
-    return hook(EventType.onLoad);
-}
-/**
- * Called before deleting entity, but only when providing initialized entity to EM#remove()
- */
-export function BeforeDelete() {
-    return hook(EventType.beforeDelete);
-}
-/**
- * Called after deleting entity, but only when providing initialized entity to EM#remove()
- */
-export function AfterDelete() {
-    return hook(EventType.afterDelete);
-}

package/decorators/index.d.ts

@@ -1,17 +0,0 @@
-export * from './PrimaryKey.js';
-export * from './Entity.js';
-export * from './OneToOne.js';
-export * from './ManyToOne.js';
-export * from './ManyToMany.js';
-export { OneToMany, OneToManyOptions } from './OneToMany.js';
-export * from './Property.js';
-export * from './Check.js';
-export * from './Enum.js';
-export * from './Formula.js';
-export * from './Indexed.js';
-export * from './Embeddable.js';
-export * from './Embedded.js';
-export * from './Filter.js';
-export * from './CreateRequestContext.js';
-export * from './hooks.js';
-export * from './Transactional.js';

package/decorators/index.js

@@ -1,17 +0,0 @@
-export * from './PrimaryKey.js';
-export * from './Entity.js';
-export * from './OneToOne.js';
-export * from './ManyToOne.js';
-export * from './ManyToMany.js';
-export { OneToMany } from './OneToMany.js';
-export * from './Property.js';
-export * from './Check.js';
-export * from './Enum.js';
-export * from './Formula.js';
-export * from './Indexed.js';
-export * from './Embeddable.js';
-export * from './Embedded.js';
-export * from './Filter.js';
-export * from './CreateRequestContext.js';
-export * from './hooks.js';
-export * from './Transactional.js';