@stardeck-customer-apps/testing 0.1.1

package/dist/index.mjs

@@ -0,0 +1,878 @@
+// src/test-app.ts
+import crypto3 from "crypto";
+import { readFileSync, existsSync } from "fs";
+import { resolve } from "path";
+
+// src/pglite/database.ts
+import { PGlite } from "@electric-sql/pglite";
+import { citext } from "@electric-sql/pglite/contrib/citext";
+import { pg_trgm } from "@electric-sql/pglite/contrib/pg_trgm";
+import { pgcrypto } from "@electric-sql/pglite/contrib/pgcrypto";
+import { uuid_ossp } from "@electric-sql/pglite/contrib/uuid_ossp";
+async function createPgliteDatabase() {
+  const db = new PGlite({
+    extensions: { pg_trgm, pgcrypto, uuid_ossp, citext }
+  });
+  await db.waitReady;
+  return db;
+}
+async function applySchema(db, schemaSql) {
+  const trimmed = schemaSql.trim();
+  if (!trimmed) return;
+  await db.exec(trimmed);
+}
+async function dropAllTables(db) {
+  await db.exec(`DROP SCHEMA public CASCADE; CREATE SCHEMA public;`);
+}
+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/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`
+};
+var DEFAULT_TEST_USER = {
+  id: "test-user-1",
+  email: "test-user@example.com",
+  name: "Test User",
+  role: "member",
+  permissions: []
+};
+var DEFAULT_SCHEMA_PATH = "./src/generated/data-store-schema.sql";
+
+// src/simulator/hmac.ts
+import crypto from "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 = crypto.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 || !crypto.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/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
+import crypto2 from "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-${crypto2.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 });
+}
+function createInbox() {
+  return {
+    all: () => [...state.emails],
+    to: (address) => state.emails.filter(
+      (e) => e.to.includes(address) || e.cc.includes(address) || e.bcc.includes(address)
+    ),
+    latest: (address) => {
+      const pool = address ? state.emails.filter(
+        (e) => e.to.includes(address) || e.cc.includes(address) || e.bcc.includes(address)
+      ) : state.emails;
+      return pool[pool.length - 1];
+    },
+    clear: () => {
+      state.emails = [];
+    },
+    get count() {
+      return state.emails.length;
+    }
+  };
+}
+
+// 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.`
+    );
+  };
+}
+function uninstallFetchRouter() {
+  if (fetchHolder.originalFetch) {
+    globalThis.fetch = fetchHolder.originalFetch;
+    fetchHolder.originalFetch = null;
+  }
+}
+
+// src/test-app.ts
+function applyTestEnv() {
+  for (const [key, value] of Object.entries(TEST_ENV_DEFAULTS)) {
+    process.env[key] = value;
+  }
+  delete process.env.DISABLE_AUTH;
+  delete process.env.NEXT_PUBLIC_DISABLE_AUTH;
+  delete process.env.SANDBOX_MODE;
+}
+function buildUser(partial) {
+  return {
+    ...DEFAULT_TEST_USER,
+    organizationId: process.env.ORGANIZATION_ID ?? null,
+    projectId: process.env.PROJECT_ID ?? null,
+    ...partial
+  };
+}
+function loadSchemaSql(options) {
+  if (options.schemaSql !== void 0) return options.schemaSql;
+  if (options.schema === null) return null;
+  const schemaPath = resolve(process.cwd(), options.schema ?? DEFAULT_SCHEMA_PATH);
+  if (!existsSync(schemaPath)) {
+    if (options.schema) {
+      throw new Error(
+        `[stardeck-testing] Schema snapshot not found at ${schemaPath}. Run \`npx stardeck-data-store generate-types\` to regenerate it.`
+      );
+    }
+    return null;
+  }
+  return readFileSync(schemaPath, "utf-8");
+}
+async function createTestApp(options = {}) {
+  if (state.db) {
+    throw new Error(
+      "[stardeck-testing] A test app is already active in this test file. Call `app.close()` first, or share one app per file."
+    );
+  }
+  applyTestEnv();
+  state.allowNetwork = options.allowNetwork ?? false;
+  installFetchRouter();
+  const db = await createPgliteDatabase();
+  state.db = db;
+  const initialize = async () => {
+    const schemaSql = loadSchemaSql(options);
+    if (schemaSql) await applySchema(db, schemaSql);
+    if (options.seed) await options.seed(db);
+  };
+  try {
+    await initialize();
+  } catch (error) {
+    state.db = null;
+    await db.close().catch(() => {
+    });
+    throw error;
+  }
+  const inbox = createInbox();
+  const app = {
+    db,
+    inbox,
+    async query(sql, params = []) {
+      const result = await db.query(sql, params);
+      return result.rows;
+    },
+    asUser(user) {
+      const fullUser = buildUser(user);
+      state.currentUser = fullUser;
+      return fullUser;
+    },
+    signOut() {
+      state.currentUser = null;
+    },
+    issueSession(user) {
+      const fullUser = buildUser(user);
+      const tokens = {
+        accessToken: `test-access-${crypto3.randomUUID()}`,
+        refreshToken: `test-refresh-${crypto3.randomUUID()}`
+      };
+      state.sessions.set(tokens.accessToken, fullUser);
+      state.refreshSessions.set(tokens.refreshToken, fullUser);
+      return tokens;
+    },
+    async reset() {
+      await dropAllTables(db);
+      await initialize();
+      state.currentUser = null;
+      state.sessions.clear();
+      state.refreshSessions.clear();
+      state.emails = [];
+      state.emailCounter = 0;
+    },
+    async close() {
+      state.db = null;
+      state.currentUser = null;
+      state.sessions.clear();
+      state.refreshSessions.clear();
+      state.emails = [];
+      uninstallFetchRouter();
+      await db.close();
+    }
+  };
+  return app;
+}
+
+// src/next/headers-shim.ts
+import { AsyncLocalStorage } from "async_hooks";
+var requestScopeStorage = globalSingleton(
+  "request-scope",
+  () => new AsyncLocalStorage()
+);
+
+// src/next/call-route.ts
+function parseCookieHeader(header) {
+  const map = /* @__PURE__ */ new Map();
+  if (!header) return map;
+  for (const part of header.split(";")) {
+    const eq = part.indexOf("=");
+    if (eq === -1) continue;
+    map.set(part.slice(0, eq).trim(), part.slice(eq + 1).trim());
+  }
+  return map;
+}
+async function importNextServer() {
+  try {
+    return await import("next/server.js");
+  } catch {
+    return await import("next/server");
+  }
+}
+async function callRoute(handler, options = {}) {
+  const { NextRequest } = await importNextServer();
+  const path = options.path ?? "/api/test-route";
+  const url = new URL(`http://localhost:3333${path}`);
+  for (const [key, value] of Object.entries(options.searchParams ?? {})) {
+    url.searchParams.set(key, value);
+  }
+  const method = options.method ?? (options.body !== void 0 ? "POST" : "GET");
+  const headers = new Headers(options.headers);
+  const user = options.user !== void 0 ? options.user : state.currentUser;
+  if (user && !headers.has("x-stardeck-user")) {
+    headers.set("x-stardeck-user", JSON.stringify(user));
+  }
+  if (options.body !== void 0 && !headers.has("Content-Type")) {
+    headers.set("Content-Type", "application/json");
+  }
+  const cookiePairs = Object.entries(options.cookies ?? {});
+  if (cookiePairs.length > 0) {
+    const existing = headers.get("cookie");
+    const cookieString = cookiePairs.map(([k, v]) => `${k}=${v}`).join("; ");
+    headers.set("cookie", existing ? `${existing}; ${cookieString}` : cookieString);
+  }
+  const request = new NextRequest(url, {
+    method,
+    headers,
+    body: options.body !== void 0 ? JSON.stringify(options.body) : void 0
+  });
+  const scope = {
+    headers,
+    cookies: parseCookieHeader(headers.get("cookie"))
+  };
+  try {
+    return await requestScopeStorage.run(
+      scope,
+      () => Promise.resolve(
+        handler(request, {
+          params: Promise.resolve(options.params ?? {})
+        })
+      )
+    );
+  } catch (error) {
+    const redirect = decodeNextRedirect(error);
+    if (redirect) return redirect;
+    throw error;
+  }
+}
+function decodeNextRedirect(error) {
+  const digest = error?.digest;
+  if (typeof digest !== "string" || !digest.startsWith("NEXT_REDIRECT")) return null;
+  const parts = digest.split(";");
+  const location = parts[2] ?? "/";
+  const status = Number(parts[3]) || 307;
+  return new Response(null, { status, headers: { location } });
+}
+
+// src/workflow.ts
+import { describe } from "vitest";
+function describeWorkflow(name, fn) {
+  describe(`workflow:${name}`, fn);
+}
+var WORKFLOW_NAME_PREFIX = "workflow:";
+function parseWorkflowName(describeTitle) {
+  return describeTitle.startsWith(WORKFLOW_NAME_PREFIX) ? describeTitle.slice(WORKFLOW_NAME_PREFIX.length) : null;
+}
+export {
+  CONTROL_PLANE_TEST_URL,
+  DATA_STORE_TEST_HOST,
+  DEFAULT_SCHEMA_PATH,
+  TEST_ENV_DEFAULTS,
+  WORKFLOW_NAME_PREFIX,
+  callRoute,
+  createTestApp,
+  describeWorkflow,
+  parseWorkflowName
+};