bunsane 0.1.4 → 0.2.0

package/tests/query-sorting.test.ts

@@ -1,101 +0,0 @@
-import { describe, it, expect, beforeAll, mock } from "bun:test";
-import Query from "../core/Query";
-import { BaseComponent, CompData, Component } from "../core/Components";
-import ComponentRegistry from "../core/ComponentRegistry";
-
-// Define test components
-@Component
-class TestUserComponent extends BaseComponent {
-    @CompData()
-    name: string = "";
-
-    @CompData()
-    age: number = 0;
-
-    @CompData()
-    score: number = 0;
-}
-
-@Component
-class TestPostComponent extends BaseComponent {
-    @CompData()
-    title: string = "";
-
-    @CompData()
-    createdAt: string = "";
-}
-
-describe("Query Sorting", () => {
-    beforeAll(() => {
-        // Mock ComponentRegistry for testing
-        mock.restore();
-
-        // Mock the getComponentId method to return predictable IDs
-        (ComponentRegistry as any).getComponentId = mock((name: string) => {
-            if (name === "TestUserComponent") return "test-user-type-id";
-            if (name === "TestPostComponent") return "test-post-type-id";
-            return undefined;
-        });
-    });
-
-    it("should create a query with sortBy method", () => {
-        const query = new Query();
-        const result = query.with(TestUserComponent).sortBy(TestUserComponent, "age", "DESC");
-
-        expect(result).toBeInstanceOf(Query);
-        expect((result as any).sortOrders).toHaveLength(1);
-        expect((result as any).sortOrders[0]).toEqual({
-            component: "TestUserComponent",
-            property: "age",
-            direction: "DESC",
-            nullsFirst: false
-        });
-    });
-
-    it("should validate component is included in query before sorting", () => {
-        const query = new Query();
-
-        expect(() => {
-            query.sortBy(TestUserComponent, "age");
-        }).toThrow("Cannot sort by component TestUserComponent that is not included in the query");
-    });
-
-    it("should support orderBy with multiple sort orders", () => {
-        const query = new Query();
-        const sortOrders = [
-            { component: "TestUserComponent", property: "age", direction: "DESC" as const },
-            { component: "TestUserComponent", property: "name", direction: "ASC" as const }
-        ];
-
-        const result = query.with(TestUserComponent).orderBy(sortOrders);
-
-        expect((result as any).sortOrders).toEqual(sortOrders);
-    });
-
-    it("should build correct ORDER BY clause for sorting", () => {
-        const query = new Query();
-        query.with(TestUserComponent).sortBy(TestUserComponent, "age", "DESC");
-
-        const orderByClause = (query as any).buildOrderByClause(["test-user-type-id"]);
-
-        expect(orderByClause).toContain("ORDER BY");
-        expect(orderByClause).toContain("DESC");
-        expect(orderByClause).toContain("ec.entity_id ASC");
-    });
-
-    it("should handle nulls first option", () => {
-        const query = new Query();
-        query.with(TestUserComponent).sortBy(TestUserComponent, "age", "ASC", true);
-
-        expect((query as any).sortOrders[0].nullsFirst).toBe(true);
-    });
-
-    it("should build ORDER BY clause with nulls first", () => {
-        const query = new Query();
-        query.with(TestUserComponent).sortBy(TestUserComponent, "age", "ASC", true);
-
-        const orderByClause = (query as any).buildOrderByClause(["test-user-type-id"]);
-
-        expect(orderByClause).toContain("NULLS FIRST");
-    });
-});

package/tests/query.test.ts

@@ -1,81 +0,0 @@
-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";
-import Query from "core/Query";
-import ComponentRegistry from "core/ComponentRegistry";
-
-let app;
-beforeAll(async () => {
-    app = new App();
-    app.init();
-    await app.waitForAppReady();
-});
-
-@Component
-class QueryTestComponent extends BaseComponent {
-    @CompData()
-    value: string = "";
-}
-
-@Component
-class CountTestComponent extends BaseComponent {
-    @CompData()
-    value: string = "";
-}
-
-describe("Query test", async () => {
-    test("Create and Update Entity", async () => {
-        const entity = Entity.Create()
-        .add(QueryTestComponent, {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(QueryTestComponent, {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(QueryTestComponent)
-        expect(comp?.value).toBe("UpdatedTest");
-
-    });
-
-    test("Count method should return total entities matching query", async () => {
-        // Create a few test entities without relying on component registration
-        const entity1 = Entity.Create();
-        const entity2 = Entity.Create();
-        const entity3 = Entity.Create();
-        
-        await entity1.save();
-        await entity2.save();
-        await entity3.save();
-
-        // Test count with specific entity ID
-        const specificCount = await new Query()
-            .findById(entity1.id)
-            .count();
-
-        expect(specificCount).toBe(1);
-
-        // Test count with empty query (no components required)
-        const emptyQueryCount = await new Query().count();
-        expect(emptyQueryCount).toBe(0); // Empty query should return 0
-
-        // Test count with multiple entity IDs by creating a more complex scenario
-        // Since we can't easily test component-based counting without registration,
-        // let's focus on the core functionality that works
-        const entityIds = [entity1.id, entity2.id, entity3.id];
-        
-        // Test that we can count entities that exist
-        for (const id of entityIds) {
-            const count = await new Query().findById(id).count();
-            expect(count).toBe(1);
-        }
-    });
-})

package/tests/relations.test.ts

@@ -1,170 +0,0 @@
-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 { BatchLoader } from "core/BatchLoader";
-import { isFieldRequestedSafe } from "gql/helpers";
-import db from "database";
-
-let app: App;
-
-beforeAll(async () => {
-    app = new App();
-    app.init();
-    await app.waitForAppReady();
-});
-
-beforeEach(async () => {
-    await db`TRUNCATE TABLE entities CASCADE;`;
-});
-
-@Component
-class AuthorComponent extends BaseComponent {
-    @CompData()
-    value: string = ""; // related user id
-}
-
-@Component
-class TitleComponent extends BaseComponent {
-    @CompData()
-    value: string = "";
-}
-
-@Component
-class UserComponent extends BaseComponent {
-    @CompData()
-    name: string = "";
-}
-
-describe('Relations Tests', () => {
-    test('BatchLoader.loadRelatedEntitiesBatched fetches relations in one query', async () => {
-        // Create users
-        const user1 = Entity.Create().add(UserComponent, { name: "User1" });
-        const user2 = Entity.Create().add(UserComponent, { name: "User2" });
-        await Promise.all([user1.save(), user2.save()]);
-
-        // Create posts with authors
-        const post1 = Entity.Create()
-            .add(TitleComponent, { value: "Post1" })
-            .add(AuthorComponent, { value: user1.id });
-        const post2 = Entity.Create()
-            .add(TitleComponent, { value: "Post2" })
-            .add(AuthorComponent, { value: user2.id });
-        await Promise.all([post1.save(), post2.save()]);
-
-        // Test batched loading
-        const loader = async (ids: string[]) => {
-            const entities = await Entity.LoadMultiple(ids);
-            return entities;
-        };
-
-        const result = await BatchLoader.loadRelatedEntitiesBatched([post1, post2], AuthorComponent, loader);
-
-        expect(result.size).toBe(2);
-        expect(result.get(user1.id)?.id).toBe(user1.id);
-        expect(result.get(user2.id)?.id).toBe(user2.id);
-    });
-
-    test('BatchLoader handles large parent list efficiently', async () => {
-        // Create 100 users
-        const users = [];
-        for (let i = 0; i < 100; i++) {
-            const user = Entity.Create().add(UserComponent, { name: `User${i}` });
-            users.push(user);
-        }
-        await Promise.all(users.map(u => u.save()));
-
-        // Create 100 posts with random authors
-        const posts = [];
-        for (let i = 0; i < 100; i++) {
-            const randomUser = users[Math.floor(Math.random() * users.length)]!;
-            const post = Entity.Create()
-                .add(TitleComponent, { value: `Post${i}` })
-                .add(AuthorComponent, { value: randomUser.id });
-            posts.push(post);
-        }
-        await Promise.all(posts.map(p => p.save()));
-
-        // Test batched loading performance
-        const startTime = Date.now();
-        const loader = async (ids: string[]) => {
-            return await Entity.LoadMultiple(ids);
-        };
-
-        const result = await BatchLoader.loadRelatedEntitiesBatched(posts, AuthorComponent, loader);
-        const endTime = Date.now();
-
-        expect(result.size).toBeGreaterThan(0);
-        expect(endTime - startTime).toBeLessThan(1000); // Should complete under 1 second
-    });
-
-    test('isFieldRequestedSafe handles nested selections', () => {
-        const info = {
-            fieldNodes: [{
-                selectionSet: {
-                    selections: [
-                        { kind: 'Field', name: { value: 'id' } },
-                        {
-                            kind: 'Field',
-                            name: { value: 'author' },
-                            selectionSet: {
-                                selections: [{ kind: 'Field', name: { value: 'name' } }]
-                            }
-                        }
-                    ]
-                }
-            }]
-        };
-
-        expect(isFieldRequestedSafe(info, 'id')).toBe(true);
-        expect(isFieldRequestedSafe(info, 'author')).toBe(true);
-        expect(isFieldRequestedSafe(info, 'author', 'name')).toBe(true);
-        expect(isFieldRequestedSafe(info, 'title')).toBe(false);
-    });
-
-    test('isFieldRequestedSafe handles fragments', () => {
-        const info = {
-            fieldNodes: [{
-                selectionSet: {
-                    selections: [
-                        { kind: 'FragmentSpread', name: { value: 'UserFragment' } }
-                    ]
-                }
-            }]
-        };
-
-        // Assuming fragments are expanded, but for test, mock as if selections are there
-        // In real scenario, fragments would be resolved
-        expect(isFieldRequestedSafe(info, 'id')).toBe(false); // since no direct field
-    });
-
-    test('isFieldRequestedSafe handles missing selectionSet', () => {
-        const info = {
-            fieldNodes: [{
-                // no selectionSet
-            }]
-        };
-
-        expect(isFieldRequestedSafe(info, 'id')).toBe(false);
-    });
-
-    test('Entity.doDelete resolves promise correctly', async () => {
-        const entity = Entity.Create().add(TitleComponent, { value: "Test" });
-        await entity.save();
-
-        const deletePromise = entity.delete();
-        await expect(deletePromise).resolves.toBe(true);
-
-        // Verify deleted (soft delete - check deleted_at is set)
-        const check = await db`SELECT id, deleted_at FROM entities WHERE id = ${entity.id}`;
-        expect(check.length).toBe(1);
-        expect(check[0].deleted_at).not.toBeNull();
-    });
-
-    test('Entity.doDelete resolves false for non-persisted entity', async () => {
-        const entity = new Entity(); // not saved
-
-        const deletePromise = entity.delete();
-        await expect(deletePromise).resolves.toBe(false);
-    });
-});