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

package/browser/driver/postgres/PostgresDriver.js

@@ -1,23 +1,33 @@
-import { ConnectionIsNotSetError } from "../../error/ConnectionIsNotSetError";
-import { DriverPackageNotInstalledError } from "../../error/DriverPackageNotInstalledError";
-import { PlatformTools } from "../../platform/PlatformTools";
-import { RdbmsSchemaBuilder } from "../../schema-builder/RdbmsSchemaBuilder";
-import { ApplyValueTransformers } from "../../util/ApplyValueTransformers";
-import { DateUtils } from "../../util/DateUtils";
-import { OrmUtils } from "../../util/OrmUtils";
-import { VersionUtils } from "../../util/VersionUtils";
-import { PostgresQueryRunner } from "./PostgresQueryRunner";
-import { DriverUtils } from "../DriverUtils";
-import { TypeORMError } from "../../error";
-import { InstanceChecker } from "../../util/InstanceChecker";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgresDriver = void 0;
+const error_1 = require("../../error");
+const ConnectionIsNotSetError_1 = require("../../error/ConnectionIsNotSetError");
+const DriverPackageNotInstalledError_1 = require("../../error/DriverPackageNotInstalledError");
+const PlatformTools_1 = require("../../platform/PlatformTools");
+const RdbmsSchemaBuilder_1 = require("../../schema-builder/RdbmsSchemaBuilder");
+const ApplyValueTransformers_1 = require("../../util/ApplyValueTransformers");
+const DateUtils_1 = require("../../util/DateUtils");
+const InstanceChecker_1 = require("../../util/InstanceChecker");
+const OrmUtils_1 = require("../../util/OrmUtils");
+const VersionUtils_1 = require("../../util/VersionUtils");
+const DriverUtils_1 = require("../DriverUtils");
+const PostgresQueryRunner_1 = require("./PostgresQueryRunner");
 /**
  * Organizes communication with PostgreSQL DBMS.
  */
-export class PostgresDriver {
+class PostgresDriver {
+    /**
+     * DataSource used by the driver.
+     * @deprecated since 1.0.0. Use {@link dataSource} instance instead.
+     */
+    get connection() {
+        return this.dataSource;
+    }
     // -------------------------------------------------------------------------
     // Constructor
     // -------------------------------------------------------------------------
-    constructor(connection) {
+    constructor(dataSource) {
         /**
          * Pool for slave databases.
          * Used in replication.
@@ -41,7 +51,6 @@ export class PostgresDriver {
         this.transactionSupport = "nested";
         /**
          * Gets list of supported column data types by a driver.
-         *
          * @see https://www.postgresql.org/docs/current/datatype.html
          */
         this.supportedDataTypes = [
@@ -188,6 +197,17 @@ export class PostgresDriver {
             metadataName: "varchar",
             metadataValue: "text",
         };
+        /**
+         * Table indices supported
+         */
+        this.supportedIndexTypes = [
+            "brin",
+            "btree",
+            "gin",
+            "gist",
+            "hash",
+            "spgist",
+        ];
         /**
          * The prefix used for the parameters
          */
@@ -217,21 +237,26 @@ export class PostgresDriver {
             requiresRecursiveHint: true,
             materializedHint: true,
         };
-        if (!connection) {
+        this.compareTableIndexTypes = (indexA, indexB) => {
+            const normalizedA = indexA.isSpatial ? "gist" : (indexA.type ?? "btree");
+            const normalizedB = indexB.isSpatial ? "gist" : (indexB.type ?? "btree");
+            return normalizedA.toLowerCase() === normalizedB.toLowerCase();
+        };
+        if (!dataSource) {
             return;
         }
-        this.connection = connection;
-        this.options = connection.options;
+        this.dataSource = dataSource;
+        this.options = dataSource.options;
         this.isReplicated = this.options.replication ? true : false;
         if (this.options.useUTC) {
             process.env.PGTZ = "UTC";
         }
         // load postgres package
         this.loadDependencies();
-        this.database = DriverUtils.buildDriverOptions(this.options.replication
+        this.database = DriverUtils_1.DriverUtils.buildDriverOptions(this.options.replication
             ? this.options.replication.master
             : this.options).database;
-        this.schema = DriverUtils.buildDriverOptions(this.options).schema;
+        this.schema = DriverUtils_1.DriverUtils.buildDriverOptions(this.options).schema;
         // ObjectUtils.assign(this.options, DriverUtils.buildDriverOptions(connection.options)); // todo: do it better way
         // validate options to make sure everything is set
         // todo: revisit validation with replication in mind
@@ -281,18 +306,40 @@ export class PostgresDriver {
      * Makes any action after connection (e.g. create extensions in Postgres driver).
      */
     async afterConnect() {
-        const extensionsMetadata = await this.checkMetadataForExtensions();
         const [connection, release] = await this.obtainMasterConnection();
         const installExtensions = this.options.installExtensions === undefined ||
             this.options.installExtensions;
-        if (installExtensions && extensionsMetadata.hasExtensions) {
-            await this.enableExtensions(extensionsMetadata, connection);
+        if (installExtensions) {
+            const extensionsMetadata = await this.checkMetadataForExtensions();
+            const extensionsToInstall = this.options.extensions;
+            if (extensionsMetadata.hasExtensions)
+                await this.enableExtensions(extensionsMetadata, connection);
+            if (extensionsToInstall) {
+                const availableExtensions = await this.getAvailableExtensions(connection);
+                await this.enableCustomExtensions(availableExtensions, extensionsToInstall, connection);
+            }
         }
-        this.isGeneratedColumnsSupported = VersionUtils.isGreaterOrEqual(this.version, "12.0");
+        this.isGeneratedColumnsSupported = VersionUtils_1.VersionUtils.isGreaterOrEqual(this.version, "12.0");
         await release();
     }
+    async getAvailableExtensions(connection) {
+        const availableExtensions = new Set();
+        const { logger } = this.dataSource;
+        try {
+            const result = await this.executeQuery(connection, `SELECT name FROM pg_available_extensions`);
+            if (result.rows && Array.isArray(result.rows)) {
+                result.rows.forEach((row) => {
+                    availableExtensions.add(row.name);
+                });
+            }
+        }
+        catch (_) {
+            logger.log("warn", "Could not retrieve available extensions. Extension installation may fail if extensions are not available.");
+        }
+        return availableExtensions;
+    }
     async enableExtensions(extensionsMetadata, connection) {
-        const { logger } = this.connection;
+        const { logger } = this.dataSource;
         const { hasUuidColumns, hasCitextColumns, hasHstoreColumns, hasCubeColumns, hasGeometryColumns, hasLtreeColumns, hasVectorColumns, hasExclusionConstraints, } = extensionsMetadata;
         if (hasUuidColumns)
             try {
@@ -352,31 +399,49 @@ export class PostgresDriver {
                 logger.log("warn", "At least one of the entities has an exclusion constraint, but the 'btree_gist' extension cannot be installed automatically. Please install it manually using superuser rights");
             }
     }
+    async enableCustomExtensions(availableExtensions, extensionsToInstall, connection) {
+        if (!extensionsToInstall)
+            return;
+        const logger = this.dataSource.logger;
+        for (const extension of extensionsToInstall) {
+            if (availableExtensions.has(extension)) {
+                try {
+                    await this.executeQuery(connection, `CREATE EXTENSION IF NOT EXISTS "${extension}"`);
+                }
+                catch (_) {
+                    logger.log("warn", `The extension "${extension}" cannot be installed automatically. Please install it manually using superuser rights`);
+                }
+            }
+            else {
+                logger.log("warn", `The extension "${extension}" is not available on this database. Please install it manually using superuser rights`);
+            }
+        }
+    }
     async checkMetadataForExtensions() {
-        const hasUuidColumns = this.connection.entityMetadatas.some((metadata) => {
+        const hasUuidColumns = this.dataSource.entityMetadatas.some((metadata) => {
             return (metadata.generatedColumns.filter((column) => column.generationStrategy === "uuid").length > 0);
         });
-        const hasCitextColumns = this.connection.entityMetadatas.some((metadata) => {
+        const hasCitextColumns = this.dataSource.entityMetadatas.some((metadata) => {
             return (metadata.columns.filter((column) => column.type === "citext").length > 0);
         });
-        const hasHstoreColumns = this.connection.entityMetadatas.some((metadata) => {
+        const hasHstoreColumns = this.dataSource.entityMetadatas.some((metadata) => {
             return (metadata.columns.filter((column) => column.type === "hstore").length > 0);
         });
-        const hasCubeColumns = this.connection.entityMetadatas.some((metadata) => {
+        const hasCubeColumns = this.dataSource.entityMetadatas.some((metadata) => {
             return (metadata.columns.filter((column) => column.type === "cube")
                 .length > 0);
         });
-        const hasGeometryColumns = this.connection.entityMetadatas.some((metadata) => {
+        const hasGeometryColumns = this.dataSource.entityMetadatas.some((metadata) => {
             return (metadata.columns.filter((column) => this.spatialTypes.indexOf(column.type) >= 0).length > 0);
         });
-        const hasLtreeColumns = this.connection.entityMetadatas.some((metadata) => {
+        const hasLtreeColumns = this.dataSource.entityMetadatas.some((metadata) => {
             return (metadata.columns.filter((column) => column.type === "ltree")
                 .length > 0);
         });
-        const hasVectorColumns = this.connection.entityMetadatas.some((metadata) => {
+        const hasVectorColumns = this.dataSource.entityMetadatas.some((metadata) => {
             return metadata.columns.some((column) => column.type === "vector" || column.type === "halfvec");
         });
-        const hasExclusionConstraints = this.connection.entityMetadatas.some((metadata) => {
+        const hasExclusionConstraints = this.dataSource.entityMetadatas.some((metadata) => {
             return metadata.exclusions.length > 0;
         });
         return {
@@ -403,7 +468,7 @@ export class PostgresDriver {
      */
     async disconnect() {
         if (!this.master) {
-            throw new ConnectionIsNotSetError("postgres");
+            throw new ConnectionIsNotSetError_1.ConnectionIsNotSetError("postgres");
         }
         await this.closePool(this.master);
         await Promise.all(this.slaves.map((slave) => this.closePool(slave)));
@@ -414,39 +479,60 @@ export class PostgresDriver {
      * Creates a schema builder used to build and sync a schema.
      */
     createSchemaBuilder() {
-        return new RdbmsSchemaBuilder(this.connection);
+        return new RdbmsSchemaBuilder_1.RdbmsSchemaBuilder(this.dataSource);
     }
     /**
      * Creates a query runner used to execute database queries.
+     * @param mode
      */
     createQueryRunner(mode) {
-        return new PostgresQueryRunner(this, mode);
+        return new PostgresQueryRunner_1.PostgresQueryRunner(this, mode);
     }
     /**
      * Prepares given value to a value to be persisted, based on its column type and metadata.
+     * @param value
+     * @param columnMetadata
      */
     preparePersistentValue(value, columnMetadata) {
         if (columnMetadata.transformer)
-            value = ApplyValueTransformers.transformTo(columnMetadata.transformer, value);
+            value = ApplyValueTransformers_1.ApplyValueTransformers.transformTo(columnMetadata.transformer, value);
         if (value === null || value === undefined)
             return value;
         if (columnMetadata.type === Boolean) {
             return value === true ? 1 : 0;
         }
         else if (columnMetadata.type === "date") {
-            return DateUtils.mixedDateToDateString(value, {
+            return DateUtils_1.DateUtils.mixedDateToDateString(value, {
                 utc: columnMetadata.utc,
             });
         }
         else if (columnMetadata.type === "time") {
-            return DateUtils.mixedDateToTimeString(value);
+            return DateUtils_1.DateUtils.mixedDateToTimeString(value);
         }
         else if (columnMetadata.type === "datetime" ||
             columnMetadata.type === Date ||
             columnMetadata.type === "timestamp" ||
+            columnMetadata.type === "timestamptz" ||
             columnMetadata.type === "timestamp with time zone" ||
             columnMetadata.type === "timestamp without time zone") {
-            return DateUtils.mixedDateToDate(value);
+            return DateUtils_1.DateUtils.mixedDateToDate(value);
+        }
+        else if (columnMetadata.type === "point") {
+            if (typeof value === "object" &&
+                value.x !== undefined &&
+                value.y !== undefined) {
+                return `(${value.x},${value.y})`;
+            }
+            return value;
+        }
+        else if (columnMetadata.type === "circle") {
+            if (typeof value === "object" &&
+                value.x !== undefined &&
+                value.y !== undefined &&
+                value.radius !== undefined) {
+                return `<(${value.x},${value.y}),${value.radius}>`;
+            }
+            return value;
         }
         else if (["json", "jsonb", ...this.spatialTypes].indexOf(columnMetadata.type) >= 0) {
             return JSON.stringify(value);
@@ -482,10 +568,10 @@ export class PostgresDriver {
             }
         }
         else if (columnMetadata.type === "simple-array") {
-            return DateUtils.simpleArrayToString(value);
+            return DateUtils_1.DateUtils.simpleArrayToString(value);
         }
         else if (columnMetadata.type === "simple-json") {
-            return DateUtils.simpleJsonToString(value);
+            return DateUtils_1.DateUtils.simpleJsonToString(value);
         }
         else if (columnMetadata.type === "cube") {
             if (columnMetadata.isArray) {
@@ -511,11 +597,13 @@ export class PostgresDriver {
     }
     /**
      * Prepares given value to a value to be persisted, based on its column type or metadata.
+     * @param value
+     * @param columnMetadata
      */
     prepareHydratedValue(value, columnMetadata) {
         if (value === null || value === undefined)
             return columnMetadata.transformer
-                ? ApplyValueTransformers.transformFrom(columnMetadata.transformer, value)
+                ? ApplyValueTransformers_1.ApplyValueTransformers.transformFrom(columnMetadata.transformer, value)
                 : value;
         if (columnMetadata.type === Boolean) {
             value = value ? true : false;
@@ -523,17 +611,18 @@ export class PostgresDriver {
         else if (columnMetadata.type === "datetime" ||
             columnMetadata.type === Date ||
             columnMetadata.type === "timestamp" ||
+            columnMetadata.type === "timestamptz" ||
             columnMetadata.type === "timestamp with time zone" ||
             columnMetadata.type === "timestamp without time zone") {
-            value = DateUtils.normalizeHydratedDate(value);
+            value = DateUtils_1.DateUtils.normalizeHydratedDate(value);
         }
         else if (columnMetadata.type === "date") {
-            value = DateUtils.mixedDateToDateString(value, {
+            value = DateUtils_1.DateUtils.mixedDateToDateString(value, {
                 utc: columnMetadata.utc,
             });
         }
         else if (columnMetadata.type === "time") {
-            value = DateUtils.mixedTimeToString(value);
+            value = DateUtils_1.DateUtils.mixedTimeToString(value);
         }
         else if (columnMetadata.type === "vector" ||
             columnMetadata.type === "halfvec") {
@@ -560,10 +649,10 @@ export class PostgresDriver {
             }
         }
         else if (columnMetadata.type === "simple-array") {
-            value = DateUtils.stringToSimpleArray(value);
+            value = DateUtils_1.DateUtils.stringToSimpleArray(value);
         }
         else if (columnMetadata.type === "simple-json") {
-            value = DateUtils.stringToSimpleJson(value);
+            value = DateUtils_1.DateUtils.stringToSimpleJson(value);
         }
         else if (columnMetadata.type === "cube") {
             value = value.replace(/[()\s]+/g, ""); // remove whitespace
@@ -577,7 +666,7 @@ export class PostgresDriver {
                 const regexp = /(?:"((?:[\d\s.,])*)")|(?:(NULL))/g;
                 const unparsedArrayString = value;
                 value = [];
-                let cube = null;
+                let cube;
                 // Iterate through all regexp matches for cubes/null in array
                 while ((cube = regexp.exec(unparsedArrayString)) !== null) {
                     if (cube[1] !== undefined) {
@@ -630,15 +719,17 @@ export class PostgresDriver {
             value = !isNaN(+value) ? parseInt(value) : value;
         }
         if (columnMetadata.transformer)
-            value = ApplyValueTransformers.transformFrom(columnMetadata.transformer, value);
+            value = ApplyValueTransformers_1.ApplyValueTransformers.transformFrom(columnMetadata.transformer, value);
         return value;
     }
     /**
      * Replaces parameters in the given sql with special escaping character
      * and an array of parameter names to be passed to a query.
+     * @param sql
+     * @param parameters
      */
-    escapeQueryWithParameters(sql, parameters, nativeParameters) {
-        const escapedParameters = Object.keys(nativeParameters).map((key) => nativeParameters[key]);
+    escapeQueryWithParameters(sql, parameters) {
+        const escapedParameters = [];
         if (!parameters || !Object.keys(parameters).length)
             return [sql, escapedParameters];
         const parameterIndexMap = new Map();
@@ -669,13 +760,16 @@ export class PostgresDriver {
     }
     /**
      * Escapes a column name.
+     * @param columnName
      */
     escape(columnName) {
-        return '"' + columnName + '"';
+        return `"${columnName.replaceAll('"', '""')}"`;
     }
     /**
      * Build full table name with schema name and table name.
      * E.g. myDB.mySchema.myTable
+     * @param tableName
+     * @param schema
      */
     buildTableName(tableName, schema) {
         const tablePath = [tableName];
@@ -686,11 +780,12 @@ export class PostgresDriver {
     }
     /**
      * Parse a target table name or other types and return a normalized table definition.
+     * @param target
      */
     parseTableName(target) {
         const driverDatabase = this.database;
         const driverSchema = this.schema;
-        if (InstanceChecker.isTable(target) || InstanceChecker.isView(target)) {
+        if (InstanceChecker_1.InstanceChecker.isTable(target) || InstanceChecker_1.InstanceChecker.isView(target)) {
             const parsed = this.parseTableName(target.name);
             return {
                 database: target.database || parsed.database || driverDatabase,
@@ -698,7 +793,7 @@ export class PostgresDriver {
                 tableName: parsed.tableName,
             };
         }
-        if (InstanceChecker.isTableForeignKey(target)) {
+        if (InstanceChecker_1.InstanceChecker.isTableForeignKey(target)) {
             const parsed = this.parseTableName(target.referencedTableName);
             return {
                 database: target.referencedDatabase ||
@@ -708,7 +803,7 @@ export class PostgresDriver {
                 tableName: parsed.tableName,
             };
         }
-        if (InstanceChecker.isEntityMetadata(target)) {
+        if (InstanceChecker_1.InstanceChecker.isEntityMetadata(target)) {
             // EntityMetadata tableName is never a path
             return {
                 database: target.database || driverDatabase,
@@ -725,6 +820,12 @@ export class PostgresDriver {
     }
     /**
      * Creates a database type from a given column metadata.
+     * @param column
+     * @param column.type
+     * @param column.length
+     * @param column.precision
+     * @param column.scale
+     * @param column.isArray
      */
     normalizeType(column) {
         if (column.type === Number ||
@@ -786,6 +887,7 @@ export class PostgresDriver {
     }
     /**
      * Normalizes "default" value of the column.
+     * @param columnMetadata
      */
     normalizeDefault(columnMetadata) {
         const defaultValue = columnMetadata.default;
@@ -810,39 +912,74 @@ export class PostgresDriver {
             return this.normalizeDatetimeFunction(value);
         }
         if (typeof defaultValue === "object") {
-            return `'${JSON.stringify(defaultValue)}'`;
+            return `'${JSON.stringify(defaultValue).replaceAll("'", "''")}'`;
         }
         return `${defaultValue}`;
     }
     /**
      * Compares "default" value of the column.
-     * Postgres sorts json values before it is saved, so in that case a deep comparison has to be performed to see if has changed.
+     * @param columnMetadata
+     * @param tableColumn
      */
     defaultEqual(columnMetadata, tableColumn) {
+        // defaults are equal if both are undefined or null
+        if ((columnMetadata.default === null ||
+            columnMetadata.default === undefined) &&
+            (tableColumn.default === null || tableColumn.default === undefined))
+            return true;
         if (["json", "jsonb"].includes(columnMetadata.type) &&
             !["function", "undefined"].includes(typeof columnMetadata.default)) {
-            const tableColumnDefault = typeof tableColumn.default === "string"
-                ? JSON.parse(tableColumn.default.substring(1, tableColumn.default.length - 1))
-                : tableColumn.default;
-            return OrmUtils.deepCompare(columnMetadata.default, tableColumnDefault);
+            return this.compareJsonDefaults(columnMetadata, tableColumn);
         }
         const columnDefault = this.lowerDefaultValueIfNecessary(this.normalizeDefault(columnMetadata));
         return columnDefault === tableColumn.default;
     }
+    /**
+     * Compares json/jsonb default values of the column.
+     * @param columnMetadata
+     * @param tableColumn
+     */
+    compareJsonDefaults(columnMetadata, tableColumn) {
+        let jsonString = tableColumn.default;
+        if (typeof jsonString === "string") {
+            jsonString = jsonString.trim();
+            if (jsonString.startsWith("'") && jsonString.endsWith("'")) {
+                jsonString = jsonString.slice(1, -1).replaceAll("''", "'");
+            }
+        }
+        if (typeof jsonString === "string") {
+            try {
+                const tableColumnDefault = JSON.parse(jsonString);
+                return OrmUtils_1.OrmUtils.deepCompare(columnMetadata.default, tableColumnDefault);
+            }
+            catch (err) {
+                if (!(err instanceof SyntaxError)) {
+                    throw new error_1.TypeORMError(`Failed to compare default values of ${columnMetadata.propertyName} column`);
+                }
+            }
+        }
+        else {
+            return OrmUtils_1.OrmUtils.deepCompare(columnMetadata.default, jsonString);
+        }
+        return false;
+    }
     /**
      * Normalizes "isUnique" value of the column.
+     * @param column
      */
     normalizeIsUnique(column) {
         return column.entityMetadata.uniques.some((uq) => uq.columns.length === 1 && uq.columns[0] === column);
     }
     /**
      * Returns default column lengths, which is required on column creation.
+     * @param column
      */
     getColumnLength(column) {
         return column.length ? column.length.toString() : "";
     }
     /**
      * Creates column type definition including length, precision and scale
+     * @param column
      */
     createFullType(column) {
         let type = column.type;
@@ -915,11 +1052,16 @@ export class PostgresDriver {
      */
     async obtainMasterConnection() {
         if (!this.master) {
-            throw new TypeORMError("Driver not Connected");
+            throw new error_1.TypeORMError("Driver not Connected");
         }
         return new Promise((ok, fail) => {
             this.master.connect((err, connection, release) => {
-                err ? fail(err) : ok([connection, release]);
+                if (err) {
+                    fail(err);
+                }
+                else {
+                    ok([connection, release]);
+                }
             });
         });
     }
@@ -935,7 +1077,12 @@ export class PostgresDriver {
         const random = Math.floor(Math.random() * this.slaves.length);
         return new Promise((ok, fail) => {
             this.slaves[random].connect((err, connection, release) => {
-                err ? fail(err) : ok([connection, release]);
+                if (err) {
+                    fail(err);
+                }
+                else {
+                    ok([connection, release]);
+                }
             });
         });
     }
@@ -943,6 +1090,8 @@ export class PostgresDriver {
      * Creates generated map of values generated or returned by database after INSERT query.
      *
      * todo: slow. optimize Object.keys(), OrmUtils.mergeDeep and column.createValueMap parts
+     * @param metadata
+     * @param insertResult
      */
     createGeneratedMap(metadata, insertResult) {
         if (!insertResult)
@@ -950,7 +1099,7 @@ export class PostgresDriver {
         return Object.keys(insertResult).reduce((map, key) => {
             const column = metadata.findColumnWithDatabaseName(key);
             if (column) {
-                OrmUtils.mergeDeep(map, column.createValueMap(insertResult[key]));
+                OrmUtils_1.OrmUtils.mergeDeep(map, column.createValueMap(insertResult[key]));
                 // OrmUtils.mergeDeep(map, column.createValueMap(this.prepareHydratedValue(insertResult[key], column))); // TODO: probably should be like there, but fails on enums, fix later
             }
             return map;
@@ -959,6 +1108,8 @@ export class PostgresDriver {
     /**
      * Differentiate columns of this table and columns from the given column metadatas columns
      * and returns only changed.
+     * @param tableColumns
+     * @param columnMetadatas
      */
     findChangedColumns(tableColumns, columnMetadatas) {
         return columnMetadatas.filter((columnMetadata) => {
@@ -983,7 +1134,7 @@ export class PostgresDriver {
                 tableColumn.enumName !== columnMetadata.enumName ||
                 (tableColumn.enum &&
                     columnMetadata.enum &&
-                    !OrmUtils.isArraysEqual(tableColumn.enum, columnMetadata.enum.map((val) => val + ""))) || // enums in postgres are always strings
+                    !OrmUtils_1.OrmUtils.isArraysEqual(tableColumn.enum, columnMetadata.enum.map((val) => val + ""))) || // enums in postgres are always strings
                 tableColumn.isGenerated !== columnMetadata.isGenerated ||
                 (tableColumn.spatialFeatureType || "").toLowerCase() !==
                     (columnMetadata.spatialFeatureType || "").toLowerCase() ||
@@ -1107,8 +1258,9 @@ export class PostgresDriver {
     }
     /**
      * Returns true if driver supports RETURNING / OUTPUT statement.
+     * @param _returningType
      */
-    isReturningSqlSupported() {
+    isReturningSqlSupported(_returningType) {
         return true;
     }
     /**
@@ -1130,6 +1282,8 @@ export class PostgresDriver {
     }
     /**
      * Creates an escaped parameter.
+     * @param parameterName
+     * @param index
      */
     createParameter(parameterName, index) {
         return this.parametersPrefix + (index + 1);
@@ -1142,11 +1296,11 @@ export class PostgresDriver {
      */
     loadStreamDependency() {
         try {
-            return PlatformTools.load("pg-query-stream");
+            return PlatformTools_1.PlatformTools.load("pg-query-stream");
         }
         catch {
             // todo: better error for browser env
-            throw new TypeORMError(`To use streams you should install pg-query-stream package. Please run "npm i pg-query-stream".`);
+            throw new error_1.TypeORMError(`To use streams you should install pg-query-stream package. Please run "npm i pg-query-stream".`);
         }
     }
     // -------------------------------------------------------------------------
@@ -1157,10 +1311,10 @@ export class PostgresDriver {
      */
     loadDependencies() {
         try {
-            const postgres = this.options.driver || PlatformTools.load("pg");
+            const postgres = this.options.driver || PlatformTools_1.PlatformTools.load("pg");
             this.postgres = postgres;
             try {
-                const pgNative = this.options.nativeDriver || PlatformTools.load("pg-native");
+                const pgNative = this.options.nativeDriver || PlatformTools_1.PlatformTools.load("pg-native");
                 if (pgNative && this.postgres.native)
                     this.postgres = this.postgres.native;
             }
@@ -1168,14 +1322,16 @@ export class PostgresDriver {
         }
         catch (e) {
             // todo: better error for browser env
-            throw new DriverPackageNotInstalledError("Postgres", "pg");
+            throw new DriverPackageNotInstalledError_1.DriverPackageNotInstalledError("Postgres", "pg");
         }
     }
     /**
      * Creates a new connection pool for a given database credentials.
+     * @param options
+     * @param credentials
      */
     async createPool(options, credentials) {
-        const { logger } = this.connection;
+        const { logger } = this.dataSource;
         credentials = Object.assign({}, credentials);
         // build connection options for the driver
         // See: https://github.com/brianc/node-postgres/tree/master/packages/pg-pool#create
@@ -1215,11 +1371,14 @@ export class PostgresDriver {
                     return fail(err);
                 if (options.logNotifications) {
                     connection.on("notice", (msg) => {
-                        msg && this.connection.logger.log("info", msg.message);
+                        if (msg) {
+                            this.dataSource.logger.log("info", msg.message);
+                        }
                     });
                     connection.on("notification", (msg) => {
-                        msg &&
-                            this.connection.logger.log("info", `Received NOTIFY on channel ${msg.channel}: ${msg.payload}.`);
+                        if (msg) {
+                            this.dataSource.logger.log("info", `Received NOTIFY on channel ${msg.channel}: ${msg.payload}.`);
+                        }
                     });
                 }
                 release();
@@ -1229,6 +1388,7 @@ export class PostgresDriver {
     }
     /**
      * Closes connection pool.
+     * @param pool
      */
     async closePool(pool) {
         while (this.connectedQueryRunners.length) {
@@ -1240,9 +1400,11 @@ export class PostgresDriver {
     }
     /**
      * Executes given query.
+     * @param connection
+     * @param query
      */
     executeQuery(connection, query) {
-        this.connection.logger.logQuery(query);
+        this.dataSource.logger.logQuery(query);
         return new Promise((ok, fail) => {
             connection.query(query, (err, result) => err ? fail(err) : ok(result));
         });
@@ -1250,6 +1412,7 @@ export class PostgresDriver {
     /**
      * If parameter is a datetime function, e.g. "CURRENT_TIMESTAMP", normalizes it.
      * Otherwise returns original input.
+     * @param value
      */
     normalizeDatetimeFunction(value) {
         // check if input is datetime function
@@ -1290,6 +1453,7 @@ export class PostgresDriver {
     }
     /**
      * Escapes a given comment.
+     * @param comment
      */
     escapeComment(comment) {
         if (!comment)
@@ -1298,5 +1462,5 @@ export class PostgresDriver {
         return comment;
     }
 }
-
-//# sourceMappingURL=PostgresDriver.js.map
+exports.PostgresDriver = PostgresDriver;
+//# sourceMappingURL=PostgresDriver.js.map