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

package/entity/ArrayCollection.js

@@ -1,407 +0,0 @@
-import { inspect } from 'node:util';
-import { Reference } from './Reference.js';
-import { helper, wrap } from './wrap.js';
-import { MetadataError, ValidationError } from '../errors.js';
-import { ReferenceKind } from '../enums.js';
-import { Utils } from '../utils/Utils.js';
-export class ArrayCollection {
-    owner;
-    items = new Set();
-    initialized = true;
-    dirty = false;
-    partial = false; // mark partially loaded collections, propagation is disabled for those
-    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;
-        /* v8 ignore next 5 */
-        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 => wrap(item).toJSON(...args));
-    }
-    toJSON() {
-        return this.toArray();
-    }
-    getIdentifiers(field) {
-        const items = this.getItems();
-        const targetMeta = this.property.targetMeta;
-        if (items.length === 0) {
-            return [];
-        }
-        field ??= targetMeta.compositePK ? targetMeta.primaryKeys : targetMeta.serializedPrimaryKey;
-        const cb = (i, f) => {
-            if (Utils.isEntity(i[f], true)) {
-                return wrap(i[f], true).getPrimaryKey();
-            }
-            return i[f];
-        };
-        return items.map(i => {
-            if (Array.isArray(field)) {
-                return field.map(f => cb(i, f));
-            }
-            return cb(i, field);
-        });
-    }
-    add(entity, ...entities) {
-        entities = Utils.asArray(entity).concat(entities);
-        for (const item of entities) {
-            const entity = 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.asArray(items).map(item => 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, partial) {
-        for (let i = 0; i < this.items.size; i++) {
-            delete this[i];
-        }
-        this.initialized = true;
-        this.partial = !!partial;
-        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.asArray(entity).concat(entities);
-        let modified = false;
-        for (const item of entities) {
-            if (!item) {
-                continue;
-            }
-            const entity = 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.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 (!helper(item).__initialized) {
-                return false;
-            }
-        }
-        return true;
-    }
-    isDirty() {
-        return this.dirty;
-    }
-    isPartial() {
-        return this.partial;
-    }
-    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 = wrap(this.owner, true).__meta;
-            /* v8 ignore next 3 */
-            if (!meta) {
-                throw 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 === ReferenceKind.MANY_TO_MANY) {
-            if (this.shouldPropagateToCollection(collection, method)) {
-                collection[method](this.owner);
-            }
-        }
-        else if (this.property.kind === ReferenceKind.ONE_TO_MANY && method !== 'takeSnapshot') {
-            const prop2 = this.property.targetMeta.properties[mappedBy];
-            const owner = prop2.mapToPk ? 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
-                helper(item).__pk = helper(item).getPrimaryKey();
-            }
-            if (!prop2.nullable && prop2.deleteRule !== 'cascade' && method === 'remove') {
-                if (!this.property.orphanRemoval) {
-                    throw ValidationError.cannotRemoveFromCollectionWithoutOrphanRemoval(this.owner, this.property);
-                }
-                return;
-            }
-            // skip if already propagated
-            if (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 */
-    [inspect.custom](depth = 2) {
-        const object = { ...this };
-        const hidden = ['items', 'owner', '_property', '_count', 'snapshot', '_populated', '_snapshot', '_lazyInitialized', '_em', 'readonly', 'partial'];
-        hidden.forEach(k => delete object[k]);
-        const ret = inspect(object, { depth });
-        const name = `${this.constructor.name}<${this.property?.type ?? 'unknown'}>`;
-        return ret === '[Object]' ? `[${name}]` : name + ' ' + ret;
-    }
-}
-Object.defineProperties(ArrayCollection.prototype, {
-    __collection: { value: true, enumerable: false, writable: false },
-});

package/entity/EntityValidator.d.ts

@@ -1,19 +0,0 @@
-import type { EntityData, EntityMetadata, EntityProperty, FilterQuery } from '../typings.js';
-export declare class EntityValidator {
-    private strict;
-    KNOWN_TYPES: Set<string>;
-    constructor(strict: boolean);
-    validate<T extends object>(entity: T, payload: any, meta: EntityMetadata<T>): void;
-    validateRequired<T extends object>(entity: T): void;
-    validateProperty<T extends object>(prop: EntityProperty, givenValue: any, entity: T): any;
-    validateParams(params: any, type?: string, field?: string): void;
-    validatePrimaryKey<T>(entity: EntityData<T>, meta: EntityMetadata<T>): void;
-    validateEmptyWhere<T>(where: FilterQuery<T>): void;
-    private getValue;
-    private setValue;
-    private validateCollection;
-    private fixTypes;
-    private fixDateType;
-    private fixNumberType;
-    private fixBooleanType;
-}

package/entity/EntityValidator.js

@@ -1,150 +0,0 @@
-import { ReferenceKind } from '../enums.js';
-import { Utils } from '../utils/Utils.js';
-import { ValidationError } from '../errors.js';
-import { helper } from './wrap.js';
-import { RawQueryFragment } from '../utils/RawQueryFragment.js';
-export class EntityValidator {
-    strict;
-    KNOWN_TYPES = new Set(['string', 'number', 'boolean', 'bigint', 'Uint8Array', 'Date', 'Buffer', 'RegExp']);
-    constructor(strict) {
-        this.strict = strict;
-    }
-    validate(entity, payload, meta) {
-        meta.props.forEach(prop => {
-            if (prop.inherited || (prop.persist === false && prop.userDefined !== false)) {
-                return;
-            }
-            if ([ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(prop.kind)) {
-                this.validateCollection(entity, prop);
-            }
-            const SCALAR_TYPES = ['string', 'number', 'boolean', 'Date'];
-            if (prop.kind !== ReferenceKind.SCALAR || !SCALAR_TYPES.includes(prop.type)) {
-                return;
-            }
-            const newValue = this.validateProperty(prop, this.getValue(payload, prop), entity);
-            if (this.getValue(payload, prop) === newValue) {
-                return;
-            }
-            this.setValue(payload, prop, newValue);
-            if (entity[prop.name]) {
-                entity[prop.name] = payload[prop.name];
-            }
-        });
-    }
-    validateRequired(entity) {
-        const wrapped = helper(entity);
-        for (const prop of wrapped.__meta.props) {
-            if (!prop.nullable &&
-                !prop.autoincrement &&
-                !prop.default &&
-                !prop.defaultRaw &&
-                !prop.onCreate &&
-                !prop.generated &&
-                !prop.embedded &&
-                ![ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(prop.kind) &&
-                prop.name !== wrapped.__meta.root.discriminatorColumn &&
-                prop.type.toLowerCase() !== 'objectid' &&
-                prop.persist !== false &&
-                entity[prop.name] == null) {
-                throw ValidationError.propertyRequired(entity, prop);
-            }
-        }
-    }
-    validateProperty(prop, givenValue, entity) {
-        if (givenValue == null || givenValue instanceof RawQueryFragment) {
-            return givenValue;
-        }
-        const expectedType = prop.runtimeType;
-        const propName = prop.embedded ? prop.name.replace(/~/g, '.') : prop.name;
-        let givenType = Utils.getObjectType(givenValue);
-        let ret = givenValue;
-        if (!this.strict) {
-            ret = this.fixTypes(expectedType, givenType, givenValue);
-            givenType = Utils.getObjectType(ret);
-        }
-        if (prop.enum && prop.items) {
-            /* v8 ignore next 3 */
-            if (!prop.items.some(it => it === givenValue)) {
-                throw ValidationError.fromWrongPropertyType(entity, propName, expectedType, givenType, givenValue);
-            }
-        }
-        else {
-            if (givenType !== expectedType && this.KNOWN_TYPES.has(expectedType)) {
-                throw ValidationError.fromWrongPropertyType(entity, propName, expectedType, givenType, givenValue);
-            }
-        }
-        return ret;
-    }
-    validateParams(params, type = 'search condition', field) {
-        if (Utils.isPrimaryKey(params) || Utils.isEntity(params)) {
-            return;
-        }
-        if (Array.isArray(params)) {
-            return params.forEach(item => this.validateParams(item, type, field));
-        }
-        if (Utils.isPlainObject(params)) {
-            Object.keys(params).forEach(k => {
-                this.validateParams(params[k], type, k);
-            });
-        }
-    }
-    validatePrimaryKey(entity, meta) {
-        const pkExists = meta.primaryKeys.every(pk => entity[pk] != null) || entity[meta.serializedPrimaryKey] != null;
-        if (!entity || !pkExists) {
-            throw ValidationError.fromMergeWithoutPK(meta);
-        }
-    }
-    validateEmptyWhere(where) {
-        if (Utils.isEmpty(where)) {
-            throw new Error(`You cannot call 'EntityManager.findOne()' with empty 'where' parameter`);
-        }
-    }
-    getValue(o, prop) {
-        if (prop.embedded && prop.embedded[0] in o) {
-            return o[prop.embedded[0]]?.[prop.embedded[1]];
-        }
-        return o[prop.name];
-    }
-    setValue(o, prop, v) {
-        /* v8 ignore next 3 */
-        if (prop.embedded && prop.embedded[0] in o) {
-            return o[prop.embedded[0]][prop.embedded[1]] = v;
-        }
-        o[prop.name] = v;
-    }
-    validateCollection(entity, prop) {
-        if (prop.hydrate !== false && helper(entity).__initialized && !entity[prop.name]) {
-            throw ValidationError.fromCollectionNotInitialized(entity, prop);
-        }
-    }
-    fixTypes(expectedType, givenType, givenValue) {
-        if (expectedType === 'Date' && ['string', 'number'].includes(givenType)) {
-            givenValue = this.fixDateType(givenValue);
-        }
-        if (expectedType === 'number' && givenType === 'string') {
-            givenValue = this.fixNumberType(givenValue);
-        }
-        if (expectedType === 'boolean' && givenType === 'number') {
-            givenValue = this.fixBooleanType(givenValue);
-        }
-        return givenValue;
-    }
-    fixDateType(givenValue) {
-        let date;
-        if (Utils.isString(givenValue) && givenValue.match(/^-?\d+(\.\d+)?$/)) {
-            date = new Date(+givenValue);
-        }
-        else {
-            date = new Date(givenValue);
-        }
-        return date.toString() !== 'Invalid Date' ? date : givenValue;
-    }
-    fixNumberType(givenValue) {
-        const num = +givenValue;
-        return '' + num === givenValue ? num : givenValue;
-    }
-    fixBooleanType(givenValue) {
-        const bool = !!givenValue;
-        return +bool === givenValue ? bool : givenValue;
-    }
-}

package/metadata/ReflectMetadataProvider.d.ts

@@ -1,8 +0,0 @@
-import 'reflect-metadata';
-import type { EntityMetadata, EntityProperty } from '../typings.js';
-import { MetadataProvider } from './MetadataProvider.js';
-export declare class ReflectMetadataProvider extends MetadataProvider {
-    loadEntityMetadata(meta: EntityMetadata, name: string): void;
-    protected initProperties(meta: EntityMetadata): void;
-    protected initPropertyType(meta: EntityMetadata, prop: EntityProperty): void;
-}

package/metadata/ReflectMetadataProvider.js

@@ -1,44 +0,0 @@
-import 'reflect-metadata';
-import { MetadataProvider } from './MetadataProvider.js';
-import { ReferenceKind } from '../enums.js';
-import { Utils } from '../utils/Utils.js';
-export class ReflectMetadataProvider extends MetadataProvider {
-    loadEntityMetadata(meta, name) {
-        this.initProperties(meta);
-    }
-    initProperties(meta) {
-        // load types and column names
-        for (const prop of meta.props) {
-            if (typeof prop.entity === 'string') {
-                prop.type = prop.entity;
-            }
-            else if (prop.entity) {
-                const tmp = prop.entity();
-                prop.type = Array.isArray(tmp) ? tmp.map(t => Utils.className(t)).sort().join(' | ') : Utils.className(tmp);
-            }
-            else {
-                this.initPropertyType(meta, prop);
-            }
-        }
-    }
-    initPropertyType(meta, prop) {
-        const type = Reflect.getMetadata('design:type', meta.prototype, prop.name);
-        if (!prop.type && (!type || (type === Object && prop.kind !== ReferenceKind.SCALAR)) && !(prop.enum && (prop.items?.length ?? 0) > 0)) {
-            throw new Error(`Please provide either 'type' or 'entity' attribute in ${meta.className}.${prop.name}. If you are using decorators, ensure you have 'emitDecoratorMetadata' enabled in your tsconfig.json.`);
-        }
-        // Force mapping to UnknownType which is a string when we see just `Object`, as that often means failed inference.
-        // This is to prevent defaulting to JSON column type, which can often be hard to revert and cause hard to understand issues with PKs.
-        // If there are explicitly provided `columnTypes`, we use those instead for the inference, this way
-        // we can have things like `columnType: 'timestamp'` be respected as `type: 'Date'`.
-        if (prop.kind === ReferenceKind.SCALAR && type === Object && !prop.columnTypes) {
-            prop.type ??= 'any';
-            return;
-        }
-        let typeName = type?.name;
-        if (typeName && ['string', 'number', 'boolean', 'array', 'object'].includes(typeName.toLowerCase())) {
-            typeName = typeName.toLowerCase();
-        }
-        prop.type ??= typeName;
-        prop.runtimeType ??= typeName;
-    }
-}

package/utils/resolveContextProvider.d.ts

@@ -1,10 +0,0 @@
-import { EntityManager } from '../EntityManager.js';
-import { MikroORM } from '../MikroORM.js';
-import type { ContextProvider, MaybePromise } from '../typings.js';
-/**
- * Find `EntityManager` in provided context, or else in instance's `orm` or `em` properties.
- */
-export declare function resolveContextProvider<T>(caller: T & {
-    orm?: MaybePromise<MikroORM>;
-    em?: MaybePromise<EntityManager>;
-}, provider?: ContextProvider<T>): Promise<EntityManager | undefined>;

package/utils/resolveContextProvider.js

@@ -1,28 +0,0 @@
-import { EntityRepository } from '../entity/EntityRepository.js';
-import { EntityManager } from '../EntityManager.js';
-import { MikroORM } from '../MikroORM.js';
-function getEntityManager(caller, context) {
-    if (context instanceof EntityManager) {
-        return context;
-    }
-    if (context instanceof EntityRepository) {
-        return context.getEntityManager();
-    }
-    if (context instanceof MikroORM) {
-        return context.em;
-    }
-    if (caller.em instanceof EntityManager) {
-        return caller.em;
-    }
-    if (caller.orm instanceof MikroORM) {
-        return caller.orm.em;
-    }
-    return undefined;
-}
-/**
- * Find `EntityManager` in provided context, or else in instance's `orm` or `em` properties.
- */
-export async function resolveContextProvider(caller, provider) {
-    const context = typeof provider === 'function' ? await provider(caller) : await provider;
-    return getEntityManager({ orm: await caller.orm, em: await caller.em }, context);
-}