bunsane 0.3.2 → 0.4.0

package/tests/unit/entity/Entity.requireComponents.test.ts

@@ -1,72 +0,0 @@
-/**
- * Unit tests for Entity.requireComponents (BUNSANE-003).
- * Ensures ComponentTargetHook includeComponents matching sees tag
- * components that weren't eagerly loaded.
- */
-import { describe, test, expect, beforeAll } from 'bun:test';
-import { Entity } from '../../../core/Entity';
-import { BaseComponent } from '../../../core/components/BaseComponent';
-import { Component, CompData } from '../../../core/components/Decorators';
-import { TestUser } from '../../fixtures/components';
-import { ensureComponentsRegistered } from '../../utils';
-
-@Component
-class ReqTag extends BaseComponent {}
-
-@Component
-class ReqData extends BaseComponent {
-    @CompData()
-    value: string = '';
-}
-
-describe('Entity.requireComponents', () => {
-    beforeAll(async () => {
-        await ensureComponentsRegistered(TestUser, ReqTag, ReqData);
-    });
-
-    test('no-op for empty list', async () => {
-        const entity = Entity.Create();
-        await expect(entity.requireComponents([])).resolves.toBeUndefined();
-        expect(entity.componentList().length).toBe(0);
-    });
-
-    test('does nothing when components already in memory', async () => {
-        const entity = Entity.Create();
-        entity.add(ReqTag);
-        const before = entity.componentList().length;
-        await entity.requireComponents([ReqTag]);
-        expect(entity.componentList().length).toBe(before);
-    });
-
-    test('hydrates missing components from DB after save', async () => {
-        const saved = Entity.Create();
-        saved.add(ReqTag);
-        saved.add(ReqData, { value: 'hello' });
-        await saved.save();
-
-        const loaded = new Entity(saved.id);
-        expect(loaded.componentList().length).toBe(0);
-
-        await loaded.requireComponents([ReqTag, ReqData]);
-
-        expect(loaded.hasInMemory(ReqTag)).toBe(true);
-        expect(loaded.hasInMemory(ReqData)).toBe(true);
-        expect(loaded.getInMemory(ReqData)?.value).toBe('hello');
-    });
-
-    test('only fetches missing components, not already-loaded ones', async () => {
-        const saved = Entity.Create();
-        saved.add(ReqTag);
-        saved.add(ReqData, { value: 'mix' });
-        await saved.save();
-
-        const loaded = new Entity(saved.id);
-        await loaded.requireComponents([ReqData]);
-        expect(loaded.hasInMemory(ReqData)).toBe(true);
-        expect(loaded.hasInMemory(ReqTag)).toBe(false);
-
-        await loaded.requireComponents([ReqTag, ReqData]);
-        expect(loaded.hasInMemory(ReqTag)).toBe(true);
-        expect(loaded.getInMemory(ReqData)?.value).toBe('mix');
-    });
-});

package/tests/unit/entity/Entity.test.ts

@@ -1,345 +0,0 @@
-/**
- * Unit tests for Entity class
- * Tests core entity functionality without database interaction
- */
-import { describe, test, expect, beforeAll } from 'bun:test';
-import { Entity } from '../../../core/Entity';
-import { TestUser, TestProduct } from '../../fixtures/components';
-import { ensureComponentsRegistered } from '../../utils';
-
-describe('Entity', () => {
-    beforeAll(async () => {
-        await ensureComponentsRegistered(TestUser, TestProduct);
-    });
-
-    describe('constructor', () => {
-        test('generates a UUID when no id is provided', () => {
-            const entity = new Entity();
-            expect(entity.id).toBeDefined();
-            expect(entity.id.length).toBeGreaterThan(0);
-            // UUIDv7 format check
-            expect(entity.id).toMatch(/^[0-9a-f-]{36}$/i);
-        });
-
-        test('uses provided id when given', () => {
-            const customId = '12345678-1234-1234-1234-123456789abc';
-            const entity = new Entity(customId);
-            expect(entity.id).toBe(customId);
-        });
-
-        test('generates UUID when empty string is provided', () => {
-            const entity = new Entity('');
-            expect(entity.id).toBeDefined();
-            expect(entity.id.length).toBeGreaterThan(0);
-            expect(entity.id).not.toBe('');
-        });
-
-        test('generates UUID when whitespace string is provided', () => {
-            const entity = new Entity('   ');
-            expect(entity.id).toBeDefined();
-            expect(entity.id.trim().length).toBeGreaterThan(0);
-        });
-
-        test('sets dirty flag to true initially', () => {
-            const entity = new Entity();
-            expect((entity as any)._dirty).toBe(true);
-        });
-
-        test('sets persisted flag to false initially', () => {
-            const entity = new Entity();
-            expect(entity._persisted).toBe(false);
-        });
-    });
-
-    describe('add()', () => {
-        test('adds a component to the entity', () => {
-            const entity = new Entity();
-            entity.add(TestUser, { name: 'John', email: 'john@example.com', age: 30 });
-
-            const components = entity.componentList();
-            expect(components.length).toBe(1);
-            expect(components[0]).toBeInstanceOf(TestUser);
-        });
-
-        test('adds component with provided data', () => {
-            const entity = new Entity();
-            entity.add(TestUser, { name: 'Jane', email: 'jane@example.com', age: 25 });
-
-            const component = entity.getInMemory(TestUser);
-            expect(component).toBeDefined();
-            expect(component?.name).toBe('Jane');
-            expect(component?.email).toBe('jane@example.com');
-            expect(component?.age).toBe(25);
-        });
-
-        test('adds component without data (defaults)', () => {
-            const entity = new Entity();
-            entity.add(TestUser);
-
-            const components = entity.componentList();
-            expect(components.length).toBe(1);
-        });
-
-        test('marks entity as dirty after adding component', () => {
-            const entity = new Entity();
-            entity.setDirty(false);
-            entity.add(TestUser, { name: 'Test', email: 'test@test.com', age: 20 });
-            expect((entity as any)._dirty).toBe(true);
-        });
-
-        test('allows adding multiple different components', () => {
-            const entity = new Entity();
-            entity.add(TestUser, { name: 'User', email: 'user@test.com', age: 30 });
-            entity.add(TestProduct, { sku: 'SKU123', name: 'Product', price: 99.99, inStock: true });
-
-            const components = entity.componentList();
-            expect(components.length).toBe(2);
-            expect(entity.getInMemory(TestUser)).toBeDefined();
-            expect(entity.getInMemory(TestProduct)).toBeDefined();
-        });
-
-        test('returns this for method chaining', () => {
-            const entity = new Entity();
-            const result = entity.add(TestUser, { name: 'Test', email: 'test@test.com', age: 20 });
-            expect(result).toBe(entity);
-        });
-    });
-
-    describe('getInMemory()', () => {
-        test('returns component if already loaded', () => {
-            const entity = new Entity();
-            entity.add(TestUser, { name: 'Test', email: 'test@test.com', age: 25 });
-
-            const component = entity.getInMemory(TestUser);
-            expect(component).toBeDefined();
-            expect(component?.name).toBe('Test');
-        });
-
-        test('returns undefined if component not loaded', () => {
-            const entity = new Entity();
-            const component = entity.getInMemory(TestUser);
-            expect(component).toBeUndefined();
-        });
-
-        test('returns correct component type', () => {
-            const entity = new Entity();
-            entity.add(TestUser, { name: 'Test', email: 'test@test.com', age: 25 });
-            entity.add(TestProduct, { sku: 'SKU123', name: 'Product', price: 50, inStock: true });
-
-            const user = entity.getInMemory(TestUser);
-            const product = entity.getInMemory(TestProduct);
-
-            expect(user).toBeInstanceOf(TestUser);
-            expect(product).toBeInstanceOf(TestProduct);
-        });
-    });
-
-    describe('hasInMemory()', () => {
-        test('returns true if component is loaded', () => {
-            const entity = new Entity();
-            entity.add(TestUser, { name: 'Test', email: 'test@test.com', age: 25 });
-            expect(entity.hasInMemory(TestUser)).toBe(true);
-        });
-
-        test('returns false if component is not loaded', () => {
-            const entity = new Entity();
-            expect(entity.hasInMemory(TestUser)).toBe(false);
-        });
-    });
-
-    describe('remove()', () => {
-        test('removes a component from the entity', () => {
-            const entity = new Entity();
-            entity.add(TestUser, { name: 'Test', email: 'test@test.com', age: 25 });
-
-            expect(entity.hasInMemory(TestUser)).toBe(true);
-            const removed = entity.remove(TestUser);
-            expect(removed).toBe(true);
-            expect(entity.hasInMemory(TestUser)).toBe(false);
-        });
-
-        test('returns false if component was not present', () => {
-            const entity = new Entity();
-            const removed = entity.remove(TestUser);
-            expect(removed).toBe(false);
-        });
-
-        test('marks entity as dirty after removing component', () => {
-            const entity = new Entity();
-            entity.add(TestUser, { name: 'Test', email: 'test@test.com', age: 25 });
-            entity.setDirty(false);
-
-            entity.remove(TestUser);
-            expect((entity as any)._dirty).toBe(true);
-        });
-
-        test('tracks removed component for wasRemoved check', () => {
-            const entity = new Entity();
-            entity.add(TestUser, { name: 'Test', email: 'test@test.com', age: 25 });
-            entity.remove(TestUser);
-
-            expect(entity.wasRemoved(TestUser)).toBe(true);
-        });
-    });
-
-    describe('wasRemoved()', () => {
-        test('returns false for component that was never added', () => {
-            const entity = new Entity();
-            expect(entity.wasRemoved(TestUser)).toBe(false);
-        });
-
-        test('returns false for component that is still present', () => {
-            const entity = new Entity();
-            entity.add(TestUser, { name: 'Test', email: 'test@test.com', age: 25 });
-            expect(entity.wasRemoved(TestUser)).toBe(false);
-        });
-
-        test('returns true for removed component', () => {
-            const entity = new Entity();
-            entity.add(TestUser, { name: 'Test', email: 'test@test.com', age: 25 });
-            entity.remove(TestUser);
-            expect(entity.wasRemoved(TestUser)).toBe(true);
-        });
-    });
-
-    describe('componentList()', () => {
-        test('returns empty array for entity without components', () => {
-            const entity = new Entity();
-            expect(entity.componentList()).toEqual([]);
-        });
-
-        test('returns all added components', () => {
-            const entity = new Entity();
-            entity.add(TestUser, { name: 'User', email: 'user@test.com', age: 30 });
-            entity.add(TestProduct, { sku: 'SKU', name: 'Product', price: 10, inStock: true });
-
-            const components = entity.componentList();
-            expect(components.length).toBe(2);
-        });
-    });
-
-    describe('setPersisted() / setDirty()', () => {
-        test('setPersisted updates _persisted flag', () => {
-            const entity = new Entity();
-            expect(entity._persisted).toBe(false);
-            entity.setPersisted(true);
-            expect(entity._persisted).toBe(true);
-        });
-
-        test('setDirty updates _dirty flag', () => {
-            const entity = new Entity();
-            expect((entity as any)._dirty).toBe(true);
-            entity.setDirty(false);
-            expect((entity as any)._dirty).toBe(false);
-        });
-    });
-
-    describe('serialize()', () => {
-        test('serializes entity with id and components', () => {
-            const entity = new Entity('test-id-123');
-            entity.add(TestUser, { name: 'John', email: 'john@example.com', age: 30 });
-
-            const serialized = entity.serialize();
-
-            expect(serialized.id).toBe('test-id-123');
-            expect(serialized.components).toBeDefined();
-            expect(serialized.components.TestUser).toBeDefined();
-            expect(serialized.components.TestUser.name).toBe('John');
-            expect(serialized.components.TestUser.email).toBe('john@example.com');
-        });
-
-        test('serializes multiple components', () => {
-            const entity = new Entity();
-            entity.add(TestUser, { name: 'User', email: 'user@test.com', age: 25 });
-            entity.add(TestProduct, { sku: 'SKU123', name: 'Product', price: 99.99, inStock: true });
-
-            const serialized = entity.serialize();
-
-            expect(Object.keys(serialized.components).length).toBe(2);
-            expect(serialized.components.TestUser).toBeDefined();
-            expect(serialized.components.TestProduct).toBeDefined();
-        });
-
-        test('serializes empty entity', () => {
-            const entity = new Entity('empty-entity');
-            const serialized = entity.serialize();
-
-            expect(serialized.id).toBe('empty-entity');
-            expect(serialized.components).toEqual({});
-        });
-    });
-
-    describe('deserialize()', () => {
-        test('deserializes entity from serialized data', () => {
-            const entity = new Entity();
-            entity.add(TestUser, { name: 'John', email: 'john@example.com', age: 30 });
-            const serialized = entity.serialize();
-
-            const deserialized = Entity.deserialize(serialized);
-
-            expect(deserialized.id).toBe(entity.id);
-            expect(deserialized._persisted).toBe(true);
-            expect((deserialized as any)._dirty).toBe(false);
-        });
-
-        test('returns same entity if already an Entity instance', () => {
-            const entity = new Entity();
-            const result = Entity.deserialize(entity);
-            expect(result).toBe(entity);
-        });
-
-        test('deserializes with multiple components', () => {
-            const entity = new Entity();
-            entity.add(TestUser, { name: 'User', email: 'user@test.com', age: 25 });
-            entity.add(TestProduct, { sku: 'SKU123', name: 'Product', price: 50, inStock: true });
-            const serialized = entity.serialize();
-
-            const deserialized = Entity.deserialize(serialized);
-
-            expect(deserialized.componentList().length).toBe(2);
-        });
-    });
-
-    describe('Clone()', () => {
-        test('creates a new entity with new id', () => {
-            const entity = new Entity('original-id');
-            entity.add(TestUser, { name: 'Original', email: 'original@test.com', age: 30 });
-
-            const clone = Entity.Clone(entity);
-
-            expect(clone.id).not.toBe(entity.id);
-            expect(clone._persisted).toBe(false);
-            expect((clone as any)._dirty).toBe(true);
-        });
-
-        test('clones component data', () => {
-            const entity = new Entity();
-            entity.add(TestUser, { name: 'Original', email: 'original@test.com', age: 30 });
-
-            const clone = Entity.Clone(entity);
-            const clonedUser = clone.getInMemory(TestUser);
-
-            expect(clonedUser?.name).toBe('Original');
-            expect(clonedUser?.email).toBe('original@test.com');
-        });
-
-        test('cloned components have new ids', () => {
-            const entity = new Entity();
-            entity.add(TestUser, { name: 'Original', email: 'original@test.com', age: 30 });
-            const originalUser = entity.getInMemory(TestUser);
-
-            const clone = Entity.Clone(entity);
-            const clonedUser = clone.getInMemory(TestUser);
-
-            expect(clonedUser?.id).not.toBe(originalUser?.id);
-        });
-    });
-
-    describe('Create()', () => {
-        test('creates a new entity instance', () => {
-            const entity = Entity.Create();
-            expect(entity).toBeInstanceOf(Entity);
-            expect(entity.id).toBeDefined();
-        });
-    });
-});

package/tests/unit/gql/depthLimit.test.ts

@@ -1,203 +0,0 @@
-import { describe, test, expect } from "bun:test";
-import {
-    GraphQLSchema,
-    GraphQLObjectType,
-    GraphQLString,
-    GraphQLList,
-    validate,
-    parse,
-} from "graphql";
-import { depthLimitRule } from "../../../gql/depthLimit";
-
-// Build a test schema with nested types: Query -> user -> friends -> friends -> ...
-const UserType: GraphQLObjectType = new GraphQLObjectType({
-    name: "User",
-    fields: () => ({
-        name: { type: GraphQLString },
-        email: { type: GraphQLString },
-        friends: { type: new GraphQLList(UserType) },
-    }),
-});
-
-const schema = new GraphQLSchema({
-    query: new GraphQLObjectType({
-        name: "Query",
-        fields: {
-            user: { type: UserType },
-        },
-    }),
-});
-
-function validateQuery(query: string, maxDepth: number) {
-    const doc = parse(query);
-    const rule = depthLimitRule(maxDepth);
-    return validate(schema, doc, [rule]);
-}
-
-describe("depthLimitRule", () => {
-    test("allows queries within depth limit", () => {
-        const query = `{ user { name } }`;
-        const errors = validateQuery(query, 3);
-        expect(errors).toHaveLength(0);
-    });
-
-    test("allows queries at exact depth boundary", () => {
-        // depth: user(1) -> name(2) = 2
-        const query = `{ user { name } }`;
-        const errors = validateQuery(query, 2);
-        expect(errors).toHaveLength(0);
-    });
-
-    test("rejects queries exceeding depth limit", () => {
-        // depth: user(1) -> friends(2) -> friends(3) -> name(4) = 4
-        const query = `{ user { friends { friends { name } } } }`;
-        const errors = validateQuery(query, 3);
-        expect(errors).toHaveLength(1);
-        expect(errors[0]!.message).toContain("exceeds maximum allowed depth");
-    });
-
-    test("handles deeply nested queries", () => {
-        // depth 5
-        const query = `{
-            user {
-                friends {
-                    friends {
-                        friends {
-                            name
-                        }
-                    }
-                }
-            }
-        }`;
-        const errors = validateQuery(query, 2);
-        expect(errors).toHaveLength(1);
-        expect(errors[0]!.message).toContain("depth 5");
-        expect(errors[0]!.message).toContain("maximum allowed depth of 2");
-    });
-
-    test("handles named fragments correctly", () => {
-        // The fragment expands to depth: friends(2) -> name(3)
-        // Total: user(1) -> friends(2) -> name(3) = 3
-        const query = `
-            fragment FriendFields on User {
-                name
-            }
-            { user { friends { ...FriendFields } } }
-        `;
-        const errors = validateQuery(query, 3);
-        expect(errors).toHaveLength(0);
-    });
-
-    test("rejects named fragments that cause depth violation", () => {
-        // fragment expands: friends -> friends -> name (3 levels from fragment root)
-        // Total: user(1) -> friends(2) -> friends(3) -> name(4) = 4
-        const query = `
-            fragment DeepFriends on User {
-                friends { friends { name } }
-            }
-            { user { ...DeepFriends } }
-        `;
-        const errors = validateQuery(query, 3);
-        expect(errors).toHaveLength(1);
-    });
-
-    test("handles inline fragments correctly", () => {
-        // Inline fragments don't increment depth
-        // depth: user(1) -> ... on User -> name(2) = 2
-        const query = `{
-            user {
-                ... on User {
-                    name
-                }
-            }
-        }`;
-        const errors = validateQuery(query, 2);
-        expect(errors).toHaveLength(0);
-    });
-
-    test("handles inline fragments with nested fields", () => {
-        // user(1) -> ... on User -> friends(2) -> name(3) = 3
-        const query = `{
-            user {
-                ... on User {
-                    friends { name }
-                }
-            }
-        }`;
-        const errors = validateQuery(query, 3);
-        expect(errors).toHaveLength(0);
-
-        const errorsStrict = validateQuery(query, 2);
-        expect(errorsStrict).toHaveLength(1);
-    });
-
-    test("depth 1 only allows scalar root fields", () => {
-        // user -> name = depth 2
-        const query = `{ user { name } }`;
-        const errors = validateQuery(query, 1);
-        expect(errors).toHaveLength(1);
-    });
-
-    test("multiple operations are each checked independently", () => {
-        const query = `
-            query Shallow { user { name } }
-            query Deep { user { friends { friends { friends { name } } } } }
-        `;
-        // maxDepth 2 should pass Shallow (depth=2) but fail Deep (depth=5)
-        const errors = validateQuery(query, 2);
-        expect(errors).toHaveLength(1);
-    });
-
-    test("allows introspection queries regardless of depth", () => {
-        // Real introspection queries go 13+ levels deep
-        const query = `{
-            __schema {
-                types {
-                    name
-                    fields {
-                        name
-                        type {
-                            name
-                            ofType {
-                                name
-                                ofType {
-                                    name
-                                    ofType {
-                                        name
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }`;
-        // depth=8, limit=3 — should still pass because it's introspection
-        const errors = validateQuery(query, 3);
-        expect(errors).toHaveLength(0);
-    });
-
-    test("allows __type introspection queries", () => {
-        const query = `{
-            __type(name: "User") {
-                name
-                fields {
-                    name
-                    type { name ofType { name ofType { name } } }
-                }
-            }
-        }`;
-        const errors = validateQuery(query, 2);
-        expect(errors).toHaveLength(0);
-    });
-
-    test("still limits mixed queries with introspection and user fields", () => {
-        // If a query mixes __schema with user fields, it's NOT pure introspection
-        const query = `{
-            __schema { types { name } }
-            user { friends { friends { friends { name } } } }
-        }`;
-        const errors = validateQuery(query, 3);
-        expect(errors).toHaveLength(1);
-    });
-});