@mikro-orm/core 7.0.0-dev.33 → 7.0.0-dev.331

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,14 +0,0 @@
-import type { TransactionOptions } from '../enums.js';
-import type { ContextProvider } from '../typings.js';
-type TransactionalOptions<T> = TransactionOptions & {
-    context?: ContextProvider<T>;
-    contextName?: string;
-};
-/**
- * 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, contextName, ...txOptions } = options;
-            const em = (await resolveContextProvider(this, context))
-                || TransactionContext.getEntityManager(contextName)
-                || RequestContext.getEntityManager(contextName);
-            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';

package/entity/ArrayCollection.d.ts

@@ -1,118 +0,0 @@
-import { inspect } from 'node:util';
-import type { EntityDTO, EntityProperty, IPrimaryKey, Primary } from '../typings.js';
-import { Reference } from './Reference.js';
-export declare class ArrayCollection<T extends object, O extends object> {
-    readonly owner: O;
-    protected readonly items: Set<T>;
-    protected initialized: boolean;
-    protected dirty: boolean;
-    protected partial: boolean;
-    protected snapshot: T[] | undefined;
-    protected _count?: number;
-    private _property?;
-    constructor(owner: O, items?: T[]);
-    loadCount(): Promise<number>;
-    getItems(): T[];
-    toArray<TT extends T>(): EntityDTO<TT>[];
-    toJSON(): EntityDTO<T>[];
-    getIdentifiers<U extends IPrimaryKey = Primary<T> & IPrimaryKey>(field?: string | string[]): U[];
-    add(entity: T | Reference<T> | Iterable<T | Reference<T>>, ...entities: (T | Reference<T>)[]): void;
-    /**
-     * @internal
-     */
-    addWithoutPropagation(entity: T): void;
-    set(items: Iterable<T | Reference<T>>): void;
-    private compare;
-    /**
-     * @internal
-     */
-    hydrate(items: T[], forcePropagate?: boolean, partial?: boolean): void;
-    /**
-     * Remove specified item(s) from the collection. Note that removing item from collection does not necessarily imply deleting the target entity,
-     * it means we are disconnecting the relation - removing items from collection, not removing entities from database - `Collection.remove()`
-     * is not the same as `em.remove()`. If we want to delete the entity by removing it from collection, we need to enable `orphanRemoval: true`,
-     * which tells the ORM we don't want orphaned entities to exist, so we know those should be removed.
-     */
-    remove(entity: T | Reference<T> | Iterable<T | Reference<T>>, ...entities: (T | Reference<T>)[]): void;
-    /**
-     * Remove all items from the collection. Note that removing items from collection does not necessarily imply deleting the target entity,
-     * it means we are disconnecting the relation - removing items from collection, not removing entities from database - `Collection.remove()`
-     * is not the same as `em.remove()`. If we want to delete the entity by removing it from collection, we need to enable `orphanRemoval: true`,
-     * which tells the ORM we don't want orphaned entities to exist, so we know those should be removed.
-     */
-    removeAll(): void;
-    /**
-     * @internal
-     */
-    removeWithoutPropagation(entity: T): void;
-    contains(item: T | Reference<T>, check?: boolean): boolean;
-    /**
-     * Extracts a slice of the collection items starting at position start to end (exclusive) of the collection.
-     * If end is null it returns all elements from start to the end of the collection.
-     */
-    slice(start?: number, end?: number): T[];
-    /**
-     * Tests for the existence of an element that satisfies the given predicate.
-     */
-    exists(cb: (item: T) => boolean): boolean;
-    /**
-     * Returns the first element of this collection that satisfies the predicate.
-     */
-    find(cb: (item: T, index: number) => boolean): T | undefined;
-    /**
-     * Extracts a subset of the collection items.
-     */
-    filter(cb: (item: T, index: number) => boolean): T[];
-    /**
-     * Maps the collection items based on your provided mapper function.
-     */
-    map<R>(mapper: (item: T, index: number) => R): R[];
-    /**
-     * Maps the collection items based on your provided mapper function to a single object.
-     */
-    reduce<R>(cb: (obj: R, item: T, index: number) => R, initial?: R): R;
-    /**
-     * Maps the collection items to a dictionary, indexed by the key you specify.
-     * If there are more items with the same key, only the first one will be present.
-     */
-    indexBy<K1 extends keyof T, K2 extends keyof T = never>(key: K1): Record<T[K1] & PropertyKey, T>;
-    /**
-     * Maps the collection items to a dictionary, indexed by the key you specify.
-     * If there are more items with the same key, only the first one will be present.
-     */
-    indexBy<K1 extends keyof T, K2 extends keyof T = never>(key: K1, valueKey: K2): Record<T[K1] & PropertyKey, T[K2]>;
-    count(): number;
-    isInitialized(fully?: boolean): boolean;
-    isDirty(): boolean;
-    isPartial(): boolean;
-    isEmpty(): boolean;
-    setDirty(dirty?: boolean): void;
-    get length(): number;
-    [Symbol.iterator](): IterableIterator<T>;
-    /**
-     * @internal
-     */
-    takeSnapshot(forcePropagate?: boolean): void;
-    /**
-     * @internal
-     */
-    getSnapshot(): T[] | undefined;
-    /**
-     * @internal
-     */
-    get property(): EntityProperty;
-    /**
-     * @internal
-     */
-    set property(prop: EntityProperty);
-    protected propagate(item: T, method: 'add' | 'remove' | 'takeSnapshot'): void;
-    protected propagateToInverseSide(item: T, method: 'add' | 'remove' | 'takeSnapshot'): void;
-    protected propagateToOwningSide(item: T, method: 'add' | 'remove' | 'takeSnapshot'): void;
-    protected shouldPropagateToCollection(collection: ArrayCollection<O, T>, method: 'add' | 'remove' | 'takeSnapshot'): boolean;
-    protected incrementCount(value: number): void;
-    /** @ignore */
-    [inspect.custom](depth?: number): string;
-}
-export interface ArrayCollection<T, O> {
-    [k: number]: T;
-}