@mikro-orm/postgresql 6.4.7-dev.1 → 7.0.0-dev.1

package/PostgreSqlConnection.d.ts

@@ -1,7 +1,7 @@
-import { AbstractSqlConnection, type Knex } from '@mikro-orm/knex';
+import { type PoolConfig } from 'pg';
+import { PostgresDialect } from 'kysely';
+import { AbstractSqlConnection } from '@mikro-orm/knex';
 export declare class PostgreSqlConnection extends AbstractSqlConnection {
-    createKnex(): void;
-    getDefaultClientUrl(): string;
-    getConnectionOptions(): Knex.PgConnectionConfig;
-    protected transformRawResult<T>(res: any, method: 'all' | 'get' | 'run'): T;
+    createKyselyDialect(overrides: PoolConfig): PostgresDialect;
+    mapOptions(overrides: PoolConfig): PoolConfig;
 }

package/PostgreSqlConnection.js

@@ -5,19 +5,24 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PostgreSqlConnection = void 0;
 const type_overrides_1 = __importDefault(require("pg/lib/type-overrides"));
+const pg_1 = require("pg");
+const kysely_1 = require("kysely");
 const postgres_array_1 = __importDefault(require("postgres-array"));
 const knex_1 = require("@mikro-orm/knex");
 class PostgreSqlConnection extends knex_1.AbstractSqlConnection {
-    createKnex() {
-        this.client = this.createKnexClient(knex_1.PostgreSqlKnexDialect);
-        this.client.client.ormConfig = this.config;
-        this.connected = true;
+    createKyselyDialect(overrides) {
+        const options = this.mapOptions(overrides);
+        return new kysely_1.PostgresDialect({
+            pool: new pg_1.Pool(options),
+            onCreateConnection: this.options.onCreateConnection ?? this.config.get('onCreateConnection'),
+        });
     }
-    getDefaultClientUrl() {
-        return 'postgresql://postgres@127.0.0.1:5432';
-    }
-    getConnectionOptions() {
-        const ret = super.getConnectionOptions();
+    mapOptions(overrides) {
+        const ret = { ...this.getConnectionOptions() };
+        const pool = this.config.get('pool');
+        knex_1.Utils.defaultValue(ret, 'min', pool?.min);
+        knex_1.Utils.defaultValue(ret, 'max', pool?.max);
+        knex_1.Utils.defaultValue(ret, 'idleTimeoutMillis', pool?.idleTimeoutMillis);
         // use `select typname, oid, typarray from pg_type order by oid` to get the list of OIDs
         const types = new type_overrides_1.default();
         [
@@ -33,24 +38,7 @@ class PostgreSqlConnection extends knex_1.AbstractSqlConnection {
             1187, // interval[]
         ].forEach(oid => types.setTypeParser(oid, str => postgres_array_1.default.parse(str)));
         ret.types = types;
-        return ret;
-    }
-    transformRawResult(res, method) {
-        if (Array.isArray(res)) {
-            return res.map(row => this.transformRawResult(row, method));
-        }
-        if (method === 'get') {
-            return res.rows[0];
-        }
-        if (method === 'all') {
-            return res.rows;
-        }
-        return {
-            affectedRows: res.rowCount,
-            insertId: res.rows[0] ? res.rows[0].id : 0,
-            row: res.rows[0],
-            rows: res.rows,
-        };
+        return knex_1.Utils.mergeConfig(ret, overrides);
     }
 }
 exports.PostgreSqlConnection = PostgreSqlConnection;

package/PostgreSqlDriver.js

@@ -6,7 +6,7 @@ const PostgreSqlConnection_1 = require("./PostgreSqlConnection");
 const PostgreSqlPlatform_1 = require("./PostgreSqlPlatform");
 class PostgreSqlDriver extends knex_1.AbstractSqlDriver {
     constructor(config) {
-        super(config, new PostgreSqlPlatform_1.PostgreSqlPlatform(), PostgreSqlConnection_1.PostgreSqlConnection, ['knex', 'pg']);
+        super(config, new PostgreSqlPlatform_1.PostgreSqlPlatform(), PostgreSqlConnection_1.PostgreSqlConnection, ['kysely', 'pg']);
     }
 }
 exports.PostgreSqlDriver = PostgreSqlDriver;

package/PostgreSqlPlatform.d.ts

@@ -1,15 +1,17 @@
 import { type IPostgresInterval } from 'postgres-interval';
-import { type EntityProperty, Type, type SimpleColumnMeta, type Configuration } from '@mikro-orm/core';
-import { AbstractSqlPlatform, type IndexDef } from '@mikro-orm/knex';
+import { type IsolationLevel, type EntityProperty, Type, type SimpleColumnMeta, type Configuration } from '@mikro-orm/core';
+import { AbstractSqlPlatform, type IndexDef, PostgreSqlNativeQueryBuilder } from '@mikro-orm/knex';
 import { PostgreSqlSchemaHelper } from './PostgreSqlSchemaHelper';
 import { PostgreSqlExceptionConverter } from './PostgreSqlExceptionConverter';
 export declare class PostgreSqlPlatform extends AbstractSqlPlatform {
     protected readonly schemaHelper: PostgreSqlSchemaHelper;
     protected readonly exceptionConverter: PostgreSqlExceptionConverter;
     setConfig(config: Configuration): void;
+    createNativeQueryBuilder(): PostgreSqlNativeQueryBuilder;
     usesReturningStatement(): boolean;
     usesCascadeStatement(): boolean;
     supportsNativeEnums(): boolean;
+    usesEnumCheckConstraints(): boolean;
     supportsCustomPrimaryKeyNames(): boolean;
     getCurrentTimestampSQL(length: number): string;
     getDateTimeTypeDeclarationSQL(column: {
@@ -38,7 +40,7 @@ export declare class PostgreSqlPlatform extends AbstractSqlPlatform {
     getFullTextWhereClause(prop: EntityProperty): string;
     supportsCreatingFullTextIndex(): boolean;
     getFullTextIndexExpression(indexName: string, schemaName: string | undefined, tableName: string, columns: SimpleColumnMeta[]): string;
-    normalizeColumnType(type: string, options?: {
+    normalizeColumnType(type: string, options: {
         length?: number;
         precision?: number;
         scale?: number;
@@ -60,6 +62,10 @@ export declare class PostgreSqlPlatform extends AbstractSqlPlatform {
         nativeEnumName?: string;
     }): string;
     supportsMultipleStatements(): boolean;
+    getBeginTransactionSQL(options?: {
+        isolationLevel?: IsolationLevel;
+        readOnly?: boolean;
+    }): string[];
     marshallArray(values: string[]): string;
     unmarshallArray(value: string): string[];
     getVarcharTypeDeclarationSQL(column: {
@@ -100,4 +106,5 @@ export declare class PostgreSqlPlatform extends AbstractSqlPlatform {
      * @inheritDoc
      */
     parseDate(value: string | number): Date;
+    getDefaultClientUrl(): string;
 }

package/PostgreSqlPlatform.js

@@ -21,6 +21,9 @@ class PostgreSqlPlatform extends knex_1.AbstractSqlPlatform {
         }
         super.setConfig(config);
     }
+    createNativeQueryBuilder() {
+        return new knex_1.PostgreSqlNativeQueryBuilder(this);
+    }
     usesReturningStatement() {
         return true;
     }
@@ -30,6 +33,9 @@ class PostgreSqlPlatform extends knex_1.AbstractSqlPlatform {
     supportsNativeEnums() {
         return true;
     }
+    usesEnumCheckConstraints() {
+        return true;
+    }
     supportsCustomPrimaryKeyNames() {
         return true;
     }
@@ -97,7 +103,7 @@ class PostgreSqlPlatform extends knex_1.AbstractSqlPlatform {
         }
         return `create index ${quotedIndexName} on ${quotedTableName} using gin(to_tsvector('simple', ${quotedColumnNames.join(` || ' ' || `)}))`;
     }
-    normalizeColumnType(type, options = {}) {
+    normalizeColumnType(type, options) {
         const simpleType = this.extractSimpleType(type);
         if (['int', 'int4', 'integer'].includes(simpleType)) {
             return this.getIntegerTypeDeclarationSQL({});
@@ -171,6 +177,15 @@ class PostgreSqlPlatform extends knex_1.AbstractSqlPlatform {
     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(',')}}`;
@@ -247,6 +262,9 @@ class PostgreSqlPlatform extends knex_1.AbstractSqlPlatform {
         });
     }
     quoteIdentifier(id, quote = '"') {
+        if (core_1.RawQueryFragment.isKnownFragment(id)) {
+            return super.quoteIdentifier(id);
+        }
         return `${quote}${id.replace('.', `${quote}.${quote}`)}${quote}`;
     }
     escape(value) {
@@ -336,14 +354,15 @@ class PostgreSqlPlatform extends knex_1.AbstractSqlPlatform {
     getIndexName(tableName, columns, type) {
         const indexName = super.getIndexName(tableName, columns, type);
         if (indexName.length > 63) {
-            return `${indexName.substring(0, 55 - type.length)}_${core_1.Utils.hash(indexName, 5)}_${type}`;
+            const suffix = type === 'primary' ? 'pkey' : type;
+            return `${indexName.substring(0, 55 - type.length)}_${core_1.Utils.hash(indexName, 5)}_${suffix}`;
         }
         return indexName;
     }
     getDefaultPrimaryName(tableName, columns) {
         const indexName = `${tableName}_pkey`;
         if (indexName.length > 63) {
-            return `${indexName.substring(0, 55 - 'primary'.length)}_${core_1.Utils.hash(indexName, 5)}_primary`;
+            return `${indexName.substring(0, 55 - 'pkey'.length)}_${core_1.Utils.hash(indexName, 5)}_pkey`;
         }
         return indexName;
     }
@@ -376,5 +395,8 @@ class PostgreSqlPlatform extends knex_1.AbstractSqlPlatform {
         }
         return parsed;
     }
+    getDefaultClientUrl() {
+        return 'postgresql://postgres@127.0.0.1:5432';
+    }
 }
 exports.PostgreSqlPlatform = PostgreSqlPlatform;

package/PostgreSqlSchemaHelper.d.ts

@@ -1,5 +1,5 @@
 import { type Dictionary } from '@mikro-orm/core';
-import { SchemaHelper, type AbstractSqlConnection, type CheckDef, type Column, type DatabaseSchema, type DatabaseTable, type ForeignKey, type IndexDef, type Knex, type Table, type TableDifference } from '@mikro-orm/knex';
+import { SchemaHelper, type AbstractSqlConnection, type CheckDef, type Column, type DatabaseSchema, type DatabaseTable, type ForeignKey, type IndexDef, type Table, type TableDifference } from '@mikro-orm/knex';
 export declare class PostgreSqlSchemaHelper extends SchemaHelper {
     static readonly DEFAULT_VALUES: {
         'now()': string[];
@@ -32,24 +32,25 @@ export declare class PostgreSqlSchemaHelper extends SchemaHelper {
     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;
-    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 | undefined;
-    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;
+    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;
+    getRenameIndexSQL(tableName: string, index: IndexDef, oldIndexName: string): string[];
+    dropIndex(table: 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[]>;
     inferLengthFromColumnType(type: string): number | undefined;
 }

package/PostgreSqlSchemaHelper.js

@@ -55,7 +55,7 @@ class PostgreSqlSchemaHelper extends knex_1.SchemaHelper {
         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 ?? schema.name);
+        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) {
@@ -70,7 +70,7 @@ class PostgreSqlSchemaHelper extends knex_1.SchemaHelper {
             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 = await this.getEnumDefinitions(connection, checks[key] ?? []);
+            const enums = this.getEnumDefinitions(checks[key] ?? []);
             table.init(columns[key], indexes[key], checks[key], pks, fks[key], enums);
         }
     }
@@ -265,13 +265,13 @@ class PostgreSqlSchemaHelper extends knex_1.SchemaHelper {
         if (schema && schema !== this.platform.getDefaultSchemaName()) {
             name = schema + '.' + name;
         }
-        return `create type ${this.platform.quoteIdentifier(name)} as enum (${values.map(value => this.platform.quoteValue(value)).join(', ')})`;
+        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.platform.quoteIdentifier(name)}`;
+        return `drop type ${this.quote(name)}`;
     }
     getAlterNativeEnumSQL(name, schema, value, items, oldItems) {
         if (schema && schema !== this.platform.getDefaultSchemaName()) {
@@ -287,11 +287,10 @@ class PostgreSqlSchemaHelper extends knex_1.SchemaHelper {
                 suffix = ` before ${this.platform.quoteValue(oldItems[0])}`;
             }
         }
-        return `alter type ${this.platform.quoteIdentifier(name)} add value if not exists ${this.platform.quoteValue(value)}${suffix}`;
+        return `alter type ${this.quote(name)} add value if not exists ${this.platform.quoteValue(value)}${suffix}`;
     }
-    async getEnumDefinitions(connection, checks, tableName, schemaName) {
-        const found = [];
-        const enums = checks.reduce((o, item, index) => {
+    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])))`
@@ -313,72 +312,50 @@ class PostgreSqlSchemaHelper extends knex_1.SchemaHelper {
                 items = items.filter(item => item !== undefined);
                 if (items.length > 0) {
                     o[item.columnName] = items;
-                    found.push(index);
+                    item.expression = `${this.quote(item.columnName)} in ('${items.join("', '")}')`;
+                    item.definition = `check (${item.expression})`;
                 }
             }
             return o;
         }, {});
-        found.reverse().forEach(index => checks.splice(index, 1));
-        return enums;
-    }
-    createTableColumn(table, column, fromTable, changedProperties, alter) {
-        const pk = fromTable.getPrimaryKey();
-        const primaryKey = column.primary && !changedProperties && !this.hasNonDefaultPrimaryKeyName(fromTable);
-        if (column.autoincrement && !column.generated && !pk?.composite && !changedProperties) {
-            if (column.mappedType instanceof core_1.BigIntType) {
-                return table.bigIncrements(column.name, { primaryKey });
-            }
-            return table.increments(column.name, { primaryKey });
+    }
+    createTableColumn(column, table) {
+        const compositePK = table.getPrimaryKey()?.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));
         }
-        if (column.nativeEnumName && column.enumItems) {
-            let schemaPrefix = fromTable.schema && fromTable.schema !== this.platform.getDefaultSchemaName() ? `${fromTable.schema}.` : '';
-            let enumName = column.nativeEnumName;
-            if (enumName.includes('.')) {
-                const [schemaName, ...parts] = enumName.split('.');
-                enumName = parts.join('.');
-                schemaPrefix = schemaName + '.';
-            }
-            const type = this.platform.quoteIdentifier(schemaPrefix + enumName);
-            if (column.type.endsWith('[]')) {
-                return table.specificType(column.name, type + '[]');
+        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);
+                }
             }
-            return table.specificType(column.name, type);
-        }
-        if (changedProperties && column.mappedType instanceof core_1.EnumType && column.enumItems?.every(item => core_1.Utils.isString(item))) {
-            const checkName = this.platform.getConfig().getNamingStrategy().indexName(fromTable.name, [column.name], 'check');
-            if (changedProperties.has('enumItems') || (!column.nativeEnumName && fromTable.getColumn(column.name)?.nativeEnumName)) {
-                table.check(`${this.platform.quoteIdentifier(column.name)} in ('${(column.enumItems.join("', '"))}')`, {}, this.platform.quoteIdentifier(checkName));
+            if (column.generated === 'by default as identity') {
+                columnType += ` generated ${column.generated}`;
             }
-            if (changedProperties.has('type')) {
-                return table.specificType(column.name, column.type);
+            else if (column.generated) {
+                columnType += ` generated always as ${column.generated}`;
             }
-            return undefined;
-        }
-        if (column.mappedType instanceof core_1.EnumType && column.enumItems?.every(item => core_1.Utils.isString(item))) {
-            return table.enum(column.name, column.enumItems);
+            col.push(columnType);
+            core_1.Utils.runIfNotEmpty(() => col.push('null'), column.nullable);
+            core_1.Utils.runIfNotEmpty(() => col.push('not null'), !column.nullable);
         }
-        // serial is just a pseudo type, it cannot be used for altering
-        /* istanbul ignore next */
-        if (changedProperties && column.type.includes('serial')) {
-            column.type = column.type.replace('serial', 'int');
-        }
-        let columnType = column.type;
-        if (column.generated === 'by default as identity') {
-            columnType += ` generated ${column.generated}`;
-        }
-        else if (column.generated) {
-            columnType += ` generated always as ${column.generated}`;
+        if (column.autoincrement && !column.generated && !compositePK) {
+            core_1.Utils.runIfNotEmpty(() => col.push('primary key'), primaryKey && column.primary);
         }
-        return table.specificType(column.name, columnType);
-    }
-    configureColumn(column, col, knex, changedProperties) {
-        const guard = (key) => !changedProperties || changedProperties.has(key);
-        core_1.Utils.runIfNotEmpty(() => col.nullable(), column.nullable && guard('nullable'));
-        core_1.Utils.runIfNotEmpty(() => col.notNullable(), !column.nullable && guard('nullable'));
-        core_1.Utils.runIfNotEmpty(() => col.unsigned(), column.unsigned && guard('unsigned'));
-        core_1.Utils.runIfNotEmpty(() => col.comment(column.comment), column.comment && !changedProperties);
-        this.configureColumnDefault(column, col, knex, changedProperties);
-        return col;
+        const useDefault = column.default != null && column.default !== 'null' && !column.autoincrement;
+        core_1.Utils.runIfNotEmpty(() => col.push(`default ${column.default}`), useDefault);
+        return col.join(' ');
     }
     getPreAlterTable(tableDiff, safe) {
         const ret = [];
@@ -387,7 +364,7 @@ class PostgreSqlSchemaHelper extends knex_1.SchemaHelper {
         const schemaName = parts.pop();
         /* istanbul ignore next */
         const name = (schemaName && schemaName !== this.platform.getDefaultSchemaName() ? schemaName + '.' : '') + tableName;
-        const quotedName = this.platform.quoteIdentifier(name);
+        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 core_1.EnumType);
         for (const col of changedEnums) {
@@ -397,19 +374,27 @@ class PostgreSqlSchemaHelper extends knex_1.SchemaHelper {
             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) {
-                if (col.changedProperties.has('enumItems') || col.column.nativeEnumName) {
-                    const constraintName = `${tableName}_${col.column.name}_check`;
-                    ret.push(`alter table ${quotedName} drop constraint if exists "${constraintName}"`);
-                }
-            }
         }
         // 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)`);
         }
-        return ret.join(';\n');
+        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 = [];
@@ -418,8 +403,8 @@ class PostgreSqlSchemaHelper extends knex_1.SchemaHelper {
         const schemaName = parts.pop();
         /* istanbul ignore next */
         const name = (schemaName && schemaName !== this.platform.getDefaultSchemaName() ? schemaName + '.' : '') + tableName;
-        const quotedName = this.platform.quoteIdentifier(name);
-        // detect that the column was an enum before and remove the check constraint in such case here
+        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 core_1.EnumType);
         for (const col of changedEnums) {
             if (!col.fromColumn.nativeEnumName && col.column.nativeEnumName && col.column.default) {
@@ -429,30 +414,32 @@ class PostgreSqlSchemaHelper extends knex_1.SchemaHelper {
                 ret.push(`alter table ${quotedName} alter column "${col.column.name}" set default ${col.column.default}`);
             }
         }
-        return ret.join(';\n');
+        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 = [];
-        const quoted = (val) => this.platform.quoteIdentifier(val);
         /* istanbul ignore next */
         const name = (schemaName && schemaName !== this.platform.getDefaultSchemaName() ? schemaName + '.' : '') + tableName;
         /* istanbul ignore else */
         if (column.autoincrement) {
             const seqName = this.platform.getIndexName(tableName, [column.name], 'sequence');
-            ret.push(`create sequence if not exists ${quoted(seqName)}`);
-            ret.push(`select setval('${seqName}', (select max(${quoted(column.name)}) from ${quoted(name)}))`);
-            ret.push(`alter table ${quoted(name)} alter column ${quoted(column.name)} set default nextval('${seqName}')`);
-        }
-        else if (column.default == null) {
-            ret.push(`alter table ${quoted(name)} alter column ${quoted(column.name)} drop default`);
+            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.join(';\n');
+        return ret;
     }
     getChangeColumnCommentSQL(tableName, to, schemaName) {
-        const name = this.platform.quoteIdentifier((schemaName && schemaName !== this.platform.getDefaultSchemaName() ? schemaName + '.' : '') + tableName);
+        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);
@@ -466,6 +453,20 @@ class PostgreSqlSchemaHelper extends knex_1.SchemaHelper {
         }
         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}'`;
     }
@@ -482,9 +483,15 @@ class PostgreSqlSchemaHelper extends knex_1.SchemaHelper {
         return `set session_replication_role = 'origin';`;
     }
     getRenameIndexSQL(tableName, index, oldIndexName) {
-        oldIndexName = this.platform.quoteIdentifier(oldIndexName);
-        const keyName = this.platform.quoteIdentifier(index.keyName);
-        return `alter index ${oldIndexName} rename to ${keyName}`;
+        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,
@@ -500,7 +507,7 @@ class PostgreSqlSchemaHelper extends knex_1.SchemaHelper {
       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.platform.quoteIdentifier(t.schema_name ?? this.platform.getDefaultSchemaName() ?? '')}.${this.platform.quoteIdentifier(t.table_name)}`)}::regclass`).join(', ')})
+      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) {
@@ -509,24 +516,9 @@ class PostgreSqlSchemaHelper extends knex_1.SchemaHelper {
       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 ?? this.platform.getDefaultSchemaName() ?? '')}`).join(' or ')})
+      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`;
     }
-    /* istanbul ignore next */
-    async getChecks(connection, tableName, schemaName, columns) {
-        const res = await this.getAllChecks(connection, new Map([[schemaName, [{ table_name: tableName, schema_name: schemaName }]]]));
-        return res[tableName];
-    }
-    /* istanbul ignore next */
-    async getColumns(connection, tableName, schemaName) {
-        const res = await this.getAllColumns(connection, new Map([[schemaName, [{ table_name: tableName, schema_name: schemaName }]]]));
-        return res[tableName];
-    }
-    /* istanbul ignore next */
-    async getIndexes(connection, tableName, schemaName) {
-        const res = await this.getAllIndexes(connection, [{ table_name: tableName, schema_name: schemaName }]);
-        return res[tableName];
-    }
     inferLengthFromColumnType(type) {
         const match = type.match(/^(\w+(?:\s+\w+)*)\s*(?:\(\s*(\d+)\s*\)|$)/);
         if (!match) {

package/README.md

@@ -183,7 +183,6 @@ yarn add @mikro-orm/core @mikro-orm/mariadb       # for mysql/mariadb
 yarn add @mikro-orm/core @mikro-orm/postgresql    # for postgresql
 yarn add @mikro-orm/core @mikro-orm/mssql         # for mssql
 yarn add @mikro-orm/core @mikro-orm/sqlite        # for sqlite
-yarn add @mikro-orm/core @mikro-orm/better-sqlite # for better-sqlite
 yarn add @mikro-orm/core @mikro-orm/libsql        # for libsql
 ```
 
@@ -196,7 +195,6 @@ npm i -s @mikro-orm/core @mikro-orm/mariadb       # for mysql/mariadb
 npm i -s @mikro-orm/core @mikro-orm/postgresql    # for postgresql
 npm i -s @mikro-orm/core @mikro-orm/mssql         # for mssql
 npm i -s @mikro-orm/core @mikro-orm/sqlite        # for sqlite
-npm i -s @mikro-orm/core @mikro-orm/better-sqlite # for better-sqlite
 npm i -s @mikro-orm/core @mikro-orm/libsql        # for libsql
 ```
 

package/index.mjs

@@ -19,12 +19,10 @@ export const ArrayType = mod.ArrayType;
 export const BaseEntity = mod.BaseEntity;
 export const BaseSqliteConnection = mod.BaseSqliteConnection;
 export const BaseSqlitePlatform = mod.BaseSqlitePlatform;
-export const BaseSqliteSchemaHelper = mod.BaseSqliteSchemaHelper;
 export const BeforeCreate = mod.BeforeCreate;
 export const BeforeDelete = mod.BeforeDelete;
 export const BeforeUpdate = mod.BeforeUpdate;
 export const BeforeUpsert = mod.BeforeUpsert;
-export const BetterSqliteKnexDialect = mod.BetterSqliteKnexDialect;
 export const BigIntType = mod.BigIntType;
 export const BlobType = mod.BlobType;
 export const BooleanType = mod.BooleanType;
@@ -113,14 +111,12 @@ export const JSON_KEY_OPERATORS = mod.JSON_KEY_OPERATORS;
 export const JoinType = mod.JoinType;
 export const JsonProperty = mod.JsonProperty;
 export const JsonType = mod.JsonType;
-export const Knex = mod.Knex;
-export const LibSqlKnexDialect = mod.LibSqlKnexDialect;
+export const Kysely = mod.Kysely;
 export const LoadStrategy = mod.LoadStrategy;
 export const LockMode = mod.LockMode;
 export const LockWaitTimeoutException = mod.LockWaitTimeoutException;
 export const ManyToMany = mod.ManyToMany;
 export const ManyToOne = mod.ManyToOne;
-export const MariaDbKnexDialect = mod.MariaDbKnexDialect;
 export const MediumIntType = mod.MediumIntType;
 export const MemoryCacheAdapter = mod.MemoryCacheAdapter;
 export const MetadataDiscovery = mod.MetadataDiscovery;
@@ -130,13 +126,12 @@ export const MetadataStorage = mod.MetadataStorage;
 export const MetadataValidator = mod.MetadataValidator;
 export const MikroORM = mod.MikroORM;
 export const MongoNamingStrategy = mod.MongoNamingStrategy;
-export const MonkeyPatchable = mod.MonkeyPatchable;
-export const MsSqlKnexDialect = mod.MsSqlKnexDialect;
-export const MySqlConnection = mod.MySqlConnection;
+export const MsSqlNativeQueryBuilder = mod.MsSqlNativeQueryBuilder;
 export const MySqlExceptionConverter = mod.MySqlExceptionConverter;
-export const MySqlKnexDialect = mod.MySqlKnexDialect;
+export const MySqlNativeQueryBuilder = mod.MySqlNativeQueryBuilder;
 export const MySqlPlatform = mod.MySqlPlatform;
 export const MySqlSchemaHelper = mod.MySqlSchemaHelper;
+export const NativeQueryBuilder = mod.NativeQueryBuilder;
 export const NodeState = mod.NodeState;
 export const NonUniqueFieldNameException = mod.NonUniqueFieldNameException;
 export const NotFoundError = mod.NotFoundError;
@@ -159,7 +154,7 @@ export const PopulatePath = mod.PopulatePath;
 export const PostgreSqlConnection = mod.PostgreSqlConnection;
 export const PostgreSqlDriver = mod.PostgreSqlDriver;
 export const PostgreSqlExceptionConverter = mod.PostgreSqlExceptionConverter;
-export const PostgreSqlKnexDialect = mod.PostgreSqlKnexDialect;
+export const PostgreSqlNativeQueryBuilder = mod.PostgreSqlNativeQueryBuilder;
 export const PostgreSqlPlatform = mod.PostgreSqlPlatform;
 export const PostgreSqlSchemaHelper = mod.PostgreSqlSchemaHelper;
 export const PrimaryKey = mod.PrimaryKey;
@@ -173,6 +168,7 @@ export const QueryOperator = mod.QueryOperator;
 export const QueryOrder = mod.QueryOrder;
 export const QueryOrderNumeric = mod.QueryOrderNumeric;
 export const QueryType = mod.QueryType;
+export const Raw = mod.Raw;
 export const RawQueryFragment = mod.RawQueryFragment;
 export const ReadOnlyException = mod.ReadOnlyException;
 export const Ref = mod.Ref;
@@ -194,8 +190,9 @@ export const SmallIntType = mod.SmallIntType;
 export const SqlEntityManager = mod.SqlEntityManager;
 export const SqlEntityRepository = mod.SqlEntityRepository;
 export const SqlSchemaGenerator = mod.SqlSchemaGenerator;
-export const SqliteKnexDialect = mod.SqliteKnexDialect;
-export const SqliteTableCompiler = mod.SqliteTableCompiler;
+export const SqliteExceptionConverter = mod.SqliteExceptionConverter;
+export const SqliteNativeQueryBuilder = mod.SqliteNativeQueryBuilder;
+export const SqliteSchemaHelper = mod.SqliteSchemaHelper;
 export const StringType = mod.StringType;
 export const SyntaxErrorException = mod.SyntaxErrorException;
 export const TableExistsException = mod.TableExistsException;
@@ -229,7 +226,7 @@ export const equals = mod.equals;
 export const getOnConflictFields = mod.getOnConflictFields;
 export const getOnConflictReturningFields = mod.getOnConflictReturningFields;
 export const helper = mod.helper;
-export const knex = mod.knex;
+export const isRaw = mod.isRaw;
 export const parseJsonSafe = mod.parseJsonSafe;
 export const raw = mod.raw;
 export const ref = mod.ref;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/postgresql",
-  "version": "6.4.7-dev.1",
+  "version": "7.0.0-dev.1",
   "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.",
   "main": "index.js",
   "module": "index.mjs",
@@ -46,7 +46,7 @@
   },
   "homepage": "https://mikro-orm.io",
   "engines": {
-    "node": ">= 18.12.0"
+    "node": ">= 22.11.0"
   },
   "scripts": {
     "build": "yarn clean && yarn compile && yarn copy && yarn run -T gen-esm-wrapper index.js index.mjs",
@@ -58,16 +58,18 @@
     "access": "public"
   },
   "dependencies": {
-    "@mikro-orm/knex": "6.4.7-dev.1",
-    "pg": "8.13.3",
+    "@mikro-orm/knex": "7.0.0-dev.1",
+    "pg": "8.13.1",
     "postgres-array": "3.0.2",
     "postgres-date": "2.1.0",
     "postgres-interval": "4.0.2"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^6.4.6"
+    "@mikro-orm/core": "^6.4.5",
+    "kysely": "https://pkg.pr.new/kysely-org/kysely/kysely@2b7007e"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "6.4.7-dev.1"
+    "@mikro-orm/core": "7.0.0-dev.1",
+    "kysely": "*"
   }
 }