bunsane 0.1.0 → 0.1.2

package/gql/decorators/Upload.ts

@@ -0,0 +1,176 @@
+import "reflect-metadata";
+import type { UploadDecoratorConfig } from "../../types/upload.types";
+import { UploadManager } from "../../core/UploadManager";
+import { logger as MainLogger } from "../../core/Logger";
+
+const logger = MainLogger.child({ scope: "UploadDecorator" });
+
+/**
+ * Metadata key for upload configuration
+ */
+export const UPLOAD_CONFIG_KEY = Symbol("upload:config");
+
+/**
+ * @Upload decorator for GraphQL mutation parameters
+ * Automatically handles file uploads and stores metadata
+ */
+export function Upload(config?: UploadDecoratorConfig) {
+    return function (target: any, propertyKey: string, parameterIndex: number) {
+        logger.trace(`Registering @Upload decorator for ${target.constructor.name}.${propertyKey} parameter ${parameterIndex}`);
+        
+        const existingMetadata = Reflect.getMetadata(UPLOAD_CONFIG_KEY, target, propertyKey) || {};
+        
+        existingMetadata[parameterIndex] = {
+            field: config?.field || propertyKey,
+            batch: config?.batch || false,
+            required: config?.required || false,
+            validationMessage: config?.validationMessage,
+            ...config
+        };
+        
+        Reflect.defineMetadata(UPLOAD_CONFIG_KEY, existingMetadata, target, propertyKey);
+    };
+}
+
+/**
+ * @UploadField decorator for GraphQL field-level upload configuration
+ * Used to configure upload behavior for specific fields
+ */
+export function UploadField(config: UploadDecoratorConfig) {
+    return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
+        logger.trace(`Registering @UploadField decorator for ${target.constructor.name}.${propertyKey}`);
+        
+        const originalMethod = descriptor.value;
+        
+        descriptor.value = async function (...args: any[]) {
+            const uploadManager = UploadManager.getInstance();
+            
+            // Check if this method has upload parameters
+            const uploadMetadata = Reflect.getMetadata(UPLOAD_CONFIG_KEY, target, propertyKey);
+            
+            if (uploadMetadata) {
+                // Process uploads before calling the original method
+                for (const [paramIndex, uploadConfig] of Object.entries(uploadMetadata)) {
+                    const paramIdx = parseInt(paramIndex);
+                    const file = args[paramIdx];
+                    const config = uploadConfig as any;
+                    
+                    if (file && file instanceof File) {
+                        logger.info(`Processing upload for parameter ${paramIdx} in ${target.constructor.name}.${propertyKey}`);
+                        
+                        try {
+                            const result = await uploadManager.uploadFile(file, config);
+                            
+                            if (!result.success) {
+                                throw new Error(config.validationMessage || result.error?.message || "Upload failed");
+                            }
+                            
+                            // Replace file parameter with upload result
+                            args[paramIdx] = result;
+                            
+                        } catch (error) {
+                            logger.error(`Upload failed for ${target.constructor.name}.${propertyKey}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+                            throw error;
+                        }
+                    } else if (config.required) {
+                        throw new Error(`Required upload file missing for parameter ${paramIdx}`);
+                    }
+                }
+            }
+            
+            return await originalMethod.apply(this, args);
+        };
+        
+        return descriptor;
+    };
+}
+
+/**
+ * Helper function to extract upload configuration from method metadata
+ */
+export function getUploadConfiguration(target: any, propertyKey: string): Record<number, any> | undefined {
+    return Reflect.getMetadata(UPLOAD_CONFIG_KEY, target, propertyKey);
+}
+
+/**
+ * @BatchUpload decorator for handling multiple file uploads
+ */
+export function BatchUpload(config?: UploadDecoratorConfig) {
+    return Upload({ ...config, batch: true });
+}
+
+/**
+ * @RequiredUpload decorator for mandatory file uploads
+ */
+export function RequiredUpload(config?: UploadDecoratorConfig) {
+    return Upload({ ...config, required: true });
+}
+
+/**
+ * Higher-order decorator factory for common upload patterns
+ */
+export class UploadDecorators {
+    /**
+     * Image upload decorator with image-specific validation
+     */
+    static Image(config?: Partial<UploadDecoratorConfig>) {
+        return Upload({
+            ...config,
+            maxFileSize: 5 * 1024 * 1024, // 5MB
+            allowedMimeTypes: ["image/jpeg", "image/png", "image/gif", "image/webp"],
+            allowedExtensions: [".jpg", ".jpeg", ".png", ".gif", ".webp"],
+            generateThumbnails: true
+        });
+    }
+
+    /**
+     * Avatar upload decorator with strict constraints
+     */
+    static Avatar(config?: Partial<UploadDecoratorConfig>) {
+        return Upload({
+            ...config,
+            required: true,
+            maxFileSize: 2 * 1024 * 1024, // 2MB
+            allowedMimeTypes: ["image/jpeg", "image/png", "image/webp"],
+            allowedExtensions: [".jpg", ".jpeg", ".png", ".webp"],
+            generateThumbnails: true,
+            namingStrategy: "uuid"
+        });
+    }
+
+    /**
+     * Document upload decorator
+     */
+    static Document(config?: Partial<UploadDecoratorConfig>) {
+        return Upload({
+            ...config,
+            maxFileSize: 25 * 1024 * 1024, // 25MB
+            allowedMimeTypes: [
+                "application/pdf",
+                "text/plain", 
+                "application/msword",
+                "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+            ],
+            allowedExtensions: [".pdf", ".txt", ".doc", ".docx"],
+            validateFileSignature: true
+        });
+    }
+
+    /**
+     * Secure upload decorator with strict validation
+     */
+    static Secure(config?: Partial<UploadDecoratorConfig>) {
+        return Upload({
+            ...config,
+            maxFileSize: 1 * 1024 * 1024, // 1MB
+            allowedMimeTypes: ["image/jpeg", "image/png"],
+            allowedExtensions: [".jpg", ".jpeg", ".png"],
+            validateFileSignature: true,
+            sanitizeFileName: true,
+            validation: {
+                scanForMalware: true,
+                strictMimeType: true
+            }
+        });
+    }
+}

package/gql/helpers.ts

@@ -0,0 +1,67 @@
+import { GraphQLFieldTypes } from './types';
+
+export type GraphQLType =
+  | GraphQLFieldTypes  // e.g., "ID!", "String"
+  | string             // For custom types like "User", "[User]", "[User]!"
+  | `${string}!`       // For required custom types
+  | `[${string}]`      // For list types
+  | `[${string}]!`;    // For required list types
+
+export function isValidGraphQLType(type: string): type is GraphQLType {
+  const enumValues = Object.values(GraphQLFieldTypes);
+  return enumValues.includes(type as GraphQLFieldTypes) ||
+         /^(\w+|\[\w+\])(!)?$/.test(type);  // Simple regex for custom types/lists
+}
+
+export type TypeFromGraphQL<T extends GraphQLType> =
+  T extends GraphQLFieldTypes.ID_REQUIRED | GraphQLFieldTypes.ID_OPTIONAL ? string :
+  T extends GraphQLFieldTypes.STRING_REQUIRED ? string :
+  T extends GraphQLFieldTypes.STRING_OPTIONAL ? string | null :
+  T extends GraphQLFieldTypes.INT_REQUIRED ? number :
+  T extends GraphQLFieldTypes.INT_OPTIONAL ? number | null :
+  T extends GraphQLFieldTypes.BOOLEAN_REQUIRED ? boolean :
+  T extends GraphQLFieldTypes.BOOLEAN_OPTIONAL ? boolean | null :
+  T extends GraphQLFieldTypes.FLOAT_REQUIRED ? number :
+  T extends GraphQLFieldTypes.FLOAT_OPTIONAL ? number | null :
+  T extends `[${string}]` | `[${string}]!` ? any[] :  
+  any;  
+
+export type ResolverInput<T extends Record<string, GraphQLType>> = {
+  [K in keyof T]: TypeFromGraphQL<T[K]>;
+};
+
+export function isFieldRequested(info: any, fieldName: string): boolean {
+    return info.fieldNodes[0].selectionSet.selections.some((selection: any) => 
+        selection.name.value === fieldName
+    );
+}
+
+export function isFieldRequestedSafe(info: any, ...path: string[]): boolean {
+    if (!info || !info.fieldNodes || info.fieldNodes.length === 0) return false;
+    const fieldNode = info.fieldNodes[0];
+    if (!fieldNode.selectionSet) return false;
+    return isPathSelected(fieldNode.selectionSet, path);
+}
+
+function isPathSelected(selectionSet: any, path: string[]): boolean {
+    if (path.length === 0) return true;
+    const [current, ...rest] = path;
+    for (const selection of selectionSet.selections) {
+        if (selection.kind === 'Field') {
+            if (selection.name.value === current) {
+                if (rest.length === 0) return true;
+                if (selection.selectionSet) {
+                    return isPathSelected(selection.selectionSet, rest);
+                }
+                return false;
+            }
+        } else if (selection.kind === 'InlineFragment' || selection.kind === 'FragmentSpread') {
+            // For simplicity, assume fragments are expanded; in practice, they should be resolved
+            // Here, we can check if the fragment has the field
+            if (selection.selectionSet) {
+                if (isPathSelected(selection.selectionSet, path)) return true;
+            }
+        }
+    }
+    return false;
+}

package/gql/index.ts

@@ -1,12 +1,33 @@
-import {createSchema, createYoga} from 'graphql-yoga';
+import {createSchema, createYoga, type Plugin} from 'graphql-yoga';
 import { GraphQLSchema, GraphQLError } from 'graphql';
-import { GraphQLType, GraphQLField, GraphQLOperation } from './Generator';
-import {GraphQLTypes} from "./types"
-export {
+import { GraphQLObjectType, GraphQLField, GraphQLOperation, GraphQLScalarType } from './Generator';
+import {GraphQLFieldTypes} from "./types"
+import {logger as MainLogger} from "core/Logger"
+import { isFieldRequested } from './helpers';
+
+const logger = MainLogger.child({scope: "GQL"});
+
+import {
+    isValidGraphQLType,
+} from "./helpers";
+import type {
     GraphQLType,
+    TypeFromGraphQL,
+    ResolverInput
+} from "./helpers";
+export {
+    GraphQLObjectType,
     GraphQLField,
     GraphQLOperation,
-    GraphQLTypes
+    GraphQLFieldTypes,
+    isValidGraphQLType,
+    GraphQLScalarType,
+    isFieldRequested
+}
+export type {
+    GraphQLType,
+    TypeFromGraphQL,
+    ResolverInput
 }
 interface Entity {
     id: string;
@@ -49,26 +70,47 @@ const staticResolvers = {
     }
 };
 
-export function createYogaInstance(schema?: GraphQLSchema) {
+const maskError = (error: any, message: string): GraphQLError => {
+    // Handle authentication errors
+    if (error.message === 'Unauthenticated' || error.extensions?.http?.status === 401 || error.extensions?.code === 'UNAUTHENTICATED') {
+        return new GraphQLError('Unauthorized', {
+            extensions: {
+                code: 'UNAUTHORIZED',
+                http: { status: 401 }
+            }
+        });
+    }
+    
+    // Handle JWT authentication errors specifically
+    if (error.extensions?.code === 'DOWNSTREAM_SERVICE_ERROR' && error.extensions?.http?.status === 401) {
+        return new GraphQLError('Unauthorized', {
+            extensions: {
+                code: 'UNAUTHORIZED',
+                http: { status: 401 }
+            }
+        });
+    }
+    
+    if (process.env.NODE_ENV === 'production') {
+        logger.error("GraphQL Error:", error);
+        // Mask sensitive error details in production
+        return new GraphQLError('Internal server error', {
+            extensions: {
+                code: 'INTERNAL_SERVER_ERROR',
+            },
+        });
+    }
+    // In development, return the original error
+    return error instanceof GraphQLError ? error : new GraphQLError(message, { originalError: error });
+};
+
+export function createYogaInstance(schema?: GraphQLSchema, plugins: Plugin[] = []) {
     if (schema) {
         return createYoga({
             schema,
-            // Configure error handling to preserve error messages for clients
+            plugins,
             maskedErrors: {
-                // In development, show full error details
-                // In production, you might want to mask sensitive information
-                maskError: (error: any, message: string): GraphQLError => {
-                    if (process.env.NODE_ENV === 'production') {
-                        // Mask sensitive error details in production
-                        return new GraphQLError('Internal server error', {
-                            extensions: {
-                                code: 'INTERNAL_SERVER_ERROR',
-                            },
-                        });
-                    }
-                    // In development, return the original error
-                    return error instanceof GraphQLError ? error : new GraphQLError(message, { originalError: error });
-                },
+                maskError,
             },
         });
     } else {
@@ -77,17 +119,9 @@ export function createYogaInstance(schema?: GraphQLSchema) {
                 typeDefs: staticTypeDefs,
                 resolvers: staticResolvers,
             }),
+            plugins,
             maskedErrors: {
-                maskError: (error: any, message: string): GraphQLError => {
-                    if (process.env.NODE_ENV === 'production') {
-                        return new GraphQLError('Internal server error', {
-                            extensions: {
-                                code: 'INTERNAL_SERVER_ERROR',
-                            },
-                        });
-                    }
-                    return error instanceof GraphQLError ? error : new GraphQLError(message, { originalError: error });
-                },
+                maskError,
             },
         });
     }

package/gql/types.ts

@@ -7,7 +7,7 @@ export enum GraphQLScalar {
     Date = "Date",
 }
 
-export enum GraphQLTypes {
+export enum GraphQLFieldTypes {
     ID_REQUIRED = "ID!",
     ID_OPTIONAL = "ID",
     STRING_REQUIRED = "String!",

package/index.ts

@@ -1,22 +1,90 @@
-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 Query from "core/Query";
-import {logger} from "core/Logger";
-import { handleGraphQLError, responseError } from "core/ErrorHandler";
+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";
+
 export { 
-    App,  
+    App, 
+    ArcheType,
     ServiceRegistry,
     BaseService,
     BaseComponent,
     Component,
     CompData,
     Entity,
+    BatchLoader,
+
     Query,
+
+    // Scheduler exports
+    ScheduleInterval,
+    ScheduledTask,
+
     logger,
 
+    type Plugin,
+
     responseError,
-    handleGraphQLError
-};
+    handleGraphQLError,
+
+    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,9 +1,17 @@
 {
   "name": "bunsane",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "author": {
     "name": "yaaruu"
   },
+  "keywords": [
+    "bun",
+    "framework",
+    "entity-component-system",
+    "ecs",
+    "graphql",
+    "typescript"
+  ],
   "module": "index.ts",
   "type": "module",
   "devDependencies": {
@@ -13,16 +21,17 @@
     "typescript": "^5"
   },
   "dependencies": {
-    "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"
+    "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"
   },
-  "graphql": {
-    "schema": "https://localhost:3001/graphql",
-    "documents": "**/*.{graphql,js,ts,jsx,tsx}"
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yaaruu/bunsane.git"
   },
   "license": "MIT"
 }

package/rest/Generator.ts

@@ -0,0 +1,3 @@
+export function generateRestControllerEndpoints() {
+    
+}

package/rest/index.ts

@@ -0,0 +1,22 @@
+export type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'OPTIONS' | 'HEAD';
+export type HTTPEndpointOptions = {
+    method: HTTPMethod;
+    path: string;
+}
+
+export function httpEndpoint(options: HTTPEndpointOptions) {
+    return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
+        if (!target.constructor.httpEndpoints) {
+            target.constructor.httpEndpoints = [];
+        }
+        target.constructor.httpEndpoints.push({
+            method: options.method,
+            path: options.path,
+            handler: descriptor.value
+        });
+    }
+}
+
+export interface RestController {
+    httpEndpoints: Array<{ method: HTTPMethod; path: string; handler: Function }>;
+}

package/service/Service.ts

@@ -4,4 +4,4 @@ class BaseService {
     }
 }
 
-export default BaseService;
+export default BaseService ;

package/service/ServiceRegistry.ts

@@ -6,7 +6,7 @@ import { GraphQLSchema } from "graphql";
 class ServiceRegistry {
     static #instance: ServiceRegistry;
 
-    private systems: Map<string, BaseService> = new Map();
+    private services: Map<string, BaseService> = new Map();
     private schema: GraphQLSchema | null = null;
 
 
@@ -18,8 +18,8 @@ class ServiceRegistry {
         ApplicationLifecycle.addPhaseListener((event) => {
             switch(event.detail) {
                 case ApplicationPhase.SYSTEM_REGISTERING: {
-                    const systemsArray = Array.from(this.systems.values());
-                    const { schema } = generateGraphQLSchema(systemsArray);
+                    const servicesArray = Array.from(this.services.values());
+                    const { schema } = generateGraphQLSchema(servicesArray);
                     this.schema = schema;
                     ApplicationLifecycle.setPhase(ApplicationPhase.SYSTEM_READY);
                     break;
@@ -37,12 +37,16 @@ class ServiceRegistry {
         return ServiceRegistry.#instance;
     }
 
-    public registerService(system: BaseService) {
-        if(!this.systems.has(system.constructor.name)) {
-            this.systems.set(system.constructor.name, system);
+    public registerService(service: BaseService) {
+        if(!this.services.has(service.constructor.name)) {
+            this.services.set(service.constructor.name, service);
         }
     }
 
+    public getServices(): BaseService[] {
+        return Array.from(this.services.values());
+    }
+
     public getSchema(): GraphQLSchema | null {
         return this.schema;
     }

package/service/index.ts

@@ -1,6 +1,17 @@
 import BaseService from "./Service";
 import { ServiceRegistry } from "index";
+import { httpEndpoint } from "../rest";
+
 export {
     BaseService,
     ServiceRegistry
-}
+}
+
+// Shorthand decorators for HTTP methods
+export const Get = (path: string) => httpEndpoint({ method: 'GET', path });
+export const Post = (path: string) => httpEndpoint({ method: 'POST', path });
+export const Put = (path: string) => httpEndpoint({ method: 'PUT', path });
+export const Delete = (path: string) => httpEndpoint({ method: 'DELETE', path });
+export const Patch = (path: string) => httpEndpoint({ method: 'PATCH', path });
+export const Options = (path: string) => httpEndpoint({ method: 'OPTIONS', path });
+export const Head = (path: string) => httpEndpoint({ method: 'HEAD', path });

package/tests/bench/insert.bench.ts

@@ -0,0 +1,59 @@
+import {describe, test, expect, beforeAll, beforeEach} from "bun:test"
+import App from "core/App"
+import { BaseComponent, CompData, Component } from "core/Components";
+import { Entity } from "core/Entity";
+import db from "database";
+
+let app;
+beforeAll(async () => {
+    app = new App();
+    await app.waitForAppReady();
+});
+
+beforeEach(async () => {
+   await db`TRUNCATE TABLE entities CASCADE;`;
+})
+
+@Component
+class TestComponent extends BaseComponent {
+    @CompData()
+    value: string = "";
+}
+
+@Component
+class AnotherComponent extends BaseComponent {
+    @CompData()
+    numberValue: number = 0;
+}
+
+@Component
+class YetAnotherComponent extends BaseComponent {
+    @CompData()
+    boolValue: boolean = false;
+}
+
+@Component
+class MassiveComponent extends BaseComponent {
+    @CompData()
+    value: string = "";
+}
+
+describe('Insert Entity Tests', () => {
+    test('Creating 10000 entities', async () => {
+        const entities = [];
+        for(let i = 0; i < 10000; i++) {
+            const entity = Entity.Create()
+                .add(TestComponent, {value: `Test ${i}`})
+                .add(AnotherComponent, {numberValue: i})
+                .add(YetAnotherComponent, {boolValue: i % 2 === 0})
+                .add(MassiveComponent, {value: "x".repeat(1000)});
+            entities.push(entity);
+        }
+        const start = performance.now();
+        await Promise.all(entities.map(entity => entity.save()));
+        const end = performance.now();
+        console.log(`Time taken to create 10000 entities: ${end - start}ms`);
+        const countResult :any = await db<{count: number}>`SELECT COUNT(*)::int FROM entities;`;
+        expect(countResult[0].count).toBe(10000);
+    });
+});