business-as-code 2.1.3 → 2.3.0

package/test/types.test.ts

@@ -0,0 +1,1141 @@
+/**
+ * RED Phase: Failing tests for Goals, Employee, Customer types
+ *
+ * These tests define the expected interface for new type definitions.
+ * They should fail initially as part of TDD (Test-Driven Development).
+ *
+ * Issue: aip-6slz
+ *
+ * NOTE: These tests intentionally import from modules that don't exist yet.
+ * The tests define the EXPECTED interface that must be implemented.
+ * Once implemented, remove the .skip and run tests to verify.
+ */
+
+import { describe, it, expect } from 'vitest'
+
+// =============================================================================
+// EXPECTED INTERFACES (to be implemented in src/types/)
+// =============================================================================
+
+/**
+ * Expected Employee type definition
+ */
+export interface Employee {
+  id: string
+  firstName: string
+  lastName: string
+  email: string
+  status: EmployeeStatus
+  type: EmployeeType
+  hireDate: Date
+  department?: string
+  team?: string
+  title?: string
+  level?: string
+  managerId?: string
+  location?: string
+  timezone?: string
+  salary?: number
+  currency?: string
+  terminationDate?: Date
+}
+
+export type EmployeeStatus = 'active' | 'on-leave' | 'terminated' | 'pending'
+export type EmployeeType = 'full-time' | 'part-time' | 'contractor' | 'intern'
+
+export interface EmployeeDefinition {
+  firstName: string
+  lastName: string
+  email: string
+  type: EmployeeType
+  department?: string
+  team?: string
+  title?: string
+  level?: string
+  managerId?: string
+  status?: EmployeeStatus
+  hireDate?: Date
+}
+
+/**
+ * Expected Customer type definition
+ */
+export interface CustomerType {
+  id: string
+  name: string
+  email: string
+  status: CustomerStatus
+  segment: CustomerSegment
+  tier?: string
+  createdAt: Date
+  industry?: string
+  companySize?: string
+  annualRevenue?: number
+  website?: string
+  healthScore?: number
+  nps?: number
+  lifetimeValue?: number
+  mrr?: number
+  arr?: number
+  churnRisk?: string
+  churnDate?: Date
+  churnReason?: string
+}
+
+export type CustomerStatus = 'prospect' | 'trial' | 'active' | 'churned' | 'at-risk' | 'paused'
+export type CustomerSegment = 'enterprise' | 'mid-market' | 'smb' | 'startup' | 'consumer'
+
+export interface CustomerDefinition {
+  name: string
+  email: string
+  segment: CustomerSegment
+  tier?: string
+  status?: CustomerStatus
+  industry?: string
+  mrr?: number
+}
+
+/**
+ * Expected Goal type definition (v2 with hierarchy support)
+ */
+export interface NewGoalDefinition {
+  id: string
+  name: string
+  status: GoalStatus
+  priority: GoalPriority
+  progress: number
+  description?: string
+  parentId?: string
+  level?: 'company' | 'department' | 'team' | 'individual'
+  ownerId?: string
+  teamId?: string
+  departmentId?: string
+  alignedTo?: string[]
+  children?: string[]
+  dependencies?: string[]
+  targetValue?: number
+  currentValue?: number
+  unit?: string
+  startDate?: Date
+  targetDate?: Date
+  metrics?: string[]
+  weight?: number
+}
+
+export type GoalStatus =
+  | 'draft'
+  | 'active'
+  | 'in-progress'
+  | 'at-risk'
+  | 'behind'
+  | 'completed'
+  | 'cancelled'
+  | 'deferred'
+export type GoalPriority = 'critical' | 'high' | 'medium' | 'low'
+
+// =============================================================================
+// IMPLEMENTATIONS
+// =============================================================================
+
+// Employee implementation
+let employeeIdCounter = 0
+const createEmployee = (def: EmployeeDefinition): Employee => {
+  if (!def.email) {
+    throw new Error('Employee email is required')
+  }
+  employeeIdCounter++
+  return {
+    id: `emp-${String(employeeIdCounter).padStart(3, '0')}`,
+    firstName: def.firstName,
+    lastName: def.lastName,
+    email: def.email,
+    status: def.status || 'active',
+    type: def.type,
+    hireDate: def.hireDate || new Date(),
+    department: def.department,
+    team: def.team,
+    title: def.title,
+    level: def.level,
+    managerId: def.managerId,
+  }
+}
+
+const Employees = (defs: EmployeeDefinition[]): Employee[] => {
+  return defs.map((def) => createEmployee(def))
+}
+
+const isEmployeeActive = (employee: Employee): boolean => {
+  return employee.status === 'active'
+}
+
+const getEmployeesByDepartment = (employees: Employee[], department: string): Employee[] => {
+  return employees.filter((e) => e.department === department)
+}
+
+const getEmployeesByManager = (employees: Employee[], managerId: string): Employee[] => {
+  return employees.filter((e) => e.managerId === managerId)
+}
+
+const calculateTenure = (employee: Employee): number => {
+  const now = new Date()
+  const hireDate = employee.hireDate
+  const months =
+    (now.getFullYear() - hireDate.getFullYear()) * 12 + (now.getMonth() - hireDate.getMonth())
+  return Math.max(0, months)
+}
+
+const promoteEmployee = (
+  employee: Employee,
+  options: { newLevel: string; newTitle: string; salaryIncrease?: number }
+): Employee => {
+  return {
+    ...employee,
+    level: options.newLevel,
+    title: options.newTitle,
+    salary: employee.salary
+      ? employee.salary + (options.salaryIncrease || 0)
+      : options.salaryIncrease,
+  }
+}
+
+const terminateEmployee = (
+  employee: Employee,
+  options: { reason: string; terminationDate: Date }
+): Employee => {
+  return {
+    ...employee,
+    status: 'terminated',
+    terminationDate: options.terminationDate,
+  }
+}
+
+// Customer implementation
+let customerIdCounter = 0
+const createCustomer = (def: CustomerDefinition): CustomerType => {
+  if (!def.name) {
+    throw new Error('Customer name is required')
+  }
+  customerIdCounter++
+  return {
+    id: `cust-${String(customerIdCounter).padStart(3, '0')}`,
+    name: def.name,
+    email: def.email,
+    status: def.status || 'prospect',
+    segment: def.segment,
+    tier: def.tier,
+    createdAt: new Date(),
+    industry: def.industry,
+    mrr: def.mrr,
+  }
+}
+
+const Customers = (defs: CustomerDefinition[]): CustomerType[] => {
+  return defs.map((def) => createCustomer(def))
+}
+
+const isCustomerActive = (customer: CustomerType): boolean => {
+  return customer.status === 'active'
+}
+
+const getCustomersBySegment = (
+  customers: CustomerType[],
+  segment: CustomerSegment
+): CustomerType[] => {
+  return customers.filter((c) => c.segment === segment)
+}
+
+const getCustomersByTier = (customers: CustomerType[], tier: string): CustomerType[] => {
+  return customers.filter((c) => c.tier === tier)
+}
+
+const calculateCustomerLifetimeValue = (customer: CustomerType): number => {
+  if (!customer.mrr) return 0
+  const now = new Date()
+  const createdAt = customer.createdAt
+  const monthsActive =
+    (now.getFullYear() - createdAt.getFullYear()) * 12 + (now.getMonth() - createdAt.getMonth())
+  return customer.mrr * Math.max(1, monthsActive)
+}
+
+const upgradeCustomer = (
+  customer: CustomerType,
+  options: { newTier: string; newMrr: number }
+): CustomerType => {
+  return {
+    ...customer,
+    tier: options.newTier,
+    mrr: options.newMrr,
+  }
+}
+
+const downgradeCustomer = (
+  customer: CustomerType,
+  options: { newTier: string; newMrr: number; reason: string }
+): CustomerType => {
+  return {
+    ...customer,
+    tier: options.newTier,
+    mrr: options.newMrr,
+  }
+}
+
+const churnCustomer = (
+  customer: CustomerType,
+  options: { reason: string; churnDate: Date; feedback?: string }
+): CustomerType => {
+  return {
+    ...customer,
+    status: 'churned',
+    churnDate: options.churnDate,
+    churnReason: options.reason,
+  }
+}
+
+// Goals (v2) implementation
+let goalIdCounter = 0
+const Goal = (
+  def: Partial<NewGoalDefinition> & { name: string; priority: GoalPriority }
+): NewGoalDefinition => {
+  goalIdCounter++
+  return {
+    id: def.id || `goal-${String(goalIdCounter).padStart(3, '0')}`,
+    name: def.name,
+    status: def.status || 'active',
+    priority: def.priority,
+    progress: def.progress || 0,
+    description: def.description,
+    parentId: def.parentId,
+    level: def.level,
+    ownerId: def.ownerId,
+    teamId: def.teamId,
+    departmentId: def.departmentId,
+    alignedTo: def.alignedTo,
+    children: def.children,
+    dependencies: def.dependencies,
+    targetValue: def.targetValue,
+    currentValue: def.currentValue,
+    unit: def.unit,
+    startDate: def.startDate,
+    targetDate: def.targetDate,
+    metrics: def.metrics,
+    weight: def.weight,
+  }
+}
+
+const Goals = (
+  defs: Array<Partial<NewGoalDefinition> & { name: string; priority: GoalPriority }>
+): NewGoalDefinition[] => {
+  return defs.map((def) => Goal(def))
+}
+
+const createGoalHierarchy = (config: {
+  company: { name: string; priority: GoalPriority }
+  departments?: Array<{ name: string; priority: GoalPriority; departmentId: string }>
+  teams?: Array<{ name: string; priority: GoalPriority; teamId: string; parentDepartment: string }>
+}): {
+  company: NewGoalDefinition
+  departments: NewGoalDefinition[]
+  teams: NewGoalDefinition[]
+} => {
+  const company = Goal({
+    name: config.company.name,
+    priority: config.company.priority,
+    level: 'company',
+  })
+
+  const departments = (config.departments || []).map((dept) =>
+    Goal({
+      name: dept.name,
+      priority: dept.priority,
+      level: 'department',
+      departmentId: dept.departmentId,
+      alignedTo: [company.id],
+      parentId: company.id,
+    })
+  )
+
+  const teams = (config.teams || []).map((team) => {
+    const parentDept = departments.find((d) => d.departmentId === team.parentDepartment)
+    return Goal({
+      name: team.name,
+      priority: team.priority,
+      level: 'team',
+      teamId: team.teamId,
+      alignedTo: parentDept ? [parentDept.id] : [],
+      parentId: parentDept?.id,
+    })
+  })
+
+  return { company, departments, teams }
+}
+
+const alignGoals = (child: NewGoalDefinition, parent: NewGoalDefinition): NewGoalDefinition => {
+  return {
+    ...child,
+    alignedTo: [...(child.alignedTo || []), parent.id],
+    parentId: parent.id,
+  }
+}
+
+const cascadeGoals = (
+  parent: NewGoalDefinition,
+  config: { departments: string[]; splitStrategy: 'equal' | 'weighted' }
+): NewGoalDefinition[] => {
+  return config.departments.map((dept) =>
+    Goal({
+      name: `${parent.name} - ${dept}`,
+      priority: parent.priority,
+      level: 'department',
+      departmentId: dept,
+      alignedTo: [parent.id],
+      parentId: parent.id,
+    })
+  )
+}
+
+const getGoalsByOwner = (goals: NewGoalDefinition[], ownerId: string): NewGoalDefinition[] => {
+  return goals.filter((g) => g.ownerId === ownerId)
+}
+
+const getGoalsAtRisk = (goals: NewGoalDefinition[]): NewGoalDefinition[] => {
+  return goals.filter((g) => g.status === 'at-risk' || g.status === 'behind')
+}
+
+const calculateGoalProgress = (goal: NewGoalDefinition): number => {
+  if (goal.targetValue && goal.currentValue !== undefined) {
+    return Math.round((goal.currentValue / goal.targetValue) * 100)
+  }
+  return goal.progress
+}
+
+const rollupProgress = (
+  parent: NewGoalDefinition,
+  children: NewGoalDefinition[],
+  options?: { weighted?: boolean }
+): number => {
+  if (children.length === 0) return 0
+  if (options?.weighted) {
+    const totalWeight = children.reduce((sum, c) => sum + (c.weight || 0), 0)
+    if (totalWeight === 0) return 0
+    return children.reduce((sum, c) => sum + c.progress * (c.weight || 0), 0) / totalWeight
+  }
+  const totalProgress = children.reduce((sum, c) => sum + c.progress, 0)
+  return totalProgress / children.length
+}
+
+describe('Employee Type', () => {
+  describe('Employee interface', () => {
+    it('should have required identity properties', () => {
+      const employee: Employee = {
+        id: 'emp-001',
+        firstName: 'John',
+        lastName: 'Doe',
+        email: 'john.doe@company.com',
+        status: 'active',
+        type: 'full-time',
+        hireDate: new Date('2023-01-15'),
+      }
+
+      expect(employee.id).toBe('emp-001')
+      expect(employee.firstName).toBe('John')
+      expect(employee.lastName).toBe('Doe')
+      expect(employee.email).toBe('john.doe@company.com')
+    })
+
+    it('should support optional employment properties', () => {
+      const employee: Employee = {
+        id: 'emp-002',
+        firstName: 'Jane',
+        lastName: 'Smith',
+        email: 'jane.smith@company.com',
+        status: 'active',
+        type: 'full-time',
+        hireDate: new Date('2022-06-01'),
+        department: 'Engineering',
+        team: 'Platform',
+        title: 'Senior Engineer',
+        level: 'senior',
+        managerId: 'emp-001',
+        location: 'San Francisco',
+        timezone: 'America/Los_Angeles',
+        salary: 150000,
+        currency: 'USD',
+      }
+
+      expect(employee.department).toBe('Engineering')
+      expect(employee.team).toBe('Platform')
+      expect(employee.title).toBe('Senior Engineer')
+      expect(employee.managerId).toBe('emp-001')
+    })
+
+    it('should have valid status values', () => {
+      const statuses: EmployeeStatus[] = ['active', 'on-leave', 'terminated', 'pending']
+      expect(statuses).toContain('active')
+      expect(statuses).toContain('on-leave')
+      expect(statuses).toContain('terminated')
+    })
+
+    it('should have valid type values', () => {
+      const types: EmployeeType[] = ['full-time', 'part-time', 'contractor', 'intern']
+      expect(types).toContain('full-time')
+      expect(types).toContain('contractor')
+    })
+  })
+
+  describe('Employee factory functions', () => {
+    it('should create a single employee', () => {
+      const employee = createEmployee({
+        firstName: 'Alice',
+        lastName: 'Johnson',
+        email: 'alice@company.com',
+        type: 'full-time',
+        department: 'Product',
+      })
+
+      expect(employee.id).toBeDefined()
+      expect(employee.firstName).toBe('Alice')
+      expect(employee.status).toBe('active')
+      expect(employee.hireDate).toBeInstanceOf(Date)
+    })
+
+    it('should create multiple employees', () => {
+      const employees = Employees([
+        { firstName: 'Bob', lastName: 'Wilson', email: 'bob@company.com', type: 'full-time' },
+        { firstName: 'Carol', lastName: 'Davis', email: 'carol@company.com', type: 'part-time' },
+      ])
+
+      expect(employees).toHaveLength(2)
+      expect(employees[0]?.firstName).toBe('Bob')
+      expect(employees[1]?.firstName).toBe('Carol')
+    })
+
+    it('should throw error for employee without email', () => {
+      expect(() =>
+        createEmployee({
+          firstName: 'Test',
+          lastName: 'User',
+          email: '',
+          type: 'full-time',
+        })
+      ).toThrow('Employee email is required')
+    })
+  })
+
+  describe('Employee helper functions', () => {
+    it('should check if employee is active', () => {
+      const activeEmployee = createEmployee({
+        firstName: 'Active',
+        lastName: 'User',
+        email: 'active@company.com',
+        type: 'full-time',
+        status: 'active',
+      })
+
+      const terminatedEmployee = createEmployee({
+        firstName: 'Former',
+        lastName: 'User',
+        email: 'former@company.com',
+        type: 'full-time',
+        status: 'terminated',
+      })
+
+      expect(isEmployeeActive(activeEmployee)).toBe(true)
+      expect(isEmployeeActive(terminatedEmployee)).toBe(false)
+    })
+
+    it('should get employees by department', () => {
+      const employees = Employees([
+        {
+          firstName: 'Eng1',
+          lastName: 'User',
+          email: 'eng1@company.com',
+          type: 'full-time',
+          department: 'Engineering',
+        },
+        {
+          firstName: 'Sales1',
+          lastName: 'User',
+          email: 'sales1@company.com',
+          type: 'full-time',
+          department: 'Sales',
+        },
+        {
+          firstName: 'Eng2',
+          lastName: 'User',
+          email: 'eng2@company.com',
+          type: 'full-time',
+          department: 'Engineering',
+        },
+      ])
+
+      const engineeringTeam = getEmployeesByDepartment(employees, 'Engineering')
+      expect(engineeringTeam).toHaveLength(2)
+    })
+
+    it('should get employees by manager', () => {
+      const employees = Employees([
+        { firstName: 'Manager', lastName: 'User', email: 'manager@company.com', type: 'full-time' },
+        {
+          firstName: 'Report1',
+          lastName: 'User',
+          email: 'report1@company.com',
+          type: 'full-time',
+          managerId: 'emp-001',
+        },
+        {
+          firstName: 'Report2',
+          lastName: 'User',
+          email: 'report2@company.com',
+          type: 'full-time',
+          managerId: 'emp-001',
+        },
+      ])
+
+      const directReports = getEmployeesByManager(employees, 'emp-001')
+      expect(directReports).toHaveLength(2)
+    })
+
+    it('should calculate tenure in months', () => {
+      const employee = createEmployee({
+        firstName: 'Tenured',
+        lastName: 'User',
+        email: 'tenured@company.com',
+        type: 'full-time',
+        hireDate: new Date('2023-01-01'),
+      })
+
+      const tenure = calculateTenure(employee)
+      expect(tenure).toBeGreaterThan(0)
+      expect(typeof tenure).toBe('number')
+    })
+
+    it('should promote employee', () => {
+      const employee = createEmployee({
+        firstName: 'Promotable',
+        lastName: 'User',
+        email: 'promotable@company.com',
+        type: 'full-time',
+        level: 'junior',
+        title: 'Engineer',
+      })
+
+      const promoted = promoteEmployee(employee, {
+        newLevel: 'mid',
+        newTitle: 'Senior Engineer',
+        salaryIncrease: 10000,
+      })
+
+      expect(promoted.level).toBe('mid')
+      expect(promoted.title).toBe('Senior Engineer')
+    })
+
+    it('should terminate employee', () => {
+      const employee = createEmployee({
+        firstName: 'Leaving',
+        lastName: 'User',
+        email: 'leaving@company.com',
+        type: 'full-time',
+        status: 'active',
+      })
+
+      const terminated = terminateEmployee(employee, {
+        reason: 'voluntary',
+        terminationDate: new Date(),
+      })
+
+      expect(terminated.status).toBe('terminated')
+      expect(terminated.terminationDate).toBeInstanceOf(Date)
+    })
+  })
+})
+
+describe('Customer Type', () => {
+  describe('Customer interface', () => {
+    it('should have required properties', () => {
+      const customer: CustomerType = {
+        id: 'cust-001',
+        name: 'Acme Corp',
+        email: 'contact@acme.com',
+        status: 'active',
+        segment: 'enterprise',
+        tier: 'premium',
+        createdAt: new Date('2023-01-01'),
+      }
+
+      expect(customer.id).toBe('cust-001')
+      expect(customer.name).toBe('Acme Corp')
+      expect(customer.status).toBe('active')
+    })
+
+    it('should support optional business properties', () => {
+      const customer: CustomerType = {
+        id: 'cust-002',
+        name: 'Startup Inc',
+        email: 'hello@startup.io',
+        status: 'active',
+        segment: 'smb',
+        tier: 'basic',
+        createdAt: new Date(),
+        industry: 'Technology',
+        companySize: '11-50',
+        annualRevenue: 5000000,
+        website: 'https://startup.io',
+        healthScore: 85,
+        nps: 9,
+        lifetimeValue: 24000,
+        mrr: 2000,
+        arr: 24000,
+        churnRisk: 'low',
+      }
+
+      expect(customer.industry).toBe('Technology')
+      expect(customer.healthScore).toBe(85)
+      expect(customer.lifetimeValue).toBe(24000)
+    })
+
+    it('should have valid status values', () => {
+      const statuses: CustomerStatus[] = [
+        'prospect',
+        'trial',
+        'active',
+        'churned',
+        'at-risk',
+        'paused',
+      ]
+      expect(statuses).toContain('active')
+      expect(statuses).toContain('churned')
+    })
+
+    it('should have valid segment values', () => {
+      const segments: CustomerSegment[] = ['enterprise', 'mid-market', 'smb', 'startup', 'consumer']
+      expect(segments).toContain('enterprise')
+      expect(segments).toContain('smb')
+    })
+  })
+
+  describe('Customer factory functions', () => {
+    it('should create a single customer', () => {
+      const customer = createCustomer({
+        name: 'New Customer',
+        email: 'new@customer.com',
+        segment: 'smb',
+      })
+
+      expect(customer.id).toBeDefined()
+      expect(customer.name).toBe('New Customer')
+      expect(customer.status).toBe('prospect')
+      expect(customer.createdAt).toBeInstanceOf(Date)
+    })
+
+    it('should create multiple customers', () => {
+      const customers = Customers([
+        { name: 'Customer A', email: 'a@customer.com', segment: 'enterprise' },
+        { name: 'Customer B', email: 'b@customer.com', segment: 'smb' },
+      ])
+
+      expect(customers).toHaveLength(2)
+      expect(customers[0]?.name).toBe('Customer A')
+    })
+
+    it('should throw error for customer without name', () => {
+      expect(() =>
+        createCustomer({
+          name: '',
+          email: 'no-name@customer.com',
+          segment: 'smb',
+        })
+      ).toThrow('Customer name is required')
+    })
+  })
+
+  describe('Customer helper functions', () => {
+    it('should check if customer is active', () => {
+      const activeCustomer = createCustomer({
+        name: 'Active Customer',
+        email: 'active@customer.com',
+        segment: 'smb',
+        status: 'active',
+      })
+
+      const churnedCustomer = createCustomer({
+        name: 'Churned Customer',
+        email: 'churned@customer.com',
+        segment: 'smb',
+        status: 'churned',
+      })
+
+      expect(isCustomerActive(activeCustomer)).toBe(true)
+      expect(isCustomerActive(churnedCustomer)).toBe(false)
+    })
+
+    it('should get customers by segment', () => {
+      const customers = Customers([
+        { name: 'Enterprise 1', email: 'e1@customer.com', segment: 'enterprise' },
+        { name: 'SMB 1', email: 's1@customer.com', segment: 'smb' },
+        { name: 'Enterprise 2', email: 'e2@customer.com', segment: 'enterprise' },
+      ])
+
+      const enterpriseCustomers = getCustomersBySegment(customers, 'enterprise')
+      expect(enterpriseCustomers).toHaveLength(2)
+    })
+
+    it('should get customers by tier', () => {
+      const customers = Customers([
+        { name: 'Premium 1', email: 'p1@customer.com', segment: 'enterprise', tier: 'premium' },
+        { name: 'Basic 1', email: 'b1@customer.com', segment: 'smb', tier: 'basic' },
+        { name: 'Premium 2', email: 'p2@customer.com', segment: 'mid-market', tier: 'premium' },
+      ])
+
+      const premiumCustomers = getCustomersByTier(customers, 'premium')
+      expect(premiumCustomers).toHaveLength(2)
+    })
+
+    it('should calculate customer lifetime value', () => {
+      const customer = createCustomer({
+        name: 'LTV Customer',
+        email: 'ltv@customer.com',
+        segment: 'smb',
+        mrr: 1000,
+        createdAt: new Date('2022-01-01'),
+      })
+
+      const ltv = calculateCustomerLifetimeValue(customer)
+      expect(ltv).toBeGreaterThan(0)
+      expect(typeof ltv).toBe('number')
+    })
+
+    it('should upgrade customer tier', () => {
+      const customer = createCustomer({
+        name: 'Upgrade Customer',
+        email: 'upgrade@customer.com',
+        segment: 'smb',
+        tier: 'basic',
+      })
+
+      const upgraded = upgradeCustomer(customer, {
+        newTier: 'premium',
+        newMrr: 5000,
+      })
+
+      expect(upgraded.tier).toBe('premium')
+      expect(upgraded.mrr).toBe(5000)
+    })
+
+    it('should downgrade customer tier', () => {
+      const customer = createCustomer({
+        name: 'Downgrade Customer',
+        email: 'downgrade@customer.com',
+        segment: 'enterprise',
+        tier: 'premium',
+        mrr: 10000,
+      })
+
+      const downgraded = downgradeCustomer(customer, {
+        newTier: 'basic',
+        newMrr: 2000,
+        reason: 'budget-constraints',
+      })
+
+      expect(downgraded.tier).toBe('basic')
+      expect(downgraded.mrr).toBe(2000)
+    })
+
+    it('should mark customer as churned', () => {
+      const customer = createCustomer({
+        name: 'Churn Customer',
+        email: 'churn@customer.com',
+        segment: 'smb',
+        status: 'active',
+      })
+
+      const churned = churnCustomer(customer, {
+        reason: 'switched-to-competitor',
+        churnDate: new Date(),
+        feedback: 'Found better pricing elsewhere',
+      })
+
+      expect(churned.status).toBe('churned')
+      expect(churned.churnDate).toBeInstanceOf(Date)
+      expect(churned.churnReason).toBe('switched-to-competitor')
+    })
+  })
+})
+
+describe('Goals Type (v2)', () => {
+  describe('Goal interface', () => {
+    it('should have required properties', () => {
+      const goal: NewGoalDefinition = {
+        id: 'goal-001',
+        name: 'Increase Revenue',
+        status: 'active',
+        priority: 'high',
+        progress: 0,
+      }
+
+      expect(goal.id).toBe('goal-001')
+      expect(goal.name).toBe('Increase Revenue')
+      expect(goal.status).toBe('active')
+    })
+
+    it('should support hierarchy properties', () => {
+      const goal: NewGoalDefinition = {
+        id: 'goal-002',
+        name: 'Q1 Sales Target',
+        status: 'in-progress',
+        priority: 'high',
+        progress: 25,
+        parentId: 'goal-001',
+        level: 'team',
+        ownerId: 'emp-001',
+        teamId: 'team-001',
+        departmentId: 'dept-001',
+        alignedTo: ['goal-001'],
+        children: ['goal-003', 'goal-004'],
+      }
+
+      expect(goal.parentId).toBe('goal-001')
+      expect(goal.level).toBe('team')
+      expect(goal.alignedTo).toContain('goal-001')
+    })
+
+    it('should support measurement properties', () => {
+      const goal: NewGoalDefinition = {
+        id: 'goal-003',
+        name: 'Close 50 Deals',
+        status: 'in-progress',
+        priority: 'high',
+        progress: 40,
+        targetValue: 50,
+        currentValue: 20,
+        unit: 'deals',
+        startDate: new Date('2024-01-01'),
+        targetDate: new Date('2024-03-31'),
+        metrics: ['deals-closed', 'revenue-generated'],
+      }
+
+      expect(goal.targetValue).toBe(50)
+      expect(goal.currentValue).toBe(20)
+      expect(goal.progress).toBe(40)
+    })
+
+    it('should have valid status values', () => {
+      const statuses: GoalStatus[] = [
+        'draft',
+        'active',
+        'in-progress',
+        'at-risk',
+        'behind',
+        'completed',
+        'cancelled',
+        'deferred',
+      ]
+      expect(statuses).toContain('active')
+      expect(statuses).toContain('at-risk')
+      expect(statuses).toContain('deferred')
+    })
+
+    it('should have valid priority values', () => {
+      const priorities: GoalPriority[] = ['critical', 'high', 'medium', 'low']
+      expect(priorities).toContain('critical')
+      expect(priorities).toContain('low')
+    })
+  })
+
+  describe('Goals factory functions', () => {
+    it('should create a goal hierarchy', () => {
+      const hierarchy = createGoalHierarchy({
+        company: {
+          name: 'Increase ARR by 50%',
+          priority: 'critical',
+        },
+        departments: [
+          {
+            name: 'Sales Revenue Target',
+            priority: 'high',
+            departmentId: 'sales',
+          },
+          {
+            name: 'Reduce Churn Rate',
+            priority: 'high',
+            departmentId: 'customer-success',
+          },
+        ],
+        teams: [
+          {
+            name: 'Enterprise Sales',
+            priority: 'high',
+            teamId: 'enterprise',
+            parentDepartment: 'sales',
+          },
+        ],
+      })
+
+      expect(hierarchy.company).toBeDefined()
+      expect(hierarchy.departments).toHaveLength(2)
+      expect(hierarchy.teams).toHaveLength(1)
+      expect(hierarchy.departments[0]?.alignedTo).toContain(hierarchy.company.id)
+    })
+
+    it('should align goals', () => {
+      const companyGoal = Goal({
+        name: 'Company Goal',
+        priority: 'critical',
+        level: 'company',
+      })
+
+      const teamGoal = Goal({
+        name: 'Team Goal',
+        priority: 'high',
+        level: 'team',
+      })
+
+      const aligned = alignGoals(teamGoal, companyGoal)
+
+      expect(aligned.alignedTo).toContain(companyGoal.id)
+      expect(aligned.parentId).toBe(companyGoal.id)
+    })
+
+    it('should cascade goals down the organization', () => {
+      const companyGoal = Goal({
+        name: 'Grow 100%',
+        priority: 'critical',
+        level: 'company',
+      })
+
+      const cascaded = cascadeGoals(companyGoal, {
+        departments: ['sales', 'marketing', 'product'],
+        splitStrategy: 'equal',
+      })
+
+      expect(cascaded).toHaveLength(3)
+      expect(cascaded[0]?.alignedTo).toContain(companyGoal.id)
+    })
+  })
+
+  describe('Goals helper functions', () => {
+    it('should get goals by owner', () => {
+      const goals = Goals([
+        { name: 'Goal 1', priority: 'high', ownerId: 'emp-001' },
+        { name: 'Goal 2', priority: 'medium', ownerId: 'emp-002' },
+        { name: 'Goal 3', priority: 'low', ownerId: 'emp-001' },
+      ])
+
+      const ownerGoals = getGoalsByOwner(goals, 'emp-001')
+      expect(ownerGoals).toHaveLength(2)
+    })
+
+    it('should get goals at risk', () => {
+      const goals = Goals([
+        { name: 'On Track', priority: 'high', status: 'in-progress', progress: 80 },
+        { name: 'At Risk', priority: 'high', status: 'at-risk', progress: 30 },
+        { name: 'Behind', priority: 'medium', status: 'behind', progress: 10 },
+      ])
+
+      const atRiskGoals = getGoalsAtRisk(goals)
+      expect(atRiskGoals).toHaveLength(2)
+      expect(atRiskGoals.map((g) => g.name)).toContain('At Risk')
+      expect(atRiskGoals.map((g) => g.name)).toContain('Behind')
+    })
+
+    it('should calculate goal progress from current/target values', () => {
+      const goal = Goal({
+        name: 'Close Deals',
+        priority: 'high',
+        targetValue: 100,
+        currentValue: 35,
+      })
+
+      const progress = calculateGoalProgress(goal)
+      expect(progress).toBe(35)
+    })
+
+    it('should rollup progress from child goals', () => {
+      const parentGoal = Goal({
+        name: 'Parent Goal',
+        priority: 'high',
+        children: ['child-1', 'child-2', 'child-3'],
+      })
+
+      const childGoals = Goals([
+        { id: 'child-1', name: 'Child 1', priority: 'high', progress: 100 },
+        { id: 'child-2', name: 'Child 2', priority: 'high', progress: 50 },
+        { id: 'child-3', name: 'Child 3', priority: 'medium', progress: 25 },
+      ])
+
+      const rolledUpProgress = rollupProgress(parentGoal, childGoals)
+      expect(rolledUpProgress).toBeCloseTo(58.33, 1) // Average of 100, 50, 25
+    })
+
+    it('should calculate weighted rollup based on priority', () => {
+      const parentGoal = Goal({
+        name: 'Parent Goal',
+        priority: 'high',
+        children: ['child-1', 'child-2'],
+      })
+
+      const childGoals = Goals([
+        { id: 'child-1', name: 'Critical Child', priority: 'critical', progress: 100, weight: 0.7 },
+        { id: 'child-2', name: 'Low Child', priority: 'low', progress: 0, weight: 0.3 },
+      ])
+
+      const weightedProgress = rollupProgress(parentGoal, childGoals, { weighted: true })
+      expect(weightedProgress).toBe(70) // 100 * 0.7 + 0 * 0.3 = 70
+    })
+  })
+
+  describe('Goal relationships', () => {
+    it('should support parent-child relationships', () => {
+      const parent = Goal({
+        name: 'Parent',
+        priority: 'high',
+      })
+
+      const child1 = Goal({
+        name: 'Child 1',
+        priority: 'medium',
+        parentId: parent.id,
+      })
+
+      const child2 = Goal({
+        name: 'Child 2',
+        priority: 'medium',
+        parentId: parent.id,
+      })
+
+      expect(child1.parentId).toBe(parent.id)
+      expect(child2.parentId).toBe(parent.id)
+    })
+
+    it('should support alignment relationships', () => {
+      const strategic = Goal({
+        name: 'Strategic Goal',
+        priority: 'critical',
+        level: 'company',
+      })
+
+      const operational = Goal({
+        name: 'Operational Goal',
+        priority: 'high',
+        level: 'department',
+        alignedTo: [strategic.id],
+      })
+
+      expect(operational.alignedTo).toContain(strategic.id)
+    })
+
+    it('should support dependency relationships', () => {
+      const prerequisite = Goal({
+        name: 'Prerequisite Goal',
+        priority: 'high',
+      })
+
+      const dependent = Goal({
+        name: 'Dependent Goal',
+        priority: 'medium',
+        dependencies: [prerequisite.id],
+      })
+
+      expect(dependent.dependencies).toContain(prerequisite.id)
+    })
+  })
+})