turbine-orm 0.41.0 → 0.42.0

package/dist/prisma-compat.js

@@ -844,14 +844,28 @@ function prismaPropertyAlias(model) {
  */
 function makeDelegate(ctx, mm, getQI) {
     const pe = ctx.options.prismaErrorCodes;
-    const lift = (run, batchable) => new CompatPromise(async () => {
-        try {
-            return await run();
-        }
-        catch (err) {
-            throw decorate(err, pe);
-        }
-    }, batchable);
+    // Build a lazy Prisma-style promise for one delegate call. Crucially, the
+    // Prisma-arg `translate` step runs INSIDE the deferred paths (the run closure
+    // and the batchable build closure), never eagerly at call time: a
+    // translation/validation error (unknown relation in `include`, unknown
+    // compound selector, negative take, ...) must surface as a REJECTED promise
+    // so a Prisma-shaped `.catch()` fires, not as a synchronous throw. The
+    // async run wrapper also converts any synchronous throw from the underlying
+    // `qi.*` build into a rejection; the array `$transaction([...])` batch path
+    // catches the same throw from `batch.build`.
+    const defer = (translate, run, batch) => {
+        const batchable = batch
+            ? { build: () => batch.build(getQI(), translate()), reshape: batch.reshape }
+            : undefined;
+        return new CompatPromise(async () => {
+            try {
+                return await run(getQI(), translate());
+            }
+            catch (err) {
+                throw decorate(err, pe);
+            }
+        }, batchable);
+    };
     const requireWhere = (args, op) => {
         if (!args || args.where === undefined) {
             throw new ValidationError(`[turbine] prisma-compat: ${op} on "${modelName(ctx, mm)}" requires a \`where\`.`);
@@ -859,125 +873,68 @@ function makeDelegate(ctx, mm, getQI) {
         return args;
     };
     return {
-        findMany: (args = {}) => {
-            const t = translateReadArgs(ctx, mm, args);
-            return lift(() => getQI()
-                .findMany(t)
-                .then((r) => reshapeRows(ctx, mm, r)), { build: () => getQI().buildFindMany(t), reshape: (raw) => reshapeRows(ctx, mm, raw) });
-        },
-        findFirst: (args = {}) => {
-            const t = translateReadArgs(ctx, mm, args);
-            return lift(() => getQI()
-                .findFirst(t)
-                .then((r) => reshapeRowOrNull(ctx, mm, r)), { build: () => getQI().buildFindFirst(t), reshape: (raw) => reshapeRowOrNull(ctx, mm, raw) });
-        },
-        findUnique: (args) => {
-            const t = translateReadArgs(ctx, mm, requireWhere(args, 'findUnique'));
-            return lift(() => getQI()
-                .findUnique(t)
-                .then((r) => reshapeRowOrNull(ctx, mm, r)), { build: () => getQI().buildFindUnique(t), reshape: (raw) => reshapeRowOrNull(ctx, mm, raw) });
-        },
-        findFirstOrThrow: (args = {}) => {
-            const t = translateReadArgs(ctx, mm, args);
-            return lift(() => getQI()
-                .findFirstOrThrow(t)
-                .then((r) => reshapeRow(ctx, mm, r)), { build: () => getQI().buildFindFirstOrThrow(t), reshape: (raw) => reshapeRow(ctx, mm, raw) });
-        },
-        findUniqueOrThrow: (args) => {
-            const t = translateReadArgs(ctx, mm, requireWhere(args, 'findUniqueOrThrow'));
-            return lift(() => getQI()
-                .findUniqueOrThrow(t)
-                .then((r) => reshapeRow(ctx, mm, r)), { build: () => getQI().buildFindUniqueOrThrow(t), reshape: (raw) => reshapeRow(ctx, mm, raw) });
-        },
-        create: (args) => {
+        findMany: (args = {}) => defer(() => translateReadArgs(ctx, mm, args), (qi, t) => qi.findMany(t).then((r) => reshapeRows(ctx, mm, r)), { build: (qi, t) => qi.buildFindMany(t), reshape: (raw) => reshapeRows(ctx, mm, raw) }),
+        findFirst: (args = {}) => defer(() => translateReadArgs(ctx, mm, args), (qi, t) => qi.findFirst(t).then((r) => reshapeRowOrNull(ctx, mm, r)), { build: (qi, t) => qi.buildFindFirst(t), reshape: (raw) => reshapeRowOrNull(ctx, mm, raw) }),
+        findUnique: (args) => defer(() => translateReadArgs(ctx, mm, requireWhere(args, 'findUnique')), (qi, t) => qi.findUnique(t).then((r) => reshapeRowOrNull(ctx, mm, r)), { build: (qi, t) => qi.buildFindUnique(t), reshape: (raw) => reshapeRowOrNull(ctx, mm, raw) }),
+        findFirstOrThrow: (args = {}) => defer(() => translateReadArgs(ctx, mm, args), (qi, t) => qi.findFirstOrThrow(t).then((r) => reshapeRow(ctx, mm, r)), { build: (qi, t) => qi.buildFindFirstOrThrow(t), reshape: (raw) => reshapeRow(ctx, mm, raw) }),
+        findUniqueOrThrow: (args) => defer(() => translateReadArgs(ctx, mm, requireWhere(args, 'findUniqueOrThrow')), (qi, t) => qi.findUniqueOrThrow(t).then((r) => reshapeRow(ctx, mm, r)), { build: (qi, t) => qi.buildFindUniqueOrThrow(t), reshape: (raw) => reshapeRow(ctx, mm, raw) }),
+        create: (args) => defer(() => {
             const t = { data: translateWriteData(ctx, mm, args.data) };
             if (typeof args.timeout === 'number')
                 t.timeout = args.timeout;
-            return lift(() => getQI()
-                .create(t)
-                .then((r) => reshapeRow(ctx, mm, r)), { build: () => getQI().buildCreate(t), reshape: (raw) => reshapeRow(ctx, mm, raw) });
-        },
-        createMany: (args) => {
+            return t;
+        }, (qi, t) => qi.create(t).then((r) => reshapeRow(ctx, mm, r)), { build: (qi, t) => qi.buildCreate(t), reshape: (raw) => reshapeRow(ctx, mm, raw) }),
+        createMany: (args) => defer(() => {
             const data = args.data;
             const rows = Array.isArray(data) ? data.map((d) => translateWriteData(ctx, mm, d)) : [];
             const t = { data: rows };
             if (args.skipDuplicates)
                 t.skipDuplicates = true;
-            return lift(() => getQI()
-                .createMany(t)
-                .then((r) => ({ count: r.length })), { build: () => getQI().buildCreateMany(t), reshape: (raw) => ({ count: raw.length }) });
-        },
-        update: (args) => {
+            return t;
+        }, (qi, t) => qi.createMany(t).then((r) => ({ count: r.length })), { build: (qi, t) => qi.buildCreateMany(t), reshape: (raw) => ({ count: raw.length }) }),
+        update: (args) => defer(() => {
             const a = requireWhere(args, 'update');
-            const t = { where: translateWhere(ctx, mm, a.where), data: translateWriteData(ctx, mm, a.data) };
-            return lift(() => getQI()
-                .update(t)
-                .then((r) => reshapeRow(ctx, mm, r)), { build: () => getQI().buildUpdate(t), reshape: (raw) => reshapeRow(ctx, mm, raw) });
-        },
-        updateMany: (args) => {
+            return { where: translateWhere(ctx, mm, a.where), data: translateWriteData(ctx, mm, a.data) };
+        }, (qi, t) => qi.update(t).then((r) => reshapeRow(ctx, mm, r)), { build: (qi, t) => qi.buildUpdate(t), reshape: (raw) => reshapeRow(ctx, mm, raw) }),
+        updateMany: (args) => defer(() => {
             const a = args;
             const t = { where: translateWhere(ctx, mm, a.where ?? {}), data: translateWriteData(ctx, mm, a.data) };
             if (a.where === undefined)
                 t.allowFullTableScan = true;
-            return lift(() => getQI().updateMany(t), {
-                build: () => getQI().buildUpdateMany(t),
-                reshape: (raw) => raw,
-            });
-        },
-        delete: (args) => {
+            return t;
+        }, (qi, t) => qi.updateMany(t), { build: (qi, t) => qi.buildUpdateMany(t), reshape: (raw) => raw }),
+        delete: (args) => defer(() => {
             const a = requireWhere(args, 'delete');
-            const t = { where: translateWhere(ctx, mm, a.where) };
-            return lift(() => getQI()
-                .delete(t)
-                .then((r) => reshapeRow(ctx, mm, r)), { build: () => getQI().buildDelete(t), reshape: (raw) => reshapeRow(ctx, mm, raw) });
-        },
-        deleteMany: (args = {}) => {
+            return { where: translateWhere(ctx, mm, a.where) };
+        }, (qi, t) => qi.delete(t).then((r) => reshapeRow(ctx, mm, r)), { build: (qi, t) => qi.buildDelete(t), reshape: (raw) => reshapeRow(ctx, mm, raw) }),
+        deleteMany: (args = {}) => defer(() => {
             const a = args;
             const t = { where: translateWhere(ctx, mm, a.where ?? {}) };
             if (a.where === undefined)
                 t.allowFullTableScan = true;
-            return lift(() => getQI().deleteMany(t), {
-                build: () => getQI().buildDeleteMany(t),
-                reshape: (raw) => raw,
-            });
-        },
-        upsert: (args) => {
+            return t;
+        }, (qi, t) => qi.deleteMany(t), { build: (qi, t) => qi.buildDeleteMany(t), reshape: (raw) => raw }),
+        upsert: (args) => defer(() => {
             const a = requireWhere(args, 'upsert');
-            const t = {
+            return {
                 where: translateWhere(ctx, mm, a.where),
                 create: translateWriteData(ctx, mm, a.create),
                 update: translateWriteData(ctx, mm, a.update),
             };
-            return lift(() => getQI()
-                .upsert(t)
-                .then((r) => reshapeRow(ctx, mm, r)), { build: () => getQI().buildUpsert(t), reshape: (raw) => reshapeRow(ctx, mm, raw) });
-        },
-        count: (args = {}) => {
+        }, (qi, t) => qi.upsert(t).then((r) => reshapeRow(ctx, mm, r)), { build: (qi, t) => qi.buildUpsert(t), reshape: (raw) => reshapeRow(ctx, mm, raw) }),
+        count: (args = {}) => defer(() => {
             const t = {};
             if (args.where !== undefined)
                 t.where = translateWhere(ctx, mm, args.where);
             if (typeof args.timeout === 'number')
                 t.timeout = args.timeout;
-            return lift(() => getQI().count(t), {
-                build: () => getQI().buildCount(t),
-                reshape: (raw) => raw,
-            });
-        },
-        aggregate: (args) => {
-            const t = translateAggregateArgs(ctx, mm, args, false);
-            return lift(() => getQI()
-                .aggregate(t)
-                .then((r) => reshapeAggregate(ctx, mm, r)), { build: () => getQI().buildAggregate(t), reshape: (raw) => reshapeAggregate(ctx, mm, raw) });
-        },
-        groupBy: (args) => {
-            const t = translateAggregateArgs(ctx, mm, args, true);
-            return lift(() => getQI()
-                .groupBy(t)
-                .then((rows) => rows.map((r) => reshapeGroupRow(ctx, mm, r))), {
-                build: () => getQI().buildGroupBy(t),
-                reshape: (raw) => raw.map((r) => reshapeGroupRow(ctx, mm, r)),
-            });
-        },
+            return t;
+        }, (qi, t) => qi.count(t), { build: (qi, t) => qi.buildCount(t), reshape: (raw) => raw }),
+        aggregate: (args) => defer(() => translateAggregateArgs(ctx, mm, args, false), (qi, t) => qi.aggregate(t).then((r) => reshapeAggregate(ctx, mm, r)), { build: (qi, t) => qi.buildAggregate(t), reshape: (raw) => reshapeAggregate(ctx, mm, raw) }),
+        groupBy: (args) => defer(() => translateAggregateArgs(ctx, mm, args, true), (qi, t) => qi.groupBy(t).then((rows) => rows.map((r) => reshapeGroupRow(ctx, mm, r))), {
+            build: (qi, t) => qi.buildGroupBy(t),
+            reshape: (raw) => raw.map((r) => reshapeGroupRow(ctx, mm, r)),
+        }),
     };
 }
 function poolOf(db) {

package/dist/query/compound-unique.d.ts

@@ -18,10 +18,12 @@
  *   1. a composite primary key (length ≥ 2);
  *   2. each composite `uniqueColumns` entry (introspected composite UNIQUE
  *      constraints);
- *   3. each composite UNIQUE index in `indexes` (`unique && !docPath`, the ONLY
- *      composite-unique source a `defineSchema` code-first client has, since
- *      `defineSchema` records single-column uniques in `uniqueColumns` and
- *      composite uniques as declared unique indexes).
+ *   3. each composite UNIQUE index in `indexes` (`unique && !docPath &&
+ *      !partial`, the ONLY composite-unique source a `defineSchema` code-first
+ *      client has, since `defineSchema` records single-column uniques in
+ *      `uniqueColumns` and composite uniques as declared unique indexes). A
+ *      PARTIAL unique index is skipped: it only guarantees uniqueness over its
+ *      predicate's rows, not table-wide, so it cannot address a single row.
  *
  * For every column set two lookup names are registered (both mapping to the same
  * ordered FIELD list): the underscore join of the camelCase FIELD names

package/dist/schema.d.ts

@@ -180,6 +180,16 @@ export interface IndexMetadata {
     columns: string[];
     unique: boolean;
     definition: string;
+    /**
+     * True when the index carries a top-level `WHERE` predicate (a Postgres
+     * PARTIAL index). A partial UNIQUE index only guarantees uniqueness over the
+     * rows matching its predicate, NOT over the whole table, so it must be
+     * EXCLUDED from compound-unique selector derivation (both the runtime
+     * `where` expansion and the generated `*WhereUnique` selector branches):
+     * addressing a row by it could match zero or many rows. Introspection sets
+     * it from the `indexdef`; absent / `false` means a full (table-wide) index.
+     */
+    partial?: boolean;
     /**
      * Set only for a PowDB doc-field expression index: the JSON path (string keys
      * and integer array indexes) into the single json document column named by

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "turbine-orm",
-  "version": "0.41.0",
+  "version": "0.42.0",
   "description": "Postgres-native TypeScript ORM — runs on Neon, Vercel Postgres, Cloudflare, Supabase. Streaming cursors, typed errors, single-query nested relations. One dependency, no WASM engine",
   "type": "module",
   "exports": {