bunsane 0.1.4 → 0.2.0

package/tests/unit/upload/RestUpload.test.ts

@@ -0,0 +1,267 @@
+import { describe, it, expect, beforeEach, mock, spyOn } from "bun:test";
+import {
+    parseFormData,
+    handleUpload,
+    uploadResponse,
+    uploadErrorResponse,
+} from "../../../upload/RestUpload";
+import { UploadManager } from "../../../upload/UploadManager";
+import type { UploadResult } from "../../../types/upload.types";
+
+function createMultipartRequest(
+    files: { name: string; content: string; type: string; fieldName?: string }[],
+    fields?: Record<string, string>,
+): Request {
+    const formData = new FormData();
+    for (const f of files) {
+        const file = new File([f.content], f.name, { type: f.type });
+        formData.append(f.fieldName ?? "file", file);
+    }
+    if (fields) {
+        for (const [k, v] of Object.entries(fields)) {
+            formData.append(k, v);
+        }
+    }
+    return new Request("http://localhost/upload", {
+        method: "POST",
+        body: formData,
+    });
+}
+
+describe("parseFormData", () => {
+    it("extracts files and text fields", async () => {
+        const req = createMultipartRequest(
+            [{ name: "photo.png", content: "imagedata", type: "image/png" }],
+            { description: "My photo", tag: "avatar" },
+        );
+
+        const { files, fields } = await parseFormData(req);
+        expect(files).toHaveLength(1);
+        expect(files[0]!.file.name).toBe("photo.png");
+        expect(files[0]!.fieldName).toBe("file");
+        expect(fields["description"]).toBe("My photo");
+        expect(fields["tag"]).toBe("avatar");
+    });
+
+    it("handles multiple files", async () => {
+        const req = createMultipartRequest([
+            { name: "a.png", content: "a", type: "image/png", fieldName: "photos" },
+            { name: "b.jpg", content: "b", type: "image/jpeg", fieldName: "photos" },
+        ]);
+
+        const { files } = await parseFormData(req);
+        expect(files).toHaveLength(2);
+        expect(files[0]!.file.name).toBe("a.png");
+        expect(files[1]!.file.name).toBe("b.jpg");
+    });
+
+    it("throws for non-multipart Content-Type", async () => {
+        const req = new Request("http://localhost/upload", {
+            method: "POST",
+            body: JSON.stringify({ data: "test" }),
+            headers: { "Content-Type": "application/json" },
+        });
+
+        await expect(parseFormData(req)).rejects.toThrow(
+            "Invalid Content-Type: expected multipart/form-data",
+        );
+    });
+
+    it("returns empty files array when no files in form", async () => {
+        const formData = new FormData();
+        formData.append("name", "test");
+        const req = new Request("http://localhost/upload", {
+            method: "POST",
+            body: formData,
+        });
+
+        const { files, fields } = await parseFormData(req);
+        expect(files).toHaveLength(0);
+        expect(fields.name).toBe("test");
+    });
+});
+
+describe("handleUpload", () => {
+    const successResult: UploadResult = {
+        success: true,
+        uploadId: "uid-1",
+        fileName: "test.png",
+        originalFileName: "photo.png",
+        mimeType: "image/png",
+        size: 1024,
+        path: "uploads/test.png",
+        url: "/uploads/test.png",
+    };
+
+    const failResult: UploadResult = {
+        success: false,
+        error: {
+            uploadId: "uid-2",
+            code: "VALIDATION_FAILED",
+            message: "File too large",
+        },
+    };
+
+    let uploadFileSpy: ReturnType<typeof spyOn>;
+
+    beforeEach(() => {
+        uploadFileSpy = spyOn(
+            UploadManager.getInstance(),
+            "uploadFile",
+        ).mockResolvedValue(successResult);
+        uploadFileSpy.mockClear();
+    });
+
+    it("pipes files through UploadManager", async () => {
+        const req = createMultipartRequest([
+            { name: "photo.png", content: "data", type: "image/png" },
+        ]);
+
+        const result = await handleUpload(req);
+        expect(result.success).toBe(true);
+        expect(result.totalFiles).toBe(1);
+        expect(result.successCount).toBe(1);
+        expect(result.failureCount).toBe(0);
+        expect(result.files).toHaveLength(1);
+        expect(uploadFileSpy).toHaveBeenCalledTimes(1);
+    });
+
+    it("enforces maxFiles limit", async () => {
+        const req = createMultipartRequest([
+            { name: "a.png", content: "a", type: "image/png" },
+            { name: "b.png", content: "b", type: "image/png" },
+            { name: "c.png", content: "c", type: "image/png" },
+        ]);
+
+        await expect(handleUpload(req, { maxFiles: 2 })).rejects.toThrow(
+            "Too many files: received 3, maximum is 2",
+        );
+    });
+
+    it("filters by fieldNames", async () => {
+        const req = createMultipartRequest([
+            { name: "a.png", content: "a", type: "image/png", fieldName: "avatar" },
+            { name: "b.png", content: "b", type: "image/png", fieldName: "banner" },
+        ]);
+
+        const result = await handleUpload(req, { fieldNames: ["avatar"] });
+        expect(result.totalFiles).toBe(1);
+        expect(uploadFileSpy).toHaveBeenCalledTimes(1);
+    });
+
+    it("passes config and storageProvider to UploadManager", async () => {
+        const req = createMultipartRequest([
+            { name: "a.png", content: "a", type: "image/png" },
+        ]);
+        const config = { maxFileSize: 5_000_000 };
+
+        await handleUpload(req, { config, storageProvider: "s3" });
+        expect(uploadFileSpy).toHaveBeenCalledWith(
+            expect.any(File),
+            config,
+            "s3",
+        );
+    });
+
+    it("reports partial failures correctly", async () => {
+        let callCount = 0;
+        uploadFileSpy.mockImplementation(async () => {
+            callCount++;
+            return callCount === 1 ? successResult : failResult;
+        });
+
+        const req = createMultipartRequest([
+            { name: "a.png", content: "a", type: "image/png" },
+            { name: "b.png", content: "b", type: "image/png" },
+        ]);
+
+        const result = await handleUpload(req);
+        expect(result.success).toBe(false);
+        expect(result.successCount).toBe(1);
+        expect(result.failureCount).toBe(1);
+    });
+
+    it("includes text fields in result", async () => {
+        const req = createMultipartRequest(
+            [{ name: "a.png", content: "a", type: "image/png" }],
+            { title: "My Upload" },
+        );
+
+        const result = await handleUpload(req);
+        expect(result.fields.title).toBe("My Upload");
+    });
+});
+
+describe("uploadResponse", () => {
+    it("returns 200 for all-success", () => {
+        const result = {
+            success: true,
+            files: [],
+            fields: {},
+            totalFiles: 2,
+            successCount: 2,
+            failureCount: 0,
+        };
+
+        const res = uploadResponse(result);
+        expect(res.status).toBe(200);
+        expect(res.headers.get("Content-Type")).toBe("application/json");
+    });
+
+    it("returns 207 for partial success", () => {
+        const result = {
+            success: false,
+            files: [],
+            fields: {},
+            totalFiles: 2,
+            successCount: 1,
+            failureCount: 1,
+        };
+
+        const res = uploadResponse(result);
+        expect(res.status).toBe(207);
+    });
+
+    it("returns 400 when all failed", () => {
+        const result = {
+            success: false,
+            files: [],
+            fields: {},
+            totalFiles: 2,
+            successCount: 0,
+            failureCount: 2,
+        };
+
+        const res = uploadResponse(result);
+        expect(res.status).toBe(400);
+    });
+});
+
+describe("uploadErrorResponse", () => {
+    it("returns error JSON with default status", async () => {
+        const res = uploadErrorResponse(new Error("Bad file"));
+        expect(res.status).toBe(400);
+
+        const body = await res.json();
+        expect(body.error).toBe("Bad file");
+        expect(body.code).toBe("UPLOAD_FAILED");
+    });
+
+    it("uses custom code and status", async () => {
+        const res = uploadErrorResponse(
+            new Error("Too big"),
+            "FILE_TOO_LARGE",
+            413,
+        );
+        expect(res.status).toBe(413);
+
+        const body = await res.json();
+        expect(body.code).toBe("FILE_TOO_LARGE");
+    });
+
+    it("handles non-Error values", async () => {
+        const res = uploadErrorResponse("something went wrong");
+        const body = await res.json();
+        expect(body.error).toBe("Unknown upload error");
+    });
+});

package/tests/unit/validateEnv.test.ts

@@ -0,0 +1,82 @@
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { validateEnv } from "../../core/validateEnv";
+
+describe("validateEnv", () => {
+    let savedEnv: NodeJS.ProcessEnv;
+
+    beforeEach(() => {
+        savedEnv = { ...process.env };
+        // Clear all DB-related env vars
+        delete process.env.DB_CONNECTION_URL;
+        delete process.env.POSTGRES_HOST;
+        delete process.env.POSTGRES_USER;
+        delete process.env.POSTGRES_PASSWORD;
+        delete process.env.POSTGRES_DB;
+        delete process.env.POSTGRES_PORT;
+        delete process.env.POSTGRES_MAX_CONNECTIONS;
+        delete process.env.APP_PORT;
+        delete process.env.NODE_ENV;
+        delete process.env.GRAPHQL_MAX_DEPTH;
+    });
+
+    afterEach(() => {
+        process.env = savedEnv;
+    });
+
+    test("passes with DB_CONNECTION_URL", () => {
+        process.env.DB_CONNECTION_URL = "postgres://user:pass@localhost:5432/db";
+        expect(() => validateEnv()).not.toThrow();
+    });
+
+    test("passes with POSTGRES_HOST + POSTGRES_USER + POSTGRES_DB", () => {
+        process.env.POSTGRES_HOST = "localhost";
+        process.env.POSTGRES_USER = "user";
+        process.env.POSTGRES_DB = "testdb";
+        expect(() => validateEnv()).not.toThrow();
+    });
+
+    test("throws when neither DB connection method provided", () => {
+        expect(() => validateEnv()).toThrow("Database connection required");
+    });
+
+    test("throws for non-numeric APP_PORT", () => {
+        process.env.DB_CONNECTION_URL = "postgres://user:pass@localhost:5432/db";
+        process.env.APP_PORT = "abc";
+        expect(() => validateEnv()).toThrow("APP_PORT must be numeric");
+    });
+
+    test("throws for invalid NODE_ENV", () => {
+        process.env.DB_CONNECTION_URL = "postgres://user:pass@localhost:5432/db";
+        process.env.NODE_ENV = "staging";
+        expect(() => validateEnv()).toThrow("Environment validation failed");
+    });
+
+    test("passes when optional vars omitted", () => {
+        process.env.DB_CONNECTION_URL = "postgres://user:pass@localhost:5432/db";
+        // No APP_PORT, NODE_ENV, POSTGRES_PORT, POSTGRES_MAX_CONNECTIONS
+        expect(() => validateEnv()).not.toThrow();
+    });
+
+    test("throws for non-numeric POSTGRES_PORT", () => {
+        process.env.DB_CONNECTION_URL = "postgres://user:pass@localhost:5432/db";
+        process.env.POSTGRES_PORT = "not-a-number";
+        expect(() => validateEnv()).toThrow("POSTGRES_PORT must be numeric");
+    });
+
+    test("throws for non-numeric POSTGRES_MAX_CONNECTIONS", () => {
+        process.env.DB_CONNECTION_URL = "postgres://user:pass@localhost:5432/db";
+        process.env.POSTGRES_MAX_CONNECTIONS = "many";
+        expect(() => validateEnv()).toThrow(
+            "POSTGRES_MAX_CONNECTIONS must be numeric",
+        );
+    });
+
+    test("passes with valid optional numeric fields", () => {
+        process.env.DB_CONNECTION_URL = "postgres://user:pass@localhost:5432/db";
+        process.env.APP_PORT = "3000";
+        process.env.POSTGRES_PORT = "5432";
+        process.env.POSTGRES_MAX_CONNECTIONS = "20";
+        process.env.GRAPHQL_MAX_DEPTH = "15";
+        expect(() => validateEnv()).not.toThrow();
+    });
+});

package/tests/utils/entity-tracker.ts

@@ -0,0 +1,57 @@
+/**
+ * Entity tracker for automatic cleanup in tests
+ */
+import { Entity } from '../../core/Entity';
+
+/**
+ * Tracks entities created during a test for cleanup
+ */
+export class EntityTracker {
+    private entities: Entity[] = [];
+
+    /**
+     * Track an entity for cleanup after the test
+     */
+    track(entity: Entity): Entity {
+        this.entities.push(entity);
+        return entity;
+    }
+
+    /**
+     * Create and track a new entity
+     */
+    create(id?: string): Entity {
+        const entity = new Entity(id);
+        return this.track(entity);
+    }
+
+    /**
+     * Clean up all tracked entities (soft delete by default)
+     */
+    async cleanup(hardDelete: boolean = true): Promise<void> {
+        for (const entity of this.entities) {
+            try {
+                if (entity._persisted) {
+                    await entity.delete(hardDelete);
+                }
+            } catch {
+                // Ignore cleanup errors - entity may already be deleted
+            }
+        }
+        this.entities = [];
+    }
+
+    /**
+     * Get count of tracked entities
+     */
+    get count(): number {
+        return this.entities.length;
+    }
+
+    /**
+     * Get all tracked entities
+     */
+    get all(): Entity[] {
+        return [...this.entities];
+    }
+}

package/tests/utils/index.ts

@@ -0,0 +1,13 @@
+/**
+ * Re-export all test utilities
+ */
+export { EntityTracker } from './entity-tracker';
+export {
+    createTestContext,
+    createTestContextWithoutCache,
+    ensureComponentRegistered,
+    ensureComponentsRegistered,
+    generateTestId,
+    delay,
+    type TestContext
+} from './test-context';

package/tests/utils/test-context.ts

@@ -0,0 +1,149 @@
+/**
+ * Test context factory for setting up and tearing down test environments
+ */
+import { beforeEach, afterEach } from 'bun:test';
+import { EntityTracker } from './entity-tracker';
+import { CacheManager } from '../../core/cache';
+import EntityManager from '../../core/EntityManager';
+import { ComponentRegistry } from '../../core/components';
+import db from '../../database';
+import { preparedStatementCache } from '../../database/PreparedStatementCache';
+
+export interface TestContext {
+    tracker: EntityTracker;
+    cacheManager: CacheManager;
+    db: typeof db;
+}
+
+/**
+ * Creates a test context with automatic setup and cleanup
+ *
+ * Usage:
+ * ```typescript
+ * describe('My Test', () => {
+ *     const ctx = createTestContext();
+ *
+ *     test('should work', async () => {
+ *         const entity = ctx.tracker.create();
+ *         entity.add(MyComponent, { value: 'test' });
+ *         await entity.save();
+ *         // Entity will be automatically cleaned up after test
+ *     });
+ * });
+ * ```
+ */
+export function createTestContext(): TestContext {
+    const tracker = new EntityTracker();
+    let cacheManager: CacheManager;
+
+    beforeEach(async () => {
+        // Ensure EntityManager is ready
+        (EntityManager as any).dbReady = true;
+
+        // Initialize cache with memory provider
+        cacheManager = CacheManager.getInstance();
+        await cacheManager.initialize({
+            enabled: true,
+            provider: 'memory',
+            strategy: 'write-through',
+            defaultTTL: 3600000,
+            entity: { enabled: true, ttl: 3600000 },
+            component: { enabled: true, ttl: 1800000 },
+            query: { enabled: false, ttl: 300000, maxSize: 10000 }
+        });
+
+        // Clear cache before each test
+        await cacheManager.getProvider().clear();
+
+        // Clear prepared statement cache to prevent cache pollution between tests
+        preparedStatementCache.clear();
+    });
+
+    afterEach(async () => {
+        // Clean up tracked entities
+        await tracker.cleanup();
+
+        // Clear cache after test
+        try {
+            await cacheManager?.getProvider().clear();
+        } catch {
+            // Ignore
+        }
+    });
+
+    return {
+        tracker,
+        get cacheManager() {
+            return CacheManager.getInstance();
+        },
+        db
+    };
+}
+
+/**
+ * Creates a test context with cache disabled
+ */
+export function createTestContextWithoutCache(): TestContext {
+    const tracker = new EntityTracker();
+
+    beforeEach(async () => {
+        (EntityManager as any).dbReady = true;
+        const cacheManager = CacheManager.getInstance();
+        await cacheManager.initialize({
+            enabled: false,
+            provider: 'memory',
+            strategy: 'write-through',
+            defaultTTL: 0,
+            entity: { enabled: false, ttl: 0 },
+            component: { enabled: false, ttl: 0 },
+            query: { enabled: false, ttl: 0, maxSize: 10000 }
+        });
+    });
+
+    afterEach(async () => {
+        await tracker.cleanup();
+    });
+
+    return {
+        tracker,
+        get cacheManager() {
+            return CacheManager.getInstance();
+        },
+        db
+    };
+}
+
+/**
+ * Ensures a component is registered before running tests
+ */
+export async function ensureComponentRegistered(
+    componentClass: new (...args: any[]) => any
+): Promise<void> {
+    const componentName = componentClass.name;
+    await ComponentRegistry.getReadyPromise(componentName);
+}
+
+/**
+ * Ensures multiple components are registered before running tests
+ */
+export async function ensureComponentsRegistered(
+    ...componentClasses: Array<new (...args: any[]) => any>
+): Promise<void> {
+    await Promise.all(componentClasses.map(c => ensureComponentRegistered(c)));
+}
+
+/**
+ * Generates a unique test ID
+ */
+export function generateTestId(prefix: string = 'test'): string {
+    const timestamp = Date.now().toString(36);
+    const random = Math.random().toString(36).substring(2, 8);
+    return `${prefix}-${timestamp}-${random}`;
+}
+
+/**
+ * Creates a delay (useful for testing async operations)
+ */
+export function delay(ms: number): Promise<void> {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}

package/tsconfig.json

@@ -30,6 +30,10 @@
 
     "experimentalDecorators": true,
     "emitDecoratorMetadata": true,
-    "typeRoots": ["./types", "./node_modules/@types"]
+    "typeRoots": ["./types", "./node_modules/@types"],
+
+    "paths": {
+      "@/*": ["./*"]
+    }
   }
 }

package/types/archetype.types.ts

@@ -0,0 +1,6 @@
+export interface GetEntityOptions {
+    includeComponents?: string[];
+    excludeComponents?: string[];
+    populateRelations?: boolean;
+    throwOnNotFound?: boolean;
+}

package/types/hooks.types.ts

@@ -3,7 +3,7 @@
  */
 
 import type { Entity } from "../core/Entity";
-import type { BaseComponent } from "../core/Components";
+import type { BaseComponent } from "../core/components";
 import type {
     EntityEvent,
     ComponentEvent,