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

package/metadata/EntitySchema.js

@@ -34,29 +34,13 @@ export 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.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');
+        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.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) {
@@ -91,9 +75,10 @@ export 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) {
+        this.renameCompositeOptions(name, options);
         Utils.defaultValue(options, 'prefix', true);
         if (options.array) {
             options.object = true; // force object mode for arrays
@@ -114,6 +99,8 @@ export 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) {
@@ -123,6 +110,8 @@ export class EntitySchema {
         }
         if (options.owner) {
             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(ReferenceKind.MANY_TO_MANY, options);
         this.addProperty(name, type, prop);
@@ -135,8 +124,12 @@ export class EntitySchema {
         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.renameKey(prop, 'mappedBy', 'inversedBy');
+        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;
@@ -164,9 +157,7 @@ export class EntitySchema {
         this._meta.prototype = proto.prototype;
         this._meta.className = proto.name;
         if (!sameClass || !this._meta.constructorParams) {
-            const tokens = Utils.tokenize(proto);
-            this._meta.constructorParams = Utils.getParamNames(tokens, 'constructor');
-            this._meta.toJsonParams = Utils.getParamNames(tokens, 'toJSON').filter(p => p !== '...args');
+            this._meta.constructorParams = Utils.getConstructorParams(proto);
         }
         if (!this.internal) {
             EntitySchema.REGISTRY.set(proto, this);
@@ -181,6 +172,12 @@ export class EntitySchema {
     get name() {
         return this._meta.className;
     }
+    get tableName() {
+        return this._meta.tableName;
+    }
+    get properties() {
+        return this._meta.properties;
+    }
     /**
      * @internal
      */
@@ -266,7 +263,7 @@ export class EntitySchema {
     }
     normalizeType(options, type) {
         if ('entity' in options) {
-            if (Utils.isString(options.entity)) {
+            if (typeof options.entity === 'string') {
                 type = options.type = options.entity;
             }
             else if (options.entity) {
@@ -289,4 +286,25 @@ export class EntitySchema {
             ...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');
+    }
 }

package/metadata/MetadataDiscovery.d.ts

@@ -1,4 +1,4 @@
-import { type Constructor, EntityMetadata } from '../typings.js';
+import { type EntityClass, EntityMetadata } from '../typings.js';
 import type { Configuration } from '../utils/Configuration.js';
 import { MetadataStorage } from './MetadataStorage.js';
 import { EntitySchema } from './EntitySchema.js';
@@ -9,26 +9,25 @@ export declare class MetadataDiscovery {
     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(preferTs?: boolean): Promise<MetadataStorage>;
-    discoverSync(preferTs?: boolean): 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;
 }