business-as-code 2.1.3 → 2.3.0

package/src/organization.js

@@ -1,172 +0,0 @@
-/**
- * Organization Structure - Flows to FGA/RBAC
- *
- * Defines the complete organizational hierarchy:
- *
- * Organization
- *   └── Department
- *       └── Team
- *           └── Position (Role + Worker)
- *               └── Permissions (FGA/RBAC)
- *
- * This structure enables:
- * - Hierarchical permission inheritance
- * - Role-based task assignment
- * - Approval chains based on org structure
- * - Resource access control based on department/team
- *
- * @packageDocumentation
- */
-/**
- * Resolve permissions for a position in the org hierarchy
- */
-export function resolvePermissions(org, positionId) {
-    // Find the position
-    let position;
-    let team;
-    let department;
-    // Search through hierarchy
-    for (const dept of org.departments || []) {
-        for (const t of dept.teams || []) {
-            const pos = t.positions?.find(p => p.id === positionId);
-            if (pos) {
-                position = pos;
-                team = t;
-                department = dept;
-                break;
-            }
-        }
-        if (position)
-            break;
-    }
-    // Also check standalone teams
-    if (!position) {
-        for (const t of org.teams || []) {
-            const pos = t.positions?.find(p => p.id === positionId);
-            if (pos) {
-                position = pos;
-                team = t;
-                break;
-            }
-        }
-    }
-    if (!position)
-        return null;
-    // Find the role
-    const role = org.roles?.find(r => r.id === position.roleId);
-    // Build inheritance chain
-    const inheritanceChain = [];
-    const permissions = {};
-    const resourcePermissions = {};
-    const canApprove = [];
-    const canHandle = [];
-    // 1. Department defaults
-    if (department?.defaultPermissions) {
-        inheritanceChain.push(`department:${department.id}`);
-        mergePermissions(permissions, department.defaultPermissions);
-    }
-    // 2. Team defaults
-    if (team?.defaultPermissions) {
-        inheritanceChain.push(`team:${team.id}`);
-        mergePermissions(permissions, team.defaultPermissions);
-    }
-    // 3. Team resources (scoped permissions)
-    if (team?.resources) {
-        for (const [resourceType, resourceIds] of Object.entries(team.resources)) {
-            if (resourceIds) {
-                for (const resourceId of resourceIds) {
-                    const key = `${resourceType}:${resourceId}`;
-                    resourcePermissions[key] = resourcePermissions[key] || {};
-                    mergePermissions(resourcePermissions[key], team.defaultPermissions || {});
-                }
-            }
-        }
-    }
-    // 4. Role permissions
-    if (role?.permissions) {
-        inheritanceChain.push(`role:${role.id}`);
-        mergePermissions(permissions, role.permissions);
-    }
-    // 5. Role capabilities
-    if (role?.canApprove) {
-        canApprove.push(...role.canApprove);
-    }
-    if (role?.canHandle) {
-        canHandle.push(...role.canHandle);
-    }
-    // 6. Position-specific permissions
-    if (position.additionalPermissions) {
-        inheritanceChain.push(`position:${position.id}`);
-        mergePermissions(permissions, position.additionalPermissions);
-        // Handle resource-specific permissions
-        for (const [key, perms] of Object.entries(position.additionalPermissions)) {
-            if (key.includes(':')) {
-                resourcePermissions[key] = resourcePermissions[key] || {};
-                resourcePermissions[key] = { ...resourcePermissions[key], _direct: perms };
-            }
-        }
-    }
-    return {
-        workerId: position.workerId || '',
-        positionId: position.id,
-        permissions,
-        resourcePermissions,
-        canApprove: [...new Set(canApprove)],
-        canHandle: [...new Set(canHandle)],
-        inheritanceChain,
-    };
-}
-/**
- * Merge permissions into target
- */
-function mergePermissions(target, source) {
-    for (const [key, perms] of Object.entries(source)) {
-        if (!target[key]) {
-            target[key] = [];
-        }
-        for (const perm of perms) {
-            if (!target[key].includes(perm)) {
-                target[key].push(perm);
-            }
-        }
-    }
-}
-/**
- * Get approval chain for a request
- */
-export function getApprovalChainForRequest(org, requestType, amount) {
-    const chain = org.approvalChains?.find(c => c.type === requestType && c.active !== false);
-    if (!chain)
-        return [];
-    // Find the appropriate level based on amount
-    const levels = [...chain.levels].sort((a, b) => (a.threshold || 0) - (b.threshold || 0));
-    for (const level of levels.reverse()) {
-        if (amount === undefined || (level.threshold && amount <= level.threshold)) {
-            return level.approvers;
-        }
-    }
-    // Return highest level if amount exceeds all thresholds
-    return levels[levels.length - 1]?.approvers || [];
-}
-/**
- * Find manager for a position (follows reportsTo chain)
- */
-export function findManager(org, positionId) {
-    // Find the position
-    for (const dept of org.departments || []) {
-        for (const team of dept.teams || []) {
-            const position = team.positions?.find(p => p.id === positionId);
-            if (position?.reportsTo) {
-                // Find the manager position
-                for (const d of org.departments || []) {
-                    for (const t of d.teams || []) {
-                        const manager = t.positions?.find(p => p.id === position.reportsTo);
-                        if (manager)
-                            return manager;
-                    }
-                }
-            }
-        }
-    }
-    return null;
-}

package/src/process.js

@@ -1,240 +0,0 @@
-/**
- * Business process definition and management
- */
-/**
- * Define a business process with steps, inputs, outputs, and metrics
- *
- * @example
- * ```ts
- * const process = Process({
- *   name: 'Customer Onboarding',
- *   description: 'Process for onboarding new customers',
- *   category: 'core',
- *   owner: 'Customer Success Team',
- *   steps: [
- *     {
- *       order: 1,
- *       name: 'Welcome Email',
- *       description: 'Send personalized welcome email',
- *       responsible: 'CS Manager',
- *       duration: '5 minutes',
- *       automationLevel: 'automated',
- *     },
- *     {
- *       order: 2,
- *       name: 'Initial Setup Call',
- *       description: 'Schedule and conduct setup call',
- *       responsible: 'CS Rep',
- *       duration: '30 minutes',
- *       automationLevel: 'manual',
- *     },
- *     {
- *       order: 3,
- *       name: 'Account Configuration',
- *       description: 'Configure customer account settings',
- *       responsible: 'CS Rep',
- *       duration: '15 minutes',
- *       automationLevel: 'semi-automated',
- *     },
- *   ],
- *   inputs: ['Customer Information', 'Subscription Plan'],
- *   outputs: ['Configured Account', 'Training Materials'],
- *   metrics: [
- *     {
- *       name: 'Time to First Value',
- *       description: 'Time from signup to first successful use',
- *       target: 24,
- *       unit: 'hours',
- *     },
- *     {
- *       name: 'Onboarding Completion Rate',
- *       description: 'Percentage of customers completing onboarding',
- *       target: 90,
- *       unit: 'percent',
- *     },
- *   ],
- * })
- * ```
- */
-export function Process(definition) {
-    if (!definition.name) {
-        throw new Error('Process name is required');
-    }
-    return {
-        ...definition,
-        category: definition.category || 'support',
-        steps: definition.steps || [],
-        inputs: definition.inputs || [],
-        outputs: definition.outputs || [],
-        metrics: definition.metrics || [],
-        metadata: definition.metadata || {},
-    };
-}
-/**
- * Get process steps in order
- */
-export function getStepsInOrder(process) {
-    return [...(process.steps || [])].sort((a, b) => a.order - b.order);
-}
-/**
- * Get steps by automation level
- */
-export function getStepsByAutomationLevel(process, level) {
-    return process.steps?.filter(step => step.automationLevel === level) || [];
-}
-/**
- * Calculate total process duration in minutes
- */
-export function calculateTotalDuration(process) {
-    return (process.steps?.reduce((total, step) => {
-        return total + parseDurationToMinutes(step.duration);
-    }, 0) || 0);
-}
-/**
- * Parse duration string to minutes
- */
-function parseDurationToMinutes(duration) {
-    if (!duration)
-        return 0;
-    const lower = duration.toLowerCase();
-    const match = lower.match(/(\d+)\s*(minute|minutes|min|hour|hours|hr|day|days|week|weeks)/);
-    if (!match)
-        return 0;
-    const value = parseInt(match[1] || '0', 10);
-    const unit = match[2];
-    switch (unit) {
-        case 'minute':
-        case 'minutes':
-        case 'min':
-            return value;
-        case 'hour':
-        case 'hours':
-        case 'hr':
-            return value * 60;
-        case 'day':
-        case 'days':
-            return value * 60 * 24;
-        case 'week':
-        case 'weeks':
-            return value * 60 * 24 * 7;
-        default:
-            return 0;
-    }
-}
-/**
- * Format minutes to human-readable duration
- */
-export function formatDuration(minutes) {
-    if (minutes < 60) {
-        return `${minutes} minutes`;
-    }
-    else if (minutes < 60 * 24) {
-        const hours = Math.floor(minutes / 60);
-        const mins = minutes % 60;
-        return mins > 0 ? `${hours} hours ${mins} minutes` : `${hours} hours`;
-    }
-    else {
-        const days = Math.floor(minutes / (60 * 24));
-        const hours = Math.floor((minutes % (60 * 24)) / 60);
-        return hours > 0 ? `${days} days ${hours} hours` : `${days} days`;
-    }
-}
-/**
- * Calculate automation percentage
- */
-export function calculateAutomationPercentage(process) {
-    if (!process.steps || process.steps.length === 0)
-        return 0;
-    const automatedSteps = process.steps.filter(step => step.automationLevel === 'automated' || step.automationLevel === 'semi-automated').length;
-    return (automatedSteps / process.steps.length) * 100;
-}
-/**
- * Get metric by name
- */
-export function getMetric(process, name) {
-    return process.metrics?.find(m => m.name === name);
-}
-/**
- * Check if metric meets target
- */
-export function meetsTarget(metric) {
-    if (metric.target === undefined || metric.current === undefined)
-        return false;
-    return metric.current >= metric.target;
-}
-/**
- * Calculate metric achievement percentage
- */
-export function calculateMetricAchievement(metric) {
-    if (metric.target === undefined || metric.current === undefined)
-        return 0;
-    if (metric.target === 0)
-        return 100;
-    return (metric.current / metric.target) * 100;
-}
-/**
- * Update metric current value
- */
-export function updateMetric(process, metricName, currentValue) {
-    const metrics = process.metrics?.map(m => m.name === metricName ? { ...m, current: currentValue } : m);
-    return {
-        ...process,
-        metrics,
-    };
-}
-/**
- * Add step to process
- */
-export function addStep(process, step) {
-    return {
-        ...process,
-        steps: [...(process.steps || []), step],
-    };
-}
-/**
- * Remove step from process
- */
-export function removeStep(process, stepOrder) {
-    return {
-        ...process,
-        steps: process.steps?.filter(s => s.order !== stepOrder),
-    };
-}
-/**
- * Validate process definition
- */
-export function validateProcess(process) {
-    const errors = [];
-    if (!process.name) {
-        errors.push('Process name is required');
-    }
-    if (process.steps) {
-        const orders = new Set();
-        for (const step of process.steps) {
-            if (!step.name) {
-                errors.push(`Step at order ${step.order} must have a name`);
-            }
-            if (orders.has(step.order)) {
-                errors.push(`Duplicate step order: ${step.order}`);
-            }
-            orders.add(step.order);
-        }
-    }
-    if (process.metrics) {
-        for (const metric of process.metrics) {
-            if (!metric.name) {
-                errors.push('Metric must have a name');
-            }
-            if (metric.target !== undefined && metric.target < 0) {
-                errors.push(`Metric ${metric.name} target cannot be negative`);
-            }
-            if (metric.current !== undefined && metric.current < 0) {
-                errors.push(`Metric ${metric.name} current value cannot be negative`);
-            }
-        }
-    }
-    return {
-        valid: errors.length === 0,
-        errors,
-    };
-}

package/src/product.js

@@ -1,144 +0,0 @@
-/**
- * Product definition and management
- */
-/**
- * Define a product with pricing, features, and roadmap
- *
- * @example
- * ```ts
- * const product = Product({
- *   name: 'Widget Pro',
- *   description: 'Enterprise-grade widget management platform',
- *   category: 'SaaS',
- *   targetSegment: 'Enterprise',
- *   valueProposition: 'Reduce widget management costs by 50%',
- *   pricingModel: 'subscription',
- *   price: 99,
- *   currency: 'USD',
- *   cogs: 20,
- *   features: [
- *     'Unlimited widgets',
- *     'Advanced analytics',
- *     'API access',
- *     '24/7 support',
- *   ],
- *   roadmap: [
- *     {
- *       name: 'Mobile app',
- *       description: 'Native iOS and Android apps',
- *       targetDate: new Date('2024-09-01'),
- *       priority: 'high',
- *       status: 'in-progress',
- *     },
- *     {
- *       name: 'AI-powered insights',
- *       description: 'Automated widget optimization suggestions',
- *       targetDate: new Date('2024-12-01'),
- *       priority: 'high',
- *       status: 'planned',
- *     },
- *   ],
- * })
- * ```
- */
-export function Product(definition) {
-    if (!definition.name) {
-        throw new Error('Product name is required');
-    }
-    return {
-        ...definition,
-        pricingModel: definition.pricingModel || 'one-time',
-        currency: definition.currency || 'USD',
-        features: definition.features || [],
-        roadmap: definition.roadmap || [],
-        metadata: definition.metadata || {},
-    };
-}
-/**
- * Calculate gross margin for a product
- */
-export function calculateGrossMargin(product) {
-    if (!product.price || !product.cogs)
-        return 0;
-    return ((product.price - product.cogs) / product.price) * 100;
-}
-/**
- * Calculate gross profit for a product
- */
-export function calculateGrossProfit(product, unitsSold) {
-    if (!product.price || !product.cogs)
-        return 0;
-    return (product.price - product.cogs) * unitsSold;
-}
-/**
- * Get roadmap items by status
- */
-export function getRoadmapByStatus(product, status) {
-    return product.roadmap?.filter(item => item.status === status) || [];
-}
-/**
- * Get roadmap items by priority
- */
-export function getRoadmapByPriority(product, priority) {
-    return product.roadmap?.filter(item => item.priority === priority) || [];
-}
-/**
- * Get overdue roadmap items
- */
-export function getOverdueRoadmapItems(product) {
-    const now = new Date();
-    return (product.roadmap?.filter(item => item.targetDate &&
-        item.targetDate < now &&
-        item.status !== 'completed' &&
-        item.status !== 'cancelled') || []);
-}
-/**
- * Update roadmap item status
- */
-export function updateRoadmapItem(product, itemName, updates) {
-    const roadmap = product.roadmap?.map(item => item.name === itemName ? { ...item, ...updates } : item);
-    return {
-        ...product,
-        roadmap,
-    };
-}
-/**
- * Add feature to product
- */
-export function addFeature(product, feature) {
-    return {
-        ...product,
-        features: [...(product.features || []), feature],
-    };
-}
-/**
- * Remove feature from product
- */
-export function removeFeature(product, feature) {
-    return {
-        ...product,
-        features: product.features?.filter(f => f !== feature) || [],
-    };
-}
-/**
- * Validate product definition
- */
-export function validateProduct(product) {
-    const errors = [];
-    if (!product.name) {
-        errors.push('Product name is required');
-    }
-    if (product.price && product.price < 0) {
-        errors.push('Product price cannot be negative');
-    }
-    if (product.cogs && product.cogs < 0) {
-        errors.push('Product COGS cannot be negative');
-    }
-    if (product.price && product.cogs && product.cogs > product.price) {
-        errors.push('Product COGS cannot exceed price');
-    }
-    return {
-        valid: errors.length === 0,
-        errors,
-    };
-}