digital-products 2.0.1

package/example.ts

@@ -0,0 +1,236 @@
+/**
+ * Example usage of digital-products primitives
+ */
+
+import {
+  App,
+  Route,
+  State,
+  Auth,
+  API,
+  Endpoint,
+  Content,
+  Workflow,
+  Data,
+  Index,
+  Validate,
+  Dataset,
+  Site,
+  Nav,
+  SEO,
+  MCP,
+  Tool,
+  SDK,
+  Export,
+  Example,
+  registry,
+} from './src/index.js'
+
+// Example 1: Define an App
+const myApp = App({
+  id: 'my-app',
+  name: 'My App',
+  description: 'A web application',
+  version: '1.0.0',
+  framework: 'react',
+  routes: [
+    Route('/', 'Home'),
+    Route('/about', 'About'),
+    Route('/users/:id', 'UserDetail', {
+      meta: { title: 'User Profile' },
+    }),
+  ],
+  state: State({
+    library: 'zustand',
+    schema: {
+      user: 'Current user object',
+      settings: 'App settings object',
+    },
+    persistence: {
+      type: 'local',
+      key: 'app-state',
+    },
+  }),
+  auth: Auth({
+    provider: 'clerk',
+    protectedRoutes: ['/dashboard', '/profile'],
+  }),
+})
+
+// Example 2: Define an API
+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',
+  },
+})
+
+// Example 3: Define Content
+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'],
+  },
+  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' },
+    ],
+  }),
+})
+
+// Example 4: Define Data
+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'),
+  ],
+})
+
+// Example 5: Define a Dataset
+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)',
+  },
+  size: 1000000,
+  license: 'CC-BY-4.0',
+  updateFrequency: 'daily',
+})
+
+// Example 6: Define a Site
+const docsSite = Site({
+  id: 'docs',
+  name: 'Documentation Site',
+  description: 'Product documentation',
+  version: '1.0.0',
+  generator: 'fumadocs',
+  navigation: [
+    Nav('Home', '/'),
+    Nav('Docs', '/docs', {
+      children: [
+        Nav('Getting Started', '/docs/getting-started'),
+        Nav('API Reference', '/docs/api-reference'),
+      ],
+    }),
+  ],
+  seo: SEO({
+    titleTemplate: '%s | My Product',
+    description: 'Official documentation for My Product',
+    keywords: ['docs', 'api', 'reference'],
+  }),
+})
+
+// Example 7: Define an MCP Server
+const mcpServer = MCP({
+  id: 'my-mcp',
+  name: 'My MCP Server',
+  description: 'Custom MCP server for AI tools',
+  version: '1.0.0',
+  transport: 'stdio',
+  tools: [
+    Tool('searchFiles', 'Search for files in the project', {
+      query: 'Search query',
+      path: 'Directory to search in',
+    }),
+    Tool('readFile', 'Read file contents', {
+      path: 'File path to read',
+    }),
+  ],
+})
+
+// Example 8: Define an SDK
+const mySDK = SDK({
+  id: 'my-sdk',
+  name: 'My SDK',
+  description: 'JavaScript SDK for My API',
+  version: '1.0.0',
+  language: 'typescript',
+  api: 'my-api',
+  exports: [
+    Export('function', 'createClient', 'Create an API client', {
+      parameters: {
+        apiKey: 'API key for authentication',
+        baseUrl: 'Optional base URL',
+      },
+      returns: 'API client instance',
+    }),
+  ],
+  install: 'npm install my-sdk',
+  examples: [
+    Example(
+      'Basic Usage',
+      'Create a client and make a request',
+      `import { createClient } from 'my-sdk'
+
+const client = createClient({ apiKey: 'YOUR_API_KEY' })
+const users = await client.get('/users')
+console.log(users)`
+    ),
+  ],
+})
+
+// Access the registry
+console.log('Registered products:', registry.list().map((p) => p.name))
+console.log('Apps:', registry.listByType('app').map((p) => p.name))
+console.log('APIs:', registry.listByType('api').map((p) => p.name))

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "digital-products",
+  "version": "2.0.1",
+  "description": "Primitives for defining and building digital products",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "test": "vitest",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint .",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "ai-database": "workspace:*",
+    "ai-functions": "workspace:*",
+    "rpc.do": "^0.1.0"
+  },
+  "keywords": [
+    "products",
+    "apps",
+    "api",
+    "digital",
+    "primitives"
+  ],
+  "license": "MIT"
+}

package/src/api.ts

@@ -0,0 +1,140 @@
+/**
+ * API() - Define an API
+ */
+
+import type { APIDefinition, EndpointDefinition, APIAuthConfig, RateLimitConfig } from './types.js'
+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: Omit<APIDefinition, 'type'>): APIDefinition {
+  const api: APIDefinition = {
+    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: EndpointDefinition['method'],
+  path: string,
+  description: string,
+  options?: Omit<EndpointDefinition, 'method' | 'path' | 'description'>
+): EndpointDefinition {
+  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: APIAuthConfig): APIAuthConfig {
+  return config
+}
+
+/**
+ * Helper to configure rate limiting
+ *
+ * @example
+ * ```ts
+ * const rateLimit = RateLimit({
+ *   requests: 100,
+ *   window: 60, // 60 seconds
+ *   onExceeded: 'reject',
+ * })
+ * ```
+ */
+export function RateLimit(config: RateLimitConfig): RateLimitConfig {
+  return config
+}

package/src/app.ts

@@ -0,0 +1,117 @@
+/**
+ * App() - Define an application
+ */
+
+import type { AppDefinition, RouteDefinition, StateDefinition, AuthConfig } from './types.js'
+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: Omit<AppDefinition, 'type'>): AppDefinition {
+  const app: AppDefinition = {
+    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: string,
+  component: string,
+  options?: Omit<RouteDefinition, 'path' | 'component'>
+): RouteDefinition {
+  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: StateDefinition): StateDefinition {
+  return config
+}
+
+/**
+ * Helper to configure authentication
+ *
+ * @example
+ * ```ts
+ * const auth = Auth({
+ *   provider: 'clerk',
+ *   protectedRoutes: ['/dashboard', '/profile'],
+ *   roles: ['admin', 'user'],
+ * })
+ * ```
+ */
+export function Auth(config: AuthConfig): AuthConfig {
+  return config
+}

package/src/content.ts

@@ -0,0 +1,82 @@
+/**
+ * Content() - Define content
+ */
+
+import type { ContentDefinition, WorkflowDefinition } from './types.js'
+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: Omit<ContentDefinition, 'type'>): ContentDefinition {
+  const content: ContentDefinition = {
+    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: WorkflowDefinition): WorkflowDefinition {
+  return config
+}