@fornari-lanza/domain-design-language-language 0.0.1

package/src/domain-design-language-validator.ts

@@ -0,0 +1,699 @@
+import type { AstNode, ValidationAcceptor, ValidationChecks } from 'langium';
+import {
+  AggregateRoot,
+  Command,
+  AsymmetricRelationship,
+  BoundedContext,
+  DomainEvent,
+  DomainEventsDeclaration,
+  DomainModel,
+  DomainService,
+  Entity,
+  Enum,
+  EventStormingDeclaration,
+  isActor,
+  isAggregateRoot,
+  isAsymmetricRelationship,
+  isExternalSystem,
+  isPolicyTrigger,
+  //isPortReferenceDependency,
+  isProjection,
+  isReadModel,
+  isSymmetricRelationship,
+  isValueObject,
+  Payload,
+  PolicyTrigger,
+  ProcessFlow,
+  ReactionStep,
+  Relationship,
+  UbiquitousLanguageDeclaration,
+  ValueObject,
+  type ContextMap,
+  type DomainDesignLanguageAstType,
+  MethodsDeclaration,
+  Method,
+  isMethod,
+  ExceptionsDeclaration,
+} from './generated/ast.js';
+import type { DomainDesignLanguageServices } from './domain-design-language-module.js';
+
+/**
+ * Register custom validation checks.
+ */
+export function registerValidationChecks(
+  services: DomainDesignLanguageServices,
+) {
+  const registry = services.validation.ValidationRegistry;
+  const validator = services.validation.DomainDesignLanguageValidator;
+  const checks: ValidationChecks<DomainDesignLanguageAstType> = {
+    DomainModel: validator.checkUniquePurpose,
+    BoundedContext: [
+      validator.checkUniqueAggregates,
+      validator.checkUniqueDomainServices,
+      validator.checkUniquePorts,
+      validator.checkUniqueCommands,
+      validator.checkNameStartsWithCapital,
+    ],
+    UbiquitousLanguageDeclaration: validator.checkUniqueTerms,
+    Term: validator.checkNameStartsWithCapital,
+    ContextMap: validator.checkUniqueRelationships,
+    Relationship: validator.checkSelfRelationships,
+    AsymmetricRelationship: validator.checkRelationshipRoles,
+    AggregateRoot: [
+      validator.checkNameStartsWithCapital,
+      validator.checkUniqueAttributes,
+    ],
+    ValueObject: [
+      validator.checkNameStartsWithCapital,
+      validator.checkUniquePrimitiveAttributes,
+    ],
+    Entity: [
+      validator.checkNameStartsWithCapital,
+      validator.checkUniqueAttributes,
+    ],
+    DomainEvent: [
+      validator.checkNameStartsWithCapital,
+      validator.checkNameIsInPastTense,
+    ],
+    DomainService: [
+      validator.checkNameStartsWithCapital,
+      validator.checkUniqueDtoAttributes,
+    ],
+    Method: [
+      validator.checkUniqueDtoAttributes,
+      validator.checkNameIsCamelCase,
+    ],
+    DomainException: validator.checkNameStartsWithCapital,
+    Payload: validator.checkUniquePrimitiveAttributes,
+    MethodsDeclaration: validator.checkUniqueMethods,
+    ExceptionsDeclaration: validator.checkUniqueExceptions,
+    DomainEventsDeclaration: validator.checkUniqueDomainEvents,
+    Port: validator.checkNameStartsWithCapital,
+    Command: [
+      validator.checkNameStartsWithCapital,
+      validator.checkUniqueDtoAttributes,
+      validator.checkUniqueCommandElements,
+    ],
+    Enum: validator.checkUniqueValues,
+    EventStormingElement: validator.checkNameStartsWithCapital,
+    Policy: validator.checkNameStartsWithCapital,
+    ProcessFlow: [
+      validator.checkNameStartsWithCapital,
+      validator.checkUniquePolicies,
+    ],
+    EventStormingDeclaration: validator.checkUniqueEventStormingElements,
+    ReactionStep: validator.checkUniqueOutcomes,
+  };
+  registry.register(checks, validator);
+}
+
+/**
+ * Implementation of custom validations.
+ */
+export class DomainDesignLanguageValidator {
+  checkUniquePurpose(model: DomainModel, accept: ValidationAcceptor): void {
+    if (model.boundedContext && model.contextMap)
+      accept(
+        'error',
+        'A file cannot contain both a Bounded Context and a Context Map. Please move the Context Map to a separate file.',
+        {
+          node: model.contextMap,
+        },
+      );
+  }
+
+  checkUniqueTerms(
+    ubiquitousLanguage: UbiquitousLanguageDeclaration,
+    accept: ValidationAcceptor,
+  ): void {
+    const terms = new Set<string>();
+    ubiquitousLanguage.terms.forEach((term) => {
+      if (terms.has(term.name))
+        accept(
+          'error',
+          `Repeated term name '${term.name}' in bounded context '${ubiquitousLanguage.$container.name}'.`,
+          {
+            node: term,
+            property: 'name',
+          },
+        );
+      terms.add(term.name);
+    });
+  }
+
+  checkUniqueAggregates(
+    boundedContext: BoundedContext,
+    accept: ValidationAcceptor,
+  ): void {
+    const aggregates = new Set<string>();
+    boundedContext.aggregates.forEach((aggregate) => {
+      if (aggregates.has(aggregate.name))
+        accept(
+          'error',
+          `Repeated aggregate root name '${aggregate.name}' in bounded context '${boundedContext.name}'.`,
+          {
+            node: aggregate,
+            property: 'name',
+          },
+        );
+      aggregates.add(aggregate.name);
+    });
+  }
+
+  checkUniqueDomainServices(
+    boundedContext: BoundedContext,
+    accept: ValidationAcceptor,
+  ): void {
+    const domainServices = new Set<string>();
+    boundedContext.domainServices.forEach((domainService) => {
+      if (domainServices.has(domainService.name))
+        accept(
+          'error',
+          `Repeated domain service name '${domainService.name}' in bounded context '${boundedContext.name}'.`,
+          {
+            node: domainService,
+            property: 'name',
+          },
+        );
+      domainServices.add(domainService.name);
+    });
+  }
+
+  checkUniquePorts(
+    boundedContext: BoundedContext,
+    accept: ValidationAcceptor,
+  ): void {
+    const ports = new Set<string>();
+    boundedContext.ports.forEach((port) => {
+      if (ports.has(port.name))
+        accept(
+          'error',
+          `Repeated port name '${port.name}' in bounded context '${boundedContext.name}'.`,
+          {
+            node: port,
+            property: 'name',
+          },
+        );
+      ports.add(port.name);
+    });
+  }
+
+  checkUniqueCommands(
+    boundedContext: BoundedContext,
+    accept: ValidationAcceptor,
+  ): void {
+    const commands = new Set<string>();
+    boundedContext.commands.forEach((command) => {
+      if (commands.has(command.name))
+        accept(
+          'error',
+          `Repeated command name '${command.name}' in bounded context '${boundedContext.name}'.`,
+          {
+            node: command,
+            property: 'name',
+          },
+        );
+      commands.add(command.name);
+    });
+  }
+
+  checkUniqueEventStormingElements(
+    eventStormingDeclaration: EventStormingDeclaration,
+    accept: ValidationAcceptor,
+  ): void {
+    const actors = new Set<string>();
+    const readModels = new Set<string>();
+    const externalSystems = new Set<string>();
+    eventStormingDeclaration.elements.forEach((element) => {
+      if (isActor(element)) {
+        if (actors.has(element.name))
+          accept(
+            'error',
+            `Repeated actor name '${element.name}' in event storming.`,
+            {
+              node: element,
+              property: 'name',
+            },
+          );
+        actors.add(element.name);
+      } else if (isReadModel(element)) {
+        if (readModels.has(element.name))
+          accept(
+            'error',
+            `Repeated read model name '${element.name}' in event storming.`,
+            {
+              node: element,
+              property: 'name',
+            },
+          );
+        readModels.add(element.name);
+      } else if (isExternalSystem(element)) {
+        if (externalSystems.has(element.name))
+          accept(
+            'error',
+            `Repeated external system name '${element.name}' in event storming.`,
+            {
+              node: element,
+              property: 'name',
+            },
+          );
+        externalSystems.add(element.name);
+      }
+    });
+    const processFlows = new Set<string>();
+    eventStormingDeclaration.flows.forEach((processFlow) => {
+      if (processFlows.has(processFlow.name))
+        accept(
+          'error',
+          `Repeated process flow name '${processFlow.name}' in event storming.`,
+          {
+            node: processFlow,
+            property: 'name',
+          },
+        );
+      processFlows.add(processFlow.name);
+    });
+  }
+
+  checkUniquePolicies(
+    processFlow: ProcessFlow,
+    accept: ValidationAcceptor,
+  ): void {
+    const policies = new Set<string>();
+    const outcomes: PolicyTrigger[] = processFlow.reactions.flatMap((step) =>
+      step.outcomes.filter(isPolicyTrigger),
+    );
+    outcomes.forEach((outcome) => {
+      if (outcome.policy.name && policies.has(outcome.policy.name))
+        accept(
+          'error',
+          `Repeated policy '${outcome.policy.name}' in process flow.`,
+          {
+            node: outcome,
+            property: 'policy',
+          },
+        );
+      policies.add(outcome.policy?.name || '');
+    });
+  }
+
+  checkUniqueOutcomes(step: ReactionStep, accept: ValidationAcceptor): void {
+    const readModels = new Set<string>();
+    const policies = new Set<string>();
+    step.outcomes.forEach((outcome) => {
+      if (isProjection(outcome)) {
+        if (
+          outcome.readModel.ref?.name &&
+          readModels.has(outcome.readModel.ref?.name)
+        )
+          accept(
+            'error',
+            `Repeated read model '${outcome.readModel.ref?.name}' projection in 'on' definition.`,
+            {
+              node: outcome,
+              property: 'readModel',
+            },
+          );
+        readModels.add(outcome.readModel?.ref?.name || '');
+      } else if (isPolicyTrigger(outcome)) {
+        if (outcome.policy.name && policies.has(outcome.policy.name))
+          accept(
+            'error',
+            `Repeated policy '${outcome.policy.name}' in 'on' definition.`,
+            {
+              node: outcome,
+              property: 'policy',
+            },
+          );
+        policies.add(outcome.policy?.name || '');
+      }
+    });
+  }
+
+  checkUniqueDomainEvents(
+    declaration: DomainEventsDeclaration,
+    accept: ValidationAcceptor,
+  ): void {
+    const names = new Set<string>();
+    declaration.events.forEach((event) => {
+      if (names.has(event.name)) {
+        accept(
+          'error',
+          `Repeated event name '${event.name}' in aggregate ${declaration.$container.name}.`,
+          {
+            node: event,
+            property: 'name',
+          },
+        );
+      }
+      names.add(event.name);
+    });
+  }
+
+  checkUniqueMethods(
+    declaration: MethodsDeclaration,
+    accept: ValidationAcceptor,
+  ): void {
+    const names = new Set<string>();
+    declaration.methods.forEach((method) => {
+      if (names.has(method.name)) {
+        accept(
+          'error',
+          `Repeated method name '${method.name}' in aggregate ${declaration.$container.name}.`,
+          {
+            node: method,
+            property: 'name',
+          },
+        );
+      }
+      names.add(method.name);
+    });
+  }
+
+  checkUniqueExceptions(
+    declaration: ExceptionsDeclaration,
+    accept: ValidationAcceptor,
+  ): void {
+    const names = new Set<string>();
+    declaration.exceptions.forEach((exception) => {
+      if (names.has(exception.name)) {
+        accept(
+          'error',
+          `Repeated exception name '${exception.name}' in aggregate ${declaration.$container.name}.`,
+          {
+            node: exception,
+            property: 'name',
+          },
+        );
+      }
+      names.add(exception.name);
+    });
+  }
+
+  checkUniqueAttributes(
+    entity: Entity | AggregateRoot,
+    accept: ValidationAcceptor,
+  ): void {
+    const attributes = new Set<string>();
+    entity.attributes.forEach((attribute) => {
+      if (attributes.has(attribute.type.name)) {
+        accept(
+          'error',
+          `Repeated attribute name '${attribute.type.name}' in ${
+            isAggregateRoot(entity) ? 'aggregate root' : 'entity'
+          } '${entity.name}'.`,
+          {
+            node: attribute.type,
+            property: 'name',
+          },
+        );
+      }
+      attributes.add(attribute.type.name);
+    });
+  }
+
+  checkUniquePrimitiveAttributes(
+    node: ValueObject | Payload,
+    accept: ValidationAcceptor,
+  ): void {
+    const attributes = new Set<string>();
+    node.attributes.forEach((attribute) => {
+      if (attributes.has(attribute.name)) {
+        accept(
+          'error',
+          `Repeated attribute name '${attribute.name}' in ${
+            isValueObject(node) ? 'value object' : 'payload'
+          }${isValueObject(node) ? ` '${node.name}'.` : '.'}`,
+          {
+            node: attribute,
+            property: 'name',
+          },
+        );
+      }
+      attributes.add(attribute.name);
+    });
+  }
+
+  checkUniqueDtoAttributes(
+    service: DomainService | Command | Method,
+    accept: ValidationAcceptor,
+  ): void {
+    let attributes = new Set<string>();
+    service.input?.attributes.forEach((input) => {
+      if (attributes.has(input.name)) {
+        accept(
+          'error',
+          `Repeated attribute name '${input.name}' in input object of ${isMethod(service) ? 'method' : 'service'} '${service.name}'.`,
+          {
+            node: input,
+            property: 'name',
+          },
+        );
+      }
+      attributes.add(input.name);
+    });
+  }
+
+  checkUniqueCommandElements(
+    service: Command,
+    accept: ValidationAcceptor,
+  ): void {
+    const events = new Set<string>();
+    service.events.forEach((event, index) => {
+      if (event.ref?.name && events.has(event.ref.name)) {
+        accept(
+          'error',
+          `Repeated event '${event.ref.name}' in emit declaration of command '${service.name}'.`,
+          {
+            node: service,
+            property: 'events',
+            index,
+          },
+        );
+      }
+      events.add(event.ref?.name ?? '');
+    });
+    const domainServices = new Set<string>();
+    service.domainServices.forEach((domainService, index) => {
+      if (
+        domainService.ref?.name &&
+        domainServices.has(domainService.ref.name)
+      ) {
+        accept(
+          'error',
+          `Repeated domain service '${domainService.ref.name}' in use declaration of command '${service.name}'.`,
+          {
+            node: service,
+            property: 'domainServices',
+            index,
+          },
+        );
+      }
+      domainServices.add(domainService.ref?.name ?? '');
+    });
+    //const repositories = new Set<string>();
+    const ports = new Set<string>();
+    service.dependencies.forEach((dependency) => {
+      if (dependency.port.ref) {
+        if (ports.has(dependency.port.ref.name))
+          accept(
+            'error',
+            `Repeated port '${dependency.port.ref.name}' in dependencies of service '${service.name}'.`,
+            {
+              node: dependency,
+              property: 'port',
+            },
+          );
+        ports.add(dependency.port.ref.name);
+      }
+      /* if (isPortReferenceDependency(dependency)) {
+        if (dependency.port.ref) {
+          if (ports.has(dependency.port.ref.name))
+            accept(
+              'error',
+              `Repeated port '${dependency.port.ref.name}' in dependencies of service '${service.name}'.`,
+              {
+                node: dependency,
+                property: 'port',
+              },
+            );
+          ports.add(dependency.port.ref.name);
+        }
+      } */ /* else {
+        if (dependency.aggregate.ref) {
+          if (repositories.has(dependency.aggregate.ref.name))
+            accept(
+              'error',
+              `Repeated repository of aggregate root '${dependency.aggregate.ref.name}' in dependencies of service '${service.name}'.`,
+              {
+                node: dependency,
+                property: 'aggregate',
+              },
+            );
+          repositories.add(dependency.aggregate.ref.name);
+        }
+      } */
+    });
+  }
+
+  checkUniqueRelationships(
+    contextMap: ContextMap,
+    accept: ValidationAcceptor,
+  ): void {
+    const registeredRelationships = new Set<string[]>();
+    contextMap.relationships.forEach((relationship) => {
+      let boundedContext1: string | undefined;
+      let boundedContext2: string | undefined;
+      if (isAsymmetricRelationship(relationship)) {
+        boundedContext1 = relationship.upstream?.ref?.name;
+        boundedContext2 = relationship.downstream?.ref?.name;
+      }
+      if (isSymmetricRelationship(relationship)) {
+        boundedContext1 = relationship.participant1?.ref?.name;
+        boundedContext2 = relationship.participant2?.ref?.name;
+      }
+      if (!boundedContext1 || !boundedContext2) return;
+      registeredRelationships.forEach((rel) => {
+        if (
+          (rel[0] === boundedContext1 && rel[1] === boundedContext2) ||
+          (rel[0] === boundedContext2 && rel[1] === boundedContext1)
+        ) {
+          accept(
+            'error',
+            `Repeated relationship between '${boundedContext1}' and '${boundedContext2}' in context map.`,
+            {
+              node: relationship,
+            },
+          );
+        }
+      });
+      registeredRelationships.add([boundedContext1, boundedContext2]);
+    });
+  }
+
+  checkSelfRelationships(
+    relationship: Relationship,
+    accept: ValidationAcceptor,
+  ): void {
+    let boundedContext1: string | undefined;
+    let boundedContext2: string | undefined;
+    if (isAsymmetricRelationship(relationship)) {
+      boundedContext1 = relationship.upstream?.ref?.name;
+      boundedContext2 = relationship.downstream?.ref?.name;
+    }
+    if (isSymmetricRelationship(relationship)) {
+      boundedContext1 = relationship.participant1?.ref?.name;
+      boundedContext2 = relationship.participant2?.ref?.name;
+    }
+    if (boundedContext1 && boundedContext2) {
+      if (boundedContext1 === boundedContext2) {
+        accept('error', 'Self-referential relationships are not allowed.', {
+          node: relationship,
+        });
+      }
+    }
+  }
+
+  checkRelationshipRoles(
+    relationship: AsymmetricRelationship,
+    accept: ValidationAcceptor,
+  ): void {
+    if (relationship.customerSupplier) {
+      if (relationship.downstreamRole === 'Conformist')
+        accept(
+          'error',
+          'Cannot have a Conformist role in a customer/supplier relationship.',
+          {
+            node: relationship,
+            property: 'downstreamRole',
+          },
+        );
+      else if (relationship.downstreamRole === 'AntiCorruptionLayer')
+        accept(
+          'warning',
+          'Anti-Corruption Layer pattern should not be used in a customer/supplier relationship.',
+          {
+            node: relationship,
+            property: 'downstreamRole',
+          },
+        );
+      if (relationship.upstreamRoles.includes('OpenHostService')) {
+        accept(
+          'error',
+          'Cannot have an Open Host Service role in a customer/supplier relationship.',
+          {
+            node: relationship,
+            property: 'upstreamRoles',
+            index: relationship.upstreamRoles.indexOf('OpenHostService'),
+          },
+        );
+      }
+    }
+    if (
+      relationship.upstreamRoles?.[0] &&
+      relationship.upstreamRoles?.[0] === relationship.upstreamRoles?.[1]
+    ) {
+      accept('error', 'Cannot have repeated roles.', {
+        node: relationship,
+        property: 'upstreamRoles',
+        index: 1,
+      });
+    }
+  }
+
+  checkUniqueValues(enumDefinition: Enum, accept: ValidationAcceptor): void {
+    const literals = new Set<string>();
+    enumDefinition.values.forEach((value) => {
+      if (literals.has(value)) {
+        accept('error', `Duplicate value found: ${value}`, {
+          node: enumDefinition,
+          property: 'values',
+          index: Array.from(literals).indexOf(value),
+        });
+      }
+      literals.add(value);
+    });
+  }
+
+  checkNameIsInPastTense(event: DomainEvent, accept: ValidationAcceptor): void {
+    if (event.name) {
+      const lastTwoChars = event.name.slice(-2);
+      if (lastTwoChars !== 'ed') {
+        accept('hint', 'Check if the name is in past tense.', {
+          node: event,
+          property: 'name',
+        });
+      }
+    }
+  }
+
+  checkNameStartsWithCapital(
+    node: AstNode & { name?: string },
+    accept: ValidationAcceptor,
+  ): void {
+    if (node.name) {
+      const firstChar = node.name.substring(0, 1);
+      if (firstChar.toUpperCase() !== firstChar) {
+        accept('warning', 'The name should start with a capital letter.', {
+          node: node,
+          property: 'name',
+        });
+      }
+    }
+  }
+
+  checkNameIsCamelCase(
+    node: AstNode & { name?: string },
+    accept: ValidationAcceptor,
+  ): void {
+    if (node.name) {
+      const firstChar = node.name.substring(0, 1);
+      if (firstChar.toLowerCase() !== firstChar) {
+        accept('warning', 'The name should start with a lowercase letter.', {
+          node: node,
+          property: 'name',
+        });
+      }
+    }
+  }
+}