@mikro-orm/postgresql 7.0.0-dev.33 → 7.0.0-dev.331

package/README.md

@@ -2,14 +2,14 @@
   <a href="https://mikro-orm.io"><img src="https://raw.githubusercontent.com/mikro-orm/mikro-orm/master/docs/static/img/logo-readme.svg?sanitize=true" alt="MikroORM" /></a>
 </h1>
 
-TypeScript ORM for Node.js based on Data Mapper, [Unit of Work](https://mikro-orm.io/docs/unit-of-work/) and [Identity Map](https://mikro-orm.io/docs/identity-map/) patterns. Supports MongoDB, MySQL, MariaDB, PostgreSQL and SQLite (including libSQL) databases. 
+TypeScript ORM for Node.js based on Data Mapper, [Unit of Work](https://mikro-orm.io/docs/unit-of-work/) and [Identity Map](https://mikro-orm.io/docs/identity-map/) patterns. Supports MongoDB, MySQL, MariaDB, PostgreSQL, SQLite (including libSQL), MSSQL and Oracle databases. 
 
 > Heavily inspired by [Doctrine](https://www.doctrine-project.org/) and [Hibernate](https://hibernate.org/).
 
-[![NPM version](https://img.shields.io/npm/v/@mikro-orm/core.svg)](https://www.npmjs.com/package/@mikro-orm/core)
-[![NPM dev version](https://img.shields.io/npm/v/@mikro-orm/core/next.svg)](https://www.npmjs.com/package/@mikro-orm/core)
+[![NPM version](https://img.shields.io/npm/v/@mikro-orm/core.svg)](https://npmx.dev/package/@mikro-orm/core)
+[![NPM dev version](https://img.shields.io/npm/v/@mikro-orm/core/next.svg)](https://npmx.dev/package/@mikro-orm/core)
 [![Chat on discord](https://img.shields.io/discord/1214904142443839538?label=discord&color=blue)](https://discord.gg/w8bjxFHS7X)
-[![Downloads](https://img.shields.io/npm/dm/@mikro-orm/core.svg)](https://www.npmjs.com/package/@mikro-orm/core)
+[![Downloads](https://img.shields.io/npm/dm/@mikro-orm/core.svg)](https://npmx.dev/package/@mikro-orm/core)
 [![Coverage Status](https://img.shields.io/coveralls/mikro-orm/mikro-orm.svg)](https://coveralls.io/r/mikro-orm/mikro-orm?branch=master)
 [![Build Status](https://github.com/mikro-orm/mikro-orm/workflows/tests/badge.svg?branch=master)](https://github.com/mikro-orm/mikro-orm/actions?workflow=tests)
 
@@ -181,6 +181,7 @@ yarn add @mikro-orm/core @mikro-orm/mysql         # for mysql/mariadb
 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/oracledb      # for oracle
 yarn add @mikro-orm/core @mikro-orm/sqlite        # for sqlite
 yarn add @mikro-orm/core @mikro-orm/libsql        # for libsql
 ```
@@ -381,6 +382,8 @@ See also the list of contributors who [participated](https://github.com/mikro-or
 
 Please ⭐️ this repository if this project helped you!
 
+> If you'd like to support my open-source work, consider sponsoring me directly at [github.com/sponsors/b4nan](https://github.com/sponsors/b4nan).
+
 ## 📝 License
 
 Copyright © 2018 [Martin Adámek](https://github.com/b4nan).

package/index.d.ts

@@ -1,8 +1,7 @@
-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, PostgreSqlOptions as Options, definePostgreSqlConfig as defineConfig, } from './PostgreSqlMikroORM.js';
+export { PostgreSqlEntityManager as EntityManager } from './PostgreSqlEntityManager.js';
+export { PostgreSqlMikroORM as MikroORM, type PostgreSqlOptions as Options, definePostgreSqlConfig as defineConfig, } from './PostgreSqlMikroORM.js';
+export { raw } from './raw.js';

package/index.js

@@ -1,8 +1,7 @@
-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 { PostgreSqlEntityManager as EntityManager } from './PostgreSqlEntityManager.js';
 export { PostgreSqlMikroORM as MikroORM, definePostgreSqlConfig as defineConfig, } from './PostgreSqlMikroORM.js';
+export { raw } from './raw.js';

package/package.json

@@ -1,67 +1,67 @@
 {
   "name": "@mikro-orm/postgresql",
-  "type": "module",
-  "version": "7.0.0-dev.33",
+  "version": "7.0.0-dev.331",
   "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",
-    ".": "./index.js"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+ssh://git@github.com/mikro-orm/mikro-orm.git"
-  },
   "keywords": [
-    "orm",
+    "data-mapper",
+    "ddd",
+    "entity",
+    "identity-map",
+    "javascript",
+    "js",
+    "mariadb",
+    "mikro-orm",
     "mongo",
     "mongodb",
     "mysql",
-    "mariadb",
+    "orm",
     "postgresql",
     "sqlite",
     "sqlite3",
     "ts",
     "typescript",
-    "js",
-    "javascript",
-    "entity",
-    "ddd",
-    "mikro-orm",
-    "unit-of-work",
-    "data-mapper",
-    "identity-map"
+    "unit-of-work"
   ],
-  "author": "Martin Adámek",
-  "license": "MIT",
+  "homepage": "https://mikro-orm.io",
   "bugs": {
     "url": "https://github.com/mikro-orm/mikro-orm/issues"
   },
-  "homepage": "https://mikro-orm.io",
-  "engines": {
-    "node": ">= 22.11.0"
+  "license": "MIT",
+  "author": "Martin Adámek",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/mikro-orm/mikro-orm.git"
+  },
+  "type": "module",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": "./index.js"
+  },
+  "publishConfig": {
+    "access": "public"
   },
   "scripts": {
-    "build": "yarn clean && yarn compile && yarn copy",
+    "build": "yarn compile && yarn copy",
     "clean": "yarn run -T rimraf ./dist",
     "compile": "yarn run -T tsc -p tsconfig.build.json",
     "copy": "node ../../scripts/copy.mjs"
   },
-  "publishConfig": {
-    "access": "public"
-  },
   "dependencies": {
-    "@mikro-orm/knex": "7.0.0-dev.33",
-    "pg": "8.16.3",
+    "@mikro-orm/sql": "7.0.0-dev.331",
+    "kysely": "0.28.11",
+    "pg": "8.20.0",
+    "pg-cursor": "2.19.0",
     "postgres-array": "3.0.4",
     "postgres-date": "2.1.0",
     "postgres-interval": "4.0.2"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^6.5.7",
-    "kysely": "0.28.7"
+    "@mikro-orm/core": "^6.6.9"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.0-dev.33",
-    "kysely": "*"
+    "@mikro-orm/core": "7.0.0-dev.331"
+  },
+  "engines": {
+    "node": ">= 22.17.0"
   }
 }

package/raw.d.ts

@@ -0,0 +1,67 @@
+import { type AnyString, type Dictionary, type EntityKey, type RawQueryFragment } from '@mikro-orm/sql';
+import type { SelectQueryBuilder as KyselySelectQueryBuilder } from 'kysely';
+/** @internal Type for QueryBuilder instances passed to raw() - uses toRaw to distinguish from Kysely QueryBuilder */
+type QueryBuilderLike = {
+    toQuery(): {
+        sql: string;
+        params: readonly unknown[];
+    };
+    toRaw(): RawQueryFragment;
+};
+/**
+ * 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<R = RawQueryFragment & symbol, T extends object = any>(sql: QueryBuilderLike | KyselySelectQueryBuilder<any, any, any> | EntityKey<T> | EntityKey<T>[] | AnyString | ((alias: string) => string) | RawQueryFragment, params?: readonly unknown[] | Dictionary<unknown>): R;
+export {};

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;
-}