@mikro-orm/core 7.0.0-dev.321 → 7.0.0-dev.323

package/metadata/MetadataStorage.d.ts

@@ -1,12 +1,8 @@
 import { type Dictionary, EntityMetadata, type EntityName } from '../typings.js';
 import type { EntityManager } from '../EntityManager.js';
 export declare class MetadataStorage {
+    #private;
     static readonly PATH_SYMBOL: unique symbol;
-    private static readonly metadata;
-    private readonly metadata;
-    private readonly idMap;
-    private readonly classNameMap;
-    private readonly uniqueNameMap;
     constructor(metadata?: Dictionary<EntityMetadata>);
     static getMetadata(): Dictionary<EntityMetadata>;
     static getMetadata<T = any>(entity: string, path: string): EntityMetadata<T>;

package/metadata/MetadataStorage.js

@@ -10,39 +10,39 @@ function getGlobalStorage(namespace) {
 }
 export class MetadataStorage {
     static PATH_SYMBOL = Symbol.for('@mikro-orm/core/MetadataStorage.PATH_SYMBOL');
-    static metadata = getGlobalStorage('metadata');
-    metadata = new Map();
-    idMap;
-    classNameMap;
-    uniqueNameMap;
+    static #metadata = getGlobalStorage('metadata');
+    #metadataMap = new Map();
+    #idMap;
+    #classNameMap;
+    #uniqueNameMap;
     constructor(metadata = {}) {
-        this.idMap = {};
-        this.uniqueNameMap = {};
-        this.classNameMap = Utils.copy(metadata, false);
-        for (const meta of Object.values(this.classNameMap)) {
-            this.idMap[meta._id] = meta;
-            this.uniqueNameMap[meta.uniqueName] = meta;
-            this.metadata.set(meta.class, meta);
+        this.#idMap = {};
+        this.#uniqueNameMap = {};
+        this.#classNameMap = Utils.copy(metadata, false);
+        for (const meta of Object.values(this.#classNameMap)) {
+            this.#idMap[meta._id] = meta;
+            this.#uniqueNameMap[meta.uniqueName] = meta;
+            this.#metadataMap.set(meta.class, meta);
         }
     }
     static getMetadata(entity, path) {
         const key = entity && path ? entity + '-' + Utils.hash(path) : null;
-        if (key && !MetadataStorage.metadata[key]) {
-            MetadataStorage.metadata[key] = new EntityMetadata({ className: entity, path });
+        if (key && !MetadataStorage.#metadata[key]) {
+            MetadataStorage.#metadata[key] = new EntityMetadata({ className: entity, path });
         }
         if (key) {
-            return MetadataStorage.metadata[key];
+            return MetadataStorage.#metadata[key];
         }
-        return MetadataStorage.metadata;
+        return MetadataStorage.#metadata;
     }
     static isKnownEntity(name) {
-        return !!Object.values(this.metadata).find(meta => meta.className === name);
+        return !!Object.values(this.#metadata).find(meta => meta.className === name);
     }
     static clear() {
-        Object.keys(this.metadata).forEach(k => delete this.metadata[k]);
+        Object.keys(this.#metadata).forEach(k => delete this.#metadata[k]);
     }
     getAll() {
-        return this.metadata;
+        return this.#metadataMap;
     }
     get(entityName, init = false) {
         const exists = this.find(entityName);
@@ -61,50 +61,50 @@ export class MetadataStorage {
         if (!entityName) {
             return;
         }
-        const meta = this.metadata.get(entityName);
+        const meta = this.#metadataMap.get(entityName);
         if (meta) {
             return meta;
         }
         if (entityName instanceof EntitySchema) {
-            return this.metadata.get(entityName.meta.class) ?? entityName.meta;
+            return this.#metadataMap.get(entityName.meta.class) ?? entityName.meta;
         }
-        return this.classNameMap[Utils.className(entityName)];
+        return this.#classNameMap[Utils.className(entityName)];
     }
     has(entityName) {
-        return this.metadata.has(entityName);
+        return this.#metadataMap.has(entityName);
     }
     set(entityName, meta) {
-        this.metadata.set(entityName, meta);
-        this.idMap[meta._id] = meta;
-        this.uniqueNameMap[meta.uniqueName] = meta;
-        this.classNameMap[Utils.className(entityName)] = meta;
+        this.#metadataMap.set(entityName, meta);
+        this.#idMap[meta._id] = meta;
+        this.#uniqueNameMap[meta.uniqueName] = meta;
+        this.#classNameMap[Utils.className(entityName)] = meta;
         return meta;
     }
     reset(entityName) {
         const meta = this.find(entityName);
         if (meta) {
-            this.metadata.delete(meta.class);
-            delete this.idMap[meta._id];
-            delete this.uniqueNameMap[meta.uniqueName];
-            delete this.classNameMap[meta.className];
+            this.#metadataMap.delete(meta.class);
+            delete this.#idMap[meta._id];
+            delete this.#uniqueNameMap[meta.uniqueName];
+            delete this.#classNameMap[meta.className];
         }
     }
     decorate(em) {
-        [...this.metadata.values()].filter(meta => meta.prototype).forEach(meta => EntityHelper.decorate(meta, em));
+        [...this.#metadataMap.values()].filter(meta => meta.prototype).forEach(meta => EntityHelper.decorate(meta, em));
     }
     *[Symbol.iterator]() {
-        for (const meta of this.metadata.values()) {
+        for (const meta of this.#metadataMap.values()) {
             yield meta;
         }
     }
     getById(id) {
-        return this.idMap[id];
+        return this.#idMap[id];
     }
     getByClassName(className, validate = true) {
-        return this.validate(this.classNameMap[className], className, validate);
+        return this.validate(this.#classNameMap[className], className, validate);
     }
     getByUniqueName(uniqueName, validate = true) {
-        return this.validate(this.uniqueNameMap[uniqueName], uniqueName, validate);
+        return this.validate(this.#uniqueNameMap[uniqueName], uniqueName, validate);
     }
     validate(meta, id, validate) {
         if (!meta && validate) {

package/naming-strategy/EntityCaseNamingStrategy.js

@@ -11,7 +11,7 @@ export class EntityCaseNamingStrategy extends AbstractNamingStrategy {
     }
     joinKeyColumnName(entityName, referencedColumnName, composite, tableName) {
         entityName = this.classToTableName(entityName, tableName);
-        const name = entityName.substr(0, 1).toLowerCase() + entityName.substr(1);
+        const name = entityName.substring(0, 1).toLowerCase() + entityName.substring(1);
         if (composite && referencedColumnName) {
             return name + '_' + referencedColumnName;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "7.0.0-dev.321",
+  "version": "7.0.0-dev.323",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "keywords": [
     "data-mapper",

package/serialization/EntitySerializer.js

@@ -36,7 +36,7 @@ export class EntitySerializer {
         const meta = wrapped.__meta;
         let contextCreated = false;
         if (!wrapped.__serializationContext.root) {
-            const root = new SerializationContext(wrapped.__config);
+            const root = new SerializationContext();
             SerializationContext.propagate(root, entity, (meta, prop) => meta.properties[prop]?.kind !== ReferenceKind.SCALAR);
             options.populate = (options.populate ? Utils.asArray(options.populate) : options.populate);
             contextCreated = true;

package/serialization/EntityTransformer.js

@@ -20,7 +20,7 @@ export class EntityTransformer {
             return entity;
         }
         if (!wrapped.__serializationContext.root) {
-            const root = new SerializationContext(wrapped.__config, wrapped.__serializationContext.populate, wrapped.__serializationContext.fields, wrapped.__serializationContext.exclude);
+            const root = new SerializationContext(wrapped.__serializationContext.populate, wrapped.__serializationContext.fields, wrapped.__serializationContext.exclude);
             SerializationContext.propagate(root, entity, isVisible);
             contextCreated = true;
         }
@@ -64,6 +64,9 @@ export class EntityTransformer {
                 if (!partiallyLoaded && !populated && !isPrimary) {
                     continue;
                 }
+                if (root.isExcluded(meta.class, prop) && !populated) {
+                    continue;
+                }
             }
             const cycle = root.visit(meta.class, prop);
             if (cycle && visited) {

package/serialization/SerializationContext.d.ts

@@ -1,19 +1,14 @@
 import type { AnyEntity, EntityMetadata, EntityName, PopulateOptions } from '../typings.js';
-import type { Configuration } from '../utils/Configuration.js';
 /**
  * Helper that allows to keep track of where we are currently at when serializing complex entity graph with cycles.
  * Before we process a property, we call `visit` that checks if it is not a cycle path (but allows to pass cycles that
  * are defined in populate hint). If not, we proceed and call `leave` afterwards.
  */
 export declare class SerializationContext<T extends object> {
-    private readonly config;
-    private readonly populate;
-    private readonly fields?;
-    private readonly exclude?;
+    #private;
     readonly path: [EntityName, string][];
     readonly visited: Set<Partial<any>>;
-    private entities;
-    constructor(config: Configuration, populate?: PopulateOptions<T>[], fields?: Set<string> | undefined, exclude?: string[] | undefined);
+    constructor(populate?: PopulateOptions<T>[], fields?: Set<string>, exclude?: readonly string[]);
     /**
      * Returns true when there is a cycle detected.
      */
@@ -25,6 +20,7 @@ export declare class SerializationContext<T extends object> {
      */
     static propagate(root: SerializationContext<any>, entity: AnyEntity, isVisible: (meta: EntityMetadata, prop: string) => boolean): void;
     isMarkedAsPopulated(entityName: EntityName, prop: string): boolean;
+    isExcluded(entityName: EntityName, prop: string): boolean;
     isPartiallyLoaded(entityName: EntityName, prop: string): boolean;
     private register;
 }

package/serialization/SerializationContext.js

@@ -6,18 +6,16 @@ import { helper } from '../entity/wrap.js';
  * are defined in populate hint). If not, we proceed and call `leave` afterwards.
  */
 export class SerializationContext {
-    config;
-    populate;
-    fields;
-    exclude;
     path = [];
     visited = new Set();
-    entities = new Set();
-    constructor(config, populate = [], fields, exclude) {
-        this.config = config;
-        this.populate = populate;
-        this.fields = fields;
-        this.exclude = exclude;
+    #entities = new Set();
+    #populate;
+    #fields;
+    #exclude;
+    constructor(populate = [], fields, exclude) {
+        this.#populate = populate;
+        this.#fields = fields;
+        this.#exclude = exclude;
     }
     /**
      * Returns true when there is a cycle detected.
@@ -42,7 +40,7 @@ export class SerializationContext {
         }
     }
     close() {
-        for (const entity of this.entities) {
+        for (const entity of this.#entities) {
             delete helper(entity).__serializationContext.root;
         }
     }
@@ -73,7 +71,7 @@ export class SerializationContext {
         }
     }
     isMarkedAsPopulated(entityName, prop) {
-        let populate = this.populate ?? [];
+        let populate = this.#populate ?? [];
         for (const segment of this.path) {
             const hints = populate.filter(p => p.field === segment[1]);
             if (hints.length > 0) {
@@ -92,11 +90,18 @@ export class SerializationContext {
         }
         return !!populate?.some(p => p.field === prop);
     }
+    isExcluded(entityName, prop) {
+        if (!this.#exclude || this.#exclude.length === 0) {
+            return false;
+        }
+        const fullPath = this.path.map(segment => segment[1] + '.').join('') + prop;
+        return this.#exclude.includes(fullPath);
+    }
     isPartiallyLoaded(entityName, prop) {
-        if (!this.fields) {
+        if (!this.#fields) {
             return true;
         }
-        let fields = [...this.fields];
+        let fields = [...this.#fields];
         for (const segment of this.path) {
             /* v8 ignore next */
             if (fields.length === 0) {
@@ -110,6 +115,6 @@ export class SerializationContext {
     }
     register(entity) {
         helper(entity).__serializationContext.root = this;
-        this.entities.add(entity);
+        this.#entities.add(entity);
     }
 }

package/unit-of-work/ChangeSetComputer.d.ts

@@ -3,12 +3,7 @@ import { ChangeSet } from './ChangeSet.js';
 import { type Collection } from '../entity/Collection.js';
 import type { EntityManager } from '../EntityManager.js';
 export declare class ChangeSetComputer {
-    private readonly em;
-    private readonly collectionUpdates;
-    private readonly comparator;
-    private readonly metadata;
-    private readonly platform;
-    private readonly config;
+    #private;
     constructor(em: EntityManager, collectionUpdates: Set<Collection<AnyEntity>>);
     computeChangeSet<T extends object>(entity: T): ChangeSet<T> | null;
     /**

package/unit-of-work/ChangeSetComputer.js

@@ -7,22 +7,22 @@ import { Reference } from '../entity/Reference.js';
 import { PolymorphicRef } from '../entity/PolymorphicRef.js';
 import { ReferenceKind } from '../enums.js';
 export class ChangeSetComputer {
-    em;
-    collectionUpdates;
-    comparator;
-    metadata;
-    platform;
-    config;
+    #comparator;
+    #metadata;
+    #platform;
+    #config;
+    #em;
+    #collectionUpdates;
     constructor(em, collectionUpdates) {
-        this.em = em;
-        this.collectionUpdates = collectionUpdates;
-        this.config = this.em.config;
-        this.metadata = this.em.getMetadata();
-        this.platform = this.em.getPlatform();
-        this.comparator = this.config.getComparator(this.metadata);
+        this.#em = em;
+        this.#collectionUpdates = collectionUpdates;
+        this.#config = this.#em.config;
+        this.#metadata = this.#em.getMetadata();
+        this.#platform = this.#em.getPlatform();
+        this.#comparator = this.#config.getComparator(this.#metadata);
     }
     computeChangeSet(entity) {
-        const meta = this.metadata.get(entity.constructor);
+        const meta = this.#metadata.get(entity.constructor);
         if (meta.readonly) {
             return null;
         }
@@ -38,7 +38,7 @@ export class ChangeSetComputer {
             }
         }
         if (type === ChangeSetType.UPDATE && !wrapped.__initialized) {
-            const data = this.comparator.prepareEntity(entity);
+            const data = this.#comparator.prepareEntity(entity);
             if (Utils.equals(data, wrapped.__originalEntityData)) {
                 return null;
             }
@@ -79,11 +79,11 @@ export class ChangeSetComputer {
             type === ChangeSetType.CREATE &&
             (entity[prop.name] == null ||
                 (Utils.isScalarReference(entity[prop.name]) && entity[prop.name].unwrap() == null))) {
-            entity[prop.name] = prop.onCreate(entity, this.em);
+            entity[prop.name] = prop.onCreate(entity, this.#em);
         }
         if (prop.onUpdate && type === ChangeSetType.UPDATE) {
             const pairs = map.get(entity) ?? [];
-            pairs.push([prop.name, prop.onUpdate(entity, this.em)]);
+            pairs.push([prop.name, prop.onUpdate(entity, this.#em)]);
             map.set(entity, pairs);
         }
         if (prop.kind === ReferenceKind.EMBEDDED && entity[prop.name]) {
@@ -93,7 +93,7 @@ export class ChangeSetComputer {
         }
     }
     computePayload(entity, ignoreUndefined = false) {
-        const data = this.comparator.prepareEntity(entity);
+        const data = this.#comparator.prepareEntity(entity);
         const wrapped = helper(entity);
         const entityName = wrapped.__meta.class;
         const originalEntityData = wrapped.__originalEntityData;
@@ -104,7 +104,7 @@ export class ChangeSetComputer {
             return data;
         }
         if (originalEntityData) {
-            const comparator = this.comparator.getEntityComparator(entityName);
+            const comparator = this.#comparator.getEntityComparator(entityName);
             const diff = comparator(originalEntityData, data);
             if (ignoreUndefined) {
                 Utils.keys(diff)
@@ -144,7 +144,7 @@ export class ChangeSetComputer {
                 if (prop.targetKey && prop.targetMeta) {
                     const targetProp = prop.targetMeta.properties[prop.targetKey];
                     if (targetProp?.customType) {
-                        value = targetProp.customType.convertToDatabaseValue(value, this.platform, { mode: 'serialization' });
+                        value = targetProp.customType.convertToDatabaseValue(value, this.#platform, { mode: 'serialization' });
                     }
                 }
                 if (prop.polymorphic) {
@@ -163,9 +163,9 @@ export class ChangeSetComputer {
             return;
         }
         if (target.isDirty()) {
-            this.collectionUpdates.add(target);
+            this.#collectionUpdates.add(target);
         }
-        if (prop.owner && !this.platform.usesPivotTable()) {
+        if (prop.owner && !this.#platform.usesPivotTable()) {
             changeSet.payload[prop.name] = target.getItems(false).map((item) => {
                 return item.__helper.__identifier ?? item.__helper.getPrimaryKey();
             });

package/unit-of-work/ChangeSetPersister.d.ts

@@ -3,15 +3,7 @@ import { type ChangeSet } from './ChangeSet.js';
 import type { DriverMethodOptions } from '../drivers/IDatabaseDriver.js';
 import type { EntityManager } from '../EntityManager.js';
 export declare class ChangeSetPersister {
-    private readonly em;
-    private readonly platform;
-    private readonly comparator;
-    private readonly usesReturningStatement;
-    private readonly driver;
-    private readonly metadata;
-    private readonly hydrator;
-    private readonly factory;
-    private readonly config;
+    #private;
     constructor(em: EntityManager);
     executeInserts<T extends object>(changeSets: ChangeSet<T>[], options?: DriverMethodOptions, withSchema?: boolean): Promise<void>;
     executeUpdates<T extends object>(changeSets: ChangeSet<T>[], batched: boolean, options?: DriverMethodOptions, withSchema?: boolean): Promise<void>;