digital-products 2.1.1 → 2.3.0

package/vitest.config.ts

@@ -0,0 +1,42 @@
+import { defineWorkersConfig } from '@cloudflare/vitest-pool-workers/config'
+
+export default defineWorkersConfig({
+  test: {
+    // CRITICAL: Limit concurrency to prevent resource exhaustion
+    maxConcurrency: 1,
+    maxWorkers: 1,
+    minWorkers: 1,
+    fileParallelism: false,
+
+    poolOptions: {
+      workers: {
+        wrangler: { configPath: './wrangler.jsonc' },
+        miniflare: {
+          compatibilityDate: '2025-01-20',
+          compatibilityFlags: ['nodejs_compat_v2'],
+          durableObjects: {
+            PRODUCT_CATALOG: 'ProductCatalog',
+          },
+        },
+      },
+    },
+
+    include: ['src/**/*.test.ts', 'test/**/*.test.ts'],
+    testTimeout: 60000, // AI calls can take time
+    hookTimeout: 30000,
+
+    // Coverage configuration
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'json', 'html'],
+      include: ['src/**/*.ts'],
+      exclude: ['**/*.test.ts', '**/__tests__/**', '**/node_modules/**'],
+      thresholds: {
+        statements: 65,
+        branches: 60,
+        functions: 60,
+        lines: 65,
+      },
+    },
+  },
+})

package/wrangler.jsonc

@@ -0,0 +1,36 @@
+{
+  // Wrangler configuration for digital-products worker tests
+  // Used by @cloudflare/vitest-pool-workers for testing
+
+  "name": "digital-products",
+  "main": "src/worker.ts",
+  "compatibility_date": "2025-01-20",
+  "compatibility_flags": ["nodejs_compat_v2"],
+
+  // AI binding for Cloudflare Workers AI
+  // Enables real AI Gateway access in tests (cache: true for deterministic tests)
+  "ai": {
+    "binding": "AI"
+  },
+
+  // Durable Objects for product catalog persistence
+  "durable_objects": {
+    "bindings": [
+      { "name": "PRODUCT_CATALOG", "class_name": "ProductCatalog" }
+    ]
+  },
+
+  // Migrations for Durable Objects
+  "migrations": [
+    { "tag": "v1", "new_classes": ["ProductCatalog"] }
+  ],
+
+  // The default export (ProductService) extends WorkerEntrypoint
+  // All public methods are automatically exposed via RPC
+
+  // Environment variables for AI Gateway
+  // These are loaded from .dev.vars or .env in local development
+  "vars": {
+    // Placeholder - actual values come from .dev.vars
+  }
+}

package/.turbo/turbo-build.log

@@ -1,5 +0,0 @@
-
-
-> digital-products@2.0.1 build /Users/nathanclevenger/projects/primitives.org.ai/packages/digital-products
-> tsc
-

package/src/api.js

@@ -1,128 +0,0 @@
-/**
- * API() - Define an API
- */
-import { registerProduct } from './product.js';
-/**
- * Create an API definition
- *
- * @example
- * ```ts
- * const myAPI = API({
- *   id: 'my-api',
- *   name: 'My API',
- *   description: 'A RESTful API',
- *   version: '1.0.0',
- *   style: 'rest',
- *   baseUrl: 'https://api.example.com',
- *   endpoints: [
- *     Endpoint('GET', '/users', 'List all users', {
- *       response: {
- *         users: ['Array of user objects'],
- *         total: 'Total count (number)',
- *       },
- *     }),
- *     Endpoint('POST', '/users', 'Create a user', {
- *       request: {
- *         name: 'User name',
- *         email: 'User email',
- *       },
- *       response: {
- *         id: 'User ID',
- *         name: 'User name',
- *         email: 'User email',
- *       },
- *     }),
- *   ],
- *   auth: {
- *     type: 'bearer',
- *     header: 'Authorization',
- *   },
- *   rateLimit: {
- *     requests: 100,
- *     window: 60,
- *   },
- * })
- * ```
- */
-export function API(config) {
-    const api = {
-        type: 'api',
-        id: config.id,
-        name: config.name,
-        description: config.description,
-        version: config.version,
-        style: config.style || 'rest',
-        baseUrl: config.baseUrl,
-        endpoints: config.endpoints || [],
-        auth: config.auth,
-        rateLimit: config.rateLimit,
-        docsUrl: config.docsUrl,
-        openapi: config.openapi,
-        metadata: config.metadata,
-        tags: config.tags,
-        status: config.status || 'active',
-    };
-    return registerProduct(api);
-}
-/**
- * Helper to create an endpoint definition
- *
- * @example
- * ```ts
- * const endpoint = Endpoint('GET', '/users/:id', 'Get user by ID', {
- *   params: { id: 'User ID' },
- *   response: {
- *     id: 'User ID',
- *     name: 'User name',
- *     email: 'User email',
- *   },
- *   auth: true,
- * })
- * ```
- */
-export function Endpoint(method, path, description, options) {
-    return {
-        method,
-        path,
-        description,
-        ...options,
-    };
-}
-/**
- * Helper to configure API authentication
- *
- * @example
- * ```ts
- * const auth = APIAuth({
- *   type: 'bearer',
- *   header: 'Authorization',
- * })
- *
- * const oauth = APIAuth({
- *   type: 'oauth2',
- *   oauth2: {
- *     authUrl: 'https://auth.example.com/authorize',
- *     tokenUrl: 'https://auth.example.com/token',
- *     scopes: ['read', 'write'],
- *   },
- * })
- * ```
- */
-export function APIAuth(config) {
-    return config;
-}
-/**
- * Helper to configure rate limiting
- *
- * @example
- * ```ts
- * const rateLimit = RateLimit({
- *   requests: 100,
- *   window: 60, // 60 seconds
- *   onExceeded: 'reject',
- * })
- * ```
- */
-export function RateLimit(config) {
-    return config;
-}

package/src/app.js

@@ -1,106 +0,0 @@
-/**
- * App() - Define an application
- */
-import { registerProduct } from './product.js';
-/**
- * Create an application definition
- *
- * @example
- * ```ts
- * const myApp = App({
- *   id: 'my-app',
- *   name: 'My App',
- *   description: 'A web application',
- *   version: '1.0.0',
- *   framework: 'react',
- *   routes: [
- *     { path: '/', component: 'Home' },
- *     { path: '/about', component: 'About' },
- *     { path: '/users/:id', component: 'UserDetail' },
- *   ],
- *   state: {
- *     library: 'zustand',
- *     schema: {
- *       user: 'Current user object',
- *       settings: 'App settings object',
- *     },
- *   },
- *   auth: {
- *     provider: 'clerk',
- *     protectedRoutes: ['/dashboard', '/profile'],
- *   },
- * })
- * ```
- */
-export function App(config) {
-    const app = {
-        type: 'app',
-        id: config.id,
-        name: config.name,
-        description: config.description,
-        version: config.version,
-        framework: config.framework || 'react',
-        routes: config.routes || [],
-        config: config.config,
-        state: config.state,
-        auth: config.auth,
-        deployments: config.deployments,
-        metadata: config.metadata,
-        tags: config.tags,
-        status: config.status || 'active',
-    };
-    return registerProduct(app);
-}
-/**
- * Helper to create a route definition
- *
- * @example
- * ```ts
- * const userRoute = Route('/users/:id', 'UserDetail', {
- *   meta: { title: 'User Profile' },
- * })
- * ```
- */
-export function Route(path, component, options) {
-    return {
-        path,
-        component,
-        ...options,
-    };
-}
-/**
- * Helper to configure state management
- *
- * @example
- * ```ts
- * const state = State({
- *   library: 'zustand',
- *   schema: {
- *     user: 'Current user',
- *     settings: 'User settings',
- *   },
- *   persistence: {
- *     type: 'local',
- *     key: 'app-state',
- *   },
- * })
- * ```
- */
-export function State(config) {
-    return config;
-}
-/**
- * Helper to configure authentication
- *
- * @example
- * ```ts
- * const auth = Auth({
- *   provider: 'clerk',
- *   protectedRoutes: ['/dashboard', '/profile'],
- *   roles: ['admin', 'user'],
- * })
- * ```
- */
-export function Auth(config) {
-    return config;
-}

package/src/content.js

@@ -1,77 +0,0 @@
-/**
- * Content() - Define content
- */
-import { registerProduct } from './product.js';
-/**
- * Create a content definition
- *
- * @example
- * ```ts
- * const blogContent = Content({
- *   id: 'blog',
- *   name: 'Blog Posts',
- *   description: 'Blog content for the website',
- *   version: '1.0.0',
- *   format: 'mdx',
- *   source: './content/blog',
- *   frontmatter: {
- *     title: 'Post title',
- *     author: 'Author name',
- *     date: 'Publication date (date)',
- *     tags: ['Array of tags'],
- *   },
- *   categories: ['Technology', 'Business', 'Design'],
- *   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' },
- *     ],
- *   }),
- * })
- * ```
- */
-export function Content(config) {
-    const content = {
-        type: 'content',
-        id: config.id,
-        name: config.name,
-        description: config.description,
-        version: config.version,
-        format: config.format || 'markdown',
-        source: config.source,
-        schema: config.schema,
-        frontmatter: config.frontmatter,
-        categories: config.categories,
-        workflow: config.workflow,
-        metadata: config.metadata,
-        tags: config.tags,
-        status: config.status || 'active',
-    };
-    return registerProduct(content);
-}
-/**
- * Helper to create a workflow definition
- *
- * @example
- * ```ts
- * const workflow = Workflow({
- *   states: ['draft', 'review', 'published', 'archived'],
- *   initialState: 'draft',
- *   transitions: [
- *     { from: 'draft', to: 'review', action: 'submit' },
- *     { from: 'review', to: 'published', action: 'approve' },
- *     { from: 'review', to: 'draft', action: 'reject' },
- *     { from: 'published', to: 'archived', action: 'archive' },
- *   ],
- *   approvals: [
- *     { state: 'review', roles: ['editor', 'admin'] },
- *   ],
- * })
- * ```
- */
-export function Workflow(config) {
-    return config;
-}

package/src/data.js

@@ -1,106 +0,0 @@
-/**
- * Data() - Define structured data
- */
-import { registerProduct } from './product.js';
-/**
- * Create a data definition
- *
- * @example
- * ```ts
- * const userData = Data({
- *   id: 'users',
- *   name: 'Users',
- *   description: 'User data store',
- *   version: '1.0.0',
- *   schema: {
- *     id: 'User ID',
- *     name: 'User name',
- *     email: 'User email',
- *     createdAt: 'Creation timestamp (date)',
- *     role: 'admin | user | guest',
- *   },
- *   provider: 'postgres',
- *   indexes: [
- *     Index('email_idx', ['email'], { unique: true }),
- *     Index('role_idx', ['role']),
- *   ],
- *   validation: [
- *     Validate('email', 'email', 'Must be a valid email'),
- *     Validate('name', 'required', 'Name is required'),
- *   ],
- * })
- * ```
- */
-export function Data(config) {
-    const data = {
-        type: 'data',
-        id: config.id,
-        name: config.name,
-        description: config.description,
-        version: config.version,
-        schema: config.schema,
-        provider: config.provider || 'fs',
-        indexes: config.indexes,
-        relationships: config.relationships,
-        validation: config.validation,
-        metadata: config.metadata,
-        tags: config.tags,
-        status: config.status || 'active',
-    };
-    return registerProduct(data);
-}
-/**
- * Helper to create an index definition
- *
- * @example
- * ```ts
- * const emailIndex = Index('email_idx', ['email'], { unique: true })
- * const nameIndex = Index('name_idx', ['firstName', 'lastName'])
- * const vectorIndex = Index('embedding_idx', ['embedding'], { type: 'vector' })
- * ```
- */
-export function Index(name, fields, options) {
-    return {
-        name,
-        fields,
-        ...options,
-    };
-}
-/**
- * Helper to create a relationship definition
- *
- * @example
- * ```ts
- * const userPosts = Relationship('one-to-many', 'userId', 'posts', 'author')
- * const postTags = Relationship('many-to-many', 'postId', 'tags', 'posts')
- * ```
- */
-export function Relationship(type, from, to, field) {
-    return {
-        type,
-        from,
-        to,
-        field,
-    };
-}
-/**
- * Helper to create a validation rule
- *
- * @example
- * ```ts
- * const emailRule = Validate('email', 'email', 'Must be a valid email')
- * const ageRule = Validate('age', 'min', { value: 18 }, 'Must be 18 or older')
- * const uniqueRule = Validate('username', 'unique', 'Username already taken')
- * ```
- */
-export function Validate(field, rule, paramsOrMessage, message) {
-    if (typeof paramsOrMessage === 'string') {
-        return { field, rule, message: paramsOrMessage };
-    }
-    return {
-        field,
-        rule,
-        params: paramsOrMessage,
-        message,
-    };
-}

package/src/dataset.js

@@ -1,49 +0,0 @@
-/**
- * Dataset() - Define a dataset
- */
-import { registerProduct } from './product.js';
-/**
- * Create a dataset definition
- *
- * @example
- * ```ts
- * const movieDataset = Dataset({
- *   id: 'movies',
- *   name: 'Movie Database',
- *   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',
- * })
- * ```
- */
-export function Dataset(config) {
-    const dataset = {
-        type: 'dataset',
-        id: config.id,
-        name: config.name,
-        description: config.description,
-        version: config.version,
-        format: config.format || 'json',
-        schema: config.schema,
-        source: config.source,
-        size: config.size,
-        license: config.license,
-        updateFrequency: config.updateFrequency || 'static',
-        metadata: config.metadata,
-        tags: config.tags,
-        status: config.status || 'active',
-    };
-    return registerProduct(dataset);
-}