@mikro-orm/core 7.0.0-dev.12 → 7.0.0-dev.121

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