@yandjin-mikro-orm/postgresql 6.1.4-rc-sti-changes-1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Martin Adámek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/PostgreSqlConnection.d.ts

@@ -0,0 +1,15 @@
+import { AbstractSqlConnection, type Knex } from "@yandjin-mikro-orm/knex";
+export declare class PostgreSqlConnection extends AbstractSqlConnection {
+    createKnex(): void;
+    getDefaultClientUrl(): string;
+    getConnectionOptions(): Knex.PgConnectionConfig;
+    protected transformRawResult<T>(res: any, method: "all" | "get" | "run"): T;
+    /**
+     * monkey patch knex' postgres dialect so it correctly handles column updates (especially enums)
+     */
+    private patchKnex;
+    private addColumn;
+    private alterColumnNullable;
+    private addColumnDefault;
+    private dropColumnDefault;
+}

package/PostgreSqlConnection.js

@@ -0,0 +1,162 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgreSqlConnection = void 0;
+const type_overrides_1 = __importDefault(require("pg/lib/type-overrides"));
+const postgres_array_1 = __importDefault(require("postgres-array"));
+const knex_1 = require("@yandjin-mikro-orm/knex");
+class PostgreSqlConnection extends knex_1.AbstractSqlConnection {
+    createKnex() {
+        this.patchKnex();
+        this.client = this.createKnexClient("pg");
+        this.connected = true;
+    }
+    getDefaultClientUrl() {
+        return "postgresql://postgres@127.0.0.1:5432";
+    }
+    getConnectionOptions() {
+        const ret = super.getConnectionOptions();
+        // use `select typname, oid, typarray from pg_type order by oid` to get the list of OIDs
+        const types = new type_overrides_1.default();
+        [
+            1082, // date
+            1114, // timestamp
+            1184, // timestamptz
+            1186, // interval
+        ].forEach((oid) => types.setTypeParser(oid, (str) => str));
+        [
+            1182, // date[]
+            1115, // timestamp[]
+            1185, // timestamptz[]
+            1187, // interval[]
+        ].forEach((oid) => types.setTypeParser(oid, (str) => postgres_array_1.default.parse(str)));
+        ret.types = types;
+        return ret;
+    }
+    transformRawResult(res, method) {
+        if (method === "get") {
+            return res.rows[0];
+        }
+        if (method === "all") {
+            return res.rows;
+        }
+        return {
+            affectedRows: res.rowCount,
+            insertId: res.rows[0] ? res.rows[0].id : 0,
+            row: res.rows[0],
+            rows: res.rows,
+        };
+    }
+    /**
+     * monkey patch knex' postgres dialect so it correctly handles column updates (especially enums)
+     */
+    patchKnex() {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const that = this;
+        const { PostgresDialectTableCompiler, TableCompiler } = knex_1.MonkeyPatchable;
+        PostgresDialectTableCompiler.prototype.addColumns = function (columns, prefix, colCompilers) {
+            if (prefix !== this.alterColumnsPrefix) {
+                // base class implementation for normal add
+                return TableCompiler.prototype.addColumns.call(this, columns, prefix);
+            }
+            // alter columns
+            for (const col of colCompilers) {
+                that.addColumn.call(this, col, that);
+            }
+        };
+    }
+    addColumn(col, that) {
+        const options = that.config.get("schemaGenerator");
+        const quotedTableName = this.tableName();
+        const type = col.getColumnType();
+        const colName = this.client.wrapIdentifier(col.getColumnName(), col.columnBuilder.queryContext());
+        const constraintName = `${this.tableNameRaw.replace(/^.*\.(.*)$/, "$1")}_${col.getColumnName()}_check`;
+        const useNative = col.args?.[2]?.useNative;
+        const alterType = col.columnBuilder.alterType;
+        const alterNullable = col.columnBuilder.alterNullable;
+        const defaultTo = col.modified.defaultTo;
+        if (defaultTo != null) {
+            that.dropColumnDefault.call(this, col, colName);
+        }
+        if (col.type === "enu" && !useNative) {
+            if (alterType) {
+                this.pushQuery({
+                    sql: `alter table ${quotedTableName} alter column ${colName} type text using (${colName}::text)`,
+                    bindings: [],
+                });
+            }
+            /* istanbul ignore else */
+            if (options.createForeignKeyConstraints && alterNullable) {
+                this.pushQuery({
+                    sql: `alter table ${quotedTableName} add constraint "${constraintName}" ${type.replace(/^text /, "")}`,
+                    bindings: [],
+                });
+            }
+        }
+        else if (type === "uuid") {
+            // we need to drop the default as it would be invalid
+            this.pushQuery({
+                sql: `alter table ${quotedTableName} alter column ${colName} drop default`,
+                bindings: [],
+            });
+            this.pushQuery({
+                sql: `alter table ${quotedTableName} alter column ${colName} type ${type} using (${colName}::text::uuid)`,
+                bindings: [],
+            });
+        }
+        else if (alterType) {
+            this.pushQuery({
+                sql: `alter table ${quotedTableName} alter column ${colName} type ${type} using (${colName}::${type})`,
+                bindings: [],
+            });
+        }
+        that.addColumnDefault.call(this, col, colName);
+        that.alterColumnNullable.call(this, col, colName);
+    }
+    alterColumnNullable(col, colName) {
+        const quotedTableName = this.tableName();
+        const nullable = col.modified.nullable;
+        if (!nullable) {
+            return;
+        }
+        if (nullable[0] === false) {
+            this.pushQuery({
+                sql: `alter table ${quotedTableName} alter column ${colName} set not null`,
+                bindings: [],
+            });
+        }
+        else {
+            this.pushQuery({
+                sql: `alter table ${quotedTableName} alter column ${colName} drop not null`,
+                bindings: [],
+            });
+        }
+    }
+    addColumnDefault(col, colName) {
+        const quotedTableName = this.tableName();
+        const defaultTo = col.modified.defaultTo;
+        if (!defaultTo) {
+            return;
+        }
+        if (defaultTo[0] !== null) {
+            const modifier = col.defaultTo(...defaultTo);
+            this.pushQuery({
+                sql: `alter table ${quotedTableName} alter column ${colName} set ${modifier}`,
+                bindings: [],
+            });
+        }
+    }
+    dropColumnDefault(col, colName) {
+        const quotedTableName = this.tableName();
+        const defaultTo = col.modified.defaultTo;
+        if (defaultTo?.[0] == null) {
+            this.pushQuery({
+                sql: `alter table ${quotedTableName} alter column ${colName} drop default`,
+                bindings: [],
+            });
+        }
+    }
+}
+exports.PostgreSqlConnection = PostgreSqlConnection;

package/PostgreSqlDriver.d.ts

@@ -0,0 +1,6 @@
+import type { Configuration } from "@yandjin-mikro-orm/core";
+import { AbstractSqlDriver } from "@yandjin-mikro-orm/knex";
+import { PostgreSqlConnection } from "./PostgreSqlConnection";
+export declare class PostgreSqlDriver extends AbstractSqlDriver<PostgreSqlConnection> {
+    constructor(config: Configuration);
+}

package/PostgreSqlDriver.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgreSqlDriver = void 0;
+const knex_1 = require("@yandjin-mikro-orm/knex");
+const PostgreSqlConnection_1 = require("./PostgreSqlConnection");
+const PostgreSqlPlatform_1 = require("./PostgreSqlPlatform");
+class PostgreSqlDriver extends knex_1.AbstractSqlDriver {
+    constructor(config) {
+        super(config, new PostgreSqlPlatform_1.PostgreSqlPlatform(), PostgreSqlConnection_1.PostgreSqlConnection, [
+            "knex",
+            "pg",
+        ]);
+    }
+}
+exports.PostgreSqlDriver = PostgreSqlDriver;

package/PostgreSqlExceptionConverter.d.ts

@@ -0,0 +1,8 @@
+import { ExceptionConverter, type Dictionary, type DriverException } from "@yandjin-mikro-orm/core";
+export declare class PostgreSqlExceptionConverter extends ExceptionConverter {
+    /**
+     * @link http://www.postgresql.org/docs/9.4/static/errcodes-appendix.html
+     * @link https://github.com/doctrine/dbal/blob/master/src/Driver/AbstractPostgreSQLDriver.php
+     */
+    convertException(exception: Error & Dictionary): DriverException;
+}

package/PostgreSqlExceptionConverter.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgreSqlExceptionConverter = void 0;
+const core_1 = require("@yandjin-mikro-orm/core");
+class PostgreSqlExceptionConverter extends core_1.ExceptionConverter {
+    /* istanbul ignore next */
+    /**
+     * @link http://www.postgresql.org/docs/9.4/static/errcodes-appendix.html
+     * @link https://github.com/doctrine/dbal/blob/master/src/Driver/AbstractPostgreSQLDriver.php
+     */
+    convertException(exception) {
+        switch (exception.code) {
+            case "40001":
+            case "40P01":
+                return new core_1.DeadlockException(exception);
+            case "0A000":
+                // Foreign key constraint violations during a TRUNCATE operation
+                // are considered "feature not supported" in PostgreSQL.
+                if (exception.message.includes("truncate")) {
+                    return new core_1.ForeignKeyConstraintViolationException(exception);
+                }
+                break;
+            case "23502":
+                return new core_1.NotNullConstraintViolationException(exception);
+            case "23503":
+                return new core_1.ForeignKeyConstraintViolationException(exception);
+            case "23505":
+                return new core_1.UniqueConstraintViolationException(exception);
+            case "23514":
+                return new core_1.CheckConstraintViolationException(exception);
+            case "42601":
+                return new core_1.SyntaxErrorException(exception);
+            case "42702":
+                return new core_1.NonUniqueFieldNameException(exception);
+            case "42703":
+                return new core_1.InvalidFieldNameException(exception);
+            case "42P01":
+                return new core_1.TableNotFoundException(exception);
+            case "42P07":
+                return new core_1.TableExistsException(exception);
+        }
+        return super.convertException(exception);
+    }
+}
+exports.PostgreSqlExceptionConverter = PostgreSqlExceptionConverter;

package/PostgreSqlMikroORM.d.ts

@@ -0,0 +1,19 @@
+import { MikroORM, type Options, type IDatabaseDriver, type EntityManager, type EntityManagerType } from "@yandjin-mikro-orm/core";
+import { PostgreSqlDriver } from "./PostgreSqlDriver";
+import type { SqlEntityManager } from "@yandjin-mikro-orm/knex";
+/**
+ * @inheritDoc
+ */
+export declare class PostgreSqlMikroORM<EM extends EntityManager = SqlEntityManager> extends MikroORM<PostgreSqlDriver, EM> {
+    private static DRIVER;
+    /**
+     * @inheritDoc
+     */
+    static init<D extends IDatabaseDriver = PostgreSqlDriver, EM extends EntityManager = D[typeof EntityManagerType] & EntityManager>(options?: Options<D, EM>): Promise<MikroORM<D, EM>>;
+    /**
+     * @inheritDoc
+     */
+    static initSync<D extends IDatabaseDriver = PostgreSqlDriver, EM extends EntityManager = D[typeof EntityManagerType] & EntityManager>(options: Options<D, EM>): MikroORM<D, EM>;
+}
+export type PostgreSqlOptions = Options<PostgreSqlDriver>;
+export declare function definePostgreSqlConfig(options: PostgreSqlOptions): Options<PostgreSqlDriver, SqlEntityManager<PostgreSqlDriver> & EntityManager<IDatabaseDriver<import("@yandjin-mikro-orm/core").Connection>>>;

package/PostgreSqlMikroORM.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.definePostgreSqlConfig = exports.PostgreSqlMikroORM = void 0;
+const core_1 = require("@yandjin-mikro-orm/core");
+const PostgreSqlDriver_1 = require("./PostgreSqlDriver");
+/**
+ * @inheritDoc
+ */
+class PostgreSqlMikroORM extends core_1.MikroORM {
+    static DRIVER = PostgreSqlDriver_1.PostgreSqlDriver;
+    /**
+     * @inheritDoc
+     */
+    static async init(options) {
+        return super.init(options);
+    }
+    /**
+     * @inheritDoc
+     */
+    static initSync(options) {
+        return super.initSync(options);
+    }
+}
+exports.PostgreSqlMikroORM = PostgreSqlMikroORM;
+/* istanbul ignore next */
+function definePostgreSqlConfig(options) {
+    return (0, core_1.defineConfig)({ driver: PostgreSqlDriver_1.PostgreSqlDriver, ...options });
+}
+exports.definePostgreSqlConfig = definePostgreSqlConfig;

package/PostgreSqlPlatform.d.ts

@@ -0,0 +1,96 @@
+import { type IPostgresInterval } from "postgres-interval";
+import { type EntityProperty, Type, type SimpleColumnMeta } from "@yandjin-mikro-orm/core";
+import { AbstractSqlPlatform, type IndexDef } from "@yandjin-mikro-orm/knex";
+import { PostgreSqlSchemaHelper } from "./PostgreSqlSchemaHelper";
+import { PostgreSqlExceptionConverter } from "./PostgreSqlExceptionConverter";
+export declare class PostgreSqlPlatform extends AbstractSqlPlatform {
+    protected readonly schemaHelper: PostgreSqlSchemaHelper;
+    protected readonly exceptionConverter: PostgreSqlExceptionConverter;
+    usesReturningStatement(): boolean;
+    usesCascadeStatement(): boolean;
+    supportsNativeEnums(): boolean;
+    supportsCustomPrimaryKeyNames(): boolean;
+    /**
+     * Postgres will complain if we try to batch update uniquely constrained property (moving the value from one entity to another).
+     * This flag will result in postponing 1:1 updates (removing them from the batched query).
+     * @see https://stackoverflow.com/questions/5403437/atomic-multi-row-update-with-a-unique-constraint
+     */
+    allowsUniqueBatchUpdates(): boolean;
+    getCurrentTimestampSQL(length: number): string;
+    getDateTimeTypeDeclarationSQL(column: {
+        length?: number;
+    }): string;
+    getDefaultDateTimeLength(): number;
+    convertIntervalToJSValue(value: string): unknown;
+    convertIntervalToDatabaseValue(value: IPostgresInterval): unknown;
+    getTimeTypeDeclarationSQL(): string;
+    getIntegerTypeDeclarationSQL(column: {
+        length?: number;
+        autoincrement?: boolean;
+        generated?: string;
+    }): string;
+    getBigIntTypeDeclarationSQL(column: {
+        autoincrement?: boolean;
+    }): string;
+    getTinyIntTypeDeclarationSQL(column: {
+        length?: number;
+        unsigned?: boolean;
+        autoincrement?: boolean;
+    }): string;
+    getUuidTypeDeclarationSQL(column: {
+        length?: number;
+    }): string;
+    getFullTextWhereClause(prop: EntityProperty): string;
+    supportsCreatingFullTextIndex(): boolean;
+    getFullTextIndexExpression(indexName: string, schemaName: string | undefined, tableName: string, columns: SimpleColumnMeta[]): string;
+    getMappedType(type: string): Type<unknown>;
+    getRegExpOperator(val?: unknown, flags?: string): string;
+    getRegExpValue(val: RegExp): {
+        $re: string;
+        $flags?: string;
+    };
+    isBigIntProperty(prop: EntityProperty): boolean;
+    getArrayDeclarationSQL(): string;
+    getFloatDeclarationSQL(): string;
+    getDoubleDeclarationSQL(): string;
+    getEnumTypeDeclarationSQL(column: {
+        fieldNames: string[];
+        items?: unknown[];
+        nativeEnumName?: string;
+    }): string;
+    supportsMultipleStatements(): boolean;
+    marshallArray(values: string[]): string;
+    unmarshallArray(value: string): string[];
+    getBlobDeclarationSQL(): string;
+    getJsonDeclarationSQL(): string;
+    getSearchJsonPropertyKey(path: string[], type: string | undefined | Type, aliased: boolean, value?: unknown): string;
+    getJsonIndexDefinition(index: IndexDef): string[];
+    quoteIdentifier(id: string, quote?: string): string;
+    quoteValue(value: any): string;
+    indexForeignKeys(): boolean;
+    getDefaultMappedType(type: string): Type<unknown>;
+    supportsSchemas(): boolean;
+    getDefaultSchemaName(): string | undefined;
+    /**
+     * Returns the default name of index for the given columns
+     * cannot go past 64 character length for identifiers in MySQL
+     */
+    getIndexName(tableName: string, columns: string[], type: "index" | "unique" | "foreign" | "primary" | "sequence"): string;
+    getDefaultPrimaryName(tableName: string, columns: string[]): string;
+    /**
+     * @inheritDoc
+     */
+    castColumn(prop?: {
+        columnTypes?: string[];
+    }): string;
+    /**
+     * @inheritDoc
+     */
+    castJsonValue(prop?: {
+        columnTypes?: string[];
+    }): string;
+    /**
+     * @inheritDoc
+     */
+    parseDate(value: string | number): Date;
+}