digital-products 2.1.3 → 2.3.0

package/src/features/define.ts

@@ -1,130 +0,0 @@
-/**
- * Feature Definition
- * Primitives for defining product features
- */
-
-/**
- * Feature status options
- */
-export type FeatureStatus = 'active' | 'beta' | 'deprecated' | 'disabled'
-
-/**
- * Feature definition
- */
-export interface FeatureDefinition {
-  /** Unique identifier */
-  id: string
-  /** Human-readable name */
-  name: string
-  /** Description of the feature */
-  description: string
-  /** Feature category */
-  category?: string
-  /** Dependencies on other features */
-  dependencies?: string[]
-  /** Metadata */
-  metadata?: Record<string, unknown>
-  /** Feature status */
-  status?: FeatureStatus
-  /** Version */
-  version?: string
-}
-
-/**
- * Create a feature definition
- */
-export function Feature(config: Omit<FeatureDefinition, 'status'> & { status?: FeatureStatus }): FeatureDefinition {
-  return {
-    id: config.id,
-    name: config.name,
-    description: config.description,
-    category: config.category,
-    dependencies: config.dependencies,
-    metadata: config.metadata,
-    status: config.status ?? 'active',
-    version: config.version,
-  }
-}
-
-/**
- * Create and validate a feature definition
- */
-export function defineFeature(
-  config: Omit<FeatureDefinition, 'status'> & { status?: FeatureStatus }
-): FeatureDefinition {
-  if (!config.id || config.id.trim() === '') {
-    throw new Error('Feature ID is required')
-  }
-
-  return Feature(config)
-}
-
-/**
- * Feature registry interface
- */
-export interface FeatureRegistry {
-  /** Register a feature */
-  register(feature: FeatureDefinition): void
-  /** Get a feature by ID */
-  get(id: string): FeatureDefinition | undefined
-  /** List all features */
-  list(): FeatureDefinition[]
-  /** List features by category */
-  listByCategory(category: string): FeatureDefinition[]
-  /** Get dependency graph for a feature */
-  getDependencyGraph(featureId: string): string[]
-  /** Clear registry */
-  clear(): void
-}
-
-/**
- * Create a feature registry
- */
-export function createFeatureRegistry(): FeatureRegistry {
-  const features = new Map<string, FeatureDefinition>()
-
-  return {
-    register(feature: FeatureDefinition): void {
-      features.set(feature.id, feature)
-    },
-
-    get(id: string): FeatureDefinition | undefined {
-      return features.get(id)
-    },
-
-    list(): FeatureDefinition[] {
-      return Array.from(features.values())
-    },
-
-    listByCategory(category: string): FeatureDefinition[] {
-      return Array.from(features.values()).filter((f) => f.category === category)
-    },
-
-    getDependencyGraph(featureId: string): string[] {
-      const result: string[] = []
-      const visited = new Set<string>()
-
-      const traverse = (id: string) => {
-        if (visited.has(id)) return
-        visited.add(id)
-
-        const feature = features.get(id)
-        if (feature?.dependencies) {
-          for (const depId of feature.dependencies) {
-            traverse(depId)
-            if (!result.includes(depId)) {
-              result.push(depId)
-            }
-          }
-        }
-      }
-
-      traverse(featureId)
-      return result
-    },
-
-    clear(): void {
-      features.clear()
-    },
-  }
-}

package/src/features/flags.ts

@@ -1,247 +0,0 @@
-/**
- * Feature Flags
- * Runtime feature flag system
- */
-
-import { createHash } from 'crypto'
-
-/**
- * Flag value types
- */
-export type FlagType = 'boolean' | 'string' | 'number' | 'json'
-
-/**
- * Targeting condition
- */
-export interface TargetingCondition {
-  attribute: string
-  operator: 'equals' | 'not_equals' | 'in' | 'not_in' | 'gt' | 'lt' | 'gte' | 'lte' | 'contains'
-  value: unknown
-}
-
-/**
- * Targeting rule
- */
-export interface TargetingRule {
-  condition: TargetingCondition
-  value: unknown
-}
-
-/**
- * Feature flag definition
- */
-export interface FeatureFlagDefinition {
-  /** Unique key */
-  key: string
-  /** Human-readable name */
-  name: string
-  /** Flag type */
-  type: FlagType
-  /** Default value */
-  defaultValue: unknown
-  /** Allowed variants (for string type) */
-  variants?: string[]
-  /** Min value (for number type) */
-  min?: number
-  /** Max value (for number type) */
-  max?: number
-  /** Targeting rules */
-  rules?: TargetingRule[]
-  /** Rollout percentage (0-100) */
-  rolloutPercentage?: number
-  /** Description */
-  description?: string
-}
-
-/**
- * Create a feature flag
- */
-export function FeatureFlag(config: FeatureFlagDefinition): FeatureFlagDefinition {
-  return {
-    key: config.key,
-    name: config.name,
-    type: config.type,
-    defaultValue: config.defaultValue,
-    variants: config.variants,
-    min: config.min,
-    max: config.max,
-    rules: config.rules,
-    rolloutPercentage: config.rolloutPercentage,
-    description: config.description,
-  }
-}
-
-/**
- * Create a feature flag (alias)
- */
-export const createFeatureFlag = FeatureFlag
-
-/**
- * Evaluation context for flag evaluation
- */
-export interface FlagEvaluationContext {
-  userId?: string
-  sessionId?: string
-  attributes?: Record<string, unknown>
-}
-
-/**
- * Evaluation stats
- */
-export interface EvaluationStats {
-  totalEvaluations: number
-  trueCount: number
-  falseCount: number
-}
-
-/**
- * Feature flag manager interface
- */
-export interface FeatureFlagManager {
-  /** Register a flag */
-  register(flag: FeatureFlagDefinition): void
-  /** Get a flag by key */
-  get(key: string): FeatureFlagDefinition | undefined
-  /** Evaluate a flag */
-  evaluate(key: string, context: FlagEvaluationContext): unknown
-  /** Get evaluation stats */
-  getEvaluationStats(key: string): EvaluationStats
-  /** Set override for testing */
-  setOverride(key: string, value: unknown): void
-  /** Clear override */
-  clearOverride(key: string): void
-  /** List all flags */
-  list(): FeatureFlagDefinition[]
-  /** Remove a flag */
-  remove(key: string): void
-}
-
-/**
- * Create a feature flag manager
- */
-export function createFeatureFlagManager(): FeatureFlagManager {
-  const flags = new Map<string, FeatureFlagDefinition>()
-  const overrides = new Map<string, unknown>()
-  const stats = new Map<string, EvaluationStats>()
-
-  const initStats = (key: string) => {
-    if (!stats.has(key)) {
-      stats.set(key, { totalEvaluations: 0, trueCount: 0, falseCount: 0 })
-    }
-  }
-
-  const evaluateCondition = (condition: TargetingCondition, context: FlagEvaluationContext): boolean => {
-    const attributeValue = context.attributes?.[condition.attribute]
-
-    switch (condition.operator) {
-      case 'equals':
-        return attributeValue === condition.value
-      case 'not_equals':
-        return attributeValue !== condition.value
-      case 'in':
-        return Array.isArray(condition.value) && condition.value.includes(attributeValue)
-      case 'not_in':
-        return Array.isArray(condition.value) && !condition.value.includes(attributeValue)
-      case 'gt':
-        return typeof attributeValue === 'number' && attributeValue > (condition.value as number)
-      case 'lt':
-        return typeof attributeValue === 'number' && attributeValue < (condition.value as number)
-      case 'gte':
-        return typeof attributeValue === 'number' && attributeValue >= (condition.value as number)
-      case 'lte':
-        return typeof attributeValue === 'number' && attributeValue <= (condition.value as number)
-      case 'contains':
-        return typeof attributeValue === 'string' && attributeValue.includes(condition.value as string)
-      default:
-        return false
-    }
-  }
-
-  const hashUserToPercentage = (userId: string, key: string): number => {
-    const hash = createHash('md5').update(`${userId}-${key}`).digest('hex')
-    const num = parseInt(hash.substring(0, 8), 16)
-    return (num % 100) + 1
-  }
-
-  return {
-    register(flag: FeatureFlagDefinition): void {
-      flags.set(flag.key, flag)
-      initStats(flag.key)
-    },
-
-    get(key: string): FeatureFlagDefinition | undefined {
-      return flags.get(key)
-    },
-
-    evaluate(key: string, context: FlagEvaluationContext): unknown {
-      initStats(key)
-      const flagStats = stats.get(key)!
-      flagStats.totalEvaluations++
-
-      // Check for override first
-      if (overrides.has(key)) {
-        const value = overrides.get(key)
-        if (value === true) flagStats.trueCount++
-        else if (value === false) flagStats.falseCount++
-        return value
-      }
-
-      const flag = flags.get(key)
-      if (!flag) {
-        return undefined
-      }
-
-      // Check targeting rules
-      if (flag.rules) {
-        for (const rule of flag.rules) {
-          if (evaluateCondition(rule.condition, context)) {
-            const value = rule.value
-            if (value === true) flagStats.trueCount++
-            else if (value === false) flagStats.falseCount++
-            return value
-          }
-        }
-      }
-
-      // Check rollout percentage
-      if (flag.rolloutPercentage !== undefined && context.userId) {
-        const userPercentage = hashUserToPercentage(context.userId, key)
-        if (userPercentage <= flag.rolloutPercentage) {
-          if (flag.type === 'boolean') {
-            flagStats.trueCount++
-            return true
-          }
-        }
-      }
-
-      // Return default value
-      const value = flag.defaultValue
-      if (value === true) flagStats.trueCount++
-      else if (value === false) flagStats.falseCount++
-      return value
-    },
-
-    getEvaluationStats(key: string): EvaluationStats {
-      initStats(key)
-      return stats.get(key)!
-    },
-
-    setOverride(key: string, value: unknown): void {
-      overrides.set(key, value)
-    },
-
-    clearOverride(key: string): void {
-      overrides.delete(key)
-    },
-
-    list(): FeatureFlagDefinition[] {
-      return Array.from(flags.values())
-    },
-
-    remove(key: string): void {
-      flags.delete(key)
-      overrides.delete(key)
-      stats.delete(key)
-    },
-  }
-}

package/src/features/toggles.ts

@@ -1,189 +0,0 @@
-/**
- * Feature Toggles
- * Operational feature toggles for release management
- */
-
-/**
- * Toggle categories following Martin Fowler's feature toggle taxonomy
- */
-export type ToggleCategory = 'ops' | 'release' | 'experiment' | 'permission'
-
-/**
- * Feature toggle definition
- */
-export interface FeatureToggleDefinition {
-  /** Toggle name */
-  name: string
-  /** Category */
-  category: ToggleCategory
-  /** Whether toggle is enabled */
-  enabled: boolean
-  /** Description */
-  description?: string
-  /** Release date (for release toggles) */
-  releaseDate?: Date
-  /** Experiment ID (for experiment toggles) */
-  experimentId?: string
-  /** Required roles (for permission toggles) */
-  requiredRoles?: string[]
-  /** Expiration date */
-  expiresAt?: Date
-}
-
-/**
- * Create a feature toggle
- */
-export function FeatureToggle(config: FeatureToggleDefinition): FeatureToggleDefinition {
-  return {
-    name: config.name,
-    category: config.category,
-    enabled: config.enabled,
-    description: config.description,
-    releaseDate: config.releaseDate,
-    experimentId: config.experimentId,
-    requiredRoles: config.requiredRoles,
-    expiresAt: config.expiresAt,
-  }
-}
-
-/**
- * Create a toggle (alias)
- */
-export const createToggle = FeatureToggle
-
-/**
- * Toggle evaluation context
- */
-export interface ToggleContext {
-  roles?: string[]
-  userId?: string
-  attributes?: Record<string, unknown>
-}
-
-/**
- * Toggle service interface
- */
-export interface ToggleService {
-  /** Register a toggle */
-  register(toggle: FeatureToggleDefinition): void
-  /** Check if toggle is enabled */
-  isEnabled(name: string, context?: ToggleContext): boolean
-  /** Enable a toggle */
-  enable(name: string): void
-  /** Disable a toggle */
-  disable(name: string): void
-  /** List toggles by category */
-  listByCategory(category: ToggleCategory): FeatureToggleDefinition[]
-  /** Bulk enable toggles */
-  bulkEnable(names: string[]): void
-  /** Bulk disable toggles */
-  bulkDisable(names: string[]): void
-  /** Export toggle state */
-  export(): FeatureToggleDefinition[]
-  /** Import toggle state */
-  import(toggles: FeatureToggleDefinition[]): void
-  /** Get toggle by name */
-  get(name: string): FeatureToggleDefinition | undefined
-}
-
-/**
- * Create a toggle service
- */
-export function createToggleService(): ToggleService {
-  const toggles = new Map<string, FeatureToggleDefinition>()
-
-  const checkPermission = (toggle: FeatureToggleDefinition, context?: ToggleContext): boolean => {
-    if (toggle.category !== 'permission' || !toggle.requiredRoles) {
-      return true
-    }
-
-    if (!context?.roles) {
-      return false
-    }
-
-    return toggle.requiredRoles.some((role) => context.roles!.includes(role))
-  }
-
-  const checkExpiration = (toggle: FeatureToggleDefinition): boolean => {
-    if (!toggle.expiresAt) {
-      return true
-    }
-
-    return new Date() < toggle.expiresAt
-  }
-
-  return {
-    register(toggle: FeatureToggleDefinition): void {
-      toggles.set(toggle.name, toggle)
-    },
-
-    isEnabled(name: string, context?: ToggleContext): boolean {
-      const toggle = toggles.get(name)
-      if (!toggle) {
-        return false
-      }
-
-      // Check expiration
-      if (!checkExpiration(toggle)) {
-        return false
-      }
-
-      // Check permission for permission toggles
-      if (!checkPermission(toggle, context)) {
-        return false
-      }
-
-      return toggle.enabled
-    },
-
-    enable(name: string): void {
-      const toggle = toggles.get(name)
-      if (toggle) {
-        toggle.enabled = true
-      }
-    },
-
-    disable(name: string): void {
-      const toggle = toggles.get(name)
-      if (toggle) {
-        toggle.enabled = false
-      }
-    },
-
-    listByCategory(category: ToggleCategory): FeatureToggleDefinition[] {
-      return Array.from(toggles.values()).filter((t) => t.category === category)
-    },
-
-    bulkEnable(names: string[]): void {
-      for (const name of names) {
-        const toggle = toggles.get(name)
-        if (toggle) {
-          toggle.enabled = true
-        }
-      }
-    },
-
-    bulkDisable(names: string[]): void {
-      for (const name of names) {
-        const toggle = toggles.get(name)
-        if (toggle) {
-          toggle.enabled = false
-        }
-      }
-    },
-
-    export(): FeatureToggleDefinition[] {
-      return Array.from(toggles.values())
-    },
-
-    import(importedToggles: FeatureToggleDefinition[]): void {
-      for (const toggle of importedToggles) {
-        toggles.set(toggle.name, toggle)
-      }
-    },
-
-    get(name: string): FeatureToggleDefinition | undefined {
-      return toggles.get(name)
-    },
-  }
-}

package/src/index.js

@@ -1,35 +0,0 @@
-/**
- * digital-products - Primitives for defining and building digital products
- *
- * This package provides primitives for defining digital products:
- * - Apps: Interactive user-facing applications
- * - APIs: Programmatic interfaces
- * - Content: Text/media content with schemas
- * - Data: Structured data definitions
- * - Datasets: Curated data collections
- * - Sites: Websites and documentation
- * - MCPs: Model Context Protocol servers
- * - SDKs: Software development kits
- *
- * @packageDocumentation
- */
-// Export all types
-export * from './types.js';
-// Export entity definitions (Nouns) as namespace to avoid conflicts with types
-export * as Nouns from './entities/index.js';
-// Also export individual entity collections for convenience
-export { AllDigitalProductEntities, DigitalProductEntityCategories, Entities, 
-// Category exports
-ProductEntities, ProductCategories, InterfaceEntities, InterfaceCategories, ContentEntities, ContentCategories, WebEntities, WebCategories, AIEntities, AICategories, LifecycleEntities, LifecycleCategories, } from './entities/index.js';
-// Export registry
-export { registry } from './registry.js';
-// Export product constructors
-export { Product, createProduct, registerProduct } from './product.js';
-export { App, Route, State, Auth } from './app.js';
-export { API, Endpoint, APIAuth, RateLimit } from './api.js';
-export { Content, Workflow } from './content.js';
-export { Data, Index, Relationship, Validate } from './data.js';
-export { Dataset } from './dataset.js';
-export { Site, Nav, SEO, Analytics } from './site.js';
-export { MCP, Tool, Resource, Prompt, MCPConfig } from './mcp.js';
-export { SDK, Export, Example } from './sdk.js';