uql-orm 0.26.1 → 0.26.3

package/README.md

@@ -58,7 +58,7 @@ from the browser to the server. The same object runs on every supported database
 - **Raw SQL when you want it.** [`raw()`](https://uql-orm.dev/querying/raw-sql) fits anywhere in a query, [virtual fields](https://uql-orm.dev/entities/virtual-fields) are sub-queries you can filter on, and a migration can be plain SQL.
 - **Light.** Zero runtime dependencies, 305 kB on the wire, every dialect included. See [what we deleted to get there](https://uql-orm.dev/blog/zero-dependencies).
 - **The hard things are built in.** [Semantic and vector search](https://uql-orm.dev/ai-semantic-search), [multi-tenant filters you cannot bypass by accident](https://uql-orm.dev/multi-tenancy), [soft-delete with restore](https://uql-orm.dev/entities/soft-delete), [streaming](https://uql-orm.dev/querying/streaming), and [a REST API from your entities](https://uql-orm.dev/http).
-- **The fastest ORM.** On a full PostgreSQL round trip it adds the least over hand-written driver code of any ORM in our open-source [benchmark](https://github.com/rogerpadilla/ts-orm-benchmark): 278µs, against 621µs for the next closest and 1,889µs for the slowest.
+- **The fastest ORM.** On a full PostgreSQL round trip it adds the least over hand-written driver code of any ORM in our open-source [benchmark](https://github.com/rogerpadilla/ts-orm-benchmark): 239µs, against 812µs for the next closest and 2,286µs for the slowest.
 
 ## Get started
 

package/dist/querier/abstractSqlQuerier.js

@@ -1,6 +1,6 @@
 import { decodeColumn } from '../dialect/hydrateColumn.js';
 import { getMeta } from '../entity/index.js';
-import { buildUpdateResult, clone, getInsertFieldKeys, getRelationRequestSummary, isAutoIncrement, obtainAttrsPaths, throwNoPendingTransaction, throwPendingTransaction, unflatObject, unflatObjects, withoutSoftDeleteFilter, } from '../util/index.js';
+import { buildUpdateResult, cascadesOnDelete, clone, getInsertFieldKeys, getRelationRequestSummary, isAutoIncrement, obtainAttrsPaths, throwNoPendingTransaction, throwPendingTransaction, unflatObject, unflatObjects, withoutSoftDeleteFilter, } from '../util/index.js';
 import { AbstractQuerier } from './abstractQuerier.js';
 import { enrichError } from './queryError.js';
 export class AbstractSqlQuerier extends AbstractQuerier {
@@ -222,6 +222,17 @@ export class AbstractSqlQuerier extends AbstractQuerier {
     }
     async internalDeleteMany(entity, q, opts) {
         const meta = getMeta(entity);
+        // Resolving the ids first is what makes the two hard cases work at all: a cascade needs its
+        // parents' ids to find their children, and no engine but MySQL accepts `ORDER BY`/`LIMIT` on a
+        // DELETE, so a paged delete has to name the rows it settled on. A plain predicate needs neither,
+        // and there the round trip buys nothing: the statement can say what the caller already said.
+        const hasPagination = q.$sort !== undefined || q.$limit !== undefined || q.$skip !== undefined;
+        if (!hasPagination && !cascadesOnDelete(meta)) {
+            const ctx = this.dialect.createContext();
+            this.dialect.delete(ctx, entity, q, opts);
+            const { changes = 0 } = await this.run(ctx.sql, ctx.values);
+            return changes;
+        }
         // A hard delete also targets already-soft-deleted rows, so drop the soft-delete filter when finding ids.
         const findOpts = opts?.hardDelete ? { ...opts, filters: withoutSoftDeleteFilter(opts.filters) } : opts;
         const findCtx = this.dialect.createContext();

package/dist/util/dialect.util.d.ts

@@ -35,6 +35,11 @@ export declare function fillOnFields<E>(meta: EntityMeta<E>, payload: E | E[], c
  * or `meta.relations` itself to enumerate every cascadable relation).
  */
 export declare function filterPersistableRelationKeys<E>(meta: EntityMeta<E>, payload: object, action: CascadeType): RelationKey<E>[];
+/**
+ * Whether deleting this entity has to delete anything else, which is the reason a delete resolves the
+ * matching ids before issuing anything: a child is reached through the ids of its parent.
+ */
+export declare function cascadesOnDelete<E>(meta: EntityMeta<E>): boolean;
 export declare function isCascadable(action: CascadeType, configuration?: boolean | CascadeType): boolean;
 /**
  * The map form of a `$select` value, or `undefined` for the raw-array form. Centralizes the one

package/dist/util/dialect.util.js

@@ -83,6 +83,13 @@ export function filterPersistableRelationKeys(meta, payload, action) {
         return relOpts && isCascadable(action, relOpts.cascade);
     });
 }
+/**
+ * Whether deleting this entity has to delete anything else, which is the reason a delete resolves the
+ * matching ids before issuing anything: a child is reached through the ids of its parent.
+ */
+export function cascadesOnDelete(meta) {
+    return filterPersistableRelationKeys(meta, meta.relations, 'delete').length > 0;
+}
 export function isCascadable(action, configuration) {
     if (typeof configuration === 'boolean') {
         return configuration;

package/package.json

@@ -3,7 +3,7 @@
   "homepage": "https://uql-orm.dev",
   "description": "Extremely fast, type-safe TypeScript ORM - one API for every database",
   "license": "MIT",
-  "version": "0.26.1",
+  "version": "0.26.3",
   "type": "module",
   "engines": {
     "node": ">=24"