@stardeck-customer-apps/testing 0.1.1

package/dist/setup.js

@@ -0,0 +1,658 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/global-singleton.ts
+function globalSingleton(key, create) {
+  const symbol = /* @__PURE__ */ Symbol.for(`stardeck-testing.${key}`);
+  const holder = globalThis;
+  holder[symbol] ??= create();
+  return holder[symbol];
+}
+
+// src/state.ts
+var state = globalSingleton("state", () => ({
+  db: null,
+  currentUser: null,
+  sessions: /* @__PURE__ */ new Map(),
+  refreshSessions: /* @__PURE__ */ new Map(),
+  emails: [],
+  emailCounter: 0,
+  allowNetwork: false
+}));
+function requireDb() {
+  if (!state.db) {
+    throw new Error(
+      "[stardeck-testing] No active test app. Call `await createTestApp(...)` in beforeAll before using Stardeck SDKs in tests."
+    );
+  }
+  return state.db;
+}
+
+// src/constants.ts
+var TEST_DOMAIN_SUFFIX = ".stardeck.test";
+var CONTROL_PLANE_TEST_URL = "https://control-plane.stardeck.test";
+var DATA_STORE_TEST_HOST = "db.stardeck.test";
+var TEST_ENV_DEFAULTS = {
+  CONTROL_PLANE_URL: CONTROL_PLANE_TEST_URL,
+  DEPLOYMENT_SECRET: "stardeck-test-deployment-secret",
+  ORGANIZATION_ID: "00000000-0000-4000-8000-00000000000a",
+  PROJECT_ID: "00000000-0000-4000-8000-00000000000b",
+  DEPLOYMENT_ID: "00000000-0000-4000-8000-00000000000c",
+  DATA_STORE_URL: `postgresql://test:test@${DATA_STORE_TEST_HOST}/main`
+};
+
+// src/simulator/hmac.ts
+var import_node_crypto = __toESM(require("crypto"));
+var TIMESTAMP_TOLERANCE_SECONDS = 300;
+function verifyDeploymentAuthHeader(secret, header) {
+  const dotIndex = header.lastIndexOf(".");
+  if (dotIndex === -1) return null;
+  const payloadB64 = header.slice(0, dotIndex);
+  const signature = header.slice(dotIndex + 1);
+  let payloadJson;
+  try {
+    payloadJson = Buffer.from(payloadB64, "base64").toString("utf-8");
+  } catch {
+    return null;
+  }
+  const expected = import_node_crypto.default.createHmac("sha256", secret).update(payloadJson).digest("hex");
+  const expectedBuf = Buffer.from(expected, "utf-8");
+  const actualBuf = Buffer.from(signature, "utf-8");
+  if (expectedBuf.length !== actualBuf.length || !import_node_crypto.default.timingSafeEqual(expectedBuf, actualBuf)) {
+    return null;
+  }
+  let payload;
+  try {
+    payload = JSON.parse(payloadJson);
+  } catch {
+    return null;
+  }
+  if (payload.type !== "deployment-request") return null;
+  const now = Math.floor(Date.now() / 1e3);
+  if (Math.abs(now - payload.timestamp) > TIMESTAMP_TOLERANCE_SECONDS) return null;
+  return payload;
+}
+
+// src/simulator/http.ts
+function json(body, status = 200) {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+function success(data) {
+  return json({ success: true, data });
+}
+function failure(error, status = 400) {
+  return json({ success: false, error }, status);
+}
+
+// src/simulator/data-store.ts
+function quoteIdent(name) {
+  return `"${name.replace(/"/g, '""')}"`;
+}
+function normalizeIdent(name) {
+  return name.toLowerCase().replace(/\s+/g, "_");
+}
+async function getTableColumns(db, tableName) {
+  const { rows } = await db.query(
+    `SELECT column_name FROM information_schema.columns WHERE table_schema = 'public' AND table_name = $1 ORDER BY ordinal_position`,
+    [tableName]
+  );
+  if (rows.length === 0) return null;
+  return rows.map((r) => r.column_name);
+}
+async function getPrimaryKeyColumns(db, tableName) {
+  const { rows } = await db.query(
+    `SELECT ku.column_name
+     FROM information_schema.table_constraints tc
+     JOIN information_schema.key_column_usage ku
+       ON tc.constraint_name = ku.constraint_name AND tc.table_schema = ku.table_schema
+     WHERE tc.constraint_type = 'PRIMARY KEY'
+       AND tc.table_schema = 'public'
+       AND tc.table_name = $1`,
+    [tableName]
+  );
+  return rows.map((r) => r.column_name);
+}
+function coerceNumericFields(result) {
+  const numericFields = result.fields.filter((f) => f.dataTypeID === 1700).map((f) => f.name);
+  if (numericFields.length === 0) return result.rows;
+  return result.rows.map((row) => {
+    const coerced = { ...row };
+    for (const name of numericFields) {
+      if (typeof coerced[name] === "string") {
+        coerced[name] = parseFloat(coerced[name]);
+      }
+    }
+    return coerced;
+  });
+}
+function buildWhereClause(filters, validColumns) {
+  const conditions = [];
+  const params = [];
+  let paramIndex = 1;
+  for (const filter of filters) {
+    if (!validColumns.includes(filter.column)) continue;
+    const col = quoteIdent(filter.column);
+    switch (filter.operator) {
+      case "eq":
+        conditions.push(`${col} = $${paramIndex++}`);
+        params.push(filter.value);
+        break;
+      case "neq":
+        conditions.push(`${col} != $${paramIndex++}`);
+        params.push(filter.value);
+        break;
+      case "contains": {
+        conditions.push(`${col}::text ILIKE $${paramIndex++}`);
+        const escaped = String(filter.value ?? "").replace(/[%_\\]/g, "\\$&");
+        params.push(`%${escaped}%`);
+        break;
+      }
+      case "gt":
+        conditions.push(`${col} > $${paramIndex++}`);
+        params.push(filter.value);
+        break;
+      case "lt":
+        conditions.push(`${col} < $${paramIndex++}`);
+        params.push(filter.value);
+        break;
+      case "is_null":
+        conditions.push(`${col} IS NULL`);
+        break;
+      case "is_not_null":
+        conditions.push(`${col} IS NOT NULL`);
+        break;
+    }
+  }
+  if (conditions.length === 0) return { clause: "", params: [] };
+  return { clause: `WHERE ${conditions.join(" AND ")}`, params };
+}
+async function handleQuery(db, body) {
+  if (typeof body.tableName !== "string" || body.tableName.length === 0) {
+    return failure("Invalid request body", 400);
+  }
+  const tableName = body.tableName;
+  const limit = body.limit === void 0 ? 50 : Number(body.limit);
+  const offset = body.offset === void 0 ? 0 : Number(body.offset);
+  if (!Number.isInteger(limit) || limit < 1 || limit > 100) {
+    return failure("Invalid request body", 400);
+  }
+  if (!Number.isInteger(offset) || offset < 0) {
+    return failure("Invalid request body", 400);
+  }
+  if (body.orderDir !== void 0 && body.orderDir !== "asc" && body.orderDir !== "desc") {
+    return failure("Invalid request body", 400);
+  }
+  const orderBy = body.orderBy ? String(body.orderBy) : void 0;
+  const orderDir = body.orderDir === "desc" ? "desc" : "asc";
+  const filters = body.filters ?? [];
+  const validColumns = await getTableColumns(db, tableName);
+  if (!validColumns) return failure(`Table "${tableName}" not found`, 404);
+  if (orderBy && !validColumns.includes(orderBy)) {
+    return failure(`Column "${orderBy}" not found in table "${tableName}"`);
+  }
+  const { clause: whereClause, params: whereParams } = buildWhereClause(filters, validColumns);
+  const orderClause = orderBy ? `ORDER BY ${quoteIdent(orderBy)} ${orderDir === "desc" ? "DESC" : "ASC"}` : "";
+  const nextParamIdx = whereParams.length + 1;
+  const quotedTable = quoteIdent(tableName);
+  const preparedWhereParams = whereParams.map(prepareParam);
+  const dataResult = await db.query(
+    `SELECT * FROM ${quotedTable} ${whereClause} ${orderClause} LIMIT $${nextParamIdx} OFFSET $${nextParamIdx + 1}`,
+    [...preparedWhereParams, limit, offset]
+  );
+  const countResult = await db.query(
+    `SELECT count(*)::int as total FROM ${quotedTable} ${whereClause}`,
+    preparedWhereParams
+  );
+  return success({
+    rows: coerceNumericFields(dataResult),
+    columns: validColumns,
+    total: countResult.rows[0]?.total ?? 0,
+    limit,
+    offset
+  });
+}
+function buildPkWhere(primaryKey, pkColumns, startParamIdx) {
+  const conditions = [];
+  const params = [];
+  let paramIdx = startParamIdx;
+  for (const col of pkColumns) {
+    if (!(col in primaryKey)) {
+      throw new Error(`Missing primary key column: ${col}`);
+    }
+    conditions.push(`${quoteIdent(col)} = $${paramIdx++}`);
+    params.push(primaryKey[col]);
+  }
+  return { clause: conditions.join(" AND "), params };
+}
+async function handleMutate(db, body) {
+  if (typeof body.tableName !== "string" || body.tableName.length === 0) {
+    return failure("Invalid request body", 400);
+  }
+  const tableName = body.tableName;
+  const operation = String(body.operation ?? "");
+  if (!["insert", "update", "delete"].includes(operation)) {
+    return failure("Invalid request body", 400);
+  }
+  const columns = await getTableColumns(db, tableName);
+  if (!columns) return failure(`Table "${tableName}" not found`, 404);
+  const pkColumns = await getPrimaryKeyColumns(db, tableName);
+  switch (operation) {
+    case "insert": {
+      const row = body.row ?? {};
+      const insertColumns = Object.keys(row).filter((col) => columns.includes(col));
+      let sql;
+      let values;
+      if (insertColumns.length === 0) {
+        sql = `INSERT INTO ${quoteIdent(tableName)} DEFAULT VALUES RETURNING *`;
+        values = [];
+      } else {
+        values = insertColumns.map((col) => prepareParam(row[col]));
+        const colList = insertColumns.map((c) => quoteIdent(c)).join(", ");
+        const paramList = insertColumns.map((_, i) => `$${i + 1}`).join(", ");
+        sql = `INSERT INTO ${quoteIdent(tableName)} (${colList}) VALUES (${paramList}) RETURNING *`;
+      }
+      const result = await db.query(sql, values);
+      return success({ row: result.rows[0] });
+    }
+    case "update": {
+      const column = String(body.column ?? "");
+      if (!columns.includes(column)) {
+        return failure(`Column "${column}" not found in table "${tableName}"`);
+      }
+      if (pkColumns.length === 0) {
+        return failure(`Table "${tableName}" has no primary key`);
+      }
+      const { clause: pkClause, params: pkParams } = buildPkWhere(
+        body.primaryKey ?? {},
+        pkColumns,
+        2
+      );
+      const updateValue = body.value === "" ? null : prepareParam(body.value);
+      const result = await db.query(
+        `UPDATE ${quoteIdent(tableName)} SET ${quoteIdent(column)} = $1 WHERE ${pkClause} RETURNING *`,
+        [updateValue, ...pkParams.map(prepareParam)]
+      );
+      if (result.rows.length === 0) return failure("Row not found", 404);
+      return success({ row: result.rows[0] });
+    }
+    case "delete": {
+      if (pkColumns.length === 0) {
+        return failure(`Table "${tableName}" has no primary key`);
+      }
+      const { clause: pkClause, params: pkParams } = buildPkWhere(
+        body.primaryKey ?? {},
+        pkColumns,
+        1
+      );
+      const result = await db.query(
+        `DELETE FROM ${quoteIdent(tableName)} WHERE ${pkClause} RETURNING *`,
+        pkParams.map(prepareParam)
+      );
+      if (result.rows.length === 0) return failure("Row not found", 404);
+      return success({ deleted: true, row: result.rows[0] });
+    }
+    default:
+      return failure(`Unknown operation "${operation}"`);
+  }
+}
+function prepareParam(value) {
+  if (value instanceof Date) return value.toISOString();
+  if (Array.isArray(value)) return encodeArrayLiteral(value);
+  if (value !== null && typeof value === "object") return JSON.stringify(value);
+  return value;
+}
+function encodeArrayLiteral(values) {
+  const items = values.map((v) => {
+    if (v === null || v === void 0) return "NULL";
+    if (Array.isArray(v)) return quoteArrayElement(encodeArrayLiteral(v));
+    if (v instanceof Date) return quoteArrayElement(v.toISOString());
+    if (typeof v === "object") return quoteArrayElement(JSON.stringify(v));
+    return quoteArrayElement(String(v));
+  });
+  return `{${items.join(",")}}`;
+}
+function quoteArrayElement(raw) {
+  return `"${raw.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+async function handleGetSchema(db) {
+  const { rows } = await db.query(
+    `SELECT
+       t.table_name,
+       c.column_name,
+       c.data_type,
+       c.is_nullable,
+       c.column_default,
+       CASE WHEN pk.column_name IS NOT NULL THEN true ELSE false END as is_primary_key
+     FROM information_schema.tables t
+     JOIN information_schema.columns c
+       ON t.table_name = c.table_name AND t.table_schema = c.table_schema
+     LEFT JOIN (
+       SELECT ku.column_name, ku.table_name
+       FROM information_schema.table_constraints tc
+       JOIN information_schema.key_column_usage ku
+         ON tc.constraint_name = ku.constraint_name AND tc.table_schema = ku.table_schema
+       WHERE tc.constraint_type = 'PRIMARY KEY' AND tc.table_schema = 'public'
+     ) pk ON pk.table_name = c.table_name AND pk.column_name = c.column_name
+     WHERE t.table_schema = 'public'
+       AND t.table_type = 'BASE TABLE'
+       AND t.table_name NOT LIKE '\\_deleted\\_%'
+     ORDER BY t.table_name, c.ordinal_position`
+  );
+  const tables = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    if (!tables.has(row.table_name)) tables.set(row.table_name, []);
+    const cols = tables.get(row.table_name);
+    cols.push({
+      columnName: row.column_name,
+      dataType: row.data_type,
+      isNullable: row.is_nullable === "YES",
+      columnDefault: row.column_default,
+      isPrimaryKey: row.is_primary_key,
+      position: cols.length
+    });
+  }
+  return success({
+    tables: Array.from(tables, ([tableName, columns]) => ({ tableName, columns }))
+  });
+}
+var FIELD_TYPE_TO_PG = {
+  text: "text",
+  long_text: "text",
+  number: "double precision",
+  boolean: "boolean",
+  date: "date",
+  datetime: "timestamptz",
+  select: "text",
+  multi_select: "jsonb",
+  url: "text",
+  email: "text",
+  phone: "text",
+  currency: "numeric",
+  rating: "integer",
+  relation: "uuid",
+  file_ref: "jsonb",
+  file_refs: "jsonb",
+  json: "jsonb"
+};
+function columnDdl(column) {
+  const pgType = FIELD_TYPE_TO_PG[column.fieldType];
+  if (!pgType) {
+    throw new Error(
+      `Unsupported fieldType "${column.fieldType}" in test simulator. Supported: ${Object.keys(FIELD_TYPE_TO_PG).join(", ")}`
+    );
+  }
+  let ddl = `${quoteIdent(normalizeIdent(column.name))} ${pgType}`;
+  if (column.nullable === false) ddl += " NOT NULL";
+  return ddl;
+}
+async function handleCreateTable(db, body) {
+  const name = normalizeIdent(String(body.name ?? ""));
+  const columns = body.columns ?? [];
+  if (!name) return failure("Table name is required");
+  try {
+    const columnDefs = [
+      `"id" uuid PRIMARY KEY DEFAULT gen_random_uuid()`,
+      ...columns.map(columnDdl),
+      `"created_at" timestamptz NOT NULL DEFAULT now()`,
+      `"updated_at" timestamptz NOT NULL DEFAULT now()`
+    ];
+    await db.exec(`CREATE TABLE ${quoteIdent(name)} (
+  ${columnDefs.join(",\n  ")}
+)`);
+  } catch (error) {
+    return failure(error instanceof Error ? error.message : String(error));
+  }
+  return success({ tableName: name });
+}
+async function handleAddColumn(db, body) {
+  const tableName = normalizeIdent(String(body.tableName ?? ""));
+  const column = body.column;
+  if (!tableName || !column) return failure("tableName and column are required");
+  try {
+    await db.exec(`ALTER TABLE ${quoteIdent(tableName)} ADD COLUMN ${columnDdl(column)}`);
+  } catch (error) {
+    return failure(error instanceof Error ? error.message : String(error));
+  }
+  return success({ columnName: normalizeIdent(column.name) });
+}
+
+// src/pglite/database.ts
+var import_pglite = require("@electric-sql/pglite");
+var import_citext = require("@electric-sql/pglite/contrib/citext");
+var import_pg_trgm = require("@electric-sql/pglite/contrib/pg_trgm");
+var import_pgcrypto = require("@electric-sql/pglite/contrib/pgcrypto");
+var import_uuid_ossp = require("@electric-sql/pglite/contrib/uuid_ossp");
+var identityParsers = null;
+function getIdentityParsers() {
+  if (!identityParsers) {
+    identityParsers = {};
+    const identity = (value) => value;
+    for (let oid = 1; oid <= 13e3; oid++) {
+      identityParsers[oid] = identity;
+    }
+  }
+  return identityParsers;
+}
+
+// src/simulator/neon-proxy.ts
+var BOOL_OID = 16;
+var PG_BOOL_TRUE = /* @__PURE__ */ new Set(["true", "t", "1", "yes", "y", "on"]);
+var PG_BOOL_FALSE = /* @__PURE__ */ new Set(["false", "f", "0", "no", "n", "off"]);
+var neonParamSerializers = {
+  [BOOL_OID]: (value) => {
+    if (typeof value === "boolean") return value ? "t" : "f";
+    const normalized = String(value).trim().toLowerCase();
+    if (PG_BOOL_TRUE.has(normalized)) return "t";
+    if (PG_BOOL_FALSE.has(normalized)) return "f";
+    throw new Error(`Invalid input for boolean type: ${JSON.stringify(value)}`);
+  }
+};
+async function handleNeonSql(db, request) {
+  const body = await request.json();
+  if (body.queries) {
+    return json(
+      {
+        message: "Transactions over the Neon HTTP driver are not supported (matches production neon-http behavior). Use single statements in tests."
+      },
+      400
+    );
+  }
+  if (!body.query) {
+    return json({ message: "Missing query" }, 400);
+  }
+  const arrayMode = (request.headers.get("Neon-Array-Mode") ?? request.headers.get("neon-array-mode")) === "true";
+  try {
+    const result = await db.query(body.query, body.params ?? [], {
+      parsers: getIdentityParsers(),
+      serializers: neonParamSerializers,
+      rowMode: arrayMode ? "array" : "object"
+    });
+    const command = body.query.trim().split(/\s+/)[0]?.toUpperCase() ?? "SELECT";
+    return json({
+      command,
+      rowCount: result.affectedRows || result.rows.length,
+      fields: result.fields.map((f) => ({ name: f.name, dataTypeID: f.dataTypeID })),
+      rows: result.rows,
+      rowAsArray: arrayMode
+    });
+  } catch (error) {
+    const err = error;
+    return json({ message: err.message, code: err.code }, 400);
+  }
+}
+
+// src/simulator/auth.ts
+var import_node_crypto2 = __toESM(require("crypto"));
+function handleAuthVerify(request) {
+  const authHeader = request.headers.get("Authorization");
+  const token = authHeader?.startsWith("Bearer ") ? authHeader.slice(7) : null;
+  const user = token ? state.sessions.get(token) : null;
+  if (!user) {
+    return json({ authenticated: false, user: null }, 401);
+  }
+  return json({ authenticated: true, user });
+}
+function handleAuthRefresh(request) {
+  const authHeader = request.headers.get("Authorization");
+  const refreshToken = authHeader?.startsWith("Bearer ") ? authHeader.slice(7) : null;
+  const user = refreshToken ? state.refreshSessions.get(refreshToken) : null;
+  if (!user || !refreshToken) {
+    return json({ error: "invalid_grant" }, 401);
+  }
+  const accessToken = `test-access-${import_node_crypto2.default.randomUUID()}`;
+  state.sessions.set(accessToken, user);
+  return json({
+    access_token: accessToken,
+    refresh_token: refreshToken,
+    token_type: "Bearer",
+    expires_in: 3600,
+    refresh_token_expires_in: 86400
+  });
+}
+
+// src/simulator/email.ts
+function toArray(value) {
+  if (!value) return [];
+  return Array.isArray(value) ? value.map(String) : [String(value)];
+}
+async function handleEmailSend(request) {
+  const body = await request.json();
+  const from = body.from ?? {};
+  if (!from.name || !from.prefix || !body.to || !body.subject) {
+    return failure("Missing required email fields");
+  }
+  state.emailCounter += 1;
+  const resendId = `test-email-${state.emailCounter}`;
+  const fromAddress = `${from.name} <${from.prefix}@test.stardeck.email>`;
+  const email = {
+    resendId,
+    fromAddress,
+    from: { name: from.name, prefix: from.prefix },
+    to: toArray(body.to),
+    cc: toArray(body.cc),
+    bcc: toArray(body.bcc),
+    subject: String(body.subject),
+    html: body.html ? String(body.html) : void 0,
+    text: body.text ? String(body.text) : void 0,
+    replyTo: body.replyTo ? String(body.replyTo) : void 0,
+    attachments: (body.attachments ?? []).map((a) => ({
+      filename: String(a.filename ?? ""),
+      contentType: a.contentType ? String(a.contentType) : void 0
+    })),
+    sentAt: /* @__PURE__ */ new Date()
+  };
+  state.emails.push(email);
+  return success({ resendId, fromAddress });
+}
+
+// src/simulator/router.ts
+var fetchHolder = globalSingleton("fetch-holder", () => ({
+  originalFetch: null
+}));
+function isLocalHost(hostname) {
+  return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname === "0.0.0.0";
+}
+async function handleSimulatedRequest(request, url) {
+  if (url.pathname === "/sql") {
+    return handleNeonSql(requireDb(), request);
+  }
+  const authMatch = url.pathname.match(/^\/api\/deployments\/[^/]+\/auth\/(verify|refresh)$/);
+  if (authMatch) {
+    return authMatch[1] === "verify" ? handleAuthVerify(request) : handleAuthRefresh(request);
+  }
+  const dataStoreMatch = url.pathname.match(/^\/api\/data-stores\/[^/]+(\/.*)?$/);
+  const isEmail = url.pathname === "/api/email/send";
+  if (dataStoreMatch || isEmail) {
+    const authHeader = request.headers.get("X-Stardeck-Auth");
+    if (!authHeader) {
+      return failure("Missing authentication header", 401);
+    }
+    const secret = process.env.DEPLOYMENT_SECRET;
+    if (!secret || !verifyDeploymentAuthHeader(secret, authHeader)) {
+      return failure("Invalid authentication", 401);
+    }
+  }
+  if (isEmail && request.method === "POST") {
+    return handleEmailSend(request);
+  }
+  if (dataStoreMatch) {
+    const subPath = dataStoreMatch[1] ?? "";
+    const db = requireDb();
+    const readBody = async () => await request.json();
+    if (subPath === "/query" && request.method === "POST") {
+      return handleQuery(db, await readBody());
+    }
+    if (subPath === "/mutate" && request.method === "POST") {
+      return handleMutate(db, await readBody());
+    }
+    if (subPath === "/schema" && request.method === "GET") {
+      return handleGetSchema(db);
+    }
+    if (subPath === "/schema/tables" && request.method === "POST") {
+      return handleCreateTable(db, await readBody());
+    }
+    if (subPath === "/schema/columns" && request.method === "POST") {
+      return handleAddColumn(db, await readBody());
+    }
+  }
+  return failure(
+    `[stardeck-testing] No simulator for ${request.method} ${url.pathname}. Supported: data-store query/mutate/schema, email send, auth verify/refresh, Neon /sql.`,
+    404
+  );
+}
+function installFetchRouter() {
+  if (fetchHolder.originalFetch) return;
+  fetchHolder.originalFetch = globalThis.fetch;
+  globalThis.fetch = async (input, init) => {
+    const request = input instanceof Request ? input : new Request(input, init);
+    const merged = input instanceof Request && init ? new Request(request, init) : request;
+    const url = new URL(merged.url);
+    if (url.hostname.endsWith(TEST_DOMAIN_SUFFIX)) {
+      return handleSimulatedRequest(merged, url);
+    }
+    if (isLocalHost(url.hostname) || state.allowNetwork) {
+      return fetchHolder.originalFetch(merged);
+    }
+    throw new Error(
+      `[stardeck-testing] Blocked outbound request to ${url.origin}${url.pathname}. Tests run offline by default for determinism. If this request is intentional, pass { allowNetwork: true } to createTestApp(), or point the code at a simulated service.`
+    );
+  };
+}
+
+// src/setup.ts
+if (state.db) {
+  const stale = state.db;
+  state.db = null;
+  state.currentUser = null;
+  state.sessions.clear();
+  state.refreshSessions.clear();
+  state.emails = [];
+  state.emailCounter = 0;
+  void stale.close().catch(() => {
+  });
+}
+installFetchRouter();