digital-workers 2.1.3 → 2.4.0

package/test/image.test.ts

@@ -0,0 +1,398 @@
+/**
+ * Tests for image() - Image generation primitive
+ *
+ * The image() function provides image generation with rich metadata
+ * about the generation process. It returns ImageResult with URL,
+ * prompt, and metadata (model, size, style, duration).
+ *
+ * These tests use real AI calls via the Cloudflare AI Gateway.
+ * Tests are skipped if AI_GATEWAY_URL and OPENAI_API_KEY are not configured.
+ */
+
+import { describe, it, expect } from 'vitest'
+import { image } from '../src/index.js'
+
+// Skip tests if no gateway configured
+const hasGateway = !!process.env.AI_GATEWAY_URL || !!process.env.IMAGE_GATEWAY_URL
+const hasOpenAI = !!process.env.OPENAI_API_KEY
+
+describe('image() - Image Generation Primitive', () => {
+  describe('Unit Tests (no AI)', () => {
+    it('should be exported from index', () => {
+      expect(image).toBeDefined()
+      expect(typeof image).toBe('function')
+    })
+
+    it('should have variations method', () => {
+      expect(image.variations).toBeDefined()
+      expect(typeof image.variations).toBe('function')
+    })
+
+    it('should have edit method', () => {
+      expect(image.edit).toBeDefined()
+      expect(typeof image.edit).toBe('function')
+    })
+
+    it('should have upscale method', () => {
+      expect(image.upscale).toBeDefined()
+      expect(typeof image.upscale).toBe('function')
+    })
+
+    it('should have style method', () => {
+      expect(image.style).toBeDefined()
+      expect(typeof image.style).toBe('function')
+    })
+
+    it('should have batch method', () => {
+      expect(image.batch).toBeDefined()
+      expect(typeof image.batch).toBe('function')
+    })
+
+    it('should have aspectRatio method', () => {
+      expect(image.aspectRatio).toBeDefined()
+      expect(typeof image.aspectRatio).toBe('function')
+    })
+
+    it('style method should return a function', () => {
+      const cinematicGenerator = image.style('cinematic')
+      expect(typeof cinematicGenerator).toBe('function')
+    })
+
+    it('style method should work with all style presets', () => {
+      const styles = [
+        'realistic',
+        'artistic',
+        'cartoon',
+        'abstract',
+        'photographic',
+        'digital-art',
+        'cinematic',
+      ] as const
+
+      styles.forEach((style) => {
+        const styledGenerator = image.style(style)
+        expect(typeof styledGenerator).toBe('function')
+      })
+    })
+  })
+
+  describe.skipIf(!hasGateway || !hasOpenAI)(
+    'Integration Tests (with AI) - Basic Generation',
+    () => {
+      it('should generate an image from a prompt', async () => {
+        const result = await image('A simple red circle on white background', {
+          size: '256x256',
+        })
+
+        expect(result).toBeDefined()
+        expect(result.url).toBeDefined()
+        expect(typeof result.url).toBe('string')
+        expect(result.url.length).toBeGreaterThan(0)
+        expect(result.prompt).toBe('A simple red circle on white background')
+        expect(result.metadata).toBeDefined()
+        expect(result.metadata.model).toBeDefined()
+        expect(result.metadata.size).toBe('256x256')
+      }, 60000) // 60 second timeout for image generation
+
+      it('should include duration in metadata', async () => {
+        const result = await image('A blue square', {
+          size: '256x256',
+        })
+
+        expect(result.metadata.duration).toBeDefined()
+        expect(typeof result.metadata.duration).toBe('number')
+        expect(result.metadata.duration).toBeGreaterThan(0)
+      }, 60000)
+
+      it('should support style option', async () => {
+        const result = await image('A mountain landscape', {
+          style: 'artistic',
+          size: '256x256',
+        })
+
+        expect(result).toBeDefined()
+        expect(result.url).toBeDefined()
+        expect(result.metadata.style).toBe('artistic')
+      }, 60000)
+
+      it('should support different sizes', async () => {
+        const sizes = ['256x256', '512x512', '1024x1024'] as const
+
+        for (const size of sizes) {
+          const result = await image('A green triangle', { size })
+          expect(result.metadata.size).toBe(size)
+        }
+      }, 180000) // 3 minutes for multiple generations
+
+      it('should return revised prompt when model modifies it', async () => {
+        const result = await image('A sunset', {
+          model: 'dall-e-3',
+          size: '1024x1024',
+        })
+
+        // DALL-E 3 typically revises prompts
+        expect(result.revisedPrompt).toBeDefined()
+      }, 60000)
+    }
+  )
+
+  describe.skipIf(!hasGateway || !hasOpenAI)('Integration Tests (with AI) - Style Presets', () => {
+    it('should generate realistic style image', async () => {
+      const result = await image('A coffee cup on a table', {
+        style: 'realistic',
+        size: '256x256',
+      })
+
+      expect(result.url).toBeDefined()
+      expect(result.metadata.style).toBe('realistic')
+    }, 60000)
+
+    it('should generate cartoon style image', async () => {
+      const result = await image('A happy dog', {
+        style: 'cartoon',
+        size: '256x256',
+      })
+
+      expect(result.url).toBeDefined()
+      expect(result.metadata.style).toBe('cartoon')
+    }, 60000)
+
+    it('should generate abstract style image', async () => {
+      const result = await image('Emotions and feelings', {
+        style: 'abstract',
+        size: '256x256',
+      })
+
+      expect(result.url).toBeDefined()
+      expect(result.metadata.style).toBe('abstract')
+    }, 60000)
+
+    it('should generate cinematic style image', async () => {
+      const result = await image('A hero standing on a cliff', {
+        style: 'cinematic',
+        size: '256x256',
+      })
+
+      expect(result.url).toBeDefined()
+      expect(result.metadata.style).toBe('cinematic')
+    }, 60000)
+  })
+
+  describe.skipIf(!hasGateway || !hasOpenAI)(
+    'Integration Tests (with AI) - Styled Generator',
+    () => {
+      it('should create styled generator with image.style()', async () => {
+        const cartoonImage = image.style('cartoon')
+
+        const result = await cartoonImage('A friendly robot', {
+          size: '256x256',
+        })
+
+        expect(result).toBeDefined()
+        expect(result.url).toBeDefined()
+        expect(result.metadata.style).toBe('cartoon')
+      }, 60000)
+
+      it('should work with multiple styled generators', async () => {
+        const realisticGen = image.style('realistic')
+        const abstractGen = image.style('abstract')
+
+        const [realistic, abstract] = await Promise.all([
+          realisticGen('A flower', { size: '256x256' }),
+          abstractGen('A flower', { size: '256x256' }),
+        ])
+
+        expect(realistic.metadata.style).toBe('realistic')
+        expect(abstract.metadata.style).toBe('abstract')
+      }, 120000)
+    }
+  )
+
+  describe.skipIf(!hasGateway || !hasOpenAI)(
+    'Integration Tests (with AI) - Batch Generation',
+    () => {
+      it('should generate multiple images in batch', async () => {
+        const prompts = ['A red apple', 'A blue berry', 'A yellow banana']
+
+        const results = await image.batch(prompts, {
+          size: '256x256',
+        })
+
+        expect(results).toBeDefined()
+        expect(Array.isArray(results)).toBe(true)
+        expect(results.length).toBe(3)
+
+        results.forEach((result, index) => {
+          expect(result.url).toBeDefined()
+          expect(result.prompt).toBe(prompts[index])
+        })
+      }, 180000)
+
+      it('should apply shared options to all images in batch', async () => {
+        const results = await image.batch(['A cat', 'A dog'], {
+          style: 'cartoon',
+          size: '256x256',
+        })
+
+        results.forEach((result) => {
+          expect(result.metadata.style).toBe('cartoon')
+          expect(result.metadata.size).toBe('256x256')
+        })
+      }, 120000)
+    }
+  )
+
+  describe.skipIf(!hasGateway || !hasOpenAI)('Integration Tests (with AI) - Aspect Ratio', () => {
+    it('should generate square image', async () => {
+      const result = await image.aspectRatio('A landscape scene', 'square')
+
+      expect(result.url).toBeDefined()
+      expect(result.metadata.size).toBe('1024x1024')
+    }, 60000)
+
+    it('should generate portrait image', async () => {
+      const result = await image.aspectRatio('A portrait of a person', 'portrait')
+
+      expect(result.url).toBeDefined()
+      expect(result.metadata.size).toBe('1024x1792')
+    }, 60000)
+
+    it('should generate landscape image', async () => {
+      const result = await image.aspectRatio('A wide mountain range', 'landscape')
+
+      expect(result.url).toBeDefined()
+      expect(result.metadata.size).toBe('1792x1024')
+    }, 60000)
+  })
+
+  describe.skipIf(!hasGateway || !hasOpenAI)('Integration Tests (with AI) - Variations', () => {
+    it('should generate variations of an image', async () => {
+      // First generate a source image
+      const source = await image('A simple geometric shape', {
+        size: '256x256',
+        model: 'dall-e-2', // Variations work with DALL-E 2
+      })
+
+      expect(source.url).toBeDefined()
+
+      // Then generate variations
+      const variations = await image.variations(source.url, {
+        count: 2,
+        size: '256x256',
+      })
+
+      expect(variations).toBeDefined()
+      expect(Array.isArray(variations)).toBe(true)
+      expect(variations.length).toBe(2)
+
+      variations.forEach((variation) => {
+        expect(variation.url).toBeDefined()
+        expect(variation.metadata.model).toBeDefined()
+      })
+    }, 180000)
+  })
+
+  describe.skipIf(!hasGateway || !hasOpenAI)('Integration Tests (with AI) - Editing', () => {
+    it('should edit an image with a prompt', async () => {
+      // First generate a source image
+      const source = await image('A room with a blank wall', {
+        size: '256x256',
+        model: 'dall-e-2', // Edits work with DALL-E 2
+      })
+
+      expect(source.url).toBeDefined()
+
+      // Edit the image
+      const edited = await image.edit(source.url, {
+        prompt: 'Add a colorful painting on the wall',
+        size: '256x256',
+      })
+
+      expect(edited).toBeDefined()
+      expect(edited.url).toBeDefined()
+      expect(edited.prompt).toBe('Add a colorful painting on the wall')
+      expect(edited.metadata.duration).toBeGreaterThan(0)
+    }, 180000)
+  })
+
+  describe.skipIf(!hasGateway)('Integration Tests (with AI) - Upscaling', () => {
+    it('should upscale an image', async () => {
+      // First generate a small source image
+      const source = await image('A detailed flower', {
+        size: '256x256',
+      })
+
+      expect(source.url).toBeDefined()
+
+      // Upscale it
+      const upscaled = await image.upscale(source.url, {
+        scale: 2,
+      })
+
+      expect(upscaled).toBeDefined()
+      expect(upscaled.url).toBeDefined()
+      expect(upscaled.scaleFactor).toBe(2)
+      expect(upscaled.upscaledSize.width).toBeGreaterThan(upscaled.originalSize.width)
+      expect(upscaled.upscaledSize.height).toBeGreaterThan(upscaled.originalSize.height)
+    }, 180000)
+  })
+
+  describe('Error Handling', () => {
+    it('should throw error for invalid image URL format in variations', async () => {
+      await expect(image.variations('not-a-valid-url', { count: 2 })).rejects.toThrow(
+        'Invalid image URL format'
+      )
+    })
+
+    it('should throw error for invalid image URL format in edit', async () => {
+      await expect(image.edit('not-a-valid-url', { prompt: 'test' })).rejects.toThrow(
+        'Invalid image URL format'
+      )
+    })
+  })
+
+  describe('Type Safety', () => {
+    it('should accept valid ImageOptions', () => {
+      const options: Parameters<typeof image>[1] = {
+        style: 'realistic',
+        size: '1024x1024',
+        model: 'dall-e-3',
+        quality: 'hd',
+        format: 'url',
+      }
+
+      expect(options.style).toBe('realistic')
+      expect(options.size).toBe('1024x1024')
+    })
+
+    it('should accept valid VariationOptions', () => {
+      const options: Parameters<typeof image.variations>[1] = {
+        count: 3,
+        size: '512x512',
+        format: 'url',
+      }
+
+      expect(options.count).toBe(3)
+    })
+
+    it('should accept valid EditOptions', () => {
+      const options: Parameters<typeof image.edit>[1] = {
+        prompt: 'Add a rainbow',
+        mask: 'https://example.com/mask.png',
+        size: '512x512',
+      }
+
+      expect(options.prompt).toBe('Add a rainbow')
+    })
+
+    it('should accept valid UpscaleOptions', () => {
+      const options: Parameters<typeof image.upscale>[1] = {
+        scale: 4,
+        model: 'real-esrgan',
+        denoise: 0.5,
+      }
+
+      expect(options.scale).toBe(4)
+    })
+  })
+})

package/test/is.test.ts

@@ -0,0 +1,287 @@
+/**
+ * Tests for is() - Type validation primitive
+ *
+ * The is() function provides comprehensive type/schema validation with detailed
+ * error messages and optional value coercion. Unlike ai-functions.is() which is
+ * a boolean assertion via LLM, this function returns TypeCheckResult with
+ * validation status, errors, and optionally coerced values.
+ *
+ * These tests use real AI calls via the Cloudflare AI Gateway.
+ * Tests are skipped if AI_GATEWAY_URL is not configured.
+ */
+
+import { describe, it, expect } from 'vitest'
+import { is } from '../src/index.js'
+
+// Skip tests if no gateway configured
+const hasGateway = !!process.env.AI_GATEWAY_URL || !!process.env.ANTHROPIC_API_KEY
+
+describe('is() - Type Validation Primitive', () => {
+  describe('Unit Tests (no AI) - Built-in Types', () => {
+    it('should be exported from index', () => {
+      expect(is).toBeDefined()
+      expect(typeof is).toBe('function')
+    })
+
+    it('should have email method', () => {
+      expect(is.email).toBeDefined()
+      expect(typeof is.email).toBe('function')
+    })
+
+    it('should have url method', () => {
+      expect(is.url).toBeDefined()
+      expect(typeof is.url).toBe('function')
+    })
+
+    it('should have date method', () => {
+      expect(is.date).toBeDefined()
+      expect(typeof is.date).toBe('function')
+    })
+
+    it('should have custom method', () => {
+      expect(is.custom).toBeDefined()
+      expect(typeof is.custom).toBe('function')
+    })
+
+    // Built-in type checks (no AI needed)
+    it('should validate string type', async () => {
+      const result = await is('hello', 'string')
+      expect(result.valid).toBe(true)
+      expect(result.value).toBe('hello')
+    })
+
+    it('should validate number type', async () => {
+      const result = await is(42, 'number')
+      expect(result.valid).toBe(true)
+      expect(result.value).toBe(42)
+    })
+
+    it('should invalidate wrong type', async () => {
+      const result = await is('hello', 'number')
+      expect(result.valid).toBe(false)
+      expect(result.errors).toBeDefined()
+      expect(Array.isArray(result.errors)).toBe(true)
+    })
+
+    it('should validate boolean type', async () => {
+      const result = await is(true, 'boolean')
+      expect(result.valid).toBe(true)
+    })
+
+    it('should validate array type', async () => {
+      const result = await is([1, 2, 3], 'array')
+      expect(result.valid).toBe(true)
+    })
+
+    it('should validate object type', async () => {
+      const result = await is({ key: 'value' }, 'object')
+      expect(result.valid).toBe(true)
+    })
+
+    it('should validate null type', async () => {
+      const result = await is(null, 'null')
+      expect(result.valid).toBe(true)
+    })
+
+    it('should validate undefined type', async () => {
+      const result = await is(undefined, 'undefined')
+      expect(result.valid).toBe(true)
+    })
+
+    // Coercion tests
+    it('should coerce string to number', async () => {
+      const result = await is('123', 'number', { coerce: true })
+      expect(result.valid).toBe(true)
+      expect(result.value).toBe(123)
+    })
+
+    it('should coerce number to string', async () => {
+      const result = await is(42, 'string', { coerce: true })
+      expect(result.valid).toBe(true)
+      expect(result.value).toBe('42')
+    })
+
+    it('should coerce "true" to boolean', async () => {
+      const result = await is('true', 'boolean', { coerce: true })
+      expect(result.valid).toBe(true)
+      expect(result.value).toBe(true)
+    })
+
+    it('should coerce "false" to boolean', async () => {
+      const result = await is('false', 'boolean', { coerce: true })
+      expect(result.valid).toBe(true)
+      expect(result.value).toBe(false)
+    })
+
+    it('should wrap value in array for array coercion', async () => {
+      const result = await is('single', 'array', { coerce: true })
+      expect(result.valid).toBe(true)
+      expect(result.value).toEqual(['single'])
+    })
+  })
+
+  describe('Unit Tests - Email Validation', () => {
+    it('should validate correct email', async () => {
+      const result = await is.email('user@example.com')
+      expect(result.valid).toBe(true)
+      expect(result.value).toBe('user@example.com')
+    })
+
+    it('should invalidate malformed email', async () => {
+      const result = await is.email('not-an-email')
+      expect(result.valid).toBe(false)
+      expect(result.errors).toContain('Invalid email format')
+    })
+
+    it('should invalidate email without domain', async () => {
+      const result = await is.email('user@')
+      expect(result.valid).toBe(false)
+    })
+
+    it('should invalidate non-string for email', async () => {
+      const result = await is.email(123)
+      expect(result.valid).toBe(false)
+    })
+  })
+
+  describe('Unit Tests - URL Validation', () => {
+    it('should validate correct URL', async () => {
+      const result = await is.url('https://example.com')
+      expect(result.valid).toBe(true)
+    })
+
+    it('should validate URL with path', async () => {
+      const result = await is.url('https://example.com/path/to/resource')
+      expect(result.valid).toBe(true)
+    })
+
+    it('should invalidate malformed URL', async () => {
+      const result = await is.url('not-a-url')
+      expect(result.valid).toBe(false)
+      expect(result.errors).toContain('Invalid URL format')
+    })
+
+    it('should invalidate non-string for URL', async () => {
+      const result = await is.url(123)
+      expect(result.valid).toBe(false)
+      expect(result.errors).toContain('Value must be a string')
+    })
+  })
+
+  describe('Unit Tests - Date Validation', () => {
+    it('should validate Date object', async () => {
+      const date = new Date()
+      const result = await is.date(date)
+      expect(result.valid).toBe(true)
+      expect(result.value).toEqual(date)
+    })
+
+    it('should invalidate invalid Date', async () => {
+      const result = await is.date(new Date('invalid'))
+      expect(result.valid).toBe(false)
+    })
+
+    it('should coerce string to Date', async () => {
+      const result = await is.date('2024-01-15', { coerce: true })
+      expect(result.valid).toBe(true)
+      expect(result.value).toBeInstanceOf(Date)
+    })
+
+    it('should coerce timestamp to Date', async () => {
+      const timestamp = Date.now()
+      const result = await is.date(timestamp, { coerce: true })
+      expect(result.valid).toBe(true)
+      expect(result.value).toBeInstanceOf(Date)
+    })
+  })
+
+  describe('Unit Tests - Custom Validation', () => {
+    it('should validate with custom sync function', async () => {
+      const result = await is.custom(42, (v) => typeof v === 'number' && (v as number) > 0)
+      expect(result.valid).toBe(true)
+    })
+
+    it('should invalidate with custom sync function', async () => {
+      const result = await is.custom(-5, (v) => typeof v === 'number' && (v as number) > 0)
+      expect(result.valid).toBe(false)
+    })
+
+    it('should validate with custom async function', async () => {
+      const result = await is.custom('test', async (v) => typeof v === 'string')
+      expect(result.valid).toBe(true)
+    })
+
+    it('should handle validation function errors', async () => {
+      const result = await is.custom('test', () => {
+        throw new Error('Custom error')
+      })
+      expect(result.valid).toBe(false)
+      expect(result.errors).toContain('Custom error')
+    })
+  })
+
+  describe.skipIf(!hasGateway)('Integration Tests (with AI) - Complex Types', () => {
+    it('should validate email type via AI', async () => {
+      const result = await is('test@example.com', 'email')
+      expect(result.valid).toBe(true)
+    })
+
+    it('should validate phone number type via AI', async () => {
+      const result = await is('+1-555-123-4567', 'phone number')
+      expect(result.valid).toBe(true)
+    })
+
+    it('should validate US zip code via AI', async () => {
+      const result = await is('90210', 'US zip code')
+      expect(result.valid).toBe(true)
+    })
+
+    it('should invalidate invalid zip code via AI', async () => {
+      const result = await is('ABCDE', 'US zip code')
+      expect(result.valid).toBe(false)
+    })
+
+    it('should validate ISO date format via AI', async () => {
+      const result = await is('2024-01-15T10:30:00Z', 'ISO 8601 date')
+      expect(result.valid).toBe(true)
+    })
+
+    it('should validate against schema', async () => {
+      const result = await is(
+        { name: 'John', age: 30 },
+        {
+          name: 'Person name (string)',
+          age: 'Age in years (number)',
+        }
+      )
+      expect(result.valid).toBe(true)
+    })
+
+    it('should invalidate missing schema fields', async () => {
+      const result = await is(
+        { name: 'John' },
+        {
+          name: 'Person name',
+          age: 'Age (required number)',
+          email: 'Email address (required)',
+        },
+        { strict: true }
+      )
+      // In strict mode, missing required fields should fail
+      expect(result).toBeDefined()
+    })
+
+    it('should coerce values via AI when requested', async () => {
+      const result = await is(
+        { age: '30', active: 'yes' },
+        {
+          age: 'Age in years (number)',
+          active: 'Is active (boolean)',
+        },
+        { coerce: true }
+      )
+      expect(result).toBeDefined()
+      // The AI should attempt to coerce '30' to 30 and 'yes' to true
+    })
+  })
+})