digital-products 2.0.1

package/test/api.test.ts

@@ -0,0 +1,247 @@
+/**
+ * Tests for API functionality
+ *
+ * Covers API creation and helper functions.
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest'
+import { API, Endpoint, APIAuth, RateLimit, registry } from '../src/index.js'
+
+describe('API', () => {
+  beforeEach(() => {
+    registry.clear()
+  })
+
+  describe('API creation', () => {
+    it('creates an API with basic config', () => {
+      const api = API({
+        id: 'my-api',
+        name: 'My API',
+        description: 'A RESTful API',
+        version: '1.0.0',
+        baseUrl: 'https://api.example.com',
+      })
+
+      expect(api.id).toBe('my-api')
+      expect(api.name).toBe('My API')
+      expect(api.type).toBe('api')
+      expect(api.baseUrl).toBe('https://api.example.com')
+    })
+
+    it('defaults style to rest', () => {
+      const api = API({
+        id: 'rest-api',
+        name: 'REST API',
+        description: 'A REST API',
+        version: '1.0.0',
+      })
+
+      expect(api.style).toBe('rest')
+    })
+
+    it('supports graphql style', () => {
+      const api = API({
+        id: 'graphql-api',
+        name: 'GraphQL API',
+        description: 'A GraphQL API',
+        version: '1.0.0',
+        style: 'graphql',
+      })
+
+      expect(api.style).toBe('graphql')
+    })
+
+    it('creates an API with endpoints', () => {
+      const api = API({
+        id: 'endpoint-api',
+        name: 'Endpoint API',
+        description: 'API with endpoints',
+        version: '1.0.0',
+        endpoints: [
+          Endpoint('GET', '/users', 'List users'),
+          Endpoint('POST', '/users', 'Create user'),
+        ],
+      })
+
+      expect(api.endpoints).toHaveLength(2)
+      expect(api.endpoints?.[0]?.method).toBe('GET')
+      expect(api.endpoints?.[1]?.method).toBe('POST')
+    })
+
+    it('creates an API with auth', () => {
+      const api = API({
+        id: 'auth-api',
+        name: 'Auth API',
+        description: 'API with auth',
+        version: '1.0.0',
+        auth: {
+          type: 'bearer',
+          header: 'Authorization',
+        },
+      })
+
+      expect(api.auth?.type).toBe('bearer')
+      expect(api.auth?.header).toBe('Authorization')
+    })
+
+    it('creates an API with rate limiting', () => {
+      const api = API({
+        id: 'rate-limited-api',
+        name: 'Rate Limited API',
+        description: 'API with rate limiting',
+        version: '1.0.0',
+        rateLimit: {
+          requests: 100,
+          window: 60,
+        },
+      })
+
+      expect(api.rateLimit?.requests).toBe(100)
+      expect(api.rateLimit?.window).toBe(60)
+    })
+
+    it('registers the API automatically', () => {
+      API({
+        id: 'auto-registered',
+        name: 'Auto Registered',
+        description: 'Automatically registered',
+        version: '1.0.0',
+      })
+
+      expect(registry.get('auto-registered')).toBeDefined()
+    })
+
+    it('supports docsUrl', () => {
+      const api = API({
+        id: 'documented-api',
+        name: 'Documented API',
+        description: 'API with docs',
+        version: '1.0.0',
+        docsUrl: 'https://docs.example.com/api',
+      })
+
+      expect(api.docsUrl).toBe('https://docs.example.com/api')
+    })
+
+    it('supports openapi spec reference', () => {
+      const api = API({
+        id: 'openapi-api',
+        name: 'OpenAPI API',
+        description: 'API with OpenAPI',
+        version: '1.0.0',
+        openapi: 'https://api.example.com/openapi.json',
+      })
+
+      expect(api.openapi).toBe('https://api.example.com/openapi.json')
+    })
+  })
+
+  describe('Endpoint helper', () => {
+    it('creates a basic endpoint', () => {
+      const endpoint = Endpoint('GET', '/users', 'List all users')
+
+      expect(endpoint.method).toBe('GET')
+      expect(endpoint.path).toBe('/users')
+      expect(endpoint.description).toBe('List all users')
+    })
+
+    it('creates an endpoint with params', () => {
+      const endpoint = Endpoint('GET', '/users/:id', 'Get user by ID', {
+        params: { id: 'User ID' },
+      })
+
+      expect(endpoint.params).toEqual({ id: 'User ID' })
+    })
+
+    it('creates an endpoint with request and response schemas', () => {
+      const endpoint = Endpoint('POST', '/users', 'Create user', {
+        request: {
+          name: 'User name',
+          email: 'User email',
+        },
+        response: {
+          id: 'User ID',
+          name: 'User name',
+          email: 'User email',
+        },
+      })
+
+      expect(endpoint.request).toEqual({
+        name: 'User name',
+        email: 'User email',
+      })
+      expect(endpoint.response).toEqual({
+        id: 'User ID',
+        name: 'User name',
+        email: 'User email',
+      })
+    })
+
+    it('creates an endpoint with auth requirement', () => {
+      const endpoint = Endpoint('DELETE', '/users/:id', 'Delete user', {
+        auth: true,
+      })
+
+      expect(endpoint.auth).toBe(true)
+    })
+  })
+
+  describe('APIAuth helper', () => {
+    it('creates bearer auth config', () => {
+      const auth = APIAuth({
+        type: 'bearer',
+        header: 'Authorization',
+      })
+
+      expect(auth.type).toBe('bearer')
+      expect(auth.header).toBe('Authorization')
+    })
+
+    it('creates API key auth config', () => {
+      const auth = APIAuth({
+        type: 'apiKey',
+        header: 'X-API-Key',
+      })
+
+      expect(auth.type).toBe('apiKey')
+      expect(auth.header).toBe('X-API-Key')
+    })
+
+    it('creates OAuth2 auth config', () => {
+      const auth = APIAuth({
+        type: 'oauth2',
+        oauth2: {
+          authUrl: 'https://auth.example.com/authorize',
+          tokenUrl: 'https://auth.example.com/token',
+          scopes: ['read', 'write'],
+        },
+      })
+
+      expect(auth.type).toBe('oauth2')
+      expect(auth.oauth2?.authUrl).toBe('https://auth.example.com/authorize')
+      expect(auth.oauth2?.scopes).toEqual(['read', 'write'])
+    })
+  })
+
+  describe('RateLimit helper', () => {
+    it('creates basic rate limit config', () => {
+      const rateLimit = RateLimit({
+        requests: 100,
+        window: 60,
+      })
+
+      expect(rateLimit.requests).toBe(100)
+      expect(rateLimit.window).toBe(60)
+    })
+
+    it('supports onExceeded action', () => {
+      const rateLimit = RateLimit({
+        requests: 100,
+        window: 60,
+        onExceeded: 'reject',
+      })
+
+      expect(rateLimit.onExceeded).toBe('reject')
+    })
+  })
+})

package/test/app.test.ts

@@ -0,0 +1,220 @@
+/**
+ * Tests for App functionality
+ *
+ * Covers application creation and helper functions.
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest'
+import { App, Route, State, Auth, registry } from '../src/index.js'
+
+describe('App', () => {
+  beforeEach(() => {
+    registry.clear()
+  })
+
+  describe('App creation', () => {
+    it('creates an app with basic config', () => {
+      const app = App({
+        id: 'my-app',
+        name: 'My App',
+        description: 'A web application',
+        version: '1.0.0',
+      })
+
+      expect(app.id).toBe('my-app')
+      expect(app.name).toBe('My App')
+      expect(app.type).toBe('app')
+    })
+
+    it('defaults framework to react', () => {
+      const app = App({
+        id: 'react-app',
+        name: 'React App',
+        description: 'Default framework',
+        version: '1.0.0',
+      })
+
+      expect(app.framework).toBe('react')
+    })
+
+    it('supports custom frameworks', () => {
+      const app = App({
+        id: 'vue-app',
+        name: 'Vue App',
+        description: 'Vue application',
+        version: '1.0.0',
+        framework: 'vue',
+      })
+
+      expect(app.framework).toBe('vue')
+    })
+
+    it('creates an app with routes', () => {
+      const app = App({
+        id: 'routed-app',
+        name: 'Routed App',
+        description: 'App with routes',
+        version: '1.0.0',
+        routes: [
+          Route('/', 'Home'),
+          Route('/about', 'About'),
+          Route('/users/:id', 'UserDetail'),
+        ],
+      })
+
+      expect(app.routes).toHaveLength(3)
+      expect(app.routes?.[0]?.path).toBe('/')
+      expect(app.routes?.[2]?.path).toBe('/users/:id')
+    })
+
+    it('creates an app with state config', () => {
+      const app = App({
+        id: 'stateful-app',
+        name: 'Stateful App',
+        description: 'App with state',
+        version: '1.0.0',
+        state: {
+          library: 'zustand',
+          schema: {
+            user: 'Current user object',
+            settings: 'App settings object',
+          },
+        },
+      })
+
+      expect(app.state?.library).toBe('zustand')
+      expect(app.state?.schema?.user).toBe('Current user object')
+    })
+
+    it('creates an app with auth config', () => {
+      const app = App({
+        id: 'authed-app',
+        name: 'Authed App',
+        description: 'App with auth',
+        version: '1.0.0',
+        auth: {
+          provider: 'clerk',
+          protectedRoutes: ['/dashboard', '/profile'],
+        },
+      })
+
+      expect(app.auth?.provider).toBe('clerk')
+      expect(app.auth?.protectedRoutes).toContain('/dashboard')
+    })
+
+    it('registers the app automatically', () => {
+      App({
+        id: 'auto-registered',
+        name: 'Auto Registered',
+        description: 'Automatically registered',
+        version: '1.0.0',
+      })
+
+      expect(registry.get('auto-registered')).toBeDefined()
+    })
+
+    it('supports deployments config', () => {
+      const app = App({
+        id: 'deployed-app',
+        name: 'Deployed App',
+        description: 'App with deployments',
+        version: '1.0.0',
+        deployments: {
+          production: 'https://app.example.com',
+          staging: 'https://staging.example.com',
+        },
+      })
+
+      expect(app.deployments?.production).toBe('https://app.example.com')
+    })
+  })
+
+  describe('Route helper', () => {
+    it('creates a basic route', () => {
+      const route = Route('/', 'Home')
+
+      expect(route.path).toBe('/')
+      expect(route.component).toBe('Home')
+    })
+
+    it('creates a route with meta', () => {
+      const route = Route('/about', 'About', {
+        meta: { title: 'About Us' },
+      })
+
+      expect(route.meta).toEqual({ title: 'About Us' })
+    })
+
+    it('creates a route with children', () => {
+      const route = Route('/dashboard', 'Dashboard', {
+        children: [
+          Route('/dashboard/stats', 'Stats'),
+          Route('/dashboard/settings', 'Settings'),
+        ],
+      })
+
+      expect(route.children).toHaveLength(2)
+    })
+
+    it('creates a protected route', () => {
+      const route = Route('/admin', 'Admin', {
+        protected: true,
+        roles: ['admin'],
+      })
+
+      expect(route.protected).toBe(true)
+      expect(route.roles).toContain('admin')
+    })
+  })
+
+  describe('State helper', () => {
+    it('creates a state config', () => {
+      const state = State({
+        library: 'zustand',
+        schema: {
+          user: 'Current user',
+          settings: 'User settings',
+        },
+      })
+
+      expect(state.library).toBe('zustand')
+      expect(state.schema).toHaveProperty('user')
+    })
+
+    it('supports persistence config', () => {
+      const state = State({
+        library: 'zustand',
+        schema: {},
+        persistence: {
+          type: 'local',
+          key: 'app-state',
+        },
+      })
+
+      expect(state.persistence?.type).toBe('local')
+      expect(state.persistence?.key).toBe('app-state')
+    })
+  })
+
+  describe('Auth helper', () => {
+    it('creates an auth config', () => {
+      const auth = Auth({
+        provider: 'clerk',
+        protectedRoutes: ['/dashboard', '/profile'],
+      })
+
+      expect(auth.provider).toBe('clerk')
+      expect(auth.protectedRoutes).toHaveLength(2)
+    })
+
+    it('supports roles', () => {
+      const auth = Auth({
+        provider: 'auth0',
+        protectedRoutes: ['/admin'],
+        roles: ['admin', 'user'],
+      })
+
+      expect(auth.roles).toContain('admin')
+    })
+  })
+})

package/test/content.test.ts

@@ -0,0 +1,171 @@
+/**
+ * Tests for Content functionality
+ *
+ * Covers content creation and workflow helper.
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest'
+import { Content, Workflow, registry } from '../src/index.js'
+
+describe('Content', () => {
+  beforeEach(() => {
+    registry.clear()
+  })
+
+  describe('Content creation', () => {
+    it('creates content with basic config', () => {
+      const content = Content({
+        id: 'blog',
+        name: 'Blog Posts',
+        description: 'Blog content',
+        version: '1.0.0',
+      })
+
+      expect(content.id).toBe('blog')
+      expect(content.name).toBe('Blog Posts')
+      expect(content.type).toBe('content')
+    })
+
+    it('defaults format to markdown', () => {
+      const content = Content({
+        id: 'docs',
+        name: 'Documentation',
+        description: 'Docs content',
+        version: '1.0.0',
+      })
+
+      expect(content.format).toBe('markdown')
+    })
+
+    it('supports mdx format', () => {
+      const content = Content({
+        id: 'interactive-docs',
+        name: 'Interactive Docs',
+        description: 'MDX content',
+        version: '1.0.0',
+        format: 'mdx',
+      })
+
+      expect(content.format).toBe('mdx')
+    })
+
+    it('creates content with source', () => {
+      const content = Content({
+        id: 'blog',
+        name: 'Blog Posts',
+        description: 'Blog content',
+        version: '1.0.0',
+        source: './content/blog',
+      })
+
+      expect(content.source).toBe('./content/blog')
+    })
+
+    it('creates content with frontmatter schema', () => {
+      const content = Content({
+        id: 'blog',
+        name: 'Blog Posts',
+        description: 'Blog content',
+        version: '1.0.0',
+        frontmatter: {
+          title: 'Post title',
+          author: 'Author name',
+          date: 'Publication date (date)',
+          tags: ['Array of tags'],
+        },
+      })
+
+      expect(content.frontmatter?.title).toBe('Post title')
+      expect(content.frontmatter?.author).toBe('Author name')
+    })
+
+    it('creates content with categories', () => {
+      const content = Content({
+        id: 'blog',
+        name: 'Blog Posts',
+        description: 'Blog content',
+        version: '1.0.0',
+        categories: ['Technology', 'Business', 'Design'],
+      })
+
+      expect(content.categories).toHaveLength(3)
+      expect(content.categories).toContain('Technology')
+    })
+
+    it('creates content with workflow', () => {
+      const content = Content({
+        id: 'blog',
+        name: 'Blog Posts',
+        description: 'Blog content',
+        version: '1.0.0',
+        workflow: Workflow({
+          states: ['draft', 'review', 'published'],
+          initialState: 'draft',
+          transitions: [
+            { from: 'draft', to: 'review', action: 'submit' },
+            { from: 'review', to: 'published', action: 'approve' },
+          ],
+        }),
+      })
+
+      expect(content.workflow?.states).toHaveLength(3)
+      expect(content.workflow?.initialState).toBe('draft')
+    })
+
+    it('registers content automatically', () => {
+      Content({
+        id: 'auto-registered',
+        name: 'Auto Registered',
+        description: 'Automatically registered',
+        version: '1.0.0',
+      })
+
+      expect(registry.get('auto-registered')).toBeDefined()
+    })
+  })
+
+  describe('Workflow helper', () => {
+    it('creates a workflow with states', () => {
+      const workflow = Workflow({
+        states: ['draft', 'review', 'published', 'archived'],
+        initialState: 'draft',
+        transitions: [],
+      })
+
+      expect(workflow.states).toHaveLength(4)
+      expect(workflow.initialState).toBe('draft')
+    })
+
+    it('creates a workflow with transitions', () => {
+      const workflow = Workflow({
+        states: ['draft', 'review', 'published'],
+        initialState: 'draft',
+        transitions: [
+          { from: 'draft', to: 'review', action: 'submit' },
+          { from: 'review', to: 'published', action: 'approve' },
+          { from: 'review', to: 'draft', action: 'reject' },
+        ],
+      })
+
+      expect(workflow.transitions).toHaveLength(3)
+      expect(workflow.transitions?.[0]?.from).toBe('draft')
+      expect(workflow.transitions?.[0]?.to).toBe('review')
+    })
+
+    it('supports approvals config', () => {
+      const workflow = Workflow({
+        states: ['draft', 'review', 'published'],
+        initialState: 'draft',
+        transitions: [
+          { from: 'draft', to: 'review', action: 'submit' },
+        ],
+        approvals: [
+          { state: 'review', roles: ['editor', 'admin'] },
+        ],
+      })
+
+      expect(workflow.approvals).toHaveLength(1)
+      expect(workflow.approvals?.[0]?.roles).toContain('editor')
+    })
+  })
+})