bunsane 0.3.1 → 0.4.0

package/tests/helpers/MockRedisStreamServer.ts

@@ -1,448 +0,0 @@
-/**
- * In-memory Redis Streams shim for Tier 2 integration tests.
- *
- * Implements only the commands the remote subsystem issues:
- *   xadd, xreadgroup, xread, xack, xgroup CREATE, xpending,
- *   xautoclaim, xlen, xrange, ping
- *
- * Shared server: multiple MockRedisClient instances pointing at the same
- * server simulate separate app processes talking to one Redis.
- */
-
-interface StreamEntry {
-    id: string;
-    fields: string[]; // flat [k,v,k,v,...]
-}
-
-interface PelEntry {
-    msgId: string;
-    consumer: string;
-    deliveredAt: number;
-    deliveryCount: number;
-}
-
-interface ConsumerGroup {
-    name: string;
-    consumers: Set<string>;
-    pel: Map<string, PelEntry>;
-    /** Highest ID delivered via ">" — next read starts after this. */
-    lastDeliveredId: string;
-}
-
-interface Stream {
-    key: string;
-    entries: StreamEntry[];
-    groups: Map<string, ConsumerGroup>;
-    lastGeneratedTs: number;
-    seqWithinMs: number;
-}
-
-const MIN_ID = "0-0";
-
-function parseId(id: string): [number, number] {
-    const dash = id.indexOf("-");
-    if (dash < 0) return [Number(id), 0];
-    return [Number(id.slice(0, dash)), Number(id.slice(dash + 1))];
-}
-
-function idLess(a: string, b: string): boolean {
-    const [at, as] = parseId(a);
-    const [bt, bs] = parseId(b);
-    if (at !== bt) return at < bt;
-    return as < bs;
-}
-
-function idGreater(a: string, b: string): boolean {
-    const [at, as] = parseId(a);
-    const [bt, bs] = parseId(b);
-    if (at !== bt) return at > bt;
-    return as > bs;
-}
-
-export class MockRedisStreamServer {
-    private streams = new Map<string, Stream>();
-    /** Fault injection for tests that need to simulate XADD failures. */
-    public xaddShouldFail = false;
-
-    private sleep(ms: number): Promise<void> {
-        return new Promise((r) => setTimeout(r, ms));
-    }
-
-    private getOrCreateStream(key: string): Stream {
-        let s = this.streams.get(key);
-        if (!s) {
-            s = {
-                key,
-                entries: [],
-                groups: new Map(),
-                lastGeneratedTs: 0,
-                seqWithinMs: 0,
-            };
-            this.streams.set(key, s);
-        }
-        return s;
-    }
-
-    private generateId(stream: Stream): string {
-        const now = Date.now();
-        if (now === stream.lastGeneratedTs) {
-            stream.seqWithinMs++;
-        } else {
-            stream.lastGeneratedTs = now;
-            stream.seqWithinMs = 0;
-        }
-        return `${now}-${stream.seqWithinMs}`;
-    }
-
-    /**
-     * XADD key [MAXLEN [~] N] * field value [field value ...]
-     * Returns the generated id.
-     */
-    xadd(key: string, ...args: any[]): string {
-        if (this.xaddShouldFail) {
-            throw new Error("MOCK_XADD_FAIL");
-        }
-        const stream = this.getOrCreateStream(key);
-
-        // Parse leading options
-        let i = 0;
-        let maxLen: number | null = null;
-        if (args[i] === "MAXLEN") {
-            i++;
-            if (args[i] === "~" || args[i] === "=") i++;
-            maxLen = Number(args[i]);
-            i++;
-        }
-
-        // Expect "*"
-        if (args[i] !== "*") {
-            throw new Error(`MockRedis xadd: only "*" auto-id supported, got ${args[i]}`);
-        }
-        i++;
-
-        const fields: string[] = [];
-        for (; i < args.length; i++) {
-            fields.push(String(args[i]));
-        }
-
-        const id = this.generateId(stream);
-        stream.entries.push({ id, fields });
-
-        if (maxLen !== null && stream.entries.length > maxLen) {
-            stream.entries.splice(0, stream.entries.length - maxLen);
-        }
-
-        return id;
-    }
-
-    /**
-     * XGROUP CREATE stream group id [MKSTREAM]
-     * id "$" = start from latest, "0" / "0-0" = start from beginning.
-     */
-    xgroup(op: string, key: string, groupName: string, startId: string, mkstream?: string): string {
-        if (op !== "CREATE") {
-            throw new Error(`MockRedis xgroup: op "${op}" not supported`);
-        }
-        const hasStream = this.streams.has(key);
-        if (!hasStream && mkstream !== "MKSTREAM") {
-            throw new Error("ERR no such key");
-        }
-        const stream = this.getOrCreateStream(key);
-        if (stream.groups.has(groupName)) {
-            const err = new Error(
-                `BUSYGROUP Consumer Group name already exists`
-            );
-            throw err;
-        }
-        const lastDeliveredId =
-            startId === "$"
-                ? stream.entries.length > 0
-                    ? stream.entries[stream.entries.length - 1]!.id
-                    : MIN_ID
-                : startId === "0" || startId === "0-0"
-                  ? MIN_ID
-                  : startId;
-        stream.groups.set(groupName, {
-            name: groupName,
-            consumers: new Set(),
-            pel: new Map(),
-            lastDeliveredId,
-        });
-        return "OK";
-    }
-
-    /**
-     * XREADGROUP GROUP g consumer [COUNT n] [BLOCK ms] STREAMS s ">"
-     * Returns [[streamKey, [[id, fields], ...]]] or null on timeout.
-     */
-    async xreadgroup(...args: any[]): Promise<any> {
-        let i = 0;
-        if (args[i] !== "GROUP") throw new Error("expected GROUP");
-        i++;
-        const groupName = String(args[i++]);
-        const consumer = String(args[i++]);
-        let count = Infinity;
-        let blockMs = 0;
-        while (args[i] !== "STREAMS") {
-            const opt = String(args[i++]).toUpperCase();
-            if (opt === "COUNT") count = Number(args[i++]);
-            else if (opt === "BLOCK") blockMs = Number(args[i++]);
-            else throw new Error(`unknown XREADGROUP opt ${opt}`);
-        }
-        i++; // skip STREAMS
-        const streams: string[] = [];
-        const ids: string[] = [];
-        const remaining = args.slice(i);
-        const half = remaining.length / 2;
-        for (let k = 0; k < half; k++) {
-            streams.push(String(remaining[k]));
-            ids.push(String(remaining[k + half]));
-        }
-
-        const deadline = Date.now() + blockMs;
-        while (true) {
-            const result = this.readGroupOnce(groupName, consumer, count, streams, ids);
-            if (result) return result;
-            if (Date.now() >= deadline) return null;
-            await this.sleep(10);
-        }
-    }
-
-    private readGroupOnce(
-        groupName: string,
-        consumer: string,
-        count: number,
-        streams: string[],
-        ids: string[]
-    ): any[] | null {
-        const out: any[] = [];
-        for (let s = 0; s < streams.length; s++) {
-            const streamKey = streams[s]!;
-            const id = ids[s]!;
-            const stream = this.streams.get(streamKey);
-            if (!stream) continue;
-            const group = stream.groups.get(groupName);
-            if (!group) continue;
-            group.consumers.add(consumer);
-
-            let newEntries: StreamEntry[];
-            if (id === ">") {
-                // New messages only
-                newEntries = stream.entries.filter((e) =>
-                    idGreater(e.id, group.lastDeliveredId)
-                );
-                if (newEntries.length > count) {
-                    newEntries = newEntries.slice(0, count);
-                }
-                for (const entry of newEntries) {
-                    group.lastDeliveredId = entry.id;
-                    const existing = group.pel.get(entry.id);
-                    if (existing) {
-                        existing.deliveryCount++;
-                        existing.deliveredAt = Date.now();
-                        existing.consumer = consumer;
-                    } else {
-                        group.pel.set(entry.id, {
-                            msgId: entry.id,
-                            consumer,
-                            deliveredAt: Date.now(),
-                            deliveryCount: 1,
-                        });
-                    }
-                }
-            } else {
-                // Re-read this consumer's PEL
-                newEntries = stream.entries.filter((e) => {
-                    const p = group.pel.get(e.id);
-                    return p && p.consumer === consumer && idGreater(e.id, id);
-                });
-                if (newEntries.length > count) {
-                    newEntries = newEntries.slice(0, count);
-                }
-            }
-
-            if (newEntries.length > 0) {
-                out.push([
-                    streamKey,
-                    newEntries.map((e) => [e.id, e.fields]),
-                ]);
-            }
-        }
-        return out.length > 0 ? out : null;
-    }
-
-    /**
-     * XREAD [COUNT n] [BLOCK ms] STREAMS s id
-     */
-    async xread(...args: any[]): Promise<any> {
-        let i = 0;
-        let count = Infinity;
-        let blockMs = 0;
-        while (args[i] !== "STREAMS") {
-            const opt = String(args[i++]).toUpperCase();
-            if (opt === "COUNT") count = Number(args[i++]);
-            else if (opt === "BLOCK") blockMs = Number(args[i++]);
-            else throw new Error(`unknown XREAD opt ${opt}`);
-        }
-        i++;
-        const remaining = args.slice(i);
-        const half = remaining.length / 2;
-        const streams: string[] = [];
-        const ids: string[] = [];
-        for (let k = 0; k < half; k++) {
-            streams.push(String(remaining[k]));
-            ids.push(String(remaining[k + half]));
-        }
-
-        // Resolve "$" to the current last id per stream once, up front.
-        // Subsequent polls compare against that snapshot so new entries get
-        // delivered exactly once.
-        const resolvedIds = ids.map((id, k) => {
-            if (id !== "$") return id;
-            const stream = this.streams.get(streams[k]!);
-            if (!stream || stream.entries.length === 0) return MIN_ID;
-            return stream.entries[stream.entries.length - 1]!.id;
-        });
-
-        const deadline = Date.now() + blockMs;
-        while (true) {
-            const out: any[] = [];
-            for (let s = 0; s < streams.length; s++) {
-                const streamKey = streams[s]!;
-                const afterId = resolvedIds[s]!;
-                const stream = this.streams.get(streamKey);
-                if (!stream) continue;
-                const matching = stream.entries
-                    .filter((e) => idGreater(e.id, afterId))
-                    .slice(0, count);
-                if (matching.length > 0) {
-                    out.push([
-                        streamKey,
-                        matching.map((e) => [e.id, e.fields]),
-                    ]);
-                }
-            }
-            if (out.length > 0) return out;
-            if (Date.now() >= deadline) return null;
-            await this.sleep(10);
-        }
-    }
-
-    xack(key: string, groupName: string, msgId: string): number {
-        const stream = this.streams.get(key);
-        if (!stream) return 0;
-        const group = stream.groups.get(groupName);
-        if (!group) return 0;
-        return group.pel.delete(msgId) ? 1 : 0;
-    }
-
-    /**
-     * Two forms:
-     *   XPENDING key group                              -> summary
-     *   XPENDING key group minId maxId count [consumer] -> detail
-     */
-    xpending(key: string, groupName: string, ...args: any[]): any {
-        const stream = this.streams.get(key);
-        if (!stream) return [0, null, null, null];
-        const group = stream.groups.get(groupName);
-        if (!group) return [0, null, null, null];
-
-        if (args.length === 0) {
-            // Summary
-            const ids = Array.from(group.pel.keys()).sort((a, b) =>
-                idLess(a, b) ? -1 : idGreater(a, b) ? 1 : 0
-            );
-            if (ids.length === 0) return [0, null, null, null];
-            const byConsumer = new Map<string, number>();
-            for (const p of group.pel.values()) {
-                byConsumer.set(
-                    p.consumer,
-                    (byConsumer.get(p.consumer) ?? 0) + 1
-                );
-            }
-            return [
-                ids.length,
-                ids[0],
-                ids[ids.length - 1],
-                Array.from(byConsumer.entries()).map(([c, n]) => [c, String(n)]),
-            ];
-        }
-
-        const [minId, maxId, _count] = args;
-        const out: any[] = [];
-        for (const p of group.pel.values()) {
-            if (idLess(p.msgId, minId) || idGreater(p.msgId, maxId)) continue;
-            out.push([
-                p.msgId,
-                p.consumer,
-                Date.now() - p.deliveredAt,
-                p.deliveryCount,
-            ]);
-        }
-        return out;
-    }
-
-    /**
-     * XAUTOCLAIM stream group consumer idleMs cursor [COUNT n]
-     * Returns [nextCursor, entries]
-     */
-    xautoclaim(
-        key: string,
-        groupName: string,
-        consumer: string,
-        idleMs: number,
-        cursor: string,
-        ..._rest: any[]
-    ): any {
-        const stream = this.streams.get(key);
-        if (!stream) return ["0-0", []];
-        const group = stream.groups.get(groupName);
-        if (!group) return ["0-0", []];
-
-        const now = Date.now();
-        const claimed: any[] = [];
-        for (const p of group.pel.values()) {
-            if (now - p.deliveredAt < idleMs) continue;
-            if (idLess(p.msgId, cursor) && cursor !== "0-0") continue;
-            p.consumer = consumer;
-            p.deliveryCount++;
-            p.deliveredAt = now;
-            const entry = stream.entries.find((e) => e.id === p.msgId);
-            if (entry) claimed.push([entry.id, entry.fields]);
-        }
-        return ["0-0", claimed];
-    }
-
-    xlen(key: string): number {
-        return this.streams.get(key)?.entries.length ?? 0;
-    }
-
-    xrange(key: string, start: string, end: string, ..._rest: any[]): any[] {
-        const stream = this.streams.get(key);
-        if (!stream) return [];
-        const lo = start === "-" ? MIN_ID : start;
-        const hi = end === "+" ? "9999999999999-9999" : end;
-        return stream.entries
-            .filter(
-                (e) =>
-                    !idLess(e.id, lo) && !idGreater(e.id, hi)
-            )
-            .map((e) => [e.id, e.fields]);
-    }
-
-    ping(): string {
-        return "PONG";
-    }
-
-    /** Helper for tests: total PEL entries across a group. */
-    getPelSize(streamKey: string, groupName: string): number {
-        return (
-            this.streams.get(streamKey)?.groups.get(groupName)?.pel.size ?? 0
-        );
-    }
-
-    /** Helper for tests: raw stream entry count ignoring groups. */
-    getStreamLength(key: string): number {
-        return this.xlen(key);
-    }
-}

package/tests/integration/archetype/ArcheType.persistence.test.ts

@@ -1,241 +0,0 @@
-/**
- * Integration tests for ArcheType persistence
- * Tests archetype creation and loading with the database
- */
-import { describe, test, expect, beforeAll, beforeEach, afterEach } from 'bun:test';
-import { Entity } from '../../../core/Entity';
-import { Query, FilterOp } from '../../../query/Query';
-import { TestUser, TestProduct, TestOrder } from '../../fixtures/components';
-import { TestUserArchetype, TestUserWithOrdersArchetype } from '../../fixtures/archetypes/TestUserArchetype';
-import { createTestContext, ensureComponentsRegistered } from '../../utils';
-
-describe('ArcheType Persistence', () => {
-    const ctx = createTestContext();
-
-    beforeAll(async () => {
-        await ensureComponentsRegistered(TestUser, TestProduct, TestOrder);
-    });
-
-    describe('createAndSaveEntity()', () => {
-        test('creates and persists entity with archetype components', async () => {
-            const archetype = new TestUserArchetype();
-            archetype.fill({ user: { name: 'ArchetypeSave', email: 'archsave@example.com', age: 30 } });
-            const entity = await archetype.createAndSaveEntity();
-            ctx.tracker.track(entity);
-
-            expect(entity._persisted).toBe(true);
-
-            const loaded = await Entity.FindById(entity.id);
-            expect(loaded).not.toBeNull();
-
-            // Use async get() since component may not be in memory after FindById
-            const userData = await loaded?.get(TestUser);
-            expect(userData?.name).toBe('ArchetypeSave');
-        });
-
-        test('creates entity with multiple components', async () => {
-            const archetype = new TestUserWithOrdersArchetype();
-            archetype.fill({
-                user: { name: 'MultiArch', email: 'multiarch@example.com', age: 28 },
-                order: {
-                    orderNumber: 'ORD-ARCH-001',
-                    total: 199.99,
-                    status: 'completed',
-                    createdAt: new Date()
-                }
-            });
-            const entity = await archetype.createAndSaveEntity();
-            ctx.tracker.track(entity);
-
-            const loaded = await Entity.FindById(entity.id);
-            expect(loaded).not.toBeNull();
-
-            // Load components and verify
-            const userData = await loaded?.get(TestUser);
-            const orderData = await loaded?.get(TestOrder);
-            expect(userData).toBeDefined();
-            expect(orderData).toBeDefined();
-        });
-    });
-
-    describe('createEntity() with fill()', () => {
-        test('creates entity from archetype with data', async () => {
-            const archetype = new TestUserArchetype();
-            archetype.fill({ user: { name: 'FillCreate', email: 'fillcreate@example.com', age: 25 } });
-            const entity = archetype.createEntity();
-            ctx.tracker.track(entity);
-
-            expect(entity).toBeInstanceOf(Entity);
-            expect(entity.id).toBeDefined();
-            expect((entity as any)._dirty).toBe(true);
-            expect(entity._persisted).toBe(false);
-
-            // Component should be in memory after createEntity
-            const userData = entity.getInMemory(TestUser);
-            expect(userData?.name).toBe('FillCreate');
-        });
-
-        test('entity can be saved after creation', async () => {
-            const archetype = new TestUserArchetype();
-            archetype.fill({ user: { name: 'SaveAfter', email: 'saveafter@example.com', age: 30 } });
-            const entity = archetype.createEntity();
-            ctx.tracker.track(entity);
-
-            await entity.save();
-
-            expect(entity._persisted).toBe(true);
-            expect((entity as any)._dirty).toBe(false);
-        });
-    });
-
-    describe('getEntityWithID()', () => {
-        test('loads entity by ID with archetype components', async () => {
-            // Create and save an entity
-            const archetype = new TestUserArchetype();
-            archetype.fill({ user: { name: 'GetWithId', email: 'getwithid@example.com', age: 25 } });
-            const entity = await archetype.createAndSaveEntity();
-            ctx.tracker.track(entity);
-
-            // Load using archetype's getEntityWithID
-            const loadArchetype = new TestUserArchetype();
-            const loaded = await loadArchetype.getEntityWithID(entity.id);
-
-            expect(loaded).not.toBeNull();
-            expect(loaded?.id).toBe(entity.id);
-
-            // Component should be loaded
-            const userData = await loaded?.get(TestUser);
-            expect(userData?.name).toBe('GetWithId');
-        });
-
-        test('returns null for non-existent ID', async () => {
-            const archetype = new TestUserArchetype();
-            const loaded = await archetype.getEntityWithID('00000000-0000-0000-0000-000000000000');
-            expect(loaded).toBeNull();
-        });
-
-        test('returns null for invalid ID', async () => {
-            const archetype = new TestUserArchetype();
-            const loaded = await archetype.getEntityWithID('');
-            expect(loaded).toBeNull();
-        });
-    });
-
-    describe('updateEntity()', () => {
-        test('updates entity with new data', async () => {
-            const archetype = new TestUserArchetype();
-            archetype.fill({ user: { name: 'ToUpdate', email: 'toupdate@example.com', age: 30 } });
-            const entity = await archetype.createAndSaveEntity();
-            ctx.tracker.track(entity);
-
-            // Update the entity
-            await archetype.updateEntity(entity, {
-                user: { name: 'Updated', age: 31 }
-            });
-            await entity.save();
-
-            const loaded = await Entity.FindById(entity.id);
-            const userData = await loaded?.get(TestUser);
-            expect(userData?.name).toBe('Updated');
-            expect(userData?.age).toBe(31);
-        });
-
-        test('preserves unchanged fields', async () => {
-            const archetype = new TestUserArchetype();
-            archetype.fill({ user: { name: 'Preserve', email: 'preserve@example.com', age: 25 } });
-            const entity = await archetype.createAndSaveEntity();
-            ctx.tracker.track(entity);
-
-            // Update only name
-            await archetype.updateEntity(entity, {
-                user: { name: 'PreserveUpdated' }
-            });
-            await entity.save();
-
-            const loaded = await Entity.FindById(entity.id);
-            const userData = await loaded?.get(TestUser);
-            expect(userData?.name).toBe('PreserveUpdated');
-            expect(userData?.email).toBe('preserve@example.com'); // Email unchanged
-        });
-    });
-
-    describe('querying entities with archetype components', () => {
-        beforeEach(async () => {
-            // Create test data
-            for (let i = 0; i < 3; i++) {
-                const archetype = new TestUserArchetype();
-                archetype.fill({
-                    user: {
-                        name: `QueryArchUser${i}`,
-                        email: `queryarch${i}@example.com`,
-                        age: 20 + i * 10
-                    }
-                });
-                const entity = await archetype.createAndSaveEntity();
-                ctx.tracker.track(entity);
-            }
-        });
-
-        test('finds entities via Query with archetype components', async () => {
-            const results = await new Query()
-                .with(TestUser, {
-                    filters: [Query.filter('email', FilterOp.LIKE, 'queryarch%@example.com')]
-                })
-                .populate()
-                .exec();
-
-            expect(results.length).toBeGreaterThanOrEqual(3);
-        });
-
-        test('filters by component field values', async () => {
-            const results = await new Query()
-                .with(TestUser, {
-                    filters: [Query.filter('name', FilterOp.EQ, 'QueryArchUser0')]
-                })
-                .populate()
-                .exec();
-
-            expect(results.length).toBeGreaterThanOrEqual(1);
-            const userData = await results[0]?.get(TestUser);
-            expect(userData?.name).toBe('QueryArchUser0');
-        });
-    });
-
-    describe('Unwrap()', () => {
-        test('unwraps entity to plain object', async () => {
-            const archetype = new TestUserArchetype();
-            archetype.fill({ user: { name: 'Unwrap', email: 'unwrap@example.com', age: 30 } });
-            const entity = await archetype.createAndSaveEntity();
-            ctx.tracker.track(entity);
-
-            const unwrapped = await archetype.Unwrap(entity);
-
-            expect(unwrapped.id).toBe(entity.id);
-            // The unwrapped format may vary - check that user data is present
-            expect(unwrapped.user || unwrapped).toBeDefined();
-        });
-    });
-
-    describe('validation', () => {
-        test('withValidation validates input data', () => {
-            const archetype = new TestUserArchetype();
-
-            // Valid data should pass
-            const validResult = archetype.withValidation({
-                user: { name: 'Valid', email: 'valid@example.com', age: 25 }
-            });
-
-            expect(validResult).toBeDefined();
-        });
-    });
-
-    describe('component properties', () => {
-        test('getComponentsToLoad returns component constructors', () => {
-            const archetype = new TestUserArchetype();
-            const components = (archetype as any).getComponentsToLoad();
-
-            expect(Array.isArray(components)).toBe(true);
-            expect(components.length).toBeGreaterThan(0);
-        });
-    });
-});