business-as-code 2.0.1 → 2.1.1

package/src/service.js

@@ -0,0 +1,139 @@
+/**
+ * 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

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

package/src/vision.js

@@ -0,0 +1,67 @@
+/**
+ * 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

@@ -0,0 +1,246 @@
+/**
+ * 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,
+    };
+}