@mikro-orm/core 7.0.0-dev.0 → 7.0.0-dev.2

package/unit-of-work/ChangeSetPersister.js

@@ -1,13 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ChangeSetPersister = void 0;
-const entity_1 = require("../entity");
-const ChangeSet_1 = require("./ChangeSet");
-const RawQueryFragment_1 = require("../utils/RawQueryFragment");
-const Utils_1 = require("../utils/Utils");
-const errors_1 = require("../errors");
-const enums_1 = require("../enums");
-class ChangeSetPersister {
+import { EntityIdentifier } from '../entity/EntityIdentifier.js';
+import { helper } from '../entity/wrap.js';
+import { ChangeSetType } from './ChangeSet.js';
+import { isRaw } from '../utils/RawQueryFragment.js';
+import { Utils } from '../utils/Utils.js';
+import { OptimisticLockError } from '../errors.js';
+import { ReferenceKind } from '../enums.js';
+export class ChangeSetPersister {
     driver;
     metadata;
     hydrator;
@@ -60,7 +58,7 @@ class ChangeSetPersister {
         }
         const size = this.config.get('batchSize');
         const meta = changeSets[0].meta;
-        const pk = Utils_1.Utils.getPrimaryKeyHash(meta.primaryKeys);
+        const pk = Utils.getPrimaryKeyHash(meta.primaryKeys);
         for (let i = 0; i < changeSets.length; i += size) {
             const chunk = changeSets.slice(i, i + size);
             const pks = chunk.map(cs => cs.getPrimaryKey());
@@ -86,12 +84,12 @@ class ChangeSetPersister {
         for (const prop of meta.relations) {
             this.processProperty(changeSet, prop);
         }
-        if (changeSet.type === ChangeSet_1.ChangeSetType.CREATE && this.config.get('validateRequired')) {
+        if (changeSet.type === ChangeSetType.CREATE && this.config.get('validateRequired')) {
             this.validator.validateRequired(changeSet.entity);
         }
     }
     async persistNewEntity(meta, changeSet, options) {
-        const wrapped = (0, entity_1.helper)(changeSet.entity);
+        const wrapped = helper(changeSet.entity);
         options = this.propagateSchemaFromMetadata(meta, options, {
             convertCustomTypes: false,
         });
@@ -133,7 +131,7 @@ class ChangeSetPersister {
         const res = await this.driver.nativeInsertMany(meta.className, changeSets.map(cs => cs.payload), options);
         for (let i = 0; i < changeSets.length; i++) {
             const changeSet = changeSets[i];
-            const wrapped = (0, entity_1.helper)(changeSet.entity);
+            const wrapped = helper(changeSet.entity);
             if (!wrapped.hasPrimaryKey()) {
                 const field = meta.getPrimaryProps()[0].fieldNames[0];
                 this.mapPrimaryKey(meta, res.rows[i][field], changeSet);
@@ -172,7 +170,7 @@ class ChangeSetPersister {
             }
         }
         if (tmp.length === 0 && meta.concurrencyCheckKeys.size > 0) {
-            throw errors_1.OptimisticLockError.lockFailed(changeSet.entity);
+            throw OptimisticLockError.lockFailed(changeSet.entity);
         }
     }
     async persistManagedEntitiesBatch(meta, changeSets, options) {
@@ -191,10 +189,10 @@ class ChangeSetPersister {
         }
         const res = await this.driver.nativeUpdateMany(meta.className, cond, payload, options);
         const map = new Map();
-        res.rows?.forEach(item => map.set(Utils_1.Utils.getCompositeKeyHash(item, meta, true, this.platform, true), item));
+        res.rows?.forEach(item => map.set(Utils.getCompositeKeyHash(item, meta, true, this.platform, true), item));
         for (const changeSet of changeSets) {
             if (res.rows) {
-                const row = map.get((0, entity_1.helper)(changeSet.entity).getSerializedPrimaryKey());
+                const row = map.get(helper(changeSet.entity).getSerializedPrimaryKey());
                 this.mapReturnedValues(changeSet.entity, changeSet.payload, row, meta);
             }
             changeSet.persisted = true;
@@ -203,7 +201,7 @@ class ChangeSetPersister {
     mapPrimaryKey(meta, value, changeSet) {
         const prop = meta.properties[meta.primaryKeys[0]];
         const insertId = prop.customType ? prop.customType.convertToJSValue(value, this.platform) : value;
-        const wrapped = (0, entity_1.helper)(changeSet.entity);
+        const wrapped = helper(changeSet.entity);
         if (!wrapped.hasPrimaryKey()) {
             wrapped.setPrimaryKey(insertId);
         }
@@ -218,17 +216,17 @@ class ChangeSetPersister {
      * Sets populate flag to new entities so they are serialized like if they were loaded from the db
      */
     markAsPopulated(changeSet, meta) {
-        (0, entity_1.helper)(changeSet.entity).__schema = this.driver.getSchemaName(meta, changeSet);
+        helper(changeSet.entity).__schema = this.driver.getSchemaName(meta, changeSet);
         if (!this.config.get('populateAfterFlush')) {
             return;
         }
-        (0, entity_1.helper)(changeSet.entity).populated();
+        helper(changeSet.entity).populated();
         meta.relations.forEach(prop => {
             const value = changeSet.entity[prop.name];
-            if (Utils_1.Utils.isEntity(value, true)) {
+            if (Utils.isEntity(value, true)) {
                 value.__helper.populated();
             }
-            else if (Utils_1.Utils.isCollection(value)) {
+            else if (Utils.isCollection(value)) {
                 value.populated();
             }
         });
@@ -252,9 +250,9 @@ class ChangeSetPersister {
             return;
         }
         // skip entity references as they don't have version values loaded
-        changeSets = changeSets.filter(cs => (0, entity_1.helper)(cs.entity).__initialized);
+        changeSets = changeSets.filter(cs => helper(cs.entity).__initialized);
         const $or = changeSets.map(cs => {
-            const cond = Utils_1.Utils.getPrimaryKeyCond(cs.originalEntity, meta.primaryKeys.concat(...meta.concurrencyCheckKeys));
+            const cond = Utils.getPrimaryKeyCond(cs.originalEntity, meta.primaryKeys.concat(...meta.concurrencyCheckKeys));
             if (meta.versionProperty) {
                 // @ts-ignore
                 cond[meta.versionProperty] = this.platform.quoteVersionValue(cs.entity[meta.versionProperty], meta.properties[meta.versionProperty]);
@@ -269,14 +267,14 @@ class ChangeSetPersister {
         if (res.length !== changeSets.length) {
             const compare = (a, b, keys) => keys.every(k => a[k] === b[k]);
             const entity = changeSets.find(cs => {
-                return !res.some(row => compare(Utils_1.Utils.getPrimaryKeyCond(cs.entity, primaryKeys), row, primaryKeys));
+                return !res.some(row => compare(Utils.getPrimaryKeyCond(cs.entity, primaryKeys), row, primaryKeys));
             }).entity;
-            throw errors_1.OptimisticLockError.lockFailed(entity);
+            throw OptimisticLockError.lockFailed(entity);
         }
     }
     checkOptimisticLock(meta, changeSet, res) {
         if ((meta.versionProperty || meta.concurrencyCheckKeys.size > 0) && res && !res.affectedRows) {
-            throw errors_1.OptimisticLockError.lockFailed(changeSet.entity);
+            throw OptimisticLockError.lockFailed(changeSet.entity);
         }
     }
     /**
@@ -285,18 +283,18 @@ class ChangeSetPersister {
      */
     async reloadVersionValues(meta, changeSets, options) {
         const reloadProps = meta.versionProperty && !this.usesReturningStatement ? [meta.properties[meta.versionProperty]] : [];
-        if (changeSets[0].type === ChangeSet_1.ChangeSetType.CREATE) {
+        if (changeSets[0].type === ChangeSetType.CREATE) {
             // do not reload things that already had a runtime value
             meta.props
                 .filter(prop => prop.persist !== false && (prop.autoincrement || prop.generated || prop.defaultRaw))
-                .filter(prop => (changeSets[0].entity[prop.name] == null && prop.defaultRaw !== 'null') || (0, RawQueryFragment_1.isRaw)(changeSets[0].entity[prop.name]))
+                .filter(prop => (changeSets[0].entity[prop.name] == null && prop.defaultRaw !== 'null') || isRaw(changeSets[0].entity[prop.name]))
                 .forEach(prop => reloadProps.push(prop));
         }
-        if (changeSets[0].type === ChangeSet_1.ChangeSetType.UPDATE) {
+        if (changeSets[0].type === ChangeSetType.UPDATE) {
             const returning = new Set();
             changeSets.forEach(cs => {
-                Utils_1.Utils.keys(cs.payload).forEach(k => {
-                    if ((0, RawQueryFragment_1.isRaw)(cs.payload[k]) && (0, RawQueryFragment_1.isRaw)(cs.entity[k])) {
+                Utils.keys(cs.payload).forEach(k => {
+                    if (isRaw(cs.payload[k]) && isRaw(cs.entity[k])) {
                         returning.add(meta.properties[k]);
                     }
                 });
@@ -313,22 +311,22 @@ class ChangeSetPersister {
             return;
         }
         reloadProps.unshift(...meta.getPrimaryProps());
-        const pk = Utils_1.Utils.getPrimaryKeyHash(meta.primaryKeys);
+        const pk = Utils.getPrimaryKeyHash(meta.primaryKeys);
         const pks = changeSets.map(cs => {
-            const val = (0, entity_1.helper)(cs.entity).getPrimaryKey(true);
-            if (Utils_1.Utils.isPlainObject(val)) {
-                return Utils_1.Utils.getCompositeKeyValue(val, meta, false, this.platform);
+            const val = helper(cs.entity).getPrimaryKey(true);
+            if (Utils.isPlainObject(val)) {
+                return Utils.getCompositeKeyValue(val, meta, false, this.platform);
             }
             return val;
         });
         options = this.propagateSchemaFromMetadata(meta, options, {
-            fields: Utils_1.Utils.unique(reloadProps.map(prop => prop.name)),
+            fields: Utils.unique(reloadProps.map(prop => prop.name)),
         });
         const data = await this.driver.find(meta.className, { [pk]: { $in: pks } }, options);
         const map = new Map();
-        data.forEach(item => map.set(Utils_1.Utils.getCompositeKeyHash(item, meta, true, this.platform, true), item));
+        data.forEach(item => map.set(Utils.getCompositeKeyHash(item, meta, true, this.platform, true), item));
         for (const changeSet of changeSets) {
-            const data = map.get((0, entity_1.helper)(changeSet.entity).getSerializedPrimaryKey());
+            const data = map.get(helper(changeSet.entity).getSerializedPrimaryKey());
             this.hydrator.hydrate(changeSet.entity, meta, data, this.factory, 'full', false, true);
             Object.assign(changeSet.payload, data); // merge to the changeset payload, so it gets saved to the entity snapshot
         }
@@ -336,21 +334,21 @@ class ChangeSetPersister {
     processProperty(changeSet, prop) {
         const meta = this.metadata.find(changeSet.name);
         const value = changeSet.payload[prop.name]; // for inline embeddables
-        if (value instanceof entity_1.EntityIdentifier) {
+        if (value instanceof EntityIdentifier) {
             changeSet.payload[prop.name] = value.getValue();
             return;
         }
-        if (prop.kind === enums_1.ReferenceKind.MANY_TO_MANY && Array.isArray(value)) {
-            changeSet.payload[prop.name] = value.map(val => val instanceof entity_1.EntityIdentifier ? val.getValue() : val);
+        if (prop.kind === ReferenceKind.MANY_TO_MANY && Array.isArray(value)) {
+            changeSet.payload[prop.name] = value.map(val => val instanceof EntityIdentifier ? val.getValue() : val);
             return;
         }
         if (prop.name in changeSet.payload) {
             return;
         }
-        const values = Utils_1.Utils.unwrapProperty(changeSet.payload, meta, prop, true); // for object embeddables
+        const values = Utils.unwrapProperty(changeSet.payload, meta, prop, true); // for object embeddables
         values.forEach(([value, indexes]) => {
-            if (value instanceof entity_1.EntityIdentifier) {
-                Utils_1.Utils.setPayloadProperty(changeSet.payload, meta, prop, value.getValue(), indexes);
+            if (value instanceof EntityIdentifier) {
+                Utils.setPayloadProperty(changeSet.payload, meta, prop, value.getValue(), indexes);
             }
         });
     }
@@ -360,7 +358,7 @@ class ChangeSetPersister {
      * We do need to map to the change set payload too, as it will be used in the originalEntityData for new entities.
      */
     mapReturnedValues(entity, payload, row, meta, upsert = false) {
-        if ((!this.usesReturningStatement && !upsert) || !row || !Utils_1.Utils.hasObjectKeys(row)) {
+        if ((!this.usesReturningStatement && !upsert) || !row || !Utils.hasObjectKeys(row)) {
             return;
         }
         const mapped = this.comparator.mapResult(meta.className, row);
@@ -377,4 +375,3 @@ class ChangeSetPersister {
         Object.assign(payload, mapped);
     }
 }
-exports.ChangeSetPersister = ChangeSetPersister;

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

@@ -1,4 +1,4 @@
-import type { Dictionary, EntityProperty } from '../typings';
+import type { Dictionary, EntityProperty } from '../typings.js';
 export declare const enum NodeState {
     NOT_VISITED = 0,
     IN_PROGRESS = 1,

package/unit-of-work/CommitOrderCalculator.js

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CommitOrderCalculator = exports.NodeState = void 0;
-const enums_1 = require("../enums");
-var NodeState;
+import { ReferenceKind } from '../enums.js';
+export var NodeState;
 (function (NodeState) {
     NodeState[NodeState["NOT_VISITED"] = 0] = "NOT_VISITED";
     NodeState[NodeState["IN_PROGRESS"] = 1] = "IN_PROGRESS";
     NodeState[NodeState["VISITED"] = 2] = "VISITED";
-})(NodeState || (exports.NodeState = NodeState = {}));
+})(NodeState || (NodeState = {}));
 /**
  * CommitOrderCalculator implements topological sorting, which is an ordering
  * algorithm for directed graphs (DG) and/or directed acyclic graphs (DAG) by
@@ -18,7 +15,7 @@ var NodeState;
  * Based on https://github.com/doctrine/orm/blob/master/lib/Doctrine/ORM/Internal/CommitOrderCalculator.php
  * @internal
  */
-class CommitOrderCalculator {
+export class CommitOrderCalculator {
     /** Matrix of nodes, keys are provided hashes and values are the node definition objects. */
     nodes = {};
     /** Volatile variable holding calculated nodes during sorting process. */
@@ -42,8 +39,8 @@ class CommitOrderCalculator {
         this.nodes[from].dependencies[to] = { from, to, weight };
     }
     discoverProperty(prop, entityName) {
-        const toOneOwner = (prop.kind === enums_1.ReferenceKind.ONE_TO_ONE && prop.owner) || prop.kind === enums_1.ReferenceKind.MANY_TO_ONE;
-        const toManyOwner = prop.kind === enums_1.ReferenceKind.MANY_TO_MANY && prop.owner && !prop.pivotEntity;
+        const toOneOwner = (prop.kind === ReferenceKind.ONE_TO_ONE && prop.owner) || prop.kind === ReferenceKind.MANY_TO_ONE;
+        const toManyOwner = prop.kind === ReferenceKind.MANY_TO_MANY && prop.owner && !prop.pivotEntity;
         if (!toOneOwner && !toManyOwner) {
             return;
         }
@@ -110,4 +107,3 @@ class CommitOrderCalculator {
         this.sortedNodeList.push(target.hash);
     }
 }
-exports.CommitOrderCalculator = CommitOrderCalculator;

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

@@ -1,4 +1,4 @@
-import type { AnyEntity, EntityMetadata } from '../typings';
+import type { AnyEntity, EntityMetadata } from '../typings.js';
 export declare class IdentityMap {
     private readonly defaultSchema?;
     constructor(defaultSchema?: string | undefined);

package/unit-of-work/IdentityMap.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IdentityMap = void 0;
-class IdentityMap {
+export class IdentityMap {
     defaultSchema;
     constructor(defaultSchema) {
         this.defaultSchema = defaultSchema;
@@ -73,4 +70,3 @@ class IdentityMap {
         return hash;
     }
 }
-exports.IdentityMap = IdentityMap;

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

@@ -1,10 +1,11 @@
-import type { AnyEntity, EntityData, EntityMetadata, EntityProperty, FilterQuery, Primary } from '../typings';
-import { Collection, Reference } from '../entity';
-import { ChangeSet, ChangeSetType } from './ChangeSet';
-import { ChangeSetPersister } from './ChangeSetPersister';
-import type { EntityManager } from '../EntityManager';
-import { IdentityMap } from './IdentityMap';
-import type { LockOptions } from '../drivers/IDatabaseDriver';
+import type { AnyEntity, EntityData, EntityMetadata, EntityProperty, FilterQuery, Primary } from '../typings.js';
+import { Collection } from '../entity/Collection.js';
+import { Reference } from '../entity/Reference.js';
+import { ChangeSet, ChangeSetType } from './ChangeSet.js';
+import { ChangeSetPersister } from './ChangeSetPersister.js';
+import type { EntityManager } from '../EntityManager.js';
+import { IdentityMap } from './IdentityMap.js';
+import type { LockOptions } from '../drivers/IDatabaseDriver.js';
 export declare class UnitOfWork {
     private readonly em;
     /** map of references to managed entities */