@flowuent-org/diagramming-core 1.3.10 → 1.4.1

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

@@ -1,551 +1,551 @@
-// 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
+// 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();