turbine-orm 0.81.0 → 0.90.0

package/dist/cjs/cli/observe.js

@@ -16,6 +16,8 @@ const node_crypto_1 = require("node:crypto");
 const node_http_1 = require("node:http");
 const pg_1 = __importDefault(require("pg"));
 const connection_guard_js_1 = require("../connection-guard.js");
+const local_server_guard_js_1 = require("./local-server-guard.js");
+const local_server_output_js_1 = require("./local-server-output.js");
 const observe_ui_js_1 = require("./observe-ui.js");
 const rate_limit_js_1 = require("./rate-limit.js");
 const ui_js_1 = require("./ui.js");
@@ -34,31 +36,41 @@ async function startObserve(options) {
         console.error(`[turbine] observe pool error: ${(0, ui_js_1.redactUrl)(err.message)}`);
     });
     (0, connection_guard_js_1.absorbCheckedOutErrors)(pool);
-    const probe = await pool.connect();
-    try {
-        await probe.query('SELECT 1');
-    }
-    finally {
-        probe.release();
-    }
     const authToken = (0, node_crypto_1.randomBytes)(24).toString('hex');
+    const ticketGate = (0, local_server_guard_js_1.createTicketGate)();
     const rateLimiter = new Map();
     const server = (0, node_http_1.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: (0, local_server_output_js_1.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);
+        (0, local_server_output_js_1.openInBrowser)(url);
     }
     return {
         authToken,
@@ -72,15 +84,31 @@ async function startObserve(options) {
 // ---------------------------------------------------------------------------
 // Request routing
 // ---------------------------------------------------------------------------
-async function handleRequest(req, res, pool, options, authToken, rateLimiter) {
+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 (!(0, local_server_guard_js_1.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') {
@@ -88,13 +116,28 @@ async function handleRequest(req, res, pool, options, authToken, rateLimiter) {
             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' ? (0, local_server_guard_js_1.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_ui_js_1.OBSERVE_HTML, cspNonce());
         return;
@@ -127,7 +170,7 @@ async function handleRequest(req, res, pool, options, authToken, rateLimiter) {
 // ---------------------------------------------------------------------------
 function isAuthorized(req, expectedToken) {
     const headerToken = req.headers['x-turbine-token'];
-    if (typeof headerToken === 'string' && constantTimeEqual(headerToken, expectedToken)) {
+    if (typeof headerToken === 'string' && (0, local_server_guard_js_1.constantTimeEqual)(headerToken, expectedToken)) {
         return true;
     }
     const cookieHeader = req.headers.cookie ?? '';
@@ -135,18 +178,23 @@ function isAuthorized(req, expectedToken) {
     // ENDS with this one (`x_turbine_observe_token=...`) matched first and the real
     // token was never compared, denying the legitimate session.
     const match = /(?:^|;\s*)turbine_observe_token=([a-f0-9]+)/.exec(cookieHeader);
-    if (match?.[1] && constantTimeEqual(match[1], expectedToken)) {
+    if (match?.[1] && (0, local_server_guard_js_1.constantTimeEqual)(match[1], expectedToken)) {
         return true;
     }
     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 = (0, node_crypto_1.createHash)('sha256').update(a).digest();
-    const bh = (0, node_crypto_1.createHash)('sha256').update(b).digest();
-    return (0, node_crypto_1.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 = (0, local_server_guard_js_1.createTicketGate)(authToken);
+        FALLBACK_GATES.set(authToken, gate);
+    }
+    return gate;
 }
 // ---------------------------------------------------------------------------
 // API handlers
@@ -195,7 +243,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: (0, local_server_output_js_1.responseErrorText)(err) });
     }
     finally {
         client.release();
@@ -236,7 +284,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: (0, local_server_output_js_1.responseErrorText)(err) });
     }
     finally {
         client.release();
@@ -284,21 +332,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/cjs/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/cjs/cli/pii-predicate-guard.js

@@ -65,35 +65,13 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PII_GUARD_MAX_DEPTH = exports.RELATION_FILTER_WRAPPERS = void 0;
+exports.findRowLockOption = findRowLockOption;
+exports.rowLockRefusalMessage = rowLockRefusalMessage;
 exports.assertNoPiiPredicates = assertNoPiiPredicates;
+const column_ref_js_1 = require("../query/column-ref.js");
 const filters_js_1 = require("../query/filters.js");
+Object.defineProperty(exports, "RELATION_FILTER_WRAPPERS", { enumerable: true, get: function () { return filters_js_1.RELATION_FILTER_WRAPPERS; } });
 const utils_js_1 = require("../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.
- */
-exports.RELATION_FILTER_WRAPPERS = ['some', 'none', 'every', 'is', 'isNot'];
-const RELATION_FILTER_WRAPPER_SET = new Set(exports.RELATION_FILTER_WRAPPERS);
 /**
  * Recursion bound for the guard walk.
  *
@@ -133,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.
+ */
+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.
+ */
+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';
@@ -228,23 +278,34 @@ 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 filters_js_1.COLUMN_REF_OPERATORS) {
             const operand = (0, utils_js_1.ownLookup)(operatorNode, opKey);
-            if (!isPlainObject(operand))
+            if ((0, filters_js_1.isColumnRef)(operand)) {
+                checkColumnName(table, operand.col);
                 continue;
-            const ref = operand.col;
-            if (typeof ref === 'string')
-                checkColumnName(table, ref);
+            }
+            if ((0, column_ref_js_1.isPlainColumnRefShape)(operand))
+                host.refuseShape(table, `${opKey}: { col }`);
+            if (opKey === 'not' && isPlainObject(operand))
+                checkColumnRefs(table, operand, depth + 1);
         }
     };
     /**
@@ -271,7 +332,7 @@ function assertNoPiiPredicates(args, rootTable, host) {
         // body is a clause against the SAME target. Handing the wrapper to the
         // column walker instead walked `is` as if it were a column of the target,
         // so the inner clause was never visited at all.
-        if (scope === 'relation' && RELATION_FILTER_WRAPPER_SET.has(key)) {
+        if (scope === 'relation' && filters_js_1.RELATION_FILTER_WRAPPER_SET.has(key)) {
             visitClause(value, table, depth + 1);
             return;
         }
@@ -299,7 +360,7 @@ 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/cjs/cli/prisma-resolve.js

@@ -16,9 +16,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_EXCLUDED_TABLES = void 0;
 exports.resolvePrismaSchema = resolvePrismaSchema;
+const introspect_js_1 = require("../introspect.js");
+const utils_js_1 = require("../query/utils.js");
 const schema_js_1 = require("../schema.js");
-var introspect_js_1 = require("../introspect.js");
-Object.defineProperty(exports, "DEFAULT_EXCLUDED_TABLES", { enumerable: true, get: function () { return introspect_js_1.DEFAULT_EXCLUDED_TABLES; } });
+var introspect_js_2 = require("../introspect.js");
+Object.defineProperty(exports, "DEFAULT_EXCLUDED_TABLES", { enumerable: true, get: function () { return introspect_js_2.DEFAULT_EXCLUDED_TABLES; } });
 // ---------------------------------------------------------------------------
 // Name-candidate helpers
 // ---------------------------------------------------------------------------
@@ -106,7 +108,9 @@ 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: (0, introspect_js_1.nullRecord)(), enums: (0, introspect_js_1.nullRecord)() },
         hasUnresolved: false,
         parseWarnings: ast.warnings,
         noDb,
@@ -115,7 +119,7 @@ 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 ? (0, utils_js_1.ownLookup)(resolvedSchema.tables, table) : undefined;
         const accessor = table ? (0, schema_js_1.snakeToCamel)(table) : null;
         const status = noDb ? 'parsed' : table ? 'resolved' : 'unresolved';
         const resolved = {
@@ -148,23 +152,23 @@ 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 = (0, introspect_js_1.nullRecord)();
             for (const f of resolved.fields) {
                 if (f.status === 'resolved' && f.turbineField)
                     fields[f.prismaName] = f.turbineField;
             }
-            const relations = {};
+            const relations = (0, introspect_js_1.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 = (0, introspect_js_1.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, (0, utils_js_1.ownLookup)(resolvedSchema?.tables ?? {}, table));
             result.map.models[model.name] = {
                 table,
                 accessor,
@@ -264,7 +268,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 = (0, utils_js_1.ownLookup)(tableMeta.reverseColumnMap, column);
     if (turbineField) {
         return { prismaName: fieldName, turbineField, column, status: 'resolved' };
     }
@@ -310,9 +314,9 @@ function relationFkColumns(model, field) {
 function collectClientDefaults(model, resolvedFields, tableMeta) {
     if (!tableMeta)
         return undefined;
-    const out = {};
+    const out = (0, introspect_js_1.nullRecord)();
     for (const field of model.fields) {
-        const turbineField = resolvedFields[field.name];
+        const turbineField = (0, utils_js_1.ownLookup)(resolvedFields, field.name);
         if (!turbineField)
             continue;
         const col = tableMeta.columns.find((c) => c.field === turbineField || c.name === turbineField);
@@ -472,11 +476,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) => !(0, utils_js_1.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) => (0, utils_js_1.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/cjs/cli/prisma-schema.js

@@ -93,11 +93,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;
 }
@@ -429,7 +437,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}`);
     }
@@ -463,7 +471,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}`);
                 }