@mikro-orm/postgresql 7.0.0-dev.11 → 7.0.0-dev.110

package/index.js

@@ -1,8 +1,6 @@
-export * from '@mikro-orm/knex';
+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.11",
+  "version": "7.0.0-dev.110",
   "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",
@@ -38,7 +38,7 @@
   },
   "homepage": "https://mikro-orm.io",
   "engines": {
-    "node": ">= 22.11.0"
+    "node": ">= 22.17.0"
   },
   "scripts": {
     "build": "yarn clean && yarn compile && yarn copy",
@@ -50,18 +50,18 @@
     "access": "public"
   },
   "dependencies": {
-    "@mikro-orm/knex": "7.0.0-dev.11",
-    "pg": "8.14.1",
+    "@mikro-orm/sql": "7.0.0-dev.110",
+    "kysely": "0.28.9",
+    "pg": "8.16.3",
+    "pg-cursor": "2.15.3",
     "postgres-array": "3.0.4",
     "postgres-date": "2.1.0",
     "postgres-interval": "4.0.2"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^6.4.13",
-    "kysely": "0.28.0"
+    "@mikro-orm/core": "^6.6.2"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.0-dev.11",
-    "kysely": "*"
+    "@mikro-orm/core": "7.0.0-dev.110"
   }
 }

package/raw.d.ts

@@ -0,0 +1,58 @@
+import { type AnyString, type Dictionary, type EntityKey, type RawQueryFragment, type QueryBuilder } from '@mikro-orm/sql';
+import type { SelectQueryBuilder } from 'kysely';
+/**
+ * Creates raw SQL query fragment that can be assigned to a property or part of a filter. This fragment is represented
+ * by `RawQueryFragment` class instance that can be serialized to a string, so it can be used both as an object value
+ * and key. When serialized, the fragment key gets cached and only such cached key will be recognized by the ORM.
+ * This adds a runtime safety to the raw query fragments.
+ *
+ * > **`raw()` helper is required since v6 to use a raw fragment in your query, both through EntityManager and QueryBuilder.**
+ *
+ * ```ts
+ * // as a value
+ * await em.find(User, { time: raw('now()') });
+ *
+ * // as a key
+ * await em.find(User, { [raw('lower(name)')]: name.toLowerCase() });
+ *
+ * // value can be empty array
+ * await em.find(User, { [raw('(select 1 = 1)')]: [] });
+ * ```
+ *
+ * The `raw` helper supports several signatures, you can pass in a callback that receives the current property alias:
+ *
+ * ```ts
+ * await em.find(User, { [raw(alias => `lower(${alias}.name)`)]: name.toLowerCase() });
+ * ```
+ *
+ * You can also use the `sql` tagged template function, which works the same, but supports only the simple string signature:
+ *
+ * ```ts
+ * await em.find(User, { [sql`lower(name)`]: name.toLowerCase() });
+ * ```
+ *
+ * When using inside filters, you might have to use a callback signature to create new raw instance for every filter usage.
+ *
+ * ```ts
+ * @Filter({ name: 'long', cond: () => ({ [raw('length(perex)')]: { $gt: 10000 } }) })
+ * ```
+ *
+ * The `raw` helper can be used within indexes and uniques to write database-agnostic SQL expressions. In that case, you can use `'??'` to tag your database identifiers (table name, column names, index name, ...) inside your expression, and pass those identifiers as a second parameter to the `raw` helper. Internally, those will automatically be quoted according to the database in use:
+ *
+ * ```ts
+ * // On postgres, will produce: create index "index custom_idx_on_name" on "library.author" ("country")
+ * // On mysql, will produce: create index `index custom_idx_on_name` on `library.author` (`country`)
+ * @Index({ name: 'custom_idx_on_name', expression: (table, columns) => raw(`create index ?? on ?? (??)`, ['custom_idx_on_name', table, columns.name]) })
+ * @Entity({ schema: 'library' })
+ * export class Author { ... }
+ * ```
+ *
+ * You can also use the `quote` tag function to write database-agnostic SQL expressions. The end-result is the same as using the `raw` function regarding database identifiers quoting, only to have a more elegant expression syntax:
+ *
+ * ```ts
+ * @Index({ name: 'custom_idx_on_name', expression: (table, columns) => quote`create index ${'custom_idx_on_name'} on ${table} (${columns.name})` })
+ * @Entity({ schema: 'library' })
+ * export class Author { ... }
+ * ```
+ */
+export declare function raw<T extends object = any, R = any>(sql: SelectQueryBuilder<any, any, any> | QueryBuilder<T> | EntityKey<T> | EntityKey<T>[] | AnyString | ((alias: string) => string) | RawQueryFragment, params?: readonly unknown[] | Dictionary<unknown>): NoInfer<R>;

package/raw.js

@@ -0,0 +1,64 @@
+import { raw as raw_, Utils } from '@mikro-orm/sql';
+/**
+ * Creates raw SQL query fragment that can be assigned to a property or part of a filter. This fragment is represented
+ * by `RawQueryFragment` class instance that can be serialized to a string, so it can be used both as an object value
+ * and key. When serialized, the fragment key gets cached and only such cached key will be recognized by the ORM.
+ * This adds a runtime safety to the raw query fragments.
+ *
+ * > **`raw()` helper is required since v6 to use a raw fragment in your query, both through EntityManager and QueryBuilder.**
+ *
+ * ```ts
+ * // as a value
+ * await em.find(User, { time: raw('now()') });
+ *
+ * // as a key
+ * await em.find(User, { [raw('lower(name)')]: name.toLowerCase() });
+ *
+ * // value can be empty array
+ * await em.find(User, { [raw('(select 1 = 1)')]: [] });
+ * ```
+ *
+ * The `raw` helper supports several signatures, you can pass in a callback that receives the current property alias:
+ *
+ * ```ts
+ * await em.find(User, { [raw(alias => `lower(${alias}.name)`)]: name.toLowerCase() });
+ * ```
+ *
+ * You can also use the `sql` tagged template function, which works the same, but supports only the simple string signature:
+ *
+ * ```ts
+ * await em.find(User, { [sql`lower(name)`]: name.toLowerCase() });
+ * ```
+ *
+ * When using inside filters, you might have to use a callback signature to create new raw instance for every filter usage.
+ *
+ * ```ts
+ * @Filter({ name: 'long', cond: () => ({ [raw('length(perex)')]: { $gt: 10000 } }) })
+ * ```
+ *
+ * The `raw` helper can be used within indexes and uniques to write database-agnostic SQL expressions. In that case, you can use `'??'` to tag your database identifiers (table name, column names, index name, ...) inside your expression, and pass those identifiers as a second parameter to the `raw` helper. Internally, those will automatically be quoted according to the database in use:
+ *
+ * ```ts
+ * // On postgres, will produce: create index "index custom_idx_on_name" on "library.author" ("country")
+ * // On mysql, will produce: create index `index custom_idx_on_name` on `library.author` (`country`)
+ * @Index({ name: 'custom_idx_on_name', expression: (table, columns) => raw(`create index ?? on ?? (??)`, ['custom_idx_on_name', table, columns.name]) })
+ * @Entity({ schema: 'library' })
+ * export class Author { ... }
+ * ```
+ *
+ * You can also use the `quote` tag function to write database-agnostic SQL expressions. The end-result is the same as using the `raw` function regarding database identifiers quoting, only to have a more elegant expression syntax:
+ *
+ * ```ts
+ * @Index({ name: 'custom_idx_on_name', expression: (table, columns) => quote`create index ${'custom_idx_on_name'} on ${table} (${columns.name})` })
+ * @Entity({ schema: 'library' })
+ * export class Author { ... }
+ * ```
+ */
+export function raw(sql, params) {
+    if (Utils.isObject(sql) && 'compile' in sql) {
+        const query = sql.compile();
+        const processed = query.sql.replaceAll(/\$\d+/g, '?');
+        return raw_(processed, query.parameters);
+    }
+    return raw_(sql, params);
+}

package/PostgreSqlExceptionConverter.d.ts

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

package/PostgreSqlExceptionConverter.js

@@ -1,48 +0,0 @@
-import { DeadlockException, ExceptionConverter, ForeignKeyConstraintViolationException, InvalidFieldNameException, NonUniqueFieldNameException, NotNullConstraintViolationException, SyntaxErrorException, TableExistsException, TableNotFoundException, UniqueConstraintViolationException, CheckConstraintViolationException, } from '@mikro-orm/core';
-export class PostgreSqlExceptionConverter extends ExceptionConverter {
-    /**
-     * @link http://www.postgresql.org/docs/9.4/static/errcodes-appendix.html
-     * @link https://github.com/doctrine/dbal/blob/master/src/Driver/AbstractPostgreSQLDriver.php
-     */
-    convertException(exception) {
-        if (exception.detail?.toString().trim()) {
-            exception.message += '\n - detail: ' + exception.detail;
-        }
-        if (exception.hint?.toString().trim()) {
-            exception.message += '\n - hint: ' + exception.hint;
-        }
-        /* v8 ignore start */
-        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);
-        }
-        /* v8 ignore stop */
-        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/knex';
-export declare class PostgreSqlSchemaHelper extends SchemaHelper {
-    static readonly DEFAULT_VALUES: {
-        'now()': string[];
-        'current_timestamp(?)': string[];
-        "('now'::text)::timestamp(?) with time zone": string[];
-        "('now'::text)::timestamp(?) without time zone": string[];
-        'null::character varying': string[];
-        'null::timestamp with time zone': string[];
-        'null::timestamp without time zone': string[];
-    };
-    getSchemaBeginning(charset: string, 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;
-}