bunsane 0.3.1 → 0.3.2

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;
+}

package/core/archetype/decorators.ts

@@ -0,0 +1,171 @@
+import type { BaseComponent } from "../components";
+import type { ArcheTypeFieldOptions } from "../metadata/definitions/ArcheType";
+import type { BaseArcheType, ArcheTypeOptions, RelationOptions } from "../ArcheType";
+import { getMetadataStorage } from "../metadata";
+import "reflect-metadata";
+
+export const archetypeFunctionsSymbol = Symbol.for("bunsane:archetypeFunctions");
+export const archetypeFieldsSymbol = Symbol.for("bunsane:archetypeFields");
+export const archetypeUnionFieldsSymbol = Symbol.for("bunsane:archetypeUnionFields");
+export const archetypeRelationsSymbol = Symbol.for("bunsane:archetypeRelations");
+
+export function ArcheTypeFunction(options?: {
+    returnType?: string;
+    args?: Array<{
+        name: string;
+        type: any;
+        nullable?: boolean;
+    }>;
+}) {
+    return function (target: any, propertyKey: string) {
+        if (!target[archetypeFunctionsSymbol]) {
+            target[archetypeFunctionsSymbol] = [];
+        }
+        target[archetypeFunctionsSymbol].push({ propertyKey, options });
+    };
+}
+
+export function ArcheType<T extends new () => BaseArcheType>(
+    nameOrOptions?: string | ArcheTypeOptions
+) {
+    return function (target: T): T {
+        const storage = getMetadataStorage();
+        const typeId = storage.getComponentId(target.name);
+
+        let archetype_name = target.name;
+
+        if (typeof nameOrOptions === "string") {
+            archetype_name = nameOrOptions;
+        } else if (nameOrOptions) {
+            archetype_name = nameOrOptions.name || target.name;
+        }
+
+        storage.collectArcheTypeMetadata({
+            name: archetype_name,
+            typeId: typeId,
+            target: target,
+        });
+
+        const prototype = target.prototype;
+        const fields = prototype[archetypeFieldsSymbol];
+        if (fields) {
+            for (const { propertyKey, component, options } of fields) {
+                const type = Reflect.getMetadata(
+                    "design:type",
+                    target.prototype,
+                    propertyKey
+                );
+                storage.collectArchetypeField(
+                    archetype_name,
+                    propertyKey,
+                    component,
+                    options,
+                    type
+                );
+            }
+        }
+
+        const unions = prototype[archetypeUnionFieldsSymbol];
+        if (unions) {
+            for (const { propertyKey, components, options } of unions) {
+                storage.collectArchetypeUnion(
+                    archetype_name,
+                    propertyKey,
+                    components,
+                    options,
+                    "union"
+                );
+            }
+        }
+
+        const relations = prototype[archetypeRelationsSymbol];
+        if (relations) {
+            for (const {
+                propertyKey,
+                relatedArcheType,
+                relationType,
+                options,
+            } of relations) {
+                const type = Reflect.getMetadata(
+                    "design:type",
+                    target.prototype,
+                    propertyKey
+                );
+                storage.collectArchetypeRelation(
+                    archetype_name,
+                    propertyKey,
+                    relatedArcheType,
+                    relationType,
+                    options,
+                    type
+                );
+            }
+        }
+
+        const functions = prototype[archetypeFunctionsSymbol];
+        if (functions) {
+            storage.collectArcheTypeMetadata({
+                name: archetype_name,
+                typeId: typeId,
+                target: target,
+                functions: functions,
+            });
+        }
+
+        return target;
+    };
+}
+
+export function ArcheTypeField<T extends BaseComponent>(
+    component: new (...args: any[]) => T,
+    options?: ArcheTypeFieldOptions
+) {
+    return function (target: any, propertyKey: string) {
+        if (!target[archetypeFieldsSymbol]) {
+            target[archetypeFieldsSymbol] = [];
+        }
+        target[archetypeFieldsSymbol].push({ propertyKey, component, options });
+    };
+}
+
+export function ArcheTypeUnionField(
+    components: (new (...args: any[]) => any)[],
+    options?: ArcheTypeFieldOptions
+) {
+    return function (target: any, propertyKey: string) {
+        if (!target[archetypeUnionFieldsSymbol]) {
+            target[archetypeUnionFieldsSymbol] = [];
+        }
+        target[archetypeUnionFieldsSymbol].push({
+            propertyKey,
+            components,
+            options,
+        });
+    };
+}
+
+function createRelationDecorator(
+    relationType: "hasMany" | "belongsTo" | "hasOne" | "belongsToMany"
+) {
+    return function (relatedArcheType: string, options?: RelationOptions) {
+        return function (target: any, propertyKey: string) {
+            if (!target[archetypeRelationsSymbol]) {
+                target[archetypeRelationsSymbol] = [];
+            }
+            target[archetypeRelationsSymbol].push({
+                propertyKey,
+                relatedArcheType,
+                relationType,
+                options,
+            });
+        };
+    };
+}
+
+export const HasMany = createRelationDecorator("hasMany");
+export const BelongsTo = createRelationDecorator("belongsTo");
+export const HasOne = createRelationDecorator("hasOne");
+export const BelongsToMany = createRelationDecorator("belongsToMany");
+
+// Keep ArcheTypeRelation as alias for backwards compatibility
+export const ArcheTypeRelation = HasMany;