digital-products 2.0.1

package/test/data.test.ts

@@ -0,0 +1,201 @@
+/**
+ * Tests for Data functionality
+ *
+ * Covers data definitions and helper functions.
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest'
+import { Data, Index, Relationship, Validate, registry } from '../src/index.js'
+
+describe('Data', () => {
+  beforeEach(() => {
+    registry.clear()
+  })
+
+  describe('Data creation', () => {
+    it('creates data with basic config', () => {
+      const data = Data({
+        id: 'users',
+        name: 'Users',
+        description: 'User data store',
+        version: '1.0.0',
+        schema: {
+          id: 'User ID',
+          name: 'User name',
+          email: 'User email',
+        },
+      })
+
+      expect(data.id).toBe('users')
+      expect(data.name).toBe('Users')
+      expect(data.type).toBe('data')
+    })
+
+    it('defaults provider to fs', () => {
+      const data = Data({
+        id: 'default-provider',
+        name: 'Default Provider',
+        description: 'Uses default provider',
+        version: '1.0.0',
+        schema: {},
+      })
+
+      expect(data.provider).toBe('fs')
+    })
+
+    it('supports custom providers', () => {
+      const data = Data({
+        id: 'postgres-data',
+        name: 'Postgres Data',
+        description: 'Postgres storage',
+        version: '1.0.0',
+        schema: {},
+        provider: 'postgres',
+      })
+
+      expect(data.provider).toBe('postgres')
+    })
+
+    it('creates data with indexes', () => {
+      const data = Data({
+        id: 'indexed-data',
+        name: 'Indexed Data',
+        description: 'Data with indexes',
+        version: '1.0.0',
+        schema: {
+          id: 'ID',
+          email: 'Email',
+          name: 'Name',
+        },
+        indexes: [
+          Index('email_idx', ['email'], { unique: true }),
+          Index('name_idx', ['name']),
+        ],
+      })
+
+      expect(data.indexes).toHaveLength(2)
+      expect(data.indexes?.[0]?.name).toBe('email_idx')
+      expect(data.indexes?.[0]?.unique).toBe(true)
+    })
+
+    it('creates data with relationships', () => {
+      const data = Data({
+        id: 'related-data',
+        name: 'Related Data',
+        description: 'Data with relationships',
+        version: '1.0.0',
+        schema: {},
+        relationships: [
+          Relationship('one-to-many', 'userId', 'posts', 'author'),
+        ],
+      })
+
+      expect(data.relationships).toHaveLength(1)
+      expect(data.relationships?.[0]?.type).toBe('one-to-many')
+    })
+
+    it('creates data with validation', () => {
+      const data = Data({
+        id: 'validated-data',
+        name: 'Validated Data',
+        description: 'Data with validation',
+        version: '1.0.0',
+        schema: {},
+        validation: [
+          Validate('email', 'email', 'Must be a valid email'),
+          Validate('name', 'required', 'Name is required'),
+        ],
+      })
+
+      expect(data.validation).toHaveLength(2)
+      expect(data.validation?.[0]?.field).toBe('email')
+    })
+
+    it('registers data automatically', () => {
+      Data({
+        id: 'auto-registered',
+        name: 'Auto Registered',
+        description: 'Automatically registered',
+        version: '1.0.0',
+        schema: {},
+      })
+
+      expect(registry.get('auto-registered')).toBeDefined()
+    })
+  })
+
+  describe('Index helper', () => {
+    it('creates a basic index', () => {
+      const index = Index('my_idx', ['field1', 'field2'])
+
+      expect(index.name).toBe('my_idx')
+      expect(index.fields).toEqual(['field1', 'field2'])
+    })
+
+    it('creates a unique index', () => {
+      const index = Index('unique_idx', ['email'], { unique: true })
+
+      expect(index.unique).toBe(true)
+    })
+
+    it('creates a vector index', () => {
+      const index = Index('vector_idx', ['embedding'], { type: 'vector' })
+
+      expect(index.type).toBe('vector')
+    })
+  })
+
+  describe('Relationship helper', () => {
+    it('creates a one-to-many relationship', () => {
+      const rel = Relationship('one-to-many', 'userId', 'posts', 'author')
+
+      expect(rel.type).toBe('one-to-many')
+      expect(rel.from).toBe('userId')
+      expect(rel.to).toBe('posts')
+      expect(rel.field).toBe('author')
+    })
+
+    it('creates a many-to-many relationship', () => {
+      const rel = Relationship('many-to-many', 'postId', 'tags', 'posts')
+
+      expect(rel.type).toBe('many-to-many')
+    })
+
+    it('creates a one-to-one relationship', () => {
+      const rel = Relationship('one-to-one', 'userId', 'profile', 'user')
+
+      expect(rel.type).toBe('one-to-one')
+    })
+  })
+
+  describe('Validate helper', () => {
+    it('creates a validation rule with message', () => {
+      const rule = Validate('email', 'email', 'Must be a valid email')
+
+      expect(rule.field).toBe('email')
+      expect(rule.rule).toBe('email')
+      expect(rule.message).toBe('Must be a valid email')
+    })
+
+    it('creates a validation rule with params', () => {
+      const rule = Validate('age', 'min', { value: 18 }, 'Must be 18 or older')
+
+      expect(rule.field).toBe('age')
+      expect(rule.rule).toBe('min')
+      expect(rule.params).toEqual({ value: 18 })
+      expect(rule.message).toBe('Must be 18 or older')
+    })
+
+    it('creates a required validation rule', () => {
+      const rule = Validate('name', 'required', 'Name is required')
+
+      expect(rule.rule).toBe('required')
+    })
+
+    it('creates a unique validation rule', () => {
+      const rule = Validate('username', 'unique', 'Username already taken')
+
+      expect(rule.rule).toBe('unique')
+    })
+  })
+})

package/test/dataset.test.ts

@@ -0,0 +1,181 @@
+/**
+ * Tests for Dataset functionality
+ *
+ * Covers dataset creation.
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest'
+import { Dataset, registry } from '../src/index.js'
+
+describe('Dataset', () => {
+  beforeEach(() => {
+    registry.clear()
+  })
+
+  describe('Dataset creation', () => {
+    it('creates a dataset with basic config', () => {
+      const dataset = Dataset({
+        id: 'movies',
+        name: 'Movie Database',
+        description: 'Movie information dataset',
+        version: '2024.1',
+      })
+
+      expect(dataset.id).toBe('movies')
+      expect(dataset.name).toBe('Movie Database')
+      expect(dataset.type).toBe('dataset')
+    })
+
+    it('defaults format to json', () => {
+      const dataset = Dataset({
+        id: 'default-format',
+        name: 'Default Format',
+        description: 'Uses default format',
+        version: '1.0.0',
+      })
+
+      expect(dataset.format).toBe('json')
+    })
+
+    it('supports parquet format', () => {
+      const dataset = Dataset({
+        id: 'parquet-dataset',
+        name: 'Parquet Dataset',
+        description: 'Parquet format',
+        version: '1.0.0',
+        format: 'parquet',
+      })
+
+      expect(dataset.format).toBe('parquet')
+    })
+
+    it('supports csv format', () => {
+      const dataset = Dataset({
+        id: 'csv-dataset',
+        name: 'CSV Dataset',
+        description: 'CSV format',
+        version: '1.0.0',
+        format: 'csv',
+      })
+
+      expect(dataset.format).toBe('csv')
+    })
+
+    it('creates a dataset with schema', () => {
+      const dataset = Dataset({
+        id: 'schema-dataset',
+        name: 'Schema Dataset',
+        description: 'Dataset with schema',
+        version: '1.0.0',
+        schema: {
+          id: 'Movie ID',
+          title: 'Movie title',
+          year: 'Release year (number)',
+          rating: 'Average rating (number)',
+        },
+      })
+
+      expect(dataset.schema?.id).toBe('Movie ID')
+      expect(dataset.schema?.title).toBe('Movie title')
+    })
+
+    it('creates a dataset with source', () => {
+      const dataset = Dataset({
+        id: 'source-dataset',
+        name: 'Source Dataset',
+        description: 'Dataset with source',
+        version: '1.0.0',
+        source: 's3://datasets/movies.parquet',
+      })
+
+      expect(dataset.source).toBe('s3://datasets/movies.parquet')
+    })
+
+    it('creates a dataset with size', () => {
+      const dataset = Dataset({
+        id: 'sized-dataset',
+        name: 'Sized Dataset',
+        description: 'Dataset with size',
+        version: '1.0.0',
+        size: 1000000,
+      })
+
+      expect(dataset.size).toBe(1000000)
+    })
+
+    it('creates a dataset with license', () => {
+      const dataset = Dataset({
+        id: 'licensed-dataset',
+        name: 'Licensed Dataset',
+        description: 'Dataset with license',
+        version: '1.0.0',
+        license: 'CC-BY-4.0',
+      })
+
+      expect(dataset.license).toBe('CC-BY-4.0')
+    })
+
+    it('defaults updateFrequency to static', () => {
+      const dataset = Dataset({
+        id: 'static-dataset',
+        name: 'Static Dataset',
+        description: 'Static dataset',
+        version: '1.0.0',
+      })
+
+      expect(dataset.updateFrequency).toBe('static')
+    })
+
+    it('supports daily updateFrequency', () => {
+      const dataset = Dataset({
+        id: 'daily-dataset',
+        name: 'Daily Dataset',
+        description: 'Updated daily',
+        version: '1.0.0',
+        updateFrequency: 'daily',
+      })
+
+      expect(dataset.updateFrequency).toBe('daily')
+    })
+
+    it('registers dataset automatically', () => {
+      Dataset({
+        id: 'auto-registered',
+        name: 'Auto Registered',
+        description: 'Automatically registered',
+        version: '1.0.0',
+      })
+
+      expect(registry.get('auto-registered')).toBeDefined()
+    })
+
+    it('creates a complete dataset definition', () => {
+      const dataset = Dataset({
+        id: 'complete-dataset',
+        name: 'Complete Dataset',
+        description: 'Comprehensive movie information dataset',
+        version: '2024.1',
+        format: 'parquet',
+        schema: {
+          id: 'Movie ID',
+          title: 'Movie title',
+          year: 'Release year (number)',
+          genres: ['Array of genre names'],
+          rating: 'Average rating (number)',
+          votes: 'Number of votes (number)',
+        },
+        source: 's3://datasets/movies.parquet',
+        size: 1000000,
+        license: 'CC-BY-4.0',
+        updateFrequency: 'daily',
+        tags: ['movies', 'entertainment'],
+        metadata: { curator: 'Data Team' },
+      })
+
+      expect(dataset.id).toBe('complete-dataset')
+      expect(dataset.format).toBe('parquet')
+      expect(dataset.license).toBe('CC-BY-4.0')
+      expect(dataset.tags).toContain('movies')
+    })
+  })
+})

package/test/mcp.test.ts

@@ -0,0 +1,230 @@
+/**
+ * Tests for MCP functionality
+ *
+ * Covers MCP server creation and helper functions.
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest'
+import { MCP, Tool, Resource, Prompt, MCPConfig, registry } from '../src/index.js'
+
+describe('MCP', () => {
+  beforeEach(() => {
+    registry.clear()
+  })
+
+  describe('MCP creation', () => {
+    it('creates an MCP with basic config', () => {
+      const mcp = MCP({
+        id: 'my-mcp',
+        name: 'My MCP Server',
+        description: 'Custom MCP server',
+        version: '1.0.0',
+      })
+
+      expect(mcp.id).toBe('my-mcp')
+      expect(mcp.name).toBe('My MCP Server')
+      expect(mcp.type).toBe('mcp')
+    })
+
+    it('creates an MCP with transport', () => {
+      const mcp = MCP({
+        id: 'stdio-mcp',
+        name: 'Stdio MCP',
+        description: 'MCP with stdio',
+        version: '1.0.0',
+        transport: 'stdio',
+      })
+
+      expect(mcp.transport).toBe('stdio')
+    })
+
+    it('creates an MCP with tools', () => {
+      const mcp = MCP({
+        id: 'tool-mcp',
+        name: 'Tool MCP',
+        description: 'MCP with tools',
+        version: '1.0.0',
+        tools: [
+          Tool('searchFiles', 'Search for files', {
+            query: 'Search query',
+            path: 'Directory to search',
+          }),
+          Tool('readFile', 'Read file contents', {
+            path: 'File path to read',
+          }),
+        ],
+      })
+
+      expect(mcp.tools).toHaveLength(2)
+      expect(mcp.tools?.[0]?.name).toBe('searchFiles')
+    })
+
+    it('creates an MCP with resources', () => {
+      const mcp = MCP({
+        id: 'resource-mcp',
+        name: 'Resource MCP',
+        description: 'MCP with resources',
+        version: '1.0.0',
+        resources: [
+          Resource('file://', 'Project Files', 'Access to project files'),
+        ],
+      })
+
+      expect(mcp.resources).toHaveLength(1)
+      expect(mcp.resources?.[0]?.uri).toBe('file://')
+    })
+
+    it('creates an MCP with prompts', () => {
+      const mcp = MCP({
+        id: 'prompt-mcp',
+        name: 'Prompt MCP',
+        description: 'MCP with prompts',
+        version: '1.0.0',
+        prompts: [
+          Prompt('codeReview', 'Review code', 'Review the following code:\n\n{{code}}'),
+        ],
+      })
+
+      expect(mcp.prompts).toHaveLength(1)
+      expect(mcp.prompts?.[0]?.name).toBe('codeReview')
+    })
+
+    it('creates an MCP with config', () => {
+      const mcp = MCP({
+        id: 'config-mcp',
+        name: 'Config MCP',
+        description: 'MCP with config',
+        version: '1.0.0',
+        config: {
+          port: 3000,
+          host: 'localhost',
+        },
+      })
+
+      expect(mcp.config?.port).toBe(3000)
+    })
+
+    it('registers MCP automatically', () => {
+      MCP({
+        id: 'auto-registered',
+        name: 'Auto Registered',
+        description: 'Automatically registered',
+        version: '1.0.0',
+      })
+
+      expect(registry.get('auto-registered')).toBeDefined()
+    })
+  })
+
+  describe('Tool helper', () => {
+    it('creates a basic tool', () => {
+      const tool = Tool('myTool', 'My tool description', {
+        param1: 'First parameter',
+        param2: 'Second parameter',
+      })
+
+      expect(tool.name).toBe('myTool')
+      expect(tool.description).toBe('My tool description')
+      expect(tool.inputSchema).toHaveProperty('param1')
+    })
+
+    it('creates a tool with handler', () => {
+      const handler = async (input: unknown) => ({ result: 'done' })
+      const tool = Tool('handlerTool', 'Tool with handler', {
+        input: 'Input value',
+      }, handler)
+
+      expect(tool.handler).toBe(handler)
+    })
+
+    it('creates a tool with complex schema', () => {
+      const tool = Tool('complexTool', 'Tool with complex schema', {
+        query: 'Search query (required)',
+        options: {
+          limit: 'Maximum results (number)',
+          offset: 'Result offset (number)',
+        },
+      })
+
+      expect(tool.inputSchema?.query).toBe('Search query (required)')
+      expect(tool.inputSchema?.options).toHaveProperty('limit')
+    })
+  })
+
+  describe('Resource helper', () => {
+    it('creates a basic resource', () => {
+      const resource = Resource(
+        'file://project',
+        'Project Files',
+        'Access to all project files'
+      )
+
+      expect(resource.uri).toBe('file://project')
+      expect(resource.name).toBe('Project Files')
+      expect(resource.description).toBe('Access to all project files')
+    })
+
+    it('creates a resource with mimeType', () => {
+      const resource = Resource(
+        'file://config.json',
+        'Config',
+        'Configuration file',
+        'application/json'
+      )
+
+      expect(resource.mimeType).toBe('application/json')
+    })
+  })
+
+  describe('Prompt helper', () => {
+    it('creates a basic prompt', () => {
+      const prompt = Prompt(
+        'summarize',
+        'Summarize text',
+        'Summarize the following:\n\n{{text}}'
+      )
+
+      expect(prompt.name).toBe('summarize')
+      expect(prompt.description).toBe('Summarize text')
+      expect(prompt.template).toContain('{{text}}')
+    })
+
+    it('creates a prompt with arguments', () => {
+      const prompt = Prompt(
+        'translate',
+        'Translate text',
+        'Translate {{text}} to {{language}}',
+        {
+          text: 'Text to translate',
+          language: 'Target language',
+        }
+      )
+
+      expect(prompt.arguments).toHaveProperty('text')
+      expect(prompt.arguments).toHaveProperty('language')
+    })
+  })
+
+  describe('MCPConfig helper', () => {
+    it('creates MCP config', () => {
+      const config = MCPConfig({
+        port: 3000,
+        host: 'localhost',
+      })
+
+      expect(config.port).toBe(3000)
+      expect(config.host).toBe('localhost')
+    })
+
+    it('creates MCP config with auth', () => {
+      const config = MCPConfig({
+        auth: {
+          type: 'bearer',
+          token: 'secret-token',
+        },
+      })
+
+      expect(config.auth?.type).toBe('bearer')
+    })
+  })
+})