trickle-backend 0.1.0

package/dist/routes/codegen.js

@@ -0,0 +1,224 @@
+"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_generator_1 = require("../services/type-generator");
+const router = (0, express_1.Router)();
+function tryParseJson(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}
+/**
+ * Collect type data for all matching functions.
+ */
+function collectFunctionTypes(opts) {
+    const results = [];
+    let functionRows;
+    if (opts.functionName) {
+        functionRows = (0, queries_1.getFunctionByName)(connection_1.db, opts.functionName);
+    }
+    else {
+        const listed = (0, queries_1.listFunctions)(connection_1.db, {
+            env: opts.env,
+            limit: 500,
+        });
+        functionRows = listed.rows;
+    }
+    for (const fn of functionRows) {
+        const functionId = fn.id;
+        const functionName = fn.function_name;
+        const moduleName = fn.module;
+        const environment = fn.environment || undefined;
+        const snapshot = (0, queries_1.getLatestSnapshot)(connection_1.db, functionId, opts.env);
+        if (!snapshot)
+            continue;
+        const argsType = tryParseJson(snapshot.args_type);
+        const returnType = tryParseJson(snapshot.return_type);
+        if (!argsType || !returnType)
+            continue;
+        results.push({
+            name: functionName,
+            argsType,
+            returnType,
+            module: moduleName,
+            env: snapshot.env || environment,
+            observedAt: snapshot.observed_at,
+        });
+    }
+    return results;
+}
+// GET / — generate types for all (or filtered) functions
+router.get("/", (req, res) => {
+    try {
+        const { functionName, env, language } = req.query;
+        const functions = collectFunctionTypes({
+            functionName: functionName,
+            env: env,
+        });
+        if (functions.length === 0) {
+            res.json({ types: "// No functions found matching the given filters.\n" });
+            return;
+        }
+        const format = req.query.format?.toLowerCase();
+        const isPython = language?.toLowerCase() === "python";
+        if (format === "snapshot") {
+            // Return raw type data as a portable JSON snapshot for `trickle check`
+            const snapshot = {
+                version: 1,
+                createdAt: new Date().toISOString(),
+                functions: functions.map((f) => ({
+                    name: f.name,
+                    module: f.module,
+                    env: f.env,
+                    argsType: f.argsType,
+                    returnType: f.returnType,
+                })),
+            };
+            res.json(snapshot);
+            return;
+        }
+        if (format === "openapi") {
+            const title = req.query.title || undefined;
+            const version = req.query.version || undefined;
+            const serverUrl = req.query.serverUrl || undefined;
+            const spec = (0, type_generator_1.generateOpenApiSpec)(functions, { title, version, serverUrl });
+            res.json(spec);
+            return;
+        }
+        let types;
+        if (format === "handlers") {
+            types = (0, type_generator_1.generateHandlerTypes)(functions);
+            res.json({ types });
+            return;
+        }
+        else if (format === "zod") {
+            types = (0, type_generator_1.generateZodSchemas)(functions);
+            res.json({ types });
+            return;
+        }
+        else if (format === "react-query") {
+            types = (0, type_generator_1.generateReactQueryHooks)(functions);
+            res.json({ types });
+            return;
+        }
+        else if (format === "guards") {
+            types = (0, type_generator_1.generateTypeGuards)(functions);
+            res.json({ types });
+            return;
+        }
+        else if (format === "middleware") {
+            types = (0, type_generator_1.generateMiddleware)(functions);
+            res.json({ types });
+            return;
+        }
+        else if (format === "msw") {
+            types = (0, type_generator_1.generateMswHandlers)(functions);
+            res.json({ types });
+            return;
+        }
+        else if (format === "json-schema") {
+            types = (0, type_generator_1.generateJsonSchemas)(functions);
+            res.json({ types });
+            return;
+        }
+        else if (format === "swr") {
+            types = (0, type_generator_1.generateSwrHooks)(functions);
+            res.json({ types });
+            return;
+        }
+        else if (format === "pydantic") {
+            types = (0, type_generator_1.generatePydanticModels)(functions);
+            res.json({ types });
+            return;
+        }
+        else if (format === "class-validator") {
+            types = (0, type_generator_1.generateClassValidatorDtos)(functions);
+            res.json({ types });
+            return;
+        }
+        else if (format === "graphql") {
+            types = (0, type_generator_1.generateGraphqlSchema)(functions);
+            res.json({ types });
+            return;
+        }
+        else if (format === "trpc") {
+            types = (0, type_generator_1.generateTrpcRouter)(functions);
+            res.json({ types });
+            return;
+        }
+        else if (format === "axios") {
+            types = (0, type_generator_1.generateAxiosClient)(functions);
+            res.json({ types });
+            return;
+        }
+        else if (format === "annotate") {
+            const lang = language?.toLowerCase() === "python" ? "python" : "typescript";
+            const annotations = (0, type_generator_1.generateInlineAnnotations)(functions, lang);
+            res.json({ annotations });
+            return;
+        }
+        else if (format === "stubs") {
+            // Group functions by module and return per-module type stubs
+            const byModule = {};
+            for (const fn of functions) {
+                const mod = fn.module || "_default";
+                if (!byModule[mod])
+                    byModule[mod] = [];
+                byModule[mod].push(fn);
+            }
+            const stubs = {};
+            for (const [mod, fns] of Object.entries(byModule)) {
+                stubs[mod] = {
+                    ts: (0, type_generator_1.generateAllTypes)(fns),
+                    python: (0, type_generator_1.generatePythonTypes)(fns),
+                };
+            }
+            res.json({ stubs });
+            return;
+        }
+        else if (format === "client") {
+            types = (0, type_generator_1.generateApiClient)(functions);
+        }
+        else if (isPython) {
+            types = (0, type_generator_1.generatePythonTypes)(functions);
+        }
+        else {
+            types = (0, type_generator_1.generateAllTypes)(functions);
+        }
+        res.json({ types });
+    }
+    catch (err) {
+        console.error("Codegen error:", err);
+        res.status(500).json({ error: "Internal server error" });
+    }
+});
+// GET /:functionName — generate types for a specific function
+router.get("/:functionName", (req, res) => {
+    try {
+        const { functionName } = req.params;
+        const { env, language } = req.query;
+        const functions = collectFunctionTypes({
+            functionName,
+            env: env,
+        });
+        if (functions.length === 0) {
+            res.status(404).json({ error: `No function found matching "${functionName}"` });
+            return;
+        }
+        const isPython = language?.toLowerCase() === "python";
+        const types = isPython
+            ? (0, type_generator_1.generatePythonTypes)(functions)
+            : (0, type_generator_1.generateAllTypes)(functions);
+        res.json({ types });
+    }
+    catch (err) {
+        console.error("Codegen error:", err);
+        res.status(500).json({ error: "Internal server error" });
+    }
+});
+exports.default = router;

package/dist/routes/coverage.d.ts

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

package/dist/routes/coverage.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = require("express");
+const connection_1 = require("../db/connection");
+const router = (0, express_1.Router)();
+/**
+ * GET /api/coverage — Type observation coverage report.
+ *
+ * Returns per-function stats: snapshot count, variant count,
+ * freshness, error count, and an overall health score.
+ */
+router.get("/", (req, res) => {
+    try {
+        const { env, stale_hours } = req.query;
+        const staleThresholdHours = stale_hours ? parseInt(stale_hours, 10) : 24;
+        // Get all functions
+        let functionsQuery = `SELECT * FROM functions`;
+        const params = [];
+        if (env) {
+            functionsQuery += ` WHERE environment = ?`;
+            params.push(env);
+        }
+        functionsQuery += ` ORDER BY last_seen_at DESC`;
+        const functions = connection_1.db.prepare(functionsQuery).all(...params);
+        // Per-function stats
+        const snapshotCountStmt = connection_1.db.prepare(`SELECT COUNT(*) as count FROM type_snapshots WHERE function_id = ?`);
+        const variantCountStmt = connection_1.db.prepare(`SELECT COUNT(DISTINCT type_hash) as count FROM type_snapshots WHERE function_id = ?`);
+        const errorCountStmt = connection_1.db.prepare(`SELECT COUNT(*) as count FROM errors WHERE function_id = ?`);
+        const latestSnapshotStmt = connection_1.db.prepare(`SELECT observed_at FROM type_snapshots WHERE function_id = ? ORDER BY observed_at DESC LIMIT 1`);
+        const now = new Date();
+        const staleThreshold = new Date(now.getTime() - staleThresholdHours * 60 * 60 * 1000);
+        const entries = functions.map((fn) => {
+            const snapshots = snapshotCountStmt.get(fn.id).count;
+            const variants = variantCountStmt.get(fn.id).count;
+            const errors = errorCountStmt.get(fn.id).count;
+            const latestRow = latestSnapshotStmt.get(fn.id);
+            const lastObserved = latestRow ? latestRow.observed_at : fn.last_seen_at;
+            const lastObservedDate = new Date(lastObserved);
+            const isStale = lastObservedDate < staleThreshold;
+            const hasTypes = snapshots > 0;
+            const hasMultipleVariants = variants > 1;
+            const hasErrors = errors > 0;
+            // Per-function health: 0-100
+            let health = 0;
+            if (hasTypes)
+                health += 60; // Has type observations
+            if (!isStale)
+                health += 20; // Recently observed
+            if (!hasErrors)
+                health += 10; // No errors
+            if (!hasMultipleVariants)
+                health += 10; // Consistent types (single variant)
+            return {
+                functionName: fn.function_name,
+                module: fn.module,
+                language: fn.language,
+                environment: fn.environment,
+                firstSeen: fn.first_seen_at,
+                lastObserved,
+                snapshots,
+                variants,
+                errors,
+                isStale,
+                hasTypes,
+                health,
+            };
+        });
+        // Aggregate stats
+        const total = entries.length;
+        const withTypes = entries.filter((e) => e.hasTypes).length;
+        const staleCount = entries.filter((e) => e.isStale).length;
+        const freshCount = entries.filter((e) => !e.isStale).length;
+        const withErrors = entries.filter((e) => e.errors > 0).length;
+        const withMultipleVariants = entries.filter((e) => e.variants > 1).length;
+        const overallHealth = total > 0
+            ? Math.round(entries.reduce((sum, e) => sum + e.health, 0) / total)
+            : 0;
+        res.json({
+            summary: {
+                total,
+                withTypes,
+                withoutTypes: total - withTypes,
+                fresh: freshCount,
+                stale: staleCount,
+                withErrors,
+                withMultipleVariants,
+                health: overallHealth,
+                staleThresholdHours,
+            },
+            entries,
+        });
+    }
+    catch (err) {
+        console.error("Coverage error:", err);
+        res.status(500).json({ error: "Internal server error" });
+    }
+});
+exports.default = router;

package/dist/routes/dashboard.d.ts

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