uql-orm 0.26.0 → 0.26.2

package/README.md

@@ -9,7 +9,7 @@
 
 <h3>The smartest TypeScript ORM</h3>
 
-<p>Type-safe to the leaf, serializable queries, no codegen, and one API across every SQL database, MongoDB, and every runtime. And the <a href="https://uql-orm.dev/benchmark">fastest</a>.</p>
+<p>Serializable queries, type-safe to the leaf, no codegen, and one API across every SQL database, MongoDB, and every runtime. And the <a href="https://uql-orm.dev/benchmark">fastest</a>.</p>
 
 <p>
   <a href="https://uql-orm.dev"><b>Website</b></a> ·
@@ -50,8 +50,8 @@ from the browser to the server. The same object runs on every supported database
 
 ## Why UQL?
 
+- **Serializable queries (JSON), not method chains.** Plain JSON in, typed rows out. No DSL to learn.
 - **Type-safe to the leaf, nothing to generate.** Every key is checked against your entity, down into populated relations and [JSON/JSONB](https://uql-orm.dev/querying/json) dot-paths, so `$like` on a numeric column is a compile error. Entities are plain classes: no `.prisma` file, no generated client, no build step.
-- **Queries are data (JSON), not method chains.** Plain JSON in, typed rows out. No DSL to learn.
 - **One API, everywhere it runs.** PostgreSQL, CockroachDB, MySQL, MariaDB, SQLite, Turso, libSQL, Neon, Cloudflare D1, Bun's native SQL, and even MongoDB. The same code on Node 24+, Bun, Deno, [Cloudflare Workers](https://uql-orm.dev/cloudflare-d1), [AWS Lambda and Vercel](https://uql-orm.dev/serverless), and [the browser](https://uql-orm.dev/browser), with no native binaries on the `fetch`-based drivers.
 - **Relations without N+1.** [`$populate`](https://uql-orm.dev/querying/relations) loads a to-many with one query for all parents, not one per parent. Nothing is lazy, so nothing fires behind your back in a serializer.
 - **Migrations you read before they run.** Edit an entity, run `uql-migrate generate:entities`, review the SQL in the PR like any other file. [`drift:check`](https://uql-orm.dev/migrations) catches a database that no longer matches.

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/type/entity.d.ts

@@ -314,7 +314,7 @@ export type OnFieldCallback<V = TsTypeOf<FieldType>> = V | QueryRaw | (() => V |
  * `type` allowed. A decorator has it the other way round: `@Field({ type: String })` is checked before
  * the class exists, so the only way to reach the property is to state what `type: String` implies and
  * let the decorator's context position compare it against the real field. Neither can be derived from
- * the other by inference, so `entityOptions.type-test.ts` asserts they agree instead.
+ * the other by inference, so `entityOptions.test-d.ts` asserts they agree instead.
  */
 export type TsTypeOf<T> = T extends StringConstructor ? string : T extends NumberConstructor ? number : T extends BigIntConstructor ? bigint : T extends BooleanConstructor ? boolean : T extends DateConstructor ? Date : T extends StringColumnType ? string : T extends NumericColumnType ? number | bigint : T extends BooleanColumnType ? boolean : T extends DateColumnType ? Date : T extends JsonColumnType ? Json<unknown> | readonly Json<unknown>[] : T extends BlobColumnType ? Uint8Array : T extends VectorColumnType ? readonly number[] : unknown;
 /**

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.0",
+  "version": "0.26.2",
   "type": "module",
   "engines": {
     "node": ">=24"
@@ -127,9 +127,9 @@
   "devDependencies": {
     "@libsql/client": "^0.17.4",
     "@neondatabase/serverless": "^1.1.0",
-    "@nestjs/common": "^11.1.28",
-    "@nestjs/core": "^11.1.28",
-    "@nestjs/testing": "^11.1.28",
+    "@nestjs/common": "^11.1.29",
+    "@nestjs/core": "^11.1.29",
+    "@nestjs/testing": "^11.1.29",
     "@tursodatabase/database": "^0.7.2",
     "@tursodatabase/serverless": "^1.4.0",
     "@types/better-sqlite3": "^9.6.0",
@@ -140,7 +140,7 @@
     "express": "^5.2.1",
     "mariadb": "^3.5.3",
     "mongodb": "^7.5.0",
-    "mysql2": "^3.23.2",
+    "mysql2": "^3.23.3",
     "pg": "^8.23.0",
     "pg-query-stream": "^4.17.0",
     "rxjs": "^7.8.2",