@yandjin-mikro-orm/core 6.1.4-rc-sti-changes-1

package/typings.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityMetadata = exports.Config = exports.HiddenProps = exports.EagerProps = exports.OptionalProps = exports.PrimaryKeyProp = exports.EntityRepositoryType = void 0;
+const enums_1 = require("./enums");
+const entity_1 = require("./entity");
+const Utils_1 = require("./utils/Utils");
+const EntityComparator_1 = require("./utils/EntityComparator");
+exports.EntityRepositoryType = Symbol('EntityRepositoryType');
+exports.PrimaryKeyProp = Symbol('PrimaryKeyProp');
+exports.OptionalProps = Symbol('OptionalProps');
+exports.EagerProps = Symbol('EagerProps');
+exports.HiddenProps = Symbol('HiddenProps');
+exports.Config = Symbol('Config');
+class EntityMetadata {
+    static counter = 0;
+    _id = 1000 * EntityMetadata.counter++; // keep the id >= 1000 to allow computing cache keys by simple addition
+    propertyOrder = new Map();
+    constructor(meta = {}) {
+        this.properties = {};
+        this.props = [];
+        this.primaryKeys = [];
+        this.filters = {};
+        this.hooks = {};
+        this.indexes = [];
+        this.uniques = [];
+        this.checks = [];
+        this.referencingProperties = [];
+        this.concurrencyCheckKeys = new Set();
+        this.stiChildren = [];
+        Object.assign(this, meta);
+    }
+    getStiRoot() {
+        // if (this.root.stiRoot) {
+        //   return this.root.stiRoot;
+        // }
+        // const children = this.root.stiChildren as EntityMetadata<any>[];
+        // if (children.length === 0) {
+        //   return Utils.copy(this.root, false);
+        // }
+        // const newRoot: EntityMetadata<any> = Utils.copy(this.root, false);
+        // for (const meta of children) {
+        //   Object.values(meta.properties).forEach((prop) => {
+        //     const exists = newRoot.properties[prop.name];
+        //     prop = Utils.copy(prop, false);
+        //     prop.nullable = true;
+        //     if (!exists) {
+        //       prop.inherited = true;
+        //     }
+        //     newRoot.addProperty(prop);
+        //   });
+        //   newRoot.indexes = Utils.unique([...newRoot.indexes, ...meta.indexes]);
+        //   newRoot.uniques = Utils.unique([...newRoot.uniques, ...meta.uniques]);
+        // }
+        // this.root.stiRoot = newRoot;
+        // return newRoot;
+        return this.root.stiRoot ?? this.root;
+    }
+    addProperty(prop, sync = true) {
+        if (prop.pivotTable && !prop.pivotEntity) {
+            prop.pivotEntity = prop.pivotTable;
+        }
+        this.properties[prop.name] = prop;
+        this.propertyOrder.set(prop.name, this.props.length);
+        /* istanbul ignore next */
+        if (sync) {
+            this.sync();
+        }
+    }
+    removeProperty(name, sync = true) {
+        delete this.properties[name];
+        this.propertyOrder.delete(name);
+        /* istanbul ignore next */
+        if (sync) {
+            this.sync();
+        }
+    }
+    getPrimaryProps() {
+        return this.primaryKeys.map(pk => this.properties[pk]);
+    }
+    get tableName() {
+        return this.collection;
+    }
+    set tableName(name) {
+        this.collection = name;
+    }
+    sync(initIndexes = false) {
+        this.root ??= this;
+        const props = Object.values(this.properties).sort((a, b) => this.propertyOrder.get(a.name) - this.propertyOrder.get(b.name));
+        this.props = [...props.filter(p => p.primary), ...props.filter(p => !p.primary)];
+        this.relations = this.props.filter(prop => typeof prop.kind !== 'undefined' && prop.kind !== enums_1.ReferenceKind.SCALAR && prop.kind !== enums_1.ReferenceKind.EMBEDDED);
+        this.bidirectionalRelations = this.relations.filter(prop => prop.mappedBy || prop.inversedBy);
+        this.uniqueProps = this.props.filter(prop => prop.unique);
+        this.comparableProps = this.props.filter(prop => EntityComparator_1.EntityComparator.isComparable(prop, this));
+        this.hydrateProps = this.props.filter(prop => {
+            // `prop.userDefined` is either `undefined` or `false`
+            const discriminator = this.root.discriminatorColumn === prop.name && prop.userDefined === false;
+            // even if we don't have a setter, do not ignore value from database!
+            const onlyGetter = prop.getter && !prop.setter;
+            return !prop.inherited && prop.hydrate !== false && !discriminator && !prop.embedded && !onlyGetter;
+        });
+        this.trackingProps = this.hydrateProps
+            .filter(prop => !prop.getter && !prop.setter)
+            .filter(prop => ![enums_1.ReferenceKind.ONE_TO_MANY, enums_1.ReferenceKind.MANY_TO_MANY].includes(prop.kind))
+            .filter(prop => !prop.serializedPrimaryKey);
+        this.selfReferencing = this.relations.some(prop => [this.className, this.root.className].includes(prop.type));
+        this.hasUniqueProps = this.uniques.length + this.uniqueProps.length > 0;
+        this.virtual = !!this.expression;
+        this.checks = Utils_1.Utils.removeDuplicates(this.checks);
+        this.indexes = Utils_1.Utils.removeDuplicates(this.indexes);
+        this.uniques = Utils_1.Utils.removeDuplicates(this.uniques);
+        for (const hook of Utils_1.Utils.keys(this.hooks)) {
+            this.hooks[hook] = Utils_1.Utils.removeDuplicates(this.hooks[hook]);
+        }
+        if (this.virtual) {
+            this.readonly = true;
+        }
+        if (initIndexes && this.name) {
+            this.props.forEach(prop => this.initIndexes(prop));
+        }
+        this.definedProperties = this.trackingProps.reduce((o, prop) => {
+            const isCollection = [enums_1.ReferenceKind.ONE_TO_MANY, enums_1.ReferenceKind.MANY_TO_MANY].includes(prop.kind);
+            const isReference = [enums_1.ReferenceKind.ONE_TO_ONE, enums_1.ReferenceKind.MANY_TO_ONE].includes(prop.kind) && (prop.inversedBy || prop.mappedBy) && !prop.mapToPk;
+            if (isReference) {
+                // eslint-disable-next-line @typescript-eslint/no-this-alias
+                const meta = this;
+                o[prop.name] = {
+                    get() {
+                        return this.__helper.__data[prop.name];
+                    },
+                    set(val) {
+                        const wrapped = this.__helper;
+                        const hydrator = wrapped.hydrator;
+                        const entity = entity_1.Reference.unwrapReference(val ?? wrapped.__data[prop.name]);
+                        const old = entity_1.Reference.unwrapReference(wrapped.__data[prop.name]);
+                        wrapped.__data[prop.name] = entity_1.Reference.wrapReference(val, prop);
+                        // when propagation from inside hydration, we set the FK to the entity data immediately
+                        if (val && hydrator.isRunning() && wrapped.__originalEntityData && prop.owner) {
+                            wrapped.__originalEntityData[prop.name] = Utils_1.Utils.getPrimaryKeyValues(val, prop.targetMeta.primaryKeys, true);
+                        }
+                        else {
+                            wrapped.__touched = !hydrator.isRunning();
+                        }
+                        entity_1.EntityHelper.propagate(meta, entity, this, prop, entity_1.Reference.unwrapReference(val), old);
+                    },
+                    enumerable: true,
+                    configurable: true,
+                };
+            }
+            if (prop.inherited || prop.primary || isCollection || prop.persist === false || prop.trackChanges === false || isReference || prop.embedded) {
+                return o;
+            }
+            o[prop.name] = {
+                get() {
+                    return this.__helper.__data[prop.name];
+                },
+                set(val) {
+                    if (typeof val === 'object' && !!val && '__raw' in val) {
+                        val.assign();
+                    }
+                    this.__helper.__data[prop.name] = val;
+                    this.__helper.__touched = !this.__helper.hydrator.isRunning();
+                },
+                enumerable: true,
+                configurable: true,
+            };
+            return o;
+        }, { __gettersDefined: { value: true, enumerable: false } });
+    }
+    initIndexes(prop) {
+        const simpleIndex = this.indexes.find(index => index.properties === prop.name && !index.options && !index.type && !index.expression);
+        const simpleUnique = this.uniques.find(index => index.properties === prop.name && !index.options);
+        const owner = prop.kind === enums_1.ReferenceKind.MANY_TO_ONE;
+        if (!prop.index && simpleIndex) {
+            Utils_1.Utils.defaultValue(simpleIndex, 'name', true);
+            prop.index = simpleIndex.name;
+            this.indexes.splice(this.indexes.indexOf(simpleIndex), 1);
+        }
+        if (!prop.unique && simpleUnique) {
+            Utils_1.Utils.defaultValue(simpleUnique, 'name', true);
+            prop.unique = simpleUnique.name;
+            this.uniques.splice(this.uniques.indexOf(simpleUnique), 1);
+        }
+        if (prop.index && owner && prop.fieldNames.length > 1) {
+            this.indexes.push({ properties: prop.name });
+            prop.index = false;
+        }
+        /* istanbul ignore next */
+        if (owner && prop.fieldNames.length > 1 && prop.unique) {
+            this.uniques.push({ properties: prop.name });
+            prop.unique = false;
+        }
+    }
+    /** @internal */
+    clone() {
+        return this;
+    }
+}
+exports.EntityMetadata = EntityMetadata;

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

@@ -0,0 +1,34 @@
+/// <reference types="node" />
+import { inspect } from 'util';
+import type { EntityData, EntityMetadata, EntityDictionary, Primary } from '../typings';
+export declare class ChangeSet<T extends object> {
+    entity: T;
+    type: ChangeSetType;
+    payload: EntityDictionary<T>;
+    meta: EntityMetadata<T>;
+    private primaryKey?;
+    private serializedPrimaryKey?;
+    constructor(entity: T, type: ChangeSetType, payload: EntityDictionary<T>, meta: EntityMetadata<T>);
+    getPrimaryKey(object?: boolean): Primary<T> | null;
+    getSerializedPrimaryKey(): string | null;
+    /** @ignore */
+    [inspect.custom](depth: number): string;
+}
+export interface ChangeSet<T> {
+    name: string;
+    rootName: string;
+    collection: string;
+    schema?: string;
+    type: ChangeSetType;
+    entity: T;
+    payload: EntityDictionary<T>;
+    persisted: boolean;
+    originalEntity?: EntityData<T>;
+}
+export declare enum ChangeSetType {
+    CREATE = "create",
+    UPDATE = "update",
+    DELETE = "delete",
+    UPDATE_EARLY = "update_early",
+    DELETE_EARLY = "delete_early"
+}

package/unit-of-work/ChangeSet.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChangeSetType = exports.ChangeSet = void 0;
+const util_1 = require("util");
+const wrap_1 = require("../entity/wrap");
+const Utils_1 = require("../utils/Utils");
+class ChangeSet {
+    entity;
+    type;
+    payload;
+    meta;
+    primaryKey;
+    serializedPrimaryKey;
+    constructor(entity, type, payload, meta) {
+        this.entity = entity;
+        this.type = type;
+        this.payload = payload;
+        this.meta = meta;
+        this.name = meta.className;
+        this.rootName = meta.root.className;
+        this.collection = meta.root.collection;
+        this.schema = (0, wrap_1.helper)(entity).__schema ?? meta.root.schema;
+    }
+    getPrimaryKey(object = false) {
+        if (!this.originalEntity) {
+            this.primaryKey ??= (0, wrap_1.helper)(this.entity).getPrimaryKey(true);
+        }
+        else if (this.meta.compositePK) {
+            this.primaryKey = this.meta.primaryKeys.map(pk => this.originalEntity[pk]);
+        }
+        else {
+            this.primaryKey = this.originalEntity[this.meta.primaryKeys[0]];
+        }
+        if (object && this.primaryKey != null) {
+            return Utils_1.Utils.primaryKeyToObject(this.meta, this.primaryKey);
+        }
+        return this.primaryKey ?? null;
+    }
+    getSerializedPrimaryKey() {
+        this.serializedPrimaryKey ??= (0, wrap_1.helper)(this.entity).getSerializedPrimaryKey();
+        return this.serializedPrimaryKey;
+    }
+    /** @ignore */
+    [util_1.inspect.custom](depth) {
+        const object = { ...this };
+        const hidden = ['meta', 'serializedPrimaryKey'];
+        hidden.forEach(k => delete object[k]);
+        const ret = (0, util_1.inspect)(object, { depth });
+        const name = `${this.constructor.name}<${this.meta.className}>`;
+        /* istanbul ignore next */
+        return ret === '[Object]' ? `[${name}]` : name + ' ' + ret;
+    }
+}
+exports.ChangeSet = ChangeSet;
+var ChangeSetType;
+(function (ChangeSetType) {
+    ChangeSetType["CREATE"] = "create";
+    ChangeSetType["UPDATE"] = "update";
+    ChangeSetType["DELETE"] = "delete";
+    ChangeSetType["UPDATE_EARLY"] = "update_early";
+    ChangeSetType["DELETE_EARLY"] = "delete_early";
+})(ChangeSetType || (exports.ChangeSetType = ChangeSetType = {}));

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

@@ -0,0 +1,26 @@
+import { type Configuration } from '../utils';
+import type { MetadataStorage } from '../metadata';
+import type { AnyEntity } from '../typings';
+import { ChangeSet } from './ChangeSet';
+import { type Collection, type EntityValidator } from '../entity';
+import type { Platform } from '../platforms';
+import type { EntityManager } from '../EntityManager';
+export declare class ChangeSetComputer {
+    private readonly validator;
+    private readonly collectionUpdates;
+    private readonly metadata;
+    private readonly platform;
+    private readonly config;
+    private readonly em;
+    private readonly comparator;
+    constructor(validator: EntityValidator, collectionUpdates: Set<Collection<AnyEntity>>, metadata: MetadataStorage, platform: Platform, config: Configuration, em: EntityManager);
+    computeChangeSet<T extends object>(entity: T): ChangeSet<T> | null;
+    /**
+     * Traverses entity graph and executes `onCreate` and `onUpdate` methods, assigning the values to given properties.
+     */
+    private processPropertyInitializers;
+    private computePayload;
+    private processProperty;
+    private processToOne;
+    private processToMany;
+}

package/unit-of-work/ChangeSetComputer.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChangeSetComputer = void 0;
+const utils_1 = require("../utils");
+const ChangeSet_1 = require("./ChangeSet");
+const entity_1 = require("../entity");
+const enums_1 = require("../enums");
+class ChangeSetComputer {
+    validator;
+    collectionUpdates;
+    metadata;
+    platform;
+    config;
+    em;
+    comparator;
+    constructor(validator, collectionUpdates, metadata, platform, config, em) {
+        this.validator = validator;
+        this.collectionUpdates = collectionUpdates;
+        this.metadata = metadata;
+        this.platform = platform;
+        this.config = config;
+        this.em = em;
+        this.comparator = this.config.getComparator(this.metadata);
+    }
+    computeChangeSet(entity) {
+        const wrapped = (0, entity_1.helper)(entity);
+        const meta = this.metadata.get(wrapped.__meta.className);
+        if (meta.readonly) {
+            return null;
+        }
+        const type = wrapped.__originalEntityData ? ChangeSet_1.ChangeSetType.UPDATE : ChangeSet_1.ChangeSetType.CREATE;
+        const map = new Map();
+        // Execute `onCreate` and `onUpdate` on properties recursively, saves `onUpdate` results
+        // to the `map` as we want to apply those only if something else changed.
+        if (type === ChangeSet_1.ChangeSetType.CREATE) { // run update hooks only after we know there are other changes
+            for (const prop of meta.hydrateProps) {
+                this.processPropertyInitializers(entity, prop, type, map);
+            }
+        }
+        if (type === ChangeSet_1.ChangeSetType.UPDATE && !wrapped.__initialized && !wrapped.isTouched()) {
+            return null;
+        }
+        const changeSet = new ChangeSet_1.ChangeSet(entity, type, this.computePayload(entity), meta);
+        changeSet.originalEntity = wrapped.__originalEntityData;
+        if (this.config.get('validate')) {
+            this.validator.validate(changeSet.entity, changeSet.payload, meta);
+        }
+        for (const prop of meta.relations.filter(prop => prop.persist !== false || prop.userDefined === false)) {
+            this.processProperty(changeSet, prop);
+        }
+        if (changeSet.type === ChangeSet_1.ChangeSetType.UPDATE && !utils_1.Utils.hasObjectKeys(changeSet.payload)) {
+            return null;
+        }
+        // Execute `onCreate` and `onUpdate` on properties recursively, saves `onUpdate` results
+        // to the `map` as we want to apply those only if something else changed.
+        if (type === ChangeSet_1.ChangeSetType.UPDATE) {
+            for (const prop of meta.hydrateProps) {
+                this.processPropertyInitializers(entity, prop, type, map);
+            }
+        }
+        if (map.size > 0) {
+            for (const [entity, pairs] of map) {
+                for (const [prop, value] of pairs) {
+                    entity[prop] = value;
+                }
+            }
+            // Recompute the changeset, we need to merge this as here we ignore relations.
+            const diff = this.computePayload(entity, true);
+            utils_1.Utils.merge(changeSet.payload, diff);
+        }
+        return changeSet;
+    }
+    /**
+     * Traverses entity graph and executes `onCreate` and `onUpdate` methods, assigning the values to given properties.
+     */
+    processPropertyInitializers(entity, prop, type, map, nested) {
+        if (prop.onCreate && type === ChangeSet_1.ChangeSetType.CREATE && entity[prop.name] == null) {
+            entity[prop.name] = prop.onCreate(entity, this.em);
+        }
+        if (prop.onUpdate && type === ChangeSet_1.ChangeSetType.UPDATE) {
+            const pairs = map.get(entity) ?? [];
+            pairs.push([prop.name, prop.onUpdate(entity, this.em)]);
+            map.set(entity, pairs);
+        }
+        if (prop.kind === enums_1.ReferenceKind.EMBEDDED && entity[prop.name]) {
+            for (const embeddedProp of prop.targetMeta.hydrateProps) {
+                this.processPropertyInitializers(entity[prop.name], embeddedProp, type, map, nested || prop.object);
+            }
+        }
+    }
+    computePayload(entity, ignoreUndefined = false) {
+        const data = this.comparator.prepareEntity(entity);
+        const entityName = (0, entity_1.helper)(entity).__meta.className;
+        const originalEntityData = (0, entity_1.helper)(entity).__originalEntityData;
+        if (originalEntityData) {
+            const comparator = this.comparator.getEntityComparator(entityName);
+            const diff = comparator(originalEntityData, data);
+            if (ignoreUndefined) {
+                utils_1.Utils.keys(diff)
+                    .filter(k => diff[k] === undefined)
+                    .forEach(k => delete diff[k]);
+            }
+            return diff;
+        }
+        return data;
+    }
+    processProperty(changeSet, prop, target) {
+        if (!target) {
+            const targets = utils_1.Utils.unwrapProperty(changeSet.entity, changeSet.meta, prop);
+            targets.forEach(([t]) => this.processProperty(changeSet, prop, t));
+            return;
+        }
+        if (utils_1.Utils.isCollection(target)) { // m:n or 1:m
+            this.processToMany(prop, changeSet);
+        }
+        if ([enums_1.ReferenceKind.MANY_TO_ONE, enums_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
+            this.processToOne(prop, changeSet);
+        }
+    }
+    processToOne(prop, changeSet) {
+        const isToOneOwner = prop.kind === enums_1.ReferenceKind.MANY_TO_ONE || (prop.kind === enums_1.ReferenceKind.ONE_TO_ONE && prop.owner);
+        if (!isToOneOwner || prop.mapToPk) {
+            return;
+        }
+        const targets = utils_1.Utils.unwrapProperty(changeSet.entity, changeSet.meta, prop);
+        targets.forEach(([target, idx]) => {
+            if (!target.__helper.hasPrimaryKey()) {
+                utils_1.Utils.setPayloadProperty(changeSet.payload, this.metadata.find(changeSet.name), prop, target.__helper.__identifier, idx);
+            }
+        });
+    }
+    processToMany(prop, changeSet) {
+        const target = changeSet.entity[prop.name];
+        if (!target.isDirty()) {
+            return;
+        }
+        if (prop.owner || target.getItems(false).filter(item => !item.__helper.__initialized).length > 0) {
+            if (this.platform.usesPivotTable()) {
+                this.collectionUpdates.add(target);
+            }
+            else {
+                changeSet.payload[prop.name] = target.getItems(false).map((item) => item.__helper.__identifier ?? item.__helper.getPrimaryKey());
+            }
+        }
+        else if (prop.kind === enums_1.ReferenceKind.ONE_TO_MANY && target.getSnapshot() === undefined) {
+            this.collectionUpdates.add(target);
+        }
+        else if (prop.kind === enums_1.ReferenceKind.MANY_TO_MANY && !prop.owner) {
+            this.collectionUpdates.add(target);
+        }
+    }
+}
+exports.ChangeSetComputer = ChangeSetComputer;

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

@@ -0,0 +1,50 @@
+import type { MetadataStorage } from '../metadata';
+import type { Dictionary, EntityDictionary, EntityMetadata, IHydrator } from '../typings';
+import { type EntityFactory, type EntityValidator } from '../entity';
+import { type ChangeSet } from './ChangeSet';
+import { type Configuration } from '../utils';
+import type { DriverMethodOptions, IDatabaseDriver } from '../drivers';
+export declare class ChangeSetPersister {
+    private readonly driver;
+    private readonly metadata;
+    private readonly hydrator;
+    private readonly factory;
+    private readonly validator;
+    private readonly config;
+    private readonly platform;
+    private readonly comparator;
+    constructor(driver: IDatabaseDriver, metadata: MetadataStorage, hydrator: IHydrator, factory: EntityFactory, validator: EntityValidator, config: Configuration);
+    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>;
+    executeDeletes<T extends object>(changeSets: ChangeSet<T>[], options?: DriverMethodOptions, withSchema?: boolean): Promise<void>;
+    private runForEachSchema;
+    private processProperties;
+    private persistNewEntity;
+    private persistNewEntities;
+    private propagateSchemaFromMetadata;
+    private persistNewEntitiesBatch;
+    private persistManagedEntity;
+    private persistManagedEntities;
+    private checkConcurrencyKeys;
+    private persistManagedEntitiesBatch;
+    private mapPrimaryKey;
+    /**
+     * Sets populate flag to new entities so they are serialized like if they were loaded from the db
+     */
+    private markAsPopulated;
+    private updateEntity;
+    private checkOptimisticLocks;
+    private checkOptimisticLock;
+    /**
+     * This method also handles reloading of database default values for inserts and raw property updates,
+     * so we use a single query in case of both versioning and default values is used.
+     */
+    private reloadVersionValues;
+    private processProperty;
+    /**
+     * Maps values returned via `returning` statement (postgres) or the inserted id (other sql drivers).
+     * No need to handle composite keys here as they need to be set upfront.
+     * We do need to map to the change set payload too, as it will be used in the originalEntityData for new entities.
+     */
+    mapReturnedValues<T extends object>(entity: T, payload: EntityDictionary<T>, row: Dictionary | undefined, meta: EntityMetadata<T>): void;
+}