snow-flow 3.0.9 → 3.0.10

package/dist/templates/flow-template-system.js

@@ -1,625 +0,0 @@
-"use strict";
-/**
- * 🚀 Flow Template System for Faster Development
- *
- * Revolutionary template system that generates perfect ServiceNow flows from
- * predefined patterns, dramatically reducing development time and ensuring
- * consistent, high-quality implementations.
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FlowTemplateSystem = void 0;
-const logger_js_1 = require("../utils/logger.js");
-const xml_first_flow_generator_js_1 = require("../utils/xml-first-flow-generator.js");
-const servicenow_client_js_1 = require("../utils/servicenow-client.js");
-const promises_1 = __importDefault(require("fs/promises"));
-const path_1 = __importDefault(require("path"));
-class FlowTemplateSystem {
-    constructor(client) {
-        this.templates = new Map();
-        this.logger = new logger_js_1.Logger('FlowTemplateSystem');
-        this.xmlGenerator = new xml_first_flow_generator_js_1.XMLFirstFlowGenerator();
-        this.client = client || new servicenow_client_js_1.ServiceNowClient();
-        this.templatesPath = path_1.default.join(process.cwd(), 'src', 'templates', 'flows');
-        this.initializeTemplateSystem();
-    }
-    /**
-     * Initialize template system with built-in templates
-     */
-    async initializeTemplateSystem() {
-        try {
-            // Create templates directory if not exists
-            await promises_1.default.mkdir(this.templatesPath, { recursive: true });
-            // Load built-in templates
-            await this.loadBuiltInTemplates();
-            // Load custom templates from disk
-            await this.loadCustomTemplates();
-            this.logger.info('🚀 Flow Template System initialized', {
-                totalTemplates: this.templates.size,
-                categories: this.getTemplateCategories()
-            });
-        }
-        catch (error) {
-            this.logger.error('❌ Failed to initialize template system:', error);
-        }
-    }
-    /**
-     * Get all available templates
-     */
-    getTemplates() {
-        return Array.from(this.templates.values())
-            .sort((a, b) => b.metadata.usageCount - a.metadata.usageCount);
-    }
-    /**
-     * Get templates by category
-     */
-    getTemplatesByCategory(category) {
-        return this.getTemplates().filter(t => t.category === category);
-    }
-    /**
-     * Search templates by keywords
-     */
-    searchTemplates(query) {
-        const lowerQuery = query.toLowerCase();
-        return this.getTemplates().filter(template => template.name.toLowerCase().includes(lowerQuery) ||
-            template.description.toLowerCase().includes(lowerQuery) ||
-            template.metadata.tags.some(tag => tag.toLowerCase().includes(lowerQuery)));
-    }
-    /**
-     * Get template by ID
-     */
-    getTemplate(templateId) {
-        return this.templates.get(templateId) || null;
-    }
-    /**
-     * Generate flow from template
-     */
-    async generateFlowFromTemplate(customization) {
-        const startTime = Date.now();
-        try {
-            this.logger.info('🎯 Generating flow from template', {
-                templateId: customization.templateId,
-                variables: Object.keys(customization.variables).length
-            });
-            // Get template
-            const template = this.getTemplate(customization.templateId);
-            if (!template) {
-                throw new Error(`Template not found: ${customization.templateId}`);
-            }
-            // Validate variables
-            const validationErrors = this.validateVariables(template, customization.variables);
-            if (validationErrors.length > 0) {
-                throw new Error(`Variable validation failed: ${validationErrors.join(', ')}`);
-            }
-            // Process template
-            const flowDefinition = await this.processTemplate(template, customization);
-            // Generate XML
-            const flowXML = this.xmlGenerator.generateCompleteFlowXML(flowDefinition);
-            // Deploy if client is available
-            let sys_id;
-            let url;
-            if (this.client) {
-                try {
-                    const deployResult = await this.client.deployFlow(flowDefinition);
-                    if (deployResult.success) {
-                        sys_id = deployResult.sys_id;
-                        url = deployResult.url;
-                    }
-                }
-                catch (deployError) {
-                    this.logger.warn('⚠️ Flow XML generated but deployment failed', deployError);
-                }
-            }
-            // Update template usage
-            template.metadata.usageCount++;
-            await this.saveTemplate(template);
-            const generationTime = Date.now() - startTime;
-            return {
-                success: true,
-                flowDefinition,
-                flowXML,
-                sys_id,
-                url,
-                metrics: {
-                    generationTime,
-                    templateUsed: template.name,
-                    variablesCount: Object.keys(customization.variables).length,
-                    activitiesCount: flowDefinition.activities.length
-                }
-            };
-        }
-        catch (error) {
-            this.logger.error('❌ Flow generation failed', error);
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-                metrics: {
-                    generationTime: Date.now() - startTime,
-                    templateUsed: customization.templateId,
-                    variablesCount: Object.keys(customization.variables).length,
-                    activitiesCount: 0
-                }
-            };
-        }
-    }
-    /**
-     * Create custom template
-     */
-    async createTemplate(template) {
-        const fullTemplate = {
-            ...template,
-            metadata: {
-                version: '1.0.0',
-                author: 'Custom',
-                lastUpdated: new Date().toISOString(),
-                usageCount: 0,
-                successRate: 0,
-                tags: template.metadata?.tags || []
-            }
-        };
-        this.templates.set(template.id, fullTemplate);
-        await this.saveTemplate(fullTemplate);
-        this.logger.info('✅ Custom template created', { templateId: template.id });
-    }
-    /**
-     * Preview template generation (without deployment)
-     */
-    async previewTemplate(customization) {
-        const template = this.getTemplate(customization.templateId);
-        if (!template) {
-            throw new Error(`Template not found: ${customization.templateId}`);
-        }
-        const flowDefinition = await this.processTemplate(template, customization);
-        return {
-            flowDefinition,
-            estimatedComplexity: template.complexity,
-            requiredPermissions: this.calculateRequiredPermissions(flowDefinition),
-            warnings: this.analyzePotentialIssues(flowDefinition)
-        };
-    }
-    /**
-     * Get template usage analytics
-     */
-    getTemplateAnalytics() {
-        const templates = this.getTemplates();
-        const totalUsage = templates.reduce((sum, t) => sum + t.metadata.usageCount, 0);
-        const topTemplates = templates
-            .slice(0, 5)
-            .map(t => ({
-            id: t.id,
-            name: t.name,
-            usage: t.metadata.usageCount
-        }));
-        const categoriesUsage = templates.reduce((acc, t) => {
-            acc[t.category] = (acc[t.category] || 0) + t.metadata.usageCount;
-            return acc;
-        }, {});
-        return {
-            totalTemplates: templates.length,
-            totalUsage,
-            topTemplates,
-            categoriesUsage
-        };
-    }
-    /**
-     * Private helper methods
-     */
-    async loadBuiltInTemplates() {
-        // iPhone Approval Template
-        const iphoneApprovalTemplate = {
-            id: 'iphone_approval_flow',
-            name: 'iPhone Approval Flow',
-            description: 'Complete iPhone provisioning flow with manager approval and automated fulfillment',
-            category: 'approval',
-            complexity: 'moderate',
-            estimatedTime: '10-15 minutes',
-            prerequisites: ['iPhone catalog item', 'Manager approval group', 'Fulfillment team'],
-            variables: [
-                {
-                    name: 'catalog_item',
-                    displayName: 'iPhone Catalog Item',
-                    type: 'table',
-                    required: true,
-                    description: 'ServiceNow catalog item for iPhone requests',
-                    placeholder: 'sc_cat_item sys_id'
-                },
-                {
-                    name: 'approval_group',
-                    displayName: 'Manager Approval Group',
-                    type: 'group',
-                    required: true,
-                    description: 'Group responsible for approving iPhone requests',
-                    defaultValue: 'IT Managers'
-                },
-                {
-                    name: 'fulfillment_group',
-                    displayName: 'Fulfillment Team',
-                    type: 'group',
-                    required: true,
-                    description: 'Team that handles iPhone provisioning',
-                    defaultValue: 'IT Support'
-                },
-                {
-                    name: 'notification_template',
-                    displayName: 'Notification Template',
-                    type: 'string',
-                    required: false,
-                    description: 'Custom notification template for updates',
-                    defaultValue: 'Standard approval notification'
-                }
-            ],
-            activities: [
-                {
-                    id: 'initial_notification',
-                    name: 'Send Initial Notification',
-                    type: 'notification',
-                    description: 'Notify requester that their request is being processed',
-                    order: 1,
-                    inputs: {
-                        recipient: '${trigger.requested_for}',
-                        subject: 'iPhone Request Received - ${trigger.number}',
-                        message: 'Your iPhone request has been received and is being processed.'
-                    }
-                },
-                {
-                    id: 'manager_approval',
-                    name: 'Manager Approval',
-                    type: 'approval',
-                    description: 'Get approval from manager for iPhone request',
-                    order: 2,
-                    inputs: {
-                        approver: '${trigger.requested_for.manager}',
-                        fallback_approver: '${approval_group}',
-                        subject: 'iPhone Approval Required',
-                        description: 'Please approve the iPhone request for ${trigger.requested_for.name}'
-                    }
-                },
-                {
-                    id: 'approved_check',
-                    name: 'Check Approval Status',
-                    type: 'condition',
-                    description: 'Check if the request was approved',
-                    order: 3,
-                    condition: '${manager_approval.result} == "approved"',
-                    inputs: {}
-                },
-                {
-                    id: 'fulfillment_task',
-                    name: 'Create Fulfillment Task',
-                    type: 'create_record',
-                    description: 'Create task for iPhone fulfillment team',
-                    order: 4,
-                    inputs: {
-                        table: 'sc_task',
-                        fields: {
-                            short_description: 'Provision iPhone for ${trigger.requested_for.name}',
-                            description: 'Request: ${trigger.number}\nUser: ${trigger.requested_for.name}\nApproved by: ${manager_approval.approver}',
-                            assignment_group: '${fulfillment_group}',
-                            priority: '3',
-                            state: '1'
-                        }
-                    }
-                },
-                {
-                    id: 'approval_notification',
-                    name: 'Send Approval Notification',
-                    type: 'notification',
-                    description: 'Notify requester of approval and next steps',
-                    order: 5,
-                    inputs: {
-                        recipient: '${trigger.requested_for}',
-                        subject: 'iPhone Request Approved - ${trigger.number}',
-                        message: 'Your iPhone request has been approved and assigned to the fulfillment team.'
-                    }
-                },
-                {
-                    id: 'rejection_notification',
-                    name: 'Send Rejection Notification',
-                    type: 'notification',
-                    description: 'Notify requester of rejection',
-                    order: 6,
-                    condition: '${manager_approval.result} == "rejected"',
-                    inputs: {
-                        recipient: '${trigger.requested_for}',
-                        subject: 'iPhone Request Declined - ${trigger.number}',
-                        message: 'Your iPhone request has been declined. Please contact your manager for more information.'
-                    }
-                }
-            ],
-            metadata: {
-                version: '1.2.0',
-                author: 'Snow-Flow Templates',
-                lastUpdated: new Date().toISOString(),
-                usageCount: 0,
-                successRate: 95.5,
-                tags: ['approval', 'iphone', 'provisioning', 'catalog', 'popular']
-            }
-        };
-        // Incident Escalation Template
-        const incidentEscalationTemplate = {
-            id: 'incident_escalation_flow',
-            name: 'Incident Escalation Flow',
-            description: 'Automatic incident escalation based on priority and time thresholds',
-            category: 'utility',
-            complexity: 'simple',
-            estimatedTime: '5-8 minutes',
-            prerequisites: ['Incident table access', 'Escalation groups configured'],
-            variables: [
-                {
-                    name: 'priority_threshold',
-                    displayName: 'Priority Threshold',
-                    type: 'choice',
-                    required: true,
-                    description: 'Minimum priority for escalation',
-                    validation: {
-                        options: ['1 - Critical', '2 - High', '3 - Moderate']
-                    },
-                    defaultValue: '2 - High'
-                },
-                {
-                    name: 'escalation_time',
-                    displayName: 'Escalation Time (minutes)',
-                    type: 'number',
-                    required: true,
-                    description: 'Time before escalation in minutes',
-                    defaultValue: 30,
-                    validation: {
-                        minLength: 1
-                    }
-                },
-                {
-                    name: 'escalation_group',
-                    displayName: 'Escalation Group',
-                    type: 'group',
-                    required: true,
-                    description: 'Group to escalate incidents to',
-                    defaultValue: 'IT Management'
-                }
-            ],
-            activities: [
-                {
-                    id: 'check_priority',
-                    name: 'Check Incident Priority',
-                    type: 'condition',
-                    description: 'Verify incident meets priority threshold',
-                    order: 1,
-                    condition: '${trigger.priority} <= ${priority_threshold}',
-                    inputs: {}
-                },
-                {
-                    id: 'wait_for_escalation',
-                    name: 'Wait for Escalation Time',
-                    type: 'script',
-                    description: 'Wait for specified time before escalating',
-                    order: 2,
-                    inputs: {
-                        script: 'gs.sleep(${escalation_time} * 60 * 1000);'
-                    }
-                },
-                {
-                    id: 'check_still_open',
-                    name: 'Check if Still Open',
-                    type: 'condition',
-                    description: 'Verify incident is still open and unassigned',
-                    order: 3,
-                    condition: '${trigger.state} < 6 && ${trigger.assigned_to} == ""',
-                    inputs: {}
-                },
-                {
-                    id: 'escalate_incident',
-                    name: 'Escalate Incident',
-                    type: 'update_record',
-                    description: 'Assign to escalation group and add escalation note',
-                    order: 4,
-                    inputs: {
-                        table: 'incident',
-                        sys_id: '${trigger.sys_id}',
-                        fields: {
-                            assignment_group: '${escalation_group}',
-                            work_notes: 'Automatically escalated after ${escalation_time} minutes due to no assignment'
-                        }
-                    }
-                },
-                {
-                    id: 'escalation_notification',
-                    name: 'Send Escalation Notification',
-                    type: 'notification',
-                    description: 'Notify escalation group of new assignment',
-                    order: 5,
-                    inputs: {
-                        recipient: '${escalation_group}',
-                        subject: 'Incident Escalated - ${trigger.number}',
-                        message: 'Incident ${trigger.number} has been escalated to your group after ${escalation_time} minutes.'
-                    }
-                }
-            ],
-            metadata: {
-                version: '1.1.0',
-                author: 'Snow-Flow Templates',
-                lastUpdated: new Date().toISOString(),
-                usageCount: 0,
-                successRate: 98.2,
-                tags: ['incident', 'escalation', 'automation', 'sla']
-            }
-        };
-        // Store templates
-        this.templates.set(iphoneApprovalTemplate.id, iphoneApprovalTemplate);
-        this.templates.set(incidentEscalationTemplate.id, incidentEscalationTemplate);
-        this.logger.info('✅ Built-in templates loaded', { count: 2 });
-    }
-    async loadCustomTemplates() {
-        try {
-            const files = await promises_1.default.readdir(this.templatesPath);
-            const jsonFiles = files.filter(f => f.endsWith('.json'));
-            for (const file of jsonFiles) {
-                try {
-                    const filePath = path_1.default.join(this.templatesPath, file);
-                    const content = await promises_1.default.readFile(filePath, 'utf-8');
-                    const template = JSON.parse(content);
-                    this.templates.set(template.id, template);
-                }
-                catch (error) {
-                    this.logger.warn(`⚠️ Failed to load template ${file}:`, error);
-                }
-            }
-            this.logger.info('✅ Custom templates loaded', { count: jsonFiles.length });
-        }
-        catch (error) {
-            // Templates directory doesn't exist yet - that's fine
-            this.logger.debug('Templates directory not found, creating...');
-        }
-    }
-    async saveTemplate(template) {
-        const filePath = path_1.default.join(this.templatesPath, `${template.id}.json`);
-        await promises_1.default.writeFile(filePath, JSON.stringify(template, null, 2));
-    }
-    validateVariables(template, variables) {
-        const errors = [];
-        for (const templateVar of template.variables) {
-            const value = variables[templateVar.name];
-            // Check required variables
-            if (templateVar.required && (value === undefined || value === null || value === '')) {
-                errors.push(`Required variable '${templateVar.name}' is missing`);
-                continue;
-            }
-            // Skip validation if variable is not provided and not required
-            if (value === undefined || value === null)
-                continue;
-            // Type validation
-            if (templateVar.type === 'number' && isNaN(Number(value))) {
-                errors.push(`Variable '${templateVar.name}' must be a number`);
-            }
-            if (templateVar.type === 'boolean' && typeof value !== 'boolean') {
-                errors.push(`Variable '${templateVar.name}' must be a boolean`);
-            }
-            // Validation rules
-            if (templateVar.validation) {
-                const val = templateVar.validation;
-                if (val.pattern && !new RegExp(val.pattern).test(String(value))) {
-                    errors.push(`Variable '${templateVar.name}' does not match required pattern`);
-                }
-                if (val.minLength && String(value).length < val.minLength) {
-                    errors.push(`Variable '${templateVar.name}' is too short (minimum ${val.minLength})`);
-                }
-                if (val.maxLength && String(value).length > val.maxLength) {
-                    errors.push(`Variable '${templateVar.name}' is too long (maximum ${val.maxLength})`);
-                }
-                if (val.options && !val.options.includes(String(value))) {
-                    errors.push(`Variable '${templateVar.name}' must be one of: ${val.options.join(', ')}`);
-                }
-            }
-        }
-        return errors;
-    }
-    async processTemplate(template, customization) {
-        // Start with base flow definition
-        const flowDefinition = {
-            name: customization.customizations?.flowName || `${template.name} (Generated)`,
-            description: customization.customizations?.description || template.description,
-            trigger_type: 'record_created', // Default, will be customized based on template
-            activities: [],
-            run_as: 'user',
-            accessible_from: 'package_private'
-        };
-        // Process activities
-        let activities = template.activities.slice();
-        // Skip activities if specified
-        if (customization.customizations?.skipActivities) {
-            activities = activities.filter(a => !customization.customizations?.skipActivities.includes(a.id));
-        }
-        // Add additional activities if specified
-        if (customization.customizations?.additionalActivities) {
-            activities.push(...customization.customizations.additionalActivities);
-        }
-        // Sort by order
-        activities.sort((a, b) => a.order - b.order);
-        // Convert template activities to XML activities
-        flowDefinition.activities = activities.map(activity => {
-            // Apply modifications if specified
-            const modifications = customization.customizations?.modifyActivities?.[activity.id];
-            const finalActivity = modifications ? { ...activity, ...modifications } : activity;
-            // Process variable substitution in inputs
-            const processedInputs = this.processVariableSubstitution(finalActivity.inputs, customization.variables);
-            return {
-                name: finalActivity.name,
-                type: finalActivity.type,
-                inputs: processedInputs,
-                outputs: finalActivity.outputs,
-                condition: finalActivity.condition
-            };
-        });
-        return flowDefinition;
-    }
-    processVariableSubstitution(obj, variables) {
-        if (typeof obj === 'string') {
-            // Replace ${variable_name} patterns
-            return obj.replace(/\$\{([^}]+)\}/g, (match, varName) => {
-                return variables[varName] || match;
-            });
-        }
-        if (Array.isArray(obj)) {
-            return obj.map(item => this.processVariableSubstitution(item, variables));
-        }
-        if (typeof obj === 'object' && obj !== null) {
-            const result = {};
-            for (const [key, value] of Object.entries(obj)) {
-                result[key] = this.processVariableSubstitution(value, variables);
-            }
-            return result;
-        }
-        return obj;
-    }
-    calculateRequiredPermissions(flowDefinition) {
-        const permissions = new Set();
-        // Base permissions
-        permissions.add('flow_designer');
-        // Check activities for required permissions
-        for (const activity of flowDefinition.activities) {
-            switch (activity.type) {
-                case 'create_record':
-                case 'update_record':
-                    permissions.add(`${activity.inputs.table}_admin`);
-                    break;
-                case 'approval':
-                    permissions.add('approval_admin');
-                    break;
-                case 'notification':
-                    permissions.add('notification_admin');
-                    break;
-                case 'script':
-                    permissions.add('script_execution');
-                    break;
-            }
-        }
-        return Array.from(permissions);
-    }
-    analyzePotentialIssues(flowDefinition) {
-        const warnings = [];
-        // Check for complex flows
-        if (flowDefinition.activities.length > 10) {
-            warnings.push('Flow has many activities - consider breaking into sub-flows');
-        }
-        // Check for missing error handling
-        const hasErrorHandling = flowDefinition.activities.some(a => a.name.toLowerCase().includes('error') || a.name.toLowerCase().includes('exception'));
-        if (!hasErrorHandling) {
-            warnings.push('No error handling activities detected - consider adding try/catch logic');
-        }
-        // Check for performance issues
-        const hasLoops = flowDefinition.activities.some(a => a.condition?.includes('while') || a.type === 'script');
-        if (hasLoops) {
-            warnings.push('Potential loops detected - ensure proper exit conditions');
-        }
-        return warnings;
-    }
-    getTemplateCategories() {
-        const categories = new Set();
-        for (const template of this.templates.values()) {
-            categories.add(template.category);
-        }
-        return Array.from(categories);
-    }
-}
-exports.FlowTemplateSystem = FlowTemplateSystem;
-exports.default = FlowTemplateSystem;

package/dist/test-fetch-incidents.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=test-fetch-incidents.d.ts.map