@mikro-orm/postgresql 7.0.0-dev.102 → 7.0.0-dev.103

package/PostgreSqlPlatform.d.ts

@@ -1,112 +1,11 @@
 import { type IPostgresInterval } from 'postgres-interval';
-import { type Configuration, type EntityProperty, type IsolationLevel, type SimpleColumnMeta, Type } from '@mikro-orm/core';
-import { AbstractSqlPlatform, type IndexDef, PostgreSqlNativeQueryBuilder } from '@mikro-orm/sql';
-import { PostgreSqlSchemaHelper } from './PostgreSqlSchemaHelper.js';
-import { PostgreSqlExceptionConverter } from './PostgreSqlExceptionConverter.js';
-export declare class PostgreSqlPlatform extends AbstractSqlPlatform {
-    protected readonly schemaHelper: PostgreSqlSchemaHelper;
-    protected readonly exceptionConverter: PostgreSqlExceptionConverter;
-    setConfig(config: Configuration): void;
-    createNativeQueryBuilder(): PostgreSqlNativeQueryBuilder;
-    usesReturningStatement(): boolean;
-    usesCascadeStatement(): boolean;
-    supportsNativeEnums(): boolean;
-    usesEnumCheckConstraints(): boolean;
-    supportsCustomPrimaryKeyNames(): boolean;
-    getCurrentTimestampSQL(length: number): string;
-    getDateTimeTypeDeclarationSQL(column: {
-        length?: number;
-    }): string;
-    getDefaultDateTimeLength(): number;
+import { BasePostgreSqlPlatform } from '@mikro-orm/sql';
+export declare class PostgreSqlPlatform extends BasePostgreSqlPlatform {
     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;
-    normalizeColumnType(type: string, options: {
-        length?: number;
-        precision?: number;
-        scale?: number;
-        autoincrement?: boolean;
-    }): 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;
-    getBeginTransactionSQL(options?: {
-        isolationLevel?: IsolationLevel;
-        readOnly?: boolean;
-    }): string[];
-    marshallArray(values: string[]): string;
-    unmarshallArray(value: string): string[];
-    getVarcharTypeDeclarationSQL(column: {
-        length?: number;
-    }): string;
-    getCharTypeDeclarationSQL(column: {
-        length?: number;
-    }): string;
-    getIntervalTypeDeclarationSQL(column: {
-        length?: number;
-    }): string;
-    getBlobDeclarationSQL(): string;
-    getJsonDeclarationSQL(): string;
-    getSearchJsonPropertyKey(path: string[], type: string | undefined | Type, aliased: boolean, value?: unknown): string;
-    getJsonIndexDefinition(index: IndexDef): string[];
-    quoteIdentifier(id: string | {
-        toString: () => string;
-    }, quote?: string): string;
     escape(value: any): string;
-    private pad;
-    /** @internal */
-    formatDate(date: Date): 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 63 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
      */
     parseDate(value: string | number): Date;
-    getDefaultClientUrl(): string;
 }

package/PostgreSqlPlatform.js

@@ -1,48 +1,8 @@
 import { Client } from 'pg';
 import parseDate from 'postgres-date';
 import PostgresInterval from 'postgres-interval';
-import { ALIAS_REPLACEMENT, ARRAY_OPERATORS, raw, RawQueryFragment, Type, Utils, } from '@mikro-orm/core';
-import { AbstractSqlPlatform, PostgreSqlNativeQueryBuilder } from '@mikro-orm/sql';
-import { PostgreSqlSchemaHelper } from './PostgreSqlSchemaHelper.js';
-import { PostgreSqlExceptionConverter } from './PostgreSqlExceptionConverter.js';
-import { FullTextType } from './types/FullTextType.js';
-export class PostgreSqlPlatform extends AbstractSqlPlatform {
-    schemaHelper = new PostgreSqlSchemaHelper(this);
-    exceptionConverter = new PostgreSqlExceptionConverter();
-    setConfig(config) {
-        if (config.get('forceUtcTimezone') == null) {
-            config.set('forceUtcTimezone', true);
-        }
-        super.setConfig(config);
-    }
-    createNativeQueryBuilder() {
-        return new PostgreSqlNativeQueryBuilder(this);
-    }
-    usesReturningStatement() {
-        return true;
-    }
-    usesCascadeStatement() {
-        return true;
-    }
-    supportsNativeEnums() {
-        return true;
-    }
-    usesEnumCheckConstraints() {
-        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;
-    }
+import { BasePostgreSqlPlatform, Utils } from '@mikro-orm/sql';
+export class PostgreSqlPlatform extends BasePostgreSqlPlatform {
     convertIntervalToJSValue(value) {
         return PostgresInterval(value);
     }
@@ -52,214 +12,6 @@ export class PostgreSqlPlatform extends AbstractSqlPlatform {
         }
         return value;
     }
-    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(',')}}`;
-    }
-    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}`;
-    }
     escape(value) {
         if (typeof value === 'bigint') {
             value = value.toString();
@@ -278,103 +30,6 @@ export class PostgreSqlPlatform extends AbstractSqlPlatform {
         }
         return value;
     }
-    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 '';
-        }
-    }
     /**
      * @inheritDoc
      */
@@ -395,7 +50,4 @@ export class PostgreSqlPlatform extends AbstractSqlPlatform {
         }
         return parsed;
     }
-    getDefaultClientUrl() {
-        return 'postgresql://postgres@127.0.0.1:5432';
-    }
 }

package/index.d.ts

@@ -2,8 +2,5 @@ export * from '@mikro-orm/sql';
 export * from './PostgreSqlConnection.js';
 export * from './PostgreSqlDriver.js';
 export * from './PostgreSqlPlatform.js';
-export * from './PostgreSqlSchemaHelper.js';
-export * from './PostgreSqlExceptionConverter.js';
-export * from './types/index.js';
 export { PostgreSqlMikroORM as MikroORM, type PostgreSqlOptions as Options, definePostgreSqlConfig as defineConfig, } from './PostgreSqlMikroORM.js';
 export { raw } from './raw.js';

package/index.js

@@ -2,8 +2,5 @@ export * from '@mikro-orm/sql';
 export * from './PostgreSqlConnection.js';
 export * from './PostgreSqlDriver.js';
 export * from './PostgreSqlPlatform.js';
-export * from './PostgreSqlSchemaHelper.js';
-export * from './PostgreSqlExceptionConverter.js';
-export * from './types/index.js';
 export { PostgreSqlMikroORM as MikroORM, definePostgreSqlConfig as defineConfig, } from './PostgreSqlMikroORM.js';
 export { raw } from './raw.js';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mikro-orm/postgresql",
   "type": "module",
-  "version": "7.0.0-dev.102",
+  "version": "7.0.0-dev.103",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "exports": {
     "./package.json": "./package.json",
@@ -50,7 +50,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@mikro-orm/sql": "7.0.0-dev.102",
+    "@mikro-orm/sql": "7.0.0-dev.103",
     "pg": "8.16.3",
     "pg-cursor": "2.15.3",
     "postgres-array": "3.0.4",
@@ -62,7 +62,7 @@
     "kysely": "0.28.9"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.0-dev.102",
+    "@mikro-orm/core": "7.0.0-dev.103",
     "kysely": "*"
   }
 }

package/PostgreSqlExceptionConverter.d.ts

@@ -1,8 +0,0 @@
-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/PostgreSqlExceptionConverter.js

@@ -1,47 +0,0 @@
-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/PostgreSqlSchemaHelper.d.ts

@@ -1,56 +0,0 @@
-import { type Dictionary } from '@mikro-orm/core';
-import { SchemaHelper, type AbstractSqlConnection, type CheckDef, type Column, type DatabaseSchema, type DatabaseTable, type ForeignKey, type IndexDef, type Table, type TableDifference } from '@mikro-orm/sql';
-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;
-    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, 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;
-    private getIndexesSQL;
-    private getChecksSQL;
-    inferLengthFromColumnType(type: string): number | undefined;
-}

package/PostgreSqlSchemaHelper.js

@@ -1,548 +0,0 @@
-import { EnumType, Type, Utils, DeferMode } from '@mikro-orm/core';
-import { SchemaHelper, } from '@mikro-orm/sql';
-export class PostgreSqlSchemaHelper extends SchemaHelper {
-    static DEFAULT_VALUES = {
-        'now()': ['now()', 'current_timestamp'],
-        'current_timestamp(?)': ['current_timestamp(?)'],
-        "('now'::text)::timestamp(?) with time zone": ['current_timestamp(?)'],
-        "('now'::text)::timestamp(?) without time zone": ['current_timestamp(?)'],
-        'null::character varying': ['null'],
-        'null::timestamp with time zone': ['null'],
-        'null::timestamp without time zone': ['null'],
-    };
-    getSchemaBeginning(charset, disableForeignKeys) {
-        if (disableForeignKeys) {
-            return `set names '${charset}';\n${this.disableForeignKeysSQL()}\n\n`;
-        }
-        return `set names '${charset}';\n\n`;
-    }
-    getCreateDatabaseSQL(name) {
-        return `create database ${name}`;
-    }
-    getListTablesSQL() {
-        return `select table_name, table_schema as schema_name, `
-            + `(select pg_catalog.obj_description(c.oid) from pg_catalog.pg_class c
-          where c.oid = (select ('"' || table_schema || '"."' || table_name || '"')::regclass::oid) and c.relname = table_name) as table_comment `
-            + `from information_schema.tables `
-            + `where ${this.getIgnoredNamespacesConditionSQL('table_schema')} `
-            + `and table_name != 'geometry_columns' and table_name != 'spatial_ref_sys' and table_type != 'VIEW' `
-            + `and table_name not in (select inhrelid::regclass::text from pg_inherits) `
-            + `order by table_name`;
-    }
-    async getNamespaces(connection) {
-        const sql = `select schema_name from information_schema.schemata `
-            + `where ${this.getIgnoredNamespacesConditionSQL()} `
-            + `order by schema_name`;
-        const res = await connection.execute(sql);
-        return res.map(row => row.schema_name);
-    }
-    getIgnoredNamespacesConditionSQL(column = 'schema_name') {
-        const ignored = [
-            'information_schema',
-            'tiger',
-            'topology',
-            /* v8 ignore next */
-            ...this.platform.getConfig().get('schemaGenerator').ignoreSchema ?? [],
-        ].map(s => this.platform.quoteValue(s)).join(', ');
-        const ignoredPrefixes = [
-            'pg_',
-            'crdb_',
-            '_timescaledb_',
-        ].map(p => `"${column}" not like '${p}%'`).join(' and ');
-        return `${ignoredPrefixes} and "${column}" not in (${ignored})`;
-    }
-    async loadInformationSchema(schema, connection, tables, schemas) {
-        schemas ??= tables.length === 0 ? [schema.name] : tables.map(t => t.schema_name);
-        const nativeEnums = await this.getNativeEnumDefinitions(connection, schemas);
-        schema.setNativeEnums(nativeEnums);
-        if (tables.length === 0) {
-            return;
-        }
-        const tablesBySchema = this.getTablesGroupedBySchemas(tables);
-        const columns = await this.getAllColumns(connection, tablesBySchema, nativeEnums);
-        const indexes = await this.getAllIndexes(connection, tables);
-        const checks = await this.getAllChecks(connection, tablesBySchema);
-        const fks = await this.getAllForeignKeys(connection, tablesBySchema);
-        for (const t of tables) {
-            const key = this.getTableKey(t);
-            const table = schema.addTable(t.table_name, t.schema_name, t.table_comment);
-            const pks = await this.getPrimaryKeys(connection, indexes[key], table.name, table.schema);
-            const enums = this.getEnumDefinitions(checks[key] ?? []);
-            if (columns[key]) {
-                table.init(columns[key], indexes[key], checks[key], pks, fks[key], enums);
-            }
-        }
-    }
-    async getAllIndexes(connection, tables) {
-        const sql = this.getIndexesSQL(tables);
-        const unquote = (str) => str.replace(/['"`]/g, '');
-        const allIndexes = await connection.execute(sql);
-        const ret = {};
-        for (const index of allIndexes) {
-            const key = this.getTableKey(index);
-            const indexDef = {
-                columnNames: index.index_def.map((name) => unquote(name)),
-                composite: index.index_def.length > 1,
-                // JSON columns can have unique index but not unique constraint, and we need to distinguish those, so we can properly drop them
-                constraint: index.contype === 'u',
-                keyName: index.constraint_name,
-                unique: index.unique,
-                primary: index.primary,
-            };
-            if (index.condeferrable) {
-                indexDef.deferMode = index.condeferred ? DeferMode.INITIALLY_DEFERRED : DeferMode.INITIALLY_IMMEDIATE;
-            }
-            if (index.index_def.some((col) => col.match(/[(): ,"'`]/)) || index.expression?.match(/ where /i)) {
-                indexDef.expression = index.expression;
-            }
-            if (index.deferrable) {
-                indexDef.deferMode = index.initially_deferred ? DeferMode.INITIALLY_DEFERRED : DeferMode.INITIALLY_IMMEDIATE;
-            }
-            ret[key] ??= [];
-            ret[key].push(indexDef);
-        }
-        return ret;
-    }
-    async getAllColumns(connection, tablesBySchemas, nativeEnums) {
-        const sql = `select table_schema as schema_name, table_name, column_name,
-      column_default,
-      is_nullable,
-      udt_name,
-      udt_schema,
-      coalesce(datetime_precision, character_maximum_length) length,
-      atttypmod custom_length,
-      numeric_precision,
-      numeric_scale,
-      data_type,
-      is_identity,
-      identity_generation,
-      generation_expression,
-      pg_catalog.col_description(pgc.oid, cols.ordinal_position::int) column_comment
-      from information_schema.columns cols
-      join pg_class pgc on cols.table_name = pgc.relname
-      join pg_attribute pga on pgc.oid = pga.attrelid and cols.column_name = pga.attname
-      where (${[...tablesBySchemas.entries()].map(([schema, tables]) => `(table_schema = ${this.platform.quoteValue(schema)} and table_name in (${tables.map(t => this.platform.quoteValue(t.table_name)).join(',')}))`).join(' or ')})
-      order by ordinal_position`;
-        const allColumns = await connection.execute(sql);
-        const str = (val) => val != null ? '' + val : val;
-        const ret = {};
-        for (const col of allColumns) {
-            const mappedType = connection.getPlatform().getMappedType(col.data_type);
-            const increments = (col.column_default?.includes('nextval') || col.is_identity === 'YES') && connection.getPlatform().isNumericColumn(mappedType);
-            const key = this.getTableKey(col);
-            ret[key] ??= [];
-            let type = col.data_type.toLowerCase() === 'array'
-                ? col.udt_name.replace(/^_(.*)$/, '$1[]')
-                : col.udt_name;
-            if (col.data_type === 'USER-DEFINED' && col.udt_schema && col.udt_schema !== this.platform.getDefaultSchemaName()) {
-                type = `${col.udt_schema}.${type}`;
-            }
-            if (type === 'bpchar') {
-                type = 'char';
-            }
-            if (type === 'vector' && col.length == null && col.custom_length != null && col.custom_length !== -1) {
-                col.length = col.custom_length;
-            }
-            if (col.length != null && !type.endsWith(`(${col.length})`) && !['text', 'date'].includes(type)) {
-                type += `(${col.length})`;
-            }
-            if (type === 'numeric' && col.numeric_precision != null && col.numeric_scale != null) {
-                type += `(${col.numeric_precision},${col.numeric_scale})`;
-            }
-            const length = this.inferLengthFromColumnType(type) === -1 ? -1 : col.length;
-            const column = {
-                name: col.column_name,
-                type,
-                mappedType,
-                length,
-                precision: col.numeric_precision,
-                scale: col.numeric_scale,
-                nullable: col.is_nullable === 'YES',
-                default: str(this.normalizeDefaultValue(col.column_default, col.length)),
-                unsigned: increments,
-                autoincrement: increments,
-                generated: col.is_identity === 'YES' ? (col.identity_generation === 'BY DEFAULT' ? 'by default as identity' : 'identity') : (col.generation_expression ? col.generation_expression + ' stored' : undefined),
-                comment: col.column_comment,
-            };
-            if (nativeEnums?.[column.type]) {
-                column.mappedType = Type.getType(EnumType);
-                column.nativeEnumName = column.type;
-                column.enumItems = nativeEnums[column.type]?.items;
-            }
-            ret[key].push(column);
-        }
-        return ret;
-    }
-    async getAllChecks(connection, tablesBySchemas) {
-        const sql = this.getChecksSQL(tablesBySchemas);
-        const allChecks = await connection.execute(sql);
-        const ret = {};
-        for (const check of allChecks) {
-            const key = this.getTableKey(check);
-            ret[key] ??= [];
-            const m = check.expression.match(/^check \(\((.*)\)\)$/i);
-            const def = m?.[1].replace(/\((.*?)\)::\w+/g, '$1');
-            ret[key].push({
-                name: check.name,
-                columnName: check.column_name,
-                definition: check.expression,
-                expression: def,
-            });
-        }
-        return ret;
-    }
-    async getAllForeignKeys(connection, tablesBySchemas) {
-        const sql = `select nsp1.nspname schema_name, cls1.relname table_name, nsp2.nspname referenced_schema_name,
-      cls2.relname referenced_table_name, a.attname column_name, af.attname referenced_column_name, conname constraint_name,
-      confupdtype update_rule, confdeltype delete_rule, array_position(con.conkey,a.attnum) as ord, condeferrable, condeferred,
-      pg_get_constraintdef(con.oid) as constraint_def
-      from pg_attribute a
-      join pg_constraint con on con.conrelid = a.attrelid AND a.attnum = ANY (con.conkey)
-      join pg_attribute af on af.attnum = con.confkey[array_position(con.conkey,a.attnum)] AND af.attrelid = con.confrelid
-      join pg_namespace nsp1 on nsp1.oid = con.connamespace
-      join pg_class cls1 on cls1.oid = con.conrelid
-      join pg_class cls2 on cls2.oid = confrelid
-      join pg_namespace nsp2 on nsp2.oid = cls2.relnamespace
-      where (${[...tablesBySchemas.entries()].map(([schema, tables]) => `(cls1.relname in (${tables.map(t => this.platform.quoteValue(t.table_name)).join(',')}) and nsp1.nspname = ${this.platform.quoteValue(schema)})`).join(' or ')})
-      and confrelid > 0
-      order by nsp1.nspname, cls1.relname, constraint_name, ord`;
-        const allFks = await connection.execute(sql);
-        const ret = {};
-        function mapReferentialIntegrity(value, def) {
-            const match = ['n', 'd'].includes(value) && def.match(/ON DELETE (SET (NULL|DEFAULT) \(.*?\))/);
-            if (match) {
-                return match[1];
-            }
-            /* v8 ignore next */
-            switch (value) {
-                case 'r': return 'RESTRICT';
-                case 'c': return 'CASCADE';
-                case 'n': return 'SET NULL';
-                case 'd': return 'SET DEFAULT';
-                case 'a':
-                default: return 'NO ACTION';
-            }
-        }
-        for (const fk of allFks) {
-            fk.update_rule = mapReferentialIntegrity(fk.update_rule, fk.constraint_def);
-            fk.delete_rule = mapReferentialIntegrity(fk.delete_rule, fk.constraint_def);
-            if (fk.condeferrable) {
-                fk.defer_mode = fk.condeferred ? DeferMode.INITIALLY_DEFERRED : DeferMode.INITIALLY_IMMEDIATE;
-            }
-            const key = this.getTableKey(fk);
-            ret[key] ??= [];
-            ret[key].push(fk);
-        }
-        Object.keys(ret).forEach(key => {
-            const [schemaName, tableName] = key.split('.');
-            ret[key] = this.mapForeignKeys(ret[key], tableName, schemaName);
-        });
-        return ret;
-    }
-    async getNativeEnumDefinitions(connection, schemas) {
-        const uniqueSchemas = Utils.unique(schemas);
-        const res = await connection.execute(`select t.typname as enum_name, n.nspname as schema_name, array_agg(e.enumlabel order by e.enumsortorder) as enum_value
-        from pg_type t
-        join pg_enum e on t.oid = e.enumtypid
-        join pg_catalog.pg_namespace n on n.oid = t.typnamespace
-        where n.nspname in (${Array(uniqueSchemas.length).fill('?').join(', ')})
-        group by t.typname, n.nspname`, uniqueSchemas);
-        return res.reduce((o, row) => {
-            let name = row.enum_name;
-            if (row.schema_name && row.schema_name !== this.platform.getDefaultSchemaName()) {
-                name = row.schema_name + '.' + name;
-            }
-            let items = row.enum_value;
-            if (!Array.isArray(items)) {
-                items = this.platform.unmarshallArray(row.enum_value);
-            }
-            o[name] = {
-                name: row.enum_name,
-                schema: row.schema_name,
-                items,
-            };
-            return o;
-        }, {});
-    }
-    getCreateNativeEnumSQL(name, values, schema) {
-        if (schema && schema !== this.platform.getDefaultSchemaName()) {
-            name = schema + '.' + name;
-        }
-        return `create type ${this.quote(name)} as enum (${values.map(value => this.platform.quoteValue(value)).join(', ')})`;
-    }
-    getDropNativeEnumSQL(name, schema) {
-        if (schema && schema !== this.platform.getDefaultSchemaName()) {
-            name = schema + '.' + name;
-        }
-        return `drop type ${this.quote(name)}`;
-    }
-    getAlterNativeEnumSQL(name, schema, value, items, oldItems) {
-        if (schema && schema !== this.platform.getDefaultSchemaName()) {
-            name = schema + '.' + name;
-        }
-        let suffix = '';
-        if (items && value && oldItems) {
-            const position = items.indexOf(value);
-            if (position > 0) {
-                suffix = ` after ${this.platform.quoteValue(items[position - 1])}`;
-            }
-            else if (items.length > 1 && oldItems.length > 0) {
-                suffix = ` before ${this.platform.quoteValue(oldItems[0])}`;
-            }
-        }
-        return `alter type ${this.quote(name)} add value if not exists ${this.platform.quoteValue(value)}${suffix}`;
-    }
-    getEnumDefinitions(checks) {
-        return checks.reduce((o, item) => {
-            // check constraints are defined as one of:
-            // `CHECK ((type = ANY (ARRAY['local'::text, 'global'::text])))`
-            // `CHECK (("columnName" = ANY (ARRAY['local'::text, 'global'::text])))`
-            // `CHECK (((enum_test)::text = ANY ((ARRAY['a'::character varying, 'b'::character varying, 'c'::character varying])::text[])))`
-            // `CHECK ((("enumTest")::text = ANY ((ARRAY['a'::character varying, 'b'::character varying, 'c'::character varying])::text[])))`
-            // `CHECK ((type = 'a'::text))`
-            const m1 = item.definition?.match(/check \(\(\("?(\w+)"?\)::/i) || item.definition?.match(/check \(\("?(\w+)"? = /i);
-            const m2 = item.definition?.match(/\(array\[(.*)]\)/i) || item.definition?.match(/ = (.*)\)/i);
-            if (item.columnName && m1 && m2) {
-                const m3 = m2[1].match(/('[^']*'::text)/g);
-                let items;
-                /* v8 ignore next */
-                if (m3) {
-                    items = m3.map((item) => item.trim().match(/^\(?'(.*)'/)?.[1]);
-                }
-                else {
-                    items = m2[1].split(',').map((item) => item.trim().match(/^\(?'(.*)'/)?.[1]);
-                }
-                items = items.filter(item => item !== undefined);
-                if (items.length > 0) {
-                    o[item.columnName] = items;
-                    item.expression = `${this.quote(item.columnName)} in ('${items.join("', '")}')`;
-                    item.definition = `check (${item.expression})`;
-                }
-            }
-            return o;
-        }, {});
-    }
-    createTableColumn(column, table) {
-        const pk = table.getPrimaryKey();
-        const compositePK = pk?.composite;
-        const primaryKey = !this.hasNonDefaultPrimaryKeyName(table);
-        const col = [this.quote(column.name)];
-        if (column.autoincrement && !column.generated && !compositePK) {
-            col.push(column.mappedType.getColumnType({ autoincrement: true }, this.platform));
-        }
-        else {
-            let columnType = column.type;
-            if (column.nativeEnumName) {
-                const parts = column.type.split('.');
-                if (parts.length === 2 && parts[0] === '*') {
-                    columnType = `${table.schema}.${parts[1]}`;
-                }
-                if (columnType.endsWith('[]')) {
-                    columnType = this.quote(columnType.substring(0, columnType.length - 2)) + '[]';
-                }
-                else {
-                    columnType = this.quote(columnType);
-                }
-            }
-            if (column.generated === 'by default as identity') {
-                columnType += ` generated ${column.generated}`;
-            }
-            else if (column.generated) {
-                columnType += ` generated always as ${column.generated}`;
-            }
-            col.push(columnType);
-            Utils.runIfNotEmpty(() => col.push('null'), column.nullable);
-            Utils.runIfNotEmpty(() => col.push('not null'), !column.nullable);
-        }
-        if (column.autoincrement && !compositePK) {
-            Utils.runIfNotEmpty(() => col.push('primary key'), primaryKey && column.primary);
-        }
-        const useDefault = column.default != null && column.default !== 'null' && !column.autoincrement;
-        Utils.runIfNotEmpty(() => col.push(`default ${column.default}`), useDefault);
-        return col.join(' ');
-    }
-    getPreAlterTable(tableDiff, safe) {
-        const ret = [];
-        const parts = tableDiff.name.split('.');
-        const tableName = parts.pop();
-        const schemaName = parts.pop();
-        /* v8 ignore next */
-        const name = (schemaName && schemaName !== this.platform.getDefaultSchemaName() ? schemaName + '.' : '') + tableName;
-        const quotedName = this.quote(name);
-        // detect that the column was an enum before and remove the check constraint in such case here
-        const changedEnums = Object.values(tableDiff.changedColumns).filter(col => col.fromColumn.mappedType instanceof EnumType);
-        for (const col of changedEnums) {
-            if (!col.fromColumn.nativeEnumName && col.column.nativeEnumName && col.fromColumn.default) {
-                ret.push(`alter table ${quotedName} alter column "${col.column.name}" drop default`);
-            }
-            if (col.fromColumn.nativeEnumName && !col.column.nativeEnumName && col.fromColumn.default) {
-                ret.push(`alter table ${quotedName} alter column "${col.column.name}" drop default`);
-            }
-        }
-        // changing uuid column type requires to cast it to text first
-        const uuids = Object.values(tableDiff.changedColumns).filter(col => col.changedProperties.has('type') && col.fromColumn.type === 'uuid');
-        for (const col of uuids) {
-            ret.push(`alter table ${quotedName} alter column "${col.column.name}" type text using ("${col.column.name}"::text)`);
-        }
-        for (const { column } of Object.values(tableDiff.changedColumns).filter(diff => diff.changedProperties.has('autoincrement'))) {
-            if (!column.autoincrement && column.default == null) {
-                ret.push(`alter table ${quotedName} alter column ${this.quote(column.name)} drop default`);
-            }
-        }
-        return ret;
-    }
-    castColumn(name, type) {
-        if (type === 'uuid') {
-            type = 'text::uuid';
-        }
-        return ` using (${this.quote(name)}::${type})`;
-    }
-    dropForeignKey(tableName, constraintName) {
-        return `alter table ${this.quote(tableName)} drop constraint ${this.quote(constraintName)}`;
-    }
-    getPostAlterTable(tableDiff, safe) {
-        const ret = [];
-        const parts = tableDiff.name.split('.');
-        const tableName = parts.pop();
-        const schemaName = parts.pop();
-        /* v8 ignore next */
-        const name = (schemaName && schemaName !== this.platform.getDefaultSchemaName() ? schemaName + '.' : '') + tableName;
-        const quotedName = this.quote(name);
-        // detect that the column was an enum before and remove the check constraint in such a case here
-        const changedEnums = Object.values(tableDiff.changedColumns).filter(col => col.fromColumn.mappedType instanceof EnumType);
-        for (const col of changedEnums) {
-            if (!col.fromColumn.nativeEnumName && col.column.nativeEnumName && col.column.default) {
-                ret.push(`alter table ${quotedName} alter column "${col.column.name}" set default ${col.column.default}`);
-            }
-            if (col.fromColumn.nativeEnumName && !col.column.nativeEnumName && col.column.default) {
-                ret.push(`alter table ${quotedName} alter column "${col.column.name}" set default ${col.column.default}`);
-            }
-        }
-        for (const { column } of Object.values(tableDiff.changedColumns).filter(diff => diff.changedProperties.has('autoincrement'))) {
-            ret.push(...this.getAlterColumnAutoincrement(tableName, column, schemaName));
-        }
-        return ret;
-    }
-    getAlterColumnAutoincrement(tableName, column, schemaName) {
-        const ret = [];
-        /* v8 ignore next */
-        const name = (schemaName && schemaName !== this.platform.getDefaultSchemaName() ? schemaName + '.' : '') + tableName;
-        if (column.autoincrement) {
-            const seqName = this.platform.getIndexName(tableName, [column.name], 'sequence');
-            ret.push(`create sequence if not exists ${this.quote(seqName)}`);
-            ret.push(`select setval('${seqName}', (select max(${this.quote(column.name)}) from ${this.quote(name)}))`);
-            ret.push(`alter table ${this.quote(name)} alter column ${this.quote(column.name)} set default nextval('${seqName}')`);
-        }
-        return ret;
-    }
-    getChangeColumnCommentSQL(tableName, to, schemaName) {
-        const name = this.quote((schemaName && schemaName !== this.platform.getDefaultSchemaName() ? schemaName + '.' : '') + tableName);
-        const value = to.comment ? this.platform.quoteValue(to.comment) : 'null';
-        return `comment on column ${name}."${to.name}" is ${value}`;
-    }
-    alterTableComment(table, comment) {
-        return `comment on table ${table.getQuotedName()} is ${this.platform.quoteValue(comment ?? '')}`;
-    }
-    normalizeDefaultValue(defaultValue, length) {
-        if (!defaultValue || typeof defaultValue !== 'string') {
-            return super.normalizeDefaultValue(defaultValue, length, PostgreSqlSchemaHelper.DEFAULT_VALUES);
-        }
-        const match = defaultValue.match(/^'(.*)'::(.*)$/);
-        if (match) {
-            if (match[2] === 'integer') {
-                return +match[1];
-            }
-            return `'${match[1]}'`;
-        }
-        return super.normalizeDefaultValue(defaultValue, length, PostgreSqlSchemaHelper.DEFAULT_VALUES);
-    }
-    appendComments(table) {
-        const sql = [];
-        if (table.comment) {
-            const comment = this.platform.quoteValue(table.comment).replace(/^'|'$/g, '');
-            sql.push(`comment on table ${table.getQuotedName()} is ${this.platform.quoteValue(this.processComment(comment))}`);
-        }
-        for (const column of table.getColumns()) {
-            if (column.comment) {
-                const comment = this.platform.quoteValue(this.processComment(column.comment));
-                sql.push(`comment on column ${table.getQuotedName()}.${this.quote(column.name)} is ${comment}`);
-            }
-        }
-        return sql;
-    }
-    getDatabaseExistsSQL(name) {
-        return `select 1 from pg_database where datname = '${name}'`;
-    }
-    getDatabaseNotExistsError(dbName) {
-        return `database "${dbName}" does not exist`;
-    }
-    getManagementDbName() {
-        return this.platform.getConfig().get('schemaGenerator', {}).managementDbName ?? 'postgres';
-    }
-    disableForeignKeysSQL() {
-        return `set session_replication_role = 'replica';`;
-    }
-    enableForeignKeysSQL() {
-        return `set session_replication_role = 'origin';`;
-    }
-    getRenameIndexSQL(tableName, index, oldIndexName) {
-        oldIndexName = this.quote(oldIndexName);
-        const keyName = this.quote(index.keyName);
-        return [`alter index ${oldIndexName} rename to ${keyName}`];
-    }
-    dropIndex(table, index, oldIndexName = index.keyName) {
-        if (index.primary || (index.unique && index.constraint)) {
-            return `alter table ${this.quote(table)} drop constraint ${this.quote(oldIndexName)}`;
-        }
-        return `drop index ${this.quote(oldIndexName)}`;
-    }
-    getIndexesSQL(tables) {
-        return `select indrelid::regclass as table_name, ns.nspname as schema_name, relname as constraint_name, idx.indisunique as unique, idx.indisprimary as primary, contype, condeferrable, condeferred,
-      array(
-        select pg_get_indexdef(idx.indexrelid, k + 1, true)
-        from generate_subscripts(idx.indkey, 1) as k
-        order by k
-      ) as index_def,
-      pg_get_indexdef(idx.indexrelid) as expression,
-      c.condeferrable as deferrable,
-      c.condeferred as initially_deferred
-      from pg_index idx
-      join pg_class as i on i.oid = idx.indexrelid
-      join pg_namespace as ns on i.relnamespace = ns.oid
-      left join pg_constraint as c on c.conname = i.relname
-      where indrelid in (${tables.map(t => `${this.platform.quoteValue(`${this.quote(t.schema_name)}.${this.quote(t.table_name)}`)}::regclass`).join(', ')})
-      order by relname`;
-    }
-    getChecksSQL(tablesBySchemas) {
-        return `select ccu.table_name as table_name, ccu.table_schema as schema_name, pgc.conname as name, conrelid::regclass as table_from, ccu.column_name as column_name, pg_get_constraintdef(pgc.oid) as expression
-      from pg_constraint pgc
-      join pg_namespace nsp on nsp.oid = pgc.connamespace
-      join pg_class cls on pgc.conrelid = cls.oid
-      join information_schema.constraint_column_usage ccu on pgc.conname = ccu.constraint_name and nsp.nspname = ccu.constraint_schema
-      where contype = 'c' and (${[...tablesBySchemas.entries()].map(([schema, tables]) => `ccu.table_name in (${tables.map(t => this.platform.quoteValue(t.table_name)).join(',')}) and ccu.table_schema = ${this.platform.quoteValue(schema)}`).join(' or ')})
-      order by pgc.conname`;
-    }
-    inferLengthFromColumnType(type) {
-        const match = type.match(/^(\w+(?:\s+\w+)*)\s*(?:\(\s*(\d+)\s*\)|$)/);
-        if (!match) {
-            return;
-        }
-        if (!match[2]) {
-            switch (match[1]) {
-                case 'character varying':
-                case 'varchar':
-                case 'bpchar':
-                case 'char':
-                case 'character':
-                    return -1;
-                case 'interval':
-                case 'time':
-                case 'timestamp':
-                case 'timestamptz':
-                    return this.platform.getDefaultDateTimeLength();
-            }
-            return;
-        }
-        return +match[2];
-    }
-}

package/types/FullTextType.d.ts

@@ -1,14 +0,0 @@
-import { Type, type TransformContext, type RawQueryFragment } from '@mikro-orm/core';
-import type { PostgreSqlPlatform } from '../PostgreSqlPlatform.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: PostgreSqlPlatform, context?: TransformContext | boolean): string | null | RawQueryFragment;
-}
-export {};

package/types/FullTextType.js

@@ -1,59 +0,0 @@
-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/types/index.d.ts

@@ -1 +0,0 @@
-export * from './FullTextType.js';

package/types/index.js

@@ -1 +0,0 @@
-export * from './FullTextType.js';