turbine-orm 0.81.0 → 0.90.0

package/dist/cli/observe.js

@@ -5,10 +5,12 @@
  * _turbine_metrics. Same security model as Studio: loopback binding,
  * random token, HttpOnly cookie, CSP headers, read-only transactions.
  */
-import { createHash, randomBytes, timingSafeEqual } from 'node:crypto';
+import { randomBytes } from 'node:crypto';
 import { createServer } from 'node:http';
 import pg from 'pg';
 import { absorbCheckedOutErrors } from '../connection-guard.js';
+import { constantTimeEqual, createTicketGate, isAllowedHostHeader, redeemTicket, } from './local-server-guard.js';
+import { openInBrowser, responseErrorText } from './local-server-output.js';
 import { OBSERVE_HTML } from './observe-ui.js';
 import { callerKey, checkRateLimit } from './rate-limit.js';
 import { redactUrl } from './ui.js';
@@ -27,31 +29,41 @@ export async function startObserve(options) {
         console.error(`[turbine] observe pool error: ${redactUrl(err.message)}`);
     });
     absorbCheckedOutErrors(pool);
-    const probe = await pool.connect();
-    try {
-        await probe.query('SELECT 1');
-    }
-    finally {
-        probe.release();
-    }
     const authToken = randomBytes(24).toString('hex');
+    const ticketGate = createTicketGate();
     const rateLimiter = new Map();
     const server = createServer((req, res) => {
-        handleRequest(req, res, pool, options, authToken, rateLimiter).catch((err) => {
-            sendJson(res, 500, { error: err instanceof Error ? err.message : String(err) });
+        handleRequest(req, res, pool, options, authToken, rateLimiter, ticketGate).catch((err) => {
+            sendJson(res, 500, { error: responseErrorText(err) });
         });
     });
-    await new Promise((resolve, reject) => {
-        server.once('error', reject);
-        server.listen(options.port, options.host, () => {
-            server.off('error', reject);
-            resolve();
+    try {
+        const probe = await pool.connect();
+        try {
+            await probe.query('SELECT 1');
+        }
+        finally {
+            probe.release();
+        }
+        await new Promise((resolve, reject) => {
+            server.once('error', reject);
+            server.listen(options.port, options.host, () => {
+                server.off('error', reject);
+                resolve();
+            });
         });
-    });
+    }
+    catch (err) {
+        // A start that fails (probe refused, port taken) must not leave the probe
+        // connection idling in a pool nobody holds: it would keep a database session
+        // open and the process alive until the idle timeout.
+        await pool.end().catch(() => { });
+        throw err;
+    }
     const hostPart = options.host.includes(':') && !options.host.startsWith('[') ? `[${options.host}]` : options.host;
-    const url = `http://${hostPart}:${options.port}/?token=${authToken}`;
+    const url = `http://${hostPart}:${options.port}/?token=${ticketGate.token}`;
     if (options.openBrowser) {
-        openUrl(url);
+        openInBrowser(url);
     }
     return {
         authToken,
@@ -65,15 +77,31 @@ export async function startObserve(options) {
 // ---------------------------------------------------------------------------
 // Request routing
 // ---------------------------------------------------------------------------
-export async function handleRequest(req, res, pool, options, authToken, rateLimiter) {
+export async function handleRequest(req, res, pool, options, authToken, rateLimiter, 
+/** The one-time login ticket. Absent on a hand-built call: the ticket is then `authToken` itself. */
+ticketGate = gateFor(authToken)) {
     const hostPart = options.host.includes(':') && !options.host.startsWith('[') ? `[${options.host}]` : options.host;
     const expectedOrigin = `http://${hostPart}:${options.port}`;
+    // DNS rebinding: a page on another domain that re-resolves to this port still
+    // sends its own hostname in `Host`. Checked before any route or token logic.
+    if (!isAllowedHostHeader(req.headers.host, options.host, options.port)) {
+        sendJson(res, 403, { error: 'host not allowed: open Observe at the address printed in the terminal' });
+        return;
+    }
     const origin = req.headers.origin;
     if (origin && origin !== expectedOrigin) {
         sendJson(res, 403, { error: 'cross-origin requests not allowed' });
         return;
     }
-    const url = new URL(req.url ?? '/', expectedOrigin);
+    // A request target that is not a URL (`GET //`) is a client error, not a 500.
+    let url;
+    try {
+        url = new URL(req.url ?? '/', expectedOrigin);
+    }
+    catch {
+        sendJson(res, 400, { error: 'malformed request target' });
+        return;
+    }
     const pathname = url.pathname;
     if (pathname === '/' || pathname === '/index.html') {
         if (req.method !== 'GET' && req.method !== 'HEAD') {
@@ -81,13 +109,28 @@ export async function handleRequest(req, res, pool, options, authToken, rateLimi
             return;
         }
         const queryToken = url.searchParams.get('token');
-        if (queryToken && constantTimeEqual(queryToken, authToken)) {
-            res.writeHead(302, {
-                Location: '/',
-                'Set-Cookie': `turbine_observe_token=${authToken}; Path=/; HttpOnly; SameSite=Strict`,
-            });
-            res.end();
-            return;
+        if (queryToken) {
+            // The printed URL's token is a ONE-TIME ticket, exchanged here for the
+            // session cookie by the first GET that carries it. HEAD never spends it.
+            const outcome = req.method === 'GET' ? redeemTicket(ticketGate, queryToken) : 'invalid';
+            if (outcome === 'granted') {
+                res.writeHead(302, {
+                    Location: '/',
+                    'Set-Cookie': `turbine_observe_token=${authToken}; Path=/; HttpOnly; SameSite=Strict`,
+                });
+                res.end();
+                return;
+            }
+            if (outcome === 'used') {
+                if (isAuthorized(req, authToken)) {
+                    res.writeHead(302, { Location: '/' });
+                    res.end();
+                }
+                else {
+                    sendText(res, 403, 'This login link was already used. Restart Observe to get a new one.');
+                }
+                return;
+            }
         }
         sendHtml(res, 200, OBSERVE_HTML, cspNonce());
         return;
@@ -133,13 +176,18 @@ function isAuthorized(req, expectedToken) {
     }
     return false;
 }
-function constantTimeEqual(a, b) {
-    // Hash both inputs to fixed-length 32-byte SHA-256 digests before comparing.
-    // This makes the comparison constant-length (timingSafeEqual never throws on a
-    // length mismatch) and leaks neither length nor content via timing.
-    const ah = createHash('sha256').update(a).digest();
-    const bh = createHash('sha256').update(b).digest();
-    return timingSafeEqual(ah, bh);
+/**
+ * The ticket for a caller that passed none (a hand-built dispatch): `authToken`
+ * itself, remembered per token so it is still spent exactly once.
+ */
+const FALLBACK_GATES = new Map();
+function gateFor(authToken) {
+    let gate = FALLBACK_GATES.get(authToken);
+    if (!gate) {
+        gate = createTicketGate(authToken);
+        FALLBACK_GATES.set(authToken, gate);
+    }
+    return gate;
 }
 // ---------------------------------------------------------------------------
 // API handlers
@@ -188,7 +236,7 @@ async function apiLatency(res, pool, params) {
             // this server writes no log of its own, so the HTTP response is the only
             // channel either error could reach. Same shape as cli/studio.ts.
         }
-        sendJson(res, 500, { error: err instanceof Error ? err.message : String(err) });
+        sendJson(res, 500, { error: responseErrorText(err) });
     }
     finally {
         client.release();
@@ -229,7 +277,7 @@ async function apiModels(res, pool, params) {
             // this server writes no log of its own, so the HTTP response is the only
             // channel either error could reach. Same shape as cli/studio.ts.
         }
-        sendJson(res, 500, { error: err instanceof Error ? err.message : String(err) });
+        sendJson(res, 500, { error: responseErrorText(err) });
     }
     finally {
         client.release();
@@ -277,21 +325,3 @@ function sendText(res, status, text) {
     res.writeHead(status, { ...SECURITY_HEADERS, 'Content-Security-Policy': JSON_CSP, 'Content-Type': 'text/plain' });
     res.end(text);
 }
-// ---------------------------------------------------------------------------
-// Browser open
-// ---------------------------------------------------------------------------
-function openUrl(url) {
-    const { platform: os } = process;
-    const { spawn } = require('node:child_process');
-    try {
-        if (os === 'darwin')
-            spawn('open', [url], { stdio: 'ignore', detached: true }).unref();
-        else if (os === 'win32')
-            spawn('cmd', ['/c', 'start', '', url], { stdio: 'ignore', detached: true }).unref();
-        else
-            spawn('xdg-open', [url], { stdio: 'ignore', detached: true }).unref();
-    }
-    catch {
-        // Best effort
-    }
-}

package/dist/cli/pii-predicate-guard.d.ts

@@ -62,32 +62,15 @@
  *     name-carrying position that is not a string is refused as a SHAPE here,
  *     never skipped: skipping is the branch that leaks.
  */
+import { RELATION_FILTER_WRAPPERS } from '../query/filters.js';
 import type { SchemaMetadata, TableMetadata } from '../schema.js';
 /**
- * Relation-filter wrappers whose body is a clause against the relation's target.
- *
- * THREE copies of this list exist in the tree, and they have to agree: a wrapper
- * the compiler understands and this guard does not is a wrapper that reaches the
- * builder unguarded.
- *
- *   1. this one, the only NAMED definition;
- *   2. `query/where-compile.ts`, inlined as `'some' in x || 'every' in x || …`;
- *   3. `prisma-compat.ts`, SPLIT across `RELATION_QUANTIFIERS`
- *      (`some`/`every`/`none`) and two inline `k === 'is' || k === 'isNot'`
- *      tests, which is the copy most likely to drift because half of it does
- *      not look like a list at all.
- *
- * Copy 2 belongs to the SQL compiler and cannot import this one (a query-path
- * module must not depend on `cli/`), so the deduplication has to go the other
- * way: the list wants to live in `query/filters.ts` and be imported here, the
- * way {@link COLUMN_REF_OPERATORS} above now is.
- *
- * That destination now EXISTS (`RELATION_FILTER_WRAPPERS` in `query/filters.ts`)
- * and nothing imports it, including this file, so it is a fourth copy rather
- * than a deduplication and this comment is still the only thing holding them in
- * step. Moving each walk onto it is a change per walk, each with its own tests.
+ * Relation-filter wrappers whose body is a clause against the relation's target:
+ * the SQL compiler's own list (`query/filters.ts`), imported so a wrapper the
+ * compiler understands can never reach the builder unguarded. Re-exported for
+ * callers that still import it from here.
  */
-export declare const RELATION_FILTER_WRAPPERS: readonly ["some", "none", "every", "is", "isNot"];
+export { RELATION_FILTER_WRAPPERS };
 /**
  * Recursion bound for the guard walk.
  *
@@ -101,6 +84,43 @@ export declare const RELATION_FILTER_WRAPPERS: readonly ["some", "none", "every"
  * nothing the builder would accept is refused here for depth alone.
  */
 export declare const PII_GUARD_MAX_DEPTH = 32;
+/**
+ * Find a `lock` option anywhere a query level can carry one: the args
+ * themselves, or the options of any `with` entry at any depth. Returns the
+ * dotted path to the shallowest hit (`lock`, `with.posts.lock`), or `null`.
+ *
+ * WHY THIS IS NOT PART OF {@link assertNoPiiPredicates}. A locking read is not
+ * a hidden-column question, and the PII walk is conditional by design: Studio
+ * skips it under `--show-pii`, `explain_query` hands it an allowlisted subset
+ * of its arguments, and `compile_query` hands it only `where` for an aggregate.
+ * A read-only refusal has to hold in every one of those, so each surface calls
+ * this directly and unconditionally. It lives in this module because both
+ * surfaces already import it, which is what keeps the rule and its wording in
+ * one place.
+ *
+ * ANY VALUE other than `undefined` counts, `null` and `false` included. The
+ * builder treats exactly `undefined` as "no lock" and refuses every other
+ * non-lock value itself (E003), so answering "present" for all of them means
+ * the verdict here never depends on what the builder would have made of it.
+ *
+ * A `with` MAP is keyed by relation names, so a relation that happens to be
+ * called `lock` is a level to descend into and never a hit; only the option
+ * position on a level is read. A table column called `lock` is likewise safe:
+ * columns live under `where` / `orderBy` / `select`, which are not searched.
+ *
+ * Iterative and breadth-first, so a deeply nested payload costs time and no
+ * stack, and the shallowest hit is the one reported. The visited set makes it
+ * terminate on a cyclic object, which parsed JSON cannot produce but a caller
+ * of a pure helper can.
+ */
+export declare function findRowLockOption(args: Record<string, unknown>): string | null;
+/**
+ * The refusal text for a `lock` found by {@link findRowLockOption}, shared so
+ * the two surfaces cannot word the same rule two ways. `path` is interpolated
+ * as given: it can carry a caller-chosen relation name, so each surface passes
+ * it through its own printable-name escaping first.
+ */
+export declare function rowLockRefusalMessage(path: string, tool: string): string;
 /**
  * The two things Studio and the MCP server genuinely do differently, plus the
  * schema the walk resolves relation targets against.

package/dist/cli/pii-predicate-guard.js

@@ -62,34 +62,16 @@
  *     name-carrying position that is not a string is refused as a SHAPE here,
  *     never skipped: skipping is the branch that leaks.
  */
-import { COLUMN_REF_OPERATORS } from '../query/filters.js';
+import { isPlainColumnRefShape } from '../query/column-ref.js';
+import { COLUMN_REF_OPERATORS, isColumnRef, RELATION_FILTER_WRAPPER_SET, RELATION_FILTER_WRAPPERS, } from '../query/filters.js';
 import { ownLookup, resolveColumnName, resolveRelation } from '../query/utils.js';
 /**
- * Relation-filter wrappers whose body is a clause against the relation's target.
- *
- * THREE copies of this list exist in the tree, and they have to agree: a wrapper
- * the compiler understands and this guard does not is a wrapper that reaches the
- * builder unguarded.
- *
- *   1. this one, the only NAMED definition;
- *   2. `query/where-compile.ts`, inlined as `'some' in x || 'every' in x || …`;
- *   3. `prisma-compat.ts`, SPLIT across `RELATION_QUANTIFIERS`
- *      (`some`/`every`/`none`) and two inline `k === 'is' || k === 'isNot'`
- *      tests, which is the copy most likely to drift because half of it does
- *      not look like a list at all.
- *
- * Copy 2 belongs to the SQL compiler and cannot import this one (a query-path
- * module must not depend on `cli/`), so the deduplication has to go the other
- * way: the list wants to live in `query/filters.ts` and be imported here, the
- * way {@link COLUMN_REF_OPERATORS} above now is.
- *
- * That destination now EXISTS (`RELATION_FILTER_WRAPPERS` in `query/filters.ts`)
- * and nothing imports it, including this file, so it is a fourth copy rather
- * than a deduplication and this comment is still the only thing holding them in
- * step. Moving each walk onto it is a change per walk, each with its own tests.
+ * Relation-filter wrappers whose body is a clause against the relation's target:
+ * the SQL compiler's own list (`query/filters.ts`), imported so a wrapper the
+ * compiler understands can never reach the builder unguarded. Re-exported for
+ * callers that still import it from here.
  */
-export const RELATION_FILTER_WRAPPERS = ['some', 'none', 'every', 'is', 'isNot'];
-const RELATION_FILTER_WRAPPER_SET = new Set(RELATION_FILTER_WRAPPERS);
+export { RELATION_FILTER_WRAPPERS };
 /**
  * Recursion bound for the guard walk.
  *
@@ -129,6 +111,78 @@ const LEVEL_OBJECT_KEYS = new Set([
  * which is what the builder itself branches on.
  */
 const RELATION_PICK_KEYS = new Set(['pick', 'by', 'direction', 'nulls', 'plan']);
+/**
+ * Find a `lock` option anywhere a query level can carry one: the args
+ * themselves, or the options of any `with` entry at any depth. Returns the
+ * dotted path to the shallowest hit (`lock`, `with.posts.lock`), or `null`.
+ *
+ * WHY THIS IS NOT PART OF {@link assertNoPiiPredicates}. A locking read is not
+ * a hidden-column question, and the PII walk is conditional by design: Studio
+ * skips it under `--show-pii`, `explain_query` hands it an allowlisted subset
+ * of its arguments, and `compile_query` hands it only `where` for an aggregate.
+ * A read-only refusal has to hold in every one of those, so each surface calls
+ * this directly and unconditionally. It lives in this module because both
+ * surfaces already import it, which is what keeps the rule and its wording in
+ * one place.
+ *
+ * ANY VALUE other than `undefined` counts, `null` and `false` included. The
+ * builder treats exactly `undefined` as "no lock" and refuses every other
+ * non-lock value itself (E003), so answering "present" for all of them means
+ * the verdict here never depends on what the builder would have made of it.
+ *
+ * A `with` MAP is keyed by relation names, so a relation that happens to be
+ * called `lock` is a level to descend into and never a hit; only the option
+ * position on a level is read. A table column called `lock` is likewise safe:
+ * columns live under `where` / `orderBy` / `select`, which are not searched.
+ *
+ * Iterative and breadth-first, so a deeply nested payload costs time and no
+ * stack, and the shallowest hit is the one reported. The visited set makes it
+ * terminate on a cyclic object, which parsed JSON cannot produce but a caller
+ * of a pure helper can.
+ */
+export function findRowLockOption(args) {
+    const queue = [{ level: args, parent: null, relation: '' }];
+    const seen = new Set();
+    for (let next = 0; next < queue.length; next++) {
+        const frame = queue[next];
+        if (seen.has(frame.level))
+            continue;
+        seen.add(frame.level);
+        if (frame.level.lock !== undefined)
+            return lockPath(frame);
+        const withClause = frame.level.with;
+        if (!isPlainObject(withClause))
+            continue;
+        for (const [relation, spec] of Object.entries(withClause)) {
+            if (isPlainObject(spec))
+                queue.push({ level: spec, parent: frame, relation });
+        }
+    }
+    return null;
+}
+/** `lock`, `with.posts.lock`, `with.posts.with.author.lock`: the path from the root to a hit. */
+function lockPath(frame) {
+    const relations = [];
+    for (let at = frame; at !== null && at.parent !== null; at = at.parent) {
+        relations.push(at.relation);
+    }
+    const parts = [];
+    for (let i = relations.length - 1; i >= 0; i--)
+        parts.push('with', relations[i]);
+    parts.push('lock');
+    return parts.join('.');
+}
+/**
+ * The refusal text for a `lock` found by {@link findRowLockOption}, shared so
+ * the two surfaces cannot word the same rule two ways. `path` is interpolated
+ * as given: it can carry a caller-chosen relation name, so each surface passes
+ * it through its own printable-name escaping first.
+ */
+export function rowLockRefusalMessage(path, tool) {
+    return (`${tool} does not accept \`${path}\`: it is read-only, and a locking read takes row locks, which needs a ` +
+        'write-capable transaction in your application. Remove it from the query here (nothing else about the query ' +
+        'changes), and run the locking read inside db.$transaction(async (tx) => ...) in your code.');
+}
 /** An object or array value, i.e. something that can carry a nested name. */
 function isObjectLike(value) {
     return value !== null && typeof value === 'object';
@@ -224,23 +278,34 @@ export function assertNoPiiPredicates(args, rootTable, host) {
     /**
      * A column-keyed operator object (`{ gt: 5 }`, `{ sort, nulls }`, a JSON path,
      * a vector distance) holds values, not names, with ONE exception: the
-     * comparison operators also accept `{ col: 'otherField' }`, which compiles to
-     * a column-to-column comparison in the same table. Scan for that.
+     * comparison operators also accept a column reference (`col('otherField')`),
+     * which compiles to a column-to-column comparison in the same table. Scan for
+     * that, including inside a `not` operator object, which compiles to
+     * `NOT (<inner>)` with the same operand positions.
+     *
+     * A reference carries a symbol brand that parsed JSON cannot produce, so the
+     * request data these tools compile never holds one, and the builder refuses
+     * the plain `{ col }` spelling. That spelling is refused HERE as well, as a
+     * shape: the guard must not depend on the builder to close a channel it is
+     * responsible for.
      *
      * The operator list is IMPORTED from `query/filters.ts` rather than copied:
      * that is the set the SQL compiler itself branches on, and a guard that
      * disagreed with it would be guarding a different query than the one that
-     * runs. A copy that drifted short by one operator reopens the operand-position
-     * channel this scan exists to close, silently.
+     * runs.
      */
-    const checkColumnRefs = (table, operatorNode) => {
+    const checkColumnRefs = (table, operatorNode, depth) => {
+        assertWithinDepth(depth);
         for (const opKey of COLUMN_REF_OPERATORS) {
             const operand = ownLookup(operatorNode, opKey);
-            if (!isPlainObject(operand))
+            if (isColumnRef(operand)) {
+                checkColumnName(table, operand.col);
                 continue;
-            const ref = operand.col;
-            if (typeof ref === 'string')
-                checkColumnName(table, ref);
+            }
+            if (isPlainColumnRefShape(operand))
+                host.refuseShape(table, `${opKey}: { col }`);
+            if (opKey === 'not' && isPlainObject(operand))
+                checkColumnRefs(table, operand, depth + 1);
         }
     };
     /**
@@ -295,7 +360,7 @@ export function assertNoPiiPredicates(args, rootTable, host) {
         if (scope === 'relation' && !table.allColumns.includes(column))
             host.refuseShape(table, key);
         if (isPlainObject(value))
-            checkColumnRefs(table, value);
+            checkColumnRefs(table, value, depth + 1);
     };
     /** A where / orderBy / cursor object (or a Prisma-style array of them). */
     const visitClause = (node, table, depth) => {

package/dist/cli/prisma-resolve.js

@@ -12,6 +12,8 @@
  * Pure leaf: no filesystem, database, or process access. Passing `schema: null`
  * yields a parse-only report (every item `parsed`, no map) for `--no-db`.
  */
+import { nullRecord } from '../introspect.js';
+import { ownLookup } from '../query/utils.js';
 import { camelToSnake, snakeToCamel, withDbFieldNames } from '../schema.js';
 export { DEFAULT_EXCLUDED_TABLES } from '../introspect.js';
 // ---------------------------------------------------------------------------
@@ -101,7 +103,9 @@ export function resolvePrismaSchema(ast, schema, options = {}) {
     const result = {
         models: [],
         enums: [],
-        map: { models: {}, enums: {} },
+        // Prototype-less: models, fields, relations and enums are keyed by names the
+        // Prisma schema chose, and `__proto__` / `constructor` are legal names there.
+        map: { models: nullRecord(), enums: nullRecord() },
         hasUnresolved: false,
         parseWarnings: ast.warnings,
         noDb,
@@ -110,7 +114,7 @@ export function resolvePrismaSchema(ast, schema, options = {}) {
     for (const model of ast.models) {
         const rt = modelTable.get(model.name);
         const table = rt.table;
-        const tableMeta = table && resolvedSchema ? resolvedSchema.tables[table] : undefined;
+        const tableMeta = table && resolvedSchema ? ownLookup(resolvedSchema.tables, table) : undefined;
         const accessor = table ? snakeToCamel(table) : null;
         const status = noDb ? 'parsed' : table ? 'resolved' : 'unresolved';
         const resolved = {
@@ -143,23 +147,23 @@ export function resolvePrismaSchema(ast, schema, options = {}) {
         result.models.push(resolved);
         // Build the verified map entry (skip in --no-db and for unresolved tables).
         if (!noDb && table && accessor) {
-            const fields = {};
+            const fields = nullRecord();
             for (const f of resolved.fields) {
                 if (f.status === 'resolved' && f.turbineField)
                     fields[f.prismaName] = f.turbineField;
             }
-            const relations = {};
+            const relations = nullRecord();
             for (const r of resolved.relations) {
                 if (r.status === 'resolved' && r.turbineName && r.cardinality) {
                     relations[r.prismaName] = { name: r.turbineName, cardinality: r.cardinality };
                 }
             }
-            const compoundUniques = {};
+            const compoundUniques = nullRecord();
             for (const c of resolved.compoundUniques) {
                 if (c.status === 'resolved' && c.turbineFields)
                     compoundUniques[c.selector] = c.turbineFields;
             }
-            const clientDefaults = collectClientDefaults(model, fields, resolvedSchema?.tables[table]);
+            const clientDefaults = collectClientDefaults(model, fields, ownLookup(resolvedSchema?.tables ?? {}, table));
             result.map.models[model.name] = {
                 table,
                 accessor,
@@ -259,7 +263,7 @@ function resolveScalarField(model, fieldName, tableMeta, noDb) {
     if (noDb || !tableMeta) {
         return { prismaName: fieldName, turbineField: null, column: null, status: noDb ? 'parsed' : 'unresolved' };
     }
-    const turbineField = tableMeta.reverseColumnMap[column];
+    const turbineField = ownLookup(tableMeta.reverseColumnMap, column);
     if (turbineField) {
         return { prismaName: fieldName, turbineField, column, status: 'resolved' };
     }
@@ -305,9 +309,9 @@ function relationFkColumns(model, field) {
 function collectClientDefaults(model, resolvedFields, tableMeta) {
     if (!tableMeta)
         return undefined;
-    const out = {};
+    const out = nullRecord();
     for (const field of model.fields) {
-        const turbineField = resolvedFields[field.name];
+        const turbineField = ownLookup(resolvedFields, field.name);
         if (!turbineField)
             continue;
         const col = tableMeta.columns.find((c) => c.field === turbineField || c.name === turbineField);
@@ -467,11 +471,11 @@ function resolveCompoundUnique(model, key, tableMeta, noDb) {
     if (noDb || !tableMeta)
         return base;
     const columns = key.fields.map((f) => fieldColumn(model, f));
-    const missing = columns.filter((c) => !tableMeta.reverseColumnMap[c]);
+    const missing = columns.filter((c) => !ownLookup(tableMeta.reverseColumnMap, c));
     if (missing.length > 0) {
         return { ...base, reason: `column(s) not found: ${missing.join(', ')}` };
     }
-    const turbineFields = columns.map((c) => tableMeta.reverseColumnMap[c]);
+    const turbineFields = columns.map((c) => ownLookup(tableMeta.reverseColumnMap, c));
     const want = [...columns].sort().join(',');
     const matches = (setList) => setList.some((s) => [...s].sort().join(',') === want);
     if (key.kind === 'id') {

package/dist/cli/prisma-schema.js

@@ -87,11 +87,19 @@ function lineAt(src, offset) {
 // ---------------------------------------------------------------------------
 // Attribute-argument tokenizer
 // ---------------------------------------------------------------------------
-/** Unquote a `"..."` literal, resolving the escapes Prisma supports. */
+const QUOTED_ESCAPES = { '"': '"', '\\': '\\', n: '\n', t: '\t' };
+/**
+ * Unquote a `"..."` literal, resolving the escapes Prisma supports.
+ *
+ * ONE left-to-right pass, because the escapes are not independent: after `\\`
+ * has become a backslash, that backslash must not be read again as the start of
+ * `\n` or `\t`. A chain of `.replace` calls does exactly that, so the literal
+ * `"C:\\new"` came out as `C:` + newline + `ew`.
+ */
 function unquote(raw) {
     const s = raw.trim();
     if (s.length >= 2 && s[0] === '"' && s[s.length - 1] === '"') {
-        return s.slice(1, -1).replace(/\\"/g, '"').replace(/\\\\/g, '\\').replace(/\\n/g, '\n').replace(/\\t/g, '\t');
+        return s.slice(1, -1).replace(/\\(["\\nt])/g, (_, escaped) => QUOTED_ESCAPES[escaped]);
     }
     return s;
 }
@@ -423,7 +431,7 @@ function parseFieldLine(text, line, warnings) {
             `Turbine generates the column from the database, so it IS present on the generated client.`);
     }
     for (const attr of attrs) {
-        const note = NOTED_FIELD_ATTRS[attr.name];
+        const note = Object.hasOwn(NOTED_FIELD_ATTRS, attr.name) ? NOTED_FIELD_ATTRS[attr.name] : undefined;
         if (note)
             warnings.push(`Line ${line}: field "${name}": ${note}`);
     }
@@ -457,7 +465,7 @@ function parseModelBody(block, kind, src, warnings) {
                     // @@index and anything else: recorded in blockAttrs, unused. The
                     // few that change what the model MEANS get a warning rather than
                     // silence (see NOTED_BLOCK_ATTRS).
-                    const note = NOTED_BLOCK_ATTRS[attr.name];
+                    const note = Object.hasOwn(NOTED_BLOCK_ATTRS, attr.name) ? NOTED_BLOCK_ATTRS[attr.name] : undefined;
                     if (note)
                         warnings.push(`Line ${line}: model "${block.name}": ${note}`);
                 }