bunsane 0.1.4 → 0.2.0

package/tests/component.test.ts

@@ -1,339 +0,0 @@
-import { describe, test, expect, beforeAll } from "bun:test";
-import { BaseComponent, CompData, Component } from "../core/Components";
-import type { ComponentDataType } from "../core/Components";
-import { Entity } from "../core/Entity";
-import App from "../core/App";
-import ComponentRegistry from "../core/ComponentRegistry";
-import db from "../database";
-
-// Test component with 'value' attribute (standard assumption)
-@Component
-class ValueComponent extends BaseComponent {
-    @CompData()
-    value: string = "";
-}
-
-// Test component with different attribute name
-@Component
-class CustomAttributeComponent extends BaseComponent {
-    @CompData()
-    customData: string = "";
-}
-
-// Test component with multiple attributes
-@Component
-class MultiAttributeComponent extends BaseComponent {
-    @CompData()
-    title: string = "";
-    @CompData()
-    content: string = "";
-    @CompData({ indexed: true })
-    category: string = "";
-}
-
-// Test component with no data attributes
-@Component
-class NoDataComponent extends BaseComponent {
-    // No @CompData properties
-}
-
-// Test component with numeric value
-@Component
-class NumericComponent extends BaseComponent {
-    @CompData()
-    count: number = 0;
-}
-
-// Test component with boolean value
-@Component
-class BooleanComponent extends BaseComponent {
-    @CompData()
-    enabled: boolean = false;
-}
-
-let app: App;
-
-beforeAll(async () => {
-    app = new App();
-    app.init();
-    await app.waitForAppReady();
-});
-
-describe("Component Edge Cases and Attribute Handling", () => {
-    describe("Component with standard 'value' attribute", () => {
-        test("should correctly identify and return value property", () => {
-            const comp = new ValueComponent();
-            comp.value = "test value";
-
-            const props = comp.properties();
-            expect(props).toContain("value");
-            expect(props).toHaveLength(1);
-
-            const data = comp.data();
-            expect(data.value).toBe("test value");
-        });
-    });
-
-    describe("Component with custom attribute name", () => {
-        test("should correctly identify and return custom property", () => {
-            const comp = new CustomAttributeComponent();
-            comp.customData = "custom data";
-
-            const props = comp.properties();
-            expect(props).toContain("customData");
-            expect(props).toHaveLength(1);
-
-            const data = comp.data();
-            expect(data.customData).toBe("custom data");
-        });
-    });
-
-    describe("Component with multiple attributes", () => {
-        test("should correctly identify all data properties", () => {
-            const comp = new MultiAttributeComponent();
-            comp.title = "Test Title";
-            comp.content = "Test Content";
-            comp.category = "Test Category";
-
-            const props = comp.properties();
-            expect(props).toContain("title");
-            expect(props).toContain("content");
-            expect(props).toContain("category");
-            expect(props).toHaveLength(3);
-
-            const indexedProps = comp.indexedProperties();
-            expect(indexedProps).toContain("category");
-            expect(indexedProps).toHaveLength(1);
-        });
-
-        test("should return all data in data() method", () => {
-            const comp = new MultiAttributeComponent();
-            comp.title = "Title";
-            comp.content = "Content";
-            comp.category = "Category";
-
-            const data = comp.data();
-            expect(data.title).toBe("Title");
-            expect(data.content).toBe("Content");
-            expect(data.category).toBe("Category");
-        });
-    });
-
-    describe("Component with no data attributes", () => {
-        test("should have empty properties array", () => {
-            const comp = new NoDataComponent();
-
-            const props = comp.properties();
-            expect(props).toHaveLength(0);
-
-            const data = comp.data();
-            expect(Object.keys(data)).toHaveLength(0);
-        });
-    });
-
-    describe("Component with numeric attribute", () => {
-        test("should handle numeric values correctly", () => {
-            const comp = new NumericComponent();
-            comp.count = 42;
-
-            const data = comp.data();
-            expect(data.count).toBe(42);
-            expect(typeof data.count).toBe("number");
-        });
-    });
-
-    describe("Component with boolean attribute", () => {
-        test("should handle boolean values correctly", () => {
-            const comp = new BooleanComponent();
-            comp.enabled = true;
-
-            const data = comp.data();
-            expect(data.enabled).toBe(true);
-            expect(typeof data.enabled).toBe("boolean");
-        });
-    });
-
-    describe("Component update operations", () => {
-        test("should handle partial updates for multi-attribute components", () => {
-            const comp = new MultiAttributeComponent();
-            comp.title = "Initial Title";
-            comp.content = "Initial Content";
-            comp.category = "Initial Category";
-
-            // Simulate partial update
-            comp.title = "Updated Title";
-
-            const data = comp.data();
-            expect(data.title).toBe("Updated Title");
-            expect(data.content).toBe("Initial Content");
-            expect(data.category).toBe("Initial Category");
-        });
-    });
-
-    describe("Component type safety and data integrity", () => {
-        test("should maintain type safety for ComponentDataType", () => {
-            const comp = new ValueComponent();
-            comp.value = "test";
-
-            const data: ComponentDataType<ValueComponent> = comp.data();
-            expect(data.value).toBe("test");
-            // TypeScript should prevent accessing non-existent properties
-            // This test ensures the type system works correctly
-        });
-
-        test("should exclude non-data properties from data()", () => {
-            const comp = new ValueComponent();
-            comp.value = "test";
-            // id is not a data property
-            comp.id = "some-id";
-
-            const data = comp.data();
-            expect(data.value).toBe("test");
-            expect((data as any).id).toBeUndefined();
-        });
-    });
-
-    describe("Component registry and type identification", () => {
-        test("should generate unique type IDs for different components", () => {
-            const comp1 = new ValueComponent();
-            const comp2 = new CustomAttributeComponent();
-
-            expect(comp1.getTypeID()).not.toBe(comp2.getTypeID());
-        });
-    });
-
-    describe("Error handling for malformed components", () => {
-        test("should handle components with undefined values gracefully", () => {
-            const comp = new ValueComponent();
-            // value is undefined initially
-
-            const data = comp.data();
-            expect(data.value).toBe(""); // Default value
-        });
-    });
-});
-
-describe("Component Removal from Entities", () => {
-    test("should successfully remove an existing component from an entity", () => {
-        const entity = Entity.Create();
-        entity.add(ValueComponent, { value: "test" });
-
-        // Verify component is added
-        expect(entity.componentList()).toHaveLength(1);
-        expect(entity.componentList()[0]).toBeInstanceOf(ValueComponent);
-
-        // Remove the component
-        const removed = entity.remove(ValueComponent);
-        expect(removed).toBe(true);
-
-        // Verify component is removed
-        expect(entity.componentList()).toHaveLength(0);
-    });
-
-    test("should return false when trying to remove a non-existent component", () => {
-        const entity = Entity.Create();
-
-        // Try to remove a component that was never added
-        const removed = entity.remove(ValueComponent);
-        expect(removed).toBe(false);
-
-        // Entity should still have no components
-        expect(entity.componentList()).toHaveLength(0);
-    });
-
-    test("should remove only the specified component type, leaving others intact", () => {
-        const entity = Entity.Create();
-        entity.add(ValueComponent, { value: "value comp" });
-        entity.add(CustomAttributeComponent, { customData: "custom comp" });
-
-        // Verify both components are added
-        expect(entity.componentList()).toHaveLength(2);
-
-        // Remove only the ValueComponent
-        const removed = entity.remove(ValueComponent);
-        expect(removed).toBe(true);
-
-        // Verify only CustomAttributeComponent remains
-        expect(entity.componentList()).toHaveLength(1);
-        expect(entity.componentList()[0]).toBeInstanceOf(CustomAttributeComponent);
-    });
-
-    test("should mark entity as dirty after component removal", () => {
-        const entity = Entity.Create();
-        entity.add(ValueComponent, { value: "test" });
-
-        // Entity should be dirty after adding
-        expect((entity as any)._dirty).toBe(true);
-
-        // Save to make it clean
-        // Note: We can't actually save without database, but we can set it manually for test
-        entity.setDirty(false);
-        expect((entity as any)._dirty).toBe(false);
-
-        // Remove component
-        entity.remove(ValueComponent);
-
-        // Entity should be dirty again
-        expect((entity as any)._dirty).toBe(true);
-    });
-
-    test("should persist component addition and removal to database", async () => {
-        const entity = Entity.Create();
-        entity.add(ValueComponent, { value: "test value" });
-
-        // Save to database
-        const saveResult = await entity.save();
-        expect(saveResult).toBe(true);
-
-        // Verify component exists in database
-        const componentsAfterAdd = await db`SELECT id, data FROM components WHERE entity_id = ${entity.id} AND deleted_at IS NULL`;
-        expect(componentsAfterAdd.length).toBe(1);
-        expect(componentsAfterAdd[0].data.value).toBe("test value");
-
-        // Remove the component
-        const removed = entity.remove(ValueComponent);
-        expect(removed).toBe(true);
-
-        // Save again to persist removal
-        const saveResult2 = await entity.save();
-        expect(saveResult2).toBe(true);
-
-        // Verify component is removed from database
-        const componentsAfterRemove = await db`SELECT id, data FROM components WHERE entity_id = ${entity.id} AND deleted_at IS NULL`;
-        expect(componentsAfterRemove.length).toBe(0);
-    });
-
-    test("should handle multiple component additions and removals in database", async () => {
-        const entity = Entity.Create();
-        entity.add(ValueComponent, { value: "value comp" });
-        entity.add(CustomAttributeComponent, { customData: "custom comp" });
-
-        // Save to database
-        await entity.save();
-
-        // Verify both components exist
-        const componentsAfterAdd = await db`SELECT type_id, data FROM components WHERE entity_id = ${entity.id} AND deleted_at IS NULL ORDER BY type_id`;
-        expect(componentsAfterAdd.length).toBe(2);
-        const valueComp = componentsAfterAdd.find((c: any) => c.data.value === "value comp");
-        const customComp = componentsAfterAdd.find((c: any) => c.data.customData === "custom comp");
-        expect(valueComp).toBeDefined();
-        expect(customComp).toBeDefined();
-
-        // Remove one component
-        entity.remove(ValueComponent);
-        await entity.save();
-
-        // Verify only custom component remains
-        const componentsAfterRemove = await db`SELECT type_id, data FROM components WHERE entity_id = ${entity.id} AND deleted_at IS NULL`;
-        expect(componentsAfterRemove.length).toBe(1);
-        expect(componentsAfterRemove[0].data.customData).toBe("custom comp");
-
-        // Remove the last component
-        entity.remove(CustomAttributeComponent);
-        await entity.save();
-
-        // Verify no components remain
-        const componentsAfterRemoveAll = await db`SELECT id FROM components WHERE entity_id = ${entity.id} AND deleted_at IS NULL`;
-        expect(componentsAfterRemoveAll.length).toBe(0);
-    });
-});

package/tests/errorHandling.test.ts

@@ -1,155 +0,0 @@
-import { describe, test, expect } from "bun:test";
-import { createUserFriendlyError, handleGraphQLError } from "../core/ErrorHandler";
-import { getErrorMessage, mapZodPathToErrorCode } from "../utils/errorMessages";
-import { GraphQLError } from "graphql";
-import * as z from "zod";
-
-describe('Error Handling Phase 1 Tests', () => {
-    describe('User-Friendly Error Messages', () => {
-        test('should return correct error message for known error code', () => {
-            const errorInfo = getErrorMessage('INVALID_EMAIL');
-            expect(errorInfo.userMessage).toBe('Please enter a valid email address');
-            expect(errorInfo.suggestion).toBe('Check that your email follows the format: name@example.com');
-            expect(errorInfo.category).toBe('validation');
-        });
-
-        test('should return fallback message for unknown error code', () => {
-            const errorInfo = getErrorMessage('UNKNOWN_CODE');
-            expect(errorInfo.userMessage).toBe('An unexpected error occurred');
-            expect(errorInfo.category).toBe('system');
-        });
-
-        test('should map Zod paths to error codes correctly', () => {
-            expect(mapZodPathToErrorCode(['email'])).toBe('INVALID_EMAIL');
-            expect(mapZodPathToErrorCode(['password'])).toBe('TOO_SHORT');
-            expect(mapZodPathToErrorCode(['unknownField'])).toBe('INVALID_FORMAT');
-        });
-    });
-
-    describe('createUserFriendlyError function', () => {
-        test('should create GraphQL error with user-friendly message', () => {
-            const error = createUserFriendlyError('INVALID_EMAIL');
-
-            expect(error).toBeInstanceOf(GraphQLError);
-            expect(error.message).toBe('Please enter a valid email address');
-            expect(error.extensions).toEqual({
-                code: 'INVALID_EMAIL',
-                category: 'validation',
-                suggestion: 'Check that your email follows the format: name@example.com',
-                userFriendly: true
-            });
-        });
-
-        test('should allow custom message override', () => {
-            const customMessage = 'Custom email error';
-            const error = createUserFriendlyError('INVALID_EMAIL', customMessage);
-
-            expect(error.message).toBe(customMessage);
-            expect(error.extensions?.code).toBe('INVALID_EMAIL');
-        });
-
-        test('should merge additional extensions', () => {
-            const error = createUserFriendlyError('INVALID_EMAIL', undefined, {
-                extensions: { additionalField: 'test' }
-            });
-
-            expect(error.extensions?.additionalField).toBe('test');
-            expect(error.extensions?.userFriendly).toBe(true);
-        });
-    });
-
-    describe('handleGraphQLError function', () => {
-        test('should handle Zod validation errors with user-friendly messages', () => {
-            // Create a real Zod error by validating invalid data with a field name
-            const userSchema = z.object({
-                email: z.string().email()
-            });
-            let zodError: z.ZodError;
-
-            try {
-                userSchema.parse({ email: 'invalid-email' });
-            } catch (error) {
-                zodError = error as z.ZodError;
-            }
-
-            expect(() => handleGraphQLError(zodError!)).toThrow(GraphQLError);
-
-            try {
-                handleGraphQLError(zodError!);
-            } catch (error: any) {
-                expect(error.message).toBe('Please enter a valid email address');
-                expect(error.extensions?.code).toBe('VALIDATION_ERROR');
-                expect(error.extensions?.category).toBe('validation');
-                expect(error.extensions?.userFriendly).toBe(true);
-                expect(error.extensions?.validationErrors).toBeDefined();
-                expect(error.extensions?.suggestion).toBe('Check that your email follows the format: name@example.com');
-            }
-        });
-
-        test('should handle multiple Zod validation errors', () => {
-            // Create a schema that will produce multiple validation errors
-            const userSchema = z.object({
-                email: z.string().email(),
-                password: z.string().min(8)
-            });
-
-            let zodError: z.ZodError;
-
-            try {
-                userSchema.parse({
-                    email: 'invalid-email',
-                    password: 'short'
-                });
-            } catch (error) {
-                zodError = error as z.ZodError;
-            }
-
-            expect(() => handleGraphQLError(zodError!)).toThrow(GraphQLError);
-
-            try {
-                handleGraphQLError(zodError!);
-            } catch (error: any) {
-                expect(error.message).toContain('Please enter a valid email address');
-                expect(error.extensions?.validationErrors).toHaveLength(2);
-            }
-        });
-
-        test('should handle empty Zod errors gracefully', () => {
-            const zodError = new z.ZodError([]);
-
-            expect(() => handleGraphQLError(zodError)).toThrow(GraphQLError);
-
-            try {
-                handleGraphQLError(zodError);
-            } catch (error: any) {
-                expect(error.message).toBe('Validation failed');
-                expect(error.extensions?.code).toBe('VALIDATION_ERROR');
-                expect(error.extensions?.userFriendly).toBe(true);
-            }
-        });
-
-        test('should re-throw existing GraphQL errors', () => {
-            const originalError = new GraphQLError('Original error', {
-                extensions: { code: 'ORIGINAL' }
-            });
-
-            expect(() => handleGraphQLError(originalError)).toThrow(originalError);
-        });
-
-        test('should handle unknown errors with user-friendly message', () => {
-            const unknownError = new Error('Some unknown error');
-
-            expect(() => handleGraphQLError(unknownError)).toThrow(GraphQLError);
-
-            try {
-                handleGraphQLError(unknownError);
-            } catch (error: any) {
-                expect(error.message).toBe('Something went wrong on our end');
-                expect(error.extensions?.code).toBe('INTERNAL_ERROR');
-                expect(error.extensions?.category).toBe('system');
-                expect(error.extensions?.suggestion).toBe('Please try again in a few moments. If the problem persists, contact support');
-                expect(error.extensions?.userFriendly).toBe(true);
-            }
-        });
-    });
-});