@domainlang/language 0.12.0 → 0.13.0

package/src/sdk/patterns.ts

@@ -1,147 +1,185 @@
-/**
- * Integration Patterns - Type-safe constants for DDD integration patterns.
- * 
- * Use these constants instead of magic strings when checking relationship patterns.
- * 
- * @example
- * ```typescript
- * import { Pattern } from '../sdk/patterns.js';
- * 
- * // Instead of: hasPattern('SK') or hasPattern('SharedKernel')
- * // Use:
- * if (relationship.hasPattern(Pattern.SharedKernel)) {
- *     // ...
- * }
- * ```
- */
+import type { SidePattern, SymmetricPattern } from '../generated/ast.js';
+import {
+    isOpenHostService,
+    isPublishedLanguage,
+    isConformist,
+    isAntiCorruptionLayer,
+    isSupplier,
+    isCustomer,
+    isBigBallOfMud,
+    isSharedKernel,
+    isPartnership,
+    isSeparateWays,
+} from '../generated/ast.js';
 
 /**
- * Integration pattern abbreviations as used in the grammar.
- * These are the canonical abbreviations recognized by DomainLang.
+ * Pattern constants for programmatic use.
+ * Values match the AST $type names.
  */
 export const Pattern = {
-    // Upstream patterns (provider side)
-    /** Open Host Service - exposes a clean API for consumers */
-    OHS: 'OHS',
-    /** Published Language - shared data format/protocol */
-    PL: 'PL',
-    
-    // Downstream patterns (consumer side)
-    /** Conformist - accepts upstream model without translation */
-    CF: 'CF',
-    /** Anti-Corruption Layer - translates upstream model */
-    ACL: 'ACL',
-    
-    // Mutual patterns (both sides)
-    /** Shared Kernel - shared code/model ownership */
-    SK: 'SK',
-    /** Partnership - coordinated development */
-    P: 'P',
-    
-    // Relationship types
-    /** Customer/Supplier - negotiated contract */
-    CustomerSupplier: 'Customer/Supplier',
-    /** Separate Ways - no integration */
-    SeparateWays: 'Separate Ways',
-    /** Big Ball of Mud - legacy or unstructured */
-    BigBallOfMud: 'Big Ball of Mud',
+    // Side patterns (directional)
+    OHS: 'OpenHostService',
+    PL: 'PublishedLanguage',
+    CF: 'Conformist',
+    ACL: 'AntiCorruptionLayer',
+    S: 'Supplier',
+    C: 'Customer',
+    BBoM: 'BigBallOfMud',
+    // Symmetric patterns
+    SK: 'SharedKernel',
+    P: 'Partnership',
+    SW: 'SeparateWays',
 } as const;
 
 /**
- * Full names for integration patterns.
- * Used when patterns are spelled out in documentation blocks.
+ * Mapping from short abbreviation to full $type name.
  */
-export const PatternFullName = {
+export const PatternFullName: Record<string, string> = {
     OHS: 'OpenHostService',
     PL: 'PublishedLanguage',
     CF: 'Conformist',
     ACL: 'AntiCorruptionLayer',
+    S: 'Supplier',
+    C: 'Customer',
+    BBoM: 'BigBallOfMud',
     SK: 'SharedKernel',
     P: 'Partnership',
-} as const;
+    SW: 'SeparateWays',
+};
+
+/**
+ * Mapping from $type name to short abbreviation.
+ */
+export const PatternAbbreviation: Record<string, string> = {
+    OpenHostService: 'OHS',
+    PublishedLanguage: 'PL',
+    Conformist: 'CF',
+    AntiCorruptionLayer: 'ACL',
+    Supplier: 'S',
+    Customer: 'C',
+    BigBallOfMud: 'BBoM',
+    SharedKernel: 'SK',
+    Partnership: 'P',
+    SeparateWays: 'SW',
+};
 
 /**
- * Mapping from abbreviations to full names and vice versa.
+ * All short+long forms that map to a given canonical $type name.
  */
 export const PatternAliases: Record<string, readonly string[]> = {
-    // Abbreviation -> [abbreviation, fullName]
     OHS: ['OHS', 'OpenHostService'],
     PL: ['PL', 'PublishedLanguage'],
     CF: ['CF', 'Conformist'],
     ACL: ['ACL', 'AntiCorruptionLayer'],
+    S: ['S', 'Supplier'],
+    C: ['C', 'Customer'],
+    BBoM: ['BBoM', 'BigBallOfMud'],
     SK: ['SK', 'SharedKernel'],
     P: ['P', 'Partnership'],
-    
-    // Full names map to same
+    SW: ['SW', 'SeparateWays'],
     OpenHostService: ['OHS', 'OpenHostService'],
     PublishedLanguage: ['PL', 'PublishedLanguage'],
     Conformist: ['CF', 'Conformist'],
     AntiCorruptionLayer: ['ACL', 'AntiCorruptionLayer'],
+    Supplier: ['S', 'Supplier'],
+    Customer: ['C', 'Customer'],
+    BigBallOfMud: ['BBoM', 'BigBallOfMud'],
     SharedKernel: ['SK', 'SharedKernel'],
     Partnership: ['P', 'Partnership'],
+    SeparateWays: ['SW', 'SeparateWays'],
 };
 
-/**
- * Type representing any valid integration pattern (abbreviation or full name).
- */
-export type IntegrationPattern = 
-    | typeof Pattern[keyof typeof Pattern]
-    | typeof PatternFullName[keyof typeof PatternFullName];
+/** Union of all pattern type names */
+export type IntegrationPattern = typeof Pattern[keyof typeof Pattern];
 
 /**
- * Checks if a pattern string matches any of the expected aliases.
- * Handles both abbreviations and full names case-insensitively.
- * 
- * @param actual - Pattern string from the AST
- * @param expected - Pattern to match (abbreviation or full name)
- * @returns true if patterns match
+ * Checks if a pattern name matches an expected pattern.
+ * Works with both $type names and short abbreviations.
  */
 export function matchesPattern(actual: string, expected: string): boolean {
     const normalizedActual = actual.trim();
     const aliases = PatternAliases[expected];
-    
     if (aliases) {
         return aliases.some(alias => 
             alias.toLowerCase() === normalizedActual.toLowerCase()
         );
     }
-    
-    // Fallback: direct comparison
     return normalizedActual.toLowerCase() === expected.toLowerCase();
 }
 
+/** Side patterns that belong on the upstream side */
+export const UpstreamPatterns: readonly string[] = ['OpenHostService', 'PublishedLanguage', 'Supplier'];
+/** Side patterns that belong on the downstream side */
+export const DownstreamPatterns: readonly string[] = ['Conformist', 'AntiCorruptionLayer', 'Customer'];
+/** Symmetric patterns (mutual) */
+export const SymmetricPatterns: readonly string[] = ['SharedKernel', 'Partnership', 'SeparateWays'];
+
 /**
- * Patterns that are typically on the upstream (provider) side.
+ * Checks if a side pattern AST node is an upstream pattern. 
  */
-export const UpstreamPatterns: readonly string[] = ['OHS', 'OpenHostService', 'PL', 'PublishedLanguage'];
+export function isUpstreamSidePattern(pattern: SidePattern): boolean {
+    return isOpenHostService(pattern) || isPublishedLanguage(pattern) || isSupplier(pattern);
+}
 
 /**
- * Patterns that are typically on the downstream (consumer) side.
+ * Checks if a side pattern AST node is a downstream pattern.
  */
-export const DownstreamPatterns: readonly string[] = ['CF', 'Conformist', 'ACL', 'AntiCorruptionLayer'];
+export function isDownstreamSidePattern(pattern: SidePattern): boolean {
+    return isConformist(pattern) || isAntiCorruptionLayer(pattern) || isCustomer(pattern);
+}
 
 /**
- * Patterns that require mutual/bidirectional relationships.
+ * Checks if a side pattern AST node is a Big Ball of Mud.
  */
-export const MutualPatterns: readonly string[] = ['SK', 'SharedKernel', 'P', 'Partnership'];
+export function isBBoMSidePattern(pattern: SidePattern): boolean {
+    return isBigBallOfMud(pattern);
+}
 
 /**
- * Checks if a pattern is typically an upstream pattern.
+ * Checks if a pattern string name is an upstream pattern.
  */
 export function isUpstreamPattern(pattern: string): boolean {
     return UpstreamPatterns.some(p => matchesPattern(pattern, p));
 }
 
 /**
- * Checks if a pattern is typically a downstream pattern.
+ * Checks if a pattern string name is a downstream pattern.
  */
 export function isDownstreamPattern(pattern: string): boolean {
     return DownstreamPatterns.some(p => matchesPattern(pattern, p));
 }
 
 /**
- * Checks if a pattern requires bidirectional relationships.
+ * Checks if a pattern string name is a mutual/symmetric pattern.
  */
 export function isMutualPattern(pattern: string): boolean {
-    return MutualPatterns.some(p => matchesPattern(pattern, p));
+    return SymmetricPatterns.some(p => matchesPattern(pattern, p));
+}
+
+/**
+ * Gets the short abbreviation for a pattern $type name.
+ */
+export function getPatternAbbreviation(typeName: string): string {
+    return PatternAbbreviation[typeName] ?? typeName;
+}
+
+/**
+ * Checks if a symmetric pattern is a Shared Kernel.
+ */
+export function isSharedKernelPattern(pattern: SymmetricPattern): boolean {
+    return isSharedKernel(pattern);
+}
+
+/**
+ * Checks if a symmetric pattern is a Partnership.
+ */
+export function isPartnershipPattern(pattern: SymmetricPattern): boolean {
+    return isPartnership(pattern);
+}
+
+/**
+ * Checks if a symmetric pattern is Separate Ways.
+ */
+export function isSeparateWaysPattern(pattern: SymmetricPattern): boolean {
+    return isSeparateWays(pattern);
 }

package/src/sdk/query.ts

@@ -21,12 +21,16 @@ import {
     isBoundedContext,
     isClassification,
     isContextMap,
+    isDirectionalRelationship,
     isDomain,
     isDomainMap,
     isModel,
     isNamespaceDeclaration,
+    isSymmetricRelationship,
     isTeam,
     isThisRef,
+    isSupplier,
+    isCustomer,
 } from '../generated/ast.js';
 import { QualifiedNameProvider } from '../lsp/domain-lang-naming.js';
 import type { DomainLangServices } from '../domain-lang-module.js';
@@ -39,6 +43,7 @@ import {
 import { isDownstreamPattern, isUpstreamPattern, matchesPattern } from './patterns.js';
 import type {
     BcQueryBuilder,
+    DirectionalKind,
     ModelIndexes,
     Query,
     QueryBuilder,
@@ -331,14 +336,39 @@ class QueryImpl implements Query {
             return undefined;
         }
 
+        if (isSymmetricRelationship(rel)) {
+            // Grammar invariant: either `arrow === '><'` (SeparateWays shorthand, pattern undefined)
+            // OR `pattern` is set (explicit [SK]/[P]/[SW] brackets). Never both; never neither
+            // (validation rejects a bare "A B" without pattern or arrow).
+            // The fallback to 'SeparateWays' correctly handles the `><` case.
+            return {
+                type: 'symmetric' as const,
+                kind: (rel.pattern?.$type ?? 'SeparateWays') as 'SharedKernel' | 'Partnership' | 'SeparateWays',
+                left: { context: left, patterns: [] },
+                right: { context: right, patterns: [] },
+                source,
+                astNode: rel,
+            };
+        }
+
+        const arrow = rel.arrow as '->' | '<-' | '<->';
+        const leftSide = { context: left, patterns: rel.leftPatterns };
+        const rightSide = { context: right, patterns: rel.rightPatterns };
+        const hasSupplier = rel.leftPatterns.some(isSupplier) || rel.rightPatterns.some(isSupplier);
+        const hasCustomer = rel.leftPatterns.some(isCustomer) || rel.rightPatterns.some(isCustomer);
+        const kind: DirectionalKind = arrow === '<->'
+            ? 'Bidirectional'
+            : (hasSupplier || hasCustomer) ? 'CustomerSupplier' : 'UpstreamDownstream';
+        const upstreamSide = arrow === '->' ? leftSide : arrow === '<-' ? rightSide : undefined;
+        const downstreamSide = arrow === '->' ? rightSide : arrow === '<-' ? leftSide : undefined;
         return {
-            left,
-            right,
-            arrow: rel.arrow,
-            leftPatterns: rel.leftPatterns,
-            rightPatterns: rel.rightPatterns,
-            type: rel.type,
-            inferredType: this.inferRelationshipType(rel),
+            type: 'directional' as const,
+            kind,
+            arrow,
+            left: leftSide,
+            right: rightSide,
+            upstream: upstreamSide,
+            downstream: downstreamSide,
             source,
             astNode: rel,
         };
@@ -358,41 +388,6 @@ class QueryImpl implements Query {
         return ref.link?.ref;
     }
 
-    /**
-     * Infers relationship type from integration patterns.
-     * Simple heuristic based on common DDD pattern combinations.
-     */
-    private inferRelationshipType(rel: Relationship): string | undefined {
-        const leftPatterns = rel.leftPatterns;
-        const rightPatterns = rel.rightPatterns;
-
-        // Partnership: Bidirectional with P or SK
-        if (rel.arrow === '<->' && (leftPatterns.includes('P') || leftPatterns.includes('SK'))) {
-            return 'Partnership';
-        }
-
-        // Shared Kernel: SK pattern
-        if (leftPatterns.includes('SK') || rightPatterns.includes('SK')) {
-            return 'SharedKernel';
-        }
-
-        // Customer-Supplier: OHS + CF
-        if (leftPatterns.includes('OHS') && rightPatterns.includes('CF')) {
-            return 'CustomerSupplier';
-        }
-
-        // Upstream-Downstream: directional arrow
-        if (rel.arrow === '->') {
-            return 'UpstreamDownstream';
-        }
-
-        // Separate Ways
-        if (rel.arrow === '><') {
-            return 'SeparateWays';
-        }
-
-        return undefined;
-    }
 }
 
 /**
@@ -726,38 +721,52 @@ export function augmentRelationship(rel: Relationship, containingBc?: BoundedCon
         // Helper methods for pattern matching (type-safe, no magic strings)
         hasPattern: {
             value: (pattern: string): boolean => {
-                return rel.leftPatterns.some(p => matchesPattern(p, pattern)) ||
-                       rel.rightPatterns.some(p => matchesPattern(p, pattern));
+                if (isDirectionalRelationship(rel)) {
+                    return rel.leftPatterns.some(p => matchesPattern(p.$type, pattern)) ||
+                           rel.rightPatterns.some(p => matchesPattern(p.$type, pattern));
+                }
+                if (isSymmetricRelationship(rel) && rel.pattern) {
+                    return matchesPattern(rel.pattern.$type, pattern);
+                }
+                return false;
             },
             enumerable: false,
             configurable: true,
         },
         hasLeftPattern: {
             value: (pattern: string): boolean => {
-                return rel.leftPatterns.some(p => matchesPattern(p, pattern));
+                if (isDirectionalRelationship(rel)) {
+                    return rel.leftPatterns.some(p => matchesPattern(p.$type, pattern));
+                }
+                return false;
             },
             enumerable: false,
             configurable: true,
         },
         hasRightPattern: {
             value: (pattern: string): boolean => {
-                return rel.rightPatterns.some(p => matchesPattern(p, pattern));
+                if (isDirectionalRelationship(rel)) {
+                    return rel.rightPatterns.some(p => matchesPattern(p.$type, pattern));
+                }
+                return false;
             },
             enumerable: false,
             configurable: true,
         },
         isUpstream: {
             value: (side: 'left' | 'right'): boolean => {
+                if (!isDirectionalRelationship(rel)) return false;
                 const patterns = side === 'left' ? rel.leftPatterns : rel.rightPatterns;
-                return patterns.some(p => isUpstreamPattern(p));
+                return patterns.some(p => isUpstreamPattern(p.$type));
             },
             enumerable: false,
             configurable: true,
         },
         isDownstream: {
             value: (side: 'left' | 'right'): boolean => {
+                if (!isDirectionalRelationship(rel)) return false;
                 const patterns = side === 'left' ? rel.leftPatterns : rel.rightPatterns;
-                return patterns.some(p => isDownstreamPattern(p));
+                return patterns.some(p => isDownstreamPattern(p.$type));
             },
             enumerable: false,
             configurable: true,

package/src/sdk/serializers.ts

@@ -165,18 +165,31 @@ export function serializeNode(node: AstNode, query: Query): Record<string, unkno
  * @returns Serialized relationship object
  */
 export function serializeRelationship(view: RelationshipView): Record<string, unknown> {
-    // RelationshipView.left and .right are BoundedContext (which have name property)
-    const leftName = view.left.name;
-    const rightName = view.right.name;
+    const leftName = view.left.context.name;
+    const rightName = view.right.context.name;
+    if (view.type === 'symmetric') {
+        const patternDisplay = view.kind === 'SeparateWays' ? '><' : `[${view.kind}]`;
+        return {
+            type: 'symmetric',
+            name: `${leftName} ${patternDisplay} ${rightName}`,
+            left: leftName,
+            right: rightName,
+            kind: view.kind,
+            source: view.source,
+        };
+    }
     return {
-        $type: 'Relationship',
+        type: 'directional',
+        kind: view.kind,
         name: `${leftName} ${view.arrow} ${rightName}`,
         left: leftName,
         right: rightName,
         arrow: view.arrow,
-        leftPatterns: view.leftPatterns,
-        rightPatterns: view.rightPatterns,
-        inferredType: view.inferredType,
+        leftPatterns: view.left.patterns.map(p => p.$type),
+        rightPatterns: view.right.patterns.map(p => p.$type),
+        upstreamPatterns: view.upstream?.patterns.map(p => p.$type),
+        downstreamPatterns: view.downstream?.patterns.map(p => p.$type),
+        source: view.source,
     };
 }
 

package/src/sdk/types.ts

@@ -13,6 +13,7 @@ import type {
     Model,
     NamespaceDeclaration,
     Relationship,
+    SidePattern,
     Team,
 } from '../generated/ast.js';
 import type { DomainLangServices } from '../domain-lang-module.js';
@@ -281,30 +282,104 @@ export interface BcQueryBuilder extends QueryBuilder<BoundedContext> {
 }
 
 /**
- * Unified view of a relationship between two BoundedContexts.
- * Relationships can be defined in BoundedContext blocks or ContextMap.
+ * One side of a relationship: the bounded context and its annotated integration patterns.
+ * For symmetric relationships `patterns` is always empty — the pattern lives on the relationship itself.
+ */
+export interface RelationshipSide {
+    /** The bounded context on this side */
+    readonly context: BoundedContext;
+    /** Integration patterns annotated on this side (directional relationships only) */
+    readonly patterns: readonly SidePattern[];
+}
+
+/**
+ * DDD kind of a directional relationship.
+ * Fully discriminates all three structural cases.
+ */
+export type DirectionalKind = 'UpstreamDownstream' | 'CustomerSupplier' | 'Bidirectional';
+
+/**
+ * Directional relationship: has an arrow expressing dependency between two contexts.
+ * Discriminate on `type` to access directional or symmetric properties.
+ * Discriminate on `kind` to handle upstream/downstream vs customer/supplier vs bidirectional.
  */
-export interface RelationshipView {
-    /** Left-hand side BoundedContext */
-    readonly left: BoundedContext;
-    /** Right-hand side BoundedContext */
-    readonly right: BoundedContext;
-    /** Relationship direction arrow */
-    readonly arrow: '->' | '<-' | '<->' | '><';
-    /** Integration patterns on left side (e.g., ['OHS', 'PL']) */
-    readonly leftPatterns: readonly string[];
-    /** Integration patterns on right side (e.g., ['CF', 'ACL']) */
-    readonly rightPatterns: readonly string[];
-    /** Explicit relationship type if specified */
-    readonly type?: string;
-    /** SDK-inferred relationship type based on patterns */
-    readonly inferredType?: string;
+export interface DirectionalRelationshipView {
+    readonly type: 'directional';
+    /** DDD semantic kind — determines which roles each side plays */
+    readonly kind: DirectionalKind;
+    /** Arrow as written in source (use for display/serialization) */
+    readonly arrow: '->' | '<-' | '<->';
+    /** Left side as written in source — always defined */
+    readonly left: RelationshipSide;
+    /** Right side as written in source — always defined */
+    readonly right: RelationshipSide;
+    /**
+     * The upstream (provider) side with its patterns.
+     * Defined when `kind` is `'UpstreamDownstream'` or `'CustomerSupplier'`.
+     * `undefined` when `kind` is `'Bidirectional'` — no upstream role exists.
+     */
+    readonly upstream: RelationshipSide | undefined;
+    /**
+     * The downstream (consumer) side with its patterns.
+     * Defined when `kind` is `'UpstreamDownstream'` or `'CustomerSupplier'`.
+     * `undefined` when `kind` is `'Bidirectional'` — no downstream role exists.
+     */
+    readonly downstream: RelationshipSide | undefined;
     /** Source of the relationship definition */
     readonly source: 'BoundedContext' | 'ContextMap';
     /** Original AST relationship node */
     readonly astNode: Relationship;
 }
 
+/** Resolved symmetric integration pattern kind. */
+export type SymmetricKind = 'SharedKernel' | 'Partnership' | 'SeparateWays';
+
+/**
+ * Symmetric relationship: no arrow; neither context is upstream or downstream.
+ * Discriminate on `type` to access directional or symmetric properties.
+ */
+export interface SymmetricRelationshipView {
+    readonly type: 'symmetric';
+    /**
+     * Always-resolved symmetric integration pattern.
+     * `><` resolves to `'SeparateWays'`.
+     */
+    readonly kind: SymmetricKind;
+    /**
+     * Left side as written in source.
+     * `patterns` is always empty — symmetric patterns attach to the relationship, not each side.
+     */
+    readonly left: RelationshipSide;
+    /**
+     * Right side as written in source.
+     * `patterns` is always empty — symmetric patterns attach to the relationship, not each side.
+     */
+    readonly right: RelationshipSide;
+    /** Source of the relationship definition */
+    readonly source: 'BoundedContext' | 'ContextMap';
+    /** Original AST relationship node */
+    readonly astNode: Relationship;
+}
+
+/**
+ * Unified view of a relationship between two BoundedContexts.
+ * Relationships can be defined in BoundedContext blocks or ContextMap.
+ * Discriminate on `type` to access directional or symmetric properties.
+ *
+ * @example
+ * ```typescript
+ * for (const rel of query.relationships()) {
+ *   if (rel.type === 'symmetric') {
+ *     console.log(rel.kind); // 'SharedKernel' | 'Partnership' | 'SeparateWays'
+ *   } else {
+ *     console.log(rel.kind);  // 'UpstreamDownstream' | 'CustomerSupplier' | 'Bidirectional'
+ *     console.log(rel.arrow); // '->' | '<-' | '<->'
+ *   }
+ * }
+ * ```
+ */
+export type RelationshipView = DirectionalRelationshipView | SymmetricRelationshipView;
+
 /**
  * Internal index structure for O(1) lookups.
  * Not exported from public API.