business-as-code 2.1.1 → 2.3.0

package/src/service.js

@@ -1,139 +0,0 @@
-/**
- * Service definition and management
- */
-/**
- * Define a service with pricing, SLA, and delivery information
- *
- * @example
- * ```ts
- * const service = Service({
- *   name: 'Widget Consulting',
- *   description: 'Expert widget implementation and optimization',
- *   category: 'Consulting',
- *   targetSegment: 'Enterprise',
- *   valueProposition: 'Get expert help implementing widgets in 2 weeks',
- *   pricingModel: 'fixed',
- *   price: 5000,
- *   currency: 'USD',
- *   deliveryTime: '2 weeks',
- *   sla: {
- *     uptime: 99.9,
- *     responseTime: '< 24 hours',
- *     supportHours: 'Business hours (9-5 EST)',
- *     penalties: '10% refund per day of delay',
- *   },
- * })
- * ```
- */
-export function Service(definition) {
-    if (!definition.name) {
-        throw new Error('Service name is required');
-    }
-    return {
-        ...definition,
-        pricingModel: definition.pricingModel || 'hourly',
-        currency: definition.currency || 'USD',
-        metadata: definition.metadata || {},
-    };
-}
-/**
- * Calculate service price based on hours (for hourly pricing)
- */
-export function calculateHourlyPrice(service, hours) {
-    if (service.pricingModel !== 'hourly' || !service.price) {
-        throw new Error('Service must use hourly pricing model');
-    }
-    return service.price * hours;
-}
-/**
- * Calculate monthly retainer equivalent
- */
-export function calculateMonthlyRetainer(service, hoursPerMonth) {
-    if (service.pricingModel !== 'hourly' || !service.price) {
-        throw new Error('Service must use hourly pricing model');
-    }
-    return service.price * hoursPerMonth;
-}
-/**
- * Check if service meets SLA uptime requirement
- */
-export function checkSLAUptime(service, actualUptime) {
-    if (!service.sla?.uptime)
-        return true;
-    return actualUptime >= service.sla.uptime;
-}
-/**
- * Parse delivery time to days
- */
-export function parseDeliveryTimeToDays(deliveryTime) {
-    if (!deliveryTime)
-        return 0;
-    const lower = deliveryTime.toLowerCase();
-    // Parse patterns like "2 weeks", "3 days", "1 month"
-    const match = lower.match(/(\d+)\s*(day|days|week|weeks|month|months|hour|hours)/);
-    if (!match)
-        return 0;
-    const value = parseInt(match[1] || '0', 10);
-    const unit = match[2];
-    switch (unit) {
-        case 'hour':
-        case 'hours':
-            return value / 24;
-        case 'day':
-        case 'days':
-            return value;
-        case 'week':
-        case 'weeks':
-            return value * 7;
-        case 'month':
-        case 'months':
-            return value * 30;
-        default:
-            return 0;
-    }
-}
-/**
- * Estimate service completion date
- */
-export function estimateCompletionDate(service, startDate) {
-    const start = startDate || new Date();
-    const days = parseDeliveryTimeToDays(service.deliveryTime);
-    const completion = new Date(start);
-    completion.setDate(completion.getDate() + days);
-    return completion;
-}
-/**
- * Calculate service value (for value-based pricing)
- */
-export function calculateValueBasedPrice(service, customerValue, valueSharePercentage) {
-    if (service.pricingModel !== 'value-based') {
-        throw new Error('Service must use value-based pricing model');
-    }
-    if (valueSharePercentage < 0 || valueSharePercentage > 100) {
-        throw new Error('Value share percentage must be between 0 and 100');
-    }
-    return customerValue * (valueSharePercentage / 100);
-}
-/**
- * Validate service definition
- */
-export function validateService(service) {
-    const errors = [];
-    if (!service.name) {
-        errors.push('Service name is required');
-    }
-    if (service.price && service.price < 0) {
-        errors.push('Service price cannot be negative');
-    }
-    if (service.sla?.uptime && (service.sla.uptime < 0 || service.sla.uptime > 100)) {
-        errors.push('SLA uptime must be between 0 and 100');
-    }
-    if (service.pricingModel &&
-        !['hourly', 'fixed', 'retainer', 'value-based'].includes(service.pricingModel)) {
-        errors.push('Invalid pricing model');
-    }
-    return {
-        valid: errors.length === 0,
-        errors,
-    };
-}

package/src/types.js

@@ -1,4 +0,0 @@
-/**
- * Core types for business-as-code primitives
- */
-export {};

package/src/vision.js

@@ -1,67 +0,0 @@
-/**
- * Vision statement definition
- */
-/**
- * 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) {
-    // 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, indicator, currentMetrics) {
-    // 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, currentMetrics) {
-    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) {
-    const errors = [];
-    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.js

@@ -1,246 +0,0 @@
-/**
- * Workflow definition (automation sequences)
- */
-/**
- * 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) {
-    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) {
-    return [...(workflow.actions || [])].sort((a, b) => a.order - b.order);
-}
-/**
- * Get actions by type
- */
-export function getActionsByType(workflow, type) {
-    return workflow.actions?.filter(action => action.type === type) || [];
-}
-/**
- * Get conditional actions
- */
-export function getConditionalActions(workflow) {
-    return workflow.actions?.filter(action => action.condition) || [];
-}
-/**
- * Add action to workflow
- */
-export function addAction(workflow, action) {
-    return {
-        ...workflow,
-        actions: [...(workflow.actions || []), action],
-    };
-}
-/**
- * Remove action from workflow
- */
-export function removeAction(workflow, order) {
-    return {
-        ...workflow,
-        actions: workflow.actions?.filter(a => a.order !== order),
-    };
-}
-/**
- * Update action in workflow
- */
-export function updateAction(workflow, order, updates) {
-    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) {
-    return trigger.type === 'event';
-}
-/**
- * Check if trigger is schedule-based
- */
-export function isScheduleTrigger(trigger) {
-    return trigger.type === 'schedule';
-}
-/**
- * Check if trigger is webhook-based
- */
-export function isWebhookTrigger(trigger) {
-    return trigger.type === 'webhook';
-}
-/**
- * Parse wait duration to milliseconds
- */
-export function parseWaitDuration(duration) {
-    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, context) {
-    // 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, context) {
-    return template.replace(/\{\{([^}]+)\}\}/g, (_, path) => {
-        const value = getNestedValue(context, path.trim());
-        return String(value ?? '');
-    });
-}
-/**
- * Get nested value from object by path
- */
-function getNestedValue(obj, path) {
-    return path.split('.').reduce((acc, part) => acc?.[part], obj);
-}
-/**
- * Validate workflow definition
- */
-export function validateWorkflow(workflow) {
-    const errors = [];
-    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();
-        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,
-    };
-}