@jwikman/bc-code-intelligence-mcp 1.5.7-dev.1

package/embedded-knowledge/domains/sam-coder/command-queue-pattern-al.md

@@ -0,0 +1,141 @@
+---
+title: "Command Queue Pattern in AL"
+domain: "sam-coder"
+difficulty: "intermediate"
+bc_versions: "14+"
+tags: ["command-queue", "async-processing", "message-patterns", "queue-management"]
+prerequisites: ["queue-basics", "command-pattern", "async-programming"]
+samples: "samples/command-queue-pattern.md"
+related_topics: ["task-scheduler-pattern-implementation", "event-bridge-pattern-al"]
+---
+
+# Command Queue Pattern in AL
+
+## Overview
+
+The Command Queue Pattern enables asynchronous command processing by queuing commands for later execution, providing system decoupling and improved responsiveness. This pattern is essential for handling operations that don't require immediate execution or that need to be processed in specific orders.
+
+**Key Benefit**: Enables asynchronous processing that improves system responsiveness while providing reliable command execution guarantees.
+
+## Core Queue Architecture
+
+### Command Encapsulation
+Design command objects that encapsulate all necessary information for execution, including parameters, context, and execution requirements.
+
+### Queue Management System
+Implement queue management that handles command storage, ordering, priority processing, and execution coordination.
+
+### Processing Engine Design
+Create processing engines that can reliably execute queued commands while handling errors, retries, and recovery scenarios.
+
+## Implementation Patterns
+
+### FIFO Queue Processing
+Implement first-in-first-out queue processing for scenarios where command execution order is critical for business logic correctness.
+
+### Priority Queue Handling
+Design priority-based queue processing that ensures high-priority commands receive expedited processing while maintaining overall queue progress.
+
+### Batch Processing Integration
+Integrate queue processing with batch processing capabilities to enable efficient handling of large command volumes.
+
+## Advanced Queue Features
+
+### Command Scheduling
+Implement scheduling capabilities that allow commands to be queued for future execution at specific times or after specific delays.
+
+### Command Dependencies
+Design dependency tracking that ensures prerequisite commands complete successfully before dependent commands execute.
+
+### Transaction Integration
+Integrate command processing with transaction management to ensure data consistency and enable rollback scenarios.
+
+## Error Handling and Reliability
+
+### Retry Mechanisms
+- Implement intelligent retry policies for failed command execution
+- Support different retry strategies based on error types and command characteristics
+- Provide exponential backoff to prevent system overload during error scenarios
+- Log retry attempts for debugging and monitoring purposes
+
+### Dead Letter Queues
+- Design dead letter queues for commands that cannot be processed successfully
+- Implement manual review and reprocessing capabilities for dead letter items
+- Provide analysis tools for understanding command failure patterns
+- Support command modification and requeuing after issue resolution
+
+## Performance Optimization
+
+### Queue Throughput
+Optimize queue processing algorithms to maximize command throughput while maintaining system stability and resource efficiency.
+
+### Memory Management
+Implement efficient memory management for queued commands to prevent memory exhaustion during high-volume processing.
+
+### Parallel Processing
+Design parallel processing capabilities for independent commands to improve overall system throughput and responsiveness.
+
+## Monitoring and Diagnostics
+
+### Queue Health Monitoring
+Implement comprehensive monitoring of queue health including length, processing rates, error rates, and performance metrics.
+
+### Command Execution Tracking
+Provide detailed tracking of command execution including timing, success rates, and failure analysis capabilities.
+
+### Performance Analytics
+Design analytics capabilities that can identify performance bottlenecks and optimization opportunities in queue processing.
+
+## Integration Strategies
+
+### Event-Driven Integration
+Integrate command queues with event-driven architectures to enable reactive command processing based on business events.
+
+### External System Integration
+Design integration patterns that enable command queue coordination with external systems and services.
+
+### API Integration
+Implement API patterns that allow external systems to submit commands to queues while maintaining security and validation requirements.
+
+## Security and Validation
+
+### Command Validation
+- Implement comprehensive validation for queued commands before execution
+- Validate user permissions and authorization for command execution
+- Support command sanitization to prevent security vulnerabilities
+- Audit command execution for compliance and security monitoring
+
+### Access Control
+- Control access to command queuing and management capabilities
+- Implement role-based access to different queue operations
+- Support secure command parameter handling for sensitive data
+- Provide audit trails for command queue operations
+
+## Best Practices
+
+### Design Principles
+- Design commands to be idempotent to support safe retry operations
+- Implement comprehensive logging for command execution and queue operations
+- Use dependency injection for command implementation flexibility
+- Keep command implementations focused and single-purpose
+
+### Operational Excellence
+- Provide clear documentation for command queue configuration and management
+- Implement automated testing for queue processing logic
+- Support queue processing simulation and testing capabilities
+- Maintain clear operational procedures for queue management
+
+## Common Pitfalls
+
+### Queue Overflow
+Avoid scenarios where command queues can grow unbounded, leading to memory exhaustion and system performance degradation.
+
+### Command Coupling
+Prevent tight coupling between command implementations that reduces system flexibility and maintenance.
+
+### Processing Bottlenecks
+Identify and prevent processing bottlenecks that can cause queue backups and system responsiveness issues.
+
+*Complete command queue implementation: samples/command-queue-pattern.md*
+*Task scheduling integration: task-scheduler-pattern-implementation.md*
+*Event-driven patterns: event-bridge-pattern-al.md*

package/embedded-knowledge/domains/sam-coder/deleteall-alternative-implementation.md

@@ -0,0 +1,91 @@
+---
+title: "DeleteAll Alternative Implementation"
+domain: "sam-coder"
+difficulty: "advanced"
+bc_versions: "14+"
+tags: ["deleteall", "alternatives", "implementation", "patterns"]
+samples: "samples/deleteall-alternative-implementation.md"
+---
+# DeleteAll Alternative Implementation
+
+## Overview
+
+While DeleteAll provides comprehensive business logic enforcement through OnDelete trigger execution, many scenarios require alternative approaches that prioritize performance, custom logic, or specific operational requirements.
+
+**Key Consideration**: Alternative implementations trade business logic automation for performance or flexibility - this trade-off must align with specific business requirements.
+
+**Common Scenarios for Alternatives**:
+- High-performance bulk operations where trigger execution creates unacceptable delays
+- Custom business logic requirements that extend beyond standard OnDelete trigger capabilities  
+- Integration scenarios requiring specialized error handling and recovery mechanisms
+- Complex data transformation operations during deletion processes
+
+## Strategic Implementation Approaches
+
+### Direct Database Operations
+
+**SQL DELETE Operations**: Maximum performance approach bypassing all BC business logic layer processing.
+
+**Use Case Scenarios**:
+- Simple cleanup operations on isolated tables without related data dependencies
+- System maintenance operations where business rule enforcement is unnecessary
+- Temporary data removal where audit trails and logging are not required
+- Performance-critical operations where trigger execution overhead is prohibitive
+
+**Risk Assessment**:
+- Data integrity violations possible if business logic requirements are misunderstood
+- Related table orphaned data creation if cleanup logic is inadequate
+- Compliance violation potential if audit trail requirements are not properly implemented
+- Future maintenance complexity increases with custom implementation scope
+
+### Custom Deletion Procedures
+
+**Controlled Business Logic Implementation**: Selective implementation of essential business logic with performance optimization.
+
+**Design Patterns**:
+- Extract critical OnDelete trigger logic into dedicated validation procedures
+- Implement batch processing patterns for large dataset operations with progress tracking
+- Design custom error handling and recovery mechanisms for specific operational scenarios
+- Create specialized audit and logging procedures tailored to deletion operation requirements
+
+**Performance Optimization Techniques**:
+- Batch record processing to reduce database round-trip overhead
+- Optimized transaction boundary management for improved throughput
+- Progress tracking and user communication for long-running operations
+- Parallel processing implementation where business logic constraints permit
+
+### Hybrid Approaches
+
+**Selective DeleteAll Usage**: Combining DeleteAll with alternative approaches based on operation characteristics.
+
+**Conditional Logic Implementation**:
+- Use DeleteAll for small datasets where performance impact is acceptable
+- Implement custom logic for large datasets requiring performance optimization
+- Apply different strategies based on table complexity and related data relationships
+- Design fallback mechanisms for error conditions and exceptional scenarios
+
+## Implementation Framework
+
+### Requirements Analysis
+- Catalog all OnDelete trigger logic and classify by criticality to business operations
+- Identify related table relationships and cascade operation requirements
+- Assess audit trail and compliance logging requirements for deletion operations
+- Define acceptable performance thresholds for different types of deletion operations
+
+### Architecture Design
+- Design modular deletion procedure architecture supporting multiple implementation strategies
+- Implement configuration-driven approach enabling runtime selection of deletion methods
+- Create standardized interfaces for deletion operations supporting consistent error handling
+- Plan integration with existing BC business logic and validation procedures
+
+## Anti-Patterns
+
+### Business Logic Neglect
+**Dangerous Oversimplification**: Implementing alternatives without proper business logic consideration. Bypassing essential validation logic creates data integrity risks and compliance violations.
+
+### Performance Assumption Errors
+**Premature Optimization**: Implementing complex alternatives without validating DeleteAll performance limitations. Thoroughly evaluate DeleteAll performance before committing to alternative implementation effort.
+
+### Incomplete Implementation
+**Partial Logic Implementation**: Creating alternatives that inadequately replace DeleteAll functionality. Ensure alternative solutions provide equivalent functionality where business requirements demand it.
+

package/embedded-knowledge/domains/sam-coder/deleteall-method-usage.md

@@ -0,0 +1,118 @@
+---
+title: "DeleteAll Method Usage"
+domain: "sam-coder"
+difficulty: "intermediate"
+bc_versions: "14+"
+tags: ["deleteall", "data-manipulation", "triggers"]
+prerequisites: ["table-basics", "record-management"]
+samples: "samples/deleteall-usage.md"
+---
+# DeleteAll Method Usage
+
+## Overview
+
+DeleteAll is a BC method that removes all records from a table or filtered set while executing OnDelete triggers for each record. Unlike direct SQL DELETE operations, DeleteAll maintains full BC business logic compliance by triggering all associated validations and cascading operations.
+
+**Key Characteristic**: Always executes OnDelete triggers - this is fundamental BC behavior that cannot be bypassed.
+
+**Primary Use Cases**:
+- Clearing temporary data with proper cleanup
+- Bulk deletions requiring business logic validation
+- Data maintenance operations preserving referential integrity
+- Cleanup operations in test scenarios
+
+**Critical Understanding**: DeleteAll is not a performance optimization - it's a business logic preservation tool that executes triggers for every deleted record.
+
+## Strategic Framework
+
+### When DeleteAll is Appropriate
+
+**Data Integrity Scenarios**:
+- Clearing temporary tables where related data must be cleaned up
+- Removing test data while maintaining proper audit trails
+- Bulk operations where business rules must be enforced
+- Scenarios requiring cascade delete operations
+
+**Business Logic Requirements**:
+- Operations requiring OnDelete trigger execution
+- Scenarios where related table updates are necessary
+- Situations demanding proper logging and audit trail maintenance
+- Cases where validation logic must run for each deletion
+
+### When DeleteAll is Inappropriate
+
+**Performance-Critical Operations**:
+- Large dataset deletions where triggers are unnecessary
+- Bulk cleanup operations on isolated data
+- System maintenance requiring maximum speed
+- Operations on tables without significant business logic
+
+**Alternative Consideration Points**:
+- Direct SQL operations for simple, non-validated deletions
+- Batch processing approaches for very large datasets
+- Specialized cleanup procedures for system maintenance
+- Custom deletion logic for complex business scenarios
+
+## Implementation Considerations
+
+### Trigger Execution Impact
+
+**Performance Implications**:
+- Each record deletion executes full OnDelete trigger logic
+- Related table updates and validations occur for every record
+- Memory usage scales with trigger complexity and related data volume
+- Network traffic increases with extensive related table operations
+
+**Business Logic Preservation**:
+- Maintains complete data integrity across all related tables
+- Ensures proper audit trail and logging execution
+- Preserves cascade delete operations and referential integrity
+- Executes all custom business validation logic
+
+### Error Handling Strategy
+
+**Validation Failures**:
+- Any OnDelete trigger failure stops the entire DeleteAll operation
+- Partial deletions can occur if errors happen mid-process
+- Transaction boundaries depend on implementation context
+- Error recovery requires understanding of deletion state
+
+**Recovery Patterns**:
+- Implement proper transaction management around DeleteAll calls
+- Design retry logic for recoverable validation failures
+- Plan for partial completion scenarios and cleanup procedures
+- Consider logging and monitoring for deletion operation tracking
+
+## Best Practices
+
+### Effective DeleteAll Usage
+
+**Preparation Steps**:
+- Verify that OnDelete triggers contain necessary business logic
+- Ensure related data can handle the deletion operations
+- Test deletion operations in controlled environments first
+- Implement proper error handling and recovery procedures
+
+**Execution Patterns**:
+- Use appropriate filters to limit deletion scope
+- Consider batch processing for very large datasets
+- Implement progress tracking for long-running operations
+- Plan for proper transaction boundaries and commit strategies
+
+### Monitoring and Validation
+- Monitor deletion progress and performance impact
+- Validate that expected business logic executes correctly
+- Verify related table cleanup occurs as designed
+- Validate data integrity across all affected tables
+
+## Anti-Patterns
+
+### Performance Misunderstanding
+**Incorrect Assumption**: Using DeleteAll for performance optimization. DeleteAll executes triggers, making it slower than direct SQL operations.
+
+### Trigger Logic Avoidance
+**Incorrect Pattern**: Attempting to bypass OnDelete triggers with DeleteAll. DeleteAll always executes OnDelete triggers - this cannot be disabled.
+
+### Insufficient Error Handling
+**Problematic Implementation**: Assuming DeleteAll operations always succeed. Implement comprehensive error handling and recovery procedures.
+

package/embedded-knowledge/domains/sam-coder/deleteall-trigger-execution.md

@@ -0,0 +1,111 @@
+---
+title: "DeleteAll Trigger Execution"
+domain: "sam-coder"
+difficulty: "advanced"
+bc_versions: "14+"
+tags: ["deleteall", "triggers", "ondelete", "execution-flow"]
+prerequisites: ["deleteall-method-usage", "table-triggers", "transaction-management"]
+samples: "samples/deleteall-triggers.md"
+---
+# DeleteAll Trigger Execution
+
+## Overview
+
+DeleteAll method execution in BC follows a specific trigger execution pattern that ensures business logic consistency while processing bulk deletions. Understanding this execution flow is crucial for designing proper OnDelete triggers and predicting system behavior during bulk operations.
+
+**Core Behavior**: DeleteAll executes OnDelete triggers for every individual record, maintaining complete business logic enforcement at the cost of performance.
+
+**Execution Pattern**: Sequential processing of each record with full trigger execution, validation, and related table operations.
+
+## Trigger Execution Flow
+
+### Individual Record Processing
+DeleteAll processes records sequentially, executing the complete OnDelete trigger chain for each record. This ensures business logic consistency but creates performance overhead proportional to record count and trigger complexity.
+
+### Trigger Execution Sequence
+1. **Record Selection**: DeleteAll identifies records matching filter criteria
+2. **OnDelete Trigger Execution**: Full trigger logic executes for each record
+3. **Validation Processing**: All validation logic and business rules execute
+4. **Related Table Operations**: Cascade deletes and related table updates occur
+5. **Transaction Management**: Individual record operations within transaction boundaries
+
+### Business Logic Preservation
+OnDelete triggers execute with full access to record context, related data, and system state. This enables complex business logic including audit logging, cascade operations, and custom validation rules.
+
+## Performance Implications
+
+### Execution Overhead Sources
+- Individual record processing prevents batch optimization
+- OnDelete trigger execution adds computational overhead per record
+- Related table operations multiply database interactions
+- Validation logic extends processing time per record
+- Transaction management creates additional resource utilization
+
+### Scalability Characteristics
+- Linear performance degradation with record count increase
+- Multiplicative impact from complex OnDelete trigger logic
+- Network round-trip multiplication with related table operations
+- Memory usage accumulation with trigger execution complexity
+
+## Trigger Design Considerations
+
+### Performance-Conscious Trigger Design
+- Minimize database operations within OnDelete triggers
+- Use efficient queries and avoid complex calculations
+- Implement conditional logic to skip unnecessary processing
+- Consider batch operations for related table updates where possible
+
+### Business Logic Optimization
+- Separate essential validation from optional logging operations
+- Use TryFunction patterns for non-critical operations that might fail
+- Implement proper error handling to prevent cascade failures
+- Design triggers to be testable and maintainable
+
+### Related Table Management
+- Design efficient cascade delete patterns
+- Minimize related table lookups and updates
+- Use appropriate transaction boundaries for related operations
+- Consider using temporary tables for complex related data processing
+
+## Common Implementation Patterns
+
+### Audit Trail Implementation
+OnDelete triggers commonly implement audit trail logging by capturing deleted record information before removal. Design efficient logging procedures that minimize performance impact.
+
+### Cascade Delete Operations
+Related table cleanup through OnDelete triggers ensures referential integrity. Implement cascade patterns that balance completeness with performance requirements.
+
+### Validation and Business Rules
+OnDelete triggers enforce business rules during deletion operations. Design validation logic that fails fast and provides meaningful error messages.
+
+## Best Practices
+
+### Trigger Development
+- Keep OnDelete triggers focused on essential business logic
+- Avoid complex calculations or external system calls in triggers
+- Implement proper error handling and recovery mechanisms
+- Design triggers to be testable in isolation
+
+### Performance Management
+- Profile trigger execution under realistic data volumes
+- Monitor system resource utilization during DeleteAll operations
+- Implement appropriate timeout and cancellation mechanisms
+- Consider alternative approaches for performance-critical scenarios
+
+### Testing and Validation
+- Test OnDelete triggers with various record states and conditions
+- Validate trigger behavior under high-volume deletion scenarios
+- Verify proper error handling and rollback behavior
+- Test concurrent operation impact on trigger execution
+
+## Anti-Patterns
+
+### Performance-Blind Trigger Design
+**Problematic Pattern**: Implementing complex OnDelete triggers without considering DeleteAll performance impact. Complex trigger logic compounds performance overhead and can make bulk deletions prohibitively slow.
+
+### Inadequate Error Handling
+**Risk Pattern**: OnDelete triggers that fail without proper error handling can leave DeleteAll operations in inconsistent states. Implement comprehensive error handling and rollback mechanisms.
+
+### External System Dependencies
+**Dangerous Pattern**: OnDelete triggers that depend on external systems create reliability risks. External system failures can block all deletion operations and create operational problems.
+

package/embedded-knowledge/domains/sam-coder/event-bridge-pattern-al.md

@@ -0,0 +1,113 @@
+---
+title: "Event Bridge Pattern in AL"
+domain: "sam-coder"
+difficulty: "intermediate"
+bc_versions: "14+"
+tags: ["event-bridge", "event-routing", "message-patterns", "loose-coupling"]
+prerequisites: ["event-basics", "publisher-subscriber", "interface-implementation"]
+samples: "samples/event-bridge-pattern.md"
+related_topics: ["event-payload-design-patterns", "command-queue-pattern-al"]
+---
+
+# Event Bridge Pattern in AL
+
+## Overview
+
+The Event Bridge Pattern provides a centralized mechanism for routing events between different modules and systems while maintaining loose coupling. This pattern enables complex event-driven architectures where events can be transformed, filtered, and routed based on dynamic criteria.
+
+**Key Benefit**: Enables flexible event routing and transformation without direct dependencies between event producers and consumers.
+
+## Core Bridge Architecture
+
+### Central Event Hub
+Implement a central event hub that receives events from multiple sources and routes them to appropriate handlers based on routing rules and event characteristics.
+
+### Event Transformation
+Design transformation capabilities that can modify event payloads, add metadata, or convert between different event formats during routing.
+
+### Dynamic Routing Rules
+Implement configurable routing rules that determine which handlers receive specific events based on event type, content, or source characteristics.
+
+## Implementation Patterns
+
+### Bridge Interface Design
+Define clear interfaces for event producers, the bridge itself, and event consumers to ensure consistent interaction patterns.
+
+### Event Registration System
+Implement registration mechanisms where handlers can subscribe to specific event types or patterns through the bridge.
+
+### Asynchronous Processing
+Design asynchronous event processing capabilities to prevent bridge operations from blocking event producers.
+
+## Advanced Bridge Features
+
+### Event Filtering
+Implement sophisticated filtering capabilities that can route events based on complex criteria including payload content and metadata.
+
+### Multi-Protocol Support
+Design bridges that can handle events from different sources (AL events, web hooks, message queues) and route them uniformly.
+
+### Error Handling and Retry
+Implement robust error handling with retry mechanisms for failed event delivery and transformation operations.
+
+## Performance Optimization
+
+### Routing Efficiency
+Optimize event routing algorithms to minimize latency and processing overhead for high-frequency event scenarios.
+
+### Buffer Management
+Implement efficient buffering strategies for handling event bursts and managing memory usage during peak loads.
+
+### Parallel Processing
+Design parallel processing capabilities for independent event streams to maximize throughput and responsiveness.
+
+## Bridge Configuration
+
+### Rule-Based Routing
+- Configure routing rules through setup tables or configuration files
+- Support dynamic rule updates without system restarts
+- Implement rule validation and testing capabilities
+- Provide clear documentation for routing rule syntax
+
+### Handler Management
+- Enable dynamic handler registration and deregistration
+- Support handler priority and ordering specifications
+- Implement handler health monitoring and automatic failover
+- Provide handler performance metrics and diagnostics
+
+## Integration Strategies
+
+### System Boundaries
+Design bridge patterns that work effectively across system boundaries, supporting integration with external systems and services.
+
+### Protocol Translation
+Implement protocol translation capabilities that enable events to cross different communication protocols and message formats.
+
+### State Management
+Handle stateful event processing scenarios where the bridge needs to maintain context across multiple related events.
+
+## Best Practices
+
+### Design Principles
+- Keep bridge logic focused on routing and transformation
+- Implement comprehensive logging for event flow debugging
+- Use dependency injection for bridge component management
+- Design for horizontal scaling in high-volume scenarios
+
+### Monitoring and Diagnostics
+- Implement detailed event flow tracking and metrics
+- Provide debugging capabilities for routing rule troubleshooting
+- Monitor bridge performance and identify bottlenecks
+- Support event replay capabilities for testing and debugging
+
+## Common Pitfalls
+
+### Bridge Complexity
+Avoid creating overly complex bridge logic that becomes difficult to maintain and debug.
+
+### Performance Bottlenecks
+Prevent the bridge from becoming a performance bottleneck by implementing efficient routing and processing algorithms.
+
+*Complete bridge implementation: samples/event-bridge-pattern.md*
+*Event payload design: event-payload-design-patterns.md*
+*Command patterns: command-queue-pattern-al.md*