bunsane 0.1.2 → 0.1.4

package/core/App.ts

@@ -1,68 +1,87 @@
 import ApplicationLifecycle, {ApplicationPhase} from "core/ApplicationLifecycle";
-import { HasValidBaseTable, PrepareDatabase } from "database/DatabaseHelper";
+import { GenerateTableName, HasValidBaseTable, PrepareDatabase, UpdateComponentIndexes } from "database/DatabaseHelper";
 import ComponentRegistry from "core/ComponentRegistry";
-import { logger } from "core/Logger";
+import { logger as MainLogger } from "core/Logger";
+const logger = MainLogger.child({ scope: "App" });
 import { createYogaInstance } from "gql";
 import ServiceRegistry from "service/ServiceRegistry";
 import type { Plugin } from "graphql-yoga";
 import * as path from "path";
-import { registerDecoratedHooks } from "core/decorators/EntityHooks";
 import { SchedulerManager } from "core/SchedulerManager";
 import { registerScheduledTasks } from "core/decorators/ScheduledTask";
+import { OpenAPISpecGenerator, type SwaggerEndpointMetadata } from "swagger";
+import type BasePlugin from "plugins";
 
 export default class App {
+    private name: string = "BunSane Application";
+    private version: string = "1.0.0";
     private yoga: any;
     private yogaPlugins: Plugin[] = [];
+    private contextFactory?: (context: any) => any;
     private restEndpoints: Array<{ method: string; path: string; handler: Function; service: any }> = [];
     private restEndpointMap: Map<string, { method: string; path: string; handler: Function; service: any }> = new Map();
     private staticAssets: Map<string, string> = new Map();
+    private openAPISpecGenerator: OpenAPISpecGenerator | null = null;
+    private enforceDocs: boolean = false;
 
-    constructor() {
-        this.init();
+    private appReadyCallbacks: Array<() => void> = [];
+
+    private plugins: BasePlugin[] = [];
+
+    constructor(appName?: string, appVersion?: string) {
+        if (appName) this.name = appName;
+        if (appVersion) this.version = appVersion;
+        this.openAPISpecGenerator = new OpenAPISpecGenerator(
+            this.name,
+            this.version,
+        );
+        return this;
     }
 
     async init() {
         logger.trace(`Initializing App`);
         ComponentRegistry.init();
         ServiceRegistry.init();
-        if(ApplicationLifecycle.getCurrentPhase() === ApplicationPhase.DATABASE_INITIALIZING) {
-            if(!await HasValidBaseTable()) {
-                await PrepareDatabase();
+        // Plugin initialization
+        for(const plugin of this.plugins) {
+            if(plugin.init) {
+                await plugin.init(this);
             }
-            logger.trace(`Database prepared...`);
-            ApplicationLifecycle.setPhase(ApplicationPhase.DATABASE_READY);
         }
 
-        ApplicationLifecycle.addPhaseListener((event) => {
+        ApplicationLifecycle.addPhaseListener(async (event) => {
             const phase = event.detail;
             logger.info(`Application phase changed to: ${phase}`);
+            // Notify plugins of phase change
+            for(const plugin of this.plugins) {
+                if(plugin.onPhaseChange) {
+                    await plugin.onPhaseChange(phase, this);
+                }
+            }
             switch(phase) {
                 case ApplicationPhase.DATABASE_READY: {
                     break;
                 }
-                case ApplicationPhase.COMPONENTS_READY: {
-                    // Automatically register decorated hooks for all services
-                    const services = ServiceRegistry.getServices();
-                    for (const service of services) {
-                        try {
-                            registerDecoratedHooks(service);
-                        } catch (error) {
-                            logger.warn(`Failed to register hooks for service ${service.constructor.name}`);
-                            logger.warn(error);
-                        }
-                    }
-                    logger.info(`Registered hooks for ${services.length} services`);
-                    
-                    ApplicationLifecycle.setPhase(ApplicationPhase.SYSTEM_REGISTERING);
-                    break;
-                }
                 case ApplicationPhase.SYSTEM_READY: {
                     try {
                         const schema = ServiceRegistry.getSchema();
+                        
+                        // Wrap user's context factory to automatically spread Yoga context
+                        const wrappedContextFactory = this.contextFactory 
+                            ? (yogaContext: any) => {
+                                const userContext = this.contextFactory!(yogaContext);
+                                // Merge Yoga's context with user's context, preserving Yoga properties
+                                return {
+                                    ...yogaContext,  // Yoga context (request, params, etc.)
+                                    ...userContext,  // User's additional context
+                                };
+                            }
+                            : undefined;
+                        
                         if (schema) {
-                            this.yoga = createYogaInstance(schema, this.yogaPlugins);
+                            this.yoga = createYogaInstance(schema, this.yogaPlugins, wrappedContextFactory);
                         } else {
-                            this.yoga = createYogaInstance(undefined, this.yogaPlugins);
+                            this.yoga = createYogaInstance(undefined, this.yogaPlugins, wrappedContextFactory);
                         }
 
                         // Get all services for processing
@@ -93,12 +112,50 @@ export default class App {
                                         handler: endpoint.handler.bind(service),
                                         service: service
                                     };
+                                    logger.trace(`Registered REST endpoint: [${endpoint.method}] ${endpoint.path} for service ${service.constructor.name}`);
                                     this.restEndpoints.push(endpointInfo);
                                     this.restEndpointMap.set(`${endpoint.method}:${endpoint.path}`, endpointInfo);
+
+                                    // Check if this endpoint has a swagger operation
+                                    if ((endpoint.handler as any).swaggerOperation) {
+                                        // Collect tags from class and method decorators
+                                        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(", ")}`);
+                                        
+                                        // Merge tags into the operation
+                                        const operation = { ...(endpoint.handler as any).swaggerOperation };
+                                        if (allTags.length > 0) {
+                                            operation.tags = [...(operation.tags || []), ...allTags];
+                                        }   
+                                        
+                                        this.openAPISpecGenerator!.addEndpoint({
+                                            method: endpoint.method,
+                                            path: endpoint.path,
+                                            operation
+                                        });
+                                        logger.trace(`Registered OpenAPI spec for endpoint: [${endpoint.method}] ${endpoint.path}`);
+                                    } else {
+                                        if(this.enforceDocs) {
+                                            logger.warn(`No swagger operation found for endpoint: [${endpoint.method}] ${endpoint.path} in service ${service.constructor.name}`);
+                                            this.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" } }
+                                                }
+                                            });
+                                        }
+                                    }
                                 }
                             }
                         }
 
+
                         ApplicationLifecycle.setPhase(ApplicationPhase.APPLICATION_READY);
                     } catch (error) {
                         logger.error("Error during SYSTEM_READY phase:");
@@ -114,12 +171,24 @@ export default class App {
                 }
             }
         });
+
+        if(ApplicationLifecycle.getCurrentPhase() === ApplicationPhase.DATABASE_INITIALIZING) {
+            if(!await HasValidBaseTable()) {
+                await PrepareDatabase();
+            }
+            logger.trace(`Database prepared...`);
+            ApplicationLifecycle.setPhase(ApplicationPhase.DATABASE_READY);
+            await ComponentRegistry.registerAllComponents();
+            ApplicationLifecycle.setPhase(ApplicationPhase.SYSTEM_REGISTERING);
+        }
+
+        
     }
 
     waitForAppReady(): Promise<void> {
         return new Promise(resolve => {
             const interval = setInterval(() => {
-                if (ApplicationLifecycle.getCurrentPhase() === ApplicationPhase.APPLICATION_READY) {
+                if (ApplicationLifecycle.getCurrentPhase() >= ApplicationPhase.COMPONENTS_READY) {
                     clearInterval(interval);
                     resolve();
                 }
@@ -127,10 +196,25 @@ export default class App {
         });
     }
 
+    public addOpenAPISchema(name: string, schema: any) {
+        this.openAPISpecGenerator!.addSchema(name, schema);
+    }
+    public addOpenAPIServer(url: string, description?: string) {
+        this.openAPISpecGenerator!.addServer(url, description);
+    }
+
     public addYogaPlugin(plugin: Plugin) {
         this.yogaPlugins.push(plugin);
     }
 
+    public setGraphQLContextFactory(factory: (context: any) => any) {
+        this.contextFactory = factory;
+    }
+
+    public addPlugin(plugin: BasePlugin) {
+        this.plugins.push(plugin);
+    }   
+
     public addStaticAssets(route: string, folder: string) {
         // Resolve the folder path relative to the current working directory
         const resolvedFolder = path.resolve(folder);
@@ -161,6 +245,56 @@ export default class App {
                     headers: { 'Content-Type': 'application/json' }
                 });
             }
+
+            // OpenAPI spec endpoint
+            if (url.pathname === '/openapi.json') {
+                clearTimeout(timeoutId);
+                return new Response(this.openAPISpecGenerator!.toJSON(), {
+                    headers: { 'Content-Type': 'application/json' }
+                });
+            }
+
+            // Swagger UI endpoint
+            if (url.pathname === '/docs') {
+                clearTimeout(timeoutId);
+                const swaggerUIHTML = `
+<!DOCTYPE html>
+<html>
+<head>
+    <title>${this.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 new Response(swaggerUIHTML, {
+                    headers: { 'Content-Type': 'text/html' }
+                });
+            }
             for (const [route, folder] of this.staticAssets) {
                 if (url.pathname.startsWith(route)) {
                     const relativePath = url.pathname.slice(route.length);
@@ -234,12 +368,35 @@ export default class App {
         }
     }
 
+    public setName(name: string) {
+        this.name = name;
+    }
+
+    public setVersion(version: string) {
+        this.version = version;
+    }
+
+    public subscribeAppReady(callback: () => void) {
+        this.appReadyCallbacks.push(callback);
+    }
+
+    public enforceSwaggerDocs(value: boolean) {
+        this.enforceDocs = value;
+    }
+
     async start() {
         logger.info("Application Started");
+        const port = parseInt(process.env.PORT || "3000");
         const server = Bun.serve({
-            port: parseInt(process.env.PORT || "3000"),
+            port: port,
             fetch: this.handleRequest.bind(this),
         });
+        
+        // Update the OpenAPI spec with the actual server URL
+        this.openAPISpecGenerator!.addServer(`http://localhost:${port}`, "Development server");
+        
         logger.info(`Server is running on ${new URL(this.yoga?.graphqlEndpoint || '/graphql', `http://${server.hostname}:${server.port}`)}`)
+
+        this.appReadyCallbacks.forEach(cb => cb());
     }
 }