ai-props 0.1.2 → 2.0.2

package/test/ai.test.ts

@@ -0,0 +1,327 @@
+/**
+ * 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 { configureAIProps, 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: Record<string, unknown> = {}
+    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<{
+      title: string
+      price: number
+      description: string
+    }>({
+      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.ts

@@ -0,0 +1,236 @@
+/**
+ * Tests for ai-props cache
+ */
+
+import { describe, it, expect, beforeEach, vi } 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: MemoryPropsCache
+
+  beforeEach(() => {
+    cache = new MemoryPropsCache()
+  })
+
+  it('stores and retrieves values', () => {
+    cache.set('key1', { name: 'test' })
+    const entry = cache.get<{ name: string }>('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: LRUPropsCache
+
+  beforeEach(() => {
+    cache = new LRUPropsCache(3) // Max 3 entries
+  })
+
+  it('stores and retrieves values', () => {
+    cache.set('key1', { value: 1 })
+    const entry = cache.get<{ value: number }>('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)
+  })
+})