bunsane 0.3.1 → 0.4.0

package/tests/integration/cache/CacheInvalidation.test.ts

@@ -1,259 +0,0 @@
-/**
- * Integration tests for Cache Invalidation
- * Tests cache behavior with entity operations
- */
-import { describe, test, expect, beforeAll, beforeEach, afterEach } from 'bun:test';
-import { Entity } from '../../../core/Entity';
-import { Query } from '../../../query/Query';
-import { CacheManager } from '../../../core/cache/CacheManager';
-import { TestUser, TestProduct } from '../../fixtures/components';
-import { createTestContext, ensureComponentsRegistered, delay } from '../../utils';
-
-describe('Cache Invalidation', () => {
-    const ctx = createTestContext();
-
-    beforeAll(async () => {
-        await ensureComponentsRegistered(TestUser, TestProduct);
-    });
-
-    beforeEach(async () => {
-        // Ensure cache is enabled for these tests
-        await ctx.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 }
-        });
-    });
-
-    describe('entity cache on save', () => {
-        test('entity is cached after save', async () => {
-            const entity = ctx.tracker.create();
-            entity.add(TestUser, { name: 'CacheOnSave', email: 'cache@example.com', age: 30 });
-            await entity.save();
-
-            // Give async cache operations time to complete
-            await delay(50);
-
-            const cached = await ctx.cacheManager.getEntity(entity.id);
-            expect(cached).toBe(entity.id);
-        });
-
-        test('component is cached after save with write-through', async () => {
-            const entity = ctx.tracker.create();
-            entity.add(TestUser, { name: 'CompCache', email: 'compcache@example.com', age: 25 });
-            await entity.save();
-
-            // Give async cache operations time to complete
-            await delay(50);
-
-            const user = entity.getInMemory(TestUser);
-            expect(user).toBeDefined();
-            const typeId = user?.getTypeID();
-            expect(typeId).toBeDefined();
-
-            // With write-through, component data should be in cache
-            const cached = await ctx.cacheManager.getComponentsByEntity(entity.id, typeId);
-            expect(cached).not.toBeUndefined();
-        });
-    });
-
-    describe('cache invalidation on delete', () => {
-        test('entity cache is invalidated on delete', async () => {
-            const entity = ctx.tracker.create();
-            entity.add(TestUser, { name: 'ToInvalidate', email: 'invalidate@example.com', age: 30 });
-            await entity.save();
-
-            await delay(50);
-            const cachedBefore = await ctx.cacheManager.getEntity(entity.id);
-            expect(cachedBefore).toBe(entity.id);
-
-            await entity.delete(true);
-            await delay(50);
-
-            const cachedAfter = await ctx.cacheManager.getEntity(entity.id);
-            expect(cachedAfter).toBeNull();
-        });
-
-        test('component cache is invalidated on delete', async () => {
-            const entity = ctx.tracker.create();
-            entity.add(TestUser, { name: 'CompInvalidate', email: 'compinv@example.com', age: 28 });
-            await entity.save();
-
-            const user = entity.getInMemory(TestUser);
-            const typeId = user?.getTypeID();
-
-            await entity.delete(true);
-            await delay(50);
-
-            const cached = await ctx.cacheManager.getComponentsByEntity(entity.id, typeId);
-            expect(cached).toBeNull();
-        });
-    });
-
-    describe('component cache on update', () => {
-        test('cache updates on component modification', async () => {
-            const entity = ctx.tracker.create();
-            entity.add(TestUser, { name: 'Original', email: 'original@example.com', age: 25 });
-            await entity.save();
-
-            await delay(50);
-
-            // Update component
-            await entity.set(TestUser, { name: 'Updated' });
-            await entity.save();
-
-            await delay(50);
-
-            // Load fresh from DB using Query with component
-            const results = await new Query().findById(entity.id).with(TestUser).exec();
-            const loaded = results[0];
-            const userData = await loaded?.get(TestUser);
-            expect(userData?.name).toBe('Updated');
-        });
-
-        test('removed component is invalidated from cache', async () => {
-            const entity = ctx.tracker.create();
-            entity.add(TestUser, { name: 'ToRemove', email: 'remove@example.com', age: 30 });
-            entity.add(TestProduct, { sku: 'REMOVE', name: 'Remove Prod', price: 10, inStock: true });
-            await entity.save();
-
-            await delay(50);
-
-            // Remove component
-            entity.remove(TestProduct);
-            await entity.save();
-
-            await delay(100);
-
-            // Verify component is gone using get() to load from database
-            const loaded = await Entity.FindById(entity.id);
-            const productData = await loaded?.get(TestProduct);
-            expect(productData).toBeNull();
-        });
-    });
-
-    describe('write-through vs write-invalidate', () => {
-        test('write-through strategy updates cache on save', async () => {
-            await ctx.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 }
-            });
-
-            const entity = ctx.tracker.create();
-            entity.add(TestUser, { name: 'WriteThrough', email: 'wt@example.com', age: 30 });
-            await entity.save();
-
-            await delay(50);
-
-            const cached = await ctx.cacheManager.getEntity(entity.id);
-            expect(cached).toBe(entity.id);
-        });
-
-        test('write-invalidate strategy invalidates stale cache on save', async () => {
-            await ctx.cacheManager.initialize({
-                enabled: true,
-                provider: 'memory',
-                strategy: 'write-invalidate',
-                defaultTTL: 3600000,
-                entity: { enabled: true, ttl: 3600000 },
-                component: { enabled: true, ttl: 1800000 },
-                query: { enabled: false, ttl: 300000, maxSize: 10000 }
-            });
-
-            // Pre-populate cache with stale data
-            const provider = ctx.cacheManager.getProvider();
-            await provider.set('entity:stale-test-id', 'stale-test-id', 3600000);
-
-            // Verify stale data is in cache
-            const before = await provider.get('entity:stale-test-id');
-            expect(before).toBe('stale-test-id');
-
-            // Now create and save a real entity — this triggers invalidation
-            const entity = ctx.tracker.create();
-            entity.add(TestUser, { name: 'WriteInvalidate', email: 'wi@example.com', age: 25 });
-            await entity.save();
-
-            await delay(100);
-
-            // The entity we saved should be retrievable from DB
-            const loaded = await Entity.FindById(entity.id);
-            expect(loaded).not.toBeNull();
-            expect(loaded?.id).toBe(entity.id);
-        });
-    });
-
-    describe('cache disabled', () => {
-        beforeEach(async () => {
-            await ctx.cacheManager.initialize({ enabled: false });
-        });
-
-        test('operations work without cache', async () => {
-            const entity = ctx.tracker.create();
-            entity.add(TestUser, { name: 'NoCache', email: 'nocache@example.com', age: 30 });
-            await entity.save();
-
-            const loaded = await Entity.FindById(entity.id);
-            expect(loaded).not.toBeNull();
-            expect(loaded?.id).toBe(entity.id);
-        });
-
-        test('getEntity returns null when disabled', async () => {
-            const result = await ctx.cacheManager.getEntity('any-id');
-            expect(result).toBeNull();
-        });
-    });
-
-    describe('cache consistency', () => {
-        test('multiple updates maintain consistency', async () => {
-            const entity = ctx.tracker.create();
-            entity.add(TestUser, { name: 'Consistency1', email: 'cons@example.com', age: 20 });
-            await entity.save();
-
-            for (let i = 2; i <= 5; i++) {
-                await entity.set(TestUser, { name: `Consistency${i}`, age: 20 + i });
-                await entity.save();
-                await delay(20);
-            }
-
-            // Load using Query with component to get data in memory
-            const results = await new Query().findById(entity.id).with(TestUser).exec();
-            const loaded = results[0];
-            const userData = await loaded?.get(TestUser);
-            expect(userData?.name).toBe('Consistency5');
-            expect(userData?.age).toBe(25);
-        });
-
-        test('concurrent saves maintain data integrity', async () => {
-            const entity = ctx.tracker.create();
-            entity.add(TestUser, { name: 'Concurrent', email: 'concurrent@example.com', age: 30 });
-            await entity.save();
-
-            // Multiple updates in parallel
-            const updates = [
-                entity.set(TestUser, { age: 31 }),
-                entity.set(TestUser, { age: 32 }),
-                entity.set(TestUser, { age: 33 })
-            ];
-
-            await Promise.all(updates);
-            await entity.save();
-            await delay(50);
-
-            // Load using Query with component
-            const results = await new Query().findById(entity.id).with(TestUser).exec();
-            const loaded = results[0];
-            const userData = await loaded?.get(TestUser);
-            // One of the ages should be set
-            expect([31, 32, 33]).toContain(userData?.age);
-        });
-    });
-});

package/tests/integration/entity/Entity.persistence.test.ts

@@ -1,333 +0,0 @@
-/**
- * Integration tests for Entity persistence
- * Tests entity CRUD operations with the database
- */
-import { describe, test, expect, beforeAll, beforeEach, afterEach } from 'bun:test';
-import { Entity } from '../../../core/Entity';
-import { Query } from '../../../query/Query';
-import { TestUser, TestProduct, TestOrder } from '../../fixtures/components';
-import { createTestContext, ensureComponentsRegistered } from '../../utils';
-
-describe('Entity Persistence', () => {
-    const ctx = createTestContext();
-
-    beforeAll(async () => {
-        await ensureComponentsRegistered(TestUser, TestProduct, TestOrder);
-    });
-
-    describe('save()', () => {
-        test('persists new entity to database', async () => {
-            const entity = ctx.tracker.create();
-            entity.add(TestUser, { name: 'John Doe', email: 'john@example.com', age: 30 });
-
-            await entity.save();
-
-            expect(entity._persisted).toBe(true);
-            expect((entity as any)._dirty).toBe(false);
-        });
-
-        test('persists multiple components', async () => {
-            const entity = ctx.tracker.create();
-            entity.add(TestUser, { name: 'Jane', email: 'jane@example.com', age: 25 });
-            entity.add(TestProduct, { sku: 'SKU001', name: 'Test Product', price: 49.99, inStock: true });
-
-            await entity.save();
-
-            expect(entity._persisted).toBe(true);
-        });
-
-        test('updates existing entity', async () => {
-            const entity = ctx.tracker.create();
-            entity.add(TestUser, { name: 'Original', email: 'original@example.com', age: 20 });
-            await entity.save();
-
-            // Update the entity
-            await entity.set(TestUser, { name: 'Updated', age: 21 });
-            await entity.save();
-
-            // Verify update by loading from database using Query with component
-            const results = await new Query().findById(entity.id).with(TestUser).exec();
-            const loaded = results[0];
-            const user = await loaded?.get(TestUser);
-            expect(user?.name).toBe('Updated');
-            expect(user?.age).toBe(21);
-        });
-
-        test('saves entity with Date field', async () => {
-            const date = new Date('2024-06-15T10:30:00Z');
-            const entity = ctx.tracker.create();
-            entity.add(TestOrder, {
-                orderNumber: 'ORD-001',
-                total: 150.00,
-                status: 'pending',
-                createdAt: date
-            });
-
-            await entity.save();
-
-            // Load with Query specifying component
-            const results = await new Query().findById(entity.id).with(TestOrder).exec();
-            const loaded = results[0];
-            const order = await loaded?.get(TestOrder);
-            expect(order?.createdAt.toISOString()).toBe(date.toISOString());
-        });
-    });
-
-    describe('FindById()', () => {
-        test('loads entity by ID', async () => {
-            const entity = ctx.tracker.create();
-            entity.add(TestUser, { name: 'FindMe', email: 'findme@example.com', age: 40 });
-            await entity.save();
-
-            const loaded = await Entity.FindById(entity.id);
-
-            expect(loaded).not.toBeNull();
-            expect(loaded?.id).toBe(entity.id);
-        });
-
-        test('returns null for non-existent ID', async () => {
-            const loaded = await Entity.FindById('00000000-0000-0000-0000-000000000000');
-            expect(loaded).toBeNull();
-        });
-
-        test('loads entity and components can be fetched via get()', async () => {
-            const entity = ctx.tracker.create();
-            entity.add(TestUser, { name: 'Multi', email: 'multi@example.com', age: 30 });
-            entity.add(TestProduct, { sku: 'MULTI', name: 'Multi Product', price: 10, inStock: true });
-            await entity.save();
-
-            const loaded = await Entity.FindById(entity.id);
-
-            // Use get() to load components from database
-            const userData = await loaded?.get(TestUser);
-            const productData = await loaded?.get(TestProduct);
-            expect(userData).toBeDefined();
-            expect(productData).toBeDefined();
-        });
-
-        test('returns null for empty string ID', async () => {
-            const loaded = await Entity.FindById('');
-            expect(loaded).toBeNull();
-        });
-    });
-
-    describe('Query with components', () => {
-        test('loads entity with components into memory', async () => {
-            const entity = ctx.tracker.create();
-            entity.add(TestUser, { name: 'QueryLoad', email: 'queryload@example.com', age: 35 });
-            await entity.save();
-
-            // Use Query with .with() and .populate() to load component into memory
-            const results = await new Query().findById(entity.id).with(TestUser).populate().exec();
-            const loaded = results[0];
-
-            // After Query.with().populate(), component should be in memory
-            expect(loaded?.hasInMemory(TestUser)).toBe(true);
-            const userData = loaded?.getInMemory(TestUser);
-            expect(userData?.name).toBe('QueryLoad');
-        });
-
-        test('loads multiple components into memory', async () => {
-            const entity = ctx.tracker.create();
-            entity.add(TestUser, { name: 'MultiQuery', email: 'multiquery@example.com', age: 25 });
-            entity.add(TestProduct, { sku: 'MQ001', name: 'Multi Query Product', price: 99.99, inStock: true });
-            await entity.save();
-
-            const results = await new Query()
-                .findById(entity.id)
-                .with(TestUser)
-                .with(TestProduct)
-                .populate()
-                .exec();
-            const loaded = results[0];
-
-            expect(loaded?.hasInMemory(TestUser)).toBe(true);
-            expect(loaded?.hasInMemory(TestProduct)).toBe(true);
-        });
-    });
-
-    describe('delete()', () => {
-        test('soft deletes entity', async () => {
-            const entity = ctx.tracker.create();
-            entity.add(TestUser, { name: 'ToDelete', email: 'delete@example.com', age: 25 });
-            await entity.save();
-
-            await entity.delete();
-
-            const loaded = await Entity.FindById(entity.id);
-            expect(loaded).toBeNull();
-        });
-
-        test('hard deletes entity with force flag', async () => {
-            const entity = ctx.tracker.create();
-            entity.add(TestUser, { name: 'HardDelete', email: 'hard@example.com', age: 30 });
-            await entity.save();
-
-            await entity.delete(true);
-
-            const loaded = await Entity.FindById(entity.id);
-            expect(loaded).toBeNull();
-        });
-
-        test('returns false for non-persisted entity', async () => {
-            const entity = new Entity();
-            const result = await entity.delete();
-            expect(result).toBe(false);
-        });
-    });
-
-    describe('get()', () => {
-        test('loads component from database', async () => {
-            const entity = ctx.tracker.create();
-            entity.add(TestUser, { name: 'LoadTest', email: 'load@example.com', age: 35 });
-            await entity.save();
-
-            // Create a fresh entity with same ID to simulate loading
-            const freshEntity = new Entity(entity.id);
-            freshEntity.setPersisted(true);
-            ctx.tracker.track(freshEntity);
-
-            const userData = await freshEntity.get(TestUser);
-
-            expect(userData).not.toBeNull();
-            expect(userData?.name).toBe('LoadTest');
-            expect(userData?.email).toBe('load@example.com');
-        });
-
-        test('returns null for non-existent component', async () => {
-            const entity = ctx.tracker.create();
-            entity.add(TestUser, { name: 'NoProduct', email: 'noproduct@example.com', age: 20 });
-            await entity.save();
-
-            const productData = await entity.get(TestProduct);
-            expect(productData).toBeNull();
-        });
-
-        test('caches component after loading', async () => {
-            const entity = ctx.tracker.create();
-            entity.add(TestUser, { name: 'CacheTest', email: 'cache@example.com', age: 30 });
-            await entity.save();
-
-            const freshEntity = new Entity(entity.id);
-            freshEntity.setPersisted(true);
-            ctx.tracker.track(freshEntity);
-
-            // First call loads from DB
-            await freshEntity.get(TestUser);
-            // Second call should use cache
-            expect(freshEntity.hasInMemory(TestUser)).toBe(true);
-        });
-    });
-
-    describe('getInstanceOf()', () => {
-        test('returns component instance', async () => {
-            const entity = ctx.tracker.create();
-            entity.add(TestUser, { name: 'Instance', email: 'instance@example.com', age: 28 });
-            await entity.save();
-
-            const user = await entity.getInstanceOf(TestUser);
-
-            expect(user).not.toBeNull();
-            expect(user).toBeInstanceOf(TestUser);
-            expect(user?.name).toBe('Instance');
-        });
-    });
-
-    describe('LoadMultiple()', () => {
-        test('loads multiple entities at once', async () => {
-            const entity1 = ctx.tracker.create();
-            entity1.add(TestUser, { name: 'User1', email: 'user1@example.com', age: 20 });
-            await entity1.save();
-
-            const entity2 = ctx.tracker.create();
-            entity2.add(TestUser, { name: 'User2', email: 'user2@example.com', age: 25 });
-            await entity2.save();
-
-            const loaded = await Entity.LoadMultiple([entity1.id, entity2.id]);
-
-            expect(loaded.length).toBe(2);
-        });
-
-        test('returns empty array for empty input', async () => {
-            const loaded = await Entity.LoadMultiple([]);
-            expect(loaded).toEqual([]);
-        });
-
-        test('filters out invalid IDs', async () => {
-            const entity = ctx.tracker.create();
-            entity.add(TestUser, { name: 'Valid', email: 'valid@example.com', age: 30 });
-            await entity.save();
-
-            const loaded = await Entity.LoadMultiple([entity.id, '', '  ']);
-            expect(loaded.length).toBe(1);
-        });
-    });
-
-    describe('Clone()', () => {
-        test('creates deep clone of entity', async () => {
-            const original = ctx.tracker.create();
-            original.add(TestUser, { name: 'Original', email: 'original@example.com', age: 30 });
-            await original.save();
-
-            const clone = Entity.Clone(original);
-            ctx.tracker.track(clone);
-
-            expect(clone.id).not.toBe(original.id);
-            expect(clone._persisted).toBe(false);
-            expect(clone.getInMemory(TestUser)?.name).toBe('Original');
-        });
-
-        test('cloned entity can be saved independently', async () => {
-            const original = ctx.tracker.create();
-            original.add(TestUser, { name: 'ToClone', email: 'clone@example.com', age: 25 });
-            await original.save();
-
-            const clone = Entity.Clone(original);
-            ctx.tracker.track(clone);
-            await clone.save();
-
-            expect(clone._persisted).toBe(true);
-
-            const loadedClone = await Entity.FindById(clone.id);
-            expect(loadedClone).not.toBeNull();
-        });
-    });
-
-    describe('component removal', () => {
-        test('remove() deletes component on save', async () => {
-            const entity = ctx.tracker.create();
-            entity.add(TestUser, { name: 'Remove', email: 'remove@example.com', age: 30 });
-            entity.add(TestProduct, { sku: 'REM', name: 'Remove Product', price: 10, inStock: true });
-            await entity.save();
-
-            entity.remove(TestProduct);
-            await entity.save();
-
-            // Load entity - only query with TestUser since TestProduct was removed
-            // If we query with both, the entity won't be returned (requires both components)
-            const results = await new Query().findById(entity.id).with(TestUser).populate().exec();
-            const loaded = results[0];
-
-            expect(loaded).toBeDefined();
-            expect(loaded?.hasInMemory(TestUser)).toBe(true);
-
-            // Verify TestProduct was actually removed from database
-            const productData = await loaded?.get(TestProduct);
-            expect(productData).toBeNull();
-        });
-    });
-
-    describe('serialize / deserialize roundtrip', () => {
-        test('entity can be serialized and deserialized', async () => {
-            const entity = ctx.tracker.create();
-            entity.add(TestUser, { name: 'Serialize', email: 'serialize@example.com', age: 35 });
-            await entity.save();
-
-            const serialized = entity.serialize();
-            const deserialized = Entity.deserialize(serialized);
-
-            expect(deserialized.id).toBe(entity.id);
-            expect(deserialized.getInMemory(TestUser)?.name).toBe('Serialize');
-        });
-    });
-});