typeorm 0.3.0-rc.9 → 0.3.0

package/metadata/ColumnMetadata.js

@@ -1,18 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var MongoDriver_1 = require("../driver/mongodb/MongoDriver");
-var PromiseUtils_1 = require("../util/PromiseUtils");
-var FindOperator_1 = require("../find-options/FindOperator");
-var ApplyValueTransformers_1 = require("../util/ApplyValueTransformers");
+exports.ColumnMetadata = void 0;
+const OrmUtils_1 = require("../util/OrmUtils");
+const ApplyValueTransformers_1 = require("../util/ApplyValueTransformers");
+const ObjectUtils_1 = require("../util/ObjectUtils");
+const InstanceChecker_1 = require("../util/InstanceChecker");
 /**
  * This metadata contains all information about entity's column.
  */
-var ColumnMetadata = /** @class */ (function () {
+class ColumnMetadata {
     // ---------------------------------------------------------------------
     // Constructor
     // ---------------------------------------------------------------------
-    function ColumnMetadata(options) {
+    constructor(options) {
+        this["@instanceof"] = Symbol.for("ColumnMetadata");
         /**
          * Type's length in the database.
          */
@@ -41,11 +42,6 @@ var ColumnMetadata = /** @class */ (function () {
          * Indicates if column allows updates or not.
          */
         this.isUpdate = true;
-        /**
-         * Column comment.
-         * This feature is not supported by all databases.
-         */
-        this.comment = "";
         /**
          * Puts ZEROFILL attribute on to numeric column. Works only for MySQL.
          * If you specify ZEROFILL for a numeric column, MySQL automatically adds the UNSIGNED attribute to the column
@@ -79,6 +75,10 @@ var ColumnMetadata = /** @class */ (function () {
          * Indicates if this column contains an entity update date.
          */
         this.isUpdateDate = false;
+        /**
+         * Indicates if this column contains an entity delete date.
+         */
+        this.isDeleteDate = false;
         /**
          * Indicates if this column contains an entity version.
          */
@@ -114,7 +114,9 @@ var ColumnMetadata = /** @class */ (function () {
         if (options.args.options.type)
             this.type = options.args.options.type;
         if (options.args.options.length)
-            this.length = options.args.options.length ? options.args.options.length.toString() : "";
+            this.length = options.args.options.length
+                ? options.args.options.length.toString()
+                : "";
         if (options.args.options.width)
             this.width = options.args.options.width;
         if (options.args.options.charset)
@@ -123,7 +125,8 @@ var ColumnMetadata = /** @class */ (function () {
             this.collation = options.args.options.collation;
         if (options.args.options.primary)
             this.isPrimary = options.args.options.primary;
-        if (options.args.options.default === null) // to make sure default: null is the same as nullable: true
+        if (options.args.options.default === null)
+            // to make sure default: null is the same as nullable: true
             this.isNullable = true;
         if (options.args.options.nullable !== undefined)
             this.isNullable = options.args.options.nullable;
@@ -141,7 +144,10 @@ var ColumnMetadata = /** @class */ (function () {
             this.default = options.args.options.default;
         if (options.args.options.onUpdate)
             this.onUpdate = options.args.options.onUpdate;
-        if (options.args.options.scale !== null && options.args.options.scale !== undefined)
+        if (options.args.options.generatedIdentity)
+            this.generatedIdentity = options.args.options.generatedIdentity;
+        if (options.args.options.scale !== null &&
+            options.args.options.scale !== undefined)
             this.scale = options.args.options.scale;
         if (options.args.options.zerofill) {
             this.zerofill = options.args.options.zerofill;
@@ -149,13 +155,22 @@ var ColumnMetadata = /** @class */ (function () {
         }
         if (options.args.options.unsigned)
             this.unsigned = options.args.options.unsigned;
-        if (options.args.options.precision !== null && options.args.options.precision !== undefined)
+        if (options.args.options.precision !== null)
             this.precision = options.args.options.precision;
         if (options.args.options.enum) {
-            if (options.args.options.enum instanceof Object && !Array.isArray(options.args.options.enum)) {
+            if (ObjectUtils_1.ObjectUtils.isObject(options.args.options.enum) &&
+                !Array.isArray(options.args.options.enum)) {
                 this.enum = Object.keys(options.args.options.enum)
-                    .filter(function (key) { return isNaN(+key); }) // remove numeric keys - typescript numeric enum types generate them
-                    .map(function (key) { return options.args.options.enum[key]; });
+                    // remove numeric keys - typescript numeric enum types generate them
+                    // From the documentation: “declaration merging” means that the compiler merges two separate declarations
+                    // declared with the same name into a single definition. This concept is often used to merge enum with namespace
+                    // where in namespace we define e.g. utility methods for creating enum. This is well known in other languages
+                    // like Java (enum methods). Here in case if enum have function, we need to remove it from metadata, otherwise
+                    // generated SQL statements contains string representation of that function which leads into syntax error
+                    // at database side.
+                    .filter((key) => isNaN(+key) &&
+                    typeof options.args.options.enum[key] !== "function")
+                    .map((key) => options.args.options.enum[key]);
             }
             else {
                 this.enum = options.args.options.enum;
@@ -166,7 +181,9 @@ var ColumnMetadata = /** @class */ (function () {
         }
         if (options.args.options.asExpression) {
             this.asExpression = options.args.options.asExpression;
-            this.generatedType = options.args.options.generatedType ? options.args.options.generatedType : "VIRTUAL";
+            this.generatedType = options.args.options.generatedType
+                ? options.args.options.generatedType
+                : "VIRTUAL";
         }
         if (options.args.options.hstoreType)
             this.hstoreType = options.args.options.hstoreType;
@@ -177,6 +194,7 @@ var ColumnMetadata = /** @class */ (function () {
             this.isTreeLevel = options.args.mode === "treeLevel";
             this.isCreateDate = options.args.mode === "createDate";
             this.isUpdateDate = options.args.mode === "updateDate";
+            this.isDeleteDate = options.args.mode === "deleteDate";
             this.isVersion = options.args.mode === "version";
             this.isObjectId = options.args.mode === "objectId";
         }
@@ -184,7 +202,7 @@ var ColumnMetadata = /** @class */ (function () {
             this.transformer = options.args.options.transformer;
         if (options.args.options.spatialFeatureType)
             this.spatialFeatureType = options.args.options.spatialFeatureType;
-        if (options.args.options.srid)
+        if (options.args.options.srid !== undefined)
             this.srid = options.args.options.srid;
         if (this.isTreeLevel)
             this.type = options.connection.driver.mappedDataTypes.treeLevel;
@@ -192,17 +210,41 @@ var ColumnMetadata = /** @class */ (function () {
             if (!this.type)
                 this.type = options.connection.driver.mappedDataTypes.createDate;
             if (!this.default)
-                this.default = function () { return options.connection.driver.mappedDataTypes.createDateDefault; };
-            if ((this.precision === null || this.precision === undefined) && options.connection.driver.mappedDataTypes.createDatePrecision)
-                this.precision = options.connection.driver.mappedDataTypes.createDatePrecision;
+                this.default = () => options.connection.driver.mappedDataTypes.createDateDefault;
+            // skip precision if it was explicitly set to "null" in column options. Otherwise use default precision if it exist.
+            if (this.precision === undefined &&
+                options.args.options.precision === undefined &&
+                options.connection.driver.mappedDataTypes.createDatePrecision)
+                this.precision =
+                    options.connection.driver.mappedDataTypes.createDatePrecision;
         }
         if (this.isUpdateDate) {
             if (!this.type)
                 this.type = options.connection.driver.mappedDataTypes.updateDate;
             if (!this.default)
-                this.default = function () { return options.connection.driver.mappedDataTypes.updateDateDefault; };
-            if ((this.precision === null || this.precision === undefined) && options.connection.driver.mappedDataTypes.updateDatePrecision)
-                this.precision = options.connection.driver.mappedDataTypes.updateDatePrecision;
+                this.default = () => options.connection.driver.mappedDataTypes.updateDateDefault;
+            if (!this.onUpdate)
+                this.onUpdate =
+                    options.connection.driver.mappedDataTypes.updateDateDefault;
+            // skip precision if it was explicitly set to "null" in column options. Otherwise use default precision if it exist.
+            if (this.precision === undefined &&
+                options.args.options.precision === undefined &&
+                options.connection.driver.mappedDataTypes.updateDatePrecision)
+                this.precision =
+                    options.connection.driver.mappedDataTypes.updateDatePrecision;
+        }
+        if (this.isDeleteDate) {
+            if (!this.type)
+                this.type = options.connection.driver.mappedDataTypes.deleteDate;
+            if (!this.isNullable)
+                this.isNullable =
+                    options.connection.driver.mappedDataTypes.deleteDateNullable;
+            // skip precision if it was explicitly set to "null" in column options. Otherwise use default precision if it exist.
+            if (this.precision === undefined &&
+                options.args.options.precision === undefined &&
+                options.connection.driver.mappedDataTypes.deleteDatePrecision)
+                this.precision =
+                    options.connection.driver.mappedDataTypes.deleteDatePrecision;
         }
         if (this.isVersion)
             this.type = options.connection.driver.mappedDataTypes.version;
@@ -221,44 +263,51 @@ var ColumnMetadata = /** @class */ (function () {
     /**
      * Creates entity id map from the given entity ids array.
      */
-    ColumnMetadata.prototype.createValueMap = function (value, useDatabaseName) {
-        var _this = this;
-        if (useDatabaseName === void 0) { useDatabaseName = false; }
-        var _a;
+    createValueMap(value, useDatabaseName = false) {
         // 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.__spread(this.embeddedMetadata.parentPropertyNames);
+            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_1 = function (propertyNames, map) {
-                var propertyName = propertyNames.shift();
+            const extractEmbeddedColumnValue = (propertyNames, map) => {
+                const propertyName = propertyNames.shift();
                 if (propertyName) {
                     map[propertyName] = {};
-                    extractEmbeddedColumnValue_1(propertyNames, map[propertyName]);
+                    extractEmbeddedColumnValue(propertyNames, map[propertyName]);
                     return map;
                 }
                 // this is bugfix for #720 when increment number is bigint we need to make sure its a string
-                if ((_this.generationStrategy === "increment" || _this.generationStrategy === "rowid") && _this.type === "bigint")
+                if ((this.generationStrategy === "increment" ||
+                    this.generationStrategy === "rowid") &&
+                    this.type === "bigint" &&
+                    value !== null)
                     value = String(value);
-                map[useDatabaseName ? _this.databaseName : _this.propertyName] = value;
+                map[useDatabaseName ? this.databaseName : this.propertyName] =
+                    value;
                 return map;
             };
-            return extractEmbeddedColumnValue_1(propertyNames, {});
+            return extractEmbeddedColumnValue(propertyNames, {});
         }
-        else { // no embeds - no problems. Simply return column property name and its value of the entity
+        else {
+            // no embeds - no problems. Simply return column property name and its value of the entity
             // this is bugfix for #720 when increment number is bigint we need to make sure its a string
-            if ((this.generationStrategy === "increment" || this.generationStrategy === "rowid") && this.type === "bigint")
+            if ((this.generationStrategy === "increment" ||
+                this.generationStrategy === "rowid") &&
+                this.type === "bigint" &&
+                value !== null)
                 value = String(value);
-            return _a = {}, _a[useDatabaseName ? this.databaseName : this.propertyName] = value, _a;
+            return {
+                [useDatabaseName ? this.databaseName : this.propertyName]: value,
+            };
         }
-    };
+    }
     /**
      * Extracts column value and returns its column name with this value in a literal object.
      * If column is in embedded (or recursive embedded) it returns complex literal object.
@@ -266,119 +315,161 @@ var ColumnMetadata = /** @class */ (function () {
      * Examples what this method can return depend if this column is in embeds.
      * { id: 1 } or { title: "hello" }, { counters: { code: 1 } }, { data: { information: { counters: { code: 1 } } } }
      */
-    ColumnMetadata.prototype.getEntityValueMap = function (entity, options) {
-        var _this = this;
+    getEntityValueMap(entity, options) {
         var _a;
-        var returnNulls = false; // options && options.skipNulls === false ? false : true; // todo: remove if current will not bring problems, uncomment if it will.
+        const returnNulls = false; // options && options.skipNulls === false ? false : true; // todo: remove if current will not bring problems, uncomment if it will.
         // 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.__spread(this.embeddedMetadata.parentPropertyNames);
+            const propertyNames = [...this.embeddedMetadata.parentPropertyNames];
+            const isEmbeddedArray = this.embeddedMetadata.isArray;
             // 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_2 = function (propertyNames, value, map) {
-                var propertyName = propertyNames.shift();
-                if (value === undefined)
-                    return map;
+            const extractEmbeddedColumnValue = (propertyNames, value) => {
+                if (value === undefined) {
+                    return {};
+                }
+                const propertyName = propertyNames.shift();
                 if (propertyName) {
-                    var submap = {};
-                    extractEmbeddedColumnValue_2(propertyNames, value[propertyName], submap);
+                    const submap = extractEmbeddedColumnValue(propertyNames, value[propertyName]);
                     if (Object.keys(submap).length > 0) {
-                        map[propertyName] = submap;
+                        return { [propertyName]: submap };
                     }
-                    return map;
+                    return {};
                 }
-                if (value[_this.propertyName] !== undefined && (returnNulls === false || value[_this.propertyName] !== null))
-                    map[_this.propertyName] = value[_this.propertyName];
-                return map;
+                if (isEmbeddedArray && Array.isArray(value)) {
+                    return value.map((v) => ({
+                        [this.propertyName]: v[this.propertyName],
+                    }));
+                }
+                if (value[this.propertyName] !== undefined &&
+                    (returnNulls === false || value[this.propertyName] !== null)) {
+                    return { [this.propertyName]: value[this.propertyName] };
+                }
+                return {};
             };
-            var map = {};
-            extractEmbeddedColumnValue_2(propertyNames, entity, map);
+            const map = extractEmbeddedColumnValue(propertyNames, entity);
             return Object.keys(map).length > 0 ? map : undefined;
         }
-        else { // no embeds - no problems. Simply return column property name and its value of the entity
-            /*if (this.relationMetadata && entity[this.propertyName] && entity[this.propertyName] instanceof Object) { // commented since functionality is suspicious no failing test was found
+        else {
+            // no embeds - no problems. Simply return column property name and its value of the entity
+            /**
+             * Object.getOwnPropertyDescriptor checks if the relation is lazy, in which case value is a Promise
+             * DO NOT use `entity[
+                this.relationMetadata.propertyName] instanceof Promise`, which will invoke property getter and make unwanted DB request
+             * refer: https://github.com/typeorm/typeorm/pull/8676#issuecomment-1049906331
+             */
+            if (this.relationMetadata &&
+                !((_a = Object.getOwnPropertyDescriptor(entity, this.relationMetadata.propertyName)) === null || _a === void 0 ? void 0 : _a.get) &&
+                entity[this.relationMetadata.propertyName] &&
+                ObjectUtils_1.ObjectUtils.isObject(entity[this.relationMetadata.propertyName])) {
                 const map = this.relationMetadata.joinColumns.reduce((map, joinColumn) => {
-                    const value = joinColumn.referencedColumn!.getEntityValueMap(entity[this.propertyName]);
-                    if (value === undefined) return map;
-                    return OrmUtils.mergeDeep(map, value);
+                    const value = joinColumn.referencedColumn.getEntityValueMap(entity[this.relationMetadata.propertyName]);
+                    if (value === undefined)
+                        return map;
+                    return OrmUtils_1.OrmUtils.mergeDeep(map, value);
                 }, {});
                 if (Object.keys(map).length > 0)
                     return { [this.propertyName]: map };
-
                 return undefined;
-            } else {*/
-            if (entity[this.propertyName] !== undefined && (returnNulls === false || entity[this.propertyName] !== null))
-                return _a = {}, _a[this.propertyName] = entity[this.propertyName], _a;
-            return undefined;
-            // }
+            }
+            else {
+                if (entity[this.propertyName] !== undefined &&
+                    (returnNulls === false ||
+                        entity[this.propertyName] !== null))
+                    return { [this.propertyName]: entity[this.propertyName] };
+                return undefined;
+            }
         }
-    };
+    }
     /**
      * Extracts column value from the given entity.
      * If column is in embedded (or recursive embedded) it extracts its value from there.
      */
-    ColumnMetadata.prototype.getEntityValue = function (entity, transform) {
-        if (transform === void 0) { transform = false; }
+    getEntityValue(entity, transform = false) {
         if (entity === undefined || entity === null)
             return undefined;
         // extract column value from embeddeds of entity if column is in embedded
-        var value = undefined;
+        let value = undefined;
         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
             // first step - we extract all parent properties of the entity relative to this column, e.g. [data, information, counters]
-            var propertyNames = tslib_1.__spread(this.embeddedMetadata.parentPropertyNames);
+            const propertyNames = [...this.embeddedMetadata.parentPropertyNames];
+            const isEmbeddedArray = this.embeddedMetadata.isArray;
             // 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_3 = function (propertyNames, value) {
-                var propertyName = propertyNames.shift();
-                return propertyName && value ? extractEmbeddedColumnValue_3(propertyNames, value[propertyName]) : value;
+            const extractEmbeddedColumnValue = (propertyNames, value) => {
+                const propertyName = propertyNames.shift();
+                return propertyName && value
+                    ? extractEmbeddedColumnValue(propertyNames, value[propertyName])
+                    : value;
             };
             // once we get nested embed object we get its column, e.g. post[data][information][counters][this.propertyName]
-            var embeddedObject = extractEmbeddedColumnValue_3(propertyNames, entity);
+            const embeddedObject = extractEmbeddedColumnValue(propertyNames, entity);
             if (embeddedObject) {
                 if (this.relationMetadata && this.referencedColumn) {
-                    var relatedEntity = this.relationMetadata.getEntityValue(embeddedObject);
-                    if (relatedEntity && relatedEntity instanceof Object && !(relatedEntity instanceof FindOperator_1.FindOperator)) {
-                        value = this.referencedColumn.getEntityValue(PromiseUtils_1.PromiseUtils.extractValue(relatedEntity));
+                    const relatedEntity = this.relationMetadata.getEntityValue(embeddedObject);
+                    if (relatedEntity &&
+                        ObjectUtils_1.ObjectUtils.isObject(relatedEntity) &&
+                        !InstanceChecker_1.InstanceChecker.isFindOperator(relatedEntity) &&
+                        !Buffer.isBuffer(relatedEntity)) {
+                        value =
+                            this.referencedColumn.getEntityValue(relatedEntity);
                     }
-                    else if (embeddedObject[this.propertyName] && embeddedObject[this.propertyName] instanceof Object && !(embeddedObject[this.propertyName] instanceof FindOperator_1.FindOperator)) {
-                        value = this.referencedColumn.getEntityValue(PromiseUtils_1.PromiseUtils.extractValue(embeddedObject[this.propertyName]));
+                    else if (embeddedObject[this.propertyName] &&
+                        ObjectUtils_1.ObjectUtils.isObject(embeddedObject[this.propertyName]) &&
+                        !InstanceChecker_1.InstanceChecker.isFindOperator(embeddedObject[this.propertyName]) &&
+                        !Buffer.isBuffer(embeddedObject[this.propertyName]) &&
+                        !(embeddedObject[this.propertyName] instanceof Date)) {
+                        value = this.referencedColumn.getEntityValue(embeddedObject[this.propertyName]);
                     }
                     else {
-                        value = PromiseUtils_1.PromiseUtils.extractValue(embeddedObject[this.propertyName]);
+                        value = embeddedObject[this.propertyName];
                     }
                 }
                 else if (this.referencedColumn) {
-                    value = this.referencedColumn.getEntityValue(PromiseUtils_1.PromiseUtils.extractValue(embeddedObject[this.propertyName]));
+                    value = this.referencedColumn.getEntityValue(embeddedObject[this.propertyName]);
+                }
+                else if (isEmbeddedArray && Array.isArray(embeddedObject)) {
+                    value = embeddedObject.map((o) => o[this.propertyName]);
                 }
                 else {
-                    value = PromiseUtils_1.PromiseUtils.extractValue(embeddedObject[this.propertyName]);
+                    value = embeddedObject[this.propertyName];
                 }
             }
         }
-        else { // no embeds - no problems. Simply return column name by property name of the entity
+        else {
+            // no embeds - no problems. Simply return column name by property name of the entity
             if (this.relationMetadata && this.referencedColumn) {
-                var relatedEntity = this.relationMetadata.getEntityValue(entity);
-                if (relatedEntity && relatedEntity instanceof Object && !(relatedEntity instanceof FindOperator_1.FindOperator) && !(relatedEntity instanceof Function)) {
-                    value = this.referencedColumn.getEntityValue(PromiseUtils_1.PromiseUtils.extractValue(relatedEntity));
+                const relatedEntity = this.relationMetadata.getEntityValue(entity);
+                if (relatedEntity &&
+                    ObjectUtils_1.ObjectUtils.isObject(relatedEntity) &&
+                    !InstanceChecker_1.InstanceChecker.isFindOperator(relatedEntity) &&
+                    !(typeof relatedEntity === "function") &&
+                    !Buffer.isBuffer(relatedEntity)) {
+                    value = this.referencedColumn.getEntityValue(relatedEntity);
                 }
-                else if (entity[this.propertyName] && entity[this.propertyName] instanceof Object && !(entity[this.propertyName] instanceof FindOperator_1.FindOperator) && !(entity[this.propertyName] instanceof Function)) {
-                    value = this.referencedColumn.getEntityValue(PromiseUtils_1.PromiseUtils.extractValue(entity[this.propertyName]));
+                else if (entity[this.propertyName] &&
+                    ObjectUtils_1.ObjectUtils.isObject(entity[this.propertyName]) &&
+                    !InstanceChecker_1.InstanceChecker.isFindOperator(entity[this.propertyName]) &&
+                    !(typeof entity[this.propertyName] === "function") &&
+                    !Buffer.isBuffer(entity[this.propertyName]) &&
+                    !(entity[this.propertyName] instanceof Date)) {
+                    value = this.referencedColumn.getEntityValue(entity[this.propertyName]);
                 }
                 else {
                     value = entity[this.propertyName];
                 }
             }
             else if (this.referencedColumn) {
-                value = this.referencedColumn.getEntityValue(PromiseUtils_1.PromiseUtils.extractValue(entity[this.propertyName]));
+                value = this.referencedColumn.getEntityValue(entity[this.propertyName]);
             }
             else {
                 value = entity[this.propertyName];
@@ -387,87 +478,112 @@ var ColumnMetadata = /** @class */ (function () {
         if (transform && this.transformer)
             value = ApplyValueTransformers_1.ApplyValueTransformers.transformTo(this.transformer, value);
         return value;
-    };
+    }
     /**
      * Sets given entity's column value.
      * Using of this method helps to set entity relation's value of the lazy and non-lazy relations.
      */
-    ColumnMetadata.prototype.setEntityValue = function (entity, value) {
-        var _this = this;
+    setEntityValue(entity, value) {
         if (this.embeddedMetadata) {
             // first step - we extract all parent properties of the entity relative to this column, e.g. [data, information, counters]
-            var extractEmbeddedColumnValue_4 = 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_4(embeddedMetadatas, map[embeddedMetadata.propertyName]);
+                        map[embeddedMetadata.propertyName] =
+                            embeddedMetadata.create();
+                    extractEmbeddedColumnValue(embeddedMetadatas, map[embeddedMetadata.propertyName]);
                     return map;
                 }
-                map[_this.propertyName] = value;
+                map[this.propertyName] = value;
                 return map;
             };
-            return extractEmbeddedColumnValue_4(tslib_1.__spread(this.embeddedMetadata.embeddedMetadataTree), entity);
+            return extractEmbeddedColumnValue([...this.embeddedMetadata.embeddedMetadataTree], entity);
         }
         else {
-            entity[this.propertyName] = value;
+            // we write a deep object in this entity only if the column is virtual
+            // because if its not virtual it means the user defined a real column for this relation
+            // also we don't do it if column is inside a junction table
+            if (!this.entityMetadata.isJunction &&
+                this.isVirtual &&
+                this.referencedColumn &&
+                this.referencedColumn.propertyName !== this.propertyName) {
+                if (!(this.propertyName in entity)) {
+                    entity[this.propertyName] = {};
+                }
+                entity[this.propertyName][this.referencedColumn.propertyName] =
+                    value;
+            }
+            else {
+                entity[this.propertyName] = value;
+            }
         }
-    };
+    }
     /**
      * Compares given entity's column value with a given value.
      */
-    ColumnMetadata.prototype.compareEntityValue = function (entity, valueToCompareWith) {
-        var columnValue = this.getEntityValue(entity);
-        if (columnValue instanceof Object) {
+    compareEntityValue(entity, valueToCompareWith) {
+        const columnValue = this.getEntityValue(entity);
+        if (ObjectUtils_1.ObjectUtils.isObject(columnValue)) {
             return columnValue.equals(valueToCompareWith);
         }
         return columnValue === valueToCompareWith;
-    };
+    }
     // ---------------------------------------------------------------------
     // Builder Methods
     // ---------------------------------------------------------------------
-    ColumnMetadata.prototype.build = function (connection) {
+    build(connection) {
         this.propertyPath = this.buildPropertyPath();
         this.propertyAliasName = this.propertyPath.replace(".", "_");
         this.databaseName = this.buildDatabaseName(connection);
         this.databasePath = this.buildDatabasePath();
         this.databaseNameWithoutPrefixes = connection.namingStrategy.columnName(this.propertyName, this.givenDatabaseName, []);
         return this;
-    };
-    ColumnMetadata.prototype.buildPropertyPath = function () {
-        var path = "";
-        if (this.embeddedMetadata && this.embeddedMetadata.parentPropertyNames.length)
+    }
+    buildPropertyPath() {
+        let path = "";
+        if (this.embeddedMetadata &&
+            this.embeddedMetadata.parentPropertyNames.length)
             path = this.embeddedMetadata.parentPropertyNames.join(".") + ".";
         path += this.propertyName;
         // we add reference column to property path only if this column is virtual
         // because if its not virtual it means user defined a real column for this relation
         // also we don't do it if column is inside a junction table
-        if (!this.entityMetadata.isJunction && this.isVirtual && this.referencedColumn && this.referencedColumn.propertyName !== this.propertyName)
+        if (!this.entityMetadata.isJunction &&
+            this.isVirtual &&
+            this.referencedColumn &&
+            this.referencedColumn.propertyName !== this.propertyName)
             path += "." + this.referencedColumn.propertyName;
         return path;
-    };
-    ColumnMetadata.prototype.buildDatabasePath = function () {
-        var path = "";
-        if (this.embeddedMetadata && this.embeddedMetadata.parentPropertyNames.length)
+    }
+    buildDatabasePath() {
+        let path = "";
+        if (this.embeddedMetadata &&
+            this.embeddedMetadata.parentPropertyNames.length)
             path = this.embeddedMetadata.parentPropertyNames.join(".") + ".";
         path += this.databaseName;
         // we add reference column to property path only if this column is virtual
         // because if its not virtual it means user defined a real column for this relation
         // also we don't do it if column is inside a junction table
-        if (!this.entityMetadata.isJunction && this.isVirtual && this.referencedColumn && this.referencedColumn.databaseName !== this.databaseName)
+        if (!this.entityMetadata.isJunction &&
+            this.isVirtual &&
+            this.referencedColumn &&
+            this.referencedColumn.databaseName !== this.databaseName)
             path += "." + this.referencedColumn.databaseName;
         return path;
-    };
-    ColumnMetadata.prototype.buildDatabaseName = function (connection) {
-        var propertyNames = this.embeddedMetadata ? this.embeddedMetadata.parentPrefixes : [];
-        if (connection.driver instanceof MongoDriver_1.MongoDriver) // we don't need to include embedded name for the mongodb column names
+    }
+    buildDatabaseName(connection) {
+        let propertyNames = this.embeddedMetadata
+            ? this.embeddedMetadata.parentPrefixes
+            : [];
+        if (connection.driver.options.type === "mongodb")
+            // we don't need to include embedded name for the mongodb column names
             propertyNames = [];
         return connection.namingStrategy.columnName(this.propertyName, this.givenDatabaseName, propertyNames);
-    };
-    return ColumnMetadata;
-}());
+    }
+}
 exports.ColumnMetadata = ColumnMetadata;
 
 //# sourceMappingURL=ColumnMetadata.js.map