trickle-backend 0.1.0

package/src/routes/errors.ts

@@ -0,0 +1,91 @@
+import { Router, Request, Response } from "express";
+import { db } from "../db/connection";
+import { listErrors, getError } from "../db/queries";
+
+const router = Router();
+
+// GET / — list errors with filters
+router.get("/", (req: Request, res: Response) => {
+  try {
+    const { functionName, env, since, limit, offset } = req.query;
+
+    const result = listErrors(db, {
+      functionName: functionName as string | undefined,
+      env: env as string | undefined,
+      since: since as string | undefined,
+      limit: limit ? parseInt(limit as string, 10) : undefined,
+      offset: offset ? parseInt(offset as string, 10) : undefined,
+    });
+
+    const parsed = result.rows.map((row: Record<string, unknown>) => ({
+      ...row,
+      args_type: tryParseJson(row.args_type as string),
+      return_type: tryParseJson(row.return_type as string),
+      args_snapshot: tryParseJson(row.args_snapshot as string),
+    }));
+
+    res.json({ errors: parsed, total: result.total });
+  } catch (err) {
+    console.error("List errors error:", err);
+    res.status(500).json({ error: "Internal server error" });
+  }
+});
+
+// GET /:id — get single error with full context
+router.get("/:id", (req: Request, res: Response) => {
+  try {
+    const id = parseInt(req.params.id, 10);
+    if (isNaN(id)) {
+      res.status(400).json({ error: "Invalid error id" });
+      return;
+    }
+
+    const errorRow = getError(db, id);
+    if (!errorRow) {
+      res.status(404).json({ error: "Error not found" });
+      return;
+    }
+
+    // Find the associated type snapshot if type_hash is available
+    let snapshot: Record<string, unknown> | undefined;
+    if (errorRow.type_hash && errorRow.function_id) {
+      const stmt = db.prepare(`
+        SELECT * FROM type_snapshots
+        WHERE function_id = ? AND type_hash = ?
+        ORDER BY observed_at DESC
+        LIMIT 1
+      `);
+      snapshot = stmt.get(errorRow.function_id, errorRow.type_hash) as Record<string, unknown> | undefined;
+    }
+
+    res.json({
+      error: {
+        ...errorRow,
+        args_type: tryParseJson(errorRow.args_type as string),
+        return_type: tryParseJson(errorRow.return_type as string),
+        args_snapshot: tryParseJson(errorRow.args_snapshot as string),
+      },
+      snapshot: snapshot
+        ? {
+            ...snapshot,
+            args_type: tryParseJson(snapshot.args_type as string),
+            return_type: tryParseJson(snapshot.return_type as string),
+          }
+        : null,
+    });
+  } catch (err) {
+    console.error("Get error error:", err);
+    res.status(500).json({ error: "Internal server error" });
+  }
+});
+
+function tryParseJson(value: unknown): unknown {
+  if (typeof value !== "string") return value;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+
+export default router;

package/src/routes/functions.ts

@@ -0,0 +1,75 @@
+import { Router, Request, Response } from "express";
+import { db } from "../db/connection";
+import { listFunctions, getFunction, getLatestSnapshot } from "../db/queries";
+
+const router = Router();
+
+// GET / — list functions
+router.get("/", (req: Request, res: Response) => {
+  try {
+    const { q, env, language, limit, offset } = req.query;
+
+    const result = listFunctions(db, {
+      search: q as string | undefined,
+      env: env as string | undefined,
+      language: language as string | undefined,
+      limit: limit ? parseInt(limit as string, 10) : undefined,
+      offset: offset ? parseInt(offset as string, 10) : undefined,
+    });
+
+    res.json({ functions: result.rows, total: result.total });
+  } catch (err) {
+    console.error("List functions error:", err);
+    res.status(500).json({ error: "Internal server error" });
+  }
+});
+
+// GET /:id — get single function with latest snapshots
+router.get("/:id", (req: Request, res: Response) => {
+  try {
+    const id = parseInt(req.params.id, 10);
+    if (isNaN(id)) {
+      res.status(400).json({ error: "Invalid function id" });
+      return;
+    }
+
+    const func = getFunction(db, id);
+    if (!func) {
+      res.status(404).json({ error: "Function not found" });
+      return;
+    }
+
+    // Get latest snapshots per known env
+    const envStmt = db.prepare(`
+      SELECT DISTINCT env FROM type_snapshots WHERE function_id = ?
+    `);
+    const envs = (envStmt.all(id) as { env: string }[]).map((r) => r.env);
+
+    const latestSnapshots: Record<string, unknown> = {};
+    for (const env of envs) {
+      const snapshot = getLatestSnapshot(db, id, env);
+      if (snapshot) {
+        latestSnapshots[env] = {
+          ...snapshot,
+          args_type: tryParseJson(snapshot.args_type as string),
+          return_type: tryParseJson(snapshot.return_type as string),
+        };
+      }
+    }
+
+    res.json({ function: func, latestSnapshots });
+  } catch (err) {
+    console.error("Get function error:", err);
+    res.status(500).json({ error: "Internal server error" });
+  }
+});
+
+function tryParseJson(value: string): unknown {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+
+export default router;

package/src/routes/ingest.ts

@@ -0,0 +1,139 @@
+import { Router, Request, Response } from "express";
+import { db } from "../db/connection";
+import { upsertFunction, findSnapshotByHash, insertSnapshot, insertError } from "../db/queries";
+import { sseBroker } from "../services/sse-broker";
+import { IngestPayload } from "../types";
+
+const router = Router();
+
+function processPayload(payload: IngestPayload) {
+  const {
+    functionName,
+    module,
+    language,
+    environment,
+    typeHash,
+    argsType,
+    returnType,
+    sampleInput,
+    sampleOutput,
+    error,
+  } = payload;
+
+  const env = environment || "unknown";
+  const func = upsertFunction(db, { functionName, module, environment: env, language });
+  const functionId = func.id as number;
+
+  let isNewType = false;
+  const existingSnapshot = findSnapshotByHash(db, functionId, typeHash, env);
+
+  if (!existingSnapshot) {
+    insertSnapshot(db, {
+      functionId,
+      typeHash,
+      argsType: JSON.stringify(argsType),
+      returnType: JSON.stringify(returnType),
+      variablesType: null as any,
+      sampleInput: sampleInput !== undefined ? JSON.stringify(sampleInput) : null as any,
+      sampleOutput: sampleOutput !== undefined ? JSON.stringify(sampleOutput) : null as any,
+      env,
+    });
+    isNewType = true;
+
+    sseBroker.broadcast("type:new", {
+      functionName,
+      module,
+      typeHash,
+      environment: env,
+    });
+  }
+
+  let errorRecord: Record<string, unknown> | undefined;
+  if (error) {
+    errorRecord = insertError(db, {
+      functionId,
+      errorType: error.type,
+      errorMessage: error.message,
+      stackTrace: error.stackTrace || null as any,
+      argsType: JSON.stringify(argsType),
+      returnType: JSON.stringify(returnType),
+      variablesType: null as any,
+      argsSnapshot: error.argsSnapshot !== undefined ? JSON.stringify(error.argsSnapshot) : null as any,
+      typeHash,
+      env,
+    });
+
+    sseBroker.broadcast("error:new", {
+      functionName,
+      module,
+      errorType: error.type,
+      errorMessage: error.message,
+      environment: env,
+    });
+  }
+
+  return { functionId, isNewType, error: errorRecord };
+}
+
+// POST / — single payload ingest
+router.post("/", (req: Request, res: Response) => {
+  try {
+    const payload = req.body as IngestPayload;
+
+    if (!payload.functionName || !payload.module || !payload.typeHash) {
+      res.status(400).json({ error: "Missing required fields: functionName, module, typeHash" });
+      return;
+    }
+
+    const result = processPayload(payload);
+
+    res.status(200).json({
+      ok: true,
+      functionId: result.functionId,
+      isNewType: result.isNewType,
+      errorId: result.error?.id,
+    });
+  } catch (err) {
+    console.error("Ingest error:", err);
+    res.status(500).json({ error: "Internal server error" });
+  }
+});
+
+// POST /batch — batch ingest
+router.post("/batch", (req: Request, res: Response) => {
+  try {
+    const { payloads } = req.body as { payloads: IngestPayload[] };
+
+    if (!Array.isArray(payloads) || payloads.length === 0) {
+      res.status(400).json({ error: "Expected non-empty payloads array" });
+      return;
+    }
+
+    const results: unknown[] = [];
+
+    const transaction = db.transaction(() => {
+      for (const payload of payloads) {
+        if (!payload.functionName || !payload.module || !payload.typeHash) {
+          results.push({ error: "Missing required fields", functionName: payload.functionName });
+          continue;
+        }
+        const result = processPayload(payload);
+        results.push({
+          ok: true,
+          functionId: result.functionId,
+          isNewType: result.isNewType,
+          errorId: result.error?.id,
+        });
+      }
+    });
+
+    transaction();
+
+    res.status(200).json({ ok: true, results });
+  } catch (err) {
+    console.error("Batch ingest error:", err);
+    res.status(500).json({ error: "Internal server error" });
+  }
+});
+
+export default router;

package/src/routes/mock.ts

@@ -0,0 +1,66 @@
+import { Router, Request, Response } from "express";
+import { db } from "../db/connection";
+import { listFunctions, getLatestSnapshot } from "../db/queries";
+
+const router = Router();
+
+function tryParseJson(value: unknown): unknown {
+  if (typeof value !== "string") return value;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+
+/** Route-style function name → { method, path } */
+function parseRouteName(name: string): { method: string; path: string } | null {
+  const match = name.match(/^(GET|POST|PUT|DELETE|PATCH)\s+(.+)$/i);
+  if (!match) return null;
+  return { method: match[1].toUpperCase(), path: match[2] };
+}
+
+/**
+ * GET /api/mock-config
+ *
+ * Returns all observed routes with their sample data, ready for mock server use.
+ */
+router.get("/", (_req: Request, res: Response) => {
+  try {
+    const { rows } = listFunctions(db, { limit: 500 });
+    const routes: Array<{
+      method: string;
+      path: string;
+      functionName: string;
+      module: string;
+      sampleInput: unknown;
+      sampleOutput: unknown;
+      observedAt: string;
+    }> = [];
+
+    for (const fn of rows) {
+      const parsed = parseRouteName(fn.function_name as string);
+      if (!parsed) continue; // Skip non-route functions
+
+      const snapshot = getLatestSnapshot(db, fn.id as number);
+      if (!snapshot) continue;
+
+      routes.push({
+        method: parsed.method,
+        path: parsed.path,
+        functionName: fn.function_name as string,
+        module: fn.module as string,
+        sampleInput: tryParseJson(snapshot.sample_input),
+        sampleOutput: tryParseJson(snapshot.sample_output),
+        observedAt: snapshot.observed_at as string,
+      });
+    }
+
+    res.json({ routes });
+  } catch (err) {
+    console.error("Mock config error:", err);
+    res.status(500).json({ error: "Internal server error" });
+  }
+});
+
+export default router;

package/src/routes/search.ts

@@ -0,0 +1,169 @@
+import { Router, Request, Response } from "express";
+import { db } from "../db/connection";
+import { listFunctions, getLatestSnapshot } from "../db/queries";
+import { TypeNode } from "../types";
+
+const router = Router();
+
+interface FieldMatch {
+  path: string;
+  kind: string;
+  typeName?: string;
+}
+
+interface SearchResult {
+  functionName: string;
+  module: string;
+  environment: string;
+  lastSeen: string;
+  matches: FieldMatch[];
+}
+
+function tryParseJson(value: string): unknown {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+
+/**
+ * Recursively search a TypeNode tree for fields matching the query.
+ * Returns an array of matching field paths.
+ */
+function searchTypeNode(
+  node: TypeNode,
+  query: string,
+  currentPath: string,
+  results: FieldMatch[],
+): void {
+  const lowerQuery = query.toLowerCase();
+
+  switch (node.kind) {
+    case "object": {
+      for (const [key, val] of Object.entries(node.properties)) {
+        const fieldPath = currentPath ? `${currentPath}.${key}` : key;
+
+        // Check if the field name matches
+        if (key.toLowerCase().includes(lowerQuery)) {
+          results.push({
+            path: fieldPath,
+            kind: val.kind,
+            typeName: val.kind === "primitive" ? (val as { name: string }).name : val.kind,
+          });
+        }
+
+        // Recurse into the value
+        searchTypeNode(val, query, fieldPath, results);
+      }
+      break;
+    }
+    case "array":
+      searchTypeNode(node.element, query, `${currentPath}[]`, results);
+      break;
+    case "union":
+      for (const member of node.members) {
+        searchTypeNode(member, query, currentPath, results);
+      }
+      break;
+    case "tuple":
+      for (let i = 0; i < node.elements.length; i++) {
+        searchTypeNode(node.elements[i], query, `${currentPath}[${i}]`, results);
+      }
+      break;
+    case "promise":
+      searchTypeNode(node.resolved, query, currentPath, results);
+      break;
+    case "map":
+      searchTypeNode(node.key, query, `${currentPath}.key`, results);
+      searchTypeNode(node.value, query, `${currentPath}.value`, results);
+      break;
+    case "set":
+      searchTypeNode(node.element, query, `${currentPath}[]`, results);
+      break;
+    case "primitive": {
+      // Match on primitive type name (e.g., searching "number" finds all number fields)
+      if (node.name.toLowerCase().includes(lowerQuery) && currentPath) {
+        // Only add if not already matched by field name
+        const alreadyMatched = results.some((r) => r.path === currentPath);
+        if (!alreadyMatched) {
+          results.push({
+            path: currentPath,
+            kind: "primitive",
+            typeName: node.name,
+          });
+        }
+      }
+      break;
+    }
+  }
+}
+
+// GET / — search across all observed types
+router.get("/", (req: Request, res: Response) => {
+  try {
+    const query = req.query.q as string;
+    if (!query || query.trim().length === 0) {
+      res.status(400).json({ error: "Missing query parameter 'q'" });
+      return;
+    }
+
+    const env = req.query.env as string | undefined;
+    const lowerQuery = query.toLowerCase();
+
+    // Get all functions
+    const { rows: functionRows } = listFunctions(db, { env, limit: 500 });
+    const results: SearchResult[] = [];
+
+    for (const fn of functionRows) {
+      const functionId = fn.id as number;
+      const functionName = fn.function_name as string;
+      const moduleName = fn.module as string;
+      const environment = (fn.environment as string) || "development";
+      const lastSeen = fn.last_seen_at as string;
+
+      // Check function name match
+      const nameMatches = functionName.toLowerCase().includes(lowerQuery);
+
+      // Get latest snapshot and search types
+      const snapshot = getLatestSnapshot(db, functionId, env);
+      const fieldMatches: FieldMatch[] = [];
+
+      if (snapshot) {
+        const argsType = tryParseJson(snapshot.args_type as string) as TypeNode;
+        const returnType = tryParseJson(snapshot.return_type as string) as TypeNode;
+
+        if (argsType) {
+          searchTypeNode(argsType, query, "args", fieldMatches);
+        }
+        if (returnType) {
+          searchTypeNode(returnType, query, "response", fieldMatches);
+        }
+      }
+
+      // Include if function name matches or any fields match
+      if (nameMatches || fieldMatches.length > 0) {
+        results.push({
+          functionName,
+          module: moduleName,
+          environment,
+          lastSeen,
+          matches: nameMatches && fieldMatches.length === 0
+            ? [{ path: "(function name)", kind: "name", typeName: undefined }]
+            : fieldMatches,
+        });
+      }
+    }
+
+    res.json({
+      query,
+      total: results.length,
+      results,
+    });
+  } catch (err) {
+    console.error("Search error:", err);
+    res.status(500).json({ error: "Internal server error" });
+  }
+});
+
+export default router;

package/src/routes/tail.ts

@@ -0,0 +1,12 @@
+import { Router, Request, Response } from "express";
+import { sseBroker } from "../services/sse-broker";
+
+const router = Router();
+
+// GET / — SSE endpoint
+router.get("/", (req: Request, res: Response) => {
+  const filter = req.query.filter as string | undefined;
+  sseBroker.addClient(res, filter);
+});
+
+export default router;

package/src/routes/types.ts

@@ -0,0 +1,106 @@
+import { Router, Request, Response } from "express";
+import { db } from "../db/connection";
+import { listSnapshots } from "../db/queries";
+import { diffTypes } from "../services/type-differ";
+import { TypeNode } from "../types";
+
+const router = Router();
+
+// GET /:functionId — get type snapshots for a function
+router.get("/:functionId", (req: Request, res: Response) => {
+  try {
+    const functionId = parseInt(req.params.functionId, 10);
+    if (isNaN(functionId)) {
+      res.status(400).json({ error: "Invalid functionId" });
+      return;
+    }
+
+    const { env, limit } = req.query;
+    const snapshots = listSnapshots(db, {
+      functionId,
+      env: env as string | undefined,
+      limit: limit ? parseInt(limit as string, 10) : undefined,
+    });
+
+    const parsed = snapshots.map((s) => ({
+      ...s,
+      args_type: tryParseJson(s.args_type as string),
+      return_type: tryParseJson(s.return_type as string),
+      sample_input: tryParseJson(s.sample_input as string),
+      sample_output: tryParseJson(s.sample_output as string),
+    }));
+
+    res.json({ snapshots: parsed });
+  } catch (err) {
+    console.error("List types error:", err);
+    res.status(500).json({ error: "Internal server error" });
+  }
+});
+
+// GET /:functionId/diff — diff between two snapshots or envs
+router.get("/:functionId/diff", (req: Request, res: Response) => {
+  try {
+    const functionId = parseInt(req.params.functionId, 10);
+    if (isNaN(functionId)) {
+      res.status(400).json({ error: "Invalid functionId" });
+      return;
+    }
+
+    const { from, to, fromEnv, toEnv } = req.query;
+
+    let fromSnapshot: Record<string, unknown> | undefined;
+    let toSnapshot: Record<string, unknown> | undefined;
+
+    if (from && to) {
+      // Diff by snapshot IDs
+      const stmt = db.prepare(`SELECT * FROM type_snapshots WHERE id = ? AND function_id = ?`);
+      fromSnapshot = stmt.get(parseInt(from as string, 10), functionId) as Record<string, unknown> | undefined;
+      toSnapshot = stmt.get(parseInt(to as string, 10), functionId) as Record<string, unknown> | undefined;
+    } else if (fromEnv && toEnv) {
+      // Diff between envs (latest snapshot in each)
+      const stmt = db.prepare(`
+        SELECT * FROM type_snapshots
+        WHERE function_id = ? AND env = ?
+        ORDER BY observed_at DESC
+        LIMIT 1
+      `);
+      fromSnapshot = stmt.get(functionId, fromEnv as string) as Record<string, unknown> | undefined;
+      toSnapshot = stmt.get(functionId, toEnv as string) as Record<string, unknown> | undefined;
+    } else {
+      res.status(400).json({ error: "Provide 'from' and 'to' snapshot IDs, or 'fromEnv' and 'toEnv'" });
+      return;
+    }
+
+    if (!fromSnapshot || !toSnapshot) {
+      res.status(404).json({ error: "One or both snapshots not found" });
+      return;
+    }
+
+    const fromArgs = JSON.parse(fromSnapshot.args_type as string) as TypeNode;
+    const toArgs = JSON.parse(toSnapshot.args_type as string) as TypeNode;
+    const fromReturn = JSON.parse(fromSnapshot.return_type as string) as TypeNode;
+    const toReturn = JSON.parse(toSnapshot.return_type as string) as TypeNode;
+
+    const argsDiff = diffTypes(fromArgs, toArgs, "args");
+    const returnDiff = diffTypes(fromReturn, toReturn, "return");
+
+    res.json({
+      from: { id: fromSnapshot.id, env: fromSnapshot.env, observed_at: fromSnapshot.observed_at },
+      to: { id: toSnapshot.id, env: toSnapshot.env, observed_at: toSnapshot.observed_at },
+      diffs: [...argsDiff, ...returnDiff],
+    });
+  } catch (err) {
+    console.error("Type diff error:", err);
+    res.status(500).json({ error: "Internal server error" });
+  }
+});
+
+function tryParseJson(value: string): unknown {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+
+export default router;

package/src/server.ts

@@ -0,0 +1,40 @@
+import express from "express";
+import cors from "cors";
+
+import ingestRouter from "./routes/ingest";
+import functionsRouter from "./routes/functions";
+import typesRouter from "./routes/types";
+import errorsRouter from "./routes/errors";
+import tailRouter from "./routes/tail";
+import codegenRouter from "./routes/codegen";
+import mockRouter from "./routes/mock";
+import diffRouter from "./routes/diff";
+import dashboardRouter from "./routes/dashboard";
+import coverageRouter from "./routes/coverage";
+import auditRouter from "./routes/audit";
+import searchRouter from "./routes/search";
+
+const app = express();
+
+app.use(cors());
+app.use(express.json({ limit: "5mb" }));
+
+app.use("/api/ingest", ingestRouter);
+app.use("/api/functions", functionsRouter);
+app.use("/api/types", typesRouter);
+app.use("/api/errors", errorsRouter);
+app.use("/api/tail", tailRouter);
+app.use("/api/codegen", codegenRouter);
+app.use("/api/mock-config", mockRouter);
+app.use("/api/diff", diffRouter);
+app.use("/dashboard", dashboardRouter);
+app.use("/api/coverage", coverageRouter);
+app.use("/api/audit", auditRouter);
+app.use("/api/search", searchRouter);
+
+// Health check
+app.get("/api/health", (_req, res) => {
+  res.json({ ok: true, timestamp: new Date().toISOString() });
+});
+
+export { app };