typeorm 0.3.29-dev.cc07c90 → 1.0.0-beta.1

package/browser/metadata/ColumnMetadata.js

@@ -1,11 +1,15 @@
-import { OrmUtils } from "../util/OrmUtils";
-import { ApplyValueTransformers } from "../util/ApplyValueTransformers";
-import { ObjectUtils } from "../util/ObjectUtils";
-import { InstanceChecker } from "../util/InstanceChecker";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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");
+const Uint8ArrayUtils_1 = require("../util/Uint8ArrayUtils");
 /**
  * This metadata contains all information about entity's column.
  */
-export class ColumnMetadata {
+class ColumnMetadata {
     // ---------------------------------------------------------------------
     // Constructor
     // ---------------------------------------------------------------------
@@ -44,11 +48,6 @@ export class ColumnMetadata {
          * Only applies to "date" column type.
          */
         this.utc = false;
-        /**
-         * 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
-         */
-        this.zerofill = false;
         /**
          * Puts UNSIGNED attribute on to numeric column. Works only for MySQL.
          */
@@ -64,7 +63,7 @@ export class ColumnMetadata {
         /**
          * Indicates if column is a virtual property. Virtual properties are not mapped to the entity.
          * This property is used in tandem the virtual column decorator.
-         * @See https://typeorm.io/docs/Help/decorator-reference/#virtualcolumn for more details.
+         * @see https://typeorm.io/docs/Help/decorator-reference/#virtualcolumn for more details.
          */
         this.isVirtualProperty = false;
         /**
@@ -111,6 +110,7 @@ export class ColumnMetadata {
          */
         this.isMaterializedPath = false;
         this.entityMetadata = options.entityMetadata;
+        const driver = this.entityMetadata.dataSource.driver;
         this.embeddedMetadata = options.embeddedMetadata;
         this.referencedColumn = options.referencedColumn;
         if (options.args.target)
@@ -125,8 +125,6 @@ export class ColumnMetadata {
             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)
             this.charset = options.args.options.charset;
         if (options.args.options.collation)
@@ -146,8 +144,6 @@ export class ColumnMetadata {
             this.utc = options.args.options.utc;
         if (options.args.options.update !== undefined)
             this.isUpdate = options.args.options.update;
-        if (options.args.options.readonly !== undefined)
-            this.isUpdate = !options.args.options.readonly;
         if (options.args.options.comment)
             this.comment = options.args.options.comment;
         if (options.args.options.default !== undefined)
@@ -159,16 +155,12 @@ export class ColumnMetadata {
         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;
-            this.unsigned = true; // if you specify ZEROFILL for a numeric column, MySQL automatically adds the UNSIGNED attribute to the column
-        }
         if (options.args.options.unsigned)
             this.unsigned = options.args.options.unsigned;
         if (options.args.options.precision !== null)
             this.precision = options.args.options.precision;
         if (options.args.options.enum) {
-            if (ObjectUtils.isObject(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)
                     // remove numeric keys - typescript numeric enum types generate them
@@ -230,49 +222,44 @@ export class ColumnMetadata {
         if (options.args.options.query)
             this.query = options.args.options.query;
         if (this.isTreeLevel)
-            this.type = options.connection.driver.mappedDataTypes.treeLevel;
+            this.type = driver.mappedDataTypes.treeLevel;
         if (this.isCreateDate) {
             if (!this.type)
-                this.type = options.connection.driver.mappedDataTypes.createDate;
+                this.type = driver.mappedDataTypes.createDate;
             if (!this.default)
-                this.default = () => options.connection.driver.mappedDataTypes.createDateDefault;
+                this.default = () => 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;
+                driver.mappedDataTypes.createDatePrecision)
+                this.precision = driver.mappedDataTypes.createDatePrecision;
         }
         if (this.isUpdateDate) {
             if (!this.type)
-                this.type = options.connection.driver.mappedDataTypes.updateDate;
+                this.type = driver.mappedDataTypes.updateDate;
             if (!this.default)
-                this.default = () => options.connection.driver.mappedDataTypes.updateDateDefault;
+                this.default = () => driver.mappedDataTypes.updateDateDefault;
             if (!this.onUpdate)
-                this.onUpdate =
-                    options.connection.driver.mappedDataTypes.updateDateDefault;
+                this.onUpdate = 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;
+                driver.mappedDataTypes.updateDatePrecision)
+                this.precision = driver.mappedDataTypes.updateDatePrecision;
         }
         if (this.isDeleteDate) {
             if (!this.type)
-                this.type = options.connection.driver.mappedDataTypes.deleteDate;
+                this.type = driver.mappedDataTypes.deleteDate;
             if (!this.isNullable)
-                this.isNullable =
-                    options.connection.driver.mappedDataTypes.deleteDateNullable;
+                this.isNullable = 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;
+                driver.mappedDataTypes.deleteDatePrecision)
+                this.precision = driver.mappedDataTypes.deleteDatePrecision;
         }
         if (this.isVersion)
-            this.type = options.connection.driver.mappedDataTypes.version;
+            this.type = driver.mappedDataTypes.version;
         if (options.closureType)
             this.closureType = options.closureType;
         if (options.nestedSetLeft)
@@ -287,6 +274,8 @@ export class ColumnMetadata {
     // ---------------------------------------------------------------------
     /**
      * Creates entity id map from the given entity ids array.
+     * @param value
+     * @param useDatabaseName
      */
     createValueMap(value, useDatabaseName = false) {
         // extract column value from embeds of entity if column is in embedded
@@ -339,6 +328,9 @@ export class ColumnMetadata {
      *
      * 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 } } } }
+     * @param entity
+     * @param options
+     * @param options.skipNulls
      */
     getEntityValueMap(entity, options) {
         const returnNulls = false; // options && options.skipNulls === false ? false : true; // todo: remove if current will not bring problems, uncomment if it will.
@@ -348,28 +340,38 @@ export class ColumnMetadata {
             // 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]
-            const propertyNames = [...this.embeddedMetadata.parentPropertyNames];
+            const embeddedMetadataTree = [
+                ...this.embeddedMetadata.embeddedMetadataTree,
+            ];
             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
-            const extractEmbeddedColumnValue = (propertyNames, value) => {
+            const extractEmbeddedColumnValue = (embeddedMetadataTree, value) => {
                 if (value === undefined) {
                     return {};
                 }
-                const propertyName = propertyNames.shift();
-                if (propertyName) {
-                    const submap = extractEmbeddedColumnValue(propertyNames, value[propertyName]);
+                const embeddedMetadata = embeddedMetadataTree.at(0);
+                if (embeddedMetadata) {
+                    const embeddedPropertyName = embeddedMetadata.propertyName;
+                    const embeddedPropertyValue = value[embeddedPropertyName];
+                    if (embeddedMetadata.isArray &&
+                        Array.isArray(embeddedPropertyValue)) {
+                        return {
+                            [embeddedPropertyName]: embeddedPropertyValue.map((element) => extractEmbeddedColumnValue(embeddedMetadataTree.slice(1), element)),
+                        };
+                    }
+                    const submap = extractEmbeddedColumnValue(embeddedMetadataTree.slice(1), embeddedPropertyValue);
                     if (Object.keys(submap).length > 0) {
-                        return { [propertyName]: submap };
+                        return { [embeddedPropertyName]: submap };
                     }
                     return {};
                 }
                 if (isEmbeddedArray && Array.isArray(value)) {
-                    return value.map((v) => ({
-                        [this.propertyName]: v[this.propertyName],
+                    return value.map((element) => ({
+                        [this.propertyName]: element[this.propertyName],
                     }));
                 }
                 if (value[this.propertyName] !== undefined &&
@@ -378,7 +380,7 @@ export class ColumnMetadata {
                 }
                 return {};
             };
-            const map = extractEmbeddedColumnValue(propertyNames, entity);
+            const map = extractEmbeddedColumnValue(embeddedMetadataTree, entity);
             return Object.keys(map).length > 0 ? map : undefined;
         }
         else {
@@ -386,19 +388,19 @@ export class ColumnMetadata {
             /**
              * 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
+             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 &&
                 !Object.getOwnPropertyDescriptor(entity, this.relationMetadata.propertyName)?.get &&
                 entity[this.relationMetadata.propertyName] &&
-                ObjectUtils.isObject(entity[this.relationMetadata.propertyName])) {
+                ObjectUtils_1.ObjectUtils.isObject(entity[this.relationMetadata.propertyName])) {
                 if (this.relationMetadata.joinColumns.length > 1) {
                     const map = this.relationMetadata.joinColumns.reduce((map, joinColumn) => {
                         const value = joinColumn.referencedColumn.getEntityValueMap(entity[this.relationMetadata.propertyName]);
                         if (value === undefined)
                             return map;
-                        return OrmUtils.mergeDeep(map, value);
+                        return OrmUtils_1.OrmUtils.mergeDeep(map, value);
                     }, {});
                     if (Object.keys(map).length > 0)
                         return { [this.propertyName]: map };
@@ -424,10 +426,12 @@ export class ColumnMetadata {
     /**
      * Extracts column value from the given entity.
      * If column is in embedded (or recursive embedded) it extracts its value from there.
+     * @param entity
+     * @param transform
      */
     getEntityValue(entity, transform = false) {
         if (entity === undefined || entity === null)
-            return undefined;
+            return entity;
         // extract column value from embeddeds of entity if column is in embedded
         let value = undefined;
         if (this.embeddedMetadata) {
@@ -450,16 +454,16 @@ export class ColumnMetadata {
                 if (this.relationMetadata && this.referencedColumn) {
                     const relatedEntity = this.relationMetadata.getEntityValue(embeddedObject);
                     if (relatedEntity &&
-                        ObjectUtils.isObject(relatedEntity) &&
-                        !InstanceChecker.isFindOperator(relatedEntity) &&
-                        !Buffer.isBuffer(relatedEntity)) {
+                        ObjectUtils_1.ObjectUtils.isObject(relatedEntity) &&
+                        !InstanceChecker_1.InstanceChecker.isFindOperator(relatedEntity) &&
+                        !(0, Uint8ArrayUtils_1.isUint8Array)(relatedEntity)) {
                         value =
                             this.referencedColumn.getEntityValue(relatedEntity);
                     }
                     else if (embeddedObject[this.propertyName] &&
-                        ObjectUtils.isObject(embeddedObject[this.propertyName]) &&
-                        !InstanceChecker.isFindOperator(embeddedObject[this.propertyName]) &&
-                        !Buffer.isBuffer(embeddedObject[this.propertyName]) &&
+                        ObjectUtils_1.ObjectUtils.isObject(embeddedObject[this.propertyName]) &&
+                        !InstanceChecker_1.InstanceChecker.isFindOperator(embeddedObject[this.propertyName]) &&
+                        !(0, Uint8ArrayUtils_1.isUint8Array)(embeddedObject[this.propertyName]) &&
                         !(embeddedObject[this.propertyName] instanceof Date)) {
                         value = this.referencedColumn.getEntityValue(embeddedObject[this.propertyName]);
                     }
@@ -483,17 +487,17 @@ export class ColumnMetadata {
             if (this.relationMetadata && this.referencedColumn) {
                 const relatedEntity = this.relationMetadata.getEntityValue(entity);
                 if (relatedEntity &&
-                    ObjectUtils.isObject(relatedEntity) &&
-                    !InstanceChecker.isFindOperator(relatedEntity) &&
+                    ObjectUtils_1.ObjectUtils.isObject(relatedEntity) &&
+                    !InstanceChecker_1.InstanceChecker.isFindOperator(relatedEntity) &&
                     !(typeof relatedEntity === "function") &&
-                    !Buffer.isBuffer(relatedEntity)) {
+                    !(0, Uint8ArrayUtils_1.isUint8Array)(relatedEntity)) {
                     value = this.referencedColumn.getEntityValue(relatedEntity);
                 }
                 else if (entity[this.propertyName] &&
-                    ObjectUtils.isObject(entity[this.propertyName]) &&
-                    !InstanceChecker.isFindOperator(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]) &&
+                    !(0, Uint8ArrayUtils_1.isUint8Array)(entity[this.propertyName]) &&
                     !(entity[this.propertyName] instanceof Date)) {
                     value = this.referencedColumn.getEntityValue(entity[this.propertyName]);
                 }
@@ -509,12 +513,14 @@ export class ColumnMetadata {
             }
         }
         if (transform && this.transformer)
-            value = ApplyValueTransformers.transformTo(this.transformer, value);
+            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.
+     * @param entity
+     * @param value
      */
     setEntityValue(entity, value) {
         if (this.embeddedMetadata) {
@@ -556,9 +562,14 @@ export class ColumnMetadata {
     }
     /**
      * Compares given entity's column value with a given value.
+     * @param entity
+     * @param valueToCompareWith
      */
     compareEntityValue(entity, valueToCompareWith) {
         const columnValue = this.getEntityValue(entity);
+        if ((0, Uint8ArrayUtils_1.isUint8Array)(columnValue) && (0, Uint8ArrayUtils_1.isUint8Array)(valueToCompareWith)) {
+            return (0, Uint8ArrayUtils_1.areUint8ArraysEqual)(columnValue, valueToCompareWith);
+        }
         if (typeof columnValue?.equals === "function") {
             return columnValue.equals(valueToCompareWith);
         }
@@ -567,12 +578,12 @@ export class ColumnMetadata {
     // ---------------------------------------------------------------------
     // Builder Methods
     // ---------------------------------------------------------------------
-    build(connection) {
+    build(dataSource) {
         this.propertyPath = this.buildPropertyPath();
         this.propertyAliasName = this.propertyPath.replace(".", "_");
-        this.databaseName = this.buildDatabaseName(connection);
+        this.databaseName = this.buildDatabaseName(dataSource);
         this.databasePath = this.buildDatabasePath();
-        this.databaseNameWithoutPrefixes = connection.namingStrategy.columnName(this.propertyName, this.givenDatabaseName, []);
+        this.databaseNameWithoutPrefixes = dataSource.namingStrategy.columnName(this.propertyName, this.givenDatabaseName, []);
         return this;
     }
     buildPropertyPath() {
@@ -607,15 +618,15 @@ export class ColumnMetadata {
             path += "." + this.referencedColumn.databaseName;
         return path;
     }
-    buildDatabaseName(connection) {
+    buildDatabaseName(dataSource) {
         let propertyNames = this.embeddedMetadata
             ? this.embeddedMetadata.parentPrefixes
             : [];
-        if (connection.driver.options.type === "mongodb")
+        if (dataSource.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 dataSource.namingStrategy.columnName(this.propertyName, this.givenDatabaseName, propertyNames);
     }
 }
-
-//# sourceMappingURL=ColumnMetadata.js.map
+exports.ColumnMetadata = ColumnMetadata;
+//# sourceMappingURL=ColumnMetadata.js.map