@mikro-orm/sql 7.1.0-dev.30 → 7.1.0-dev.32

package/AbstractSqlConnection.js

@@ -1,6 +1,23 @@
 import { CompiledQuery, Kysely } from 'kysely';
 import { Connection, EventType, isRaw, Utils, } from '@mikro-orm/core';
 import { NativeQueryBuilder } from './query/NativeQueryBuilder.js';
+/**
+ * Pulls cancellation controls out of a `loggerContext` payload, returning the abort options
+ * and a sanitized context that no longer carries them. The QueryBuilder/EM stash
+ * `signal`/`inflightQueryAbortStrategy` on `loggerContext` to avoid widening the public
+ * connection API; stripping them prevents leakage into user `Logger.logQuery` payloads.
+ */
+function extractAbortOptions(loggerContext) {
+    const ctx = loggerContext;
+    if (ctx?.signal == null && ctx?.inflightQueryAbortStrategy == null) {
+        return { loggerContext };
+    }
+    const { signal, inflightQueryAbortStrategy, ...rest } = ctx;
+    return {
+        abort: { signal, inflightQueryAbortStrategy },
+        loggerContext: rest,
+    };
+}
 /** Base class for SQL database connections, built on top of Kysely. */
 export class AbstractSqlConnection extends Connection {
     #client;
@@ -183,17 +200,19 @@ export class AbstractSqlConnection extends Connection {
         await this.ensureConnection();
         const q = this.prepareQuery(query, params);
         const sql = this.getSql(q.query, q.formatted, loggerContext);
+        const { abort, loggerContext: cleanCtx } = extractAbortOptions(loggerContext);
         return this.executeQuery(sql, async () => {
             const compiled = CompiledQuery.raw(q.formatted);
-            const res = await (ctx ?? this.#client).executeQuery(compiled);
+            const res = await (ctx ?? this.#client).executeQuery(compiled, abort);
             return this.transformRawResult(res, method);
-        }, { ...q, ...loggerContext });
+        }, { ...q, ...cleanCtx });
     }
     /** Executes a SQL query and returns an async iterable that yields results row by row. */
     async *stream(query, params = [], ctx, loggerContext, chunkSize) {
         await this.ensureConnection();
         const q = this.prepareQuery(query, params);
         const sql = this.getSql(q.query, q.formatted, loggerContext);
+        const { abort, loggerContext: cleanCtx } = extractAbortOptions(loggerContext);
         // construct the compiled query manually with `kind: 'SelectQueryNode'` to avoid sqlite validation for select queries when streaming
         const compiled = {
             query: {
@@ -203,11 +222,13 @@ export class AbstractSqlConnection extends Connection {
             parameters: [],
         };
         try {
-            const res = (ctx ?? this.getClient()).getExecutor().stream(compiled, chunkSize ?? 100);
+            const res = (ctx ?? this.getClient())
+                .getExecutor()
+                .stream(compiled, chunkSize ?? 100, abort ? { signal: abort.signal } : undefined);
             this.logQuery(sql, {
                 sql,
                 params,
-                ...loggerContext,
+                ...cleanCtx,
                 affected: Utils.isPlainObject(res) ? res.affectedRows : undefined,
             });
             for await (const items of res) {
@@ -217,7 +238,7 @@ export class AbstractSqlConnection extends Connection {
             }
         }
         catch (e) {
-            this.logQuery(sql, { sql, params, ...loggerContext, level: 'error' });
+            this.logQuery(sql, { sql, params, ...cleanCtx, level: 'error' });
             throw e;
         }
     }

package/AbstractSqlDriver.js

@@ -3,6 +3,28 @@ import { QueryBuilder } from './query/QueryBuilder.js';
 import { JoinType, QueryType } from './query/enums.js';
 import { SqlEntityManager } from './SqlEntityManager.js';
 import { PivotCollectionPersister } from './PivotCollectionPersister.js';
+/** Extracts cancellation controls from any options bag that extends `AbortQueryOptions`. */
+function pickAbortOptions(options) {
+    if (!options || (options.signal == null && options.inflightQueryAbortStrategy == null)) {
+        return undefined;
+    }
+    return {
+        signal: options.signal,
+        inflightQueryAbortStrategy: options.inflightQueryAbortStrategy,
+    };
+}
+/**
+ * Returns a `loggerContext` payload that carries the abort fields alongside any existing
+ * context. The connection layer strips them before logging — this avoids widening the public
+ * `Connection.execute()` signature.
+ */
+function withAbortContext(loggerContext, options) {
+    const abort = pickAbortOptions(options);
+    if (!abort) {
+        return loggerContext;
+    }
+    return { ...loggerContext, ...abort };
+}
 /** Base class for SQL database drivers, implementing find/insert/update/delete using QueryBuilder. */
 export class AbstractSqlDriver extends DatabaseDriver {
     [EntityManagerType];
@@ -60,6 +82,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
         const qb = this.createQueryBuilder(meta.class, options.ctx, connectionType, false, options.logging, undefined, options.em)
             .withSchema(schema)
             .cache(false);
+        qb.setAbortOptions(pickAbortOptions(options));
         const fields = this.buildFields(meta, populate, joinedProps, qb, qb.alias, options, schema);
         const orderBy = this.buildOrderBy(qb, meta, populate, options);
         const populateWhere = this.buildPopulateWhere(meta, joinedProps, options);
@@ -216,7 +239,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
         const asKeyword = this.platform.usesAsKeyword() ? ' as ' : ' ';
         native.from(raw(`(${expression})${asKeyword}${this.platform.quoteIdentifier(qb.alias)}`));
         const query = native.compile();
-        const res = await this.execute(query.sql, query.params, 'all', options.ctx);
+        const res = await this.execute(query.sql, query.params, 'all', options.ctx, withAbortContext(options.loggerContext, options));
         if (type === QueryType.COUNT) {
             return res[0].count;
         }
@@ -233,7 +256,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
         native.from(raw(`(${expression})${asKeyword}${this.platform.quoteIdentifier(qb.alias)}`));
         const query = native.compile();
         const connectionType = this.resolveConnectionType({ ctx: options.ctx, connectionType: options.connectionType });
-        const res = this.getConnection(connectionType).stream(query.sql, query.params, options.ctx, options.loggerContext, options.chunkSize);
+        const res = this.getConnection(connectionType).stream(query.sql, query.params, options.ctx, withAbortContext(options.loggerContext, options), options.chunkSize);
         for await (const row of res) {
             yield this.mapResult(row, meta);
         }
@@ -541,6 +564,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
         const joinedProps = this.joinedProps(meta, populate, options);
         const schema = this.getSchemaName(meta, options);
         const qb = this.createQueryBuilder(entityName, options.ctx, options.connectionType, false, options.logging);
+        qb.setAbortOptions(pickAbortOptions(options));
         const populateWhere = this.buildPopulateWhere(meta, joinedProps, options);
         if (meta && !Utils.isEmpty(populate)) {
             this.buildFields(meta, populate, joinedProps, qb, qb.alias, options, schema);
@@ -566,6 +590,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
         const meta = this.metadata.get(entityName);
         const collections = this.extractManyToMany(meta, data);
         const qb = this.createQueryBuilder(entityName, options.ctx, 'write', options.convertCustomTypes, options.loggerContext).withSchema(this.getSchemaName(meta, options));
+        qb.setAbortOptions(pickAbortOptions(options));
         const res = await this.rethrow(qb.insert(data).execute('run', false));
         res.row = res.row || {};
         let pk;
@@ -598,9 +623,12 @@ export class AbstractSqlDriver extends DatabaseDriver {
         const props = this.getCloneableProps(meta);
         const mappedOverrides = this.mapCloneOverrides(overrides, meta, options);
         const { selectFields, insertColumns } = this.buildCloneFields(props, mappedOverrides, meta);
+        const abort = pickAbortOptions(options);
         const selectQb = this.createQueryBuilder(meta.class, options.ctx, 'read', options.convertCustomTypes, options.loggerContext).withSchema(this.getSchemaName(meta, options));
         selectQb.select(selectFields).where(where);
+        selectQb.setAbortOptions(abort);
         const insertQb = this.createQueryBuilder(meta.class, options.ctx, 'write', options.convertCustomTypes, options.loggerContext).withSchema(this.getSchemaName(meta, options));
+        insertQb.setAbortOptions(abort);
         return this.rethrow(insertQb
             .insertFrom(selectQb, { columns: insertColumns })
             .execute('run', false));
@@ -630,9 +658,12 @@ export class AbstractSqlDriver extends DatabaseDriver {
                 }
             }
             const sourceWhere = tableMeta === rootMeta ? where : (Utils.extractPK(where, tableMeta) ?? where);
+            const abort = pickAbortOptions(options);
             const selectQb = this.createQueryBuilder(tableMeta.class, options.ctx, 'read', options.convertCustomTypes, options.loggerContext).withSchema(this.getSchemaName(tableMeta, options));
             selectQb.select(selectFields).where(sourceWhere);
+            selectQb.setAbortOptions(abort);
             const insertQb = this.createQueryBuilder(tableMeta.class, options.ctx, 'write', options.convertCustomTypes, options.loggerContext).withSchema(this.getSchemaName(tableMeta, options));
+            insertQb.setAbortOptions(abort);
             const res = await this.rethrow(insertQb
                 .insertFrom(selectQb, { columns: insertColumns })
                 .execute('run', false));
@@ -840,7 +871,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
         if (transform) {
             sql = transform(sql);
         }
-        const res = await this.execute(sql, params, 'run', options.ctx, options.loggerContext);
+        const res = await this.execute(sql, params, 'run', options.ctx, withAbortContext(options.loggerContext, options));
         let pk;
         /* v8 ignore next */
         if (pks.length > 1) {
@@ -873,6 +904,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
         }
         if (Utils.hasObjectKeys(data)) {
             const qb = this.createQueryBuilder(entityName, options.ctx, 'write', options.convertCustomTypes, options.loggerContext).withSchema(this.getSchemaName(meta, options));
+            qb.setAbortOptions(pickAbortOptions(options));
             if (options.upsert) {
                 /* v8 ignore next */
                 const uniqueFields = options.onConflictFields ??
@@ -918,6 +950,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
                     ? Object.keys(where[0]).flatMap(key => Utils.splitPrimaryKeys(key))
                     : meta.primaryKeys);
             const qb = this.createQueryBuilder(entityName, options.ctx, 'write', options.convertCustomTypes, options.loggerContext).withSchema(this.getSchemaName(meta, options));
+            qb.setAbortOptions(pickAbortOptions(options));
             const returning = getOnConflictReturningFields(meta, data[0], uniqueFields, options);
             qb.insert(data)
                 .onConflict(uniqueFields)
@@ -1063,7 +1096,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
         if (transform) {
             sql = transform(sql, params);
         }
-        const res = await this.rethrow(this.execute(sql, params, 'run', options.ctx, options.loggerContext));
+        const res = await this.rethrow(this.execute(sql, params, 'run', options.ctx, withAbortContext(options.loggerContext, options)));
         for (let i = 0; i < collections.length; i++) {
             await this.processManyToMany(meta, where[i], collections[i], false, options);
         }
@@ -1081,6 +1114,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
         const qb = this.createQueryBuilder(entityName, options.ctx, 'write', false, options.loggerContext)
             .delete(where)
             .withSchema(this.getSchemaName(meta, options));
+        qb.setAbortOptions(pickAbortOptions(options));
         return this.rethrow(qb.execute('run', false));
     }
     /**
@@ -1151,6 +1185,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
             if (coll.property.kind === ReferenceKind.ONE_TO_MANY) {
                 const cols = coll.property.referencedColumnNames;
                 const qb = this.createQueryBuilder(coll.property.targetMeta.class, options?.ctx, 'write').withSchema(this.getSchemaName(meta, options));
+                qb.setAbortOptions(pickAbortOptions(options));
                 if (coll.getSnapshot() === undefined) {
                     if (coll.property.orphanRemoval) {
                         const query = qb
@@ -1192,7 +1227,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
                 schema = this.config.get('schema');
             }
             const tableName = `${schema ?? '_'}.${pivotMeta.tableName}`;
-            const persister = (groups[tableName] ??= new PivotCollectionPersister(pivotMeta, this, options?.ctx, schema, options?.loggerContext));
+            const persister = (groups[tableName] ??= new PivotCollectionPersister(pivotMeta, this, options?.ctx, schema, options?.loggerContext, pickAbortOptions(options)));
             persister.enqueueUpdate(coll.property, insertDiff, deleteDiff, pks, coll.isInitialized());
         }
         for (const persister of Utils.values(groups)) {
@@ -2023,7 +2058,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
         for (const prop of meta.relations) {
             if (collections[prop.name]) {
                 const pivotMeta = this.metadata.get(prop.pivotEntity);
-                const persister = new PivotCollectionPersister(pivotMeta, this, options?.ctx, options?.schema, options?.loggerContext);
+                const persister = new PivotCollectionPersister(pivotMeta, this, options?.ctx, options?.schema, options?.loggerContext, pickAbortOptions(options));
                 persister.enqueueUpdate(prop, collections[prop.name], clear, pks);
                 await this.rethrow(persister.execute());
             }
@@ -2032,6 +2067,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
     async lockPessimistic(entity, options) {
         const meta = helper(entity).__meta;
         const qb = this.createQueryBuilder(meta.class, options.ctx, undefined, undefined, options.logging).withSchema(options.schema ?? meta.schema);
+        qb.setAbortOptions(pickAbortOptions(options));
         const cond = Utils.getPrimaryKeyCond(entity, meta.primaryKeys);
         qb.select(raw('1'))
             .where(cond)

package/PivotCollectionPersister.d.ts

@@ -1,8 +1,8 @@
-import { type Dictionary, type EntityMetadata, type EntityProperty, type Primary, type Transaction } from '@mikro-orm/core';
+import { type AbortQueryOptions, type Dictionary, type EntityMetadata, type EntityProperty, type Primary, type Transaction } from '@mikro-orm/core';
 import { type AbstractSqlDriver } from './AbstractSqlDriver.js';
 export declare class PivotCollectionPersister<Entity extends object> {
     #private;
-    constructor(meta: EntityMetadata<Entity>, driver: AbstractSqlDriver, ctx?: Transaction, schema?: string, loggerContext?: Dictionary);
+    constructor(meta: EntityMetadata<Entity>, driver: AbstractSqlDriver, ctx?: Transaction, schema?: string, loggerContext?: Dictionary, abort?: AbortQueryOptions);
     enqueueUpdate(prop: EntityProperty<Entity>, insertDiff: Primary<Entity>[][], deleteDiff: Primary<Entity>[][] | boolean, pks: Primary<Entity>[], isInitialized?: boolean): void;
     private enqueueInsert;
     private enqueueUpsert;

package/PivotCollectionPersister.js

@@ -44,12 +44,14 @@ export class PivotCollectionPersister {
     #ctx;
     #schema;
     #loggerContext;
-    constructor(meta, driver, ctx, schema, loggerContext) {
+    #abort;
+    constructor(meta, driver, ctx, schema, loggerContext, abort) {
         this.#meta = meta;
         this.#driver = driver;
         this.#ctx = ctx;
         this.#schema = schema;
         this.#loggerContext = loggerContext;
+        this.#abort = abort;
         this.#batchSize = this.#driver.config.get('batchSize');
     }
     enqueueUpdate(prop, insertDiff, deleteDiff, pks, isInitialized = true) {
@@ -153,6 +155,7 @@ export class PivotCollectionPersister {
                     ctx: this.#ctx,
                     schema: this.#schema,
                     loggerContext: this.#loggerContext,
+                    ...this.#abort,
                 });
             }
         }
@@ -166,6 +169,7 @@ export class PivotCollectionPersister {
                     convertCustomTypes: false,
                     processCollections: false,
                     loggerContext: this.#loggerContext,
+                    ...this.#abort,
                 });
             }
         }
@@ -181,6 +185,7 @@ export class PivotCollectionPersister {
                     upsert: true,
                     onConflictAction: 'ignore',
                     loggerContext: this.#loggerContext,
+                    ...this.#abort,
                 });
             }
         }

package/README.md

@@ -2,7 +2,7 @@
   <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, SQLite (including libSQL), MSSQL and Oracle 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 (including CockroachDB and PGlite), SQLite (including libSQL), MSSQL and Oracle databases.
 
 > Heavily inspired by [Doctrine](https://www.doctrine-project.org/) and [Hibernate](https://hibernate.org/).
 
@@ -19,6 +19,7 @@ Install a driver package for your database:
 
 ```sh
 npm install @mikro-orm/postgresql   # PostgreSQL
+npm install @mikro-orm/pglite       # PGlite (embedded PostgreSQL in WASM)
 npm install @mikro-orm/mysql        # MySQL
 npm install @mikro-orm/mariadb      # MariaDB
 npm install @mikro-orm/sqlite       # SQLite

package/SqlEntityManager.d.ts

@@ -1,4 +1,4 @@
-import { type EntitySchemaWithMeta, EntityManager, type AnyEntity, type ConnectionType, type CountByOptions, type Dictionary, type EntityData, type EntityKey, type EntityName, type EntityRepository, type FilterQuery, type GetRepository, type LoggingOptions, type QueryResult, type RawQueryFragment } from '@mikro-orm/core';
+import { type AbortQueryOptions, type EntitySchemaWithMeta, EntityManager, type AnyEntity, type ConnectionType, type CountByOptions, type Dictionary, type EntityData, type EntityKey, type EntityName, type EntityRepository, type FilterQuery, type GetRepository, type LoggingOptions, type QueryResult, type RawQueryFragment } from '@mikro-orm/core';
 import type { AbstractSqlDriver } from './AbstractSqlDriver.js';
 import type { NativeQueryBuilder } from './query/NativeQueryBuilder.js';
 import type { QueryBuilder } from './query/QueryBuilder.js';
@@ -6,6 +6,13 @@ import type { SqlEntityRepository } from './SqlEntityRepository.js';
 import type { Kysely } from 'kysely';
 import type { InferClassEntityDB, InferKyselyDB } from './typings.js';
 import { type MikroKyselyPluginOptions } from './plugin/index.js';
+/** Options for the modern signature of `SqlEntityManager.execute()`. */
+export interface EmExecuteOptions extends AbortQueryOptions {
+    /** Result shape — `'all'` for rows, `'get'` for a single row, `'run'` for affected count. Defaults to `'all'`. */
+    method?: 'all' | 'get' | 'run';
+    /** Logger context payload forwarded to `Logger.logQuery`. */
+    loggerContext?: LoggingOptions;
+}
 /** Options for `SqlEntityManager.getKysely()`. */
 export interface GetKyselyOptions extends MikroKyselyPluginOptions {
     /** Connection type to use (`'read'` or `'write'`). */
@@ -27,8 +34,19 @@ export declare class SqlEntityManager<Driver extends AbstractSqlDriver = Abstrac
      * Returns configured Kysely instance.
      */
     getKysely<TDB = undefined, TOptions extends GetKyselyOptions = GetKyselyOptions>(options?: TOptions): Kysely<TDB extends undefined ? InferKyselyDB<EntitiesFromManager<this>, TOptions> & InferClassEntityDB<AllEntitiesFromManager<this>, TOptions> : TDB>;
-    /** Executes a raw SQL query, using the current transaction context if available. */
+    /**
+     * Executes a raw SQL query, using the current transaction context if available. The fork-level
+     * `signal` / `inflightQueryAbortStrategy` (set via `em.fork({ signal })`) is applied automatically.
+     * For per-call cancellation use the options-bag overload below.
+     */
     execute<T extends QueryResult | EntityData<AnyEntity> | EntityData<AnyEntity>[] = EntityData<AnyEntity>[]>(query: string | NativeQueryBuilder | RawQueryFragment, params?: any[], method?: 'all' | 'get' | 'run', loggerContext?: LoggingOptions): Promise<T>;
+    /**
+     * Executes a raw SQL query with an options bag carrying `method`, `loggerContext`, `signal`
+     * and `inflightQueryAbortStrategy`. Per-call `signal` / `inflightQueryAbortStrategy` override
+     * the fork-level defaults set via `em.fork({ signal })`. The current transaction context is
+     * applied automatically.
+     */
+    execute<T extends QueryResult | EntityData<AnyEntity> | EntityData<AnyEntity>[] = EntityData<AnyEntity>[]>(query: string | NativeQueryBuilder | RawQueryFragment, params: any[], options: EmExecuteOptions): Promise<T>;
     /**
      * @inheritDoc
      */

package/SqlEntityManager.js

@@ -9,7 +9,9 @@ export class SqlEntityManager extends EntityManager {
      */
     createQueryBuilder(entityName, alias, type, loggerContext) {
         const context = this.getContext(false);
-        return this.driver.createQueryBuilder(entityName, context.getTransactionContext(), type, true, loggerContext ?? context.loggerContext, alias, this);
+        const qb = this.driver.createQueryBuilder(entityName, context.getTransactionContext(), type, true, loggerContext ?? context.loggerContext, alias, this);
+        qb.setAbortOptions(context.getAbortOptions());
+        return qb;
     }
     /**
      * Shortcut for `createQueryBuilder()`
@@ -31,9 +33,19 @@ export class SqlEntityManager extends EntityManager {
         }
         return kysely;
     }
-    /** Executes a raw SQL query, using the current transaction context if available. */
-    async execute(query, params = [], method = 'all', loggerContext) {
-        return this.getDriver().execute(query, params, method, this.getContext(false).getTransactionContext(), loggerContext);
+    async execute(query, params = [], methodOrOptions = 'all', loggerContext) {
+        const opts = typeof methodOrOptions === 'string' ? { method: methodOrOptions, loggerContext } : methodOrOptions;
+        const context = this.getContext(false);
+        // Per-field fallback to fork-level abort, matching `EntityManager.prepareOptions` semantics.
+        const fork = context.getAbortOptions();
+        const hasAbort = opts.signal != null || opts.inflightQueryAbortStrategy != null || fork != null;
+        // Connection layer carries abort piggy-backed on `loggerContext`; merge only when needed.
+        const merged = hasAbort || opts.loggerContext ? { ...opts.loggerContext } : undefined;
+        if (merged && hasAbort) {
+            merged.signal = opts.signal ?? fork?.signal;
+            merged.inflightQueryAbortStrategy = opts.inflightQueryAbortStrategy ?? fork?.inflightQueryAbortStrategy;
+        }
+        return this.getDriver().execute(query, params, opts.method ?? 'all', context.getTransactionContext(), merged);
     }
     /**
      * @inheritDoc

package/dialects/postgresql/BasePostgreSqlEntityManager.d.ts

@@ -0,0 +1,19 @@
+import { type EntityName } from '@mikro-orm/core';
+import { SqlEntityManager } from '../../SqlEntityManager.js';
+import type { AbstractSqlDriver } from '../../AbstractSqlDriver.js';
+/**
+ * Shared base class for PostgreSQL-flavoured entity managers (`pg`, `pglite`).
+ * Adds Postgres-only helpers on top of `SqlEntityManager`.
+ */
+export declare class BasePostgreSqlEntityManager<Driver extends AbstractSqlDriver = AbstractSqlDriver> extends SqlEntityManager<Driver> {
+    /**
+     * Refreshes a materialized view.
+     *
+     * @param entityName - The entity name or class of the materialized view
+     * @param options - Optional settings
+     * @param options.concurrently - If true, refreshes the view concurrently (requires a unique index on the view)
+     */
+    refreshMaterializedView<Entity extends object>(entityName: EntityName<Entity>, options?: {
+        concurrently?: boolean;
+    }): Promise<void>;
+}

package/dialects/postgresql/BasePostgreSqlEntityManager.js

@@ -0,0 +1,24 @@
+import { SqlEntityManager } from '../../SqlEntityManager.js';
+/**
+ * Shared base class for PostgreSQL-flavoured entity managers (`pg`, `pglite`).
+ * Adds Postgres-only helpers on top of `SqlEntityManager`.
+ */
+export class BasePostgreSqlEntityManager extends SqlEntityManager {
+    /**
+     * Refreshes a materialized view.
+     *
+     * @param entityName - The entity name or class of the materialized view
+     * @param options - Optional settings
+     * @param options.concurrently - If true, refreshes the view concurrently (requires a unique index on the view)
+     */
+    async refreshMaterializedView(entityName, options) {
+        const meta = this.getMetadata(entityName);
+        if (!meta.view || !meta.materialized) {
+            throw new Error(`Entity ${meta.className} is not a materialized view`);
+        }
+        const helper = this.getDriver().getPlatform().getSchemaHelper();
+        const schema = meta.schema ?? this.config.get('schema');
+        const sql = helper.refreshMaterializedView(meta.tableName, schema, options?.concurrently);
+        await this.execute(sql);
+    }
+}

package/dialects/postgresql/BasePostgreSqlPlatform.d.ts

@@ -71,6 +71,12 @@ export declare class BasePostgreSqlPlatform extends AbstractSqlPlatform {
     }): string[];
     marshallArray(values: string[]): string;
     unmarshallArray(value: string): string[];
+    escape(value: any): string;
+    /**
+     * Ported from PostgreSQL 9.2.4 source code (`src/interfaces/libpq/fe-exec.c`),
+     * matching `pg.Client.prototype.escapeLiteral` so we don't need a `pg` dep here.
+     */
+    private escapeLiteral;
     getVarcharTypeDeclarationSQL(column: {
         length?: number;
     }): string;

package/dialects/postgresql/BasePostgreSqlPlatform.js

@@ -212,6 +212,50 @@ export class BasePostgreSqlPlatform extends AbstractSqlPlatform {
             return v;
         });
     }
+    escape(value) {
+        if (typeof value === 'bigint') {
+            value = value.toString();
+        }
+        if (typeof value === 'string') {
+            return this.escapeLiteral(value);
+        }
+        if (value instanceof Date) {
+            return `'${this.formatDate(value)}'`;
+        }
+        if (ArrayBuffer.isView(value)) {
+            return `E'\\\\x${value.toString('hex')}'`;
+        }
+        if (Array.isArray(value)) {
+            return value.map(v => this.escape(v)).join(', ');
+        }
+        return value;
+    }
+    /**
+     * Ported from PostgreSQL 9.2.4 source code (`src/interfaces/libpq/fe-exec.c`),
+     * matching `pg.Client.prototype.escapeLiteral` so we don't need a `pg` dep here.
+     */
+    escapeLiteral(str) {
+        let hasBackslash = false;
+        let escaped = `'`;
+        for (let i = 0; i < str.length; i++) {
+            const c = str[i];
+            if (c === `'`) {
+                escaped += c + c;
+            }
+            else if (c === '\\') {
+                escaped += c + c;
+                hasBackslash = true;
+            }
+            else {
+                escaped += c;
+            }
+        }
+        escaped += `'`;
+        if (hasBackslash) {
+            escaped = ` E${escaped}`;
+        }
+        return escaped;
+    }
     getVarcharTypeDeclarationSQL(column) {
         if (column.length === -1) {
             return 'varchar';

package/dialects/postgresql/index.d.ts

@@ -1,4 +1,6 @@
 export * from './PostgreSqlNativeQueryBuilder.js';
 export * from './BasePostgreSqlPlatform.js';
+export * from './BasePostgreSqlEntityManager.js';
 export * from './FullTextType.js';
 export * from './PostgreSqlSchemaHelper.js';
+export * from './typeOverrides.js';

package/dialects/postgresql/index.js

@@ -1,4 +1,6 @@
 export * from './PostgreSqlNativeQueryBuilder.js';
 export * from './BasePostgreSqlPlatform.js';
+export * from './BasePostgreSqlEntityManager.js';
 export * from './FullTextType.js';
 export * from './PostgreSqlSchemaHelper.js';
+export * from './typeOverrides.js';

package/dialects/postgresql/typeOverrides.d.ts

@@ -0,0 +1,14 @@
+/**
+ * MikroORM keeps PostgreSQL date/timestamp/interval values as raw strings
+ * (and array variants as `string[]`); both `pg` and `pglite` would otherwise
+ * eagerly parse them via `pg-types`. Centralizing the OID list here keeps the
+ * postgres and pglite drivers in lockstep, while leaving the actual array
+ * parsing implementation to the leaf driver (so `@mikro-orm/sql` stays free of
+ * postgres-array / postgres-date / postgres-interval dependencies).
+ *
+ * Use `select typname, oid, typarray from pg_type order by oid` to look up OIDs.
+ */
+type PostgreSqlArrayParser = (value: string) => string[];
+type PostgreSqlValueParser = (value: string) => unknown;
+export declare function createPostgreSqlTypeParsers(arrayParse: PostgreSqlArrayParser): Record<number, PostgreSqlValueParser>;
+export {};

package/dialects/postgresql/typeOverrides.js

@@ -0,0 +1,12 @@
+export function createPostgreSqlTypeParsers(arrayParse) {
+    const parsers = {};
+    for (const oid of [1082, 1114, 1184, 1186]) {
+        // date, timestamp, timestamptz, interval — kept as raw strings
+        parsers[oid] = str => str;
+    }
+    for (const oid of [1182, 1115, 1185, 1187]) {
+        // date[], timestamp[], timestamptz[], interval[]
+        parsers[oid] = arrayParse;
+    }
+    return parsers;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.1.0-dev.30",
+  "version": "7.1.0-dev.32",
   "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.",
   "keywords": [
     "data-mapper",
@@ -47,13 +47,13 @@
     "copy": "node ../../scripts/copy.mjs"
   },
   "dependencies": {
-    "kysely": "0.28.17"
+    "kysely": "0.29.0"
   },
   "devDependencies": {
     "@mikro-orm/core": "^7.0.15"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.1.0-dev.30"
+    "@mikro-orm/core": "7.1.0-dev.32"
   },
   "engines": {
     "node": ">= 22.17.0"

package/query/QueryBuilder.d.ts

@@ -1,4 +1,4 @@
-import { type AnyEntity, type AutoPath, type Collection, type ConnectionType, type Dictionary, type EntityData, type EntityDTOFlat, type EntityDTOProp, type EntityKey, type EntityManager, EntityMetadata, type EntityName, type EntityProperty, type ExpandProperty, type FilterObject, type FilterOptions, type FilterValue, type FlushMode, type GroupOperator, type Loaded, LockMode, type LoggingOptions, type MetadataStorage, type PrimaryProperty, type ObjectQuery, PopulateHint, type PopulateOptions, type PopulatePath, QueryFlag, type QueryOrderKeysFlat, type QueryOrderMap, type QueryResult, RawQueryFragment, type Raw, type RequiredEntityData, type Scalar, type SerializeDTO, type Subquery, type Transaction } from '@mikro-orm/core';
+import { type AbortQueryOptions, type AnyEntity, type AutoPath, type Collection, type ConnectionType, type Dictionary, type EntityData, type EntityDTOFlat, type EntityDTOProp, type EntityKey, type EntityManager, EntityMetadata, type EntityName, type EntityProperty, type ExpandProperty, type FilterObject, type FilterOptions, type FilterValue, type FlushMode, type GroupOperator, type Loaded, LockMode, type LoggingOptions, type MetadataStorage, type PrimaryProperty, type ObjectQuery, PopulateHint, type PopulateOptions, type PopulatePath, QueryFlag, type QueryOrderKeysFlat, type QueryOrderMap, type QueryResult, RawQueryFragment, type Raw, type RequiredEntityData, type Scalar, type SerializeDTO, type Subquery, type Transaction } from '@mikro-orm/core';
 import { JoinType, QueryType } from './enums.js';
 import type { AbstractSqlDriver } from '../AbstractSqlDriver.js';
 import { type Alias, type OnConflictClause, QueryBuilderHelper } from './QueryBuilderHelper.js';
@@ -915,6 +915,11 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
      * Gets logger context for this query builder.
      */
     getLoggerContext<T extends Dictionary & LoggingOptions = Dictionary>(): T;
+    /**
+     * Configures cancellation behavior for this query builder. The signal is forwarded to the
+     * underlying database client; see {@apilink AbortQueryOptions} for the available strategies.
+     */
+    setAbortOptions(options: AbortQueryOptions | undefined): void;
     private fromVirtual;
     /**
      * Adds a join from a property object. Used internally for TPT joins where the property

package/query/QueryBuilder.js

@@ -35,6 +35,7 @@ export class QueryBuilder {
     #state = _a.createDefaultState();
     #helper;
     #query;
+    #abortOptions;
     /** @internal */
     static createDefaultState() {
         return {
@@ -1010,7 +1011,7 @@ export class QueryBuilder {
         if (cached?.data !== undefined) {
             return cached.data;
         }
-        const loggerContext = { id: this.em?.id, ...this.loggerContext };
+        const loggerContext = { id: this.em?.id, ...this.loggerContext, ...this.#abortOptions };
         const res = await this.getConnection().execute(query.sql, query.params, method, this.context, loggerContext);
         const meta = this.mainAlias.meta;
         if (!options.mapResults || !meta) {
@@ -1066,7 +1067,7 @@ export class QueryBuilder {
         options.mapResults ??= true;
         const chunkSize = options.chunkSize ?? 100;
         const query = this.toQuery();
-        const loggerContext = { id: this.em?.id, ...this.loggerContext };
+        const loggerContext = { id: this.em?.id, ...this.loggerContext, ...this.#abortOptions };
         const res = this.getConnection().stream(query.sql, query.params, this.context, loggerContext, chunkSize);
         const meta = this.mainAlias.meta;
         if (options.rawResults || !meta) {
@@ -1290,6 +1291,7 @@ export class QueryBuilder {
         qb.#state.finalized = false;
         qb.#query = undefined;
         qb.#helper = qb.createQueryBuilderHelper();
+        qb.#abortOptions = this.#abortOptions;
         return qb;
     }
     /**
@@ -1305,6 +1307,13 @@ export class QueryBuilder {
         this.loggerContext ??= {};
         return this.loggerContext;
     }
+    /**
+     * Configures cancellation behavior for this query builder. The signal is forwarded to the
+     * underlying database client; see {@apilink AbortQueryOptions} for the available strategies.
+     */
+    setAbortOptions(options) {
+        this.#abortOptions = options;
+    }
     fromVirtual(meta) {
         if (typeof meta.expression === 'string') {
             return `(${meta.expression}) as ${this.platform.quoteIdentifier(this.alias)}`;