bunsane 0.1.4 → 0.2.0

package/gql/visitors/TypeCollectorVisitor.ts

@@ -0,0 +1,79 @@
+import { GraphVisitor } from "./GraphVisitor";
+import { TypeNode, OperationNode, FieldNode, InputNode, ScalarNode } from "../graph/GraphNode";
+
+/**
+ * Visitor that collects all type definitions in dependency order.
+ * Used to gather type definitions before schema generation.
+ */
+export class TypeCollectorVisitor extends GraphVisitor {
+    private collectedTypes: Map<string, string> = new Map();
+    private collectedInputs: Map<string, string> = new Map();
+    private collectedScalars: Set<string> = new Set();
+
+    visitTypeNode(node: TypeNode): void {
+        this.collectedTypes.set(node.name, node.typeDef);
+    }
+
+    visitOperationNode(node: OperationNode): void {
+        // Operations don't define types themselves, but may reference them
+        // This visitor focuses on collecting type definitions
+    }
+
+    visitFieldNode(node: FieldNode): void {
+        // Fields don't define types themselves
+    }
+
+    visitInputNode(node: InputNode): void {
+        this.collectedInputs.set(node.name, node.typeDef);
+    }
+
+    visitScalarNode(node: ScalarNode): void {
+        this.collectedScalars.add(node.name);
+    }
+
+    getResults(): {
+        types: Map<string, string>;
+        inputs: Map<string, string>;
+        scalars: Set<string>;
+    } {
+        return {
+            types: new Map(this.collectedTypes),
+            inputs: new Map(this.collectedInputs),
+            scalars: new Set(this.collectedScalars)
+        };
+    }
+
+    /**
+     * Get all type definitions as a single string in dependency order
+     */
+    getTypeDefsString(): string {
+        const results = this.getResults();
+        let typeDefs = '';
+
+        // Add scalar definitions first
+        for (const scalarName of results.scalars) {
+            typeDefs += `scalar ${scalarName}\n`;
+        }
+
+        // Add input types
+        for (const [name, typeDef] of results.inputs) {
+            typeDefs += `${typeDef}\n`;
+        }
+
+        // Add object types
+        for (const [name, typeDef] of results.types) {
+            typeDefs += `${typeDef}\n`;
+        }
+
+        return typeDefs.trim();
+    }
+
+    /**
+     * Clear all collected types
+     */
+    clear(): void {
+        this.collectedTypes.clear();
+        this.collectedInputs.clear();
+        this.collectedScalars.clear();
+    }
+}

package/gql/visitors/VisitorComposer.ts

@@ -0,0 +1,96 @@
+import { GraphVisitor } from "./GraphVisitor";
+import { SchemaGraph } from "../graph/SchemaGraph";
+
+/**
+ * Composes multiple visitors to run them in sequence on a graph.
+ * Allows chaining visitor operations for complex processing pipelines.
+ */
+export class VisitorComposer {
+    private visitors: GraphVisitor[] = [];
+
+    /**
+     * Add a visitor to the composition
+     */
+    addVisitor(visitor: GraphVisitor): VisitorComposer {
+        this.visitors.push(visitor);
+        return this;
+    }
+
+    /**
+     * Run all visitors on the given graph in sequence
+     */
+    visitGraph(graph: SchemaGraph): Record<string, any> {
+        for (const visitor of this.visitors) {
+            // Call beforeVisit for setup
+            visitor.beforeVisit();
+
+            // Visit all nodes in topological order
+            const sortedNodes = graph.topologicalSort();
+            for (const node of sortedNodes) {
+                visitor.visit(node);
+            }
+
+            // Call afterVisit for cleanup
+            visitor.afterVisit();
+        }
+
+        return this.getResults();
+    }
+
+    /**
+     * Run all visitors on a specific set of nodes
+     */
+    visitNodes(nodes: any[]): Record<string, any> {
+        for (const visitor of this.visitors) {
+            for (const node of nodes) {
+                visitor.visit(node);
+            }
+        }
+
+        return this.getResults();
+    }
+
+    /**
+     * Remove a specific visitor from the composition
+     */
+    removeVisitor(visitor: GraphVisitor): boolean {
+        const index = this.visitors.indexOf(visitor);
+        if (index > -1) {
+            this.visitors.splice(index, 1);
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Clear all visitors from the composer
+     */
+    clearVisitors(): void {
+        this.visitors = [];
+    }
+
+    /**
+     * Get results from all visitors as an object
+     */
+    getResults(): Record<string, any> {
+        const results: Record<string, any> = {};
+        this.visitors.forEach((visitor, index) => {
+            results[`visitor-${index}`] = visitor.getResults();
+        });
+        return results;
+    }
+
+    /**
+     * Get the number of visitors in the composition
+     */
+    size(): number {
+        return this.visitors.length;
+    }
+
+    /**
+     * Get all visitors in the composition
+     */
+    getVisitors(): GraphVisitor[] {
+        return [...this.visitors];
+    }
+}

package/gql/visitors/index.ts

@@ -0,0 +1,7 @@
+export { GraphVisitor } from "./GraphVisitor";
+export { TypeCollectorVisitor } from "./TypeCollectorVisitor";
+export { DeduplicationVisitor } from "./DeduplicationVisitor";
+export { SchemaGeneratorVisitor } from "./SchemaGeneratorVisitor";
+export { ResolverGeneratorVisitor } from "./ResolverGeneratorVisitor";
+export { ArchetypePreprocessorVisitor } from "./ArchetypePreprocessorVisitor";
+export { VisitorComposer } from "./VisitorComposer";

package/package.json

@@ -1,39 +1,61 @@
 {
-  "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"
+    "name": "bunsane",
+    "version": "0.2.0",
+    "author": {
+        "name": "yaaruu"
+    },
+    "keywords": [
+        "bun",
+        "framework",
+        "entity-component-system",
+        "ecs",
+        "graphql",
+        "typescript"
+    ],
+    "module": "index.ts",
+    "type": "module",
+    "scripts": {
+        "build": "bun run build:studio && tsc",
+        "build:studio": "cd studio && bun install && bun run build",
+        "dev": "tsc --watch",
+        "test": "bun test tests/unit tests/integration tests/graphql",
+        "test:all": "bun test tests/",
+        "test:unit": "bun test tests/unit/",
+        "test:integration": "bun test tests/integration/",
+        "test:graphql": "bun test tests/graphql/",
+        "test:pglite": "bun tests/pglite-setup.ts tests/unit tests/integration tests/graphql",
+        "test:pglite:unit": "bun tests/pglite-setup.ts tests/unit/",
+        "test:e2e": "SKIP_TEST_DB_SETUP=true bun test tests/e2e/",
+        "test:stress": "bun test tests/stress --timeout 600000",
+        "test:stress:smoke": "STRESS_RECORD_COUNT=10000 bun test tests/stress --timeout 300000",
+        "test:stress:standard": "STRESS_RECORD_COUNT=100000 bun test tests/stress --timeout 600000",
+        "test:stress:full": "STRESS_RECORD_COUNT=1000000 bun test tests/stress --timeout 1800000"
+    },
+    "devDependencies": {
+        "@electric-sql/pglite": "^0.3.15",
+        "@electric-sql/pglite-socket": "^0.0.20",
+        "@types/bun": "latest",
+        "@types/node": "^25.0.3",
+        "knip": "^5.78.0"
+    },
+    "peerDependencies": {
+        "typescript": "^5.9.3"
+    },
+    "dependencies": {
+        "@gqloom/core": "^0.12.0",
+        "@gqloom/zod": "^0.12.2",
+        "dataloader": "2.2.2",
+        "graphql": "16.11.0",
+        "graphql-yoga": "5.15.1",
+        "ioredis": "5.8.2",
+        "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

@@ -1,5 +1,5 @@
-import type App from "core/App";
-import type { ApplicationPhase } from "core/ApplicationLifecycle";
+import type App from "../core/App";
+import type { ApplicationPhase } from "../core/ApplicationLifecycle";
 
 abstract class BasePlugin {
     name!: string;

package/query/CTENode.ts

@@ -0,0 +1,97 @@
+import { QueryNode } from "./QueryNode";
+import type { QueryResult } from "./QueryNode";
+import { QueryContext } from "./QueryContext";
+
+export class CTENode extends QueryNode {
+    public execute(context: QueryContext): QueryResult {
+        // Generate CTE for base entity filtering
+        const componentIds = Array.from(context.componentIds);
+        const excludedIds = Array.from(context.excludedComponentIds);
+
+        if (componentIds.length === 0) {
+            throw new Error("CTENode requires at least one component type to filter on");
+        }
+
+        let cteSql = "WITH base_entities AS (\n";
+        cteSql += "    SELECT DISTINCT ec.entity_id\n";
+        cteSql += "    FROM entity_components ec\n";
+        cteSql += "    WHERE ec.type_id IN (";
+
+        // Add component type placeholders
+        const typePlaceholders = componentIds.map((_, index) => `$${context.addParam(componentIds[index])}`).join(', ');
+        cteSql += typePlaceholders + ")\n";
+        cteSql += "    AND ec.deleted_at IS NULL\n";
+
+        // Add cursor-based pagination filter in CTE (more efficient than OFFSET)
+        if (context.cursorId !== null) {
+            const operator = context.cursorDirection === 'after' ? '>' : '<';
+            cteSql += `    AND ec.entity_id ${operator} $${context.addParam(context.cursorId)}\n`;
+        }
+
+        // Add exclusions if any
+        if (excludedIds.length > 0) {
+            const excludedPlaceholders = excludedIds.map((id) => `$${context.addParam(id)}`).join(', ');
+            cteSql += `    AND NOT EXISTS (\n`;
+            cteSql += `        SELECT 1 FROM entity_components ec_ex\n`;
+            cteSql += `        WHERE ec_ex.entity_id = ec.entity_id\n`;
+            cteSql += `        AND ec_ex.type_id IN (${excludedPlaceholders})\n`;
+            cteSql += `        AND ec_ex.deleted_at IS NULL\n`;
+            cteSql += `    )\n`;
+        }
+
+        // Add entity exclusions if any
+        if (context.excludedEntityIds.size > 0) {
+            const entityExcludedIds = Array.from(context.excludedEntityIds);
+            const entityPlaceholders = entityExcludedIds.map((id) => `$${context.addParam(id)}`).join(', ');
+            cteSql += `    AND ec.entity_id NOT IN (${entityPlaceholders})\n`;
+        }
+
+        // Group by entity_id to count distinct component types
+        // This ensures entities have ALL required components
+        cteSql += `    GROUP BY ec.entity_id\n`;
+        cteSql += `    HAVING COUNT(DISTINCT ec.type_id) >= $${context.addParam(componentIds.length)}\n`;
+
+        // Add ORDER BY for deterministic pagination results
+        // Must be before LIMIT/OFFSET for consistent page results
+        // Reverse order for 'before' cursor direction
+        const orderDirection = context.cursorDirection === 'before' ? 'DESC' : 'ASC';
+        cteSql += `    ORDER BY ec.entity_id ${orderDirection}\n`;
+
+        // Check if there are component filters - if so, pagination must happen AFTER filtering
+        // Otherwise we'd limit results before applying filters, causing incorrect results
+        const hasComponentFilters = context.componentFilters.size > 0;
+
+        // Add LIMIT/OFFSET at CTE level ONLY when there are no component filters
+        // When filters exist, pagination must be applied after LATERAL joins filter the results
+        if (!hasComponentFilters) {
+            if (context.limit !== null) {
+                cteSql += `    LIMIT $${context.addParam(context.limit)}\n`;
+            }
+            // Only include OFFSET when not using cursor-based pagination
+            if (context.cursorId === null && (context.offsetValue > 0 || context.limit !== null)) {
+                cteSql += `    OFFSET $${context.addParam(context.offsetValue)}\n`;
+            }
+            // Mark pagination as handled at CTE level to prevent double application
+            context.paginationAppliedInCTE = true;
+        } else {
+            // Pagination will be applied later, after filters
+            context.paginationAppliedInCTE = false;
+        }
+
+        cteSql += ")";
+
+        // Mark CTE as available in context
+        context.hasCTE = true;
+        context.cteName = "base_entities";
+
+        return {
+            sql: cteSql,
+            params: context.params,
+            context
+        };
+    }
+
+    public getNodeType(): string {
+        return "CTENode";
+    }
+}