trickle-backend 0.1.0

package/dist/routes/errors.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = require("express");
+const connection_1 = require("../db/connection");
+const queries_1 = require("../db/queries");
+const router = (0, express_1.Router)();
+// GET / — list errors with filters
+router.get("/", (req, res) => {
+    try {
+        const { functionName, env, since, limit, offset } = req.query;
+        const result = (0, queries_1.listErrors)(connection_1.db, {
+            functionName: functionName,
+            env: env,
+            since: since,
+            limit: limit ? parseInt(limit, 10) : undefined,
+            offset: offset ? parseInt(offset, 10) : undefined,
+        });
+        const parsed = result.rows.map((row) => ({
+            ...row,
+            args_type: tryParseJson(row.args_type),
+            return_type: tryParseJson(row.return_type),
+            args_snapshot: tryParseJson(row.args_snapshot),
+        }));
+        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, res) => {
+    try {
+        const id = parseInt(req.params.id, 10);
+        if (isNaN(id)) {
+            res.status(400).json({ error: "Invalid error id" });
+            return;
+        }
+        const errorRow = (0, queries_1.getError)(connection_1.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;
+        if (errorRow.type_hash && errorRow.function_id) {
+            const stmt = connection_1.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);
+        }
+        res.json({
+            error: {
+                ...errorRow,
+                args_type: tryParseJson(errorRow.args_type),
+                return_type: tryParseJson(errorRow.return_type),
+                args_snapshot: tryParseJson(errorRow.args_snapshot),
+            },
+            snapshot: snapshot
+                ? {
+                    ...snapshot,
+                    args_type: tryParseJson(snapshot.args_type),
+                    return_type: tryParseJson(snapshot.return_type),
+                }
+                : null,
+        });
+    }
+    catch (err) {
+        console.error("Get error error:", err);
+        res.status(500).json({ error: "Internal server error" });
+    }
+});
+function tryParseJson(value) {
+    if (typeof value !== "string")
+        return value;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}
+exports.default = router;

package/dist/routes/functions.d.ts

@@ -0,0 +1,2 @@
+declare const router: import("express-serve-static-core").Router;
+export default router;

package/dist/routes/functions.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = require("express");
+const connection_1 = require("../db/connection");
+const queries_1 = require("../db/queries");
+const router = (0, express_1.Router)();
+// GET / — list functions
+router.get("/", (req, res) => {
+    try {
+        const { q, env, language, limit, offset } = req.query;
+        const result = (0, queries_1.listFunctions)(connection_1.db, {
+            search: q,
+            env: env,
+            language: language,
+            limit: limit ? parseInt(limit, 10) : undefined,
+            offset: offset ? parseInt(offset, 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, res) => {
+    try {
+        const id = parseInt(req.params.id, 10);
+        if (isNaN(id)) {
+            res.status(400).json({ error: "Invalid function id" });
+            return;
+        }
+        const func = (0, queries_1.getFunction)(connection_1.db, id);
+        if (!func) {
+            res.status(404).json({ error: "Function not found" });
+            return;
+        }
+        // Get latest snapshots per known env
+        const envStmt = connection_1.db.prepare(`
+      SELECT DISTINCT env FROM type_snapshots WHERE function_id = ?
+    `);
+        const envs = envStmt.all(id).map((r) => r.env);
+        const latestSnapshots = {};
+        for (const env of envs) {
+            const snapshot = (0, queries_1.getLatestSnapshot)(connection_1.db, id, env);
+            if (snapshot) {
+                latestSnapshots[env] = {
+                    ...snapshot,
+                    args_type: tryParseJson(snapshot.args_type),
+                    return_type: tryParseJson(snapshot.return_type),
+                };
+            }
+        }
+        res.json({ function: func, latestSnapshots });
+    }
+    catch (err) {
+        console.error("Get function error:", err);
+        res.status(500).json({ error: "Internal server error" });
+    }
+});
+function tryParseJson(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}
+exports.default = router;

package/dist/routes/ingest.d.ts

@@ -0,0 +1,2 @@
+declare const router: import("express-serve-static-core").Router;
+export default router;

package/dist/routes/ingest.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = require("express");
+const connection_1 = require("../db/connection");
+const queries_1 = require("../db/queries");
+const sse_broker_1 = require("../services/sse-broker");
+const router = (0, express_1.Router)();
+function processPayload(payload) {
+    const { functionName, module, language, environment, typeHash, argsType, returnType, sampleInput, sampleOutput, error, } = payload;
+    const env = environment || "unknown";
+    const func = (0, queries_1.upsertFunction)(connection_1.db, { functionName, module, environment: env, language });
+    const functionId = func.id;
+    let isNewType = false;
+    const existingSnapshot = (0, queries_1.findSnapshotByHash)(connection_1.db, functionId, typeHash, env);
+    if (!existingSnapshot) {
+        (0, queries_1.insertSnapshot)(connection_1.db, {
+            functionId,
+            typeHash,
+            argsType: JSON.stringify(argsType),
+            returnType: JSON.stringify(returnType),
+            variablesType: null,
+            sampleInput: sampleInput !== undefined ? JSON.stringify(sampleInput) : null,
+            sampleOutput: sampleOutput !== undefined ? JSON.stringify(sampleOutput) : null,
+            env,
+        });
+        isNewType = true;
+        sse_broker_1.sseBroker.broadcast("type:new", {
+            functionName,
+            module,
+            typeHash,
+            environment: env,
+        });
+    }
+    let errorRecord;
+    if (error) {
+        errorRecord = (0, queries_1.insertError)(connection_1.db, {
+            functionId,
+            errorType: error.type,
+            errorMessage: error.message,
+            stackTrace: error.stackTrace || null,
+            argsType: JSON.stringify(argsType),
+            returnType: JSON.stringify(returnType),
+            variablesType: null,
+            argsSnapshot: error.argsSnapshot !== undefined ? JSON.stringify(error.argsSnapshot) : null,
+            typeHash,
+            env,
+        });
+        sse_broker_1.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, res) => {
+    try {
+        const payload = req.body;
+        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, res) => {
+    try {
+        const { payloads } = req.body;
+        if (!Array.isArray(payloads) || payloads.length === 0) {
+            res.status(400).json({ error: "Expected non-empty payloads array" });
+            return;
+        }
+        const results = [];
+        const transaction = connection_1.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" });
+    }
+});
+exports.default = router;

package/dist/routes/mock.d.ts

@@ -0,0 +1,2 @@
+declare const router: import("express-serve-static-core").Router;
+export default router;

package/dist/routes/mock.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = require("express");
+const connection_1 = require("../db/connection");
+const queries_1 = require("../db/queries");
+const router = (0, express_1.Router)();
+function tryParseJson(value) {
+    if (typeof value !== "string")
+        return value;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}
+/** Route-style function name → { method, path } */
+function parseRouteName(name) {
+    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, res) => {
+    try {
+        const { rows } = (0, queries_1.listFunctions)(connection_1.db, { limit: 500 });
+        const routes = [];
+        for (const fn of rows) {
+            const parsed = parseRouteName(fn.function_name);
+            if (!parsed)
+                continue; // Skip non-route functions
+            const snapshot = (0, queries_1.getLatestSnapshot)(connection_1.db, fn.id);
+            if (!snapshot)
+                continue;
+            routes.push({
+                method: parsed.method,
+                path: parsed.path,
+                functionName: fn.function_name,
+                module: fn.module,
+                sampleInput: tryParseJson(snapshot.sample_input),
+                sampleOutput: tryParseJson(snapshot.sample_output),
+                observedAt: snapshot.observed_at,
+            });
+        }
+        res.json({ routes });
+    }
+    catch (err) {
+        console.error("Mock config error:", err);
+        res.status(500).json({ error: "Internal server error" });
+    }
+});
+exports.default = router;

package/dist/routes/search.d.ts

@@ -0,0 +1,2 @@
+declare const router: import("express-serve-static-core").Router;
+export default router;

package/dist/routes/search.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = require("express");
+const connection_1 = require("../db/connection");
+const queries_1 = require("../db/queries");
+const router = (0, express_1.Router)();
+function tryParseJson(value) {
+    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, query, currentPath, results) {
+    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.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, res) => {
+    try {
+        const query = req.query.q;
+        if (!query || query.trim().length === 0) {
+            res.status(400).json({ error: "Missing query parameter 'q'" });
+            return;
+        }
+        const env = req.query.env;
+        const lowerQuery = query.toLowerCase();
+        // Get all functions
+        const { rows: functionRows } = (0, queries_1.listFunctions)(connection_1.db, { env, limit: 500 });
+        const results = [];
+        for (const fn of functionRows) {
+            const functionId = fn.id;
+            const functionName = fn.function_name;
+            const moduleName = fn.module;
+            const environment = fn.environment || "development";
+            const lastSeen = fn.last_seen_at;
+            // Check function name match
+            const nameMatches = functionName.toLowerCase().includes(lowerQuery);
+            // Get latest snapshot and search types
+            const snapshot = (0, queries_1.getLatestSnapshot)(connection_1.db, functionId, env);
+            const fieldMatches = [];
+            if (snapshot) {
+                const argsType = tryParseJson(snapshot.args_type);
+                const returnType = tryParseJson(snapshot.return_type);
+                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" });
+    }
+});
+exports.default = router;

package/dist/routes/tail.d.ts

@@ -0,0 +1,2 @@
+declare const router: import("express-serve-static-core").Router;
+export default router;

package/dist/routes/tail.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = require("express");
+const sse_broker_1 = require("../services/sse-broker");
+const router = (0, express_1.Router)();
+// GET / — SSE endpoint
+router.get("/", (req, res) => {
+    const filter = req.query.filter;
+    sse_broker_1.sseBroker.addClient(res, filter);
+});
+exports.default = router;

package/dist/routes/types.d.ts

@@ -0,0 +1,2 @@
+declare const router: import("express-serve-static-core").Router;
+export default router;

package/dist/routes/types.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = require("express");
+const connection_1 = require("../db/connection");
+const queries_1 = require("../db/queries");
+const type_differ_1 = require("../services/type-differ");
+const router = (0, express_1.Router)();
+// GET /:functionId — get type snapshots for a function
+router.get("/:functionId", (req, res) => {
+    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 = (0, queries_1.listSnapshots)(connection_1.db, {
+            functionId,
+            env: env,
+            limit: limit ? parseInt(limit, 10) : undefined,
+        });
+        const parsed = snapshots.map((s) => ({
+            ...s,
+            args_type: tryParseJson(s.args_type),
+            return_type: tryParseJson(s.return_type),
+            sample_input: tryParseJson(s.sample_input),
+            sample_output: tryParseJson(s.sample_output),
+        }));
+        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, res) => {
+    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;
+        let toSnapshot;
+        if (from && to) {
+            // Diff by snapshot IDs
+            const stmt = connection_1.db.prepare(`SELECT * FROM type_snapshots WHERE id = ? AND function_id = ?`);
+            fromSnapshot = stmt.get(parseInt(from, 10), functionId);
+            toSnapshot = stmt.get(parseInt(to, 10), functionId);
+        }
+        else if (fromEnv && toEnv) {
+            // Diff between envs (latest snapshot in each)
+            const stmt = connection_1.db.prepare(`
+        SELECT * FROM type_snapshots
+        WHERE function_id = ? AND env = ?
+        ORDER BY observed_at DESC
+        LIMIT 1
+      `);
+            fromSnapshot = stmt.get(functionId, fromEnv);
+            toSnapshot = stmt.get(functionId, toEnv);
+        }
+        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);
+        const toArgs = JSON.parse(toSnapshot.args_type);
+        const fromReturn = JSON.parse(fromSnapshot.return_type);
+        const toReturn = JSON.parse(toSnapshot.return_type);
+        const argsDiff = (0, type_differ_1.diffTypes)(fromArgs, toArgs, "args");
+        const returnDiff = (0, type_differ_1.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) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}
+exports.default = router;

package/dist/server.d.ts

@@ -0,0 +1,2 @@
+declare const app: import("express-serve-static-core").Express;
+export { app };

package/dist/server.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.app = void 0;
+const express_1 = __importDefault(require("express"));
+const cors_1 = __importDefault(require("cors"));
+const ingest_1 = __importDefault(require("./routes/ingest"));
+const functions_1 = __importDefault(require("./routes/functions"));
+const types_1 = __importDefault(require("./routes/types"));
+const errors_1 = __importDefault(require("./routes/errors"));
+const tail_1 = __importDefault(require("./routes/tail"));
+const codegen_1 = __importDefault(require("./routes/codegen"));
+const mock_1 = __importDefault(require("./routes/mock"));
+const diff_1 = __importDefault(require("./routes/diff"));
+const dashboard_1 = __importDefault(require("./routes/dashboard"));
+const coverage_1 = __importDefault(require("./routes/coverage"));
+const audit_1 = __importDefault(require("./routes/audit"));
+const search_1 = __importDefault(require("./routes/search"));
+const app = (0, express_1.default)();
+exports.app = app;
+app.use((0, cors_1.default)());
+app.use(express_1.default.json({ limit: "5mb" }));
+app.use("/api/ingest", ingest_1.default);
+app.use("/api/functions", functions_1.default);
+app.use("/api/types", types_1.default);
+app.use("/api/errors", errors_1.default);
+app.use("/api/tail", tail_1.default);
+app.use("/api/codegen", codegen_1.default);
+app.use("/api/mock-config", mock_1.default);
+app.use("/api/diff", diff_1.default);
+app.use("/dashboard", dashboard_1.default);
+app.use("/api/coverage", coverage_1.default);
+app.use("/api/audit", audit_1.default);
+app.use("/api/search", search_1.default);
+// Health check
+app.get("/api/health", (_req, res) => {
+    res.json({ ok: true, timestamp: new Date().toISOString() });
+});

package/dist/services/sse-broker.d.ts

@@ -0,0 +1,10 @@
+import { EventEmitter } from "events";
+import { Response } from "express";
+declare class SseBroker extends EventEmitter {
+    private clients;
+    addClient(res: Response, filter?: string): void;
+    removeClient(res: Response): void;
+    broadcast(event: string, data: unknown): void;
+}
+export declare const sseBroker: SseBroker;
+export {};