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

package/out/generated/grammar.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"grammar.js","sourceRoot":"","sources":["../../src/generated/grammar.ts"],"names":[],"mappings":"AAAA;;;gFAGgF;AAGhF,OAAO,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAE9C,IAAI,iCAAsD,CAAC;AAC3D,MAAM,CAAC,MAAM,2BAA2B,GAAG,GAAY,EAAE,CAAC,iCAAiC,IAAI,CAAC,iCAAiC,GAAG,mBAAmB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA81GtJ,CAAC,CAAC,CAAC"}

package/out/generated/module.d.ts

@@ -0,0 +1,13 @@
+/******************************************************************************
+ * This file was generated by langium-cli 4.0.0.
+ * DO NOT EDIT MANUALLY!
+ ******************************************************************************/
+import type { LangiumSharedCoreServices, LangiumCoreServices, LangiumGeneratedCoreServices, LangiumGeneratedSharedCoreServices, Module } from 'langium';
+export declare const DomainDesignLanguageLanguageMetaData: {
+    readonly languageId: "domain-design-language";
+    readonly fileExtensions: readonly [".ddd"];
+    readonly caseInsensitive: false;
+    readonly mode: "development";
+};
+export declare const DomainDesignLanguageGeneratedSharedModule: Module<LangiumSharedCoreServices, LangiumGeneratedSharedCoreServices>;
+export declare const DomainDesignLanguageGeneratedModule: Module<LangiumCoreServices, LangiumGeneratedCoreServices>;

package/out/generated/module.js

@@ -0,0 +1,21 @@
+/******************************************************************************
+ * This file was generated by langium-cli 4.0.0.
+ * DO NOT EDIT MANUALLY!
+ ******************************************************************************/
+import { DomainDesignLanguageAstReflection } from './ast.js';
+import { DomainDesignLanguageGrammar } from './grammar.js';
+export const DomainDesignLanguageLanguageMetaData = {
+    languageId: 'domain-design-language',
+    fileExtensions: ['.ddd'],
+    caseInsensitive: false,
+    mode: 'development'
+};
+export const DomainDesignLanguageGeneratedSharedModule = {
+    AstReflection: () => new DomainDesignLanguageAstReflection()
+};
+export const DomainDesignLanguageGeneratedModule = {
+    Grammar: () => DomainDesignLanguageGrammar(),
+    LanguageMetaData: () => DomainDesignLanguageLanguageMetaData,
+    parser: {}
+};
+//# sourceMappingURL=module.js.map

package/out/generated/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../src/generated/module.ts"],"names":[],"mappings":"AAAA;;;gFAGgF;AAGhF,OAAO,EAAE,iCAAiC,EAAE,MAAM,UAAU,CAAC;AAC7D,OAAO,EAAE,2BAA2B,EAAE,MAAM,cAAc,CAAC;AAE3D,MAAM,CAAC,MAAM,oCAAoC,GAAG;IAChD,UAAU,EAAE,wBAAwB;IACpC,cAAc,EAAE,CAAC,MAAM,CAAC;IACxB,eAAe,EAAE,KAAK;IACtB,IAAI,EAAE,aAAa;CACc,CAAC;AAEtC,MAAM,CAAC,MAAM,yCAAyC,GAA0E;IAC5H,aAAa,EAAE,GAAG,EAAE,CAAC,IAAI,iCAAiC,EAAE;CAC/D,CAAC;AAEF,MAAM,CAAC,MAAM,mCAAmC,GAA8D;IAC1G,OAAO,EAAE,GAAG,EAAE,CAAC,2BAA2B,EAAE;IAC5C,gBAAgB,EAAE,GAAG,EAAE,CAAC,oCAAoC;IAC5D,MAAM,EAAE,EAAE;CACb,CAAC"}

package/out/index.d.ts

@@ -0,0 +1,5 @@
+export * from './domain-design-language-module.js';
+export * from './domain-design-language-validator.js';
+export * from './generated/ast.js';
+export * from './generated/grammar.js';
+export * from './generated/module.js';

package/out/index.js

@@ -0,0 +1,6 @@
+export * from './domain-design-language-module.js';
+export * from './domain-design-language-validator.js';
+export * from './generated/ast.js';
+export * from './generated/grammar.js';
+export * from './generated/module.js';
+//# sourceMappingURL=index.js.map

package/out/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,oCAAoC,CAAC;AACnD,cAAc,uCAAuC,CAAC;AACtD,cAAc,oBAAoB,CAAC;AACnC,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC"}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@fornari-lanza/domain-design-language-language",
+  "description": "The language specific package",
+  "version": "0.0.1",
+  "type": "module",
+  "engines": {
+    "node": ">=20.10.0",
+    "npm": ">=10.2.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "out",
+    "src"
+  ],
+  "main": "./out/index.js",
+  "module": "./out/index.js",
+  "exports": {
+    ".": {
+      "types": "./out/index.d.ts",
+      "default": "./out/index.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      ".": [
+        "out/index"
+      ]
+    }
+  },
+  "scripts": {
+    "clean": "shx rm -fr *.tsbuildinfo out",
+    "build": "echo 'No build step'",
+    "build:clean": "npm run clean && npm run build",
+    "langium:generate": "langium generate",
+    "langium:watch": "langium generate --watch"
+  },
+  "dependencies": {
+    "langium": "~4.0.0"
+  },
+  "devDependencies": {
+    "langium-cli": "~4.0.0"
+  },
+  "volta": {
+    "node": "20.19.2",
+    "npm": "10.8.2"
+  }
+}

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

@@ -0,0 +1,186 @@
+import type { AstNode } from 'langium';
+import { AbstractFormatter, Formatting } from 'langium/lsp';
+import * as ast from './generated/ast.js';
+
+export class DomainDesignLanguageFormatter extends AbstractFormatter {
+  protected format(node: AstNode): void {
+    const formatter = this.getNodeFormatter(node);
+    const bracesOpen = formatter.keyword('{');
+    const bracesClose = formatter.keyword('}');
+    const bracketsOpen = formatter.keyword('[');
+    const bracketsClose = formatter.keyword(']');
+    const parenthesisOpen = formatter.keyword('(');
+    const parenthesisClose = formatter.keyword(')');
+    const comma = formatter.keyword(',');
+    bracesOpen.append(Formatting.newLine()).prepend(Formatting.oneSpace());
+    bracesClose.surround(Formatting.newLine());
+    bracketsOpen.append(Formatting.noSpace());
+    bracketsClose.prepend(Formatting.noSpace());
+    parenthesisOpen.append(Formatting.noSpace());
+    parenthesisClose.prepend(Formatting.noSpace());
+    comma.append(Formatting.oneSpace()).prepend(Formatting.noSpace());
+    if (ast.isDomainModel(node)) {
+      const nodes = formatter.nodes(
+        ...(node.boundedContext ? [node.boundedContext] : []),
+        ...(node.contextMap ? [node.contextMap] : []),
+      );
+      nodes.append(Formatting.noIndent());
+    } else if (ast.isBoundedContext(node)) {
+      formatter
+        .properties(
+          'ubiquitousLanguage',
+          'aggregates',
+          'domainServices',
+          'ports',
+          'commands',
+          'eventStorming',
+        )
+        .prepend(Formatting.indent());
+      formatter.property('description').prepend(Formatting.indent());
+    } else if (ast.isUbiquitousLanguageDeclaration(node)) {
+      formatter.properties('terms').prepend(Formatting.indent());
+    } else if (ast.isTerm(node)) {
+      formatter
+        .keywords('definition:', 'aliases:')
+        .prepend(Formatting.indent())
+        .append(Formatting.oneSpace());
+    } else if (ast.isContextMap(node)) {
+      formatter.keyword('ContextMap').append(Formatting.oneSpace());
+      formatter.properties('relationships').prepend(Formatting.indent());
+    } else if (ast.isAsymmetricRelationship(node)) {
+      formatter
+        .keywords('upstream:', 'downstream:')
+        .prepend(Formatting.indent())
+        .append(Formatting.oneSpace());
+      formatter
+        .properties('customerSupplier', 'description')
+        .prepend(Formatting.indent());
+    } else if (ast.isSymmetricRelationship(node)) {
+      formatter.keyword('Relationship').append(Formatting.oneSpace());
+      formatter
+        .keywords('between')
+        .prepend(Formatting.indent())
+        .append(Formatting.oneSpace());
+      formatter.keyword('and').surround(Formatting.oneSpace());
+      formatter.properties('type', 'description').prepend(Formatting.indent());
+    } else if (ast.isAggregateRoot(node)) {
+      formatter.keyword('AggregateRoot').append(Formatting.oneSpace());
+      formatter
+        .keywords('enforcedInvariants:', 'correctivePolicies:')
+        .prepend(Formatting.indent())
+        .append(Formatting.oneSpace());
+      formatter
+        .properties(
+          'id',
+          'attributes',
+          'events',
+          'description',
+          'methods',
+          'exceptions',
+        )
+        .prepend(Formatting.indent());
+    } else if (ast.isUID(node)) {
+      formatter
+        .keywords('type:', 'enforcedInvariants:')
+        .prepend(Formatting.indent())
+        .append(Formatting.oneSpace());
+    } else if (ast.isValueObject(node)) {
+      formatter.keyword('ValueObject').append(Formatting.oneSpace());
+      formatter
+        .properties('attributes', 'description')
+        .prepend(Formatting.indent());
+      formatter
+        .keywords('enforcedInvariants:')
+        .prepend(Formatting.indent())
+        .append(Formatting.oneSpace());
+    } else if (ast.isPrimitiveAttribute(node) || ast.isDomainAttribute(node)) {
+      formatter
+        .keyword(':')
+        .append(Formatting.oneSpace())
+        .prepend(Formatting.noSpace());
+      formatter.properties('many', 'optional').append(Formatting.oneSpace());
+    } else if (ast.isAggregateAttribute(node) || ast.isEntityAttribute(node)) {
+      formatter.properties('many', 'optional').append(Formatting.oneSpace());
+    } else if (ast.isEntity(node)) {
+      formatter.keyword('Entity').append(Formatting.oneSpace());
+      formatter.properties('id', 'attributes').prepend(Formatting.indent());
+      formatter.property('description').prepend(Formatting.indent());
+    } else if (ast.isDomainEventsDeclaration(node)) {
+      formatter.properties('events').prepend(Formatting.indent());
+      formatter.keyword('DomainEvents').append(Formatting.oneSpace());
+    } else if (ast.isDomainEvent(node)) {
+      formatter.property('name').append(Formatting.oneSpace());
+      formatter.property('description').prepend(Formatting.indent());
+      formatter.property('payload').prepend(Formatting.indent());
+    } else if (ast.isPayload(node)) {
+      formatter.properties('attributes').prepend(Formatting.indent());
+    } else if (ast.isDomainService(node) || ast.isCommand(node)) {
+      formatter.property('name').prepend(Formatting.oneSpace());
+      formatter.property('description').prepend(Formatting.indent());
+      formatter
+        .keywords('type:', 'uses', 'emits', 'dependencies:')
+        .prepend(Formatting.indent())
+        .append(Formatting.oneSpace());
+      formatter.properties('input', 'response').prepend(Formatting.indent());
+    } else if (
+      ast.isDomainServiceInput(node) ||
+      ast.isDomainServiceResponse(node) ||
+      ast.isInputDTO(node) ||
+      ast.isResponseDTO(node)
+    ) {
+      formatter.properties('attributes').prepend(Formatting.indent());
+    } else if (ast.isPort(node)) {
+      formatter.keyword('Port').append(Formatting.oneSpace());
+      formatter.property('description').prepend(Formatting.indent());
+    } else if (ast.isEventStormingDeclaration(node)) {
+      formatter.keyword('EventStorming').append(Formatting.oneSpace());
+      formatter.properties('elements', 'flows').prepend(Formatting.indent());
+    } else if (ast.isEventStormingElement(node)) {
+      formatter.property('name').surround(Formatting.oneSpace());
+      formatter.property('description').prepend(Formatting.indent());
+    } else if (ast.isProcessFlow(node)) {
+      formatter.keyword('ProcessFlow').append(Formatting.oneSpace());
+      formatter.property('description').prepend(Formatting.indent());
+      formatter
+        .properties('given', 'command', 'reactions')
+        .prepend(Formatting.indent());
+    } else if (ast.isGivenStep(node)) {
+      formatter.keyword('given').append(Formatting.oneSpace());
+      formatter.keyword('views').surround(Formatting.oneSpace());
+    } else if (ast.isActorCommandStep(node)) {
+      formatter.keyword('issues').surround(Formatting.oneSpace());
+    } else if (ast.isReactionStep(node)) {
+      formatter.keywords('on').append(Formatting.oneSpace());
+      formatter.keyword('then').surround(Formatting.oneSpace());
+      formatter.properties('outcomes').prepend(Formatting.indent());
+    } else if (ast.isProjection(node)) {
+      formatter.keyword('projects').append(Formatting.oneSpace());
+      formatter.keywords('to', 'hotspot').surround(Formatting.oneSpace());
+    } else if (ast.isPolicyTrigger(node)) {
+      formatter.keyword('triggers').append(Formatting.oneSpace());
+      formatter.keyword('hotspot').prepend(Formatting.indent());
+    } else if (ast.isPolicy(node)) {
+      formatter.keyword('Policy').append(Formatting.oneSpace());
+      formatter.property('description').prepend(Formatting.indent());
+      formatter
+        .keywords('invokes')
+        .prepend(Formatting.indent())
+        .append(Formatting.oneSpace());
+      formatter.keywords('on').surround(Formatting.oneSpace());
+    } else if (ast.isMethod(node)) {
+      formatter.property('name').append(Formatting.noSpace());
+      formatter.keywords('(', ')').surround(Formatting.noSpace());
+      formatter
+        .properties('description')
+        .prepend(Formatting.indent());
+    } else if (ast.isMethodsDeclaration(node)) {
+      formatter.properties('methods').prepend(Formatting.indent());
+      formatter.keyword('Methods').append(Formatting.oneSpace());
+    } else if (ast.isExceptionsDeclaration(node)) {
+      formatter.properties('exceptions').prepend(Formatting.indent());
+      formatter.keyword('DomainExceptions').append(Formatting.oneSpace());
+    } else if (ast.isDomainException(node)) {
+      formatter.property('name').append(Formatting.oneSpace());
+    }
+  }
+}

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

@@ -0,0 +1,96 @@
+import { type Module, inject } from 'langium';
+import {
+  createDefaultModule,
+  createDefaultSharedModule,
+  type DefaultSharedModuleContext,
+  type LangiumServices,
+  type LangiumSharedServices,
+  type PartialLangiumServices,
+} from 'langium/lsp';
+import {
+  DomainDesignLanguageGeneratedModule,
+  DomainDesignLanguageGeneratedSharedModule,
+} from './generated/module.js';
+import {
+  DomainDesignLanguageValidator,
+  registerValidationChecks,
+} from './domain-design-language-validator.js';
+import { DomainDesignLanguageFormatter } from './domain-design-language-formatter.js';
+import { DomainDesignLanguageScopeProvider } from './domain-design-language-scope.js';
+
+/**
+ * Declaration of custom services - add your own service classes here.
+ */
+export type DomainDesignLanguageAddedServices = {
+  validation: {
+    DomainDesignLanguageValidator: DomainDesignLanguageValidator;
+  };
+};
+
+/**
+ * Union of Langium default services and your custom services - use this as constructor parameter
+ * of custom service classes.
+ */
+export type DomainDesignLanguageServices = LangiumServices &
+  DomainDesignLanguageAddedServices;
+
+/**
+ * Dependency injection module that overrides Langium default services and contributes the
+ * declared custom services. The Langium defaults can be partially specified to override only
+ * selected services, while the custom services must be fully specified.
+ */
+export const DomainDesignLanguageModule: Module<
+  DomainDesignLanguageServices,
+  PartialLangiumServices & DomainDesignLanguageAddedServices
+> = {
+  validation: {
+    DomainDesignLanguageValidator: () => new DomainDesignLanguageValidator(),
+  },
+  lsp: {
+    Formatter: () => new DomainDesignLanguageFormatter(),
+  },
+  references: {
+    ScopeProvider: (services) =>
+      new DomainDesignLanguageScopeProvider(services),
+  },
+};
+
+/**
+ * Create the full set of services required by Langium.
+ *
+ * First inject the shared services by merging two modules:
+ *  - Langium default shared services
+ *  - Services generated by langium-cli
+ *
+ * Then inject the language-specific services by merging three modules:
+ *  - Langium default language-specific services
+ *  - Services generated by langium-cli
+ *  - Services specified in this file
+ *
+ * @param context Optional module context with the LSP connection
+ * @returns An object wrapping the shared services and the language-specific services
+ */
+export function createDomainDesignLanguageServices(
+  context: DefaultSharedModuleContext,
+): {
+  shared: LangiumSharedServices;
+  DomainDesignLanguage: DomainDesignLanguageServices;
+} {
+  const shared = inject(
+    createDefaultSharedModule(context),
+    DomainDesignLanguageGeneratedSharedModule,
+  );
+  const DomainDesignLanguage = inject(
+    createDefaultModule({ shared }),
+    DomainDesignLanguageGeneratedModule,
+    DomainDesignLanguageModule,
+  );
+  shared.ServiceRegistry.register(DomainDesignLanguage);
+  registerValidationChecks(DomainDesignLanguage);
+  if (!context.connection) {
+    // We don't run inside a language server
+    // Therefore, initialize the configuration provider instantly
+    shared.workspace.ConfigurationProvider.initialized({});
+  }
+  return { shared, DomainDesignLanguage };
+}

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

@@ -0,0 +1,132 @@
+import {
+  AstNode,
+  AstNodeDescription,
+  DefaultScopeProvider,
+  ReferenceInfo,
+  Scope,
+  URI,
+} from 'langium';
+import {
+  BoundedContext,
+  DomainEvent,
+  isCommand,
+  isAsymmetricRelationship,
+  isBoundedContext,
+  isDomainAttribute,
+  isEntity,
+  isPolicyTrigger,
+  isProcessFlow,
+  isReactionStep,
+  isSymmetricRelationship,
+  isValueObject,
+  ProcessFlow,
+} from './generated/ast.js';
+import { glob } from 'glob';
+
+export class DomainDesignLanguageScopeProvider extends DefaultScopeProvider {
+  override getScope(context: ReferenceInfo): Scope {
+    if (isDomainAttribute(context.container) && context.property === 'type')
+      return this.getScopeForDomainAttribute(context);
+    if (
+      (isCommand(context.container) && context.property === 'events') ||
+      (isReactionStep(context.container) && context.property === 'trigger')
+    )
+      return this.getScopeForDomainEvents(context);
+    if (
+      isAsymmetricRelationship(context.container) &&
+      (context.property === 'upstream' || context.property === 'downstream')
+    )
+      return this.getBoundedContextsFromGlobalScope();
+    if (
+      isSymmetricRelationship(context.container) &&
+      (context.property === 'participant1' ||
+        context.property === 'participant2')
+    )
+      return this.getBoundedContextsFromGlobalScope();
+    return super.getScope(context);
+  }
+
+  private searchParent<T extends AstNode>(
+    context: ReferenceInfo,
+    predicate: (node: AstNode) => boolean,
+  ): T | undefined {
+    let node = context.container;
+    while (node.$container && !predicate(node)) node = node.$container;
+    return predicate(node) ? (node as T) : undefined;
+  }
+
+  private getBoundedContextsFromGlobalScope(): Scope {
+    const files = glob.sync('./boundedContexts/*.ddd', { absolute: true });
+    const uris = new Set<string>();
+    for (const filePath of files) uris.add(URI.file(filePath).toString());
+    const astNodeDescriptions = this.indexManager
+      .allElements('BoundedContext', uris)
+      .toArray();
+    return this.createScope(astNodeDescriptions);
+  }
+
+  private getScopeForDomainAttribute(context: ReferenceInfo): Scope {
+    const boundedContext = this.searchParent<BoundedContext>(
+      context,
+      isBoundedContext,
+    );
+    const validReferences = new Set<AstNodeDescription>();
+    if (boundedContext) {
+      boundedContext.aggregates.forEach((aggregate) => {
+        validReferences.add(
+          this.descriptions.createDescription(aggregate, aggregate.name),
+        );
+        aggregate.attributes.forEach((attr) => {
+          if (isValueObject(attr.type) || isEntity(attr.type))
+            validReferences.add(
+              this.descriptions.createDescription(
+                attr.type,
+                `${aggregate.name}.${attr.type.name}`,
+              ),
+            );
+        });
+      });
+    }
+    return this.createScope(validReferences);
+  }
+
+  private getScopeForDomainEvents(context: ReferenceInfo): Scope {
+    const validReferences = new Set<AstNodeDescription>();
+    if (isReactionStep(context.container)) {
+      const isFirstReactionStep = context.container.$containerIndex === 0;
+      const flow = this.searchParent<ProcessFlow>(context, isProcessFlow);
+      const events: DomainEvent[] = [];
+      if (isFirstReactionStep) {
+        events.push(
+          ...(flow?.command.command.ref?.events.map((e) => e.ref) ?? []).filter(
+            (e): e is DomainEvent => !!e,
+          ),
+        );
+      } else {
+        const policyEvents =
+          flow?.reactions[
+            (context.container.$containerIndex ?? 1) - 1
+          ].outcomes.flatMap((o) =>
+            isPolicyTrigger(o) && o.policy.command.ref?.events
+              ? o.policy.command.ref?.events
+                  .map((e) => e.ref)
+                  .filter((e): e is DomainEvent => !!e)
+              : [],
+          ) ?? [];
+        events.push(...policyEvents);
+      }
+      events.forEach((event) => {
+        validReferences.add(
+          this.descriptions.createDescription(event, event.name),
+        );
+      });
+    } else if (isCommand(context.container)) {
+      context.container.aggregate.ref?.events?.events.forEach((event) => {
+        validReferences.add(
+          this.descriptions.createDescription(event, event.name),
+        );
+      });
+    }
+    return this.createScope(validReferences);
+  }
+}