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

package/MikroORM.d.ts

@@ -35,15 +35,13 @@ export declare function loadOptionalDependencies(options: Options): Promise<void
  * ```
  */
 export declare class MikroORM<Driver extends IDatabaseDriver = IDatabaseDriver, EM extends Driver[typeof EntityManagerType] & EntityManager<Driver> = Driver[typeof EntityManagerType] & EntityManager<Driver>, Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]> {
+    #private;
     /** The global EntityManager instance. If you are using `RequestContext` helper, it will automatically pick the request specific context under the hood */
     em: EM & {
         '~entities'?: Entities;
     };
     readonly driver: Driver;
     readonly config: Configuration<Driver>;
-    private metadata;
-    private readonly logger;
-    private readonly discovery;
     /**
      * Initialize the ORM, load entity metadata, create EntityManager and connect to the database.
      * If you omit the `options` parameter, your CLI config will be used.

package/MikroORM.js

@@ -74,9 +74,9 @@ export class MikroORM {
     em;
     driver;
     config;
-    metadata;
-    logger;
-    discovery;
+    #metadata;
+    #logger;
+    #discovery;
     /**
      * Initialize the ORM, load entity metadata, create EntityManager and connect to the database.
      * If you omit the `options` parameter, your CLI config will be used.
@@ -92,7 +92,7 @@ export class MikroORM {
         await loadOptionalDependencies(options);
         const orm = new this(options);
         const preferTs = orm.config.get('preferTs', Utils.detectTypeScriptSupport());
-        orm.metadata = await orm.discovery.discover(preferTs);
+        orm.#metadata = await orm.#discovery.discover(preferTs);
         orm.createEntityManager();
         return orm;
     }
@@ -108,15 +108,15 @@ export class MikroORM {
         this.config = new Configuration(options);
         const discovery = this.config.get('discovery');
         this.driver = this.config.getDriver();
-        this.logger = this.config.getLogger();
-        this.logger.log('info', `MikroORM version: ${colors.green(Utils.getORMVersion())}`);
-        this.discovery = new MetadataDiscovery(new MetadataStorage(), this.driver.getPlatform(), this.config);
+        this.#logger = this.config.getLogger();
+        this.#logger.log('info', `MikroORM version: ${colors.green(Utils.getORMVersion())}`);
+        this.#discovery = new MetadataDiscovery(new MetadataStorage(), this.driver.getPlatform(), this.config);
         this.driver.getPlatform().init(this);
         for (const extension of this.config.get('extensions')) {
             extension.register(this);
         }
         if (!discovery.skipSyncDiscovery) {
-            this.metadata = this.discovery.discoverSync();
+            this.#metadata = this.#discovery.discoverSync();
             this.createEntityManager();
         }
     }
@@ -162,32 +162,32 @@ export class MikroORM {
      */
     getMetadata(entityName) {
         if (entityName) {
-            return this.metadata.get(entityName);
+            return this.#metadata.get(entityName);
         }
-        return this.metadata;
+        return this.#metadata;
     }
     createEntityManager() {
-        this.driver.setMetadata(this.metadata);
+        this.driver.setMetadata(this.#metadata);
         this.em = this.driver.createEntityManager();
         this.em.global = true;
-        this.metadata.decorate(this.em);
-        this.driver.setMetadata(this.metadata);
+        this.#metadata.decorate(this.em);
+        this.driver.setMetadata(this.#metadata);
     }
     /**
      * Allows dynamically discovering new entity by reference, handy for testing schema diffing.
      */
     discoverEntity(entities, reset) {
         for (const className of Utils.asArray(reset)) {
-            this.metadata.reset(className);
-            this.discovery.reset(className);
+            this.#metadata.reset(className);
+            this.#discovery.reset(className);
         }
-        const tmp = this.discovery.discoverReferences(Utils.asArray(entities));
-        const metadata = this.discovery.processDiscoveredEntities(tmp);
+        const tmp = this.#discovery.discoverReferences(Utils.asArray(entities));
+        const metadata = this.#discovery.processDiscoveredEntities(tmp);
         for (const meta of metadata) {
-            this.metadata.set(meta.class, meta);
-            meta.root = this.metadata.get(meta.root.class);
+            this.#metadata.set(meta.class, meta);
+            meta.root = this.#metadata.get(meta.root.class);
         }
-        this.metadata.decorate(this.em);
+        this.#metadata.decorate(this.em);
     }
     /**
      * Gets the SchemaGenerator.

package/cache/FileCacheAdapter.d.ts

@@ -1,10 +1,6 @@
 import type { SyncCacheAdapter } from './CacheAdapter.js';
 export declare class FileCacheAdapter implements SyncCacheAdapter {
-    private readonly options;
-    private readonly baseDir;
-    private readonly pretty;
-    private readonly VERSION;
-    private cache;
+    #private;
     constructor(options: {
         cacheDir: string;
         combined?: boolean | string;

package/cache/FileCacheAdapter.js

@@ -2,16 +2,16 @@ import { existsSync, readFileSync, writeFileSync, unlinkSync } from 'node:fs';
 import { fs } from '../utils/fs-utils.js';
 import { Utils } from '../utils/Utils.js';
 export class FileCacheAdapter {
-    options;
-    baseDir;
-    pretty;
-    VERSION = Utils.getORMVersion();
-    cache = {};
+    #VERSION = Utils.getORMVersion();
+    #cache = {};
+    #options;
+    #baseDir;
+    #pretty;
     constructor(options = {}, baseDir, pretty = false) {
-        this.options = options;
-        this.baseDir = baseDir;
-        this.pretty = pretty;
-        this.options.cacheDir ??= process.cwd() + '/temp';
+        this.#options = options;
+        this.#baseDir = baseDir;
+        this.#pretty = pretty;
+        this.#options.cacheDir ??= process.cwd() + '/temp';
     }
     /**
      * @inheritDoc
@@ -32,13 +32,13 @@ export class FileCacheAdapter {
      * @inheritDoc
      */
     set(name, data, origin) {
-        if (this.options.combined) {
-            this.cache[name.replace(/\.[jt]s$/, '')] = data;
+        if (this.#options.combined) {
+            this.#cache[name.replace(/\.[jt]s$/, '')] = data;
             return;
         }
         const path = this.path(name);
         const hash = this.getHash(origin);
-        writeFileSync(path, JSON.stringify({ data, origin, hash, version: this.VERSION }, null, this.pretty ? 2 : undefined));
+        writeFileSync(path, JSON.stringify({ data, origin, hash, version: this.#VERSION }, null, this.#pretty ? 2 : undefined));
     }
     /**
      * @inheritDoc
@@ -62,28 +62,28 @@ export class FileCacheAdapter {
                 // ignore if file is already gone
             }
         }
-        this.cache = {};
+        this.#cache = {};
     }
     combine() {
-        if (!this.options.combined) {
+        if (!this.#options.combined) {
             return;
         }
-        let path = typeof this.options.combined === 'string' ? this.options.combined : './metadata.json';
-        path = fs.normalizePath(this.options.cacheDir, path);
-        this.options.combined = path; // override in the options, so we can log it from the CLI in `cache:generate` command
-        writeFileSync(path, JSON.stringify(this.cache, null, this.pretty ? 2 : undefined));
+        let path = typeof this.#options.combined === 'string' ? this.#options.combined : './metadata.json';
+        path = fs.normalizePath(this.#options.cacheDir, path);
+        this.#options.combined = path; // override in the options, so we can log it from the CLI in `cache:generate` command
+        writeFileSync(path, JSON.stringify(this.#cache, null, this.#pretty ? 2 : undefined));
         return path;
     }
     path(name) {
-        fs.ensureDir(this.options.cacheDir);
-        return `${this.options.cacheDir}/${name}.json`;
+        fs.ensureDir(this.#options.cacheDir);
+        return `${this.#options.cacheDir}/${name}.json`;
     }
     getHash(origin) {
-        origin = fs.absolutePath(origin, this.baseDir);
+        origin = fs.absolutePath(origin, this.#baseDir);
         if (!existsSync(origin)) {
             return null;
         }
         const contents = readFileSync(origin);
-        return Utils.hash(contents.toString() + this.VERSION);
+        return Utils.hash(contents.toString() + this.#VERSION);
     }
 }

package/cache/GeneratedCacheAdapter.d.ts

@@ -1,7 +1,7 @@
 import type { CacheAdapter } from './CacheAdapter.js';
 import type { Dictionary } from '../typings.js';
 export declare class GeneratedCacheAdapter implements CacheAdapter {
-    private readonly data;
+    #private;
     constructor(options: {
         data: Dictionary;
     });

package/cache/GeneratedCacheAdapter.js

@@ -1,32 +1,32 @@
 export class GeneratedCacheAdapter {
-    data = new Map();
+    #data;
     constructor(options) {
-        this.data = new Map(Object.entries(options.data));
+        this.#data = new Map(Object.entries(options.data));
     }
     /**
      * @inheritDoc
      */
     get(name) {
         const key = name.replace(/\.[jt]s$/, '');
-        const data = this.data.get(key);
+        const data = this.#data.get(key);
         return data;
     }
     /**
      * @inheritDoc
      */
     set(name, data, origin) {
-        this.data.set(name, { data });
+        this.#data.set(name, { data });
     }
     /**
      * @inheritDoc
      */
     remove(name) {
-        this.data.delete(name);
+        this.#data.delete(name);
     }
     /**
      * @inheritDoc
      */
     clear() {
-        this.data.clear();
+        this.#data.clear();
     }
 }

package/cache/MemoryCacheAdapter.d.ts

@@ -1,7 +1,6 @@
 import type { CacheAdapter } from './CacheAdapter.js';
 export declare class MemoryCacheAdapter implements CacheAdapter {
-    private readonly options;
-    private readonly data;
+    #private;
     constructor(options: {
         expiration: number;
     });

package/cache/MemoryCacheAdapter.js

@@ -1,17 +1,17 @@
 export class MemoryCacheAdapter {
-    options;
-    data = new Map();
+    #data = new Map();
+    #options;
     constructor(options) {
-        this.options = options;
+        this.#options = options;
     }
     /**
      * @inheritDoc
      */
     get(name) {
-        const data = this.data.get(name);
+        const data = this.#data.get(name);
         if (data) {
             if (data.expiration < Date.now()) {
-                this.data.delete(name);
+                this.#data.delete(name);
             }
             else {
                 return data.data;
@@ -23,18 +23,18 @@ export class MemoryCacheAdapter {
      * @inheritDoc
      */
     set(name, data, origin, expiration) {
-        this.data.set(name, { data, expiration: Date.now() + (expiration ?? this.options.expiration) });
+        this.#data.set(name, { data, expiration: Date.now() + (expiration ?? this.#options.expiration) });
     }
     /**
      * @inheritDoc
      */
     remove(name) {
-        this.data.delete(name);
+        this.#data.delete(name);
     }
     /**
      * @inheritDoc
      */
     clear() {
-        this.data.clear();
+        this.#data.clear();
     }
 }

package/entity/Collection.d.ts

@@ -9,17 +9,9 @@ export interface MatchingOptions<T extends object, P extends string = never> ext
     ctx?: Transaction;
 }
 export declare class Collection<T extends object, O extends object = object> {
+    #private;
     readonly owner: O;
     [k: number]: T;
-    private readonly items;
-    private initialized;
-    private dirty;
-    private partial;
-    private snapshot;
-    private readonly?;
-    private _count?;
-    private _property?;
-    private _populated?;
     constructor(owner: O, items?: T[], initialized?: boolean);
     /**
      * Creates new Collection instance, assigns it to the owning entity and sets the items to it (propagating them to their inverse sides)
@@ -163,7 +155,7 @@ export declare class Collection<T extends object, O extends object = object> {
     protected propagateToInverseSide(item: T, method: 'add' | 'remove' | 'takeSnapshot'): void;
     protected propagateToOwningSide(item: T, method: 'add' | 'remove' | 'takeSnapshot'): void;
     protected shouldPropagateToCollection(collection: Collection<O, T>, method: 'add' | 'remove' | 'takeSnapshot'): boolean;
-    private incrementCount;
+    protected incrementCount(value: number): void;
 }
 export interface InitCollectionOptions<T, P extends string = never, F extends string = '*', E extends string = never> extends EntityLoaderOptions<T, F, E> {
     dataloader?: boolean;