@mikro-orm/core 6.4.6-dev.1 → 6.4.6-dev.10

package/connections/Connection.js

@@ -15,6 +15,7 @@ class Connection {
         this.config = config;
         this.type = type;
         this.logger = this.config.getLogger();
+        this.platform = this.config.getPlatform();
         if (options) {
             this.options = utils_1.Utils.copy(options);
         }

package/drivers/DatabaseDriver.d.ts

@@ -68,5 +68,6 @@ export declare abstract class DatabaseDriver<C extends Connection> implements ID
      */
     getSchemaName(meta?: EntityMetadata, options?: {
         schema?: string;
+        parentSchema?: string;
     }): string | undefined;
 }

package/drivers/DatabaseDriver.js

@@ -360,7 +360,7 @@ class DatabaseDriver {
      */
     getTableName(meta, options, quote = true) {
         const schema = this.getSchemaName(meta, options);
-        const tableName = schema ? `${schema}.${meta.tableName}` : meta.tableName;
+        const tableName = schema && schema !== this.platform.getDefaultSchemaName() ? `${schema}.${meta.tableName}` : meta.tableName;
         if (quote) {
             return this.platform.quoteIdentifier(tableName);
         }
@@ -376,8 +376,8 @@ class DatabaseDriver {
         if (options?.schema === '*') {
             return this.config.get('schema');
         }
-        const schemaName = meta?.schema === '*' ? this.config.get('schema') : meta?.schema;
-        return options?.schema ?? schemaName ?? this.config.get('schema');
+        const schemaName = meta?.schema === '*' ? this.config.getSchema() : meta?.schema;
+        return options?.schema ?? options?.parentSchema ?? schemaName ?? this.config.getSchema();
     }
 }
 exports.DatabaseDriver = DatabaseDriver;

package/drivers/IDatabaseDriver.d.ts

@@ -58,6 +58,7 @@ export interface IDatabaseDriver<C extends Connection = Connection> {
      */
     getSchemaName(meta?: EntityMetadata, options?: {
         schema?: string;
+        parentSchema?: string;
     }): string | undefined;
 }
 export type EntityField<T, P extends string = PopulatePath.ALL> = keyof T | PopulatePath.ALL | AutoPath<T, P, `${PopulatePath.ALL}`>;

package/entity/EntityFactory.d.ts

@@ -9,6 +9,7 @@ export interface FactoryOptions {
     convertCustomTypes?: boolean;
     recomputeSnapshot?: boolean;
     schema?: string;
+    parentSchema?: string;
 }
 export declare class EntityFactory {
     private readonly em;

package/entity/EntityFactory.js

@@ -192,6 +192,7 @@ class EntityFactory {
         return this.comparator;
     }
     createEntity(data, meta, options) {
+        const schema = this.driver.getSchemaName(meta, options);
         if (options.newEntity || meta.forceConstructor || meta.virtual) {
             if (!meta.class) {
                 throw new Error(`Cannot create entity ${meta.className}, class prototype is unknown`);
@@ -210,7 +211,7 @@ class EntityFactory {
             if (meta.virtual) {
                 return entity;
             }
-            (0, wrap_1.helper)(entity).__schema = this.driver.getSchemaName(meta, options);
+            (0, wrap_1.helper)(entity).__schema = schema;
             if (options.initialized) {
                 EntityHelper_1.EntityHelper.ensurePropagation(entity);
             }
@@ -220,9 +221,9 @@ class EntityFactory {
         const entity = Object.create(meta.class.prototype);
         (0, wrap_1.helper)(entity).__managed = true;
         (0, wrap_1.helper)(entity).__processing = !meta.embeddable && !meta.virtual;
-        (0, wrap_1.helper)(entity).__schema = this.driver.getSchemaName(meta, options);
+        (0, wrap_1.helper)(entity).__schema = schema;
         if (options.merge && !options.newEntity) {
-            this.hydrator.hydrateReference(entity, meta, data, this, options.convertCustomTypes, this.driver.getSchemaName(meta, options));
+            this.hydrator.hydrateReference(entity, meta, data, this, options.convertCustomTypes, options.schema, options.parentSchema);
             this.unitOfWork.register(entity);
         }
         if (options.initialized) {
@@ -232,10 +233,10 @@ class EntityFactory {
     }
     hydrate(entity, meta, data, options) {
         if (options.initialized) {
-            this.hydrator.hydrate(entity, meta, data, this, 'full', options.newEntity, options.convertCustomTypes, this.driver.getSchemaName(meta, options));
+            this.hydrator.hydrate(entity, meta, data, this, 'full', options.newEntity, options.convertCustomTypes, options.schema, this.driver.getSchemaName(meta, options));
         }
         else {
-            this.hydrator.hydrateReference(entity, meta, data, this, options.convertCustomTypes, this.driver.getSchemaName(meta, options));
+            this.hydrator.hydrateReference(entity, meta, data, this, options.convertCustomTypes, options.schema, this.driver.getSchemaName(meta, options));
         }
         Utils_1.Utils.keys(data).forEach(key => {
             (0, wrap_1.helper)(entity)?.__loadedProperties.add(key);

package/hydration/Hydrator.d.ts

@@ -12,11 +12,11 @@ export declare abstract class Hydrator implements IHydrator {
     /**
      * @inheritDoc
      */
-    hydrate<T extends object>(entity: T, meta: EntityMetadata<T>, data: EntityData<T>, factory: EntityFactory, type: 'full' | 'reference', newEntity?: boolean, convertCustomTypes?: boolean, schema?: string): void;
+    hydrate<T extends object>(entity: T, meta: EntityMetadata<T>, data: EntityData<T>, factory: EntityFactory, type: 'full' | 'reference', newEntity?: boolean, convertCustomTypes?: boolean, schema?: string, parentSchema?: string): void;
     /**
      * @inheritDoc
      */
-    hydrateReference<T extends object>(entity: T, meta: EntityMetadata<T>, data: EntityData<T>, factory: EntityFactory, convertCustomTypes?: boolean, schema?: string): void;
+    hydrateReference<T extends object>(entity: T, meta: EntityMetadata<T>, data: EntityData<T>, factory: EntityFactory, convertCustomTypes?: boolean, schema?: string, parentSchema?: string): void;
     isRunning(): boolean;
     protected getProperties<T extends object>(meta: EntityMetadata<T>, type: 'full' | 'reference'): EntityProperty<T>[];
     protected hydrateProperty<T extends object>(entity: T, prop: EntityProperty<T>, data: EntityData<T>, factory: EntityFactory, newEntity?: boolean, convertCustomTypes?: boolean): void;

package/hydration/Hydrator.js

@@ -15,7 +15,7 @@ class Hydrator {
     /**
      * @inheritDoc
      */
-    hydrate(entity, meta, data, factory, type, newEntity = false, convertCustomTypes = false, schema) {
+    hydrate(entity, meta, data, factory, type, newEntity = false, convertCustomTypes = false, schema, parentSchema) {
         // the running state is used to consider propagation as hydration, saving the values directly to the entity data,
         // but we don't want that for new entities, their propagation should result in entity updates when flushing
         this.running = !newEntity;
@@ -28,7 +28,7 @@ class Hydrator {
     /**
      * @inheritDoc
      */
-    hydrateReference(entity, meta, data, factory, convertCustomTypes, schema) {
+    hydrateReference(entity, meta, data, factory, convertCustomTypes, schema, parentSchema) {
         this.running = true;
         meta.primaryKeys.forEach(pk => {
             this.hydrateProperty(entity, meta.properties[pk], data, factory, false, convertCustomTypes);

package/hydration/ObjectHydrator.d.ts

@@ -1,18 +1,18 @@
 import type { EntityData, EntityMetadata } from '../typings';
 import { Hydrator } from './Hydrator';
 import type { EntityFactory } from '../entity/EntityFactory';
-type EntityHydrator<T extends object> = (entity: T, data: EntityData<T>, factory: EntityFactory, newEntity: boolean, convertCustomTypes: boolean, schema?: string) => void;
+type EntityHydrator<T extends object> = (entity: T, data: EntityData<T>, factory: EntityFactory, newEntity: boolean, convertCustomTypes: boolean, schema?: string, parentSchema?: string) => void;
 export declare class ObjectHydrator extends Hydrator {
     private readonly hydrators;
     private tmpIndex;
     /**
      * @inheritDoc
      */
-    hydrate<T extends object>(entity: T, meta: EntityMetadata<T>, data: EntityData<T>, factory: EntityFactory, type: 'full' | 'reference', newEntity?: boolean, convertCustomTypes?: boolean, schema?: string): void;
+    hydrate<T extends object>(entity: T, meta: EntityMetadata<T>, data: EntityData<T>, factory: EntityFactory, type: 'full' | 'reference', newEntity?: boolean, convertCustomTypes?: boolean, schema?: string, parentSchema?: string): void;
     /**
      * @inheritDoc
      */
-    hydrateReference<T extends object>(entity: T, meta: EntityMetadata<T>, data: EntityData<T>, factory: EntityFactory, convertCustomTypes?: boolean, schema?: string): void;
+    hydrateReference<T extends object>(entity: T, meta: EntityMetadata<T>, data: EntityData<T>, factory: EntityFactory, convertCustomTypes?: boolean, schema?: string, parentSchema?: string): void;
     /**
      * @internal Highly performance-sensitive method.
      */

package/hydration/ObjectHydrator.js

@@ -16,23 +16,23 @@ class ObjectHydrator extends Hydrator_1.Hydrator {
     /**
      * @inheritDoc
      */
-    hydrate(entity, meta, data, factory, type, newEntity = false, convertCustomTypes = false, schema) {
+    hydrate(entity, meta, data, factory, type, newEntity = false, convertCustomTypes = false, schema, parentSchema) {
         const hydrate = this.getEntityHydrator(meta, type);
         const running = this.running;
         // the running state is used to consider propagation as hydration, saving the values directly to the entity data,
         // but we don't want that for new entities, their propagation should result in entity updates when flushing
         this.running = !newEntity;
-        Utils_1.Utils.callCompiledFunction(hydrate, entity, data, factory, newEntity, convertCustomTypes, schema);
+        Utils_1.Utils.callCompiledFunction(hydrate, entity, data, factory, newEntity, convertCustomTypes, schema, parentSchema);
         this.running = running;
     }
     /**
      * @inheritDoc
      */
-    hydrateReference(entity, meta, data, factory, convertCustomTypes = false, schema) {
+    hydrateReference(entity, meta, data, factory, convertCustomTypes = false, schema, parentSchema) {
         const hydrate = this.getEntityHydrator(meta, 'reference');
         const running = this.running;
         this.running = true;
-        Utils_1.Utils.callCompiledFunction(hydrate, entity, data, factory, false, convertCustomTypes, schema);
+        Utils_1.Utils.callCompiledFunction(hydrate, entity, data, factory, false, convertCustomTypes, schema, parentSchema);
         this.running = running;
     }
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "6.4.6-dev.1",
+  "version": "6.4.6-dev.10",
   "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.",
   "main": "index.js",
   "module": "index.mjs",
@@ -64,7 +64,7 @@
     "esprima": "4.0.1",
     "fs-extra": "11.3.0",
     "globby": "11.1.0",
-    "mikro-orm": "6.4.6-dev.1",
+    "mikro-orm": "6.4.6-dev.10",
     "reflect-metadata": "0.2.2"
   }
 }

package/typings.d.ts

@@ -777,11 +777,11 @@ export interface IHydrator {
      * Hydrates the whole entity. This process handles custom type conversions, creating missing Collection instances,
      * mapping FKs to entity instances, as well as merging those entities.
      */
-    hydrate<T extends object>(entity: T, meta: EntityMetadata<T>, data: EntityData<T>, factory: EntityFactory, type: 'full' | 'reference', newEntity?: boolean, convertCustomTypes?: boolean, schema?: string): void;
+    hydrate<T extends object>(entity: T, meta: EntityMetadata<T>, data: EntityData<T>, factory: EntityFactory, type: 'full' | 'reference', newEntity?: boolean, convertCustomTypes?: boolean, schema?: string, parentSchema?: string): void;
     /**
      * Hydrates primary keys only
      */
-    hydrateReference<T extends object>(entity: T, meta: EntityMetadata<T>, data: EntityData<T>, factory: EntityFactory, convertCustomTypes?: boolean, schema?: string): void;
+    hydrateReference<T extends object>(entity: T, meta: EntityMetadata<T>, data: EntityData<T>, factory: EntityFactory, convertCustomTypes?: boolean, schema?: string, parentSchema?: string): void;
     isRunning(): boolean;
 }
 export interface HydratorConstructor {

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

@@ -1,5 +1,7 @@
 import type { AnyEntity, EntityMetadata } from '../typings';
 export declare class IdentityMap {
+    private readonly defaultSchema?;
+    constructor(defaultSchema?: string | undefined);
     private readonly registry;
     store<T>(item: T): void;
     delete<T>(item: T): void;

package/unit-of-work/IdentityMap.js

@@ -2,6 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IdentityMap = void 0;
 class IdentityMap {
+    defaultSchema;
+    constructor(defaultSchema) {
+        this.defaultSchema = defaultSchema;
+    }
     registry = new Map();
     store(item) {
         this.getStore(item.__meta.root).set(this.getPkHash(item), item);
@@ -62,7 +66,7 @@ class IdentityMap {
         const wrapped = item.__helper;
         const meta = wrapped.__meta;
         const hash = wrapped.getSerializedPrimaryKey();
-        const schema = wrapped.__schema || meta.root.schema;
+        const schema = wrapped.__schema ?? meta.root.schema ?? this.defaultSchema;
         if (schema) {
             return schema + ':' + hash;
         }

package/unit-of-work/UnitOfWork.js

@@ -17,7 +17,7 @@ const insideFlush = new node_async_hooks_1.AsyncLocalStorage();
 class UnitOfWork {
     em;
     /** map of references to managed entities */
-    identityMap = new IdentityMap_1.IdentityMap();
+    identityMap;
     persistStack = new Set();
     removeStack = new Set();
     orphanRemoveStack = new Set();
@@ -38,6 +38,7 @@ class UnitOfWork {
         this.em = em;
         this.metadata = this.em.getMetadata();
         this.platform = this.em.getPlatform();
+        this.identityMap = new IdentityMap_1.IdentityMap(this.platform.getDefaultSchemaName());
         this.eventManager = this.em.getEventManager();
         this.comparator = this.em.getComparator();
         this.changeSetComputer = new ChangeSetComputer_1.ChangeSetComputer(this.em.getValidator(), this.collectionUpdates, this.metadata, this.platform, this.em.config, this.em);
@@ -136,7 +137,7 @@ class UnitOfWork {
             const keys = Array.isArray(id) ? Utils_1.Utils.flatten(id) : [id];
             hash = Utils_1.Utils.getPrimaryKeyHash(keys);
         }
-        schema ??= meta.schema ?? this.em.config.get('schema');
+        schema ??= meta.schema ?? this.em.config.getSchema();
         if (schema) {
             hash = `${schema}:${hash}`;
         }

package/utils/Configuration.d.ts

@@ -167,10 +167,12 @@ export declare class Configuration<D extends IDatabaseDriver = IDatabaseDriver,
      * Gets Logger instance.
      */
     getLogger(): Logger;
+    getPlatform(): Platform;
     /**
      * Gets current client URL (connection string).
      */
     getClientUrl(hidePassword?: boolean): string;
+    getSchema(skipDefaultSchema?: boolean): string | undefined;
     /**
      * Gets current database driver instance.
      */

package/utils/Configuration.js

@@ -198,6 +198,9 @@ class Configuration {
     getLogger() {
         return this.logger;
     }
+    getPlatform() {
+        return this.platform;
+    }
     /**
      * Gets current client URL (connection string).
      */
@@ -207,6 +210,12 @@ class Configuration {
         }
         return this.options.clientUrl;
     }
+    getSchema(skipDefaultSchema = false) {
+        if (skipDefaultSchema && this.options.schema === this.platform.getDefaultSchemaName()) {
+            return undefined;
+        }
+        return this.options.schema;
+    }
     /**
      * Gets current database driver instance.
      */
@@ -317,6 +326,9 @@ class Configuration {
         if (validate && !this.options.dbName && this.options.clientUrl) {
             throw new Error("No database specified, `clientUrl` option provided but it's missing the pathname.");
         }
+        if (!this.options.schema) {
+            this.options.schema = this.platform.getDefaultSchemaName();
+        }
         if (!this.options.charset) {
             this.options.charset = this.platform.getDefaultCharset();
         }