business-as-code 2.1.3 → 2.4.0

package/src/workflow.ts

@@ -88,20 +88,23 @@ export function getActionsByType(
   workflow: WorkflowDefinition,
   type: WorkflowAction['type']
 ): WorkflowAction[] {
-  return workflow.actions?.filter(action => action.type === type) || []
+  return workflow.actions?.filter((action) => action.type === type) || []
 }
 
 /**
  * Get conditional actions
  */
 export function getConditionalActions(workflow: WorkflowDefinition): WorkflowAction[] {
-  return workflow.actions?.filter(action => action.condition) || []
+  return workflow.actions?.filter((action) => action.condition) || []
 }
 
 /**
  * Add action to workflow
  */
-export function addAction(workflow: WorkflowDefinition, action: WorkflowAction): WorkflowDefinition {
+export function addAction(
+  workflow: WorkflowDefinition,
+  action: WorkflowAction
+): WorkflowDefinition {
   return {
     ...workflow,
     actions: [...(workflow.actions || []), action],
@@ -112,10 +115,10 @@ export function addAction(workflow: WorkflowDefinition, action: WorkflowAction):
  * Remove action from workflow
  */
 export function removeAction(workflow: WorkflowDefinition, order: number): WorkflowDefinition {
-  return {
-    ...workflow,
-    actions: workflow.actions?.filter(a => a.order !== order),
-  }
+  const actions = workflow.actions?.filter((a) => a.order !== order)
+  const result: WorkflowDefinition = { ...workflow }
+  if (actions !== undefined) result.actions = actions
+  return result
 }
 
 /**
@@ -126,14 +129,13 @@ export function updateAction(
   order: number,
   updates: Partial<WorkflowAction>
 ): WorkflowDefinition {
-  const actions = workflow.actions?.map(action =>
+  const actions = workflow.actions?.map((action) =>
     action.order === order ? { ...action, ...updates } : action
   )
 
-  return {
-    ...workflow,
-    actions,
-  }
+  const result: WorkflowDefinition = { ...workflow }
+  if (actions !== undefined) result.actions = actions
+  return result
 }
 
 /**
@@ -161,7 +163,9 @@ export function isWebhookTrigger(trigger: WorkflowTrigger): boolean {
  * 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)/)
+  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)
@@ -234,7 +238,10 @@ function getNestedValue(obj: Record<string, unknown>, path: string): unknown {
 /**
  * Validate workflow definition
  */
-export function validateWorkflow(workflow: WorkflowDefinition): { valid: boolean; errors: string[] } {
+export function validateWorkflow(workflow: WorkflowDefinition): {
+  valid: boolean
+  errors: string[]
+} {
   const errors: string[] = []
 
   if (!workflow.name) {
@@ -267,7 +274,7 @@ export function validateWorkflow(workflow: WorkflowDefinition): { valid: boolean
       orders.add(action.order)
 
       // Validate action-specific requirements
-      if (action.type === 'wait' && !action.params?.duration) {
+      if (action.type === 'wait' && !action.params?.['duration']) {
         errors.push(`Wait action at order ${action.order} must specify duration`)
       }
     }

package/test/business.test.ts

@@ -0,0 +1,282 @@
+/**
+ * Tests for business.ts - Business entity definition and management
+ */
+
+import { describe, it, expect } from 'vitest'
+import {
+  Business,
+  getTotalBudget,
+  getTotalTeamSize,
+  getDepartment,
+  getTeam,
+  validateBusiness,
+} from '../src/business.js'
+import type { BusinessDefinition } from '../src/types.js'
+
+describe('Business', () => {
+  describe('Business()', () => {
+    it('should create a business entity with required fields', () => {
+      const business = Business({
+        name: 'Acme Corp',
+      })
+
+      expect(business.name).toBe('Acme Corp')
+      expect(business.values).toEqual([])
+      expect(business.teamSize).toBe(0)
+      expect(business.metadata).toEqual({})
+      expect(business.foundedAt).toBeInstanceOf(Date)
+    })
+
+    it('should create a business entity with all fields', () => {
+      const foundedDate = new Date('2020-01-01')
+      const business = Business({
+        name: 'Test Corp',
+        description: 'A test company',
+        industry: 'Technology',
+        mission: 'To innovate',
+        values: ['Innovation', 'Integrity'],
+        targetMarket: 'Enterprise',
+        foundedAt: foundedDate,
+        teamSize: 50,
+        structure: {
+          departments: [
+            {
+              name: 'Engineering',
+              head: 'Jane Smith',
+              members: ['Alice', 'Bob'],
+              budget: 1000000,
+            },
+          ],
+        },
+        metadata: { customField: 'value' },
+      })
+
+      expect(business.name).toBe('Test Corp')
+      expect(business.description).toBe('A test company')
+      expect(business.industry).toBe('Technology')
+      expect(business.mission).toBe('To innovate')
+      expect(business.values).toEqual(['Innovation', 'Integrity'])
+      expect(business.targetMarket).toBe('Enterprise')
+      expect(business.foundedAt).toBe(foundedDate)
+      expect(business.teamSize).toBe(50)
+      expect(business.structure?.departments).toHaveLength(1)
+      expect(business.metadata).toEqual({ customField: 'value' })
+    })
+
+    it('should throw error if name is empty', () => {
+      expect(() => Business({ name: '' })).toThrow('Business name is required')
+    })
+
+    it('should preserve provided values and not override with defaults', () => {
+      const business = Business({
+        name: 'Test',
+        values: ['Custom'],
+        teamSize: 100,
+      })
+
+      expect(business.values).toEqual(['Custom'])
+      expect(business.teamSize).toBe(100)
+    })
+  })
+
+  describe('getTotalBudget()', () => {
+    it('should return 0 if no departments', () => {
+      const business = Business({ name: 'Test' })
+      expect(getTotalBudget(business)).toBe(0)
+    })
+
+    it('should return 0 if structure has no departments', () => {
+      const business = Business({
+        name: 'Test',
+        structure: {},
+      })
+      expect(getTotalBudget(business)).toBe(0)
+    })
+
+    it('should calculate total budget across departments', () => {
+      const business = Business({
+        name: 'Test',
+        structure: {
+          departments: [
+            { name: 'Engineering', budget: 1000000 },
+            { name: 'Sales', budget: 500000 },
+            { name: 'HR' }, // No budget specified
+          ],
+        },
+      })
+
+      expect(getTotalBudget(business)).toBe(1500000)
+    })
+
+    it('should handle departments with zero budget', () => {
+      const business = Business({
+        name: 'Test',
+        structure: {
+          departments: [
+            { name: 'Engineering', budget: 1000000 },
+            { name: 'Sales', budget: 0 },
+          ],
+        },
+      })
+
+      expect(getTotalBudget(business)).toBe(1000000)
+    })
+  })
+
+  describe('getTotalTeamSize()', () => {
+    it('should return teamSize if no departments', () => {
+      const business = Business({ name: 'Test', teamSize: 50 })
+      expect(getTotalTeamSize(business)).toBe(50)
+    })
+
+    it('should return 0 if no teamSize and no departments', () => {
+      const business = Business({ name: 'Test' })
+      expect(getTotalTeamSize(business)).toBe(0)
+    })
+
+    it('should calculate total team size from department members', () => {
+      const business = Business({
+        name: 'Test',
+        structure: {
+          departments: [
+            { name: 'Engineering', members: ['Alice', 'Bob', 'Charlie'] },
+            { name: 'Sales', members: ['David', 'Eve'] },
+            { name: 'HR' }, // No members
+          ],
+        },
+      })
+
+      expect(getTotalTeamSize(business)).toBe(5)
+    })
+  })
+
+  describe('getDepartment()', () => {
+    const business = Business({
+      name: 'Test',
+      structure: {
+        departments: [
+          { name: 'Engineering', head: 'Jane' },
+          { name: 'Sales', head: 'John' },
+        ],
+      },
+    })
+
+    it('should find department by name', () => {
+      const dept = getDepartment(business, 'Engineering')
+      expect(dept?.name).toBe('Engineering')
+      expect(dept?.head).toBe('Jane')
+    })
+
+    it('should return undefined for non-existent department', () => {
+      const dept = getDepartment(business, 'Marketing')
+      expect(dept).toBeUndefined()
+    })
+
+    it('should return undefined if no structure', () => {
+      const simpleBusiness = Business({ name: 'Simple' })
+      const dept = getDepartment(simpleBusiness, 'Engineering')
+      expect(dept).toBeUndefined()
+    })
+  })
+
+  describe('getTeam()', () => {
+    const business = Business({
+      name: 'Test',
+      structure: {
+        teams: [
+          { name: 'Alpha', lead: 'Alice' },
+          { name: 'Beta', lead: 'Bob' },
+        ],
+      },
+    })
+
+    it('should find team by name', () => {
+      const team = getTeam(business, 'Alpha')
+      expect(team?.name).toBe('Alpha')
+      expect(team?.lead).toBe('Alice')
+    })
+
+    it('should return undefined for non-existent team', () => {
+      const team = getTeam(business, 'Gamma')
+      expect(team).toBeUndefined()
+    })
+
+    it('should return undefined if no structure', () => {
+      const simpleBusiness = Business({ name: 'Simple' })
+      const team = getTeam(simpleBusiness, 'Alpha')
+      expect(team).toBeUndefined()
+    })
+  })
+
+  describe('validateBusiness()', () => {
+    it('should validate valid business', () => {
+      const business = Business({
+        name: 'Valid Corp',
+        teamSize: 50,
+      })
+
+      const result = validateBusiness(business)
+      expect(result.valid).toBe(true)
+      expect(result.errors).toHaveLength(0)
+    })
+
+    it('should fail validation if name is missing', () => {
+      const business: BusinessDefinition = { name: '' }
+      const result = validateBusiness(business)
+
+      expect(result.valid).toBe(false)
+      expect(result.errors).toContain('Business name is required')
+    })
+
+    it('should fail validation if teamSize is negative', () => {
+      const business: BusinessDefinition = { name: 'Test', teamSize: -5 }
+      const result = validateBusiness(business)
+
+      expect(result.valid).toBe(false)
+      expect(result.errors).toContain('Team size cannot be negative')
+    })
+
+    it('should fail validation if department has no name', () => {
+      const business: BusinessDefinition = {
+        name: 'Test',
+        structure: {
+          departments: [{ name: '', budget: 1000 }],
+        },
+      }
+      const result = validateBusiness(business)
+
+      expect(result.valid).toBe(false)
+      expect(result.errors).toContain('Department name is required')
+    })
+
+    it('should fail validation if department budget is negative', () => {
+      const business: BusinessDefinition = {
+        name: 'Test',
+        structure: {
+          departments: [{ name: 'Engineering', budget: -1000 }],
+        },
+      }
+      const result = validateBusiness(business)
+
+      expect(result.valid).toBe(false)
+      expect(result.errors).toContain('Department Engineering budget cannot be negative')
+    })
+
+    it('should return multiple errors for multiple issues', () => {
+      const business: BusinessDefinition = {
+        name: '',
+        teamSize: -5,
+        structure: {
+          departments: [
+            { name: '', budget: 1000 },
+            { name: 'Sales', budget: -500 },
+          ],
+        },
+      }
+      const result = validateBusiness(business)
+
+      expect(result.valid).toBe(false)
+      expect(result.errors.length).toBeGreaterThan(1)
+    })
+  })
+})

package/test/dollar.test.ts

@@ -0,0 +1,270 @@
+/**
+ * Tests for dollar.ts - $ helper for business operations
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest'
+import {
+  $,
+  createBusinessOperations,
+  updateContext,
+  getContext,
+  resetContext,
+} from '../src/dollar.js'
+
+describe('Dollar ($) Helper', () => {
+  beforeEach(() => {
+    resetContext()
+  })
+
+  describe('createBusinessOperations()', () => {
+    it('should create operations with default context', () => {
+      const ops = createBusinessOperations()
+
+      expect(ops.context).toEqual({})
+      expect(typeof ops.format).toBe('function')
+      expect(typeof ops.percent).toBe('function')
+      expect(typeof ops.growth).toBe('function')
+      expect(typeof ops.margin).toBe('function')
+      expect(typeof ops.roi).toBe('function')
+      expect(typeof ops.ltv).toBe('function')
+      expect(typeof ops.cac).toBe('function')
+      expect(typeof ops.burnRate).toBe('function')
+      expect(typeof ops.runway).toBe('function')
+      expect(typeof ops.log).toBe('function')
+    })
+
+    it('should create operations with initial context', () => {
+      const ops = createBusinessOperations({
+        business: { name: 'Test Corp' },
+        financials: { revenue: 100000 },
+      })
+
+      expect(ops.context.business?.name).toBe('Test Corp')
+      expect(ops.context.financials?.revenue).toBe(100000)
+    })
+  })
+
+  describe('$.format()', () => {
+    it('should format currency with default USD', () => {
+      const formatted = $.format(1234.56)
+      expect(formatted).toContain('1,234.56')
+      expect(formatted).toContain('$')
+    })
+
+    it('should format currency with specified currency', () => {
+      const formatted = $.format(1000, 'EUR')
+      expect(formatted).toContain('1,000')
+    })
+
+    it('should format negative amounts', () => {
+      const formatted = $.format(-500)
+      expect(formatted).toContain('-')
+      expect(formatted).toContain('500')
+    })
+
+    it('should handle zero amount', () => {
+      const formatted = $.format(0)
+      expect(formatted).toContain('0')
+    })
+
+    it('should handle large numbers', () => {
+      const formatted = $.format(1000000000)
+      expect(formatted).toContain('1,000,000,000')
+    })
+  })
+
+  describe('$.percent()', () => {
+    it('should calculate percentage', () => {
+      expect($.percent(25, 100)).toBe(25)
+    })
+
+    it('should handle zero total', () => {
+      expect($.percent(25, 0)).toBe(0)
+    })
+
+    it('should handle over 100%', () => {
+      expect($.percent(150, 100)).toBe(150)
+    })
+
+    it('should handle decimal values', () => {
+      expect($.percent(33, 100)).toBe(33)
+    })
+
+    it('should handle zero value', () => {
+      expect($.percent(0, 100)).toBe(0)
+    })
+  })
+
+  describe('$.growth()', () => {
+    it('should calculate growth rate', () => {
+      expect($.growth(120, 100)).toBe(20)
+    })
+
+    it('should calculate negative growth', () => {
+      expect($.growth(80, 100)).toBe(-20)
+    })
+
+    it('should handle zero previous value', () => {
+      expect($.growth(100, 0)).toBe(0)
+    })
+
+    it('should handle same values (no growth)', () => {
+      expect($.growth(100, 100)).toBe(0)
+    })
+
+    it('should handle doubling', () => {
+      expect($.growth(200, 100)).toBe(100)
+    })
+  })
+
+  describe('$.margin()', () => {
+    it('should calculate margin', () => {
+      expect($.margin(100, 60)).toBe(40)
+    })
+
+    it('should handle zero revenue', () => {
+      expect($.margin(0, 0)).toBe(0)
+    })
+
+    it('should handle 100% margin', () => {
+      expect($.margin(100, 0)).toBe(100)
+    })
+
+    it('should handle negative margin', () => {
+      expect($.margin(100, 150)).toBe(-50)
+    })
+  })
+
+  describe('$.roi()', () => {
+    it('should calculate ROI', () => {
+      expect($.roi(150, 100)).toBe(50)
+    })
+
+    it('should calculate negative ROI', () => {
+      expect($.roi(80, 100)).toBe(-20)
+    })
+
+    it('should handle zero cost', () => {
+      expect($.roi(150, 0)).toBe(0)
+    })
+
+    it('should handle 100% ROI', () => {
+      expect($.roi(200, 100)).toBe(100)
+    })
+  })
+
+  describe('$.ltv()', () => {
+    it('should calculate lifetime value', () => {
+      expect($.ltv(100, 12, 2)).toBe(2400)
+    })
+
+    it('should handle monthly subscription', () => {
+      // $50/month, 12 months/year, 3 year lifetime
+      expect($.ltv(50, 12, 3)).toBe(1800)
+    })
+
+    it('should handle zero values', () => {
+      expect($.ltv(0, 12, 2)).toBe(0)
+      expect($.ltv(100, 0, 2)).toBe(0)
+      expect($.ltv(100, 12, 0)).toBe(0)
+    })
+  })
+
+  describe('$.cac()', () => {
+    it('should calculate customer acquisition cost', () => {
+      expect($.cac(10000, 100)).toBe(100)
+    })
+
+    it('should handle zero customers', () => {
+      expect($.cac(10000, 0)).toBe(0)
+    })
+
+    it('should handle zero spend', () => {
+      expect($.cac(0, 100)).toBe(0)
+    })
+  })
+
+  describe('$.burnRate()', () => {
+    it('should calculate monthly burn rate', () => {
+      expect($.burnRate(100000, 70000, 3)).toBe(10000)
+    })
+
+    it('should handle zero months', () => {
+      expect($.burnRate(100000, 70000, 0)).toBe(0)
+    })
+
+    it('should handle positive cash flow', () => {
+      // If ending > starting, burn is negative (accumulating cash)
+      expect($.burnRate(100000, 130000, 3)).toBe(-10000)
+    })
+  })
+
+  describe('$.runway()', () => {
+    it('should calculate runway in months', () => {
+      expect($.runway(100000, 10000)).toBe(10)
+    })
+
+    it('should handle zero burn rate', () => {
+      expect($.runway(100000, 0)).toBe(Infinity)
+    })
+
+    it('should handle negative burn rate (profitable)', () => {
+      expect($.runway(100000, -10000)).toBe(Infinity)
+    })
+
+    it('should handle large runway', () => {
+      expect($.runway(1000000, 1000)).toBe(1000)
+    })
+  })
+
+  describe('Context Management', () => {
+    it('should update context', () => {
+      updateContext({ business: { name: 'Updated Corp' } })
+      const ctx = getContext()
+      expect(ctx.business?.name).toBe('Updated Corp')
+    })
+
+    it('should merge context updates', () => {
+      updateContext({ business: { name: 'Test Corp' } })
+      updateContext({ financials: { revenue: 100000 } })
+
+      const ctx = getContext()
+      expect(ctx.business?.name).toBe('Test Corp')
+      expect(ctx.financials?.revenue).toBe(100000)
+    })
+
+    it('should reset context', () => {
+      updateContext({ business: { name: 'Test Corp' } })
+      resetContext()
+
+      const ctx = getContext()
+      expect(ctx).toEqual({})
+    })
+
+    it('should get current context', () => {
+      updateContext({ customField: 'custom value' })
+      const ctx = getContext()
+      expect(ctx.customField).toBe('custom value')
+    })
+  })
+
+  describe('Default $ instance', () => {
+    it('should have all operations available', () => {
+      expect(typeof $.format).toBe('function')
+      expect(typeof $.percent).toBe('function')
+      expect(typeof $.growth).toBe('function')
+      expect(typeof $.margin).toBe('function')
+      expect(typeof $.roi).toBe('function')
+      expect(typeof $.ltv).toBe('function')
+      expect(typeof $.cac).toBe('function')
+      expect(typeof $.burnRate).toBe('function')
+      expect(typeof $.runway).toBe('function')
+      expect(typeof $.log).toBe('function')
+    })
+
+    it('should have context object', () => {
+      expect($.context).toBeDefined()
+      expect(typeof $.context).toBe('object')
+    })
+  })
+})