bunsane 0.3.1 → 0.4.0

package/core/app/requestRouter.ts

@@ -0,0 +1,310 @@
+import * as path from "path";
+import { logger as MainLogger } from "../Logger";
+import { getMetadataScript } from "../metadata";
+import { addCorsHeaders, getCorsHeaders } from "./cors";
+import {
+    handleHealth,
+    handleReady,
+    handleRemoteHealth,
+} from "./healthEndpoints";
+import { routeStudio } from "./studioRouter";
+import { getDbStats } from "../../database/instrumentedDb";
+import type { RequestStats } from "../RequestContext";
+
+const logger = MainLogger.child({ scope: "App" });
+
+function combineSignals(signals: AbortSignal[]): AbortSignal {
+    const anyFn = (AbortSignal as any).any;
+    if (typeof anyFn === 'function') {
+        return anyFn.call(AbortSignal, signals);
+    }
+    const controller = new AbortController();
+    for (const s of signals) {
+        if (s.aborted) {
+            controller.abort((s as any).reason);
+            return controller.signal;
+        }
+        // { once: true } auto-removes the listener after first fire, so no
+        // explicit removeEventListener is needed; GC cleans up the rest.
+        s.addEventListener('abort', () => controller.abort((s as any).reason), { once: true });
+    }
+    return controller.signal;
+}
+
+export async function handleRequest(app: any, req: Request): Promise<Response> {
+    const url = new URL(req.url);
+    const method = req.method;
+    const startTime = Date.now();
+
+    if (method === 'OPTIONS') {
+        return new Response(null, {
+            status: 204,
+            headers: getCorsHeaders(app.config.cors, req),
+        });
+    }
+
+    // Request timeout — combine framework wall-clock with client abort signal
+    // and rebind onto the request so downstream handlers (Yoga, REST) see
+    // cancellation propagation (C05).
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => {
+        controller.abort(new Error(`Request timeout after 30000ms: ${method} ${url.pathname}`));
+        const stats = (req as any).__bunsaneStats as RequestStats | undefined;
+        logger.warn({
+            scope: 'App',
+            method,
+            path: url.pathname,
+            operationName: stats?.operationName,
+            dataLoaderCalls: stats?.dataLoaderCalls,
+            dbQueryCount: stats?.dbQueryCount,
+            msg: 'Request timeout',
+        }, `Request timeout: ${method} ${url.pathname}`);
+    }, 30000);
+    // Prevent the timer from keeping the Bun event loop alive at high concurrency.
+    (timeoutId as any).unref?.();
+    const combinedSignal = combineSignals([req.signal, controller.signal]);
+    req = new Request(req, { signal: combinedSignal });
+
+    const cors = app.config.cors;
+    const wrap = (response: Response) => addCorsHeaders(response, cors, req);
+
+    try {
+        if (url.pathname === "/health") {
+            const response = await handleHealth(app);
+            clearTimeout(timeoutId);
+            return wrap(response);
+        }
+
+        if (url.pathname === "/metrics") {
+            const metrics = await app.collectMetrics();
+            clearTimeout(timeoutId);
+            return wrap(new Response(JSON.stringify(metrics), {
+                status: 200,
+                headers: { "Content-Type": "application/json" },
+            }));
+        }
+
+        if (url.pathname === "/health/remote") {
+            const response = await handleRemoteHealth(app);
+            clearTimeout(timeoutId);
+            return wrap(response);
+        }
+
+        if (url.pathname === "/health/ready") {
+            const response = await handleReady(app);
+            clearTimeout(timeoutId);
+            return wrap(response);
+        }
+
+        if (url.pathname === "/openapi.json") {
+            clearTimeout(timeoutId);
+            return wrap(new Response(app.openAPISpecGenerator!.toJSON(), {
+                headers: { "Content-Type": "application/json" },
+            }));
+        }
+
+        if (url.pathname === "/docs") {
+            clearTimeout(timeoutId);
+            const swaggerUIHTML = `
+<!DOCTYPE html>
+<html>
+<head>
+    <title>${app.name} Documentation</title>
+    <link rel="stylesheet" type="text/css" href="https://unpkg.com/swagger-ui-dist@5.10.3/swagger-ui.css" />
+    <style>
+        html { box-sizing: border-box; overflow: -moz-scrollbars-vertical; overflow-y: scroll; }
+        *, *:before, *:after { box-sizing: inherit; }
+        body { margin: 0; background: #fafafa; }
+    </style>
+</head>
+<body>
+    <div id="swagger-ui"></div>
+    <script src="https://unpkg.com/swagger-ui-dist@5.10.3/swagger-ui-bundle.js"></script>
+    <script>
+        window.onload = function() {
+            const ui = SwaggerUIBundle({
+                url: '/openapi.json',
+                dom_id: '#swagger-ui',
+                deepLinking: true,
+                presets: [
+                    SwaggerUIBundle.presets.apis,
+                    SwaggerUIBundle.presets.standalone
+                ],
+                plugins: [
+                    SwaggerUIBundle.plugins.DownloadUrl
+                ],
+                layout: "BaseLayout"
+            });
+        };
+    </script>
+</body>
+</html>`;
+            return wrap(new Response(swaggerUIHTML, {
+                headers: { "Content-Type": "text/html" },
+            }));
+        }
+
+        const studioApiResponse = await routeStudio(app, url, req, method);
+        if (studioApiResponse) {
+            clearTimeout(timeoutId);
+            return wrap(studioApiResponse);
+        }
+
+        if (
+            app.studioEnabled &&
+            (url.pathname === "/studio" || url.pathname.startsWith("/studio/"))
+        ) {
+            clearTimeout(timeoutId);
+
+            if (url.pathname.startsWith("/studio/api/")) {
+                return wrap(new Response(
+                    JSON.stringify({ error: "Studio API endpoint not found" }),
+                    { status: 404, headers: { "Content-Type": "application/json" } },
+                ));
+            }
+
+            if (!url.pathname.startsWith("/studio/assets/")) {
+                const studioIndexPath = path.join(
+                    import.meta.dirname,
+                    "..",
+                    "..",
+                    "studio",
+                    "dist",
+                    "index.html",
+                );
+                try {
+                    const studioFile = Bun.file(studioIndexPath);
+                    if (await studioFile.exists()) {
+                        let html = await studioFile.text();
+                        html = html.replace("</head>", `${getMetadataScript()}</head>`);
+                        return wrap(new Response(html, {
+                            headers: { "Content-Type": "text/html" },
+                        }));
+                    } else {
+                        return wrap(new Response(
+                            "Studio not built. Run `bun run build:studio` to build the studio.",
+                            { status: 404, headers: { "Content-Type": "text/plain" } },
+                        ));
+                    }
+                } catch (error) {
+                    console.log("Error loading studio index.html:", error);
+                    return wrap(new Response("Studio not available", {
+                        status: 404,
+                        headers: { "Content-Type": "text/plain" },
+                    }));
+                }
+            }
+        }
+
+        for (const [route, folder] of app.staticAssets) {
+            if (url.pathname.startsWith(route)) {
+                const relativePath = url.pathname.slice(route.length);
+                const filePath = path.join(folder, relativePath);
+                try {
+                    const file = Bun.file(filePath);
+                    if (await file.exists()) {
+                        clearTimeout(timeoutId);
+                        return wrap(new Response(file));
+                    }
+                } catch (error) {
+                    logger.error(`Error serving static file ${filePath}:`, error as any);
+                }
+            }
+        }
+
+        const endpointKey = `${method}:${url.pathname}`;
+        let endpoint = app.restEndpointMap.get(endpointKey);
+
+        if (!endpoint) {
+            // Only iterate endpoints that have params (regex precompiled at registration).
+            for (const ep of app.restEndpoints) {
+                if (!ep.regex || ep.method !== method) continue;
+                if (ep.regex.test(url.pathname)) {
+                    endpoint = ep;
+                    break;
+                }
+            }
+        }
+
+        if (endpoint) {
+            try {
+                const result = await endpoint.handler(req);
+                const duration = Date.now() - startTime;
+                logger.trace(`REST ${method} ${url.pathname} completed in ${duration}ms`);
+
+                clearTimeout(timeoutId);
+                if (result instanceof Response) {
+                    return wrap(result);
+                } else {
+                    return wrap(new Response(JSON.stringify(result), {
+                        headers: { "Content-Type": "application/json" },
+                    }));
+                }
+            } catch (error) {
+                const duration = Date.now() - startTime;
+                logger.error(
+                    `Error in REST endpoint ${method} ${endpoint.path} after ${duration}ms`,
+                    error as any,
+                );
+                clearTimeout(timeoutId);
+                return wrap(new Response(
+                    JSON.stringify({
+                        error: "Internal server error",
+                        code: "INTERNAL_ERROR",
+                        ...(process.env.NODE_ENV === 'development' && {
+                            message: (error as Error)?.message,
+                        }),
+                    }),
+                    { status: 500, headers: { "Content-Type": "application/json" } },
+                ));
+            }
+        }
+
+        if (app.yoga) {
+            const response = await app.yoga(req);
+            const duration = Date.now() - startTime;
+            logger.trace(`GraphQL request completed in ${duration}ms`);
+            clearTimeout(timeoutId);
+            return response;
+        }
+
+        clearTimeout(timeoutId);
+        return wrap(new Response("Not Found", { status: 404 }));
+    } catch (error) {
+        const duration = Date.now() - startTime;
+        const stats = (req as any).__bunsaneStats as RequestStats | undefined;
+        logger.error(
+            {
+                scope: 'App',
+                method,
+                path: url.pathname,
+                duration,
+                operationName: stats?.operationName,
+                dataLoaderCalls: stats?.dataLoaderCalls,
+                dbQueryCount: stats?.dbQueryCount,
+                dbStats: getDbStats(),
+                err: error,
+            },
+            `Request failed after ${duration}ms: ${method} ${url.pathname}`,
+        );
+        clearTimeout(timeoutId);
+
+        if ((error as Error).name === "AbortError") {
+            return wrap(new Response(
+                JSON.stringify({ error: "Request timeout", code: "TIMEOUT_ERROR" }),
+                { status: 408, headers: { "Content-Type": "application/json" } },
+            ));
+        }
+
+        return wrap(new Response(
+            JSON.stringify({
+                error: "Internal server error",
+                code: "INTERNAL_ERROR",
+                ...(process.env.NODE_ENV === 'development' && {
+                    message: (error as Error)?.message,
+                }),
+            }),
+            { status: 500, headers: { "Content-Type": "application/json" } },
+        ));
+    }
+}

package/core/app/restRegistry.ts

@@ -0,0 +1,80 @@
+import { logger as MainLogger } from "../Logger";
+
+const logger = MainLogger.child({ scope: "App" });
+
+export function collectRestEndpoints(app: any, services: any[]): void {
+    for (const service of services) {
+        const endpoints = (service.constructor as any).httpEndpoints;
+        if (!endpoints) continue;
+
+        for (const endpoint of endpoints) {
+            // Precompile the parameterized regex once so the hot-path router
+            // never calls replace + new RegExp per request.
+            const hasParams = endpoint.path.includes(':');
+            const regex = hasParams
+                ? new RegExp(`^${endpoint.path.replace(/:[^/]+/g, '[^/]+')}$`)
+                : undefined;
+
+            const endpointInfo = {
+                method: endpoint.method,
+                path: endpoint.path,
+                regex,
+                handler: endpoint.handler.bind(service),
+                service: service,
+            };
+            logger.trace(
+                `Registered REST endpoint: [${endpoint.method}] ${endpoint.path} for service ${service.constructor.name}`,
+            );
+            app.restEndpoints.push(endpointInfo);
+            app.restEndpointMap.set(`${endpoint.method}:${endpoint.path}`, endpointInfo);
+
+            if ((endpoint.handler as any).swaggerOperation) {
+                const classTags = (service.constructor as any).swaggerClassTags || [];
+                const methodTags =
+                    (service.constructor as any).swaggerMethodTags?.[endpoint.handler.name] || [];
+                const allTags = [...classTags, ...methodTags];
+
+                logger.trace(
+                    `Generating OpenAPI spec for endpoint: [${endpoint.method}] ${endpoint.path} with tags: ${allTags.join(", ")}`,
+                );
+
+                const operation = { ...(endpoint.handler as any).swaggerOperation };
+                if (allTags.length > 0) {
+                    operation.tags = [...(operation.tags || []), ...allTags];
+                }
+
+                app.openAPISpecGenerator!.addEndpoint({
+                    method: endpoint.method,
+                    path: endpoint.path,
+                    operation,
+                });
+                logger.trace(
+                    `Registered OpenAPI spec for endpoint: [${endpoint.method}] ${endpoint.path}`,
+                );
+            } else if (app.enforceDocs) {
+                logger.warn(
+                    `No swagger operation found for endpoint: [${endpoint.method}] ${endpoint.path} in service ${service.constructor.name}`,
+                );
+                app.openAPISpecGenerator!.addEndpoint({
+                    method: endpoint.method,
+                    path: endpoint.path,
+                    operation: {
+                        summary: `No description for ${endpoint.path}. Don't use this endpoint until it's properly documented!`,
+                        requestBody: {
+                            content: {
+                                "application/json": {
+                                    schema: {},
+                                },
+                            },
+                        },
+                        responses: {
+                            "200": {
+                                description: "Success",
+                            },
+                        },
+                    },
+                });
+            }
+        }
+    }
+}

package/core/app/shutdown.ts

@@ -0,0 +1,97 @@
+import ApplicationLifecycle from "../ApplicationLifecycle";
+import { logger as MainLogger } from "../Logger";
+import { SchedulerManager } from "../SchedulerManager";
+import db from "../../database";
+import { setRemoteManager } from "../remote";
+
+const logger = MainLogger.child({ scope: "App" });
+
+export async function runShutdown(app: any): Promise<void> {
+    if (app.isShuttingDown) return;
+    app.isShuttingDown = true;
+    app.isReady = false;
+
+    const shutdownStart = Date.now();
+    logger.info({ scope: 'app', component: 'App', msg: 'Shutting down application', gracePeriodMs: app.shutdownGracePeriod });
+
+    const budgetRemaining = () => Math.max(500, app.shutdownGracePeriod - (Date.now() - shutdownStart));
+
+    if (app.server) {
+        try {
+            logger.info({ scope: 'app', component: 'App', msg: 'Draining HTTP connections' });
+            app.server.stop(false);
+            await waitForHttpDrain(app, budgetRemaining());
+            try { app.server.stop(true); } catch {}
+            logger.info({ scope: 'app', component: 'App', msg: 'HTTP server stopped' });
+        } catch (error) {
+            logger.warn({ scope: 'app', component: 'App', msg: 'HTTP server stop error', err: error });
+        }
+    }
+
+    try {
+        await SchedulerManager.getInstance().stop(Math.min(budgetRemaining(), 15_000));
+        logger.info({ scope: 'app', component: 'App', msg: 'Scheduler stopped' });
+    } catch (error) {
+        logger.warn({ scope: 'app', component: 'App', msg: 'Scheduler stop error', err: error });
+    }
+
+    if (app.remote) {
+        try {
+            await app.remote.shutdown();
+            setRemoteManager(null);
+            app.remote = null;
+            logger.info({ scope: 'app', component: 'App', msg: 'RemoteManager shutdown' });
+        } catch (error) {
+            logger.warn({ scope: 'app', component: 'App', msg: 'RemoteManager shutdown error', err: error });
+        }
+    }
+
+    try {
+        const { Entity } = await import('../Entity');
+        await Entity.drainPendingCacheOps(Math.min(budgetRemaining(), 5_000));
+        await Entity.drainPendingSideEffects(Math.min(budgetRemaining(), 5_000));
+    } catch (error) {
+        logger.warn({ scope: 'cache', component: 'App', msg: 'Entity cache op drain error', err: error });
+    }
+
+    try {
+        const { CacheManager } = await import('../cache/CacheManager');
+        await CacheManager.getInstance().shutdown();
+        logger.info({ scope: 'cache', component: 'App', msg: 'Cache shutdown completed' });
+    } catch (error) {
+        logger.warn({ scope: 'cache', component: 'App', msg: 'Cache shutdown error', err: error });
+    }
+
+    try {
+        db.close();
+        logger.info({ scope: 'app', component: 'App', msg: 'Database pool closed' });
+    } catch (error) {
+        logger.warn({ scope: 'app', component: 'App', msg: 'Database pool close error', err: error });
+    }
+
+    try {
+        if (app.phaseListener) {
+            ApplicationLifecycle.removePhaseListener(app.phaseListener);
+            app.phaseListener = null;
+        }
+        SchedulerManager.getInstance().disposeLifecycleIntegration();
+    } catch { /* ignore */ }
+
+    app.unregisterProcessHandlers();
+
+    logger.info({ scope: 'app', component: 'App', msg: 'Application shutdown completed', durationMs: Date.now() - shutdownStart });
+}
+
+export async function waitForHttpDrain(app: any, timeoutMs: number): Promise<void> {
+    if (!app.server) return;
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const pending = (app.server as any).pendingRequests ?? 0;
+        if (pending === 0) return;
+        await new Promise((r) => setTimeout(r, 50));
+    }
+    const leftover = (app.server as any).pendingRequests ?? -1;
+    if (leftover > 0) {
+        logger.warn({ scope: 'app', component: 'App', msg: 'HTTP drain timeout, pending requests remaining', pendingRequests: leftover });
+    }
+}

package/core/app/studioRouter.ts

@@ -0,0 +1,83 @@
+import studioEndpoint from "../../endpoints";
+
+export async function routeStudio(
+    app: any,
+    url: URL,
+    req: Request,
+    method: string,
+): Promise<Response | null> {
+    if (!app.studioEnabled || !url.pathname.startsWith("/studio/api/")) return null;
+
+    if (url.pathname === "/studio/api/tables") {
+        return await studioEndpoint.getTables();
+    }
+
+    if (url.pathname === "/studio/api/stats") {
+        return await studioEndpoint.handleStudioStatsRequest();
+    }
+
+    if (url.pathname === "/studio/api/components") {
+        return await studioEndpoint.handleStudioComponentsRequest();
+    }
+
+    if (url.pathname === "/studio/api/query" && method === "POST") {
+        const body = await req.json();
+        return await studioEndpoint.handleStudioQueryRequest(body);
+    }
+
+    const studioApiPath = url.pathname.replace("/studio/api/", "");
+    const pathSegments = studioApiPath.split("/");
+
+    if (pathSegments[0] === "entity" && pathSegments[1]) {
+        const entityId = pathSegments[1];
+        return await studioEndpoint.handleEntityInspectorRequest(entityId);
+    }
+
+    if (pathSegments[0] === "table" && pathSegments[1]) {
+        const tableName = pathSegments[1];
+
+        if (method === "DELETE") {
+            const body = await req.json();
+            return await studioEndpoint.handleStudioTableDeleteRequest(tableName, body);
+        }
+
+        const limit = url.searchParams.get("limit");
+        const offset = url.searchParams.get("offset");
+        const search = url.searchParams.get("search");
+
+        return await studioEndpoint.handleStudioTableRequest(tableName, {
+            limit: limit ? parseInt(limit, 10) : undefined,
+            offset: offset ? parseInt(offset, 10) : undefined,
+            search: search ?? undefined,
+        });
+    }
+
+    if (pathSegments[0] === "arche-type" && pathSegments[1]) {
+        const archeTypeName = pathSegments[1];
+
+        if (method === "DELETE") {
+            const body = await req.json();
+            return await studioEndpoint.handleStudioArcheTypeDeleteRequest(archeTypeName, body);
+        }
+
+        const limit = url.searchParams.get("limit");
+        const offset = url.searchParams.get("offset");
+        const search = url.searchParams.get("search");
+        const includeDeleted = url.searchParams.get("include_deleted");
+
+        return await studioEndpoint.handleStudioArcheTypeRecordsRequest(archeTypeName, {
+            limit: limit ? parseInt(limit, 10) : undefined,
+            offset: offset ? parseInt(offset, 10) : undefined,
+            search: search ?? undefined,
+            include_deleted: includeDeleted === "true",
+        });
+    }
+
+    return new Response(
+        JSON.stringify({ error: "Studio API endpoint not found" }),
+        {
+            status: 404,
+            headers: { "Content-Type": "application/json" },
+        },
+    );
+}

package/core/archetype/customTypes.ts

@@ -0,0 +1,100 @@
+import { z, ZodObject } from "zod";
+import { asObjectType } from "@gqloom/zod";
+
+export const customTypeRegistry = new Map<any, any>();
+export const customTypeNameRegistry = new Map<any, string>();
+export const registeredCustomTypes = new Map<string, any>();
+export const customTypeSilks = new Map<string, any>();
+export const customTypeResolvers: any[] = [];
+export const inputTypeRegistry = new Map<any, string>();
+
+// Structural signature registry for input type deduplication
+// Maps structural signature -> registered input type name
+export const structuralSignatureRegistry = new Map<string, string>();
+
+let _generateZodStructuralSignature: ((schema: any) => string) | null = null;
+
+function getSignatureGenerator(): (schema: any) => string {
+    if (!_generateZodStructuralSignature) {
+        const { generateZodStructuralSignature } = require('../../gql/utils/TypeSignature');
+        _generateZodStructuralSignature = generateZodStructuralSignature;
+    }
+    return _generateZodStructuralSignature!;
+}
+
+export function registerCustomZodType(
+    type: any,
+    schema: any,
+    typeName?: string,
+    inputTypeName?: string
+) {
+    if (typeName && schema instanceof ZodObject) {
+        const shape = schema.shape;
+        const namedSchema = z.object({
+            __typename: z.literal(typeName).nullish(),
+            ...shape,
+        });
+        customTypeRegistry.set(type, namedSchema);
+        if (typeName) {
+            customTypeNameRegistry.set(type, typeName);
+            registeredCustomTypes.set(typeName, namedSchema);
+        }
+
+        if (inputTypeName) {
+            const inputSchema = z.object(shape).register(asObjectType, { name: inputTypeName });
+            registeredCustomTypes.set(inputTypeName, inputSchema);
+            inputTypeRegistry.set(type, inputTypeName);
+
+            try {
+                const generateSignature = getSignatureGenerator();
+                const signature = generateSignature(z.object(shape));
+                structuralSignatureRegistry.set(signature, inputTypeName);
+            } catch (e) {
+                // Signature registration is optional, don't fail if it errors
+            }
+        }
+    } else {
+        customTypeRegistry.set(type, schema);
+        if (typeName) {
+            customTypeNameRegistry.set(type, typeName);
+            registeredCustomTypes.set(typeName, schema);
+        }
+
+        if (inputTypeName && schema instanceof ZodObject) {
+            const inputSchema = schema.register(asObjectType, { name: inputTypeName });
+            registeredCustomTypes.set(inputTypeName, inputSchema);
+            inputTypeRegistry.set(type, inputTypeName);
+
+            try {
+                const generateSignature = getSignatureGenerator();
+                const signature = generateSignature(schema);
+                structuralSignatureRegistry.set(signature, inputTypeName);
+            } catch (e) {
+                // Signature registration is optional, don't fail if it errors
+            }
+        }
+    }
+}
+
+export function getRegisteredCustomTypes() {
+    return registeredCustomTypes;
+}
+
+/**
+ * Find a matching registered input type for a given Zod schema based on structural equivalence.
+ */
+export function findMatchingInputType(schema: any): string | null {
+    if (!schema) return null;
+
+    try {
+        const generateSignature = getSignatureGenerator();
+        const signature = generateSignature(schema);
+        return structuralSignatureRegistry.get(signature) || null;
+    } catch (e) {
+        return null;
+    }
+}
+
+export function getStructuralSignatureRegistry(): Map<string, string> {
+    return structuralSignatureRegistry;
+}