Startup Speed, Enterprise Scale | Domain-Driven Architecture

1// Example Domain Service in a bounded context
2export class OrderProcessingService {
3  constructor(
4      private readonly orderRepository: OrderRepository,
5      private readonly paymentGateway: PaymentGateway,
6      private readonly eventBus: EventBus
7  ) {}
8
9  async processOrder(orderId: string): Promise<OrderResult> {
10      // Load the order aggregate
11      const order = await this.orderRepository.findById(orderId);
12      
13      // Domain logic contained within the bounded context
14      if (order.canBeProcessed()) {
15          const paymentResult = await this.paymentGateway.processPayment(
16              order.paymentDetails
17          );
18          
19          // Update the order based on domain rules
20          order.markAsPaid(paymentResult.transactionId);
21          await this.orderRepository.save(order);
22          
23          // Publish domain events for cross-context communication
24          this.eventBus.publish(new OrderPaidEvent(order));
25          
26          return { success: true, order };
27      }
28      
29      return { success: false, reason: order.getProcessingBlockReason() };
30  }
31}

1// Module structure example (folder structure)
2/src
3  /modules
4      /ordering
5          /domain        // Core domain model, entities, value objects
6              order.ts
7              product.ts
8              price.ts
9          /application   // Application services, use cases
10              create-order.service.ts
11              process-payment.service.ts
12          /infrastructure // Technical implementations
13              order-repository.ts
14              payment-gateway.ts
15          /api           // Public API exposed to other modules
16              order-facade.ts
17              types.ts     // Public DTOs and interfaces
18          index.ts       // Public exports only

1// Event-based integration pattern
2export class OrderCompletedEvent implements DomainEvent {
3  constructor(
4      public readonly orderId: string,
5      public readonly customerId: string,
6      public readonly orderItems: ReadonlyArray<{
7          productId: string;
8          quantity: number;
9      }>,
10      public readonly totalAmount: Money
11  ) {}
12}
13
14// In the shipping module that handles this event
15@EventHandler(OrderCompletedEvent)
16export class CreateShipmentHandler {
17  constructor(private readonly shipmentService: ShipmentService) {}
18
19  async handle(event: OrderCompletedEvent): Promise<void> {
20      await this.shipmentService.createShipment({
21          orderId: event.orderId,
22          customerId: event.customerId,
23          items: event.orderItems
24      });
25  }
26}

1// Shared kernel example
2export namespace SharedKernel {
3  export interface Entity<T> {
4      equals(other: Entity<T>): boolean;
5      id: T;
6  }
7
8  export class Money {
9      constructor(
10          public readonly amount: number,
11          public readonly currency: string
12      ) {}
13
14      add(other: Money): Money {
15          if (this.currency !== other.currency) {
16              throw new Error('Cannot add money with different currencies');
17          }
18          return new Money(this.amount + other.amount, this.currency);
19      }
20      
21      // Other money operations...
22  }
23  
24  // Other shared primitives...
25}

┌─────────────────────────────────────────────────────────────┐
│                      Communication Platform                  │
│                                                             │
│  ┌───────────────┐   ┌───────────────┐   ┌───────────────┐  │
│  │ Call Management│   │ User Management│   │ Analytics     │  │
│  │                │   │                │   │               │  │
│  │ • Call routing │   │ • Auth         │   │ • Event       │  │
│  │ • Media handling│   │ • Profiles     │   │   processing  │  │
│  │ • Call state   │   │ • Permissions  │   │ • Reporting   │  │
│  └───────┬───────┘   └───────┬───────┘   └───────┬───────┘  │
│          │                   │                   │          │
│  ┌───────┴───────┐   ┌───────┴───────┐   ┌───────┴───────┐  │
│  │ CRM Integration│   │ Billing       │   │ Notification  │  │
│  │                │   │                │   │               │  │
│  │ • Adapters     │   │ • Pricing     │   │ • Email       │  │
│  │ • Sync         │   │ • Invoicing   │   │ • SMS         │  │
│  │ • Workflows    │   │ • Reporting   │   │ • Push        │  │
│  └───────────────┘   └───────────────┘   └───────────────┘  │
│                                                             │
└─────────────────────────────────────────────────────────────┘

1// eslint-enforce-modules.js
2module.exports = {
3  rules: {
4      'no-cross-module-imports': {
5          create: function (context) {
6              return {
7                  ImportDeclaration(node) {
8                      const importPath = node.source.value;
9                      const filePath = context.getFilename();
10                      
11                      // Extract current module
12                      const currentModule = extractModuleName(filePath);
13                      
14                      // Check if import crosses module boundaries incorrectly
15                      if (isCrossModuleImport(currentModule, importPath)) {
16                          // Only allow imports through public module APIs
17                          if (!isPublicModuleImport(importPath)) {
18                              context.report({
19                                  node,
20                                  message: `Import from ${importPath} violates module boundaries. Use the public API.`
21                              });
22                          }
23                      }
24                  }
25              };
26          }
27      }
28  }
29};

1// Domain event example
2export class CallConnectedEvent implements DomainEvent {
3  constructor(
4      public readonly callId: string,
5      public readonly agentId: string,
6      public readonly customerId: string,
7      public readonly timestamp: Date
8  ) {}
9}
10
11// Publisher in Call Management module
12@Injectable()
13export class CallService {
14  constructor(private eventBus: EventBus) {}
15  
16  async connectCall(callId: string, agentId: string, customerId: string): Promise<void> {
17      // Domain logic...
18      
19      // Publish event for other modules to react to
20      this.eventBus.publish(new CallConnectedEvent(
21          callId, 
22          agentId, 
23          customerId, 
24          new Date()
25      ));
26  }
27}
28
29// Subscriber in CRM Integration module
30@EventHandler(CallConnectedEvent)
31export class UpdateCrmWithCallHandler {
32  constructor(private crmService: CrmService) {}
33  
34  async handle(event: CallConnectedEvent): Promise<void> {
35      await this.crmService.logCallActivity({
36          callId: event.callId,
37          agentId: event.agentId,
38          customerId: event.customerId,
39          startTime: event.timestamp
40      });
41  }
42}

1// Shared types across all modules
2export namespace SharedKernel {
3  export interface Result<T, E = Error> {
4      isSuccess: boolean;
5      isFailure: boolean;
6      error?: E;
7      value?: T;
8  }
9
10  export class Success<T> implements Result<T> {
11      isSuccess = true;
12      isFailure = false;
13      constructor(public readonly value: T) {}
14  }
15
16  export class Failure<E> implements Result<never, E> {
17      isSuccess = false;
18      isFailure = true;
19      constructor(public readonly error: E) {}
20  }
21  
22  // Other shared utilities...
23}