bunsane 0.1.2 → 0.1.4

package/index.ts

@@ -1,90 +1,101 @@
-import App from "./core/App";
-import ServiceRegistry from "./service/ServiceRegistry";
-import BaseService from "./service/Service";
-import { Component, CompData, BaseComponent } from "./core/Components";
-import { Entity } from "./core/Entity";
-import ArcheType from "./core/ArcheType";
-import Query from "./core/Query";
-import {logger} from "./core/Logger";
-import { handleGraphQLError, responseError } from "./core/ErrorHandler";
-import { type Plugin } from "graphql-yoga";
-import { BatchLoader } from "core/BatchLoader";
-import { createRequestContextPlugin } from "./core/RequestContext";
-import type { RequestLoaders } from "./core/RequestLoaders";
-// Hook system exports
-import EntityHookManager from "./core/EntityHookManager";
-import {
-    EntityHook,
-    ComponentHook,
-    LifecycleHook,
-    ComponentTargetHook,
-    registerDecoratedHooks
-} from "./core/decorators/EntityHooks";
-import type {
-    EntityHookCallback,
-    ComponentHookCallback,
-    LifecycleHookCallback,
-    HookOptions,
-    ComponentTargetConfig
-} from "./core/EntityHookManager";
-import type {
-    EntityLifecycleEvent,
-    EntityCreatedEvent,
-    EntityUpdatedEvent,
-    EntityDeletedEvent,
-    ComponentLifecycleEvent,
-    ComponentAddedEvent,
-    ComponentUpdatedEvent,
-    ComponentRemovedEvent
-} from "./core/events/EntityLifecycleEvents";
-import { ScheduledTask } from "core/decorators/ScheduledTask";
-import { ScheduleInterval } from "types/scheduler.types";
+// import App from "./core/App";
+// import ServiceRegistry from "./service/ServiceRegistry";
+// import BaseService from "./service/Service";
+// import { Component, CompData, BaseComponent } from "./core/Components";
+// import { Entity } from "./core/Entity";
+// import type { IEntity } from "./core/EntityInterface";
+// import BaseArcheType, { ArcheType} from "./core/ArcheType";
+// import Query from "./core/Query";
+// import {logger} from "./core/Logger";
+// import { handleGraphQLError, responseError } from "./core/ErrorHandler";
+// import { type Plugin } from "graphql-yoga";
+// import { BatchLoader } from "./core/BatchLoader";
+// import { createRequestContextPlugin } from "./core/RequestContext";
+// import type { RequestLoaders } from "./core/RequestLoaders";
+// import BasePlugin from "./plugins";
+// // Hook system exports
+// import EntityHookManager from "./core/EntityHookManager";
+// import {
+//     EntityHook,
+//     ComponentHook,
+//     LifecycleHook,
+//     ComponentTargetHook,
+//     registerDecoratedHooks
+// } from "./core/decorators/EntityHooks";
+// import type {
+//     EntityHookCallback,
+//     ComponentHookCallback,
+//     LifecycleHookCallback,
+//     HookOptions,
+//     ComponentTargetConfig
+// } from "./core/EntityHookManager";
+// import type {
+//     EntityLifecycleEvent,
+//     EntityCreatedEvent,
+//     EntityUpdatedEvent,
+//     EntityDeletedEvent,
+//     ComponentLifecycleEvent,
+//     ComponentAddedEvent,
+//     ComponentUpdatedEvent,
+//     ComponentRemovedEvent
+// } from "./core/events/EntityLifecycleEvents";
+// import { ScheduledTask } from "./core/decorators/ScheduledTask";
+// import { ScheduleInterval } from "./types/scheduler.types";
+// // Swagger exports
+// import { ApiDocs, ApiTags } from "./swagger";
 
-export { 
-    App, 
-    ArcheType,
-    ServiceRegistry,
-    BaseService,
-    BaseComponent,
-    Component,
-    CompData,
-    Entity,
-    BatchLoader,
+// export { 
+//     App, 
+//     BaseArcheType,
+//     ArcheType,
+//     ServiceRegistry,
+//     BaseService,
+//     BaseComponent,
+//     Component,
+//     CompData,
+//     Entity,
+//     type IEntity,
+//     BatchLoader,
 
-    Query,
+//     Query,
 
-    // Scheduler exports
-    ScheduleInterval,
-    ScheduledTask,
+//     // Scheduler exports
+//     ScheduleInterval,
+//     ScheduledTask,
 
-    logger,
+//     // Swagger exports
+//     ApiDocs,
+//     ApiTags,
 
-    type Plugin,
+//     logger,
 
-    responseError,
-    handleGraphQLError,
+//     BasePlugin,
+//     type Plugin,
 
-    createRequestContextPlugin,
-    type RequestLoaders,
+//     responseError,
+//     handleGraphQLError,
 
-    // Hook system exports
-    EntityHookManager,
-    EntityHook,
-    ComponentHook,
-    LifecycleHook,
-    ComponentTargetHook,
-    registerDecoratedHooks,
-    type EntityHookCallback,
-    type ComponentHookCallback,
-    type LifecycleHookCallback,
-    type HookOptions,
-    type ComponentTargetConfig,
-    type EntityLifecycleEvent,
-    type EntityCreatedEvent,
-    type EntityUpdatedEvent,
-    type EntityDeletedEvent,
-    type ComponentLifecycleEvent,
-    type ComponentAddedEvent,
-    type ComponentUpdatedEvent,
-    type ComponentRemovedEvent
-};
+//     createRequestContextPlugin,
+//     type RequestLoaders,
+
+//     // Hook system exports
+//     EntityHookManager,
+//     EntityHook,
+//     ComponentHook,
+//     LifecycleHook,
+//     ComponentTargetHook,
+//     registerDecoratedHooks,
+//     type EntityHookCallback,
+//     type ComponentHookCallback,
+//     type LifecycleHookCallback,
+//     type HookOptions,
+//     type ComponentTargetConfig,
+//     type EntityLifecycleEvent,
+//     type EntityCreatedEvent,
+//     type EntityUpdatedEvent,
+//     type EntityDeletedEvent,
+//     type ComponentLifecycleEvent,
+//     type ComponentAddedEvent,
+//     type ComponentUpdatedEvent,
+//     type ComponentRemovedEvent
+// };

package/package.json

@@ -1,37 +1,39 @@
-{
-  "name": "bunsane",
-  "version": "0.1.2",
-  "author": {
-    "name": "yaaruu"
-  },
-  "keywords": [
-    "bun",
-    "framework",
-    "entity-component-system",
-    "ecs",
-    "graphql",
-    "typescript"
-  ],
-  "module": "index.ts",
-  "type": "module",
-  "devDependencies": {
-    "@types/bun": "latest"
-  },
-  "peerDependencies": {
-    "typescript": "^5"
-  },
-  "dependencies": {
-    "dataloader": "2.2.2",
-    "graphql": "16.11.0",
-    "graphql-yoga": "5.15.1",
-    "pino": "9.9.0",
-    "pino-pretty": "13.1.1",
-    "reflect-metadata": "0.2.2",
-    "zod": "4.1.5"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/yaaruu/bunsane.git"
-  },
-  "license": "MIT"
-}
+{
+  "name": "bunsane",
+  "version": "0.1.4",
+  "author": {
+    "name": "yaaruu"
+  },
+  "keywords": [
+    "bun",
+    "framework",
+    "entity-component-system",
+    "ecs",
+    "graphql",
+    "typescript"
+  ],
+  "module": "index.ts",
+  "type": "module",
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "@gqloom/core": "^0.12.0",
+    "@gqloom/zod": "^0.12.2",
+    "dataloader": "2.2.2",
+    "graphql": "16.11.0",
+    "graphql-yoga": "5.15.1",
+    "pino": "9.9.0",
+    "pino-pretty": "13.1.1",
+    "reflect-metadata": "0.2.2",
+    "zod": "4.1.5"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yaaruu/bunsane.git"
+  },
+  "license": "MIT"
+}

package/plugins/index.ts

@@ -0,0 +1,13 @@
+import type App from "core/App";
+import type { ApplicationPhase } from "core/ApplicationLifecycle";
+
+abstract class BasePlugin {
+    name!: string;
+    version!: string;
+
+    abstract init?(app: App): Promise<void> | void;
+    onPhaseChange?(phase: ApplicationPhase, app: App): Promise<void> | void;
+    onComponentRegistered?(componentName: string, componentCtor: new () => any, app: App): void;
+}
+
+export default BasePlugin;

package/scheduler/index.ts

@@ -0,0 +1,87 @@
+import { ScheduleInterval } from "../types/scheduler.types";
+import type { ScheduledTaskOptions } from "../types/scheduler.types";
+import { SchedulerManager } from "core/SchedulerManager";
+import { logger } from "core/Logger";
+import type { ComponentTargetConfig } from "core/EntityHookManager";
+const loggerInstance = logger.child({ scope: "ScheduledTaskDecorator" });
+
+/**
+ * Decorator for registering scheduled tasks
+ * @param options Task configuration options including interval and component target
+ */
+export function ScheduledTask(
+    options: ScheduledTaskOptions & { 
+        interval: ScheduleInterval; 
+        componentTarget?: ComponentTargetConfig
+    }
+) {
+    return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
+        const originalMethod = descriptor.value;
+
+        // Generate task ID if not provided
+        const taskId = options.id || `${target.constructor.name}.${propertyKey}`;
+
+        // Store task info for later registration
+        if (!target.constructor.__scheduledTasks) {
+            target.constructor.__scheduledTasks = [];
+        }
+
+        const taskInfo = {
+            id: taskId,
+            name: options.name || `${target.constructor.name}.${propertyKey}`,
+            componentTarget: options.componentTarget, // Legacy support
+            interval: options.interval,
+            options: {
+                runOnStart: options.runOnStart ?? false,
+                timeout: options.timeout ?? 30000,
+                enableLogging: options.enableLogging ?? true,
+                ...options
+            },
+            service: null, // Will be set when service is instantiated
+            methodName: propertyKey,
+            nextExecution: new Date(),
+            executionCount: 0,
+            isRunning: false,
+            enabled: true
+        };
+
+        target.constructor.__scheduledTasks.push(taskInfo);
+
+        // Return the original descriptor to maintain method functionality
+        return descriptor;
+    };
+}
+
+/**
+ * Function to manually register decorated tasks for a service instance
+ * This is useful when services are instantiated outside the normal decorator flow
+ */
+export function registerScheduledTasks(service: any): void {
+    const constructor = service.constructor;
+
+    if (!constructor.__scheduledTasks) {
+        return;
+    }
+
+    const scheduler = SchedulerManager.getInstance();
+
+    for (const task of constructor.__scheduledTasks) {
+        const taskWithService = {
+            ...task,
+            service: service
+        };
+
+        try {
+            scheduler.registerTask(taskWithService);
+            if (loggerInstance.isLevelEnabled('info')) {
+                loggerInstance.info(`Manually registered scheduled task: ${task.name} (${task.id})`);
+            }
+        } catch (error) {
+            loggerInstance.error(`Failed to manually register scheduled task ${task.name}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+}
+
+export {
+    ScheduleInterval
+}

package/service/Service.ts

@@ -1,4 +1,8 @@
+import type { GraphQLObjectTypeMeta, GraphQLOperationMeta } from "gql/Generator";
+
 class BaseService {
+    public __graphqlObjectType?: GraphQLObjectTypeMeta[];
+    public __graphqlOperations?: GraphQLOperationMeta<any>[];
     constructor() {
 
     }

package/service/ServiceRegistry.ts

@@ -19,7 +19,10 @@ class ServiceRegistry {
             switch(event.detail) {
                 case ApplicationPhase.SYSTEM_REGISTERING: {
                     const servicesArray = Array.from(this.services.values());
-                    const { schema } = generateGraphQLSchema(servicesArray);
+                    // Disable auto-generated archetype operations to avoid conflicts with manual operations
+                    const { schema } = generateGraphQLSchema(servicesArray, { 
+                        enableArchetypeOperations: false 
+                    });
                     this.schema = schema;
                     ApplicationLifecycle.setPhase(ApplicationPhase.SYSTEM_READY);
                     break;
@@ -41,6 +44,7 @@ class ServiceRegistry {
         if(!this.services.has(service.constructor.name)) {
             this.services.set(service.constructor.name, service);
         }
+        return service;
     }
 
     public getServices(): BaseService[] {

package/service/index.ts

@@ -1,5 +1,5 @@
 import BaseService from "./Service";
-import { ServiceRegistry } from "index";
+import  ServiceRegistry  from "./ServiceRegistry";
 import { httpEndpoint } from "../rest";
 
 export {

package/swagger/decorators.ts

@@ -0,0 +1,65 @@
+import type { HTTPMethod } from "../rest";
+
+export interface OpenAPIOperation {
+    summary?: string;
+    description?: string;
+    tags?: string[];
+    parameters?: OpenAPIParameter[];
+    requestBody?: OpenAPIRequestBody;
+    responses?: Record<string, OpenAPIResponse>;
+    security?: any[];
+}
+
+export interface OpenAPIParameter {
+    name: string;
+    in: 'query' | 'header' | 'path' | 'cookie';
+    description?: string;
+    required?: boolean;
+    schema: any;
+}
+
+export interface OpenAPIRequestBody {
+    description?: string;
+    required?: boolean;
+    content: Record<string, { schema: any }>;
+}
+
+export interface OpenAPIResponse {
+    description: string;
+    content?: Record<string, { schema: any }>;
+}
+
+export interface SwaggerEndpointMetadata {
+    method: HTTPMethod;
+    path: string;
+    operation: OpenAPIOperation;
+}
+
+/** 
+ * Annotations for OpenAPI/Swagger documentation 
+ * - @ApiOperation: Describes an API operation (endpoint)
+ * - @ApiTags: Assigns tags to group operations in the documentation
+ *
+*/
+
+export function ApiDocs(operation: OpenAPIOperation) {
+    return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
+        // Store the operation on the function itself
+        (descriptor.value as any).swaggerOperation = operation;
+    }
+}
+
+export function ApiTags(...tags: string[]) {
+    return function (target: any, propertyKey?: string) {
+        if (propertyKey) {
+            // Method decorator
+            if (!target.constructor.swaggerMethodTags) {
+                target.constructor.swaggerMethodTags = {};
+            }
+            target.constructor.swaggerMethodTags[propertyKey] = tags;
+        } else {
+            // Class decorator
+            target.swaggerClassTags = tags;
+        }
+    };
+}

package/swagger/generator.ts

@@ -0,0 +1,100 @@
+import type { SwaggerEndpointMetadata } from "./decorators";
+import {logger as MainLogger}  from "core/Logger";
+const logger = MainLogger.child({ scope: "OpenAPISpecGenerator" });
+export interface OpenAPISpec {
+    openapi: string;
+    info: {
+        title: string;
+        version: string;
+        description?: string;
+    };
+    servers?: Array<{
+        url: string;
+        description?: string;
+    }>;
+    paths: Record<string, Record<string, any>>;
+    components?: {
+        schemas?: Record<string, any>;
+        securitySchemes?: Record<string, any>;
+    };
+    tags?: Array<{
+        name: string;
+        description?: string;
+    }>;
+}
+
+export class OpenAPISpecGenerator {
+    private spec: OpenAPISpec;
+
+    constructor(title: string = "API Documentation", version: string = "1.0.0") {
+        this.spec = {
+            openapi: "3.0.0",
+            info: {
+                title,
+                version
+            },
+            paths: {},
+            components: {
+                securitySchemes: {
+                    BearerAuth: {
+                        type: "http",
+                        scheme: "bearer",
+                        bearerFormat: "JWT"
+                    }
+                },
+            }
+        };
+    }
+
+    addEndpoint(metadata: SwaggerEndpointMetadata) {
+        const { method, path, operation } = metadata;
+        logger.trace(`Adding endpoint to OpenAPI spec: [${method}] ${path}`);
+        if (!this.spec.paths[path]) {
+            this.spec.paths[path] = {};
+        }
+
+        this.spec.paths[path][method.toLowerCase()] = {
+            ...operation,
+            responses: operation.responses || {
+                "200": {
+                    description: "Success"
+                }
+            }
+        };
+    }
+
+    addServer(url: string, description?: string) {
+        if (!this.spec.servers) {
+            this.spec.servers = [];
+        }
+        this.spec.servers.push({ url, description });
+    }
+
+    addSecurityScheme(name: string, scheme: any) {
+        if (!this.spec.components) {
+            this.spec.components = {};
+        }
+        if (!this.spec.components.securitySchemes) {
+            this.spec.components.securitySchemes = {};
+        }
+        this.spec.components.securitySchemes[name] = scheme;
+    }
+
+    addSchema(name: string, schema: any) {
+        if (!this.spec.components) {
+            this.spec.components = {};
+        }
+        if (!this.spec.components.schemas) {
+            this.spec.components.schemas = {};
+        }
+        this.spec.components.schemas[name] = schema;
+    }
+
+    generate(): OpenAPISpec {
+        return this.spec;
+    }
+
+    toJSON(): string {
+        return JSON.stringify(this.spec, null, 2);
+    }
+}

package/swagger/index.ts

@@ -0,0 +1,2 @@
+export * from "./decorators";
+export * from "./generator";

package/tests/bench/insert.bench.ts

@@ -7,6 +7,7 @@ import db from "database";
 let app;
 beforeAll(async () => {
     app = new App();
+    app.init();
     await app.waitForAppReady();
 });
 

package/tests/bench/relations.bench.ts

@@ -9,6 +9,7 @@ let app: App;
 
 beforeAll(async () => {
     app = new App();
+    app.init();
     await app.waitForAppReady();
 });
 

package/tests/bench/sorting.bench.ts

@@ -10,6 +10,7 @@ let app: App;
 
 beforeAll(async () => {
     app = new App();
+    app.init();
     await app.waitForAppReady();
 });