taon-typeorm 18.0.19 → 18.0.20

package/lib/typeorm/metadata/EntityMetadata.js

@@ -1,250 +1,415 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EntityMetadata = void 0;
-var tslib_1 = require("tslib");
-var CannotCreateEntityIdMapError_1 = require("../error/CannotCreateEntityIdMapError");
-var OrmUtils_1 = require("../util/OrmUtils");
-var EntityPropertyNotFoundError_1 = require("../error/EntityPropertyNotFoundError");
-var ObjectUtils_1 = require("../util/ObjectUtils");
-var StringUtils_1 = require("../util/StringUtils");
+const CannotCreateEntityIdMapError_1 = require("../error/CannotCreateEntityIdMapError");
+const OrmUtils_1 = require("../util/OrmUtils");
+const EntityPropertyNotFoundError_1 = require("../error/EntityPropertyNotFoundError");
+const ObjectUtils_1 = require("../util/ObjectUtils");
+const StringUtils_1 = require("../util/StringUtils");
 /**
  * Contains all entity metadata.
  */
-var EntityMetadata = /** @class */ (function () {
+class EntityMetadata {
+    "@instanceof" = Symbol.for("EntityMetadata");
+    // -------------------------------------------------------------------------
+    // Properties
+    // -------------------------------------------------------------------------
+    /**
+     * Connection where this entity metadata is created.
+     */
+    connection;
+    /**
+     * Metadata arguments used to build this entity metadata.
+     */
+    tableMetadataArgs;
+    /**
+     * If entity's table is a closure-typed table, then this entity will have a closure junction table metadata.
+     */
+    closureJunctionTable;
+    /**
+     * If this is entity metadata for a junction closure table then its owner closure table metadata will be set here.
+     */
+    parentClosureEntityMetadata;
+    /**
+     * Parent's entity metadata. Used in inheritance patterns.
+     */
+    parentEntityMetadata;
+    /**
+     * Children entity metadatas. Used in inheritance patterns.
+     */
+    childEntityMetadatas = [];
+    /**
+     * All "inheritance tree" from a target entity.
+     * For example for target Post < ContentModel < Unit it will be an array of [Post, ContentModel, Unit].
+     * It also contains child entities for single table inheritance.
+     */
+    inheritanceTree = [];
+    /**
+     * Table type. Tables can be closure, junction, etc.
+     */
+    tableType = "regular";
+    /**
+     * Target class to which this entity metadata is bind.
+     * Note, that when using table inheritance patterns target can be different rather then table's target.
+     * For virtual tables which lack of real entity (like junction tables) target is equal to their table name.
+     */
+    target;
+    /**
+     * Gets the name of the target.
+     */
+    targetName;
+    /**
+     * Entity's name.
+     * Equal to entity target class's name if target is set to table.
+     * If target class is not then then it equals to table name.
+     */
+    name;
+    /**
+     * View's expression.
+     * Used in views
+     */
+    expression;
+    /**
+     * View's dependencies.
+     * Used in views
+     */
+    dependsOn;
+    /**
+     * Enables Sqlite "WITHOUT ROWID" modifier for the "CREATE TABLE" statement
+     */
+    withoutRowid = false;
+    /**
+     * Original user-given table name (taken from schema or @Entity(tableName) decorator).
+     * If user haven't specified a table name this property will be undefined.
+     */
+    givenTableName;
+    /**
+     * Entity table name in the database.
+     * This is final table name of the entity.
+     * This name already passed naming strategy, and generated based on
+     * multiple criteria, including user table name and global table prefix.
+     */
+    tableName;
+    /**
+     * Entity table path. Contains database name, schema name and table name.
+     * E.g. myDB.mySchema.myTable
+     */
+    tablePath;
+    /**
+     * Gets the table name without global table prefix.
+     * When querying table you need a table name with prefix, but in some scenarios,
+     * for example when you want to name a junction table that contains names of two other tables,
+     * you may want a table name without prefix.
+     */
+    tableNameWithoutPrefix;
+    /**
+     * Indicates if schema will be synchronized for this entity or not.
+     */
+    synchronize = true;
+    /**
+     * Table's database engine type (like "InnoDB", "MyISAM", etc).
+     */
+    engine;
+    /**
+     * Database name.
+     */
+    database;
+    /**
+     * Schema name. Used in Postgres and Sql Server.
+     */
+    schema;
+    /**
+     * Specifies a default order by used for queries from this table when no explicit order by is specified.
+     */
+    orderBy;
+    /**
+     * If this entity metadata's table using one of the inheritance patterns,
+     * then this will contain what pattern it uses.
+     */
+    inheritancePattern; /*|"CTI"*/
+    /**
+     * Checks if there any non-nullable column exist in this entity.
+     */
+    hasNonNullableRelations = false;
+    /**
+     * Indicates if this entity metadata of a junction table, or not.
+     * Junction table is a table created by many-to-many relationship.
+     *
+     * Its also possible to understand if entity is junction via tableType.
+     */
+    isJunction = false;
+    /**
+     * Indicates if the entity should be instantiated using the constructor
+     * or via allocating a new object via `Object.create()`.
+     */
+    isAlwaysUsingConstructor = true;
+    /**
+     * Indicates if this entity is a tree, what type of tree it is.
+     */
+    treeType;
+    /**
+     * Indicates if this entity is a tree, what options of tree it has.
+     */
+    treeOptions;
+    /**
+     * Checks if this table is a junction table of the closure table.
+     * This type is for tables that contain junction metadata of the closure tables.
+     */
+    isClosureJunction = false;
+    /**
+     * Checks if entity's table has multiple primary columns.
+     */
+    hasMultiplePrimaryKeys = false;
+    /**
+     * Indicates if this entity metadata has uuid generated columns.
+     */
+    hasUUIDGeneratedColumns = false;
+    /**
+     * If this entity metadata is a child table of some table, it should have a discriminator value.
+     * Used to store a value in a discriminator column.
+     */
+    discriminatorValue;
+    /**
+     * Entity's column metadatas defined by user.
+     */
+    ownColumns = [];
+    /**
+     * Columns of the entity, including columns that are coming from the embeddeds of this entity.
+     */
+    columns = [];
+    /**
+     * Ancestor columns used only in closure junction tables.
+     */
+    ancestorColumns = [];
+    /**
+     * Descendant columns used only in closure junction tables.
+     */
+    descendantColumns = [];
+    /**
+     * All columns except for virtual columns.
+     */
+    nonVirtualColumns = [];
+    /**
+     * In the case if this entity metadata is junction table's entity metadata,
+     * this will contain all referenced columns of owner entity.
+     */
+    ownerColumns = [];
+    /**
+     * In the case if this entity metadata is junction table's entity metadata,
+     * this will contain all referenced columns of inverse entity.
+     */
+    inverseColumns = [];
+    /**
+     * Gets the column with generated flag.
+     */
+    generatedColumns = [];
+    /**
+     * Gets the object id column used with mongodb database.
+     */
+    objectIdColumn;
+    /**
+     * Gets entity column which contains a create date value.
+     */
+    createDateColumn;
+    /**
+     * Gets entity column which contains an update date value.
+     */
+    updateDateColumn;
+    /**
+     * Gets entity column which contains a delete date value.
+     */
+    deleteDateColumn;
+    /**
+     * Gets entity column which contains an entity version.
+     */
+    versionColumn;
+    /**
+     * Gets the discriminator column used to store entity identificator in single-table inheritance tables.
+     */
+    discriminatorColumn;
+    /**
+     * Special column that stores tree level in tree entities.
+     */
+    treeLevelColumn;
+    /**
+     * Nested set's left value column.
+     * Used only in tree entities with nested set pattern applied.
+     */
+    nestedSetLeftColumn;
+    /**
+     * Nested set's right value column.
+     * Used only in tree entities with nested set pattern applied.
+     */
+    nestedSetRightColumn;
+    /**
+     * Materialized path column.
+     * Used only in tree entities with materialized path pattern applied.
+     */
+    materializedPathColumn;
+    /**
+     * Gets the primary columns.
+     */
+    primaryColumns = [];
+    /**
+     * Entity's relation metadatas.
+     */
+    ownRelations = [];
+    /**
+     * Relations of the entity, including relations that are coming from the embeddeds of this entity.
+     */
+    relations = [];
+    /**
+     * List of eager relations this metadata has.
+     */
+    eagerRelations = [];
+    /**
+     * List of eager relations this metadata has.
+     */
+    lazyRelations = [];
+    /**
+     * Gets only one-to-one relations of the entity.
+     */
+    oneToOneRelations = [];
+    /**
+     * Gets only owner one-to-one relations of the entity.
+     */
+    ownerOneToOneRelations = [];
+    /**
+     * Gets only one-to-many relations of the entity.
+     */
+    oneToManyRelations = [];
+    /**
+     * Gets only many-to-one relations of the entity.
+     */
+    manyToOneRelations = [];
+    /**
+     * Gets only many-to-many relations of the entity.
+     */
+    manyToManyRelations = [];
+    /**
+     * Gets only owner many-to-many relations of the entity.
+     */
+    ownerManyToManyRelations = [];
+    /**
+     * Gets only owner one-to-one and many-to-one relations.
+     */
+    relationsWithJoinColumns = [];
+    /**
+     * Tree parent relation. Used only in tree-tables.
+     */
+    treeParentRelation;
+    /**
+     * Tree children relation. Used only in tree-tables.
+     */
+    treeChildrenRelation;
+    /**
+     * Entity's relation id metadatas.
+     */
+    relationIds = [];
+    /**
+     * Entity's relation id metadatas.
+     */
+    relationCounts = [];
+    /**
+     * Entity's foreign key metadatas.
+     */
+    foreignKeys = [];
+    /**
+     * Entity's embedded metadatas.
+     */
+    embeddeds = [];
+    /**
+     * All embeddeds - embeddeds from this entity metadata and from all child embeddeds, etc.
+     */
+    allEmbeddeds = [];
+    /**
+     * Entity's own indices.
+     */
+    ownIndices = [];
+    /**
+     * Entity's index metadatas.
+     */
+    indices = [];
+    /**
+     * Entity's unique metadatas.
+     */
+    uniques = [];
+    /**
+     * Entity's own uniques.
+     */
+    ownUniques = [];
+    /**
+     * Entity's check metadatas.
+     */
+    checks = [];
+    /**
+     * Entity's exclusion metadatas.
+     */
+    exclusions = [];
+    /**
+     * Entity's own listener metadatas.
+     */
+    ownListeners = [];
+    /**
+     * Entity listener metadatas.
+     */
+    listeners = [];
+    /**
+     * Listener metadatas with "AFTER LOAD" type.
+     */
+    afterLoadListeners = [];
+    /**
+     * Listener metadatas with "AFTER INSERT" type.
+     */
+    beforeInsertListeners = [];
+    /**
+     * Listener metadatas with "AFTER INSERT" type.
+     */
+    afterInsertListeners = [];
+    /**
+     * Listener metadatas with "AFTER UPDATE" type.
+     */
+    beforeUpdateListeners = [];
+    /**
+     * Listener metadatas with "AFTER UPDATE" type.
+     */
+    afterUpdateListeners = [];
+    /**
+     * Listener metadatas with "AFTER REMOVE" type.
+     */
+    beforeRemoveListeners = [];
+    /**
+     * Listener metadatas with "BEFORE SOFT REMOVE" type.
+     */
+    beforeSoftRemoveListeners = [];
+    /**
+     * Listener metadatas with "BEFORE RECOVER" type.
+     */
+    beforeRecoverListeners = [];
+    /**
+     * Listener metadatas with "AFTER REMOVE" type.
+     */
+    afterRemoveListeners = [];
+    /**
+     * Listener metadatas with "AFTER SOFT REMOVE" type.
+     */
+    afterSoftRemoveListeners = [];
+    /**
+     * Listener metadatas with "AFTER RECOVER" type.
+     */
+    afterRecoverListeners = [];
+    /**
+     * Map of columns and relations of the entity.
+     *
+     * example: Post{ id: number, name: string, counterEmbed: { count: number }, category: Category }.
+     * This method will create following object:
+     * { id: "id", counterEmbed: { count: "counterEmbed.count" }, category: "category" }
+     */
+    propertiesMap;
     // ---------------------------------------------------------------------
     // Constructor
     // ---------------------------------------------------------------------
-    function EntityMetadata(options) {
-        this["@instanceof"] = Symbol.for("EntityMetadata");
-        /**
-         * Children entity metadatas. Used in inheritance patterns.
-         */
-        this.childEntityMetadatas = [];
-        /**
-         * All "inheritance tree" from a target entity.
-         * For example for target Post < ContentModel < Unit it will be an array of [Post, ContentModel, Unit].
-         * It also contains child entities for single table inheritance.
-         */
-        this.inheritanceTree = [];
-        /**
-         * Table type. Tables can be closure, junction, etc.
-         */
-        this.tableType = "regular";
-        /**
-         * Enables Sqlite "WITHOUT ROWID" modifier for the "CREATE TABLE" statement
-         */
-        this.withoutRowid = false;
-        /**
-         * Indicates if schema will be synchronized for this entity or not.
-         */
-        this.synchronize = true;
-        /**
-         * Checks if there any non-nullable column exist in this entity.
-         */
-        this.hasNonNullableRelations = false;
-        /**
-         * Indicates if this entity metadata of a junction table, or not.
-         * Junction table is a table created by many-to-many relationship.
-         *
-         * Its also possible to understand if entity is junction via tableType.
-         */
-        this.isJunction = false;
-        /**
-         * Indicates if the entity should be instantiated using the constructor
-         * or via allocating a new object via `Object.create()`.
-         */
-        this.isAlwaysUsingConstructor = true;
-        /**
-         * Checks if this table is a junction table of the closure table.
-         * This type is for tables that contain junction metadata of the closure tables.
-         */
-        this.isClosureJunction = false;
-        /**
-         * Checks if entity's table has multiple primary columns.
-         */
-        this.hasMultiplePrimaryKeys = false;
-        /**
-         * Indicates if this entity metadata has uuid generated columns.
-         */
-        this.hasUUIDGeneratedColumns = false;
-        /**
-         * Entity's column metadatas defined by user.
-         */
-        this.ownColumns = [];
-        /**
-         * Columns of the entity, including columns that are coming from the embeddeds of this entity.
-         */
-        this.columns = [];
-        /**
-         * Ancestor columns used only in closure junction tables.
-         */
-        this.ancestorColumns = [];
-        /**
-         * Descendant columns used only in closure junction tables.
-         */
-        this.descendantColumns = [];
-        /**
-         * All columns except for virtual columns.
-         */
-        this.nonVirtualColumns = [];
-        /**
-         * In the case if this entity metadata is junction table's entity metadata,
-         * this will contain all referenced columns of owner entity.
-         */
-        this.ownerColumns = [];
-        /**
-         * In the case if this entity metadata is junction table's entity metadata,
-         * this will contain all referenced columns of inverse entity.
-         */
-        this.inverseColumns = [];
-        /**
-         * Gets the column with generated flag.
-         */
-        this.generatedColumns = [];
-        /**
-         * Gets the primary columns.
-         */
-        this.primaryColumns = [];
-        /**
-         * Entity's relation metadatas.
-         */
-        this.ownRelations = [];
-        /**
-         * Relations of the entity, including relations that are coming from the embeddeds of this entity.
-         */
-        this.relations = [];
-        /**
-         * List of eager relations this metadata has.
-         */
-        this.eagerRelations = [];
-        /**
-         * List of eager relations this metadata has.
-         */
-        this.lazyRelations = [];
-        /**
-         * Gets only one-to-one relations of the entity.
-         */
-        this.oneToOneRelations = [];
-        /**
-         * Gets only owner one-to-one relations of the entity.
-         */
-        this.ownerOneToOneRelations = [];
-        /**
-         * Gets only one-to-many relations of the entity.
-         */
-        this.oneToManyRelations = [];
-        /**
-         * Gets only many-to-one relations of the entity.
-         */
-        this.manyToOneRelations = [];
-        /**
-         * Gets only many-to-many relations of the entity.
-         */
-        this.manyToManyRelations = [];
-        /**
-         * Gets only owner many-to-many relations of the entity.
-         */
-        this.ownerManyToManyRelations = [];
-        /**
-         * Gets only owner one-to-one and many-to-one relations.
-         */
-        this.relationsWithJoinColumns = [];
-        /**
-         * Entity's relation id metadatas.
-         */
-        this.relationIds = [];
-        /**
-         * Entity's relation id metadatas.
-         */
-        this.relationCounts = [];
-        /**
-         * Entity's foreign key metadatas.
-         */
-        this.foreignKeys = [];
-        /**
-         * Entity's embedded metadatas.
-         */
-        this.embeddeds = [];
-        /**
-         * All embeddeds - embeddeds from this entity metadata and from all child embeddeds, etc.
-         */
-        this.allEmbeddeds = [];
-        /**
-         * Entity's own indices.
-         */
-        this.ownIndices = [];
-        /**
-         * Entity's index metadatas.
-         */
-        this.indices = [];
-        /**
-         * Entity's unique metadatas.
-         */
-        this.uniques = [];
-        /**
-         * Entity's own uniques.
-         */
-        this.ownUniques = [];
-        /**
-         * Entity's check metadatas.
-         */
-        this.checks = [];
-        /**
-         * Entity's exclusion metadatas.
-         */
-        this.exclusions = [];
-        /**
-         * Entity's own listener metadatas.
-         */
-        this.ownListeners = [];
-        /**
-         * Entity listener metadatas.
-         */
-        this.listeners = [];
-        /**
-         * Listener metadatas with "AFTER LOAD" type.
-         */
-        this.afterLoadListeners = [];
-        /**
-         * Listener metadatas with "AFTER INSERT" type.
-         */
-        this.beforeInsertListeners = [];
-        /**
-         * Listener metadatas with "AFTER INSERT" type.
-         */
-        this.afterInsertListeners = [];
-        /**
-         * Listener metadatas with "AFTER UPDATE" type.
-         */
-        this.beforeUpdateListeners = [];
-        /**
-         * Listener metadatas with "AFTER UPDATE" type.
-         */
-        this.afterUpdateListeners = [];
-        /**
-         * Listener metadatas with "AFTER REMOVE" type.
-         */
-        this.beforeRemoveListeners = [];
-        /**
-         * Listener metadatas with "BEFORE SOFT REMOVE" type.
-         */
-        this.beforeSoftRemoveListeners = [];
-        /**
-         * Listener metadatas with "BEFORE RECOVER" type.
-         */
-        this.beforeRecoverListeners = [];
-        /**
-         * Listener metadatas with "AFTER REMOVE" type.
-         */
-        this.afterRemoveListeners = [];
-        /**
-         * Listener metadatas with "AFTER SOFT REMOVE" type.
-         */
-        this.afterSoftRemoveListeners = [];
-        /**
-         * Listener metadatas with "AFTER RECOVER" type.
-         */
-        this.afterRecoverListeners = [];
+    constructor(options) {
         this.connection = options.connection;
         this.inheritanceTree = options.inheritanceTree || [];
         this.inheritancePattern = options.inheritancePattern;
@@ -266,13 +431,12 @@ var EntityMetadata = /** @class */ (function () {
     /**
      * Creates a new entity.
      */
-    EntityMetadata.prototype.create = function (queryRunner, options) {
-        var _this = this;
-        var pojo = options && options.pojo === true ? true : false;
+    create(queryRunner, options) {
+        const pojo = options && options.pojo === true ? true : false;
         // if target is set to a function (e.g. class) that can be created then create it
-        var ret;
+        let ret;
         if (typeof this.target === "function" && !pojo) {
-            if (!(options === null || options === void 0 ? void 0 : options.fromDeserializer) || this.isAlwaysUsingConstructor) {
+            if (!options?.fromDeserializer || this.isAlwaysUsingConstructor) {
                 ret = new this.target();
             }
             else {
@@ -287,68 +451,66 @@ var EntityMetadata = /** @class */ (function () {
         if (this.connection.options.typename) {
             ret[this.connection.options.typename] = this.targetName;
         }
-        this.lazyRelations.forEach(function (relation) {
-            return _this.connection.relationLoader.enableLazyLoad(relation, ret, queryRunner);
-        });
+        this.lazyRelations.forEach((relation) => this.connection.relationLoader.enableLazyLoad(relation, ret, queryRunner));
         return ret;
-    };
+    }
     /**
      * Checks if given entity has an id.
      */
-    EntityMetadata.prototype.hasId = function (entity) {
+    hasId(entity) {
         if (!entity)
             return false;
-        return this.primaryColumns.every(function (primaryColumn) {
-            var value = primaryColumn.getEntityValue(entity);
+        return this.primaryColumns.every((primaryColumn) => {
+            const value = primaryColumn.getEntityValue(entity);
             return value !== null && value !== undefined && value !== "";
         });
-    };
+    }
     /**
      * Checks if given entity / object contains ALL primary keys entity must have.
      * Returns true if it contains all of them, false if at least one of them is not defined.
      */
-    EntityMetadata.prototype.hasAllPrimaryKeys = function (entity) {
-        return this.primaryColumns.every(function (primaryColumn) {
-            var value = primaryColumn.getEntityValue(entity);
+    hasAllPrimaryKeys(entity) {
+        return this.primaryColumns.every((primaryColumn) => {
+            const value = primaryColumn.getEntityValue(entity);
             return value !== null && value !== undefined;
         });
-    };
+    }
     /**
      * 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.
      */
-    EntityMetadata.prototype.ensureEntityIdMap = function (id) {
+    ensureEntityIdMap(id) {
         if (ObjectUtils_1.ObjectUtils.isObject(id))
             return id;
         if (this.hasMultiplePrimaryKeys)
             throw new CannotCreateEntityIdMapError_1.CannotCreateEntityIdMapError(this, id);
         return this.primaryColumns[0].createValueMap(id);
-    };
+    }
     /**
      * Gets primary keys of the entity and returns them in a literal object.
      * For example, for Post{ id: 1, title: "hello" } where id is primary it will return { id: 1 }
      * For multiple primary keys it returns multiple keys in object.
      * For primary keys inside embeds it returns complex object literal with keys in them.
      */
-    EntityMetadata.prototype.getEntityIdMap = function (entity) {
+    getEntityIdMap(entity) {
         if (!entity)
             return undefined;
         return EntityMetadata.getValueMap(entity, this.primaryColumns, {
             skipNulls: true,
         });
-    };
+    }
     /**
      * Creates a "mixed id map".
      * If entity has multiple primary keys (ids) then it will return just regular id map, like what getEntityIdMap returns.
      * But if entity has a single primary key then it will return just value of the id column of the entity, just value.
      * This is called mixed id map.
      */
-    EntityMetadata.prototype.getEntityIdMixedMap = function (entity) {
+    getEntityIdMixedMap(entity) {
         if (!entity)
             return entity;
-        var idMap = this.getEntityIdMap(entity);
+        const idMap = this.getEntityIdMap(entity);
         if (this.hasMultiplePrimaryKeys) {
             return idMap;
         }
@@ -356,146 +518,142 @@ var EntityMetadata = /** @class */ (function () {
             return this.primaryColumns[0].getEntityValue(idMap); // todo: what about parent primary column?
         }
         return idMap;
-    };
+    }
     /**
      * Compares two different entities by their ids.
      * Returns true if they match, false otherwise.
      */
-    EntityMetadata.prototype.compareEntities = function (firstEntity, secondEntity) {
-        var firstEntityIdMap = this.getEntityIdMap(firstEntity);
+    compareEntities(firstEntity, secondEntity) {
+        const firstEntityIdMap = this.getEntityIdMap(firstEntity);
         if (!firstEntityIdMap)
             return false;
-        var secondEntityIdMap = this.getEntityIdMap(secondEntity);
+        const secondEntityIdMap = this.getEntityIdMap(secondEntity);
         if (!secondEntityIdMap)
             return false;
         return OrmUtils_1.OrmUtils.compareIds(firstEntityIdMap, secondEntityIdMap);
-    };
+    }
     /**
      * Finds column with a given property name.
      */
-    EntityMetadata.prototype.findColumnWithPropertyName = function (propertyName) {
-        return this.columns.find(function (column) { return column.propertyName === propertyName; });
-    };
+    findColumnWithPropertyName(propertyName) {
+        return this.columns.find((column) => column.propertyName === propertyName);
+    }
     /**
      * Finds column with a given database name.
      */
-    EntityMetadata.prototype.findColumnWithDatabaseName = function (databaseName) {
-        return this.columns.find(function (column) { return column.databaseName === databaseName; });
-    };
+    findColumnWithDatabaseName(databaseName) {
+        return this.columns.find((column) => column.databaseName === databaseName);
+    }
     /**
      * Checks if there is a column or relationship with a given property path.
      */
-    EntityMetadata.prototype.hasColumnWithPropertyPath = function (propertyPath) {
-        var hasColumn = this.columns.some(function (column) { return column.propertyPath === propertyPath; });
+    hasColumnWithPropertyPath(propertyPath) {
+        const hasColumn = this.columns.some((column) => column.propertyPath === propertyPath);
         return hasColumn || this.hasRelationWithPropertyPath(propertyPath);
-    };
+    }
     /**
      * Finds column with a given property path.
      */
-    EntityMetadata.prototype.findColumnWithPropertyPath = function (propertyPath) {
-        var column = this.columns.find(function (column) { return column.propertyPath === propertyPath; });
+    findColumnWithPropertyPath(propertyPath) {
+        const column = this.columns.find((column) => column.propertyPath === propertyPath);
         if (column)
             return column;
         // in the case if column with property path was not found, try to find a relation with such property path
         // if we find relation and it has a single join column then its the column user was seeking
-        var relation = this.relations.find(function (relation) { return relation.propertyPath === propertyPath; });
+        const relation = this.relations.find((relation) => relation.propertyPath === propertyPath);
         if (relation && relation.joinColumns.length === 1)
             return relation.joinColumns[0];
         return undefined;
-    };
+    }
     /**
      * Finds column with a given property path.
      * Does not search in relation unlike findColumnWithPropertyPath.
      */
-    EntityMetadata.prototype.findColumnWithPropertyPathStrict = function (propertyPath) {
-        return this.columns.find(function (column) { return column.propertyPath === propertyPath; });
-    };
+    findColumnWithPropertyPathStrict(propertyPath) {
+        return this.columns.find((column) => column.propertyPath === propertyPath);
+    }
     /**
      * Finds columns with a given property path.
      * Property path can match a relation, and relations can contain multiple columns.
      */
-    EntityMetadata.prototype.findColumnsWithPropertyPath = function (propertyPath) {
-        var column = this.columns.find(function (column) { return column.propertyPath === propertyPath; });
+    findColumnsWithPropertyPath(propertyPath) {
+        const column = this.columns.find((column) => column.propertyPath === propertyPath);
         if (column)
             return [column];
         // in the case if column with property path was not found, try to find a relation with such property path
         // if we find relation and it has a single join column then its the column user was seeking
-        var relation = this.findRelationWithPropertyPath(propertyPath);
+        const relation = this.findRelationWithPropertyPath(propertyPath);
         if (relation && relation.joinColumns)
             return relation.joinColumns;
         return [];
-    };
+    }
     /**
      * Checks if there is a relation with the given property path.
      */
-    EntityMetadata.prototype.hasRelationWithPropertyPath = function (propertyPath) {
-        return this.relations.some(function (relation) { return relation.propertyPath === propertyPath; });
-    };
+    hasRelationWithPropertyPath(propertyPath) {
+        return this.relations.some((relation) => relation.propertyPath === propertyPath);
+    }
     /**
      * Finds relation with the given property path.
      */
-    EntityMetadata.prototype.findRelationWithPropertyPath = function (propertyPath) {
-        return this.relations.find(function (relation) { return relation.propertyPath === propertyPath; });
-    };
+    findRelationWithPropertyPath(propertyPath) {
+        return this.relations.find((relation) => relation.propertyPath === propertyPath);
+    }
     /**
      * Checks if there is an embedded with a given property path.
      */
-    EntityMetadata.prototype.hasEmbeddedWithPropertyPath = function (propertyPath) {
-        return this.allEmbeddeds.some(function (embedded) { return embedded.propertyPath === propertyPath; });
-    };
+    hasEmbeddedWithPropertyPath(propertyPath) {
+        return this.allEmbeddeds.some((embedded) => embedded.propertyPath === propertyPath);
+    }
     /**
      * Finds embedded with a given property path.
      */
-    EntityMetadata.prototype.findEmbeddedWithPropertyPath = function (propertyPath) {
-        return this.allEmbeddeds.find(function (embedded) { return embedded.propertyPath === propertyPath; });
-    };
+    findEmbeddedWithPropertyPath(propertyPath) {
+        return this.allEmbeddeds.find((embedded) => embedded.propertyPath === propertyPath);
+    }
     /**
      * Returns an array of databaseNames mapped from provided propertyPaths
      */
-    EntityMetadata.prototype.mapPropertyPathsToColumns = function (propertyPaths) {
-        var _this = this;
-        return propertyPaths.map(function (propertyPath) {
-            var column = _this.findColumnWithPropertyPath(propertyPath);
+    mapPropertyPathsToColumns(propertyPaths) {
+        return propertyPaths.map((propertyPath) => {
+            const column = this.findColumnWithPropertyPath(propertyPath);
             if (column == null) {
-                throw new EntityPropertyNotFoundError_1.EntityPropertyNotFoundError(propertyPath, _this);
+                throw new EntityPropertyNotFoundError_1.EntityPropertyNotFoundError(propertyPath, this);
             }
             return column;
         });
-    };
+    }
     /**
      * Iterates through entity and finds and extracts all values from relations in the entity.
      * If relation value is an array its being flattened.
      */
-    EntityMetadata.prototype.extractRelationValuesFromEntity = function (entity, relations) {
-        var _this = this;
-        var relationsAndValues = [];
-        relations.forEach(function (relation) {
-            var value = relation.getEntityValue(entity);
+    extractRelationValuesFromEntity(entity, relations) {
+        const relationsAndValues = [];
+        relations.forEach((relation) => {
+            const value = relation.getEntityValue(entity);
             if (Array.isArray(value)) {
-                value.forEach(function (subValue) {
-                    return relationsAndValues.push([
-                        relation,
-                        subValue,
-                        _this.getInverseEntityMetadata(subValue, relation),
-                    ]);
-                });
+                value.forEach((subValue) => relationsAndValues.push([
+                    relation,
+                    subValue,
+                    this.getInverseEntityMetadata(subValue, relation),
+                ]));
             }
             else if (value) {
                 relationsAndValues.push([
                     relation,
                     value,
-                    _this.getInverseEntityMetadata(value, relation),
+                    this.getInverseEntityMetadata(value, relation),
                 ]);
             }
         });
         return relationsAndValues;
-    };
-    EntityMetadata.prototype.getInverseEntityMetadata = function (value, relation) {
-        var childEntityMetadata = relation.inverseEntityMetadata.childEntityMetadatas.find(function (metadata) { return metadata.target === value.constructor; });
+    }
+    getInverseEntityMetadata(value, relation) {
+        const childEntityMetadata = relation.inverseEntityMetadata.childEntityMetadatas.find((metadata) => metadata.target === value.constructor);
         return childEntityMetadata
             ? childEntityMetadata
             : relation.inverseEntityMetadata;
-    };
+    }
     // -------------------------------------------------------------------------
     // Public Static Methods
     // -------------------------------------------------------------------------
@@ -504,57 +662,52 @@ var EntityMetadata = /** @class */ (function () {
      *
      * @deprecated
      */
-    EntityMetadata.createPropertyPath = function (metadata, entity, prefix) {
-        var _this = this;
-        if (prefix === void 0) { prefix = ""; }
-        var paths = [];
-        Object.keys(entity).forEach(function (key) {
+    static createPropertyPath(metadata, entity, prefix = "") {
+        const paths = [];
+        Object.keys(entity).forEach((key) => {
             // check for function is needed in the cases when createPropertyPath used on values contain a function as a value
             // example: .update().set({ name: () => `SUBSTR('', 1, 2)` })
-            var parentPath = prefix ? prefix + "." + key : key;
+            const parentPath = prefix ? prefix + "." + key : key;
             if (metadata.hasEmbeddedWithPropertyPath(parentPath)) {
-                var subPaths = _this.createPropertyPath(metadata, entity[key], parentPath);
-                paths.push.apply(paths, tslib_1.__spreadArray([], tslib_1.__read(subPaths), false));
+                const subPaths = this.createPropertyPath(metadata, entity[key], parentPath);
+                paths.push(...subPaths);
             }
             else {
-                var path = prefix ? prefix + "." + key : key;
+                const path = prefix ? prefix + "." + key : key;
                 paths.push(path);
             }
         });
         return paths;
-    };
+    }
     /**
      * Finds difference between two entity id maps.
      * Returns items that exist in the first array and absent in the second array.
      */
-    EntityMetadata.difference = function (firstIdMaps, secondIdMaps) {
-        return firstIdMaps.filter(function (firstIdMap) {
-            return !secondIdMaps.find(function (secondIdMap) {
-                return OrmUtils_1.OrmUtils.compareIds(firstIdMap, secondIdMap);
-            });
+    static difference(firstIdMaps, secondIdMaps) {
+        return firstIdMaps.filter((firstIdMap) => {
+            return !secondIdMaps.find((secondIdMap) => OrmUtils_1.OrmUtils.compareIds(firstIdMap, secondIdMap));
         });
-    };
+    }
     /**
      * Creates value map from the given values and columns.
      * Examples of usages are primary columns map and join columns map.
      */
-    EntityMetadata.getValueMap = function (entity, columns, options) {
-        return columns.reduce(function (map, column) {
-            var value = column.getEntityValueMap(entity, options);
+    static getValueMap(entity, columns, options) {
+        return columns.reduce((map, column) => {
+            const value = column.getEntityValueMap(entity, options);
             // make sure that none of the values of the columns are not missing
             if (map === undefined || value === null || value === undefined)
                 return undefined;
             return OrmUtils_1.OrmUtils.mergeDeep(map, value);
         }, {});
-    };
+    }
     // ---------------------------------------------------------------------
     // Public Builder Methods
     // ---------------------------------------------------------------------
-    EntityMetadata.prototype.build = function () {
-        var _a;
-        var namingStrategy = this.connection.namingStrategy;
-        var entityPrefix = this.connection.options.entityPrefix;
-        var entitySkipConstructor = this.connection.options.entitySkipConstructor;
+    build() {
+        const namingStrategy = this.connection.namingStrategy;
+        const entityPrefix = this.connection.options.entityPrefix;
+        const entitySkipConstructor = this.connection.options.entitySkipConstructor;
         this.engine = this.tableMetadataArgs.engine;
         this.database =
             this.tableMetadataArgs.type === "entity-child" &&
@@ -568,7 +721,7 @@ var EntityMetadata = /** @class */ (function () {
             this.parentEntityMetadata) {
             this.schema = this.parentEntityMetadata.schema;
         }
-        else if ((_a = this.connection.options) === null || _a === void 0 ? void 0 : _a.hasOwnProperty("schema")) {
+        else if (this.connection.options?.hasOwnProperty("schema")) {
             this.schema = this.connection.options.schema;
         }
         this.givenTableName =
@@ -624,27 +777,23 @@ var EntityMetadata = /** @class */ (function () {
                 this.tableMetadataArgs.type === "junction";
         this.isClosureJunction =
             this.tableMetadataArgs.type === "closure-junction";
-    };
+    }
     /**
      * Registers a new column in the entity and recomputes all depend properties.
      */
-    EntityMetadata.prototype.registerColumn = function (column) {
+    registerColumn(column) {
         if (this.ownColumns.indexOf(column) !== -1)
             return;
         this.ownColumns.push(column);
-        this.columns = this.embeddeds.reduce(function (columns, embedded) { return columns.concat(embedded.columnsFromTree); }, this.ownColumns);
-        this.primaryColumns = this.columns.filter(function (column) { return column.isPrimary; });
+        this.columns = this.embeddeds.reduce((columns, embedded) => columns.concat(embedded.columnsFromTree), this.ownColumns);
+        this.primaryColumns = this.columns.filter((column) => column.isPrimary);
         this.hasMultiplePrimaryKeys = this.primaryColumns.length > 1;
         this.hasUUIDGeneratedColumns =
-            this.columns.filter(function (column) {
-                return column.isGenerated || column.generationStrategy === "uuid";
-            }).length > 0;
+            this.columns.filter((column) => column.isGenerated || column.generationStrategy === "uuid").length > 0;
         this.propertiesMap = this.createPropertiesMap();
         if (this.childEntityMetadatas)
-            this.childEntityMetadatas.forEach(function (entityMetadata) {
-                return entityMetadata.registerColumn(column);
-            });
-    };
+            this.childEntityMetadatas.forEach((entityMetadata) => entityMetadata.registerColumn(column));
+    }
     /**
      * Creates a special object - all columns and relations of the object (plus columns and relations from embeds)
      * in a special format - { propertyName: propertyName }.
@@ -653,24 +802,20 @@ var EntityMetadata = /** @class */ (function () {
      * This method will create following object:
      * { id: "id", counterEmbed: { count: "counterEmbed.count" }, category: "category" }
      */
-    EntityMetadata.prototype.createPropertiesMap = function () {
-        var map = {};
-        this.columns.forEach(function (column) {
-            return OrmUtils_1.OrmUtils.mergeDeep(map, column.createValueMap(column.propertyPath));
-        });
-        this.relations.forEach(function (relation) {
-            return OrmUtils_1.OrmUtils.mergeDeep(map, relation.createValueMap(relation.propertyPath));
-        });
+    createPropertiesMap() {
+        const map = {};
+        this.columns.forEach((column) => OrmUtils_1.OrmUtils.mergeDeep(map, column.createValueMap(column.propertyPath)));
+        this.relations.forEach((relation) => OrmUtils_1.OrmUtils.mergeDeep(map, relation.createValueMap(relation.propertyPath)));
         return map;
-    };
+    }
     /**
      * Checks if entity has any column which rely on returning data,
      * e.g. columns with auto generated value, DEFAULT values considered as dependant of returning data.
      * For example, if we need to have RETURNING after INSERT (or we need returned id for DBs not supporting RETURNING),
      * it means we cannot execute bulk inserts in some cases.
      */
-    EntityMetadata.prototype.getInsertionReturningColumns = function () {
-        return this.columns.filter(function (column) {
+    getInsertionReturningColumns() {
+        return this.columns.filter((column) => {
             return (column.default !== undefined ||
                 column.isGenerated ||
                 column.isCreateDate ||
@@ -678,8 +823,7 @@ var EntityMetadata = /** @class */ (function () {
                 column.isDeleteDate ||
                 column.isVersion);
         });
-    };
-    return EntityMetadata;
-}());
+    }
+}
 exports.EntityMetadata = EntityMetadata;
 //# sourceMappingURL=EntityMetadata.js.map