bunsane 0.1.0

package/database/DatabaseHelper.ts

@@ -0,0 +1,138 @@
+import db from "database";
+import { logger as MainLogger } from "core/Logger";
+const logger = MainLogger.child({ scope: "DatabaseHelper" });
+
+export const GetSchema = async () => {
+    const dbSchema = await db`SELECT table_name 
+        FROM information_schema.tables 
+    WHERE table_type = 'BASE TABLE' 
+        AND table_schema NOT IN 
+            ('pg_catalog', 'information_schema');`.values();
+    const tables = dbSchema.map((row: string[]) => row[0]);
+    return tables;
+}
+
+export const HasValidBaseTable = async (): Promise<boolean> => {
+    const tables = await GetSchema();
+    const neededTables = ["entities", "components", "entity_components"];
+    return neededTables.every(t => tables.includes(t));
+}
+
+export const PrepareDatabase = async () => {
+    logger.trace(`Initializing Database.`);
+    await SetupDatabaseExtensions();
+    await CreateEntityTable();
+    await CreateComponentTable();
+    await CreateEntityComponentTable();
+}
+
+export const SetupDatabaseExtensions = async () => {
+    return new Promise(async resolve => {
+        // await db`CREATE EXTENSION IF NOT EXISTS "uuid-ossp";`;
+        return resolve(true);
+    })
+}
+
+export const CreateEntityTable = async () => {
+    return new Promise(async resolve => {
+        await db`CREATE TABLE IF NOT EXISTS entities (
+            id UUID PRIMARY KEY,
+            created_at TIMESTAMP DEFAULT NOW(),
+            updated_at TIMESTAMP DEFAULT NOW()
+        );`;
+        return resolve(true);
+    });
+}
+
+export const CreateComponentTable = () => {
+    return new Promise(async resolve => {
+        await db`CREATE TABLE IF NOT EXISTS components (
+            id UUID,
+            entity_id UUID REFERENCES entities(id),
+            type_id varchar(64) NOT NULL,
+            name varchar(128),
+            data jsonb,
+            created_at TIMESTAMP DEFAULT NOW(),
+            updated_at TIMESTAMP DEFAULT NOW(),
+            PRIMARY KEY (id, type_id, entity_id)
+        ) PARTITION BY LIST (type_id);`;
+        await db`CREATE INDEX IF NOT EXISTS idx_components_entity_id ON components (entity_id);`
+        await db`CREATE INDEX IF NOT EXISTS idx_components_type_id ON components (type_id);`
+        await db`CREATE INDEX IF NOT EXISTS idx_components_data_gin ON components USING GIN (data);`
+        return resolve(true);
+    });
+}
+
+
+export const CreateComponentPartitionTable = async (comp_name: string, type_id: string, indexedProperties?: string[]) => {
+    try {
+        logger.trace(`Attempt adding partition table for component: ${comp_name}`);
+        const table_name = `components_${comp_name.toLowerCase().replace(/\s+/g, '_')}`;
+        logger.trace(`Checking for existing partition table: ${table_name}`);
+        const existingPartition = await db`
+            SELECT 1 FROM information_schema.tables 
+            WHERE table_name = ${table_name} 
+            AND table_schema = 'public'
+        `;
+        logger.trace(`Existing partition check result: ${existingPartition.length > 0 ? 'found' : 'not found'}`);
+
+        if (existingPartition.length > 0) {
+            logger.info(`Partition table ${table_name} already exists`);
+            return;
+        }
+        logger.trace(`Creating partition table: ${table_name}`);
+
+        await db.unsafe(`CREATE TABLE IF NOT EXISTS ${table_name}
+                PARTITION OF components
+                FOR VALUES IN ('${type_id}');`);
+        
+        if (indexedProperties && indexedProperties.length > 0) {
+            for (const prop of indexedProperties) {
+                const indexName = `idx_${table_name}_${prop}`;
+                await db.unsafe(`CREATE INDEX IF NOT EXISTS ${indexName} ON ${table_name} USING GIN ((data->'${prop}'))`);
+                logger.trace(`Created index ${indexName} for property ${prop}`);
+            }
+        }
+        
+        logger.trace(`Successfully created partition table: ${table_name}`);
+        
+    } catch (error) {
+        logger.error(`Failed to create component partition table for ${comp_name}: ${error}`);
+        throw error;
+    }
+}
+
+export const DeleteComponentPartitionTable = async (comp_name: string) => {
+    try {
+        const table_name = `components_${comp_name.toLowerCase().replace(/\s+/g, '_')}`;
+
+        const existingPartition = await db`
+            SELECT 1 FROM information_schema.tables
+            WHERE table_name = ${table_name}
+            AND table_schema = 'public'
+        `;
+
+        if (existingPartition.length === 0) {
+            logger.info(`Partition table ${table_name} does not exist`);
+            return;
+        }
+
+        await db.unsafe(`DROP TABLE IF EXISTS ${table_name}`);
+        logger.info(`Successfully deleted partition table: ${table_name}`);
+
+    } catch (error) {
+        logger.error(`Failed to delete component partition table for ${comp_name}: ${error}`);
+        throw error;
+    }
+}
+
+export const CreateEntityComponentTable = async () => {
+    await db`CREATE TABLE IF NOT EXISTS entity_components (
+        entity_id UUID REFERENCES entities(id),
+        type_id VARCHAR(64) NOT NULL,
+        UNIQUE(entity_id, type_id)
+    );`;
+    await db`CREATE INDEX IF NOT EXISTS idx_entity_components_entity_id ON entity_components (entity_id);`
+    await db`CREATE INDEX IF NOT EXISTS idx_entity_components_type_id ON entity_components (type_id);`
+    await db`CREATE INDEX IF NOT EXISTS idx_entity_components_type_entity ON entity_components (type_id, entity_id);`
+}

package/database/index.ts

@@ -0,0 +1,26 @@
+import {SQL} from "bun";
+import { logger } from "core/Logger";
+
+const db = new SQL({
+    url: `postgres://${process.env.POSTGRES_USER}:${process.env.POSTGRES_PASSWORD}@${process.env.POSTGRES_HOST}:5432/${process.env.POSTGRES_DB}`,
+    // Connection pool settings
+    max: 10, // Maximum connections in pool
+    idleTimeout: 0, // Close idle connections after 30s
+    maxLifetime: 0, // Connection lifetime in seconds (0 = forever)
+    connectionTimeout: 30, // Timeout when establishing new connections
+    onclose: (err) => {
+        if (err) {
+            if((err as unknown as { code: string }).code === "ERR_POSTGRES_IDLE_TIMEOUT") {
+                logger.trace("Closing connection. Idle");
+            } else {
+                logger.error("Database connection closed with error:");
+                logger.error(err);
+            }
+        } else {
+            logger.info("Database connection closed.");
+        }   
+    },
+});
+
+
+export default db;

package/gql/Generator.ts

@@ -0,0 +1,159 @@
+import { GraphQLSchema, GraphQLError } from "graphql";
+import {makeExecutableSchema} from "@graphql-tools/schema";
+import { logger as MainLogger } from "core/Logger";
+const logger = MainLogger.child({ scope: "GraphQLGenerator" });
+export interface GraphQLTypeMeta {
+    name: string;
+    fields: Record<string, string>;
+}
+
+export interface GraphQLOperationMeta {
+    type: "Query" | "Mutation";
+    name?: string;
+    input?: Record<string, string>;
+    output: Record<string, string> | string;
+}
+
+export interface GraphQLFieldMeta {
+    type: string;
+    field: string;
+}
+
+export function GraphQLType(meta: GraphQLTypeMeta) {
+    return (target: any) => {
+        target.__graphqlType = meta;
+    }
+}
+
+export function GraphQLOperation(meta: GraphQLOperationMeta) {
+    return function (target: any, context: ClassMethodDecoratorContext) {
+        if (!target.__graphqlOperations) target.__graphqlOperations = [];
+        const operationName = meta.name ?? context;
+        if (!operationName) {
+            throw new Error("GraphQLOperation: Operation name is required (either meta.name or context.name must be defined)");
+        }
+        const operationMeta = { ...meta, name: operationName, propertyKey: context};
+        target.__graphqlOperations.push(operationMeta);
+    };
+}
+
+export function GraphQLField(meta: GraphQLFieldMeta) {
+    return function (target: any, context: ClassMethodDecoratorContext) {
+        if (!target.__graphqlFields) target.__graphqlFields = [];
+        target.__graphqlFields.push({ ...meta, propertyKey: context });
+    };
+}
+
+export function generateGraphQLSchema(systems: any[]): { schema: GraphQLSchema | null; resolvers: any } {
+    let typeDefs = "";
+    const resolvers: any = { Query: {}, Mutation: {} };
+    const queryFields: string[] = [];
+    const mutationFields: string[] = [];
+
+    systems.forEach(system => {
+        logger.trace(`Processing system: ${system.constructor.name}`);
+        if (system.constructor.__graphqlType) {
+            const { name, fields } = system.constructor.__graphqlType;
+            typeDefs += `type ${name} {\n${Object.entries(fields).map(([k, v]) => `  ${k}: ${v}`).join('\n')}\n}\n`;
+        }
+        if (system.__graphqlOperations) {
+            system.__graphqlOperations.forEach((op: any) => {
+                const { type, name, input, output, propertyKey } = op;
+                let fieldDef = `${name}`;
+                if (input) {
+                    const inputName = `${name}Input`;
+                    typeDefs += `input ${inputName} {\n${Object.entries(input).map(([k, v]) => `  ${k}: ${v}`).join('\n')}\n}\n`;
+                    fieldDef += `(input: ${inputName}!)`;
+                    resolvers[type][name] = async (_: any, args: any, context: any) => {
+                        try {
+                            return await system[propertyKey](args.input || args, context);
+                        } catch (error) {
+                            logger.error(`Error in ${type}.${name}:`);
+                            logger.error(error);
+                            if (error instanceof GraphQLError) {
+                                throw error;
+                            }
+                            throw new GraphQLError(`Internal error in ${name}`, {
+                                extensions: {
+                                    code: "INTERNAL_ERROR",
+                                    originalError: process.env.NODE_ENV === 'development' ? error : undefined
+                                }
+                            });
+                        }
+                    };
+                } else {
+                    resolvers[type][name] = async (_: any, args: any, context: any) => {
+                        try {
+                            return await system[propertyKey]({}, context);
+                        } catch (error) {
+                            logger.error(`Error in ${type}.${name}:`);
+                            logger.error(error);
+                            if (error instanceof GraphQLError) {
+                                throw error;
+                            }
+                            throw new GraphQLError(`Internal error in ${name}`, {
+                                extensions: {
+                                    code: "INTERNAL_ERROR",
+                                    originalError: process.env.NODE_ENV === 'development' ? error : undefined
+                                }
+                            });
+                        }
+                    };
+                }
+                if (typeof output === 'string') {
+                    fieldDef += `: ${output}`;
+                } else if (typeof output === 'object') {
+                    const outputName = `${name}Output`;
+                    typeDefs += `type ${outputName} {\n${Object.entries(output).map(([k, v]) => `  ${k}: ${v}`).join('\n')}\n}\n`;
+                    fieldDef += `: ${outputName}`;
+                }
+                if (type === 'Query') {
+                    queryFields.push(fieldDef);
+                } else if (type === 'Mutation') {
+                    mutationFields.push(fieldDef);
+                }
+            });
+        }
+    });
+
+    // Process field resolvers
+    systems.forEach(system => {
+        if (system.__graphqlFields) {
+            system.__graphqlFields.forEach((fieldMeta: any) => {
+                const { type, field, propertyKey } = fieldMeta;
+                if (!resolvers[type]) resolvers[type] = {};
+                resolvers[type][field] = async (parent: any, args: any, context: any) => {
+                    try {
+                        return await system[propertyKey](parent, args, context);
+                    } catch (error) {
+                        logger.error(`Error in ${type}.${field}:`);
+                        logger.error(error);
+                        if (error instanceof GraphQLError) {
+                            throw error;
+                        }
+                        throw new GraphQLError(`Internal error in ${field}`, {
+                            extensions: {
+                                code: "INTERNAL_ERROR",
+                                originalError: process.env.NODE_ENV === 'development' ? error : undefined
+                            }
+                        });
+                    }
+                };
+            });
+        }
+    });
+
+    if (queryFields.length > 0) {
+        typeDefs += `type Query {\n${queryFields.map(f => `  ${f}`).join('\n')}\n}\n`;
+    }
+    if (mutationFields.length > 0) {
+        typeDefs += `type Mutation {\n${mutationFields.map(f => `  ${f}`).join('\n')}\n}\n`;
+    }
+
+    logger.trace(`System Type Defs: ${typeDefs}`);
+    let schema : GraphQLSchema | null = null;
+    if(typeDefs !== "")  {
+        schema = makeExecutableSchema({ typeDefs, resolvers });
+    }
+    return { schema, resolvers };
+}

package/gql/index.ts

@@ -0,0 +1,96 @@
+import {createSchema, createYoga} from 'graphql-yoga';
+import { GraphQLSchema, GraphQLError } from 'graphql';
+import { GraphQLType, GraphQLField, GraphQLOperation } from './Generator';
+import {GraphQLTypes} from "./types"
+export {
+    GraphQLType,
+    GraphQLField,
+    GraphQLOperation,
+    GraphQLTypes
+}
+interface Entity {
+    id: string;
+    name: string;
+    description: string;
+}
+
+const staticTypeDefs = `
+    type Query {
+        greetings: String
+        entities: [Entity]
+        entity(id: ID!): Entity
+    }
+
+    type Entity {
+        id: ID!
+        name: String!
+        description: String
+    }
+`;
+
+const staticResolvers = {
+    Query: {
+        greetings: (): string => "Hello, world!",
+        entities: (): Entity[] => {
+            // Fetch entities from the database or any other source
+            return [
+                {
+                    id: "1",
+                    name: "Entity 1",
+                    description: "Description for Entity 1"
+                }
+            ];
+        },
+        entity: (_parent: any, args: { id: string }): Entity | null => {
+            const { id } = args;
+            // Fetch a single entity by ID from the database or any other source
+            return null;
+        }
+    }
+};
+
+export function createYogaInstance(schema?: GraphQLSchema) {
+    if (schema) {
+        return createYoga({
+            schema,
+            // Configure error handling to preserve error messages for clients
+            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 });
+                },
+            },
+        });
+    } else {
+        return createYoga({
+            schema: createSchema({
+                typeDefs: staticTypeDefs,
+                resolvers: staticResolvers,
+            }),
+            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 });
+                },
+            },
+        });
+    }
+}
+
+export const yoga = createYogaInstance();

package/gql/types.ts

@@ -0,0 +1,28 @@
+export enum GraphQLScalar {
+    ID = "ID",
+    String = "String",
+    Int = "Int",
+    Float = "Float",
+    Boolean = "Boolean",
+    Date = "Date",
+}
+
+export enum GraphQLTypes {
+    ID_REQUIRED = "ID!",
+    ID_OPTIONAL = "ID",
+    STRING_REQUIRED = "String!",
+    STRING_OPTIONAL = "String",
+    INT_REQUIRED = "Int!",
+    INT_OPTIONAL = "Int",
+    FLOAT_REQUIRED = "Float!",
+    FLOAT_OPTIONAL = "Float",
+    BOOLEAN_REQUIRED = "Boolean!",
+    BOOLEAN_OPTIONAL = "Boolean",
+}
+
+export const GraphQLList = {
+    of: (type: string) => `[${type}]`,
+    ofRequired: (type: string) => `[${type}]!`,
+} as const;
+
+

package/index.ts

@@ -0,0 +1,22 @@
+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";
+export { 
+    App,  
+    ServiceRegistry,
+    BaseService,
+    BaseComponent,
+    Component,
+    CompData,
+    Entity,
+    Query,
+    logger,
+
+    responseError,
+    handleGraphQLError
+};

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "bunsane",
+  "version": "0.1.0",
+  "author": {
+    "name": "yaaruu"
+  },
+  "module": "index.ts",
+  "type": "module",
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "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"
+  },
+  "graphql": {
+    "schema": "https://localhost:3001/graphql",
+    "documents": "**/*.{graphql,js,ts,jsx,tsx}"
+  },
+  "license": "MIT"
+}

package/service/Service.ts

@@ -0,0 +1,7 @@
+class BaseService {
+    constructor() {
+
+    }
+}
+
+export default BaseService;

package/service/ServiceRegistry.ts

@@ -0,0 +1,51 @@
+import type BaseService from "./Service";
+import ApplicationLifecycle, {ApplicationPhase} from "core/ApplicationLifecycle";
+import { generateGraphQLSchema } from "gql/Generator";
+import { GraphQLSchema } from "graphql";
+
+class ServiceRegistry {
+    static #instance: ServiceRegistry;
+
+    private systems: Map<string, BaseService> = new Map();
+    private schema: GraphQLSchema | null = null;
+
+
+    constructor() {
+        
+    }
+
+    public init() {
+        ApplicationLifecycle.addPhaseListener((event) => {
+            switch(event.detail) {
+                case ApplicationPhase.SYSTEM_REGISTERING: {
+                    const systemsArray = Array.from(this.systems.values());
+                    const { schema } = generateGraphQLSchema(systemsArray);
+                    this.schema = schema;
+                    ApplicationLifecycle.setPhase(ApplicationPhase.SYSTEM_READY);
+                    break;
+                };
+            }
+        });
+    }
+
+
+
+    public static get instance() : ServiceRegistry {
+        if (!ServiceRegistry.#instance) {
+            ServiceRegistry.#instance = new ServiceRegistry();
+        }
+        return ServiceRegistry.#instance;
+    }
+
+    public registerService(system: BaseService) {
+        if(!this.systems.has(system.constructor.name)) {
+            this.systems.set(system.constructor.name, system);
+        }
+    }
+
+    public getSchema(): GraphQLSchema | null {
+        return this.schema;
+    }
+}
+
+export default ServiceRegistry.instance;

package/service/index.ts

@@ -0,0 +1,6 @@
+import BaseService from "./Service";
+import { ServiceRegistry } from "index";
+export {
+    BaseService,
+    ServiceRegistry
+}

package/tests/query.test.ts

@@ -0,0 +1,39 @@
+import {describe, test, expect, beforeAll} from "bun:test"
+import App from "core/App"
+import { BaseComponent, CompData, Component } from "core/Components";
+import { Entity } from "core/Entity";
+
+let app;
+beforeAll(async () => {
+    app = new App();
+    await app.waitForAppReady();
+});
+
+@Component
+class TestComponent extends BaseComponent {
+    @CompData()
+    value: string = "";
+}
+
+describe("Query test", async () => {
+    test("Create and Update Entity", async () => {
+        const entity = Entity.Create()
+        .add(TestComponent, {value: "Test"})
+        await entity.save(); 
+        
+        const fetchedEntity = await Entity.FindById(entity.id);
+        expect(fetchedEntity).not.toBeNull();
+        expect(fetchedEntity?.componentList().length).toBe(1);
+
+        await fetchedEntity?.set(TestComponent, {value: "UpdatedTest"});
+        console.log("Updating Entity");
+        await fetchedEntity?.save();
+
+        const updatedEntity = await Entity.FindById(entity.id);
+        expect(updatedEntity).not.toBeNull();
+        expect(updatedEntity?.componentList().length).toBe(1);
+        const comp = await updatedEntity?.get(TestComponent)
+        expect(comp?.value).toBe("UpdatedTest");
+
+    });
+})

package/tsconfig.json

@@ -0,0 +1,34 @@
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false,
+
+    "baseUrl": ".",
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "typeRoots": ["./types", "./node_modules/@types"]
+  }
+}

package/utils/uuid.ts

@@ -0,0 +1,10 @@
+export const uuidv7 = () => {
+  return 'tttttttt-tttt-7xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
+    const r = Math.trunc(Math.random() * 16);
+    const v = c == 'x' ? r : (r & 0x3 | 0x8);
+    return v.toString(16);
+  }).replace(/^[t]{8}-[t]{4}/, function() {
+    const unixtimestamp = Date.now().toString(16).padStart(12, '0');
+    return unixtimestamp.slice(0, 8) + '-' + unixtimestamp.slice(8);
+  });
+}