business-as-code 0.2.1 → 2.0.2

package/src/vision.ts

@@ -0,0 +1,88 @@
+/**
+ * Vision statement definition
+ */
+
+import type { VisionDefinition } from './types.js'
+
+/**
+ * Define a business vision statement with timeframe and success indicators
+ *
+ * @example
+ * ```ts
+ * const vision = Vision({
+ *   statement: 'To become the world\'s most trusted widget platform',
+ *   timeframe: '5 years',
+ *   successIndicators: [
+ *     '10M+ active users',
+ *     'Present in 50+ countries',
+ *     'Industry-leading NPS score',
+ *     '$1B+ annual revenue',
+ *   ],
+ * })
+ * ```
+ */
+export function Vision(definition: VisionDefinition): VisionDefinition {
+  // Validate required fields
+  if (!definition.statement) {
+    throw new Error('Vision statement is required')
+  }
+
+  // Return validated vision definition
+  return {
+    ...definition,
+    successIndicators: definition.successIndicators || [],
+    metadata: definition.metadata || {},
+  }
+}
+
+/**
+ * Check if a success indicator has been achieved
+ */
+export function checkIndicator(
+  vision: VisionDefinition,
+  indicator: string,
+  currentMetrics: Record<string, number | boolean>
+): boolean {
+  // Simple check - would need more sophisticated parsing in production
+  return Object.entries(currentMetrics).some(([key, value]) => {
+    return indicator.toLowerCase().includes(key.toLowerCase()) && Boolean(value)
+  })
+}
+
+/**
+ * Calculate vision progress based on achieved indicators
+ */
+export function calculateProgress(
+  vision: VisionDefinition,
+  currentMetrics: Record<string, number | boolean>
+): number {
+  if (!vision.successIndicators || vision.successIndicators.length === 0) {
+    return 0
+  }
+
+  const achieved = vision.successIndicators.filter(indicator =>
+    checkIndicator(vision, indicator, currentMetrics)
+  ).length
+
+  return (achieved / vision.successIndicators.length) * 100
+}
+
+/**
+ * Validate vision definition
+ */
+export function validateVision(vision: VisionDefinition): { valid: boolean; errors: string[] } {
+  const errors: string[] = []
+
+  if (!vision.statement) {
+    errors.push('Vision statement is required')
+  }
+
+  if (vision.statement && vision.statement.length < 10) {
+    errors.push('Vision statement should be at least 10 characters')
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors,
+  }
+}

package/src/workflow.ts

@@ -0,0 +1,280 @@
+/**
+ * Workflow definition (automation sequences)
+ */
+
+import type { WorkflowDefinition, WorkflowAction, WorkflowTrigger } from './types.js'
+
+/**
+ * Define an automated workflow with triggers and actions
+ *
+ * @example
+ * ```ts
+ * const workflow = Workflow({
+ *   name: 'New Customer Welcome',
+ *   description: 'Automated welcome sequence for new customers',
+ *   trigger: {
+ *     type: 'event',
+ *     event: 'Customer.created',
+ *   },
+ *   actions: [
+ *     {
+ *       order: 1,
+ *       type: 'send',
+ *       description: 'Send welcome email',
+ *       params: {
+ *         template: 'welcome_email',
+ *         to: '{{customer.email}}',
+ *       },
+ *     },
+ *     {
+ *       order: 2,
+ *       type: 'create',
+ *       description: 'Create onboarding task',
+ *       params: {
+ *         type: 'Task',
+ *         title: 'Onboard {{customer.name}}',
+ *         assignee: 'customer_success_team',
+ *       },
+ *     },
+ *     {
+ *       order: 3,
+ *       type: 'wait',
+ *       description: 'Wait 24 hours',
+ *       params: {
+ *         duration: '24 hours',
+ *       },
+ *     },
+ *     {
+ *       order: 4,
+ *       type: 'notify',
+ *       description: 'Send setup reminder',
+ *       params: {
+ *         channel: 'email',
+ *         message: 'Reminder to complete setup',
+ *       },
+ *       condition: 'customer.setupCompleted === false',
+ *     },
+ *   ],
+ * })
+ * ```
+ */
+export function Workflow(definition: WorkflowDefinition): WorkflowDefinition {
+  if (!definition.name) {
+    throw new Error('Workflow name is required')
+  }
+
+  if (!definition.trigger) {
+    throw new Error('Workflow trigger is required')
+  }
+
+  return {
+    ...definition,
+    actions: definition.actions || [],
+    metadata: definition.metadata || {},
+  }
+}
+
+/**
+ * Get actions in execution order
+ */
+export function getActionsInOrder(workflow: WorkflowDefinition): WorkflowAction[] {
+  return [...(workflow.actions || [])].sort((a, b) => a.order - b.order)
+}
+
+/**
+ * Get actions by type
+ */
+export function getActionsByType(
+  workflow: WorkflowDefinition,
+  type: WorkflowAction['type']
+): WorkflowAction[] {
+  return workflow.actions?.filter(action => action.type === type) || []
+}
+
+/**
+ * Get conditional actions
+ */
+export function getConditionalActions(workflow: WorkflowDefinition): WorkflowAction[] {
+  return workflow.actions?.filter(action => action.condition) || []
+}
+
+/**
+ * Add action to workflow
+ */
+export function addAction(workflow: WorkflowDefinition, action: WorkflowAction): WorkflowDefinition {
+  return {
+    ...workflow,
+    actions: [...(workflow.actions || []), action],
+  }
+}
+
+/**
+ * Remove action from workflow
+ */
+export function removeAction(workflow: WorkflowDefinition, order: number): WorkflowDefinition {
+  return {
+    ...workflow,
+    actions: workflow.actions?.filter(a => a.order !== order),
+  }
+}
+
+/**
+ * Update action in workflow
+ */
+export function updateAction(
+  workflow: WorkflowDefinition,
+  order: number,
+  updates: Partial<WorkflowAction>
+): WorkflowDefinition {
+  const actions = workflow.actions?.map(action =>
+    action.order === order ? { ...action, ...updates } : action
+  )
+
+  return {
+    ...workflow,
+    actions,
+  }
+}
+
+/**
+ * Check if trigger is event-based
+ */
+export function isEventTrigger(trigger: WorkflowTrigger): boolean {
+  return trigger.type === 'event'
+}
+
+/**
+ * Check if trigger is schedule-based
+ */
+export function isScheduleTrigger(trigger: WorkflowTrigger): boolean {
+  return trigger.type === 'schedule'
+}
+
+/**
+ * Check if trigger is webhook-based
+ */
+export function isWebhookTrigger(trigger: WorkflowTrigger): boolean {
+  return trigger.type === 'webhook'
+}
+
+/**
+ * Parse wait duration to milliseconds
+ */
+export function parseWaitDuration(duration: string): number {
+  const match = duration.match(/(\d+)\s*(ms|millisecond|milliseconds|s|second|seconds|m|minute|minutes|h|hour|hours|d|day|days)/)
+  if (!match) return 0
+
+  const value = parseInt(match[1] || '0', 10)
+  const unit = match[2]
+
+  switch (unit) {
+    case 'ms':
+    case 'millisecond':
+    case 'milliseconds':
+      return value
+    case 's':
+    case 'second':
+    case 'seconds':
+      return value * 1000
+    case 'm':
+    case 'minute':
+    case 'minutes':
+      return value * 60 * 1000
+    case 'h':
+    case 'hour':
+    case 'hours':
+      return value * 60 * 60 * 1000
+    case 'd':
+    case 'day':
+    case 'days':
+      return value * 24 * 60 * 60 * 1000
+    default:
+      return 0
+  }
+}
+
+/**
+ * Evaluate condition (simple implementation)
+ */
+export function evaluateCondition(condition: string, context: Record<string, unknown>): boolean {
+  // This is a simplified implementation
+  // In production, use a proper expression evaluator
+  try {
+    // Replace variable references with actual values
+    let expression = condition
+    for (const [key, value] of Object.entries(context)) {
+      const regex = new RegExp(`\\b${key}\\b`, 'g')
+      expression = expression.replace(regex, JSON.stringify(value))
+    }
+
+    // Evaluate the expression (unsafe in production - use a proper evaluator)
+    return Boolean(eval(expression))
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Fill template with context values
+ */
+export function fillTemplate(template: string, context: Record<string, unknown>): string {
+  return template.replace(/\{\{([^}]+)\}\}/g, (_, path) => {
+    const value = getNestedValue(context, path.trim())
+    return String(value ?? '')
+  })
+}
+
+/**
+ * Get nested value from object by path
+ */
+function getNestedValue(obj: Record<string, unknown>, path: string): unknown {
+  return path.split('.').reduce((acc: any, part) => acc?.[part], obj)
+}
+
+/**
+ * Validate workflow definition
+ */
+export function validateWorkflow(workflow: WorkflowDefinition): { valid: boolean; errors: string[] } {
+  const errors: string[] = []
+
+  if (!workflow.name) {
+    errors.push('Workflow name is required')
+  }
+
+  if (!workflow.trigger) {
+    errors.push('Workflow trigger is required')
+  } else {
+    if (workflow.trigger.type === 'event' && !workflow.trigger.event) {
+      errors.push('Event trigger must specify an event name')
+    }
+    if (workflow.trigger.type === 'schedule' && !workflow.trigger.schedule) {
+      errors.push('Schedule trigger must specify a schedule expression')
+    }
+    if (workflow.trigger.type === 'webhook' && !workflow.trigger.webhook) {
+      errors.push('Webhook trigger must specify a webhook URL')
+    }
+  }
+
+  if (workflow.actions) {
+    const orders = new Set<number>()
+    for (const action of workflow.actions) {
+      if (!action.type) {
+        errors.push(`Action at order ${action.order} must have a type`)
+      }
+      if (orders.has(action.order)) {
+        errors.push(`Duplicate action order: ${action.order}`)
+      }
+      orders.add(action.order)
+
+      // Validate action-specific requirements
+      if (action.type === 'wait' && !action.params?.duration) {
+        errors.push(`Wait action at order ${action.order} must specify duration`)
+      }
+    }
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors,
+  }
+}

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts", "**/*.spec.ts"]
+}

package/dist/loaders/index.d.ts

@@ -1,174 +0,0 @@
-import { L as LoaderOptions, B as BusinessSchema, c as LoadResult } from '../types-CJ9eGS_C.js';
-import { NounSchema } from 'db.sb';
-
-/**
- * MDX Loader
- *
- * Load business schemas from MDX files using the DSL parser from db.sb
- */
-
-/**
- * Load a business schema from MDX source
- *
- * @example
- * ```typescript
- * const mdx = `
- * <Business name="My Startup">
- *   <Noun name="Customer" group="Success">
- *     <Name text required />
- *     <Email />
- *     <Status status="active|inactive|churned" />
- *   </Noun>
- * </Business>
- * `
- * const schema = await loadFromMDX(mdx)
- * ```
- */
-declare function loadFromMDX(source: string, options?: LoaderOptions): Promise<BusinessSchema>;
-/**
- * Load a single noun definition from MDX
- *
- * @example
- * ```typescript
- * const mdx = `
- * <Noun name="Customer" group="Success">
- *   <Name text required />
- *   <Email />
- * </Noun>
- * `
- * const noun = await loadNounFromMDX(mdx)
- * ```
- */
-declare function loadNounFromMDX(source: string, options?: LoaderOptions): Promise<NounSchema>;
-/**
- * Load multiple noun definitions from MDX
- */
-declare function loadNounsFromMDX(source: string, options?: LoaderOptions): Promise<NounSchema[]>;
-
-/**
- * YAML Loader
- *
- * Load business schemas from YAML files
- */
-
-/**
- * Load a business schema from YAML source
- *
- * @example
- * ```yaml
- * name: My Startup
- * version: 1.0.0
- *
- * domains:
- *   success:
- *     - name: Customer
- *       titleField: name
- *       fields:
- *         name: text required
- *         email: email
- *         status: status:active|inactive|churned
- *         healthScore: score
- * ```
- */
-declare function loadFromYAML(source: string, _options?: LoaderOptions): BusinessSchema;
-/**
- * Load a single noun from YAML
- */
-declare function loadNounFromYAML(source: string, _options?: LoaderOptions): NounSchema;
-/**
- * Load multiple nouns from YAML
- */
-declare function loadNounsFromYAML(source: string, _options?: LoaderOptions): NounSchema[];
-/**
- * Serialize a business schema to YAML
- */
-declare function toYAML(schema: BusinessSchema): string;
-/**
- * Serialize a noun to YAML
- */
-declare function nounToYAML(noun: NounSchema): string;
-
-/**
- * JSON Loader
- *
- * Load business schemas from JSON files
- */
-
-/**
- * Load a business schema from JSON source
- *
- * @example
- * ```json
- * {
- *   "name": "My Startup",
- *   "version": "1.0.0",
- *   "domains": {
- *     "success": [
- *       {
- *         "name": "Customer",
- *         "titleField": "name",
- *         "fields": {
- *           "name": "text required",
- *           "email": "email",
- *           "status": "status:active|inactive|churned"
- *         }
- *       }
- *     ]
- *   }
- * }
- * ```
- */
-declare function loadFromJSON(source: string, _options?: LoaderOptions): BusinessSchema;
-/**
- * Load a single noun from JSON
- */
-declare function loadNounFromJSON(source: string, _options?: LoaderOptions): NounSchema;
-/**
- * Load multiple nouns from JSON
- */
-declare function loadNounsFromJSON(source: string, _options?: LoaderOptions): NounSchema[];
-/**
- * Serialize a business schema to JSON
- */
-declare function toJSON(schema: BusinessSchema, pretty?: boolean): string;
-/**
- * Serialize a noun to JSON
- */
-declare function nounToJSON(noun: NounSchema, pretty?: boolean): string;
-
-/**
- * Loaders Module
- *
- * Load business schemas from various formats (MDX, YAML, JSON)
- */
-
-/**
- * Load a business schema from any supported format
- *
- * Automatically detects the format from the source content.
- */
-declare function load(source: string, options?: LoaderOptions & {
-    format?: 'mdx' | 'yaml' | 'json';
-}): Promise<LoadResult>;
-/**
- * Load a single noun from any supported format
- */
-declare function loadNoun(source: string, options?: LoaderOptions & {
-    format?: 'mdx' | 'yaml' | 'json';
-}): Promise<NounSchema>;
-/**
- * Load multiple nouns from any supported format
- */
-declare function loadNouns(source: string, options?: LoaderOptions & {
-    format?: 'mdx' | 'yaml' | 'json';
-}): Promise<NounSchema[]>;
-/**
- * Serialize a business schema to a specific format
- */
-declare function serialize(schema: BusinessSchema, format?: 'yaml' | 'json'): string;
-/**
- * Serialize a noun to a specific format
- */
-declare function serializeNoun(noun: NounSchema, format?: 'yaml' | 'json'): string;
-
-export { load, loadFromJSON, loadFromMDX, loadFromYAML, loadNoun, loadNounFromJSON, loadNounFromMDX, loadNounFromYAML, loadNouns, loadNounsFromJSON, loadNounsFromMDX, loadNounsFromYAML, nounToJSON, nounToYAML, serialize, serializeNoun, toJSON, toYAML };