turbine-orm 0.49.0 → 0.50.0

package/dist/cli/prisma-schema.d.ts

@@ -90,10 +90,36 @@ export interface PrismaEnum {
     map?: string;
     line: number;
 }
+/**
+ * A connection-string value inside a `datasource` block: either a literal
+ * string (`url = "postgres://..."`) or an `env("NAME")` indirection.
+ */
+export type PrismaConnectionValue = {
+    kind: 'literal';
+    value: string;
+} | {
+    kind: 'env';
+    variable: string;
+};
+/** A parsed `datasource` block. Only the connection keys are retained. */
+export interface PrismaDatasource {
+    /** Block name (`datasource db { ... }` -> `db`). */
+    name: string;
+    /** `provider = "postgresql"`, when declared as a literal. */
+    provider?: string;
+    /** `url = ...`, when declared as a literal or an `env(...)` call. */
+    url?: PrismaConnectionValue;
+    /** `directUrl = ...` (Prisma's non-pooled connection), same forms as `url`. */
+    directUrl?: PrismaConnectionValue;
+    /** 1-based source line of the block header. */
+    line: number;
+}
 /** The full parse result. */
 export interface PrismaSchemaAst {
     models: PrismaModel[];
     enums: PrismaEnum[];
+    /** Parsed `datasource` blocks, in source order. */
+    datasources: PrismaDatasource[];
     /** Non-fatal notes: skipped/unknown blocks and attributes. */
     warnings: string[];
 }
@@ -102,13 +128,47 @@ export declare class PrismaParseError extends Error {
     readonly line: number;
     constructor(message: string, line: number);
 }
+/** Where a datasource connection string was resolved from. */
+export interface ResolvedPrismaDatasourceUrl {
+    /** The connection string itself. */
+    url: string;
+    /** Datasource block name it came from. */
+    datasource: string;
+    /** Which key supplied it. */
+    key: 'url' | 'directUrl';
+    /** The environment variable read, when the value was an `env(...)` call. */
+    variable?: string;
+}
+/** Result of {@link resolvePrismaDatasourceUrl}. */
+export interface PrismaDatasourceUrlLookup {
+    /** The first usable connection string found, if any. */
+    resolved?: ResolvedPrismaDatasourceUrl;
+    /**
+     * Environment variable names the schema declares via `env(...)` that were
+     * unset or empty, in lookup order. Surfaced in the no-URL error so the user
+     * sees exactly which variable the schema asked for.
+     */
+    missingVariables: string[];
+}
+/**
+ * Resolve the connection string a `schema.prisma` declares, reading `env(...)`
+ * indirections out of the supplied environment (pure: the environment is an
+ * argument, never `process.env` directly).
+ *
+ * Per datasource block, `url` is preferred and `directUrl` is the fallback:
+ * `url` is what Prisma itself uses for everything but migrations, and a pooled
+ * `url` introspects the same catalog as its direct twin.
+ */
+export declare function resolvePrismaDatasourceUrl(ast: Pick<PrismaSchemaAst, 'datasources'>, env: Record<string, string | undefined>): PrismaDatasourceUrlLookup;
 /**
  * Parse a `schema.prisma` source string into a {@link PrismaSchemaAst}.
  *
  * Understands: model / view / type / enum blocks; field lines with `@map`,
  * `@id`, `@unique`, `@default`, `@updatedAt`, `@ignore`, `@relation`; and block
- * attributes `@@map`, `@@id`, `@@unique`, `@@index`, `@@schema`. Unknown
- * attributes and blocks are skipped into {@link PrismaSchemaAst.warnings}.
+ * attributes `@@map`, `@@id`, `@@unique`, `@@index`, `@@schema`; plus the
+ * `provider` / `url` / `directUrl` keys of each `datasource` block (see
+ * {@link resolvePrismaDatasourceUrl}). Unknown attributes and blocks are
+ * skipped into {@link PrismaSchemaAst.warnings}.
  *
  * @throws {@link PrismaParseError} on an unterminated block/paren/string or a
  *   structurally broken `@@id` / `@@unique` / `@@map`.

package/dist/cli/prisma-schema.js

@@ -432,6 +432,78 @@ function parseEnumBody(block, src) {
     }
     return en;
 }
+/**
+ * Parse a `datasource` block value: a quoted literal, or an `env("NAME")` call.
+ * Returns null for any other form (e.g. an interpolated expression), which the
+ * caller records as "declared but not usable" rather than guessing.
+ */
+function parseConnectionValue(raw) {
+    if (/^"(?:[^"\\]|\\.)*"$/.test(raw))
+        return { kind: 'literal', value: unquote(raw) };
+    const envCall = raw.match(/^env\(\s*("(?:[^"\\]|\\.)*")\s*\)$/);
+    if (envCall) {
+        const variable = unquote(envCall[1]);
+        return variable ? { kind: 'env', variable } : null;
+    }
+    return null;
+}
+/**
+ * Parse a `datasource` block. Only `provider`, `url`, and `directUrl` are kept;
+ * every other key (`shadowDatabaseUrl`, `relationMode`, `extensions`, ...) is
+ * irrelevant to name mapping and skipped silently, as before.
+ */
+function parseDatasourceBody(block, src) {
+    const ds = { name: block.name, line: block.headerLine };
+    for (const { text } of bodyLines(block.body, block.bodyOffset, src)) {
+        const m = text.match(/^([A-Za-z_]\w*)\s*=\s*(.+)$/);
+        if (!m)
+            continue;
+        const key = m[1];
+        const raw = m[2].trim();
+        if (key === 'provider') {
+            const value = parseConnectionValue(raw);
+            if (value?.kind === 'literal')
+                ds.provider = value.value;
+        }
+        else if (key === 'url' || key === 'directUrl') {
+            const value = parseConnectionValue(raw);
+            if (value)
+                ds[key] = value;
+        }
+    }
+    return ds;
+}
+/**
+ * Resolve the connection string a `schema.prisma` declares, reading `env(...)`
+ * indirections out of the supplied environment (pure: the environment is an
+ * argument, never `process.env` directly).
+ *
+ * Per datasource block, `url` is preferred and `directUrl` is the fallback:
+ * `url` is what Prisma itself uses for everything but migrations, and a pooled
+ * `url` introspects the same catalog as its direct twin.
+ */
+export function resolvePrismaDatasourceUrl(ast, env) {
+    const missingVariables = [];
+    for (const ds of ast.datasources) {
+        for (const key of ['url', 'directUrl']) {
+            const value = ds[key];
+            if (!value)
+                continue;
+            if (value.kind === 'literal') {
+                if (value.value)
+                    return { resolved: { url: value.value, datasource: ds.name, key }, missingVariables };
+                continue;
+            }
+            const fromEnv = env[value.variable];
+            if (fromEnv) {
+                return { resolved: { url: fromEnv, datasource: ds.name, key, variable: value.variable }, missingVariables };
+            }
+            if (!missingVariables.includes(value.variable))
+                missingVariables.push(value.variable);
+        }
+    }
+    return { missingVariables };
+}
 // ---------------------------------------------------------------------------
 // Entry point
 // ---------------------------------------------------------------------------
@@ -440,15 +512,17 @@ function parseEnumBody(block, src) {
  *
  * Understands: model / view / type / enum blocks; field lines with `@map`,
  * `@id`, `@unique`, `@default`, `@updatedAt`, `@ignore`, `@relation`; and block
- * attributes `@@map`, `@@id`, `@@unique`, `@@index`, `@@schema`. Unknown
- * attributes and blocks are skipped into {@link PrismaSchemaAst.warnings}.
+ * attributes `@@map`, `@@id`, `@@unique`, `@@index`, `@@schema`; plus the
+ * `provider` / `url` / `directUrl` keys of each `datasource` block (see
+ * {@link resolvePrismaDatasourceUrl}). Unknown attributes and blocks are
+ * skipped into {@link PrismaSchemaAst.warnings}.
  *
  * @throws {@link PrismaParseError} on an unterminated block/paren/string or a
  *   structurally broken `@@id` / `@@unique` / `@@map`.
  */
 export function parsePrismaSchema(source) {
     const src = stripComments(source);
-    const ast = { models: [], enums: [], warnings: [] };
+    const ast = { models: [], enums: [], datasources: [], warnings: [] };
     for (const block of scanBlocks(src)) {
         switch (block.keyword) {
             case 'model':
@@ -467,8 +541,11 @@ export function parsePrismaSchema(source) {
                 ast.enums.push(parseEnumBody(block, src));
                 break;
             case 'datasource':
+                // Not a table, but it declares the connection string the CLI can reuse.
+                ast.datasources.push(parseDatasourceBody(block, src));
+                break;
             case 'generator':
-                // Configuration blocks - irrelevant to name mapping.
+                // Configuration block - irrelevant to name mapping.
                 break;
             default:
                 ast.warnings.push(`Skipped unsupported block "${block.keyword} ${block.name}".`);

package/dist/cli/rate-limit.d.ts

@@ -0,0 +1,32 @@
+/**
+ * turbine-orm CLI: fixed-window rate limiter
+ *
+ * A pure leaf module (same role as `cli/destructive.ts`): no imports beyond a
+ * Node type, no I/O, no state of its own. Both local servers, Studio and
+ * Observe, throttle through it so they behave identically without either one
+ * importing the other. Studio in particular statically pulls in the embedded
+ * UI, the demo store, PII redaction and QueryInterface, none of which Observe
+ * has any use for.
+ */
+import type { IncomingMessage } from 'node:http';
+export declare const RATE_LIMIT_WINDOW_MS = 60000;
+export declare const RATE_LIMIT_MAX_REQUESTS = 100;
+/**
+ * Bucket identity for one caller. These are loopback tools with a single shared
+ * token, so the remote address is the only thing that distinguishes one client
+ * from another; requests with no socket (in-process dispatch) share one key.
+ */
+export declare function callerKey(req: IncomingMessage): string;
+export interface RateLimitResult {
+    allowed: boolean;
+    resetAt: number;
+}
+/**
+ * Fixed-window counter. `limiter` is the caller's own state map (each server
+ * owns one, so exhausting one server's budget never touches the other's) and
+ * `token` is the bucket key, not a credential.
+ */
+export declare function checkRateLimit(limiter: Map<string, {
+    count: number;
+    resetAt: number;
+}>, token: string): RateLimitResult;

package/dist/cli/rate-limit.js

@@ -0,0 +1,40 @@
+/**
+ * turbine-orm CLI: fixed-window rate limiter
+ *
+ * A pure leaf module (same role as `cli/destructive.ts`): no imports beyond a
+ * Node type, no I/O, no state of its own. Both local servers, Studio and
+ * Observe, throttle through it so they behave identically without either one
+ * importing the other. Studio in particular statically pulls in the embedded
+ * UI, the demo store, PII redaction and QueryInterface, none of which Observe
+ * has any use for.
+ */
+export const RATE_LIMIT_WINDOW_MS = 60_000; // 60 seconds
+export const RATE_LIMIT_MAX_REQUESTS = 100;
+/**
+ * Bucket identity for one caller. These are loopback tools with a single shared
+ * token, so the remote address is the only thing that distinguishes one client
+ * from another; requests with no socket (in-process dispatch) share one key.
+ */
+export function callerKey(req) {
+    return req.socket?.remoteAddress ?? 'unknown';
+}
+/**
+ * Fixed-window counter. `limiter` is the caller's own state map (each server
+ * owns one, so exhausting one server's budget never touches the other's) and
+ * `token` is the bucket key, not a credential.
+ */
+export function checkRateLimit(limiter, token) {
+    const now = Date.now();
+    const entry = limiter.get(token);
+    if (!entry || now >= entry.resetAt) {
+        // Start a new window
+        const resetAt = now + RATE_LIMIT_WINDOW_MS;
+        limiter.set(token, { count: 1, resetAt });
+        return { allowed: true, resetAt };
+    }
+    entry.count++;
+    if (entry.count > RATE_LIMIT_MAX_REQUESTS) {
+        return { allowed: false, resetAt: entry.resetAt };
+    }
+    return { allowed: true, resetAt: entry.resetAt };
+}

package/dist/cli/studio.d.ts

@@ -1,5 +1,5 @@
 /**
- * turbine-orm CLI — Studio
+ * turbine-orm CLI: Studio
  *
  * A local web UI for browsing databases, exploring relations, and composing
  * queries visually. ORM-native since v0.19: there is no raw-SQL input surface.
@@ -90,7 +90,7 @@ export interface StudioHandle {
     } | null;
     /** Random per-process session token the UI sends via cookie. */
     authToken: string;
-    /** Full URL including `?token=...` — safe to print for the user. */
+    /** Full URL including `?token=...`, safe to print for the user. */
     url: string;
 }
 export interface StudioContext {
@@ -106,12 +106,12 @@ export interface StudioContext {
     options: StudioOptions;
     authToken: string;
     stateDir: string;
-    /** Resolved statement timeout (adapter-aware) — parameterized SQL + values. */
+    /** Resolved statement timeout (adapter-aware): parameterized SQL + values. */
     statementTimeout: {
         sql: string;
         params: unknown[];
     };
-    /** Rate limiter state — tracks requests per authenticated session. */
+    /** Rate limiter state: tracks requests per authenticated session. */
     rateLimiter: Map<string, {
         count: number;
         resetAt: number;
@@ -190,7 +190,7 @@ interface SavedQuery {
     id: string;
     table: string;
     name: string;
-    /** Studio only saves visual-builder queries — there is no raw-SQL surface. */
+    /** Studio only saves visual-builder queries: there is no raw-SQL surface. */
     kind: 'builder';
     args?: unknown;
     createdAt: string;