@domainlang/language 0.11.0 → 0.13.0

package/src/diagram/elk-layout-factory.ts

@@ -0,0 +1,83 @@
+/**
+ * ELK layout engine factory for DomainLang diagrams.
+ *
+ * Encapsulates the ELK construction, factory wiring, and Sprotty-ELK layout
+ * engine instantiation so that both the VS Code extension (via the LSP server
+ * DI module) and the CLI (for standalone diagram export) can reuse the same
+ * layout logic without embedding the setup inline.
+ *
+ * @module diagram/elk-layout-factory
+ */
+import * as ElkBundled from 'elkjs/lib/elk.bundled.js';
+import type { ELK } from 'elkjs/lib/elk-api.js';
+import {
+    DefaultElementFilter,
+    ElkLayoutEngine,
+    type ElkFactory,
+    type IElementFilter,
+    type ILayoutConfigurator,
+} from 'sprotty-elk/lib/elk-layout.js';
+import type { IModelLayoutEngine } from 'sprotty-protocol';
+import { ContextMapLayoutConfigurator } from './context-map-layout-configurator.js';
+
+/** @internal Handles the dual ESM/CJS export shape of the bundled ELK module. */
+type ElkConstructor = new (args?: { algorithms?: string[] }) => ELK;
+const _elkConstructor: ElkConstructor = (
+    (ElkBundled as unknown as { default?: ElkConstructor }).default
+    ?? (ElkBundled as unknown as ElkConstructor)
+);
+
+/**
+ * Creates an {@link ElkFactory} that produces a new bundled ELK instance
+ * pre-configured for the `layered` algorithm.
+ *
+ * Use this in Langium's DI module (`layout.ElkFactory`) or directly in the
+ * CLI when running the layout engine standalone.
+ */
+export function createElkFactory(): ElkFactory {
+    return () => new _elkConstructor({ algorithms: ['layered'] });
+}
+
+/**
+ * Creates the full set of objects required to run the ELK layout engine for
+ * DomainLang context-map diagrams.
+ *
+ * Returns the three collaborators that together constitute a complete
+ * `IModelLayoutEngine`:
+ * - `elkFactory` — produces the ELK worker instance
+ * - `elementFilter` — controls which model elements are laid out
+ * - `layoutConfigurator` — supplies algorithm-specific ELK options
+ *
+ * Callers that use Langium DI should register these individually via the
+ * `layout` service group.  Callers that operate outside of DI (e.g. the CLI)
+ * can call {@link createElkLayoutEngine} for a fully assembled engine.
+ */
+export function createElkLayoutComponents(): {
+    elkFactory: ElkFactory;
+    elementFilter: IElementFilter;
+    layoutConfigurator: ILayoutConfigurator;
+} {
+    return {
+        elkFactory: createElkFactory(),
+        elementFilter: new DefaultElementFilter(),
+        layoutConfigurator: new ContextMapLayoutConfigurator(),
+    };
+}
+
+/**
+ * Creates a fully assembled {@link IModelLayoutEngine} for DomainLang
+ * context-map diagrams using the bundled ELK engine.
+ *
+ * Intended for use outside of Langium's DI container — for example, in the
+ * CLI when generating standalone SVG or image exports.
+ *
+ * @example
+ * ```typescript
+ * const layoutEngine = createElkLayoutEngine();
+ * const laidOutModel = await layoutEngine.layout(rootModel);
+ * ```
+ */
+export function createElkLayoutEngine(): IModelLayoutEngine {
+    const { elkFactory, elementFilter, layoutConfigurator } = createElkLayoutComponents();
+    return new ElkLayoutEngine(elkFactory, elementFilter, layoutConfigurator) as IModelLayoutEngine;
+}

package/src/domain-lang-module.ts

@@ -16,13 +16,18 @@ import { DomainLangFormatter } from './lsp/domain-lang-formatter.js';
 import { DomainLangHoverProvider } from './lsp/hover/domain-lang-hover.js';
 import { DomainLangCompletionProvider } from './lsp/domain-lang-completion.js';
 import { DomainLangCodeActionProvider } from './lsp/domain-lang-code-actions.js';
+import { DomainLangCodeLensProvider } from './lsp/domain-lang-code-lens-provider.js';
 import { DomainLangNodeKindProvider } from './lsp/domain-lang-node-kind-provider.js';
 import { DomainLangDocumentSymbolProvider } from './lsp/domain-lang-document-symbol-provider.js';
+import { SprottyDefaultModule, SprottySharedModule } from 'langium-sprotty';
+import type { IDiagramGenerator, IModelLayoutEngine } from 'sprotty-protocol';
 import { ImportResolver } from './services/import-resolver.js';
 import { ManifestManager } from './services/workspace-manager.js';
 import { PackageBoundaryDetector } from './services/package-boundary-detector.js';
 import { DomainLangWorkspaceManager } from './lsp/domain-lang-workspace-manager.js';
 import { DomainLangIndexManager } from './lsp/domain-lang-index-manager.js';
+import { DomainLangContextMapDiagramGenerator } from './diagram/context-map-diagram-generator.js';
+import { createElkLayoutEngine } from './diagram/elk-layout-factory.js';
 
 /**
  * Declaration of custom services - add your own service classes here.
@@ -40,8 +45,13 @@ export type DomainLangAddedServices = {
         Formatter: DomainLangFormatter,
         HoverProvider: DomainLangHoverProvider,
         CompletionProvider: DomainLangCompletionProvider,
+        CodeLensProvider: DomainLangCodeLensProvider,
         CodeActionProvider: DomainLangCodeActionProvider
-    }
+    },
+    diagram: {
+        DiagramGenerator: IDiagramGenerator,
+        ModelLayoutEngine: IModelLayoutEngine
+    },
 }
 
 /**
@@ -80,9 +90,14 @@ export const DomainLangModule: Module<DomainLangServices, PartialLangiumServices
         Formatter: () => new DomainLangFormatter(),
         HoverProvider: (services) => new DomainLangHoverProvider(services),
         CompletionProvider: (services) => new DomainLangCompletionProvider(services),
+        CodeLensProvider: () => new DomainLangCodeLensProvider(),
         CodeActionProvider: () => new DomainLangCodeActionProvider(),
         DocumentSymbolProvider: (services) => new DomainLangDocumentSymbolProvider(services)
     },
+    diagram: {
+        DiagramGenerator: (services) => new DomainLangContextMapDiagramGenerator(services as never),
+        ModelLayoutEngine: () => createElkLayoutEngine(),
+    },
 };
 
 /**
@@ -107,11 +122,13 @@ export function createDomainLangServices(context: DefaultSharedModuleContext): {
     const shared = inject(
         createDefaultSharedModule(context),
         DomainLangGeneratedSharedModule,
-        DomainLangSharedModule
+        DomainLangSharedModule,
+        SprottySharedModule as never
     );
     const DomainLang = inject(
         createDefaultModule({ shared }),
         DomainLangGeneratedModule,
+        SprottyDefaultModule as never,
         DomainLangModule
     );
     shared.ServiceRegistry.register(DomainLang);

package/src/domain-lang.langium

@@ -204,17 +204,53 @@ DomainMap:
 
 /**
  * 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)
  */
 Relationship:
-    ('[' leftPatterns+=IntegrationPattern (',' leftPatterns+=IntegrationPattern)* ']')? 
+    DirectionalRelationship | SymmetricRelationship
+;
+
+/**
+ * Directional relationship - upstream/downstream with optional side patterns.
+ * 
+ * Examples:
+ *   Orders [OHS] -> [CF] Payments
+ *   Orders [S] -> [C] Payments
+ *   Orders -> Payments
+ *   Orders [OHS] <-> [CF] Payments
+ */
+DirectionalRelationship:
+    left=BoundedContextRef
+    ('[' leftPatterns+=SidePattern (',' leftPatterns+=SidePattern)* ']')?
+    arrow=DirectionalArrow
+    ('[' rightPatterns+=SidePattern (',' rightPatterns+=SidePattern)* ']')?
+    right=BoundedContextRef
+;
+
+/**
+ * Symmetric relationship - mutual pattern between two contexts, no directionality.
+ * 
+ * Examples:
+ *   CardManagement [SK] AccountManagement
+ *   Orders [P] Payments
+ *   Orders >< Payments
+ *   Orders [SW] Payments
+ */
+SymmetricRelationship:
     left=BoundedContextRef
-    arrow=RelationshipArrow
-    ('[' rightPatterns+=IntegrationPattern (',' rightPatterns+=IntegrationPattern)* ']')? 
+    (
+        '[' pattern=SymmetricPattern ']'
+      | arrow='><'
+    )
     right=BoundedContextRef
-    (Assignment type=RelationshipType)?
 ;
 
 /**
@@ -225,40 +261,40 @@ BoundedContextRef:
 ;
 
 /**
- * Relationship arrows - symbolic and named types.
+ * Directional relationship arrows.
  * 
  * 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)
+ *   <->  Bidirectional (mutual data flow with explicit patterns)
  */
-RelationshipArrow returns string:
-    '<->' | '->' | '<-' | '><'  // Separate Ways
+DirectionalArrow returns string:
+    '<->' | '->' | '<-'
 ;
 
 /**
- * DDD Integration Patterns (used in relationships).
+ * 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.
  */
-IntegrationPattern returns string:
-    'PL' | 'PublishedLanguage'       // Published Language
-    | 'OHS' | 'OpenHostService'      // Open Host Service
-    | 'CF' | 'Conformist'            // Conformist
-    | 'ACL' | 'AntiCorruptionLayer'  // Anti-Corruption Layer
-    | 'P' | 'Partnership'            // Partnership
-    | 'SK' | 'SharedKernel'          // Shared Kernel
-    | 'BBoM' | 'BigBallOfMud'        // Big Ball of Mud
+SidePattern:
+    {infer OpenHostService}     ('OHS' | 'OpenHostService')
+  | {infer PublishedLanguage}   ('PL'  | 'PublishedLanguage')
+  | {infer Conformist}          ('CF'  | 'Conformist')
+  | {infer AntiCorruptionLayer} ('ACL' | 'AntiCorruptionLayer')
+  | {infer Supplier}            ('S'   | 'Supplier')
+  | {infer Customer}            ('C'   | 'Customer')
+  | {infer BigBallOfMud}        ('BBoM'| 'BigBallOfMud')
 ;
 
 /**
- * DDD Relationship Types.
+ * DDD Symmetric Patterns - describe the relationship between two contexts.
+ * These are mutual/shared patterns, not directional.
  */
-RelationshipType returns string:
-    'Partnership' 
-    | 'SharedKernel' 
-    | 'CustomerSupplier' 
-    | 'UpstreamDownstream' 
-    | 'SeparateWays'
+SymmetricPattern:
+    {infer SharedKernel}  ('SK' | 'SharedKernel')
+  | {infer Partnership}   ('P'  | 'Partnership')
+  | {infer SeparateWays}  ('SW' | 'SeparateWays')
 ;
 
 // ============================================================================