@flowuent-org/diagramming-core 1.3.10 → 1.4.0

package/packages/diagrams/src/lib/templates/cloud-arch/utils/restrictionEngine.ts

@@ -1,551 +0,0 @@
-// Generic Restriction Engine
-// Handles evaluation of the new flexible restriction system
-
-import {
-  RestrictionEntry,
-  PartialRestriction,
-  RestrictionEvaluationContext,
-  RestrictionEvaluationResult,
-  ResolvedRestriction,
-} from '../types/validation';
-
-export class RestrictionEngine {
-  private partialRestrictions: Map<string, PartialRestriction> = new Map();
-  private customFunctions: Map<string, Function> = new Map();
-
-  constructor() {
-    this.initializeCustomFunctions();
-  }
-
-  // Register partial restrictions for reuse
-  registerPartialRestriction(partial: PartialRestriction): void {
-    this.partialRestrictions.set(partial.id, partial);
-  }
-
-  // Register custom validation functions
-  registerCustomFunction(name: string, fn: Function): void {
-    this.customFunctions.set(name, fn);
-  }
-
-  // Resolve restrictions by processing partials and inheritance
-  resolveRestrictions(
-    entries: RestrictionEntry[],
-    partials?: string[],
-    inheritedFrom?: string[]
-  ): ResolvedRestriction[] {
-    const resolved: ResolvedRestriction[] = [];
-
-    // Process partial restrictions first
-    if (partials) {
-      for (const partialId of partials) {
-        const partial = this.partialRestrictions.get(partialId);
-        if (partial) {
-          const resolvedPartial = this.expandPartialRestriction(partial);
-          resolved.push(...resolvedPartial);
-        }
-      }
-    }
-
-    // Process direct entries
-    for (const entry of entries) {
-      if (entry.extends) {
-        // Resolve extended restriction
-        const extended = this.resolveExtendedRestriction(entry);
-        resolved.push(extended);
-      } else {
-        // Direct restriction
-        resolved.push({ ...entry });
-      }
-    }
-
-    // TODO: Process inherited restrictions from other resource types
-    // This would involve looking up restrictions from parent resource types
-
-    return this.deduplicateRestrictions(resolved);
-  }
-
-  // Expand partial restriction into concrete restrictions
-  private expandPartialRestriction(partial: PartialRestriction): ResolvedRestriction[] {
-    const template = partial.template;
-    const resolved: ResolvedRestriction[] = [];
-
-    // Apply variable substitutions if any
-    const substitutions: Record<string, any> = {};
-    if (partial.variables) {
-      for (const [key, variable] of Object.entries(partial.variables)) {
-        substitutions[key] = variable.defaultValue;
-      }
-    }
-
-    // Create resolved restriction from template
-    const restriction: ResolvedRestriction = {
-      id: `${partial.id}-resolved-${Date.now()}`,
-      ...template,
-      resolvedFrom: partial.id,
-      substitutions
-    };
-
-    resolved.push(restriction);
-    return resolved;
-  }
-
-  // Resolve extended restriction with overrides
-  private resolveExtendedRestriction(entry: RestrictionEntry): ResolvedRestriction {
-    const basePartial = this.partialRestrictions.get(entry.extends!);
-    if (!basePartial) {
-      // Return as-is if base partial not found
-      return { ...entry };
-    }
-
-    // Merge base template with overrides
-    const resolved: ResolvedRestriction = {
-      ...basePartial.template,
-      ...entry,
-      ...(entry.overrides || {}),
-      resolvedFrom: entry.extends,
-      substitutions: {}
-    };
-
-    return resolved;
-  }
-
-  // Remove duplicate restrictions (same type + target)
-  private deduplicateRestrictions(restrictions: ResolvedRestriction[]): ResolvedRestriction[] {
-    const seen = new Set<string>();
-    const deduplicated: ResolvedRestriction[] = [];
-
-    for (const restriction of restrictions) {
-      const key = `${restriction.type}-${restriction.target || 'global'}`;
-      if (!seen.has(key)) {
-        seen.add(key);
-        deduplicated.push(restriction);
-      }
-    }
-
-    return deduplicated;
-  }
-
-  // Evaluate a single restriction against context
-  evaluateRestriction(
-    restriction: ResolvedRestriction,
-    context: RestrictionEvaluationContext
-  ): RestrictionEvaluationResult {
-    try {
-      // Check conditions first
-      if (!this.evaluateConditions(restriction, context)) {
-        return {
-          isValid: true, // Condition not met, restriction doesn't apply
-          restrictionId: restriction.id,
-          restrictionType: restriction.type,
-          severity: restriction.metadata.severity,
-          message: 'Restriction condition not met, skipping evaluation',
-          metadata: {
-            category: restriction.metadata.category,
-            context: 'condition-skipped'
-          }
-        };
-      }
-
-      // Evaluate based on restriction type
-      const isValid = this.evaluateByType(restriction, context);
-
-      return {
-        isValid,
-        restrictionId: restriction.id,
-        restrictionType: restriction.type,
-        severity: restriction.metadata.severity,
-        message: this.formatMessage(restriction.validationMessage, context),
-        suggestion: this.generateSuggestion(restriction, context),
-        autoFix: restriction.metadata.autoFix,
-        metadata: {
-          category: restriction.metadata.category,
-          references: restriction.metadata.references,
-          context: restriction.condition?.context
-        }
-      };
-    } catch (error) {
-      return {
-        isValid: false,
-        restrictionId: restriction.id,
-        restrictionType: restriction.type,
-        severity: 'error',
-        message: `Restriction evaluation failed: ${error instanceof Error ? error.message : 'Unknown error'}`,
-        metadata: {
-          category: 'system',
-          context: 'evaluation-error'
-        }
-      };
-    }
-  }
-
-  // Evaluate restriction conditions
-  private evaluateConditions(
-    restriction: ResolvedRestriction,
-    context: RestrictionEvaluationContext
-  ): boolean {
-    if (!restriction.condition) return true;
-
-    const { unless, onlyIf, regions, tags, expression } = restriction.condition;
-
-    // Check 'unless' conditions (skip if any match)
-    if (unless && unless.length > 0) {
-      for (const condition of unless) {
-        if (this.evaluateConditionExpression(condition, context)) {
-          return false; // Skip this restriction
-        }
-      }
-    }
-
-    // Check 'onlyIf' conditions (apply only if all match)
-    if (onlyIf && onlyIf.length > 0) {
-      for (const condition of onlyIf) {
-        if (!this.evaluateConditionExpression(condition, context)) {
-          return false; // Skip this restriction
-        }
-      }
-    }
-
-    // Check region restrictions
-    if (regions && regions.length > 0) {
-      const sourceRegion = context.sourceResource.region;
-      if (!sourceRegion || !regions.includes(sourceRegion)) {
-        return false;
-      }
-    }
-
-    // Check tag restrictions
-    if (tags && Object.keys(tags).length > 0) {
-      const sourceTags = context.sourceResource.tags || {};
-      for (const [key, value] of Object.entries(tags)) {
-        if (sourceTags[key] !== value) {
-          return false;
-        }
-      }
-    }
-
-    // Check custom expression
-    if (expression) {
-      return this.evaluateExpression(expression, context);
-    }
-
-    return true;
-  }
-
-  // Evaluate restriction by its type
-  private evaluateByType(
-    restriction: ResolvedRestriction,
-    context: RestrictionEvaluationContext
-  ): boolean {
-    switch (restriction.type) {
-      case 'canContain':
-        return this.evaluateCanContain(restriction, context);
-      case 'cannotContain':
-        return this.evaluateCannotContain(restriction, context);
-      case 'mustBeIn':
-        return this.evaluateMustBeIn(restriction, context);
-      case 'cannotBeIn':
-        return this.evaluateCannotBeIn(restriction, context);
-      case 'quota':
-        return this.evaluateQuota(restriction, context);
-      case 'limit':
-        return this.evaluateLimit(restriction, context);
-      case 'dependency':
-        return this.evaluateDependency(restriction, context);
-      case 'conflict':
-        return this.evaluateConflict(restriction, context);
-      case 'placement':
-        return this.evaluatePlacement(restriction, context);
-      case 'validation':
-        return this.evaluateValidation(restriction, context);
-      case 'region':
-        return this.evaluateRegion(restriction, context);
-      case 'network':
-        return this.evaluateNetwork(restriction, context);
-      case 'sizing':
-        return this.evaluateSizing(restriction, context);
-      case 'naming':
-        return this.evaluateNaming(restriction, context);
-      default:
-        throw new Error(`Unknown restriction type: ${restriction.type}`);
-    }
-  }
-
-  // Type-specific evaluation methods
-  private evaluateCanContain(restriction: RestrictionEntry, context: RestrictionEvaluationContext): boolean {
-    if (!restriction.target || !context.targetResource) return true;
-
-    // Check if target resource type is allowed
-    if (context.targetResource.type !== restriction.target) {
-      return true; // Not applicable to this target type
-    }
-
-    // Count existing children of this type
-    const childCount = context.allResources.filter(
-      resource => resource.parentId === context.sourceResource.id && 
-                  resource.type === restriction.target
-    ).length;
-
-    // Check max limit
-    if (restriction.max !== undefined && childCount >= restriction.max) {
-      return false;
-    }
-
-    return true;
-  }
-
-  private evaluateCannotContain(restriction: RestrictionEntry, context: RestrictionEvaluationContext): boolean {
-    if (!restriction.target || !context.targetResource) return true;
-
-    // Check if target resource type is forbidden
-    if (context.targetResource.type === restriction.target) {
-      // Check if this would be a direct child
-      const wouldBeChild = context.allResources.some(
-        resource => resource.parentId === context.sourceResource.id && 
-                   resource.type === restriction.target
-      );
-      return !wouldBeChild;
-    }
-
-    return true;
-  }
-
-  private evaluateMustBeIn(restriction: RestrictionEntry, context: RestrictionEvaluationContext): boolean {
-    if (!restriction.target) return true;
-
-    // Find parent of source resource
-    const parent = context.allResources.find(
-      resource => resource.id === context.sourceResource.id
-    );
-
-    // Check if source is in required parent type
-    if (parent && parent.type === restriction.target) {
-      return true;
-    }
-
-    return false;
-  }
-
-  private evaluateCannotBeIn(restriction: RestrictionEntry, context: RestrictionEvaluationContext): boolean {
-    if (!restriction.target) return true;
-
-    // Find parent of source resource
-    const parent = context.allResources.find(
-      resource => resource.id === context.sourceResource.id
-    );
-
-    // Check if source is in forbidden parent type
-    if (parent && parent.type === restriction.target) {
-      return false;
-    }
-
-    return true;
-  }
-
-  private evaluateQuota(restriction: RestrictionEntry, context: RestrictionEvaluationContext): boolean {
-    if (!restriction.target || restriction.max === undefined) return true;
-
-    // Count resources of target type
-    const count = context.allResources.filter(
-      resource => resource.type === restriction.target
-    ).length;
-
-    return count <= restriction.max;
-  }
-
-  private evaluateLimit(restriction: RestrictionEntry, context: RestrictionEvaluationContext): boolean {
-    const value = restriction.value;
-    if (value === undefined) return true;
-
-    // Generic limit evaluation based on target
-    switch (restriction.target) {
-      case 'totalNodes':
-        return context.diagramContext.totalNodes <= (value as number);
-      case 'totalEdges':
-        return context.diagramContext.totalEdges <= (value as number);
-      case 'cloudProviders':
-        return context.diagramContext.cloudProviders.length <= (value as number);
-      default:
-        return true;
-    }
-  }
-
-  private evaluateDependency(restriction: RestrictionEntry, context: RestrictionEvaluationContext): boolean {
-    if (!restriction.target) return true;
-
-    // Check if required dependency exists
-    const hasDependency = context.allResources.some(
-      resource => resource.type === restriction.target
-    );
-
-    return hasDependency;
-  }
-
-  private evaluateConflict(restriction: RestrictionEntry, context: RestrictionEvaluationContext): boolean {
-    if (!restriction.target) return true;
-
-    // Check if conflicting resource exists
-    const hasConflict = context.allResources.some(
-      resource => resource.type === restriction.target && 
-                  resource.id !== context.sourceResource.id
-    );
-
-    return !hasConflict;
-  }
-
-  private evaluatePlacement(restriction: RestrictionEntry, context: RestrictionEvaluationContext): boolean {
-    // Custom placement logic based on target and value
-    return true; // Placeholder - implement specific placement rules
-  }
-
-  private evaluateValidation(restriction: RestrictionEntry, context: RestrictionEvaluationContext): boolean {
-    // Custom validation logic
-    if (restriction.condition?.expression) {
-      return this.evaluateExpression(restriction.condition.expression, context);
-    }
-    return true;
-  }
-
-  private evaluateRegion(restriction: RestrictionEntry, context: RestrictionEvaluationContext): boolean {
-    if (!restriction.target) return true;
-
-    const sourceRegion = context.sourceResource.region;
-    return sourceRegion === restriction.target;
-  }
-
-  private evaluateNetwork(restriction: RestrictionEntry, context: RestrictionEvaluationContext): boolean {
-    // Network-specific validation logic
-    return true; // Placeholder
-  }
-
-  private evaluateSizing(restriction: RestrictionEntry, context: RestrictionEvaluationContext): boolean {
-    // Size-specific validation logic
-    return true; // Placeholder
-  }
-
-  private evaluateNaming(restriction: RestrictionEntry, context: RestrictionEvaluationContext): boolean {
-    if (!restriction.target || typeof restriction.value !== 'string') return true;
-
-    // Validate naming pattern
-    const namePattern = new RegExp(restriction.value);
-    const resourceName = context.sourceResource.properties.name || context.sourceResource.id;
-    
-    return namePattern.test(resourceName);
-  }
-
-  // Helper methods
-  private evaluateConditionExpression(condition: string, context: RestrictionEvaluationContext): boolean {
-    // Simple condition evaluation - could be enhanced with a proper expression parser
-    try {
-      // Replace context variables in the condition
-      const processedCondition = this.substituteContextVariables(condition, context);
-      return new Function('return ' + processedCondition)();
-    } catch {
-      return false;
-    }
-  }
-
-  private evaluateExpression(expression: string, context: RestrictionEvaluationContext): boolean {
-    try {
-      const processedExpression = this.substituteContextVariables(expression, context);
-      return new Function('return ' + processedExpression)();
-    } catch {
-      return false;
-    }
-  }
-
-  private substituteContextVariables(expression: string, context: RestrictionEvaluationContext): string {
-    return expression
-      .replace(/\$sourceType/g, `"${context.sourceResource.type}"`)
-      .replace(/\$targetType/g, `"${context.targetResource?.type || ''}"`)
-      .replace(/\$sourceRegion/g, `"${context.sourceResource.region || ''}"`)
-      .replace(/\$totalNodes/g, context.diagramContext.totalNodes.toString())
-      .replace(/\$totalEdges/g, context.diagramContext.totalEdges.toString())
-      .replace(/\$cloudProviders/g, context.diagramContext.cloudProviders.length.toString());
-  }
-
-  private formatMessage(template: string, context: RestrictionEvaluationContext): string {
-    return this.substituteContextVariables(template, context);
-  }
-
-  private generateSuggestion(restriction: RestrictionEntry, context: RestrictionEvaluationContext): string | undefined {
-    // Generate helpful suggestions based on restriction type and context
-    switch (restriction.type) {
-      case 'canContain':
-        if (restriction.max !== undefined) {
-          return `Consider removing some ${restriction.target} resources or increase the limit.`;
-        }
-        break;
-      case 'mustBeIn':
-        return `Place this resource inside a ${restriction.target} container.`;
-      case 'cannotBeIn':
-        return `Move this resource outside of the ${restriction.target} container.`;
-      case 'quota':
-        return `You have reached the quota limit for ${restriction.target} resources.`;
-    }
-    return undefined;
-  }
-
-  // Initialize default custom functions
-  private initializeCustomFunctions(): void {
-    this.customFunctions.set('containsAll', (required: string[], actual: string[]) => {
-      return required.every(item => actual.includes(item));
-    });
-
-    this.customFunctions.set('containsAny', (options: string[], actual: string[]) => {
-      return options.some(item => actual.includes(item));
-    });
-
-    this.customFunctions.set('inRange', (value: number, min: number, max: number) => {
-      return value >= min && value <= max;
-    });
-  }
-
-  // Evaluate all restrictions for a context
-  evaluateAllRestrictions(
-    restrictions: ResolvedRestriction[],
-    context: RestrictionEvaluationContext
-  ): RestrictionEvaluationResult[] {
-    return restrictions.map(restriction => this.evaluateRestriction(restriction, context));
-  }
-
-  // Get summary of restriction evaluation results
-  getEvaluationSummary(results: RestrictionEvaluationResult[]): {
-    totalRestrictions: number;
-    passed: number;
-    failed: number;
-    warnings: number;
-    errors: number;
-    categories: Record<string, number>;
-  } {
-    const summary = {
-      totalRestrictions: results.length,
-      passed: 0,
-      failed: 0,
-      warnings: 0,
-      errors: 0,
-      categories: {} as Record<string, number>
-    };
-
-    for (const result of results) {
-      if (result.isValid) {
-        summary.passed++;
-      } else {
-        summary.failed++;
-        if (result.severity === 'warning') {
-          summary.warnings++;
-        } else if (result.severity === 'error') {
-          summary.errors++;
-        }
-      }
-
-      // Count by category
-      const category = result.metadata.category;
-      summary.categories[category] = (summary.categories[category] || 0) + 1;
-    }
-
-    return summary;
-  }
-}
-
-// Export singleton instance
-export const restrictionEngine = new RestrictionEngine();