@rowstile/prisma 0.1.0-alpha.6 → 0.1.0-alpha.7

package/README.md

@@ -47,7 +47,8 @@ and a query by permission is one call:
 
 - Use the client `$extends(authz())` returns, and only that one.
 - `$transaction([...])` is refused: Prisma starts an array's transaction from whichever request came first.
-  Use `$transaction(async (tx) => ...)`.
+  Use `$transaction(async (tx) => ...)`. Inside it, why a write was refused is asked through the transaction:
+  it needs no second connection.
 - A `create` reads its row back, so it needs the select rule too. A refusal there is `Refused` naming it.
 - Policy changes ship as Prisma migrations: `tool = "prisma"` in `rowstile.toml`, then `npx rowstile migrate`.
 

package/dist/index.js

@@ -112,8 +112,11 @@ export function signedIn(factory, options = {}) {
 async function transactionOf(tx) {
     let found;
     const make = tx._createPrismaPromise;
+    // (the two guards are for another version of Prisma than the one the checks run: left out of the measure)
+    /* v8 ignore else */
     if (typeof make === "function")
         await make(async (t) => { found = t; });
+    /* v8 ignore next */
     if (found?.kind !== "itx") {
         throw new Error("@rowstile/prisma: this version of Prisma starts its transactions another way; " +
             "report it at https://github.com/rowstile/rowstile/issues with the version of @prisma/client");
@@ -124,10 +127,13 @@ async function transactionOf(tx) {
 export function authz(options = {}) {
     return Prisma.defineExtension((client) => {
         const raw = client;
+        // (Prisma 7 always has the data model: without it, another version, left out of the measure)
+        /* v8 ignore next */
         const models = raw._runtimeDataModel?.models ?? {};
+        // the schema of a table the database's words name without one: a model's table is its @@map, else its name
         const schemaOf = (table) => {
-            for (const m of Object.values(models))
-                if (m.dbName === table && m.schema)
+            for (const [name, m] of Object.entries(models))
+                if ((m.dbName ?? name) === table && m.schema)
                     return m.schema;
             return undefined;
         };
@@ -136,11 +142,10 @@ export function authz(options = {}) {
             const name = m?.dbName ?? model;
             return m?.schema ? `${m.schema}.${name}` : name;
         };
-        // the row's key (the policy's key for the table) from the where of an update or delete: the fields
-        // options.keys names for the model, else id, else its one unique field or compound key
+        // the row's key (the policy's key for the table) from the where of an update, a delete or a findUnique: the
+        // fields options.keys names for the model, else id, else its one unique field or compound key (Prisma refuses
+        // any of them without a where before a query)
         const keyOf = (model, where) => {
-            if (!where)
-                return undefined;
             const named = options.keys?.[model];
             if (named) {
                 const vals = named.map((k) => where[k]);
@@ -161,8 +166,11 @@ export function authz(options = {}) {
             const [, v] = entries[0];
             if (isScalar(v))
                 return v;
-            if (v && typeof v === "object" && Object.values(v).every(isScalar))
+            // a compound key's fields, in a plain object: not a date (or bytes, a decimal), which isn't written as the
+            // database writes it
+            if (v && typeof v === "object" && Object.getPrototypeOf(v) === Object.prototype && Object.values(v).every(isScalar)) {
                 return Object.values(v);
+            }
             return undefined;
         };
         // through the client this returns (set below), whose last hook lets the query through
@@ -171,6 +179,15 @@ export function authz(options = {}) {
             query: async (text, values = []) => ({ rows: await self.$queryRawUnsafe(text, ...values) }),
         };
         const c = calls(q);
+        // The runtime's functions asked inside the app's interactive transaction, for a call made in one: an update or a
+        // read that found no row leaves it usable, and a question outside it would wait for a connection of its own,
+        // which on a pool of one the transaction holds until Prisma's timeout. A Prisma promise runs in the transaction
+        // it is handed (requestTransaction: how Prisma runs an array's queries in theirs).
+        const askingIn = (transaction) => transaction?.kind !== "itx" ? c : calls({
+            query: async (text, values = []) => ({
+                rows: await self.$queryRawUnsafe(text, ...values).requestTransaction(transaction),
+            }),
+        });
         const $authz = {
             ...c,
             ids: async (type, perm, as) => {
@@ -204,7 +221,7 @@ export function authz(options = {}) {
                             const table = tableOf(model);
                             const key = keyOf(model, args.where);
                             if (key !== undefined) {
-                                const v = await c.verdict(table, operation, key).catch(() => undefined);
+                                const v = await askingIn(internal?.transaction).verdict(table, operation, key).catch(() => undefined);
                                 if (v !== undefined) {
                                     v.cause = e;
                                     throw v;
@@ -212,10 +229,14 @@ export function authz(options = {}) {
                             }
                         }
                         // a read that must find a row and found none: the row isn't there, or this user can't see it (the
-                        // two answer alike). Left as Prisma's P2025 it is a 500, where an update or a delete is a 404
+                        // two answer alike). Left as Prisma's P2025 it is a 500, where an update or a delete is a 404.
+                        // findUnique's where is a key; findFirst's is any filter, which names a row only by its id
                         if (model && isP2025(e) && (operation === "findUniqueOrThrow" || operation === "findFirstOrThrow")) {
-                            const key = keyOf(model, args.where);
-                            throw new NotFound(tableOf(model), key === undefined ? undefined : idShown(key), { cause: e });
+                            const where = args.where;
+                            const key = operation === "findUniqueOrThrow" ? keyOf(model, where)
+                                : isScalar(where?.id) ? where?.id : undefined;
+                            const table = await askingIn(internal?.transaction).tableName(tableOf(model)).catch(() => tableOf(model));
+                            throw new NotFound(table, key === undefined ? undefined : idShown(key), { cause: e });
                         }
                         throw translate(e, schemaOf) ?? e;
                     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rowstile/prisma",
-  "version": "0.1.0-alpha.6",
+  "version": "0.1.0-alpha.7",
   "description": "rowstile with Prisma: a client extension that signs every query in, and turns refusals into errors",
   "license": "Apache-2.0",
   "homepage": "https://rowstile.dev",
@@ -12,6 +12,6 @@
   "exports": { ".": { "types": "./dist/index.d.ts", "default": "./dist/index.js" } },
   "files": ["dist"],
   "sideEffects": false,
-  "dependencies": { "@rowstile/client": "0.1.0-alpha.6" },
+  "dependencies": { "@rowstile/client": "0.1.0-alpha.7" },
   "peerDependencies": { "@prisma/client": ">=7" }
 }