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

package/PostgreSqlPlatform.js

@@ -0,0 +1,314 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgreSqlPlatform = void 0;
+const pg_1 = require("pg");
+const postgres_date_1 = __importDefault(require("postgres-date"));
+const postgres_interval_1 = __importDefault(require("postgres-interval"));
+const core_1 = require("@yandjin-mikro-orm/core");
+const knex_1 = require("@yandjin-mikro-orm/knex");
+const PostgreSqlSchemaHelper_1 = require("./PostgreSqlSchemaHelper");
+const PostgreSqlExceptionConverter_1 = require("./PostgreSqlExceptionConverter");
+const FullTextType_1 = require("./types/FullTextType");
+class PostgreSqlPlatform extends knex_1.AbstractSqlPlatform {
+    schemaHelper = new PostgreSqlSchemaHelper_1.PostgreSqlSchemaHelper(this);
+    exceptionConverter = new PostgreSqlExceptionConverter_1.PostgreSqlExceptionConverter();
+    usesReturningStatement() {
+        return true;
+    }
+    usesCascadeStatement() {
+        return true;
+    }
+    supportsNativeEnums() {
+        return true;
+    }
+    supportsCustomPrimaryKeyNames() {
+        return true;
+    }
+    /**
+     * 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() {
+        return false;
+    }
+    getCurrentTimestampSQL(length) {
+        return `current_timestamp(${length})`;
+    }
+    getDateTimeTypeDeclarationSQL(column) {
+        /* istanbul ignore next */
+        return "timestamptz" + (column.length != null ? `(${column.length})` : "");
+    }
+    getDefaultDateTimeLength() {
+        return 6; // timestamptz actually means timestamptz(6)
+    }
+    convertIntervalToJSValue(value) {
+        return (0, postgres_interval_1.default)(value);
+    }
+    convertIntervalToDatabaseValue(value) {
+        if (core_1.Utils.isObject(value) &&
+            "toPostgres" in value &&
+            typeof value.toPostgres === "function") {
+            return value.toPostgres();
+        }
+        return value;
+    }
+    getTimeTypeDeclarationSQL() {
+        return "time(0)";
+    }
+    getIntegerTypeDeclarationSQL(column) {
+        if (column.autoincrement && !column.generated) {
+            return `serial`;
+        }
+        return `int`;
+    }
+    getBigIntTypeDeclarationSQL(column) {
+        /* istanbul ignore next */
+        if (column.autoincrement) {
+            return `bigserial`;
+        }
+        return "bigint";
+    }
+    getTinyIntTypeDeclarationSQL(column) {
+        return "smallint";
+    }
+    getUuidTypeDeclarationSQL(column) {
+        return `uuid`;
+    }
+    getFullTextWhereClause(prop) {
+        if (prop.customType instanceof FullTextType_1.FullTextType) {
+            return `:column: @@ plainto_tsquery('${prop.customType.regconfig}', :query)`;
+        }
+        if (prop.columnTypes[0] === "tsvector") {
+            return `:column: @@ plainto_tsquery('simple', :query)`;
+        }
+        return `to_tsvector('simple', :column:) @@ plainto_tsquery('simple', :query)`;
+    }
+    supportsCreatingFullTextIndex() {
+        return true;
+    }
+    getFullTextIndexExpression(indexName, schemaName, tableName, columns) {
+        /* istanbul ignore next */
+        const quotedTableName = this.quoteIdentifier(schemaName ? `${schemaName}.${tableName}` : tableName);
+        const quotedColumnNames = columns.map((c) => this.quoteIdentifier(c.name));
+        const quotedIndexName = this.quoteIdentifier(indexName);
+        if (columns.length === 1 && columns[0].type === "tsvector") {
+            return `create index ${quotedIndexName} on ${quotedTableName} using gin(${quotedColumnNames[0]})`;
+        }
+        return `create index ${quotedIndexName} on ${quotedTableName} using gin(to_tsvector('simple', ${quotedColumnNames.join(` || ' ' || `)}))`;
+    }
+    getMappedType(type) {
+        switch (this.extractSimpleType(type)) {
+            case "tsvector":
+                return core_1.Type.getType(FullTextType_1.FullTextType);
+            default:
+                return super.getMappedType(type);
+        }
+    }
+    getRegExpOperator(val, flags) {
+        if ((val instanceof RegExp && val.flags.includes("i")) ||
+            flags?.includes("i")) {
+            return "~*";
+        }
+        return "~";
+    }
+    getRegExpValue(val) {
+        /* istanbul ignore else */
+        if (val.flags.includes("i")) {
+            return { $re: val.source, $flags: val.flags };
+        }
+        /* istanbul ignore next */
+        return { $re: val.source };
+    }
+    isBigIntProperty(prop) {
+        return (super.isBigIntProperty(prop) ||
+            ["bigserial", "int8"].includes(prop.columnTypes?.[0]));
+    }
+    getArrayDeclarationSQL() {
+        return "text[]";
+    }
+    getFloatDeclarationSQL() {
+        return "real";
+    }
+    getDoubleDeclarationSQL() {
+        return "double precision";
+    }
+    getEnumTypeDeclarationSQL(column) {
+        if (column.nativeEnumName) {
+            return column.nativeEnumName;
+        }
+        if (column.items?.every((item) => core_1.Utils.isString(item))) {
+            return "text";
+        }
+        return `smallint`;
+    }
+    supportsMultipleStatements() {
+        return true;
+    }
+    marshallArray(values) {
+        const quote = (v) => v === "" || v.match(/["{},\\]/) ? JSON.stringify(v) : v;
+        return `{${values.map((v) => quote("" + v)).join(",")}}`;
+    }
+    unmarshallArray(value) {
+        if (value === "{}") {
+            return [];
+        }
+        /* istanbul ignore next */
+        return value
+            .substring(1, value.length - 1)
+            .split(",")
+            .map((v) => (v === `""` ? "" : v));
+    }
+    getBlobDeclarationSQL() {
+        return "bytea";
+    }
+    getJsonDeclarationSQL() {
+        return "jsonb";
+    }
+    getSearchJsonPropertyKey(path, type, aliased, value) {
+        const first = path.shift();
+        const last = path.pop();
+        const root = this.quoteIdentifier(aliased ? `${core_1.ALIAS_REPLACEMENT}.${first}` : first);
+        type =
+            typeof type === "string"
+                ? this.getMappedType(type).runtimeType
+                : String(type);
+        const types = {
+            number: "float8",
+            bigint: "int8",
+            boolean: "bool",
+        };
+        const cast = (key) => (0, core_1.raw)(type in types ? `(${key})::${types[type]}` : key);
+        let lastOperator = "->>";
+        // force `->` for operator payloads with array values
+        if (core_1.Utils.isPlainObject(value) &&
+            Object.keys(value).every((key) => core_1.Utils.isArrayOperator(key) && Array.isArray(value[key]))) {
+            lastOperator = "->";
+        }
+        if (path.length === 0) {
+            return cast(`${root}${lastOperator}'${last}'`);
+        }
+        return cast(`${root}->${path.map((a) => this.quoteValue(a)).join("->")}${lastOperator}'${last}'`);
+    }
+    getJsonIndexDefinition(index) {
+        return index.columnNames.map((column) => {
+            const path = column.split(".");
+            const first = path.shift();
+            const last = path.pop();
+            if (path.length === 0) {
+                return `${this.quoteIdentifier(first)}->>${this.quoteValue(last)}`;
+            }
+            return `${this.quoteIdentifier(first)}->${path.map((c) => this.quoteValue(c)).join("->")}->>${this.quoteValue(last)}`;
+        });
+    }
+    quoteIdentifier(id, quote = '"') {
+        return `${quote}${id.replace(".", `${quote}.${quote}`)}${quote}`;
+    }
+    quoteValue(value) {
+        /* istanbul ignore if */
+        if (core_1.Utils.isPlainObject(value) || value?.[core_1.JsonProperty]) {
+            value = JSON.stringify(value);
+        }
+        if (typeof value === "string") {
+            return pg_1.Client.prototype.escapeLiteral(value);
+        }
+        if (value instanceof Date) {
+            return `'${value.toISOString()}'`;
+        }
+        if (ArrayBuffer.isView(value)) {
+            return `E'\\\\x${value.toString("hex")}'`;
+        }
+        return super.quoteValue(value);
+    }
+    indexForeignKeys() {
+        return false;
+    }
+    getDefaultMappedType(type) {
+        const normalizedType = this.extractSimpleType(type);
+        const map = {
+            int2: "smallint",
+            smallserial: "smallint",
+            int: "integer",
+            int4: "integer",
+            serial: "integer",
+            serial4: "integer",
+            int8: "bigint",
+            bigserial: "bigint",
+            serial8: "bigint",
+            numeric: "decimal",
+            bool: "boolean",
+            real: "float",
+            float4: "float",
+            float8: "double",
+            timestamp: "datetime",
+            timestamptz: "datetime",
+            bytea: "blob",
+            jsonb: "json",
+            "character varying": "varchar",
+        };
+        return super.getDefaultMappedType(map[normalizedType] ?? type);
+    }
+    supportsSchemas() {
+        return true;
+    }
+    getDefaultSchemaName() {
+        return "public";
+    }
+    /**
+     * Returns the default name of index for the given columns
+     * cannot go past 64 character length for identifiers in MySQL
+     */
+    getIndexName(tableName, columns, type) {
+        const indexName = super.getIndexName(tableName, columns, type);
+        if (indexName.length > 64) {
+            return `${indexName.substring(0, 56 - type.length)}_${core_1.Utils.hash(indexName, 5)}_${type}`;
+        }
+        return indexName;
+    }
+    getDefaultPrimaryName(tableName, columns) {
+        const indexName = `${tableName}_pkey`;
+        if (indexName.length > 64) {
+            return `${indexName.substring(0, 56 - "primary".length)}_${core_1.Utils.hash(indexName, 5)}_primary`;
+        }
+        return indexName;
+    }
+    /**
+     * @inheritDoc
+     */
+    castColumn(prop) {
+        switch (prop?.columnTypes?.[0]) {
+            case this.getUuidTypeDeclarationSQL({}):
+                return "::text";
+            case this.getBooleanTypeDeclarationSQL():
+                return "::int";
+            default:
+                return "";
+        }
+    }
+    /**
+     * @inheritDoc
+     */
+    castJsonValue(prop) {
+        if (prop?.columnTypes?.[0] === "json") {
+            return "::text";
+        }
+        return "";
+    }
+    /**
+     * @inheritDoc
+     */
+    parseDate(value) {
+        // postgres-date returns `null` for a JS ISO string which has the `T` separator
+        if (typeof value === "string" && value.charAt(10) === "T") {
+            return new Date(value);
+        }
+        if (typeof value === "number") {
+            return new Date(value);
+        }
+        return (0, postgres_date_1.default)(value);
+    }
+}
+exports.PostgreSqlPlatform = PostgreSqlPlatform;

package/PostgreSqlSchemaHelper.d.ts

@@ -0,0 +1,44 @@
+import { type Dictionary } from "@yandjin-mikro-orm/core";
+import { SchemaHelper, type AbstractSqlConnection, type CheckDef, type Column, type DatabaseSchema, type DatabaseTable, type ForeignKey, type IndexDef, type Table, type TableDifference, type Knex } from "@yandjin-mikro-orm/knex";
+export declare class PostgreSqlSchemaHelper extends SchemaHelper {
+    static readonly DEFAULT_VALUES: {
+        "now()": string[];
+        "current_timestamp(?)": string[];
+        "('now'::text)::timestamp(?) with time zone": string[];
+        "('now'::text)::timestamp(?) without time zone": string[];
+        "null::character varying": string[];
+        "null::timestamp with time zone": string[];
+        "null::timestamp without time zone": string[];
+    };
+    getSchemaBeginning(charset: string): string;
+    getListTablesSQL(): string;
+    getNamespaces(connection: AbstractSqlConnection): Promise<string[]>;
+    private getIgnoredNamespacesConditionSQL;
+    loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[], schemas?: string[]): Promise<void>;
+    getAllIndexes(connection: AbstractSqlConnection, tables: Table[]): Promise<Dictionary<IndexDef[]>>;
+    getAllColumns(connection: AbstractSqlConnection, tables: Table[], nativeEnums?: Dictionary<string[]>): Promise<Dictionary<Column[]>>;
+    getAllChecks(connection: AbstractSqlConnection, tables: Table[]): Promise<Dictionary<CheckDef[]>>;
+    getAllForeignKeys(connection: AbstractSqlConnection, tables: Table[]): Promise<Dictionary<Dictionary<ForeignKey>>>;
+    getNativeEnumDefinitions(connection: AbstractSqlConnection, schemas: string[]): Promise<Dictionary<string[]>>;
+    getDropNativeEnumSQL(name: string, schema?: string): string;
+    getAlterNativeEnumSQL(name: string, schema?: string, value?: string): string;
+    getEnumDefinitions(connection: AbstractSqlConnection, checks: CheckDef[], tableName?: string, schemaName?: string): Promise<Dictionary<string[]>>;
+    createTableColumn(table: Knex.TableBuilder, column: Column, fromTable: DatabaseTable, changedProperties?: Set<string>, alter?: boolean): Knex.ColumnBuilder;
+    configureColumn(column: Column, col: Knex.ColumnBuilder, knex: Knex, changedProperties?: Set<string>): Knex.ColumnBuilder;
+    getPreAlterTable(tableDiff: TableDifference, safe: boolean): string;
+    getPostAlterTable(tableDiff: TableDifference, safe: boolean): string;
+    getAlterColumnAutoincrement(tableName: string, column: Column, schemaName?: string): string;
+    getChangeColumnCommentSQL(tableName: string, to: Column, schemaName?: string): string;
+    normalizeDefaultValue(defaultValue: string, length: number): string | number;
+    getDatabaseExistsSQL(name: string): string;
+    getDatabaseNotExistsError(dbName: string): string;
+    getManagementDbName(): string;
+    disableForeignKeysSQL(): string;
+    enableForeignKeysSQL(): string;
+    getRenameIndexSQL(tableName: string, index: IndexDef, oldIndexName: string): string;
+    private getIndexesSQL;
+    private getChecksSQL;
+    getChecks(connection: AbstractSqlConnection, tableName: string, schemaName: string, columns?: Column[]): Promise<CheckDef[]>;
+    getColumns(connection: AbstractSqlConnection, tableName: string, schemaName?: string): Promise<Column[]>;
+    getIndexes(connection: AbstractSqlConnection, tableName: string, schemaName?: string): Promise<IndexDef[]>;
+}