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

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