@mikro-orm/core 7.0.0-dev.1 → 7.0.0-dev.100

package/decorators/Transactional.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Transactional = Transactional;
-const RequestContext_1 = require("../utils/RequestContext");
-const resolveContextProvider_1 = require("../utils/resolveContextProvider");
-const TransactionContext_1 = require("../utils/TransactionContext");
-/**
- * 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()`.
- */
-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 (0, resolveContextProvider_1.resolveContextProvider)(this, context)
-                || TransactionContext_1.TransactionContext.getEntityManager()
-                || RequestContext_1.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,59 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BeforeCreate = BeforeCreate;
-exports.AfterCreate = AfterCreate;
-exports.BeforeUpdate = BeforeUpdate;
-exports.AfterUpdate = AfterUpdate;
-exports.BeforeUpsert = BeforeUpsert;
-exports.AfterUpsert = AfterUpsert;
-exports.OnInit = OnInit;
-exports.OnLoad = OnLoad;
-exports.BeforeDelete = BeforeDelete;
-exports.AfterDelete = AfterDelete;
-const metadata_1 = require("../metadata");
-const enums_1 = require("../enums");
-function hook(type) {
-    return function (target, method) {
-        const meta = metadata_1.MetadataStorage.getMetadataFromDecorator(target.constructor);
-        if (!meta.hooks[type]) {
-            meta.hooks[type] = [];
-        }
-        meta.hooks[type].push(method);
-    };
-}
-function BeforeCreate() {
-    return hook(enums_1.EventType.beforeCreate);
-}
-function AfterCreate() {
-    return hook(enums_1.EventType.afterCreate);
-}
-function BeforeUpdate() {
-    return hook(enums_1.EventType.beforeUpdate);
-}
-function AfterUpdate() {
-    return hook(enums_1.EventType.afterUpdate);
-}
-function BeforeUpsert() {
-    return hook(enums_1.EventType.beforeUpsert);
-}
-function AfterUpsert() {
-    return hook(enums_1.EventType.afterUpsert);
-}
-function OnInit() {
-    return hook(enums_1.EventType.onInit);
-}
-function OnLoad() {
-    return hook(enums_1.EventType.onLoad);
-}
-/**
- * Called before deleting entity, but only when providing initialized entity to EM#remove()
- */
-function BeforeDelete() {
-    return hook(enums_1.EventType.beforeDelete);
-}
-/**
- * Called after deleting entity, but only when providing initialized entity to EM#remove()
- */
-function AfterDelete() {
-    return hook(enums_1.EventType.afterDelete);
-}

package/decorators/index.d.ts

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

package/decorators/index.js

@@ -1,36 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OneToMany = void 0;
-/* istanbul ignore file */
-__exportStar(require("./PrimaryKey"), exports);
-__exportStar(require("./Entity"), exports);
-__exportStar(require("./OneToOne"), exports);
-__exportStar(require("./ManyToOne"), exports);
-__exportStar(require("./ManyToMany"), exports);
-var OneToMany_1 = require("./OneToMany");
-Object.defineProperty(exports, "OneToMany", { enumerable: true, get: function () { return OneToMany_1.OneToMany; } });
-__exportStar(require("./Property"), exports);
-__exportStar(require("./Check"), exports);
-__exportStar(require("./Enum"), exports);
-__exportStar(require("./Formula"), exports);
-__exportStar(require("./Indexed"), exports);
-__exportStar(require("./Embeddable"), exports);
-__exportStar(require("./Embedded"), exports);
-__exportStar(require("./Filter"), exports);
-__exportStar(require("./CreateRequestContext"), exports);
-__exportStar(require("./hooks"), exports);
-__exportStar(require("./Transactional"), exports);

package/entity/ArrayCollection.d.ts

@@ -1,116 +0,0 @@
-import { inspect } from 'node:util';
-import type { EntityDTO, EntityProperty, IPrimaryKey, Primary } from '../typings';
-import { Reference } from './Reference';
-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 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): 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): 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;
-    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;
-}

package/entity/ArrayCollection.js

@@ -1,399 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ArrayCollection = void 0;
-const node_util_1 = require("node:util");
-const Reference_1 = require("./Reference");
-const wrap_1 = require("./wrap");
-const errors_1 = require("../errors");
-const enums_1 = require("../enums");
-const Utils_1 = require("../utils/Utils");
-class ArrayCollection {
-    owner;
-    items = new Set();
-    initialized = true;
-    dirty = false;
-    snapshot = []; // used to create a diff of the collection at commit time, undefined marks overridden values so we need to wipe when flushing
-    _count;
-    _property;
-    constructor(owner, items) {
-        this.owner = owner;
-        /* istanbul ignore next */
-        if (items) {
-            let i = 0;
-            this.items = new Set(items);
-            this.items.forEach(item => this[i++] = item);
-        }
-    }
-    async loadCount() {
-        return this.items.size;
-    }
-    getItems() {
-        return [...this.items];
-    }
-    toArray() {
-        if (this.items.size === 0) {
-            return [];
-        }
-        const meta = this.property.targetMeta;
-        const args = meta.toJsonParams.map(() => undefined);
-        return this.map(item => (0, wrap_1.wrap)(item).toJSON(...args));
-    }
-    toJSON() {
-        return this.toArray();
-    }
-    getIdentifiers(field) {
-        const items = this.getItems();
-        if (items.length === 0) {
-            return [];
-        }
-        field ??= this.property.targetMeta.serializedPrimaryKey;
-        return items.map(i => {
-            if (Utils_1.Utils.isEntity(i[field], true)) {
-                return (0, wrap_1.wrap)(i[field], true).getPrimaryKey();
-            }
-            return i[field];
-        });
-    }
-    add(entity, ...entities) {
-        entities = Utils_1.Utils.asArray(entity).concat(entities);
-        for (const item of entities) {
-            const entity = Reference_1.Reference.unwrapReference(item);
-            if (!this.contains(entity, false)) {
-                this.incrementCount(1);
-                this[this.items.size] = entity;
-                this.items.add(entity);
-                this.propagate(entity, 'add');
-            }
-        }
-    }
-    /**
-     * @internal
-     */
-    addWithoutPropagation(entity) {
-        if (!this.contains(entity, false)) {
-            this.incrementCount(1);
-            this[this.items.size] = entity;
-            this.items.add(entity);
-            this.dirty = true;
-        }
-    }
-    set(items) {
-        if (!this.initialized) {
-            this.initialized = true;
-            this.snapshot = undefined;
-        }
-        if (this.compare(Utils_1.Utils.asArray(items).map(item => Reference_1.Reference.unwrapReference(item)))) {
-            return;
-        }
-        this.remove(this.items);
-        this.add(items);
-    }
-    compare(items) {
-        if (items.length !== this.items.size) {
-            return false;
-        }
-        let idx = 0;
-        for (const item of this.items) {
-            if (item !== items[idx++]) {
-                return false;
-            }
-        }
-        return true;
-    }
-    /**
-     * @internal
-     */
-    hydrate(items, forcePropagate) {
-        for (let i = 0; i < this.items.size; i++) {
-            delete this[i];
-        }
-        this.initialized = true;
-        this.items.clear();
-        this._count = 0;
-        this.add(items);
-        this.takeSnapshot(forcePropagate);
-    }
-    /**
-     * 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, ...entities) {
-        entities = Utils_1.Utils.asArray(entity).concat(entities);
-        let modified = false;
-        for (const item of entities) {
-            if (!item) {
-                continue;
-            }
-            const entity = Reference_1.Reference.unwrapReference(item);
-            if (this.items.delete(entity)) {
-                this.incrementCount(-1);
-                delete this[this.items.size]; // remove last item
-                this.propagate(entity, 'remove');
-                modified = true;
-            }
-        }
-        if (modified) {
-            Object.assign(this, [...this.items]); // reassign array access
-        }
-    }
-    /**
-     * 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() {
-        if (!this.initialized) {
-            this.initialized = true;
-            this.snapshot = undefined;
-        }
-        this.remove(this.items);
-    }
-    /**
-     * @internal
-     */
-    removeWithoutPropagation(entity) {
-        if (!this.items.delete(entity)) {
-            return;
-        }
-        this.incrementCount(-1);
-        delete this[this.items.size];
-        Object.assign(this, [...this.items]);
-        this.dirty = true;
-    }
-    contains(item, check) {
-        const entity = Reference_1.Reference.unwrapReference(item);
-        return this.items.has(entity);
-    }
-    /**
-     * 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 = 0, end) {
-        let index = 0;
-        end ??= this.items.size;
-        const items = [];
-        for (const item of this.items) {
-            if (index === end) {
-                break;
-            }
-            if (index >= start && index < end) {
-                items.push(item);
-            }
-            index++;
-        }
-        return items;
-    }
-    /**
-     * Tests for the existence of an element that satisfies the given predicate.
-     */
-    exists(cb) {
-        for (const item of this.items) {
-            if (cb(item)) {
-                return true;
-            }
-        }
-        return false;
-    }
-    /**
-     * Returns the first element of this collection that satisfies the predicate.
-     */
-    find(cb) {
-        let index = 0;
-        for (const item of this.items) {
-            if (cb(item, index++)) {
-                return item;
-            }
-        }
-        return undefined;
-    }
-    /**
-     * Extracts a subset of the collection items.
-     */
-    filter(cb) {
-        const items = [];
-        let index = 0;
-        for (const item of this.items) {
-            if (cb(item, index++)) {
-                items.push(item);
-            }
-        }
-        return items;
-    }
-    /**
-     * Maps the collection items based on your provided mapper function.
-     */
-    map(mapper) {
-        const items = [];
-        let index = 0;
-        for (const item of this.items) {
-            items.push(mapper(item, index++));
-        }
-        return items;
-    }
-    /**
-     * Maps the collection items based on your provided mapper function to a single object.
-     */
-    reduce(cb, initial = {}) {
-        let index = 0;
-        for (const item of this.items) {
-            initial = cb(initial, item, index++);
-        }
-        return initial;
-    }
-    /**
-     * 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(key, valueKey) {
-        return this.reduce((obj, item) => {
-            obj[item[key]] ??= valueKey ? item[valueKey] : item;
-            return obj;
-        }, {});
-    }
-    count() {
-        return this.items.size;
-    }
-    isInitialized(fully = false) {
-        if (!this.initialized || !fully) {
-            return this.initialized;
-        }
-        for (const item of this.items) {
-            if (!(0, wrap_1.helper)(item).__initialized) {
-                return false;
-            }
-        }
-        return true;
-    }
-    isDirty() {
-        return this.dirty;
-    }
-    isEmpty() {
-        return this.count() === 0;
-    }
-    setDirty(dirty = true) {
-        this.dirty = dirty;
-    }
-    get length() {
-        return this.count();
-    }
-    *[Symbol.iterator]() {
-        for (const item of this.getItems()) {
-            yield item;
-        }
-    }
-    /**
-     * @internal
-     */
-    takeSnapshot(forcePropagate) {
-        this.snapshot = [...this.items];
-        this.setDirty(false);
-        if (this.property.owner || forcePropagate) {
-            this.items.forEach(item => {
-                this.propagate(item, 'takeSnapshot');
-            });
-        }
-    }
-    /**
-     * @internal
-     */
-    getSnapshot() {
-        return this.snapshot;
-    }
-    /**
-     * @internal
-     */
-    get property() {
-        if (!this._property) {
-            const meta = (0, wrap_1.wrap)(this.owner, true).__meta;
-            /* istanbul ignore if */
-            if (!meta) {
-                throw errors_1.MetadataError.fromUnknownEntity(this.owner.constructor.name, 'Collection.property getter, maybe you just forgot to initialize the ORM?');
-            }
-            this._property = meta.relations.find(prop => this.owner[prop.name] === this);
-        }
-        return this._property;
-    }
-    /**
-     * @internal
-     */
-    set property(prop) {
-        this._property = prop;
-    }
-    propagate(item, method) {
-        if (this.property.owner && this.property.inversedBy) {
-            this.propagateToInverseSide(item, method);
-        }
-        else if (!this.property.owner && this.property.mappedBy) {
-            this.propagateToOwningSide(item, method);
-        }
-    }
-    propagateToInverseSide(item, method) {
-        const collection = item[this.property.inversedBy];
-        if (this.shouldPropagateToCollection(collection, method)) {
-            method = method === 'takeSnapshot' ? method : (method + 'WithoutPropagation');
-            collection[method](this.owner);
-        }
-    }
-    propagateToOwningSide(item, method) {
-        const mappedBy = this.property.mappedBy;
-        const collection = item[mappedBy];
-        if (this.property.kind === enums_1.ReferenceKind.MANY_TO_MANY) {
-            if (this.shouldPropagateToCollection(collection, method)) {
-                collection[method](this.owner);
-            }
-        }
-        else if (this.property.kind === enums_1.ReferenceKind.ONE_TO_MANY && method !== 'takeSnapshot') {
-            const prop2 = this.property.targetMeta.properties[mappedBy];
-            const owner = prop2.mapToPk ? (0, wrap_1.helper)(this.owner).getPrimaryKey() : this.owner;
-            const value = method === 'add' ? owner : null;
-            if (this.property.orphanRemoval && method === 'remove') {
-                // cache the PK before we propagate, as its value might be needed when flushing
-                (0, wrap_1.helper)(item).__pk = (0, wrap_1.helper)(item).getPrimaryKey();
-            }
-            if (!prop2.nullable && prop2.deleteRule !== 'cascade' && method === 'remove') {
-                if (!this.property.orphanRemoval) {
-                    throw errors_1.ValidationError.cannotRemoveFromCollectionWithoutOrphanRemoval(this.owner, this.property);
-                }
-                return;
-            }
-            // skip if already propagated
-            if (Reference_1.Reference.unwrapReference(item[mappedBy]) !== value) {
-                item[mappedBy] = value;
-            }
-        }
-    }
-    shouldPropagateToCollection(collection, method) {
-        if (!collection) {
-            return false;
-        }
-        switch (method) {
-            case 'add':
-                return !collection.contains(this.owner, false);
-            case 'remove':
-                return collection.isInitialized() && collection.contains(this.owner, false);
-            case 'takeSnapshot':
-                return collection.isDirty();
-        }
-    }
-    incrementCount(value) {
-        if (typeof this._count === 'number' && this.initialized) {
-            this._count += value;
-        }
-    }
-    /** @ignore */
-    [node_util_1.inspect.custom](depth = 2) {
-        const object = { ...this };
-        const hidden = ['items', 'owner', '_property', '_count', 'snapshot', '_populated', '_snapshot', '_lazyInitialized', '_em', 'readonly'];
-        hidden.forEach(k => delete object[k]);
-        const ret = (0, node_util_1.inspect)(object, { depth });
-        const name = `${this.constructor.name}<${this.property?.type ?? 'unknown'}>`;
-        return ret === '[Object]' ? `[${name}]` : name + ' ' + ret;
-    }
-}
-exports.ArrayCollection = ArrayCollection;
-Object.defineProperties(ArrayCollection.prototype, {
-    __collection: { value: true, enumerable: false, writable: false },
-});