@domainlang/language 0.11.0 → 0.13.0

package/src/validation/maps.ts

@@ -1,6 +1,6 @@
 import type { ValidationAcceptor } from 'langium';
 import type { ContextMap, DomainMap, Relationship, BoundedContextRef } from '../generated/ast.js';
-import { isThisRef } from '../generated/ast.js';
+import { isDirectionalRelationship, isSymmetricRelationship, isThisRef } from '../generated/ast.js';
 import { ValidationMessages, buildCodeDescription, IssueCodes } from './constants.js';
 
 /**
@@ -139,9 +139,17 @@ function getRefKey(ref: BoundedContextRef): string {
 function buildRelationshipKey(rel: Relationship): string {
     const left = getRefKey(rel.left);
     const right = getRefKey(rel.right);
-    const leftPatterns = (rel.leftPatterns ?? []).slice().sort((a, b) => a.localeCompare(b)).join(',');
-    const rightPatterns = (rel.rightPatterns ?? []).slice().sort((a, b) => a.localeCompare(b)).join(',');
-    return `[${leftPatterns}]${left}${rel.arrow}[${rightPatterns}]${right}`;
+    const arrow = rel.arrow ?? '';
+
+    if (isDirectionalRelationship(rel)) {
+        const leftPatterns = rel.leftPatterns.map(p => p.$type).sort().join(',');
+        const rightPatterns = rel.rightPatterns.map(p => p.$type).sort().join(',');
+        return `[${leftPatterns}]${left}${arrow}[${rightPatterns}]${right}`;
+    }
+
+    // Symmetric relationship
+    const pattern = isSymmetricRelationship(rel) && rel.pattern ? rel.pattern.$type : '';
+    return `[${pattern}]${left}${arrow}${right}`;
 }
 
 /**

package/src/validation/relationships.ts

@@ -1,11 +1,17 @@
 import type { ValidationAcceptor } from 'langium';
-import type { Relationship, BoundedContextRef } from '../generated/ast.js';
-import { isThisRef } from '../generated/ast.js';
+import type { BoundedContextRef, Relationship } from '../generated/ast.js';
+import { 
+    isThisRef, 
+    isDirectionalRelationship,
+    isSymmetricRelationship,
+    isAntiCorruptionLayer,
+    isConformist,
+    isOpenHostService,
+    isSupplier,
+    isCustomer,
+} from '../generated/ast.js';
 import { ValidationMessages, buildCodeDescription } from './constants.js';
 
-/**
- * Gets a display name for a BoundedContextRef (handles 'this' and regular refs).
- */
 function getContextName(ref: BoundedContextRef): string {
     if (isThisRef(ref)) {
         return 'this';
@@ -14,54 +20,19 @@ function getContextName(ref: BoundedContextRef): string {
 }
 
 /**
- * Validates that SharedKernel patterns use bidirectional relationships.
- * SharedKernel implies mutual dependency and shared code ownership.
- * 
- * @param relationship - The relationship to validate
- * @param accept - The validation acceptor for reporting issues
- */
-function validateSharedKernelBidirectional(
-    relationship: Relationship,
-    accept: ValidationAcceptor
-): void {
-    // Check if SharedKernel pattern exists on either side
-    const hasSharedKernelLeft = relationship.leftPatterns?.some(
-        pattern => pattern === 'SK' || pattern === 'SharedKernel'
-    );
-    const hasSharedKernelRight = relationship.rightPatterns?.some(
-        pattern => pattern === 'SK' || pattern === 'SharedKernel'
-    );
-    
-    if ((hasSharedKernelLeft || hasSharedKernelRight) && relationship.arrow !== '<->') {
-        const leftName = getContextName(relationship.left);
-        const rightName = getContextName(relationship.right);
-        
-        accept('warning', 
-            ValidationMessages.SHARED_KERNEL_MUST_BE_BIDIRECTIONAL(leftName, rightName, relationship.arrow),
-            { node: relationship, property: 'arrow', codeDescription: buildCodeDescription('language.md', 'integration-patterns') }
-        );
-    }
-}
-
-/**
- * Validates that Anti-Corruption Layer (ACL) is on the consuming side.
- * ACL protects downstream context from upstream changes.
- * 
- * @param relationship - The relationship to validate
- * @param accept - The validation acceptor for reporting issues
+ * Validates that ACL is on the downstream (consuming) side.
+ * ACL on upstream side of -> is a warning. ACL on upstream side of <- is also a warning.
  */
 function validateACLPlacement(
     relationship: Relationship,
     accept: ValidationAcceptor
 ): void {
-    const hasACLLeft = relationship.leftPatterns?.some(
-        pattern => pattern === 'ACL' || pattern === 'AntiCorruptionLayer'
-    );
-    const hasACLRight = relationship.rightPatterns?.some(
-        pattern => pattern === 'ACL' || pattern === 'AntiCorruptionLayer'
-    );
+    if (!isDirectionalRelationship(relationship)) return;
+
+    const hasACLLeft = relationship.leftPatterns.some(isAntiCorruptionLayer);
+    const hasACLRight = relationship.rightPatterns.some(isAntiCorruptionLayer);
     
-    // ACL on left side with -> arrow means upstream has ACL (incorrect)
+    // For ->, left is upstream. ACL on upstream side is wrong.
     if (hasACLLeft && relationship.arrow === '->') {
         const leftName = getContextName(relationship.left);
         accept('warning',
@@ -70,7 +41,7 @@ function validateACLPlacement(
         );
     }
     
-    // ACL on right side with <- arrow means upstream has ACL (incorrect)
+    // For <-, right is upstream. ACL on upstream side is wrong.
     if (hasACLRight && relationship.arrow === '<-') {
         const rightName = getContextName(relationship.right);
         accept('warning',
@@ -81,24 +52,17 @@ function validateACLPlacement(
 }
 
 /**
- * Validates that Conformist pattern is on the consuming side.
- * Conformist means accepting upstream model without translation.
- * 
- * @param relationship - The relationship to validate
- * @param accept - The validation acceptor for reporting issues
+ * Validates that CF is on the downstream (consuming) side.
  */
 function validateConformistPlacement(
     relationship: Relationship,
     accept: ValidationAcceptor
 ): void {
-    const hasCFLeft = relationship.leftPatterns?.some(
-        pattern => pattern === 'CF' || pattern === 'Conformist'
-    );
-    const hasCFRight = relationship.rightPatterns?.some(
-        pattern => pattern === 'CF' || pattern === 'Conformist'
-    );
+    if (!isDirectionalRelationship(relationship)) return;
+
+    const hasCFLeft = relationship.leftPatterns.some(isConformist);
+    const hasCFRight = relationship.rightPatterns.some(isConformist);
     
-    // CF on left side with -> arrow means upstream is conformist (incorrect)
     if (hasCFLeft && relationship.arrow === '->') {
         const leftName = getContextName(relationship.left);
         accept('warning',
@@ -107,7 +71,6 @@ function validateConformistPlacement(
         );
     }
     
-    // CF on right side with <- arrow means upstream is conformist (incorrect)
     if (hasCFRight && relationship.arrow === '<-') {
         const rightName = getContextName(relationship.right);
         accept('warning',
@@ -118,18 +81,107 @@ function validateConformistPlacement(
 }
 
 /**
- * Validates that relationships don't have too many integration patterns.
- * More than 3 patterns on one side suggests syntax confusion.
- * 
- * @param relationship - The relationship to validate
- * @param accept - The validation acceptor for reporting issues
+ * Validates that OHS is on the upstream (providing) side.
+ */
+function validateOHSPlacement(
+    relationship: Relationship,
+    accept: ValidationAcceptor
+): void {
+    if (!isDirectionalRelationship(relationship)) return;
+
+    // For ->, right is downstream. OHS on downstream side is wrong.
+    const hasOHSRight = relationship.rightPatterns.some(isOpenHostService);
+    if (hasOHSRight && relationship.arrow === '->') {
+        const rightName = getContextName(relationship.right);
+        accept('warning',
+            ValidationMessages.OHS_ON_WRONG_SIDE(rightName, 'right'),
+            { node: relationship, property: 'rightPatterns', codeDescription: buildCodeDescription('language.md', 'integration-patterns') }
+        );
+    }
+
+    // For <-, left is downstream. OHS on downstream side is wrong.
+    const hasOHSLeft = relationship.leftPatterns.some(isOpenHostService);
+    if (hasOHSLeft && relationship.arrow === '<-') {
+        const leftName = getContextName(relationship.left);
+        accept('warning',
+            ValidationMessages.OHS_ON_WRONG_SIDE(leftName, 'left'),
+            { node: relationship, property: 'leftPatterns', codeDescription: buildCodeDescription('language.md', 'integration-patterns') }
+        );
+    }
+}
+
+/**
+ * Validates that Supplier is on the upstream side and Customer is on the downstream side.
+ * These are errors, not warnings — S/C have fixed placement.
+ */
+function validateCustomerSupplierPlacement(
+    relationship: Relationship,
+    accept: ValidationAcceptor
+): void {
+    if (!isDirectionalRelationship(relationship)) return;
+
+    // For ->, left is upstream, right is downstream
+    // Supplier must be upstream, Customer must be downstream
+    if (relationship.arrow === '->') {
+        if (relationship.rightPatterns.some(isSupplier)) {
+            accept('error',
+                ValidationMessages.SUPPLIER_ON_WRONG_SIDE(getContextName(relationship.right), 'right'),
+                { node: relationship, property: 'rightPatterns', codeDescription: buildCodeDescription('language.md', 'integration-patterns') }
+            );
+        }
+        if (relationship.leftPatterns.some(isCustomer)) {
+            accept('error',
+                ValidationMessages.CUSTOMER_ON_WRONG_SIDE(getContextName(relationship.left), 'left'),
+                { node: relationship, property: 'leftPatterns', codeDescription: buildCodeDescription('language.md', 'integration-patterns') }
+            );
+        }
+    }
+
+    // For <-, right is upstream, left is downstream
+    if (relationship.arrow === '<-') {
+        if (relationship.leftPatterns.some(isSupplier)) {
+            accept('error',
+                ValidationMessages.SUPPLIER_ON_WRONG_SIDE(getContextName(relationship.left), 'left'),
+                { node: relationship, property: 'leftPatterns', codeDescription: buildCodeDescription('language.md', 'integration-patterns') }
+            );
+        }
+        if (relationship.rightPatterns.some(isCustomer)) {
+            accept('error',
+                ValidationMessages.CUSTOMER_ON_WRONG_SIDE(getContextName(relationship.right), 'right'),
+                { node: relationship, property: 'rightPatterns', codeDescription: buildCodeDescription('language.md', 'integration-patterns') }
+            );
+        }
+    }
+
+    // <-> is bidirectional — Customer/Supplier is inherently directional and must not appear on a <-> arrow
+    if (relationship.arrow === '<->') {
+        const allPatterns = [...relationship.leftPatterns, ...relationship.rightPatterns];
+        if (allPatterns.some(isSupplier)) {
+            accept('error',
+                'Supplier [S] cannot be used on a bidirectional (<->) relationship — Customer/Supplier is inherently directional.',
+                { node: relationship, property: relationship.leftPatterns.some(isSupplier) ? 'leftPatterns' : 'rightPatterns', codeDescription: buildCodeDescription('language.md', 'integration-patterns') }
+            );
+        }
+        if (allPatterns.some(isCustomer)) {
+            accept('error',
+                'Customer [C] cannot be used on a bidirectional (<->) relationship — Customer/Supplier is inherently directional.',
+                { node: relationship, property: relationship.leftPatterns.some(isCustomer) ? 'leftPatterns' : 'rightPatterns', codeDescription: buildCodeDescription('language.md', 'integration-patterns') }
+            );
+        }
+    }
+}
+
+/**
+ * Validates pattern count per side (info if > 3).
  */
 function validatePatternCount(
     relationship: Relationship,
     accept: ValidationAcceptor
 ): void {
-    const leftCount = relationship.leftPatterns?.length ?? 0;
-    const rightCount = relationship.rightPatterns?.length ?? 0;
+    if (!isDirectionalRelationship(relationship)) return;
+    
+    const leftCount = relationship.leftPatterns.length;
+    const rightCount = relationship.rightPatterns.length;
     
     if (leftCount > 3) {
         accept('info',
@@ -146,9 +198,36 @@ function validatePatternCount(
     }
 }
 
-export const relationshipChecks = [
-    validateSharedKernelBidirectional,
+/**
+ * Validates that symmetric relationships with self-reference produce a warning.
+ */
+function validateSelfSymmetric(
+    relationship: Relationship,
+    accept: ValidationAcceptor
+): void {
+    if (!isSymmetricRelationship(relationship)) return;
+
+    const leftName = getContextName(relationship.left);
+    const rightName = getContextName(relationship.right);
+    
+    if (leftName === rightName) {
+        accept('warning',
+            ValidationMessages.SELF_SYMMETRIC_RELATIONSHIP(leftName),
+            { node: relationship, codeDescription: buildCodeDescription('language.md', 'integration-patterns') }
+        );
+    }
+}
+
+/**
+ * All relationship validation checks.
+ * Each function receives a Relationship (DirectionalRelationship | SymmetricRelationship)
+ * and guards internally for the correct subtype.
+ */
+export const relationshipChecks: Array<(relationship: Relationship, accept: ValidationAcceptor) => void> = [
     validateACLPlacement,
     validateConformistPlacement,
-    validatePatternCount
+    validateOHSPlacement,
+    validateCustomerSupplierPlacement,
+    validatePatternCount,
+    validateSelfSymmetric,
 ];