@domainlang/language 0.12.0 → 0.13.0

package/src/generated/ast.ts

@@ -30,11 +30,12 @@ export type DomainLangKeywordNames =
     | "BBoM"
     | "BigBallOfMud"
     | "BoundedContext"
+    | "C"
     | "CF"
     | "Classification"
     | "Conformist"
     | "ContextMap"
-    | "CustomerSupplier"
+    | "Customer"
     | "Decision"
     | "Domain"
     | "DomainMap"
@@ -49,12 +50,14 @@ export type DomainLangKeywordNames =
     | "Policy"
     | "PublishedLanguage"
     | "Rule"
+    | "S"
     | "SK"
+    | "SW"
     | "SeparateWays"
     | "SharedKernel"
+    | "Supplier"
     | "Team"
     | "Term"
-    | "UpstreamDownstream"
     | "["
     | "]"
     | "aka"
@@ -114,6 +117,24 @@ export function isAbstractDecision(item: unknown): item is AbstractDecision {
     return reflection.isInstance(item, AbstractDecision.$type);
 }
 
+/**
+ * DDD Side Patterns - describe one side's role in a directional relationship.
+ * Each pattern produces a distinct AST node type via {infer} actions.
+ * Short and long forms parse to the same node type.
+ */
+export interface AntiCorruptionLayer extends langium.AstNode {
+    readonly $container: DirectionalRelationship;
+    readonly $type: 'AntiCorruptionLayer';
+}
+
+export const AntiCorruptionLayer = {
+    $type: 'AntiCorruptionLayer'
+} as const;
+
+export function isAntiCorruptionLayer(item: unknown): item is AntiCorruptionLayer {
+    return reflection.isInstance(item, AntiCorruptionLayer.$type);
+}
+
 /**
  * Assignment operators - flexible syntax.
  */
@@ -123,6 +144,24 @@ export function isAssignment(item: unknown): item is Assignment {
     return item === ':' || item === 'is' || item === '=';
 }
 
+/**
+ * DDD Side Patterns - describe one side's role in a directional relationship.
+ * Each pattern produces a distinct AST node type via {infer} actions.
+ * Short and long forms parse to the same node type.
+ */
+export interface BigBallOfMud extends langium.AstNode {
+    readonly $container: DirectionalRelationship;
+    readonly $type: 'BigBallOfMud';
+}
+
+export const BigBallOfMud = {
+    $type: 'BigBallOfMud'
+} as const;
+
+export function isBigBallOfMud(item: unknown): item is BigBallOfMud {
+    return reflection.isInstance(item, BigBallOfMud.$type);
+}
+
 /**
  * Bounded Context - A boundary within which a domain model is defined.
  * Central pattern in DDD for managing complexity and team boundaries.
@@ -228,6 +267,24 @@ export function isClassification(item: unknown): item is Classification {
     return reflection.isInstance(item, Classification.$type);
 }
 
+/**
+ * DDD Side Patterns - describe one side's role in a directional relationship.
+ * Each pattern produces a distinct AST node type via {infer} actions.
+ * Short and long forms parse to the same node type.
+ */
+export interface Conformist extends langium.AstNode {
+    readonly $container: DirectionalRelationship;
+    readonly $type: 'Conformist';
+}
+
+export const Conformist = {
+    $type: 'Conformist'
+} as const;
+
+export function isConformist(item: unknown): item is Conformist {
+    return reflection.isInstance(item, Conformist.$type);
+}
+
 export type Container = Model | NamespaceDeclaration;
 
 export const Container = {
@@ -263,6 +320,24 @@ export function isContextMap(item: unknown): item is ContextMap {
     return reflection.isInstance(item, ContextMap.$type);
 }
 
+/**
+ * DDD Side Patterns - describe one side's role in a directional relationship.
+ * Each pattern produces a distinct AST node type via {infer} actions.
+ * Short and long forms parse to the same node type.
+ */
+export interface Customer extends langium.AstNode {
+    readonly $container: DirectionalRelationship;
+    readonly $type: 'Customer';
+}
+
+export const Customer = {
+    $type: 'Customer'
+} as const;
+
+export function isCustomer(item: unknown): item is Customer {
+    return reflection.isInstance(item, Customer.$type);
+}
+
 export interface Decision extends langium.AstNode {
     readonly $container: BoundedContext;
     readonly $type: 'Assignment' | 'Decision';
@@ -282,6 +357,52 @@ export function isDecision(item: unknown): item is Decision {
     return reflection.isInstance(item, Decision.$type);
 }
 
+/**
+ * Directional relationship arrows.
+ * 
+ * Arrow semantics:
+ *   ->   Upstream to downstream (left provides, right consumes)
+ *   <-   Downstream to upstream (right provides, left consumes)
+ *   <->  Bidirectional (mutual data flow with explicit patterns)
+ */
+export type DirectionalArrow = '->' | '<-' | '<->';
+
+export function isDirectionalArrow(item: unknown): item is DirectionalArrow {
+    return item === '<->' || item === '->' || item === '<-';
+}
+
+/**
+ * Directional relationship - upstream/downstream with optional side patterns.
+ * 
+ * Examples:
+ *   Orders [OHS] -> [CF] Payments
+ *   Orders [S] -> [C] Payments
+ *   Orders -> Payments
+ *   Orders [OHS] <-> [CF] Payments
+ */
+export interface DirectionalRelationship extends langium.AstNode {
+    readonly $container: BoundedContext | ContextMap;
+    readonly $type: 'DirectionalRelationship';
+    arrow: DirectionalArrow;
+    left: BoundedContextRef;
+    leftPatterns: Array<SidePattern>;
+    right: BoundedContextRef;
+    rightPatterns: Array<SidePattern>;
+}
+
+export const DirectionalRelationship = {
+    $type: 'DirectionalRelationship',
+    arrow: 'arrow',
+    left: 'left',
+    leftPatterns: 'leftPatterns',
+    right: 'right',
+    rightPatterns: 'rightPatterns'
+} as const;
+
+export function isDirectionalRelationship(item: unknown): item is DirectionalRelationship {
+    return reflection.isInstance(item, DirectionalRelationship.$type);
+}
+
 /**
  * Domain - A sphere of knowledge or activity in DDD.
  * Can be nested via `in` to show subdomain hierarchy.
@@ -393,15 +514,6 @@ export function isImportStatement(item: unknown): item is ImportStatement {
     return reflection.isInstance(item, ImportStatement.$type);
 }
 
-/**
- * DDD Integration Patterns (used in relationships).
- */
-export type IntegrationPattern = 'ACL' | 'AntiCorruptionLayer' | 'BBoM' | 'BigBallOfMud' | 'CF' | 'Conformist' | 'OHS' | 'OpenHostService' | 'P' | 'PL' | 'Partnership' | 'PublishedLanguage' | 'SK' | 'SharedKernel';
-
-export function isIntegrationPattern(item: unknown): item is IntegrationPattern {
-    return item === 'PL' || item === 'PublishedLanguage' || item === 'OHS' || item === 'OpenHostService' || item === 'CF' || item === 'Conformist' || item === 'ACL' || item === 'AntiCorruptionLayer' || item === 'P' || item === 'Partnership' || item === 'SK' || item === 'SharedKernel' || item === 'BBoM' || item === 'BigBallOfMud';
-}
-
 /**
  * Metadata - Defines a key that can be used in metadata blocks.
  * Examples: Language, Framework, Database, Repository.
@@ -497,6 +609,41 @@ export function isObjectMap(item: unknown): item is ObjectMap {
     return reflection.isInstance(item, ObjectMap.$type);
 }
 
+/**
+ * DDD Side Patterns - describe one side's role in a directional relationship.
+ * Each pattern produces a distinct AST node type via {infer} actions.
+ * Short and long forms parse to the same node type.
+ */
+export interface OpenHostService extends langium.AstNode {
+    readonly $container: DirectionalRelationship;
+    readonly $type: 'OpenHostService';
+}
+
+export const OpenHostService = {
+    $type: 'OpenHostService'
+} as const;
+
+export function isOpenHostService(item: unknown): item is OpenHostService {
+    return reflection.isInstance(item, OpenHostService.$type);
+}
+
+/**
+ * DDD Symmetric Patterns - describe the relationship between two contexts.
+ * These are mutual/shared patterns, not directional.
+ */
+export interface Partnership extends langium.AstNode {
+    readonly $container: SymmetricRelationship;
+    readonly $type: 'Partnership';
+}
+
+export const Partnership = {
+    $type: 'Partnership'
+} as const;
+
+export function isPartnership(item: unknown): item is Partnership {
+    return reflection.isInstance(item, Partnership.$type);
+}
+
 export interface Policy extends langium.AstNode {
     readonly $container: BoundedContext;
     readonly $type: 'Assignment' | 'Policy';
@@ -516,6 +663,24 @@ export function isPolicy(item: unknown): item is Policy {
     return reflection.isInstance(item, Policy.$type);
 }
 
+/**
+ * DDD Side Patterns - describe one side's role in a directional relationship.
+ * Each pattern produces a distinct AST node type via {infer} actions.
+ * Short and long forms parse to the same node type.
+ */
+export interface PublishedLanguage extends langium.AstNode {
+    readonly $container: DirectionalRelationship;
+    readonly $type: 'PublishedLanguage';
+}
+
+export const PublishedLanguage = {
+    $type: 'PublishedLanguage'
+} as const;
+
+export function isPublishedLanguage(item: unknown): item is PublishedLanguage {
+    return reflection.isInstance(item, PublishedLanguage.$type);
+}
+
 /**
  * Qualified Name - Hierarchical namespacing with dots.
  */
@@ -527,29 +692,20 @@ export function isQualifiedName(item: unknown): item is QualifiedName {
 
 /**
  * Relationship - Connection between two Bounded Contexts.
- * Supports DDD integration patterns (ACL, OHS, PL, etc.) and relationship types.
+ * Uses entity–relationship–entity structure where the relationship expression
+ * (type, arrow, side annotations) sits between the two entity references.
+ * 
+ * Forms:
+ *   Directional: Orders [OHS] -> [CF] Payments
+ *   Symmetric:   CardManagement [SK] AccountManagement
+ *   Separate Ways arrow: Orders >< Payments
  * 
  * [Read more on domainlang.net](https://domainlang.net/reference/language#relationships)
  */
-export interface Relationship extends langium.AstNode {
-    readonly $container: BoundedContext | ContextMap;
-    readonly $type: 'Assignment' | 'Relationship';
-    arrow: RelationshipArrow;
-    left: BoundedContextRef;
-    leftPatterns: Array<IntegrationPattern>;
-    right: BoundedContextRef;
-    rightPatterns: Array<IntegrationPattern>;
-    type?: RelationshipType;
-}
+export type Relationship = DirectionalRelationship | SymmetricRelationship;
 
 export const Relationship = {
-    $type: 'Relationship',
-    arrow: 'arrow',
-    left: 'left',
-    leftPatterns: 'leftPatterns',
-    right: 'right',
-    rightPatterns: 'rightPatterns',
-    type: 'type'
+    $type: 'Relationship'
 } as const;
 
 export function isRelationship(item: unknown): item is Relationship {
@@ -557,27 +713,52 @@ export function isRelationship(item: unknown): item is Relationship {
 }
 
 /**
- * Relationship arrows - symbolic and named types.
- * 
- * Arrow semantics:
- *   ->   Upstream to downstream (left provides, right consumes)
- *   <-   Downstream to upstream (right provides, left consumes)
- *   <->  Bidirectional/Partnership (mutual dependency)
- *   ><   Separate Ways (no integration, teams go their own way)
+ * DDD Symmetric Patterns - describe the relationship between two contexts.
+ * These are mutual/shared patterns, not directional.
  */
-export type RelationshipArrow = '->' | '<-' | '<->' | '><';
+export interface SeparateWays extends langium.AstNode {
+    readonly $container: SymmetricRelationship;
+    readonly $type: 'SeparateWays';
+}
+
+export const SeparateWays = {
+    $type: 'SeparateWays'
+} as const;
+
+export function isSeparateWays(item: unknown): item is SeparateWays {
+    return reflection.isInstance(item, SeparateWays.$type);
+}
+
+/**
+ * DDD Symmetric Patterns - describe the relationship between two contexts.
+ * These are mutual/shared patterns, not directional.
+ */
+export interface SharedKernel extends langium.AstNode {
+    readonly $container: SymmetricRelationship;
+    readonly $type: 'SharedKernel';
+}
+
+export const SharedKernel = {
+    $type: 'SharedKernel'
+} as const;
 
-export function isRelationshipArrow(item: unknown): item is RelationshipArrow {
-    return item === '<->' || item === '->' || item === '<-' || item === '><';
+export function isSharedKernel(item: unknown): item is SharedKernel {
+    return reflection.isInstance(item, SharedKernel.$type);
 }
 
 /**
- * DDD Relationship Types.
+ * DDD Side Patterns - describe one side's role in a directional relationship.
+ * Each pattern produces a distinct AST node type via {infer} actions.
+ * Short and long forms parse to the same node type.
  */
-export type RelationshipType = 'CustomerSupplier' | 'Partnership' | 'SeparateWays' | 'SharedKernel' | 'UpstreamDownstream';
+export type SidePattern = AntiCorruptionLayer | BigBallOfMud | Conformist | Customer | OpenHostService | PublishedLanguage | Supplier;
+
+export const SidePattern = {
+    $type: 'SidePattern'
+} as const;
 
-export function isRelationshipType(item: unknown): item is RelationshipType {
-    return item === 'Partnership' || item === 'SharedKernel' || item === 'CustomerSupplier' || item === 'UpstreamDownstream' || item === 'SeparateWays';
+export function isSidePattern(item: unknown): item is SidePattern {
+    return reflection.isInstance(item, SidePattern.$type);
 }
 
 /**
@@ -594,6 +775,68 @@ export function isStructureElement(item: unknown): item is StructureElement {
     return reflection.isInstance(item, StructureElement.$type);
 }
 
+/**
+ * DDD Side Patterns - describe one side's role in a directional relationship.
+ * Each pattern produces a distinct AST node type via {infer} actions.
+ * Short and long forms parse to the same node type.
+ */
+export interface Supplier extends langium.AstNode {
+    readonly $container: DirectionalRelationship;
+    readonly $type: 'Supplier';
+}
+
+export const Supplier = {
+    $type: 'Supplier'
+} as const;
+
+export function isSupplier(item: unknown): item is Supplier {
+    return reflection.isInstance(item, Supplier.$type);
+}
+
+/**
+ * DDD Symmetric Patterns - describe the relationship between two contexts.
+ * These are mutual/shared patterns, not directional.
+ */
+export type SymmetricPattern = Partnership | SeparateWays | SharedKernel;
+
+export const SymmetricPattern = {
+    $type: 'SymmetricPattern'
+} as const;
+
+export function isSymmetricPattern(item: unknown): item is SymmetricPattern {
+    return reflection.isInstance(item, SymmetricPattern.$type);
+}
+
+/**
+ * Symmetric relationship - mutual pattern between two contexts, no directionality.
+ * 
+ * Examples:
+ *   CardManagement [SK] AccountManagement
+ *   Orders [P] Payments
+ *   Orders >< Payments
+ *   Orders [SW] Payments
+ */
+export interface SymmetricRelationship extends langium.AstNode {
+    readonly $container: BoundedContext | ContextMap;
+    readonly $type: 'SymmetricRelationship';
+    arrow?: '><';
+    left: BoundedContextRef;
+    pattern?: SymmetricPattern;
+    right: BoundedContextRef;
+}
+
+export const SymmetricRelationship = {
+    $type: 'SymmetricRelationship',
+    arrow: 'arrow',
+    left: 'left',
+    pattern: 'pattern',
+    right: 'right'
+} as const;
+
+export function isSymmetricRelationship(item: unknown): item is SymmetricRelationship {
+    return reflection.isInstance(item, SymmetricRelationship.$type);
+}
+
 /**
  * Team - People responsible for a Bounded Context or Domain.
  * Represents organizational boundaries in DDD.
@@ -646,13 +889,18 @@ export function isType(item: unknown): item is Type {
 
 export type DomainLangAstType = {
     AbstractDecision: AbstractDecision
+    AntiCorruptionLayer: AntiCorruptionLayer
+    BigBallOfMud: BigBallOfMud
     BoundedContext: BoundedContext
     BoundedContextRef: BoundedContextRef
     BusinessRule: BusinessRule
     Classification: Classification
+    Conformist: Conformist
     Container: Container
     ContextMap: ContextMap
+    Customer: Customer
     Decision: Decision
+    DirectionalRelationship: DirectionalRelationship
     Domain: Domain
     DomainMap: DomainMap
     DomainTerm: DomainTerm
@@ -662,9 +910,18 @@ export type DomainLangAstType = {
     Model: Model
     NamespaceDeclaration: NamespaceDeclaration
     ObjectMap: ObjectMap
+    OpenHostService: OpenHostService
+    Partnership: Partnership
     Policy: Policy
+    PublishedLanguage: PublishedLanguage
     Relationship: Relationship
+    SeparateWays: SeparateWays
+    SharedKernel: SharedKernel
+    SidePattern: SidePattern
     StructureElement: StructureElement
+    Supplier: Supplier
+    SymmetricPattern: SymmetricPattern
+    SymmetricRelationship: SymmetricRelationship
     Team: Team
     ThisRef: ThisRef
     Type: Type
@@ -678,6 +935,18 @@ export class DomainLangAstReflection extends langium.AbstractAstReflection {
             },
             superTypes: []
         },
+        AntiCorruptionLayer: {
+            name: AntiCorruptionLayer.$type,
+            properties: {
+            },
+            superTypes: [SidePattern.$type]
+        },
+        BigBallOfMud: {
+            name: BigBallOfMud.$type,
+            properties: {
+            },
+            superTypes: [SidePattern.$type]
+        },
         BoundedContext: {
             name: BoundedContext.$type,
             properties: {
@@ -767,6 +1036,12 @@ export class DomainLangAstReflection extends langium.AbstractAstReflection {
             },
             superTypes: [Type.$type]
         },
+        Conformist: {
+            name: Conformist.$type,
+            properties: {
+            },
+            superTypes: [SidePattern.$type]
+        },
         Container: {
             name: Container.$type,
             properties: {
@@ -791,6 +1066,12 @@ export class DomainLangAstReflection extends langium.AbstractAstReflection {
             },
             superTypes: [ObjectMap.$type]
         },
+        Customer: {
+            name: Customer.$type,
+            properties: {
+            },
+            superTypes: [SidePattern.$type]
+        },
         Decision: {
             name: Decision.$type,
             properties: {
@@ -807,6 +1088,29 @@ export class DomainLangAstReflection extends langium.AbstractAstReflection {
             },
             superTypes: [AbstractDecision.$type]
         },
+        DirectionalRelationship: {
+            name: DirectionalRelationship.$type,
+            properties: {
+                arrow: {
+                    name: DirectionalRelationship.arrow
+                },
+                left: {
+                    name: DirectionalRelationship.left
+                },
+                leftPatterns: {
+                    name: DirectionalRelationship.leftPatterns,
+                    defaultValue: []
+                },
+                right: {
+                    name: DirectionalRelationship.right
+                },
+                rightPatterns: {
+                    name: DirectionalRelationship.rightPatterns,
+                    defaultValue: []
+                }
+            },
+            superTypes: [Relationship.$type]
+        },
         Domain: {
             name: Domain.$type,
             properties: {
@@ -931,6 +1235,18 @@ export class DomainLangAstReflection extends langium.AbstractAstReflection {
             },
             superTypes: [StructureElement.$type]
         },
+        OpenHostService: {
+            name: OpenHostService.$type,
+            properties: {
+            },
+            superTypes: [SidePattern.$type]
+        },
+        Partnership: {
+            name: Partnership.$type,
+            properties: {
+            },
+            superTypes: [SymmetricPattern.$type]
+        },
         Policy: {
             name: Policy.$type,
             properties: {
@@ -947,29 +1263,33 @@ export class DomainLangAstReflection extends langium.AbstractAstReflection {
             },
             superTypes: [AbstractDecision.$type]
         },
+        PublishedLanguage: {
+            name: PublishedLanguage.$type,
+            properties: {
+            },
+            superTypes: [SidePattern.$type]
+        },
         Relationship: {
             name: Relationship.$type,
             properties: {
-                arrow: {
-                    name: Relationship.arrow
-                },
-                left: {
-                    name: Relationship.left
-                },
-                leftPatterns: {
-                    name: Relationship.leftPatterns,
-                    defaultValue: []
-                },
-                right: {
-                    name: Relationship.right
-                },
-                rightPatterns: {
-                    name: Relationship.rightPatterns,
-                    defaultValue: []
-                },
-                type: {
-                    name: Relationship.type
-                }
+            },
+            superTypes: []
+        },
+        SeparateWays: {
+            name: SeparateWays.$type,
+            properties: {
+            },
+            superTypes: [SymmetricPattern.$type]
+        },
+        SharedKernel: {
+            name: SharedKernel.$type,
+            properties: {
+            },
+            superTypes: [SymmetricPattern.$type]
+        },
+        SidePattern: {
+            name: SidePattern.$type,
+            properties: {
             },
             superTypes: []
         },
@@ -979,6 +1299,36 @@ export class DomainLangAstReflection extends langium.AbstractAstReflection {
             },
             superTypes: []
         },
+        Supplier: {
+            name: Supplier.$type,
+            properties: {
+            },
+            superTypes: [SidePattern.$type]
+        },
+        SymmetricPattern: {
+            name: SymmetricPattern.$type,
+            properties: {
+            },
+            superTypes: []
+        },
+        SymmetricRelationship: {
+            name: SymmetricRelationship.$type,
+            properties: {
+                arrow: {
+                    name: SymmetricRelationship.arrow
+                },
+                left: {
+                    name: SymmetricRelationship.left
+                },
+                pattern: {
+                    name: SymmetricRelationship.pattern
+                },
+                right: {
+                    name: SymmetricRelationship.right
+                }
+            },
+            superTypes: [Relationship.$type]
+        },
         Team: {
             name: Team.$type,
             properties: {