@mikro-orm/sql 7.0.0-dev.98 → 7.0.0-rc.0

package/dialects/postgresql/BasePostgreSqlPlatform.js

@@ -0,0 +1,350 @@
+import { ALIAS_REPLACEMENT, ARRAY_OPERATORS, raw, RawQueryFragment, Type, Utils, } from '@mikro-orm/core';
+import { AbstractSqlPlatform } from '../../AbstractSqlPlatform.js';
+import { PostgreSqlNativeQueryBuilder } from './PostgreSqlNativeQueryBuilder.js';
+import { PostgreSqlSchemaHelper } from './PostgreSqlSchemaHelper.js';
+import { PostgreSqlExceptionConverter } from './PostgreSqlExceptionConverter.js';
+import { FullTextType } from './FullTextType.js';
+export class BasePostgreSqlPlatform extends AbstractSqlPlatform {
+    schemaHelper = new PostgreSqlSchemaHelper(this);
+    exceptionConverter = new PostgreSqlExceptionConverter();
+    createNativeQueryBuilder() {
+        return new PostgreSqlNativeQueryBuilder(this);
+    }
+    usesReturningStatement() {
+        return true;
+    }
+    usesCascadeStatement() {
+        return true;
+    }
+    supportsNativeEnums() {
+        return true;
+    }
+    usesEnumCheckConstraints() {
+        return true;
+    }
+    supportsMaterializedViews() {
+        return true;
+    }
+    supportsCustomPrimaryKeyNames() {
+        return true;
+    }
+    getCurrentTimestampSQL(length) {
+        return `current_timestamp(${length})`;
+    }
+    getDateTimeTypeDeclarationSQL(column) {
+        /* v8 ignore next */
+        return 'timestamptz' + (column.length != null ? `(${column.length})` : '');
+    }
+    getDefaultDateTimeLength() {
+        return 6;
+    }
+    getTimeTypeDeclarationSQL() {
+        return 'time(0)';
+    }
+    getIntegerTypeDeclarationSQL(column) {
+        if (column.autoincrement && !column.generated) {
+            return 'serial';
+        }
+        return 'int';
+    }
+    getBigIntTypeDeclarationSQL(column) {
+        /* v8 ignore next */
+        if (column.autoincrement) {
+            return `bigserial`;
+        }
+        return 'bigint';
+    }
+    getTinyIntTypeDeclarationSQL(column) {
+        return 'smallint';
+    }
+    getUuidTypeDeclarationSQL(column) {
+        return `uuid`;
+    }
+    getFullTextWhereClause(prop) {
+        if (prop.customType instanceof FullTextType) {
+            return `:column: @@ plainto_tsquery('${prop.customType.regconfig}', :query)`;
+        }
+        /* v8 ignore next */
+        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) {
+        /* v8 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(` || ' ' || `)}))`;
+    }
+    normalizeColumnType(type, options) {
+        const simpleType = this.extractSimpleType(type);
+        if (['int', 'int4', 'integer'].includes(simpleType)) {
+            return this.getIntegerTypeDeclarationSQL({});
+        }
+        if (['bigint', 'int8'].includes(simpleType)) {
+            return this.getBigIntTypeDeclarationSQL({});
+        }
+        if (['smallint', 'int2'].includes(simpleType)) {
+            return this.getSmallIntTypeDeclarationSQL({});
+        }
+        if (['boolean', 'bool'].includes(simpleType)) {
+            return this.getBooleanTypeDeclarationSQL();
+        }
+        if (['varchar', 'character varying'].includes(simpleType)) {
+            return this.getVarcharTypeDeclarationSQL(options);
+        }
+        if (['char', 'bpchar'].includes(simpleType)) {
+            return this.getCharTypeDeclarationSQL(options);
+        }
+        if (['decimal', 'numeric'].includes(simpleType)) {
+            return this.getDecimalTypeDeclarationSQL(options);
+        }
+        if (['interval'].includes(simpleType)) {
+            return this.getIntervalTypeDeclarationSQL(options);
+        }
+        return super.normalizeColumnType(type, options);
+    }
+    getMappedType(type) {
+        switch (this.extractSimpleType(type)) {
+            case 'tsvector': return Type.getType(FullTextType);
+            default: return super.getMappedType(type);
+        }
+    }
+    getRegExpOperator(val, flags) {
+        /* v8 ignore next */
+        if ((val instanceof RegExp && val.flags.includes('i')) || flags?.includes('i')) {
+            return '~*';
+        }
+        return '~';
+    }
+    /* v8 ignore next */
+    getRegExpValue(val) {
+        if (val.flags.includes('i')) {
+            return { $re: val.source, $flags: val.flags };
+        }
+        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) {
+        /* v8 ignore next */
+        if (column.nativeEnumName) {
+            return column.nativeEnumName;
+        }
+        if (column.items?.every(item => typeof item === 'string')) {
+            return 'text';
+        }
+        return `smallint`;
+    }
+    supportsMultipleStatements() {
+        return true;
+    }
+    getBeginTransactionSQL(options) {
+        if (options?.isolationLevel || options?.readOnly) {
+            let sql = 'start transaction';
+            sql += options.isolationLevel ? ` isolation level ${options.isolationLevel}` : '';
+            sql += options.readOnly ? ` read only` : '';
+            return [sql];
+        }
+        return ['begin'];
+    }
+    marshallArray(values) {
+        const quote = (v) => v === '' || v.match(/["{},\\]/) ? JSON.stringify(v) : v;
+        return `{${values.map(v => quote('' + v)).join(',')}}`;
+    }
+    /* v8 ignore next */
+    unmarshallArray(value) {
+        if (value === '{}') {
+            return [];
+        }
+        return value.substring(1, value.length - 1).split(',').map(v => {
+            if (v === `""`) {
+                return '';
+            }
+            if (v.match(/"(.*)"/)) {
+                return v.substring(1, v.length - 1).replaceAll('\\"', '"');
+            }
+            return v;
+        });
+    }
+    getVarcharTypeDeclarationSQL(column) {
+        if (column.length === -1) {
+            return 'varchar';
+        }
+        return super.getVarcharTypeDeclarationSQL(column);
+    }
+    getCharTypeDeclarationSQL(column) {
+        if (column.length === -1) {
+            return 'char';
+        }
+        return super.getCharTypeDeclarationSQL(column);
+    }
+    getIntervalTypeDeclarationSQL(column) {
+        return 'interval' + (column.length != null ? `(${column.length})` : '');
+    }
+    getBlobDeclarationSQL() {
+        return 'bytea';
+    }
+    getJsonDeclarationSQL() {
+        return 'jsonb';
+    }
+    getSearchJsonPropertyKey(path, type, aliased, value) {
+        const first = path.shift();
+        const last = path.pop();
+        const root = this.quoteIdentifier(aliased ? `${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) => raw(type in types ? `(${key})::${types[type]}` : key);
+        let lastOperator = '->>';
+        // force `->` for operator payloads with array values
+        if (Utils.isPlainObject(value) && Object.keys(value).every(key => ARRAY_OPERATORS.includes(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 => {
+            if (!column.includes('.')) {
+                return 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 = '"') {
+        if (RawQueryFragment.isKnownFragment(id)) {
+            return super.quoteIdentifier(id);
+        }
+        return `${quote}${id.toString().replace('.', `${quote}.${quote}`)}${quote}`;
+    }
+    pad(number, digits) {
+        return String(number).padStart(digits, '0');
+    }
+    /** @internal */
+    formatDate(date) {
+        if (this.timezone === 'Z') {
+            return date.toISOString();
+        }
+        let offset = -date.getTimezoneOffset();
+        let year = date.getFullYear();
+        const isBCYear = year < 1;
+        /* v8 ignore next */
+        if (isBCYear) {
+            year = Math.abs(year) + 1;
+        }
+        const datePart = `${this.pad(year, 4)}-${this.pad(date.getMonth() + 1, 2)}-${this.pad(date.getDate(), 2)}`;
+        const timePart = `${this.pad(date.getHours(), 2)}:${this.pad(date.getMinutes(), 2)}:${this.pad(date.getSeconds(), 2)}.${this.pad(date.getMilliseconds(), 3)}`;
+        let ret = `${datePart}T${timePart}`;
+        /* v8 ignore next */
+        if (offset < 0) {
+            ret += '-';
+            offset *= -1;
+        }
+        else {
+            ret += '+';
+        }
+        ret += this.pad(Math.floor(offset / 60), 2) + ':' + this.pad(offset % 60, 2);
+        /* v8 ignore next */
+        if (isBCYear) {
+            ret += ' BC';
+        }
+        return ret;
+    }
+    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',
+            'bpchar': 'character',
+        };
+        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 63 character length for identifiers in MySQL
+     */
+    getIndexName(tableName, columns, type) {
+        const indexName = super.getIndexName(tableName, columns, type);
+        if (indexName.length > 63) {
+            const suffix = type === 'primary' ? 'pkey' : type;
+            return `${indexName.substring(0, 55 - type.length)}_${Utils.hash(indexName, 5)}_${suffix}`;
+        }
+        return indexName;
+    }
+    getDefaultPrimaryName(tableName, columns) {
+        const indexName = `${tableName}_pkey`;
+        if (indexName.length > 63) {
+            return `${indexName.substring(0, 55 - 'pkey'.length)}_${Utils.hash(indexName, 5)}_pkey`;
+        }
+        return indexName;
+    }
+    /**
+     * @inheritDoc
+     */
+    castColumn(prop) {
+        switch (prop?.columnTypes?.[0]) {
+            case this.getUuidTypeDeclarationSQL({}): return '::text';
+            case this.getBooleanTypeDeclarationSQL(): return '::int';
+            default: return '';
+        }
+    }
+    getDefaultClientUrl() {
+        return 'postgresql://postgres@127.0.0.1:5432';
+    }
+}

package/dialects/postgresql/FullTextType.d.ts

@@ -0,0 +1,14 @@
+import { Type, type TransformContext, type RawQueryFragment } from '@mikro-orm/core';
+import type { BasePostgreSqlPlatform } from './BasePostgreSqlPlatform.js';
+type FullTextWeight = 'A' | 'B' | 'C' | 'D';
+export type WeightedFullTextValue = {
+    [K in FullTextWeight]?: string | null;
+};
+export declare class FullTextType extends Type<string | WeightedFullTextValue, string | null | RawQueryFragment> {
+    regconfig: string;
+    constructor(regconfig?: string);
+    compareAsType(): string;
+    getColumnType(): string;
+    convertToDatabaseValue(value: string | WeightedFullTextValue, platform: BasePostgreSqlPlatform, context?: TransformContext | boolean): string | null | RawQueryFragment;
+}
+export {};

package/dialects/postgresql/FullTextType.js

@@ -0,0 +1,59 @@
+import { raw, Type } from '@mikro-orm/core';
+export class FullTextType extends Type {
+    regconfig;
+    constructor(regconfig = 'simple') {
+        super();
+        this.regconfig = regconfig;
+    }
+    compareAsType() {
+        return 'any';
+    }
+    getColumnType() {
+        return 'tsvector';
+    }
+    // Use convertToDatabaseValue to prepare insert queries as this method has
+    // access to the raw JS value. Return Knex#raw to prevent QueryBuilderHelper#mapData
+    // from sanitizing the returned chaing of SQL functions.
+    convertToDatabaseValue(value, platform, context) {
+        // Don't convert to values from select queries to the to_tsvector notation
+        // these should be compared as string using a special oparator or function
+        // this behaviour is defined in Platform#getFullTextWhereClause.
+        // This is always a string.
+        if (typeof context === 'object' && context.fromQuery) {
+            return value;
+        }
+        // Null values should not be processed
+        if (!value) {
+            return null;
+        }
+        // the object from that looks like { A: 'test data', B: 'test data2' ... }
+        // must be converted to
+        // setweight(to_tsvector(regconfig, value), A) || setweight(to_tsvector(regconfig, value), B)... etc
+        // use Knex#raw to do binding of the values sanitization of the boundvalues
+        // as we return a raw string which should not be sanitzed anymore
+        if (typeof value === 'object') {
+            const bindings = [];
+            const sqlParts = [];
+            for (const [weight, data] of Object.entries(value)) {
+                // Check whether the weight is valid according to Postgres,
+                // Postgres allows the weight to be upper and lowercase.
+                if (!['A', 'B', 'C', 'D'].includes(weight.toUpperCase())) {
+                    throw new Error('Weight should be one of A, B, C, D.');
+                }
+                // Ignore all values that are not a string
+                if (typeof data === 'string') {
+                    sqlParts.push('setweight(to_tsvector(?, ?), ?)');
+                    bindings.push(this.regconfig, data, weight);
+                }
+            }
+            // Return null if the object has no valid strings
+            if (sqlParts.length === 0) {
+                return null;
+            }
+            // Join all the `setweight` parts using the PostgreSQL tsvector `||` concatenation operator
+            return raw(sqlParts.join(' || '), bindings);
+        }
+        // if it's not an object, it is expected to be string which does not have to be wrapped in setweight.
+        return raw('to_tsvector(?, ?)', [this.regconfig, value]);
+    }
+}

package/dialects/postgresql/PostgreSqlExceptionConverter.d.ts

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

package/dialects/postgresql/PostgreSqlExceptionConverter.js

@@ -0,0 +1,47 @@
+import { DeadlockException, ExceptionConverter, ForeignKeyConstraintViolationException, InvalidFieldNameException, NonUniqueFieldNameException, NotNullConstraintViolationException, SyntaxErrorException, TableExistsException, TableNotFoundException, UniqueConstraintViolationException, CheckConstraintViolationException, } from '@mikro-orm/core';
+export class PostgreSqlExceptionConverter extends ExceptionConverter {
+    /**
+     * @see http://www.postgresql.org/docs/9.4/static/errcodes-appendix.html
+     * @see https://github.com/doctrine/dbal/blob/master/src/Driver/AbstractPostgreSQLDriver.php
+     */
+    convertException(exception) {
+        if (exception.detail?.toString().trim()) {
+            exception.message += '\n - detail: ' + exception.detail;
+        }
+        if (exception.hint?.toString().trim()) {
+            exception.message += '\n - hint: ' + exception.hint;
+        }
+        /* v8 ignore next */
+        switch (exception.code) {
+            case '40001':
+            case '40P01':
+                return new 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 ForeignKeyConstraintViolationException(exception);
+                }
+                break;
+            case '23502':
+                return new NotNullConstraintViolationException(exception);
+            case '23503':
+                return new ForeignKeyConstraintViolationException(exception);
+            case '23505':
+                return new UniqueConstraintViolationException(exception);
+            case '23514':
+                return new CheckConstraintViolationException(exception);
+            case '42601':
+                return new SyntaxErrorException(exception);
+            case '42702':
+                return new NonUniqueFieldNameException(exception);
+            case '42703':
+                return new InvalidFieldNameException(exception);
+            case '42P01':
+                return new TableNotFoundException(exception);
+            case '42P07':
+                return new TableExistsException(exception);
+        }
+        return super.convertException(exception);
+    }
+}

package/dialects/postgresql/PostgreSqlSchemaHelper.d.ts

@@ -0,0 +1,90 @@
+import { type Dictionary } from '@mikro-orm/core';
+import { SchemaHelper } from '../../schema/SchemaHelper.js';
+import type { AbstractSqlConnection } from '../../AbstractSqlConnection.js';
+import type { CheckDef, Column, ForeignKey, IndexDef, Table, TableDifference } from '../../typings.js';
+import type { DatabaseSchema } from '../../schema/DatabaseSchema.js';
+import type { DatabaseTable } from '../../schema/DatabaseTable.js';
+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, disableForeignKeys?: boolean): string;
+    getCreateDatabaseSQL(name: string): string;
+    getListTablesSQL(): string;
+    private getIgnoredViewsCondition;
+    getListViewsSQL(): string;
+    loadViews(schema: DatabaseSchema, connection: AbstractSqlConnection): Promise<void>;
+    getListMaterializedViewsSQL(): string;
+    loadMaterializedViews(schema: DatabaseSchema, connection: AbstractSqlConnection, schemaName?: string): Promise<void>;
+    createMaterializedView(name: string, schema: string | undefined, definition: string, withData?: boolean): string;
+    dropMaterializedViewIfExists(name: string, schema?: string): string;
+    refreshMaterializedView(name: string, schema?: string, concurrently?: boolean): 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[]>>;
+    /**
+     * Parses column definitions from the full CREATE INDEX expression.
+     * Since pg_get_indexdef(oid, col_num, true) doesn't include sort modifiers,
+     * we extract them from the full expression instead.
+     *
+     * We use columnDefs (from individual pg_get_indexdef calls) as the source
+     * of column names, and find their modifiers in the expression.
+     */
+    private parseIndexColumnsFromExpression;
+    /**
+     * Extracts the content inside parentheses starting at the given position.
+     * Handles nested parentheses correctly.
+     */
+    private extractParenthesizedContent;
+    getAllColumns(connection: AbstractSqlConnection, tablesBySchemas: Map<string | undefined, Table[]>, nativeEnums?: Dictionary<{
+        name: string;
+        schema?: string;
+        items: string[];
+    }>): Promise<Dictionary<Column[]>>;
+    getAllChecks(connection: AbstractSqlConnection, tablesBySchemas: Map<string | undefined, Table[]>): Promise<Dictionary<CheckDef[]>>;
+    getAllForeignKeys(connection: AbstractSqlConnection, tablesBySchemas: Map<string | undefined, Table[]>): Promise<Dictionary<Dictionary<ForeignKey>>>;
+    getNativeEnumDefinitions(connection: AbstractSqlConnection, schemas: string[]): Promise<Dictionary<{
+        name: string;
+        schema?: string;
+        items: string[];
+    }>>;
+    getCreateNativeEnumSQL(name: string, values: unknown[], schema?: string): string;
+    getDropNativeEnumSQL(name: string, schema?: string): string;
+    getAlterNativeEnumSQL(name: string, schema?: string, value?: string, items?: string[], oldItems?: string[]): string;
+    private getEnumDefinitions;
+    createTableColumn(column: Column, table: DatabaseTable): string | undefined;
+    getPreAlterTable(tableDiff: TableDifference, safe: boolean): string[];
+    castColumn(name: string, type: string): string;
+    dropForeignKey(tableName: string, constraintName: string): string;
+    getPostAlterTable(tableDiff: TableDifference, safe: boolean): string[];
+    private getAlterColumnAutoincrement;
+    getChangeColumnCommentSQL(tableName: string, to: Column, schemaName?: string): string;
+    alterTableComment(table: DatabaseTable, comment?: string): string;
+    normalizeDefaultValue(defaultValue: string, length: number): string | number;
+    appendComments(table: DatabaseTable): string[];
+    getDatabaseExistsSQL(name: string): string;
+    getDatabaseNotExistsError(dbName: string): string;
+    getManagementDbName(): string;
+    disableForeignKeysSQL(): string;
+    enableForeignKeysSQL(): string;
+    getRenameIndexSQL(tableName: string, index: IndexDef, oldIndexName: string): string[];
+    dropIndex(table: string, index: IndexDef, oldIndexName?: string): string;
+    /**
+     * Build the column list for a PostgreSQL index.
+     */
+    protected getIndexColumns(index: IndexDef): string;
+    /**
+     * PostgreSQL-specific index options like fill factor.
+     */
+    protected getCreateIndexSuffix(index: IndexDef): string;
+    private getIndexesSQL;
+    private getChecksSQL;
+    inferLengthFromColumnType(type: string): number | undefined;
+}