taon-typeorm 18.0.19 → 18.0.20

package/lib/typeorm/metadata/RelationMetadata.js

@@ -1,143 +1,237 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RelationMetadata = void 0;
-var tslib_1 = require("tslib");
-var EntityMetadata_1 = require("./EntityMetadata");
-var error_1 = require("../error");
-var ObjectUtils_1 = require("../util/ObjectUtils");
-var InstanceChecker_1 = require("../util/InstanceChecker");
+const EntityMetadata_1 = require("./EntityMetadata");
+const error_1 = require("../error");
+const ObjectUtils_1 = require("../util/ObjectUtils");
+const InstanceChecker_1 = require("../util/InstanceChecker");
 /**
  * Contains all information about some entity's relation.
  */
-var RelationMetadata = /** @class */ (function () {
+class RelationMetadata {
+    // ---------------------------------------------------------------------
+    // Public Properties
+    // ---------------------------------------------------------------------
+    /**
+     * Entity metadata of the entity where this relation is placed.
+     *
+     * For example for @ManyToMany(type => Category) in Post, entityMetadata will be metadata of Post entity.
+     */
+    entityMetadata;
+    /**
+     * Entity metadata of the entity that is targeted by this relation.
+     *
+     * For example for @ManyToMany(type => Category) in Post, inverseEntityMetadata will be metadata of Category entity.
+     */
+    inverseEntityMetadata;
+    /**
+     * Entity metadata of the junction table.
+     * Junction tables have their own entity metadata objects.
+     * Defined only for many-to-many relations.
+     */
+    junctionEntityMetadata;
+    /**
+     * Embedded metadata where this relation is.
+     * If this relation is not in embed then this property value is undefined.
+     */
+    embeddedMetadata;
+    /**
+     * Relation type, e.g. is it one-to-one, one-to-many, many-to-one or many-to-many.
+     */
+    relationType;
+    /**
+     * Target entity to which this relation is applied.
+     * Target IS NOT equal to entityMetadata.target, because relation
+     *
+     * For example for @ManyToMany(type => Category) in Post, target will be Post.
+     * If @ManyToMany(type => Category) is in Counters which is embedded into Post, target will be Counters.
+     * If @ManyToMany(type => Category) is in abstract class BaseUser which Post extends, target will be BaseUser.
+     * Target can be string if its defined in entity schema instead of class.
+     */
+    target;
+    /**
+     * Target's property name to which relation decorator is applied.
+     */
+    propertyName;
+    /**
+     * Gets full path to this column property (including relation name).
+     * Full path is relevant when column is used in embeds (one or multiple nested).
+     * For example it will return "counters.subcounters.likes".
+     * If property is not in embeds then it returns just property name of the column.
+     */
+    propertyPath;
+    /**
+     * Indicates if this is a parent (can be only many-to-one relation) relation in the tree tables.
+     */
+    isTreeParent = false;
+    /**
+     * Indicates if this is a children (can be only one-to-many relation) relation in the tree tables.
+     */
+    isTreeChildren = false;
+    /**
+     * Indicates if this relation's column is a primary key.
+     * Can be used only for many-to-one and owner one-to-one relations.
+     */
+    isPrimary = false;
+    /**
+     * Indicates if this relation is lazily loaded.
+     */
+    isLazy = false;
+    /**
+     * Indicates if this relation is eagerly loaded.
+     */
+    isEager = false;
+    /**
+     * Indicates if persistence is enabled for the relation.
+     * By default its enabled, but if you want to avoid any changes in the relation to be reflected in the database you can disable it.
+     * If its disabled you can only change a relation from inverse side of a relation or using relation query builder functionality.
+     * This is useful for performance optimization since its disabling avoid multiple extra queries during entity save.
+     */
+    persistenceEnabled = true;
+    /**
+     * When a parent is saved (with cascading but) without a child row that still exists in database, this will control what shall happen to them.
+     * delete will remove these rows from database. nullify will remove the relation key.
+     * skip will keep the relation intact. Removal of related item is only possible through its own repo.
+     */
+    orphanedRowAction;
+    /**
+     * If set to true then related objects are allowed to be inserted to the database.
+     */
+    isCascadeInsert = false;
+    /**
+     * If set to true then related objects are allowed to be updated in the database.
+     */
+    isCascadeUpdate = false;
+    /**
+     * If set to true then related objects are allowed to be remove from the database.
+     */
+    isCascadeRemove = false;
+    /**
+     * If set to true then related objects are allowed to be soft-removed from the database.
+     */
+    isCascadeSoftRemove = false;
+    /**
+     * If set to true then related objects are allowed to be recovered from the database.
+     */
+    isCascadeRecover = false;
+    /**
+     * Indicates if relation column value can be nullable or not.
+     */
+    isNullable = true;
+    /**
+     * What to do with a relation on deletion of the row containing a foreign key.
+     */
+    onDelete;
+    /**
+     * What to do with a relation on update of the row containing a foreign key.
+     */
+    onUpdate;
+    /**
+     * What to do with a relation on update of the row containing a foreign key.
+     */
+    deferrable;
+    /**
+     * Indicates whether foreign key constraints will be created for join columns.
+     * Can be used only for many-to-one and owner one-to-one relations.
+     * Defaults to true.
+     */
+    createForeignKeyConstraints = true;
+    /**
+     * Gets the property's type to which this relation is applied.
+     *
+     * For example for @ManyToMany(type => Category) in Post, target will be Category.
+     */
+    type;
+    /**
+     * Indicates if this side is an owner of this relation.
+     */
+    isOwning = false;
+    /**
+     * Checks if this relation's type is "one-to-one".
+     */
+    isOneToOne = false;
+    /**
+     * Checks if this relation is owner side of the "one-to-one" relation.
+     * Owner side means this side of relation has a join column in the table.
+     */
+    isOneToOneOwner = false;
+    /**
+     * Checks if this relation has a join column (e.g. is it many-to-one or one-to-one owner side).
+     */
+    isWithJoinColumn = false;
+    /**
+     * Checks if this relation is NOT owner side of the "one-to-one" relation.
+     * NOT owner side means this side of relation does not have a join column in the table.
+     */
+    isOneToOneNotOwner = false;
+    /**
+     * Checks if this relation's type is "one-to-many".
+     */
+    isOneToMany = false;
+    /**
+     * Checks if this relation's type is "many-to-one".
+     */
+    isManyToOne = false;
+    /**
+     * Checks if this relation's type is "many-to-many".
+     */
+    isManyToMany = false;
+    /**
+     * Checks if this relation's type is "many-to-many", and is owner side of the relationship.
+     * Owner side means this side of relation has a join table.
+     */
+    isManyToManyOwner = false;
+    /**
+     * Checks if this relation's type is "many-to-many", and is NOT owner side of the relationship.
+     * Not owner side means this side of relation does not have a join table.
+     */
+    isManyToManyNotOwner = false;
+    /**
+     * Gets the property path of the inverse side of the relation.
+     */
+    inverseSidePropertyPath;
+    /**
+     * Inverse side of the relation set by user.
+     *
+     * Inverse side set in the relation can be either string - property name of the column on inverse side,
+     * either can be a function that accepts a map of properties with the object and returns one of them.
+     * Second approach is used to achieve type-safety.
+     */
+    givenInverseSidePropertyFactory;
+    /**
+     * Gets the relation metadata of the inverse side of this relation.
+     */
+    inverseRelation;
+    /**
+     * Join table name.
+     */
+    joinTableName;
+    /**
+     * Foreign keys created for this relation.
+     */
+    foreignKeys = [];
+    /**
+     * Join table columns.
+     * Join columns can be obtained only from owner side of the relation.
+     * From non-owner side of the relation join columns will be empty.
+     * If this relation is a many-to-one/one-to-one then it takes join columns from the current entity.
+     * If this relation is many-to-many then it takes all owner join columns from the junction entity.
+     */
+    joinColumns = [];
+    /**
+     * Inverse join table columns.
+     * Inverse join columns are supported only for many-to-many relations
+     * and can be obtained only from owner side of the relation.
+     * From non-owner side of the relation join columns will be undefined.
+     */
+    inverseJoinColumns = [];
     // ---------------------------------------------------------------------
     // Constructor
     // ---------------------------------------------------------------------
-    function RelationMetadata(options) {
-        /**
-         * Indicates if this is a parent (can be only many-to-one relation) relation in the tree tables.
-         */
-        this.isTreeParent = false;
-        /**
-         * Indicates if this is a children (can be only one-to-many relation) relation in the tree tables.
-         */
-        this.isTreeChildren = false;
-        /**
-         * Indicates if this relation's column is a primary key.
-         * Can be used only for many-to-one and owner one-to-one relations.
-         */
-        this.isPrimary = false;
-        /**
-         * Indicates if this relation is lazily loaded.
-         */
-        this.isLazy = false;
-        /**
-         * Indicates if this relation is eagerly loaded.
-         */
-        this.isEager = false;
-        /**
-         * Indicates if persistence is enabled for the relation.
-         * By default its enabled, but if you want to avoid any changes in the relation to be reflected in the database you can disable it.
-         * If its disabled you can only change a relation from inverse side of a relation or using relation query builder functionality.
-         * This is useful for performance optimization since its disabling avoid multiple extra queries during entity save.
-         */
-        this.persistenceEnabled = true;
-        /**
-         * If set to true then related objects are allowed to be inserted to the database.
-         */
-        this.isCascadeInsert = false;
-        /**
-         * If set to true then related objects are allowed to be updated in the database.
-         */
-        this.isCascadeUpdate = false;
-        /**
-         * If set to true then related objects are allowed to be remove from the database.
-         */
-        this.isCascadeRemove = false;
-        /**
-         * If set to true then related objects are allowed to be soft-removed from the database.
-         */
-        this.isCascadeSoftRemove = false;
-        /**
-         * If set to true then related objects are allowed to be recovered from the database.
-         */
-        this.isCascadeRecover = false;
-        /**
-         * Indicates if relation column value can be nullable or not.
-         */
-        this.isNullable = true;
-        /**
-         * Indicates whether foreign key constraints will be created for join columns.
-         * Can be used only for many-to-one and owner one-to-one relations.
-         * Defaults to true.
-         */
-        this.createForeignKeyConstraints = true;
-        /**
-         * Indicates if this side is an owner of this relation.
-         */
-        this.isOwning = false;
-        /**
-         * Checks if this relation's type is "one-to-one".
-         */
-        this.isOneToOne = false;
-        /**
-         * Checks if this relation is owner side of the "one-to-one" relation.
-         * Owner side means this side of relation has a join column in the table.
-         */
-        this.isOneToOneOwner = false;
-        /**
-         * Checks if this relation has a join column (e.g. is it many-to-one or one-to-one owner side).
-         */
-        this.isWithJoinColumn = false;
-        /**
-         * Checks if this relation is NOT owner side of the "one-to-one" relation.
-         * NOT owner side means this side of relation does not have a join column in the table.
-         */
-        this.isOneToOneNotOwner = false;
-        /**
-         * Checks if this relation's type is "one-to-many".
-         */
-        this.isOneToMany = false;
-        /**
-         * Checks if this relation's type is "many-to-one".
-         */
-        this.isManyToOne = false;
-        /**
-         * Checks if this relation's type is "many-to-many".
-         */
-        this.isManyToMany = false;
-        /**
-         * Checks if this relation's type is "many-to-many", and is owner side of the relationship.
-         * Owner side means this side of relation has a join table.
-         */
-        this.isManyToManyOwner = false;
-        /**
-         * Checks if this relation's type is "many-to-many", and is NOT owner side of the relationship.
-         * Not owner side means this side of relation does not have a join table.
-         */
-        this.isManyToManyNotOwner = false;
-        /**
-         * Foreign keys created for this relation.
-         */
-        this.foreignKeys = [];
-        /**
-         * Join table columns.
-         * Join columns can be obtained only from owner side of the relation.
-         * From non-owner side of the relation join columns will be empty.
-         * If this relation is a many-to-one/one-to-one then it takes join columns from the current entity.
-         * If this relation is many-to-many then it takes all owner join columns from the junction entity.
-         */
-        this.joinColumns = [];
-        /**
-         * Inverse join table columns.
-         * Inverse join columns are supported only for many-to-many relations
-         * and can be obtained only from owner side of the relation.
-         * From non-owner side of the relation join columns will be undefined.
-         */
-        this.inverseJoinColumns = [];
+    constructor(options) {
         this.entityMetadata = options.entityMetadata;
         this.embeddedMetadata = options.embeddedMetadata;
-        var args = options.args;
+        const args = options.args;
         this.target = args.target;
         this.propertyName = args.propertyName;
         this.relationType = args.relationType;
@@ -212,38 +306,37 @@ var RelationMetadata = /** @class */ (function () {
     /**
      * Creates join column ids map from the given related entity ids array.
      */
-    RelationMetadata.prototype.getRelationIdMap = function (entity) {
-        var joinColumns = this.isOwning
+    getRelationIdMap(entity) {
+        const joinColumns = this.isOwning
             ? this.joinColumns
             : this.inverseRelation.joinColumns;
-        var referencedColumns = joinColumns.map(function (joinColumn) { return joinColumn.referencedColumn; });
+        const referencedColumns = joinColumns.map((joinColumn) => joinColumn.referencedColumn);
         // console.log("entity", entity);
         // console.log("referencedColumns", referencedColumns);
         return EntityMetadata_1.EntityMetadata.getValueMap(entity, referencedColumns);
-    };
+    }
     /**
      * Ensures that given object is an entity id map.
      * If given id is an object then it means its already id map.
      * If given id isn't an object then it means its a value of the id column
      * and it creates a new id map with this value and name of the primary column.
      */
-    RelationMetadata.prototype.ensureRelationIdMap = function (id) {
+    ensureRelationIdMap(id) {
         if (ObjectUtils_1.ObjectUtils.isObject(id))
             return id;
-        var joinColumns = this.isOwning
+        const joinColumns = this.isOwning
             ? this.joinColumns
             : this.inverseRelation.joinColumns;
-        var referencedColumns = joinColumns.map(function (joinColumn) { return joinColumn.referencedColumn; });
+        const referencedColumns = joinColumns.map((joinColumn) => joinColumn.referencedColumn);
         if (referencedColumns.length > 1)
-            throw new error_1.TypeORMError("Cannot create relation id map for a single value because relation contains multiple referenced columns.");
+            throw new error_1.TypeORMError(`Cannot create relation id map for a single value because relation contains multiple referenced columns.`);
         return referencedColumns[0].createValueMap(id);
-    };
+    }
     /**
      * Extracts column value from the given entity.
      * If column is in embedded (or recursive embedded) it extracts its value from there.
      */
-    RelationMetadata.prototype.getEntityValue = function (entity, getLazyRelationsPromiseValue) {
-        if (getLazyRelationsPromiseValue === void 0) { getLazyRelationsPromiseValue = false; }
+    getEntityValue(entity, getLazyRelationsPromiseValue = false) {
         if (entity === null || entity === undefined)
             return undefined;
         // extract column value from embeddeds of entity if column is in embedded
@@ -251,21 +344,21 @@ var RelationMetadata = /** @class */ (function () {
             // example: post[data][information][counters].id where "data", "information" and "counters" are embeddeds
             // we need to get value of "id" column from the post real entity object
             // first step - we extract all parent properties of the entity relative to this column, e.g. [data, information, counters]
-            var propertyNames = tslib_1.__spreadArray([], tslib_1.__read(this.embeddedMetadata.parentPropertyNames), false);
+            const propertyNames = [...this.embeddedMetadata.parentPropertyNames];
             // next we need to access post[data][information][counters][this.propertyName] to get column value from the counters
             // this recursive function takes array of generated property names and gets the post[data][information][counters] embed
-            var extractEmbeddedColumnValue_1 = function (propertyNames, value) {
-                var propertyName = propertyNames.shift();
+            const extractEmbeddedColumnValue = (propertyNames, value) => {
+                const propertyName = propertyNames.shift();
                 if (propertyName) {
                     if (value[propertyName]) {
-                        return extractEmbeddedColumnValue_1(propertyNames, value[propertyName]);
+                        return extractEmbeddedColumnValue(propertyNames, value[propertyName]);
                     }
                     return undefined;
                 }
                 return value;
             };
             // once we get nested embed object we get its column, e.g. post[data][information][counters][this.propertyName]
-            var embeddedObject = extractEmbeddedColumnValue_1(propertyNames, entity);
+            const embeddedObject = extractEmbeddedColumnValue(propertyNames, entity);
             if (this.isLazy) {
                 if (embeddedObject["__" + this.propertyName + "__"] !==
                     undefined)
@@ -291,74 +384,72 @@ var RelationMetadata = /** @class */ (function () {
             }
             return entity[this.propertyName];
         }
-    };
+    }
     /**
      * Sets given entity's relation's value.
      * Using of this method helps to set entity relation's value of the lazy and non-lazy relations.
      *
      * If merge is set to true, it merges given value into currently
      */
-    RelationMetadata.prototype.setEntityValue = function (entity, value) {
-        var propertyName = this.isLazy
+    setEntityValue(entity, value) {
+        const propertyName = this.isLazy
             ? "__" + this.propertyName + "__"
             : this.propertyName;
         if (this.embeddedMetadata) {
             // first step - we extract all parent properties of the entity relative to this column, e.g. [data, information, counters]
-            var extractEmbeddedColumnValue_2 = function (embeddedMetadatas, map) {
+            const extractEmbeddedColumnValue = (embeddedMetadatas, map) => {
                 // if (!object[embeddedMetadata.propertyName])
                 //     object[embeddedMetadata.propertyName] = embeddedMetadata.create();
-                var embeddedMetadata = embeddedMetadatas.shift();
+                const embeddedMetadata = embeddedMetadatas.shift();
                 if (embeddedMetadata) {
                     if (!map[embeddedMetadata.propertyName])
                         map[embeddedMetadata.propertyName] =
                             embeddedMetadata.create();
-                    extractEmbeddedColumnValue_2(embeddedMetadatas, map[embeddedMetadata.propertyName]);
+                    extractEmbeddedColumnValue(embeddedMetadatas, map[embeddedMetadata.propertyName]);
                     return map;
                 }
                 map[propertyName] = value;
                 return map;
             };
-            return extractEmbeddedColumnValue_2(tslib_1.__spreadArray([], tslib_1.__read(this.embeddedMetadata.embeddedMetadataTree), false), entity);
+            return extractEmbeddedColumnValue([...this.embeddedMetadata.embeddedMetadataTree], entity);
         }
         else {
             entity[propertyName] = value;
         }
-    };
+    }
     /**
      * Creates entity id map from the given entity ids array.
      */
-    RelationMetadata.prototype.createValueMap = function (value) {
-        var _a;
-        var _this = this;
+    createValueMap(value) {
         // extract column value from embeds of entity if column is in embedded
         if (this.embeddedMetadata) {
             // example: post[data][information][counters].id where "data", "information" and "counters" are embeddeds
             // we need to get value of "id" column from the post real entity object and return it in a
             // { data: { information: { counters: { id: ... } } } } format
             // first step - we extract all parent properties of the entity relative to this column, e.g. [data, information, counters]
-            var propertyNames = tslib_1.__spreadArray([], tslib_1.__read(this.embeddedMetadata.parentPropertyNames), false);
+            const propertyNames = [...this.embeddedMetadata.parentPropertyNames];
             // now need to access post[data][information][counters] to get column value from the counters
             // and on each step we need to create complex literal object, e.g. first { data },
             // then { data: { information } }, then { data: { information: { counters } } },
             // then { data: { information: { counters: [this.propertyName]: entity[data][information][counters][this.propertyName] } } }
             // this recursive function helps doing that
-            var extractEmbeddedColumnValue_3 = function (propertyNames, map) {
-                var propertyName = propertyNames.shift();
+            const extractEmbeddedColumnValue = (propertyNames, map) => {
+                const propertyName = propertyNames.shift();
                 if (propertyName) {
                     map[propertyName] = {};
-                    extractEmbeddedColumnValue_3(propertyNames, map[propertyName]);
+                    extractEmbeddedColumnValue(propertyNames, map[propertyName]);
                     return map;
                 }
-                map[_this.propertyName] = value;
+                map[this.propertyName] = value;
                 return map;
             };
-            return extractEmbeddedColumnValue_3(propertyNames, {});
+            return extractEmbeddedColumnValue(propertyNames, {});
         }
         else {
             // no embeds - no problems. Simply return column property name and its value of the entity
-            return _a = {}, _a[this.propertyName] = value, _a;
+            return { [this.propertyName]: value };
         }
-    };
+    }
     // ---------------------------------------------------------------------
     // Builder Methods
     // ---------------------------------------------------------------------
@@ -366,28 +457,21 @@ var RelationMetadata = /** @class */ (function () {
      * Builds some depend relation metadata properties.
      * This builder method should be used only after embedded metadata tree was build.
      */
-    RelationMetadata.prototype.build = function () {
+    build() {
         this.propertyPath = this.buildPropertyPath();
-    };
+    }
     /**
      * Registers given foreign keys in the relation.
      * This builder method should be used to register foreign key in the relation.
      */
-    RelationMetadata.prototype.registerForeignKeys = function () {
-        var _a;
-        var foreignKeys = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            foreignKeys[_i] = arguments[_i];
-        }
-        (_a = this.foreignKeys).push.apply(_a, tslib_1.__spreadArray([], tslib_1.__read(foreignKeys), false));
-    };
+    registerForeignKeys(...foreignKeys) {
+        this.foreignKeys.push(...foreignKeys);
+    }
     /**
      * Registers given join columns in the relation.
      * This builder method should be used to register join column in the relation.
      */
-    RelationMetadata.prototype.registerJoinColumns = function (joinColumns, inverseJoinColumns) {
-        if (joinColumns === void 0) { joinColumns = []; }
-        if (inverseJoinColumns === void 0) { inverseJoinColumns = []; }
+    registerJoinColumns(joinColumns = [], inverseJoinColumns = []) {
         this.joinColumns = joinColumns;
         this.inverseJoinColumns = inverseJoinColumns;
         this.isOwning =
@@ -399,26 +483,26 @@ var RelationMetadata = /** @class */ (function () {
         this.isManyToManyOwner = this.isManyToMany && this.isOwning;
         this.isManyToManyNotOwner = this.isManyToMany && !this.isOwning;
         this.isWithJoinColumn = this.isManyToOne || this.isOneToOneOwner;
-    };
+    }
     /**
      * Registers a given junction entity metadata.
      * This builder method can be called after junction entity metadata for the many-to-many relation was created.
      */
-    RelationMetadata.prototype.registerJunctionEntityMetadata = function (junctionEntityMetadata) {
+    registerJunctionEntityMetadata(junctionEntityMetadata) {
         this.junctionEntityMetadata = junctionEntityMetadata;
         this.joinTableName = junctionEntityMetadata.tableName;
         if (this.inverseRelation) {
             this.inverseRelation.junctionEntityMetadata = junctionEntityMetadata;
             this.joinTableName = junctionEntityMetadata.tableName;
         }
-    };
+    }
     /**
      * Builds inverse side property path based on given inverse side property factory.
      * This builder method should be used only after properties map of the inverse entity metadata was build.
      */
-    RelationMetadata.prototype.buildInverseSidePropertyPath = function () {
+    buildInverseSidePropertyPath() {
         if (this.givenInverseSidePropertyFactory) {
-            var ownerEntityPropertiesMap = this.inverseEntityMetadata.propertiesMap;
+            const ownerEntityPropertiesMap = this.inverseEntityMetadata.propertiesMap;
             if (typeof this.givenInverseSidePropertyFactory === "function")
                 return this.givenInverseSidePropertyFactory(ownerEntityPropertiesMap);
             if (typeof this.givenInverseSidePropertyFactory === "string")
@@ -433,19 +517,18 @@ var RelationMetadata = /** @class */ (function () {
             return this.entityMetadata.treeParentRelation.propertyName;
         }
         return "";
-    };
+    }
     /**
      * Builds relation's property path based on its embedded tree.
      */
-    RelationMetadata.prototype.buildPropertyPath = function () {
+    buildPropertyPath() {
         if (!this.embeddedMetadata ||
             !this.embeddedMetadata.parentPropertyNames.length)
             return this.propertyName;
         return (this.embeddedMetadata.parentPropertyNames.join(".") +
             "." +
             this.propertyName);
-    };
-    return RelationMetadata;
-}());
+    }
+}
 exports.RelationMetadata = RelationMetadata;
 //# sourceMappingURL=RelationMetadata.js.map