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

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);
@@ -37,29 +34,13 @@ class EntitySchema {
         return schema;
     }
     addProperty(name, type, options = {}) {
-        const rename = (data, from, to) => {
-            if (from in options && !(to in options)) {
-                // @ts-ignore
-                options[to] = [options[from]];
-                // @ts-ignore
-                delete options[from];
-            }
-        };
-        if (name !== options.name) {
-            utils_1.Utils.renameKey(options, 'name', 'fieldName');
-        }
-        rename(options, 'fieldName', 'fieldNames');
-        rename(options, 'ref', 'ref');
-        rename(options, 'joinColumn', 'joinColumns');
-        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)) {
+        this.renameCompositeOptions(name, options);
+        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)) {
-            const formula = prop.formula; // tmp var is needed here
+        if (typeof prop.formula === 'string') {
+            const formula = prop.formula;
             prop.formula = () => formula;
         }
         if (prop.formula) {
@@ -69,11 +50,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 };
@@ -94,22 +75,23 @@ class EntitySchema {
     }
     addSerializedPrimaryKey(name, type, options = {}) {
         this._meta.serializedPrimaryKey = name;
-        this.addProperty(name, type, options);
+        this.addProperty(name, type, { serializedPrimaryKey: true, ...options });
     }
     addEmbedded(name, options) {
-        utils_1.Utils.defaultValue(options, 'prefix', true);
+        this.renameCompositeOptions(name, options);
+        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;
@@ -117,6 +99,8 @@ class EntitySchema {
         if (prop.fieldNames && !prop.joinColumns) {
             prop.joinColumns = prop.fieldNames;
         }
+        // By default, the foreign key constraint is created on the relation
+        Utils.defaultValue(prop, 'createForeignKeyConstraint', true);
         this.addProperty(name, type, prop);
     }
     addManyToMany(name, type, options) {
@@ -125,21 +109,27 @@ class EntitySchema {
             options.owner = true;
         }
         if (options.owner) {
-            utils_1.Utils.renameKey(options, 'mappedBy', 'inversedBy');
+            Utils.renameKey(options, 'mappedBy', 'inversedBy');
+            // By default, the foreign key constraint is created on the relation
+            Utils.defaultValue(options, 'createForeignKeyConstraint', true);
         }
-        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);
-        if (prop.owner && options.mappedBy) {
-            utils_1.Utils.renameKey(prop, 'mappedBy', 'inversedBy');
+        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) {
+            if (options.mappedBy) {
+                Utils.renameKey(prop, 'mappedBy', 'inversedBy');
+            }
+            // By default, the foreign key constraint is created on the relation
+            Utils.defaultValue(prop, 'createForeignKeyConstraint', true);
         }
         if (prop.joinColumns && !prop.fieldNames) {
             prop.fieldNames = prop.joinColumns;
@@ -167,14 +157,12 @@ 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');
+            this._meta.constructorParams = Utils.getConstructorParams(proto);
         }
         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;
         }
     }
@@ -184,6 +172,12 @@ class EntitySchema {
     get name() {
         return this._meta.className;
     }
+    get tableName() {
+        return this._meta.tableName;
+    }
+    get properties() {
+        return this._meta.properties;
+    }
     /**
      * @internal
      */
@@ -208,29 +202,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 +251,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 +263,12 @@ class EntitySchema {
     }
     normalizeType(options, type) {
         if ('entity' in options) {
-            if (utils_1.Utils.isString(options.entity)) {
+            if (typeof options.entity === 'string') {
                 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 +282,29 @@ class EntitySchema {
     createProperty(kind, options) {
         return {
             kind,
-            cascade: [enums_1.Cascade.PERSIST],
+            cascade: [Cascade.PERSIST],
             ...options,
         };
     }
+    rename(data, from, to) {
+        if (from in data && !(to in data)) {
+            // @ts-ignore
+            data[to] = [data[from]];
+            // @ts-ignore
+            delete data[from];
+        }
+    }
+    renameCompositeOptions(name, options = {}) {
+        if (name !== options.name && !options.fieldNames) {
+            Utils.renameKey(options, 'name', 'fieldName');
+        }
+        else if (options.name && (options.fieldNames?.length ?? 0) > 1) {
+            delete options.name;
+        }
+        this.rename(options, 'fieldName', 'fieldNames');
+        this.rename(options, 'joinColumn', 'joinColumns');
+        this.rename(options, 'inverseJoinColumn', 'inverseJoinColumns');
+        this.rename(options, 'referenceColumnName', 'referencedColumnNames');
+        this.rename(options, 'columnType', 'columnTypes');
+    }
 }
-exports.EntitySchema = EntitySchema;

package/metadata/MetadataDiscovery.d.ts

@@ -1,34 +1,33 @@
-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 EntityClass, 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;
     private readonly config;
     private readonly namingStrategy;
     private readonly metadataProvider;
-    private readonly cache;
     private readonly logger;
     private readonly schemaHelper;
     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(): MetadataStorage;
+    validateDiscovered(metadata: EntityMetadata[]): void;
     private mapDiscoveredEntities;
+    private initAccessors;
     processDiscoveredEntities(discovered: EntityMetadata[]): EntityMetadata[];
     private findEntities;
     private discoverMissingTargets;
     private tryDiscoverTargets;
-    private discoverDirectories;
-    discoverReferences<T>(refs: (Constructor<T> | EntitySchema<T>)[]): EntityMetadata<T>[];
+    discoverReferences<T>(refs: Iterable<EntityClass<T> | EntitySchema<T>>, validate?: boolean): EntityMetadata<T>[];
     reset(className: string): void;
-    private prepare;
     private getSchema;
+    private getRootEntity;
     private discoverEntity;
-    private saveToCache;
     private initNullability;
     private applyNamingStrategy;
     private initOwnColumns;
@@ -54,7 +53,6 @@ export declare class MetadataDiscovery {
     private initAutoincrement;
     private initCheckConstraints;
     private initGeneratedColumn;
-    private createColumnMappingObject;
     private getDefaultVersionValue;
     private inferDefaultValue;
     private initDefaultValue;
@@ -67,6 +65,5 @@ export declare class MetadataDiscovery {
     private getPrefix;
     private initUnsigned;
     private initIndexes;
-    private getEntityClassOrSchema;
     private shouldForceConstructorUsage;
 }