@mikro-orm/core 7.0.0-dev.0 → 7.0.0-dev.2

package/metadata/EntitySchema.js

@@ -1,19 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntitySchema = void 0;
-const typings_1 = require("../typings");
-const BaseEntity_1 = require("../entity/BaseEntity");
-const enums_1 = require("../enums");
-const types_1 = require("../types");
-const utils_1 = require("../utils");
-const EnumArrayType_1 = require("../types/EnumArrayType");
-class EntitySchema {
+import { EntityMetadata, } from '../typings.js';
+import { BaseEntity } from '../entity/BaseEntity.js';
+import { Cascade, ReferenceKind } from '../enums.js';
+import { Type } from '../types/Type.js';
+import { Utils } from '../utils/Utils.js';
+import { EnumArrayType } from '../types/EnumArrayType.js';
+export class EntitySchema {
     /**
      * When schema links the entity class via `class` option, this registry allows the lookup from opposite side,
      * so we can use the class in `entities` option just like the EntitySchema instance.
      */
     static REGISTRY = new Map();
-    _meta = new typings_1.EntityMetadata();
+    _meta = new EntityMetadata();
     internal = false;
     initialized = false;
     constructor(meta) {
@@ -25,7 +22,7 @@ class EntitySchema {
             EntitySchema.REGISTRY.set(meta.class, this);
         }
         if (meta.tableName || meta.collection) {
-            utils_1.Utils.renameKey(meta, 'tableName', 'collection');
+            Utils.renameKey(meta, 'tableName', 'collection');
             meta.tableName = meta.collection;
         }
         Object.assign(this._meta, { className: meta.name }, meta);
@@ -46,7 +43,7 @@ class EntitySchema {
             }
         };
         if (name !== options.name) {
-            utils_1.Utils.renameKey(options, 'name', 'fieldName');
+            Utils.renameKey(options, 'name', 'fieldName');
         }
         rename(options, 'fieldName', 'fieldNames');
         rename(options, 'ref', 'ref');
@@ -54,11 +51,11 @@ class EntitySchema {
         rename(options, 'inverseJoinColumn', 'inverseJoinColumns');
         rename(options, 'referenceColumnName', 'referencedColumnNames');
         rename(options, 'columnType', 'columnTypes');
-        const prop = { name, kind: enums_1.ReferenceKind.SCALAR, ...options, type: this.normalizeType(options, type) };
-        if (type && types_1.Type.isMappedType(type.prototype)) {
+        const prop = { name, kind: ReferenceKind.SCALAR, ...options, type: this.normalizeType(options, type) };
+        if (type && Type.isMappedType(type.prototype)) {
             prop.type = type;
         }
-        if (utils_1.Utils.isString(prop.formula)) {
+        if (Utils.isString(prop.formula)) {
             const formula = prop.formula; // tmp var is needed here
             prop.formula = () => formula;
         }
@@ -69,11 +66,11 @@ class EntitySchema {
     }
     addEnum(name, type, options = {}) {
         if (options.items instanceof Function) {
-            options.items = utils_1.Utils.extractEnumValues(options.items());
+            options.items = Utils.extractEnumValues(options.items());
         }
         // enum arrays are simple numeric/string arrays, the constraint is enforced in the custom type only
         if (options.array && !options.type) {
-            options.type = new EnumArrayType_1.EnumArrayType(`${this._meta.className}.${name}`, options.items);
+            options.type = new EnumArrayType(`${this._meta.className}.${name}`, options.items);
             options.enum = false;
         }
         const prop = { enum: true, ...options };
@@ -97,19 +94,19 @@ class EntitySchema {
         this.addProperty(name, type, options);
     }
     addEmbedded(name, options) {
-        utils_1.Utils.defaultValue(options, 'prefix', true);
+        Utils.defaultValue(options, 'prefix', true);
         if (options.array) {
             options.object = true; // force object mode for arrays
         }
         this._meta.properties[name] = {
             name,
             type: this.normalizeType(options),
-            kind: enums_1.ReferenceKind.EMBEDDED,
+            kind: ReferenceKind.EMBEDDED,
             ...options,
         };
     }
     addManyToOne(name, type, options) {
-        const prop = this.createProperty(enums_1.ReferenceKind.MANY_TO_ONE, options);
+        const prop = this.createProperty(ReferenceKind.MANY_TO_ONE, options);
         prop.owner = true;
         if (prop.joinColumns && !prop.fieldNames) {
             prop.fieldNames = prop.joinColumns;
@@ -125,21 +122,21 @@ class EntitySchema {
             options.owner = true;
         }
         if (options.owner) {
-            utils_1.Utils.renameKey(options, 'mappedBy', 'inversedBy');
+            Utils.renameKey(options, 'mappedBy', 'inversedBy');
         }
-        const prop = this.createProperty(enums_1.ReferenceKind.MANY_TO_MANY, options);
+        const prop = this.createProperty(ReferenceKind.MANY_TO_MANY, options);
         this.addProperty(name, type, prop);
     }
     addOneToMany(name, type, options) {
-        const prop = this.createProperty(enums_1.ReferenceKind.ONE_TO_MANY, options);
+        const prop = this.createProperty(ReferenceKind.ONE_TO_MANY, options);
         this.addProperty(name, type, prop);
     }
     addOneToOne(name, type, options) {
-        const prop = this.createProperty(enums_1.ReferenceKind.ONE_TO_ONE, options);
-        utils_1.Utils.defaultValue(prop, 'owner', !!prop.inversedBy || !prop.mappedBy);
-        utils_1.Utils.defaultValue(prop, 'unique', prop.owner);
+        const prop = this.createProperty(ReferenceKind.ONE_TO_ONE, options);
+        Utils.defaultValue(prop, 'owner', !!prop.inversedBy || !prop.mappedBy);
+        Utils.defaultValue(prop, 'unique', prop.owner);
         if (prop.owner && options.mappedBy) {
-            utils_1.Utils.renameKey(prop, 'mappedBy', 'inversedBy');
+            Utils.renameKey(prop, 'mappedBy', 'inversedBy');
         }
         if (prop.joinColumns && !prop.fieldNames) {
             prop.fieldNames = prop.joinColumns;
@@ -167,14 +164,14 @@ class EntitySchema {
         this._meta.prototype = proto.prototype;
         this._meta.className = proto.name;
         if (!sameClass || !this._meta.constructorParams) {
-            const tokens = utils_1.Utils.tokenize(proto);
-            this._meta.constructorParams = utils_1.Utils.getParamNames(tokens, 'constructor');
-            this._meta.toJsonParams = utils_1.Utils.getParamNames(tokens, 'toJSON').filter(p => p !== '...args');
+            const tokens = Utils.tokenize(proto);
+            this._meta.constructorParams = Utils.getParamNames(tokens, 'constructor');
+            this._meta.toJsonParams = Utils.getParamNames(tokens, 'toJSON').filter(p => p !== '...args');
         }
         if (!this.internal) {
             EntitySchema.REGISTRY.set(proto, this);
         }
-        if (Object.getPrototypeOf(proto) !== BaseEntity_1.BaseEntity) {
+        if (Object.getPrototypeOf(proto) !== BaseEntity) {
             this._meta.extends = this._meta.extends || Object.getPrototypeOf(proto).name || undefined;
         }
     }
@@ -208,29 +205,29 @@ class EntitySchema {
         this.initProperties();
         this.initPrimaryKeys();
         this._meta.props = Object.values(this._meta.properties);
-        this._meta.relations = this._meta.props.filter(prop => typeof prop.kind !== 'undefined' && prop.kind !== enums_1.ReferenceKind.SCALAR && prop.kind !== enums_1.ReferenceKind.EMBEDDED);
+        this._meta.relations = this._meta.props.filter(prop => typeof prop.kind !== 'undefined' && prop.kind !== ReferenceKind.SCALAR && prop.kind !== ReferenceKind.EMBEDDED);
         this.initialized = true;
         return this;
     }
     initProperties() {
-        utils_1.Utils.entries(this._meta.properties).forEach(([name, options]) => {
-            if (types_1.Type.isMappedType(options.type)) {
+        Utils.entries(this._meta.properties).forEach(([name, options]) => {
+            if (Type.isMappedType(options.type)) {
                 options.type ??= options.type.constructor.name;
             }
             switch (options.kind) {
-                case enums_1.ReferenceKind.ONE_TO_ONE:
+                case ReferenceKind.ONE_TO_ONE:
                     this.addOneToOne(name, options.type, options);
                     break;
-                case enums_1.ReferenceKind.ONE_TO_MANY:
+                case ReferenceKind.ONE_TO_MANY:
                     this.addOneToMany(name, options.type, options);
                     break;
-                case enums_1.ReferenceKind.MANY_TO_ONE:
+                case ReferenceKind.MANY_TO_ONE:
                     this.addManyToOne(name, options.type, options);
                     break;
-                case enums_1.ReferenceKind.MANY_TO_MANY:
+                case ReferenceKind.MANY_TO_MANY:
                     this.addManyToMany(name, options.type, options);
                     break;
-                case enums_1.ReferenceKind.EMBEDDED:
+                case ReferenceKind.EMBEDDED:
                     this.addEmbedded(name, options);
                     break;
                 default:
@@ -257,7 +254,7 @@ class EntitySchema {
         if (pks.length > 0) {
             this._meta.primaryKeys = pks.map(prop => prop.name);
             this._meta.compositePK = pks.length > 1;
-            this._meta.simplePK = !this._meta.compositePK && pks[0].kind === enums_1.ReferenceKind.SCALAR && !pks[0].customType;
+            this._meta.simplePK = !this._meta.compositePK && pks[0].kind === ReferenceKind.SCALAR && !pks[0].customType;
         }
         if (pks.length === 1 && ['number', 'bigint'].includes(pks[0].type)) {
             pks[0].autoincrement ??= true;
@@ -269,12 +266,12 @@ class EntitySchema {
     }
     normalizeType(options, type) {
         if ('entity' in options) {
-            if (utils_1.Utils.isString(options.entity)) {
+            if (Utils.isString(options.entity)) {
                 type = options.type = options.entity;
             }
             else if (options.entity) {
                 const tmp = options.entity();
-                type = options.type = Array.isArray(tmp) ? tmp.map(t => utils_1.Utils.className(t)).sort().join(' | ') : utils_1.Utils.className(tmp);
+                type = options.type = Array.isArray(tmp) ? tmp.map(t => Utils.className(t)).sort().join(' | ') : Utils.className(tmp);
             }
         }
         if (type instanceof Function) {
@@ -288,9 +285,8 @@ class EntitySchema {
     createProperty(kind, options) {
         return {
             kind,
-            cascade: [enums_1.Cascade.PERSIST],
+            cascade: [Cascade.PERSIST],
             ...options,
         };
     }
 }
-exports.EntitySchema = EntitySchema;

package/metadata/MetadataDiscovery.d.ts

@@ -1,8 +1,8 @@
-import { type Constructor, EntityMetadata } from '../typings';
-import type { Configuration } from '../utils/Configuration';
-import { MetadataStorage } from './MetadataStorage';
-import { EntitySchema } from './EntitySchema';
-import type { Platform } from '../platforms';
+import { type Constructor, EntityMetadata } from '../typings.js';
+import type { Configuration } from '../utils/Configuration.js';
+import { MetadataStorage } from './MetadataStorage.js';
+import { EntitySchema } from './EntitySchema.js';
+import type { Platform } from '../platforms/Platform.js';
 export declare class MetadataDiscovery {
     private readonly metadata;
     private readonly platform;
@@ -15,8 +15,8 @@ export declare class MetadataDiscovery {
     private readonly validator;
     private readonly discovered;
     constructor(metadata: MetadataStorage, platform: Platform, config: Configuration);
-    discover(preferTsNode?: boolean): Promise<MetadataStorage>;
-    discoverSync(preferTsNode?: boolean): MetadataStorage;
+    discover(preferTs?: boolean): Promise<MetadataStorage>;
+    discoverSync(preferTs?: boolean): MetadataStorage;
     private mapDiscoveredEntities;
     processDiscoveredEntities(discovered: EntityMetadata[]): EntityMetadata[];
     private findEntities;