ai-props 2.0.2 → 2.1.3

package/test/ai.test.js

@@ -0,0 +1,267 @@
+/**
+ * Tests for AI() wrapper and component functions
+ */
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { AI, createAIComponent, definePropsSchema, createComponentFactory, composeAIComponents, } from '../src/ai.js';
+import { resetConfig, clearCache } from '../src/index.js';
+// Mock the generateObject function
+vi.mock('ai-functions', () => ({
+    generateObject: vi.fn().mockImplementation(async ({ schema }) => {
+        // Generate mock data based on schema
+        const mockData = {};
+        for (const [key, value] of Object.entries(schema)) {
+            if (typeof value === 'string') {
+                if (value.includes('(number)')) {
+                    mockData[key] = 42;
+                }
+                else if (value.includes('(boolean)')) {
+                    mockData[key] = true;
+                }
+                else {
+                    mockData[key] = `generated-${key}`;
+                }
+            }
+            else if (Array.isArray(value)) {
+                mockData[key] = ['item1', 'item2'];
+            }
+            else if (typeof value === 'object') {
+                mockData[key] = { nested: 'value' };
+            }
+        }
+        return { object: mockData };
+    }),
+    schema: vi.fn((s) => s),
+}));
+describe('AI()', () => {
+    beforeEach(() => {
+        resetConfig();
+        clearCache();
+        vi.clearAllMocks();
+    });
+    it('creates an AI component wrapper', () => {
+        const UserCard = AI({
+            schema: {
+                name: 'User name',
+                bio: 'User biography',
+            },
+        });
+        expect(typeof UserCard).toBe('function');
+        expect(UserCard.schema).toBeDefined();
+        expect(UserCard.generateProps).toBeDefined();
+    });
+    it('generates missing props', async () => {
+        const UserCard = AI({
+            schema: {
+                name: 'User name',
+                bio: 'User biography',
+            },
+        });
+        const props = await UserCard({});
+        expect(props.name).toBe('generated-name');
+        expect(props.bio).toBe('generated-bio');
+    });
+    it('preserves provided props', async () => {
+        const UserCard = AI({
+            schema: {
+                name: 'User name',
+                bio: 'User biography',
+            },
+        });
+        const props = await UserCard({ name: 'John Doe' });
+        expect(props.name).toBe('John Doe');
+        expect(props.bio).toBe('generated-bio');
+    });
+    it('applies defaults', async () => {
+        const UserCard = AI({
+            schema: {
+                name: 'User name',
+                role: 'User role',
+            },
+            defaults: {
+                role: 'member',
+            },
+        });
+        const props = await UserCard({});
+        expect(props.role).toBe('member');
+    });
+    it('throws for missing required props', async () => {
+        const UserCard = AI({
+            schema: {
+                name: 'User name',
+                email: 'Email address',
+            },
+            required: ['email'],
+        });
+        await expect(UserCard({ name: 'John' })).rejects.toThrow('Missing required props');
+    });
+    it('excludes specified props from generation', async () => {
+        const UserCard = AI({
+            schema: {
+                name: 'User name',
+                avatar: 'Avatar URL',
+                internal: 'Internal data',
+            },
+            exclude: ['internal'],
+        });
+        const props = await UserCard({});
+        expect(props.name).toBe('generated-name');
+        expect(props.avatar).toBe('generated-avatar');
+        // internal should not be generated
+        expect(props.internal).toBeUndefined();
+    });
+    it('exposes generateProps method', async () => {
+        const UserCard = AI({
+            schema: {
+                name: 'User name',
+            },
+        });
+        const props = await UserCard.generateProps({ name: 'Context Name' });
+        expect(props).toBeDefined();
+        expect(props.name).toBe('Context Name');
+    });
+});
+describe('createAIComponent', () => {
+    beforeEach(() => {
+        resetConfig();
+        clearCache();
+        vi.clearAllMocks();
+    });
+    it('creates typed AI component', async () => {
+        const ProductCard = createAIComponent({
+            schema: {
+                title: 'Product title',
+                price: 'Price (number)',
+                description: 'Description',
+            },
+        });
+        const props = await ProductCard({});
+        expect(typeof props.title).toBe('string');
+        expect(typeof props.price).toBe('number');
+    });
+});
+describe('definePropsSchema', () => {
+    it('returns schema unchanged', () => {
+        const schema = definePropsSchema({
+            name: 'User name',
+            email: 'Email address',
+        });
+        expect(schema).toEqual({
+            name: 'User name',
+            email: 'Email address',
+        });
+    });
+    it('preserves complex schemas', () => {
+        const schema = definePropsSchema({
+            user: {
+                name: 'Name',
+                profile: {
+                    bio: 'Biography',
+                },
+            },
+            tags: ['Tag list'],
+        });
+        expect(schema.user).toBeDefined();
+        expect(schema.tags).toBeDefined();
+    });
+});
+describe('createComponentFactory', () => {
+    beforeEach(() => {
+        resetConfig();
+        clearCache();
+        vi.clearAllMocks();
+    });
+    it('creates component factory with generate method', async () => {
+        const factory = createComponentFactory({
+            schema: {
+                name: 'Product name',
+                price: 'Price (number)',
+            },
+        });
+        expect(factory.component).toBeDefined();
+        expect(factory.generate).toBeDefined();
+        expect(factory.generateMany).toBeDefined();
+        expect(factory.generateWith).toBeDefined();
+    });
+    it('generates single instance', async () => {
+        const factory = createComponentFactory({
+            schema: {
+                name: 'Product name',
+            },
+        });
+        const product = await factory.generate({ category: 'electronics' });
+        expect(product.name).toBeDefined();
+    });
+    it('generates multiple instances', async () => {
+        const factory = createComponentFactory({
+            schema: {
+                name: 'Product name',
+            },
+        });
+        const products = await factory.generateMany([
+            { category: 'electronics' },
+            { category: 'clothing' },
+            { category: 'food' },
+        ]);
+        expect(products).toHaveLength(3);
+        expect(products[0]?.name).toBeDefined();
+    });
+    it('generates with overrides', async () => {
+        const factory = createComponentFactory({
+            schema: {
+                name: 'Product name',
+                price: 'Price (number)',
+            },
+        });
+        const product = await factory.generateWith({ category: 'tech' }, { price: 99 });
+        expect(product.price).toBe(99);
+        expect(product.name).toBeDefined();
+    });
+});
+describe('composeAIComponents', () => {
+    beforeEach(() => {
+        resetConfig();
+        clearCache();
+        vi.clearAllMocks();
+    });
+    it('composes multiple schemas', async () => {
+        const FullProfile = composeAIComponents({
+            user: {
+                schema: { name: 'User name' },
+            },
+            settings: {
+                schema: { theme: 'Theme preference' },
+            },
+        });
+        expect(FullProfile.schema).toBeDefined();
+        expect(typeof FullProfile).toBe('function');
+    });
+    it('generates composed props', async () => {
+        const FullProfile = composeAIComponents({
+            user: {
+                schema: { name: 'User name' },
+            },
+            settings: {
+                schema: { theme: 'Theme preference' },
+            },
+        });
+        const profile = await FullProfile({
+            user: { name: 'John' },
+            settings: {},
+        });
+        expect(profile.user.name).toBe('John');
+        expect(profile.settings.theme).toBeDefined();
+    });
+    it('generates all missing sections', async () => {
+        const FullProfile = composeAIComponents({
+            user: {
+                schema: { name: 'User name' },
+            },
+            prefs: {
+                schema: { notifications: 'Notifications (boolean)' },
+            },
+        });
+        const profile = await FullProfile({});
+        expect(profile.user).toBeDefined();
+        expect(profile.prefs).toBeDefined();
+    });
+});

package/test/cache.test.js

@@ -0,0 +1,176 @@
+/**
+ * Tests for ai-props cache
+ */
+import { describe, it, expect, beforeEach } from 'vitest';
+import { MemoryPropsCache, LRUPropsCache, createCacheKey, getDefaultCache, configureCache, clearCache, DEFAULT_CACHE_TTL, } from '../src/cache.js';
+describe('createCacheKey', () => {
+    it('creates consistent keys for same inputs', () => {
+        const key1 = createCacheKey({ name: 'string' }, { id: 1 });
+        const key2 = createCacheKey({ name: 'string' }, { id: 1 });
+        expect(key1).toBe(key2);
+    });
+    it('creates different keys for different schemas', () => {
+        const key1 = createCacheKey({ name: 'string' });
+        const key2 = createCacheKey({ name: 'string', age: 'number' });
+        expect(key1).not.toBe(key2);
+    });
+    it('creates different keys for different contexts', () => {
+        const key1 = createCacheKey({ name: 'string' }, { id: 1 });
+        const key2 = createCacheKey({ name: 'string' }, { id: 2 });
+        expect(key1).not.toBe(key2);
+    });
+    it('handles undefined context', () => {
+        const key1 = createCacheKey({ name: 'string' });
+        const key2 = createCacheKey({ name: 'string' }, undefined);
+        expect(key1).toBe(key2);
+    });
+    it('handles string schemas', () => {
+        const key = createCacheKey('user name');
+        expect(typeof key).toBe('string');
+        expect(key.length).toBeGreaterThan(0);
+    });
+    it('creates same key regardless of object key order', () => {
+        const key1 = createCacheKey({ a: '1' }, { x: 1, y: 2 });
+        const key2 = createCacheKey({ a: '1' }, { y: 2, x: 1 });
+        expect(key1).toBe(key2);
+    });
+});
+describe('MemoryPropsCache', () => {
+    let cache;
+    beforeEach(() => {
+        cache = new MemoryPropsCache();
+    });
+    it('stores and retrieves values', () => {
+        cache.set('key1', { name: 'test' });
+        const entry = cache.get('key1');
+        expect(entry).toBeDefined();
+        expect(entry?.props.name).toBe('test');
+    });
+    it('returns undefined for missing keys', () => {
+        const entry = cache.get('nonexistent');
+        expect(entry).toBeUndefined();
+    });
+    it('deletes entries', () => {
+        cache.set('key1', { value: 1 });
+        expect(cache.delete('key1')).toBe(true);
+        expect(cache.get('key1')).toBeUndefined();
+    });
+    it('clears all entries', () => {
+        cache.set('key1', { value: 1 });
+        cache.set('key2', { value: 2 });
+        cache.clear();
+        expect(cache.size).toBe(0);
+        expect(cache.get('key1')).toBeUndefined();
+        expect(cache.get('key2')).toBeUndefined();
+    });
+    it('tracks size correctly', () => {
+        expect(cache.size).toBe(0);
+        cache.set('key1', { value: 1 });
+        expect(cache.size).toBe(1);
+        cache.set('key2', { value: 2 });
+        expect(cache.size).toBe(2);
+        cache.delete('key1');
+        expect(cache.size).toBe(1);
+    });
+    it('respects TTL', async () => {
+        const shortCache = new MemoryPropsCache(50); // 50ms TTL
+        shortCache.set('key1', { value: 1 });
+        expect(shortCache.get('key1')).toBeDefined();
+        // Wait for expiration
+        await new Promise(resolve => setTimeout(resolve, 60));
+        expect(shortCache.get('key1')).toBeUndefined();
+    });
+    it('cleans up expired entries', async () => {
+        const shortCache = new MemoryPropsCache(50);
+        shortCache.set('key1', { value: 1 });
+        shortCache.set('key2', { value: 2 });
+        await new Promise(resolve => setTimeout(resolve, 60));
+        const removed = shortCache.cleanup();
+        expect(removed).toBe(2);
+        expect(shortCache.size).toBe(0);
+    });
+    it('stores entry metadata', () => {
+        cache.set('key1', { value: 1 });
+        const entry = cache.get('key1');
+        expect(entry).toBeDefined();
+        expect(entry?.key).toBe('key1');
+        expect(entry?.timestamp).toBeDefined();
+        expect(typeof entry?.timestamp).toBe('number');
+    });
+});
+describe('LRUPropsCache', () => {
+    let cache;
+    beforeEach(() => {
+        cache = new LRUPropsCache(3); // Max 3 entries
+    });
+    it('stores and retrieves values', () => {
+        cache.set('key1', { value: 1 });
+        const entry = cache.get('key1');
+        expect(entry?.props.value).toBe(1);
+    });
+    it('evicts oldest entries when at capacity', () => {
+        cache.set('key1', { value: 1 });
+        cache.set('key2', { value: 2 });
+        cache.set('key3', { value: 3 });
+        cache.set('key4', { value: 4 }); // Should evict key1
+        expect(cache.get('key1')).toBeUndefined();
+        expect(cache.get('key2')).toBeDefined();
+        expect(cache.get('key3')).toBeDefined();
+        expect(cache.get('key4')).toBeDefined();
+    });
+    it('updates LRU order on access', () => {
+        cache.set('key1', { value: 1 });
+        cache.set('key2', { value: 2 });
+        cache.set('key3', { value: 3 });
+        // Access key1, making it most recently used
+        cache.get('key1');
+        // Add key4, should evict key2 (oldest now)
+        cache.set('key4', { value: 4 });
+        expect(cache.get('key1')).toBeDefined(); // Still there
+        expect(cache.get('key2')).toBeUndefined(); // Evicted
+        expect(cache.get('key3')).toBeDefined();
+        expect(cache.get('key4')).toBeDefined();
+    });
+    it('respects TTL in addition to capacity', async () => {
+        const shortCache = new LRUPropsCache(10, 50); // 50ms TTL
+        shortCache.set('key1', { value: 1 });
+        await new Promise(resolve => setTimeout(resolve, 60));
+        expect(shortCache.get('key1')).toBeUndefined();
+    });
+    it('maintains correct size', () => {
+        cache.set('key1', { value: 1 });
+        cache.set('key2', { value: 2 });
+        cache.set('key3', { value: 3 });
+        expect(cache.size).toBe(3);
+        cache.set('key4', { value: 4 });
+        expect(cache.size).toBe(3); // Still 3 after eviction
+    });
+});
+describe('Default cache management', () => {
+    beforeEach(() => {
+        clearCache();
+    });
+    it('getDefaultCache returns singleton', () => {
+        const cache1 = getDefaultCache();
+        const cache2 = getDefaultCache();
+        expect(cache1).toBe(cache2);
+    });
+    it('configureCache creates new instance with TTL', () => {
+        const oldCache = getDefaultCache();
+        configureCache(1000);
+        const newCache = getDefaultCache();
+        // Should be a different instance
+        expect(newCache).not.toBe(oldCache);
+    });
+    it('clearCache empties the cache', () => {
+        const cache = getDefaultCache();
+        cache.set('key1', { value: 1 });
+        clearCache();
+        expect(cache.size).toBe(0);
+    });
+});
+describe('DEFAULT_CACHE_TTL', () => {
+    it('is 5 minutes in milliseconds', () => {
+        expect(DEFAULT_CACHE_TTL).toBe(5 * 60 * 1000);
+    });
+});