@domainlang/language 0.1.81

package/src/validation/import.ts

@@ -0,0 +1,171 @@
+import type { ValidationAcceptor, ValidationChecks } from 'langium';
+import type { DomainLangAstType, ImportStatement, Model } from '../generated/ast.js';
+import { resolveImportPath } from '../utils/import-utils.js';
+import type { DomainLangServices } from '../domain-lang-module.js';
+import type { LangiumDocument } from 'langium';
+
+/**
+ * Validates import statements in DomainLang.
+ * 
+ * Checks:
+ * - Import paths are resolvable
+ * - Named imports exist in target document
+ * - Import aliases don't conflict with local names
+ */
+export class ImportValidator {
+    private readonly documents: DomainLangServices['shared']['workspace']['LangiumDocuments'];
+
+    constructor(services: DomainLangServices) {
+        this.documents = services.shared.workspace.LangiumDocuments;
+    }
+
+    /**
+     * Validates that an import path is resolvable.
+     */
+    async checkImportPath(
+        imp: ImportStatement,
+        accept: ValidationAcceptor,
+        document: LangiumDocument
+    ): Promise<void> {
+        if (!imp.uri) {
+            accept('error', 'Import statement must have a URI', { 
+                node: imp,
+                keyword: 'import'
+            });
+            return;
+        }
+
+        try {
+            await resolveImportPath(document, imp.uri);
+        } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            accept('error', `Cannot resolve import: ${message}`, {
+                node: imp,
+                property: 'uri'
+            });
+        }
+    }
+
+    /**
+     * Validates that named imports exist in the target document.
+     */
+    async checkNamedImports(
+        imp: ImportStatement,
+        accept: ValidationAcceptor,
+        document: LangiumDocument
+    ): Promise<void> {
+        // Only check if we have named imports
+        if (!imp.symbols || imp.symbols.length === 0) {
+            return;
+        }
+
+        if (!imp.uri) {
+            return; // Already reported by checkImportPath
+        }
+
+        try {
+            // Resolve the target document
+            const targetUri = await resolveImportPath(document, imp.uri);
+            const targetDoc = await this.documents.getOrCreateDocument(targetUri);
+            
+            if (!targetDoc.parseResult?.value) {
+                accept('error', `Cannot load imported document: ${imp.uri}`, {
+                    node: imp,
+                    property: 'uri'
+                });
+                return;
+            }
+
+            // Get all exported symbols from target document
+            const targetModel = targetDoc.parseResult.value as Model;
+            const exportedSymbols = this.getExportedSymbols(targetModel);
+
+            // Check each imported symbol
+            for (const symbol of imp.symbols) {
+                if (!exportedSymbols.has(symbol)) {
+                    accept('error', 
+                        `Symbol '${symbol}' not found in ${imp.uri}`,
+                        {
+                            node: imp,
+                            property: 'symbols'
+                        }
+                    );
+                }
+            }
+        } catch {
+            // Import path error already reported by checkImportPath
+            return;
+        }
+    }
+
+    /**
+     * Gets all exportable symbols from a model.
+     * 
+     * In DomainLang, top-level declarations are implicitly exported:
+     * - Domains
+     * - BoundedContexts
+     * - Classifications
+     * - Groups
+     */
+    private getExportedSymbols(model: Model): Set<string> {
+        const symbols = new Set<string>();
+
+        // Iterate through all structure elements
+        for (const element of model.children ?? []) {
+            // Check if element has a name and add it
+            if ('name' in element && typeof element.name === 'string') {
+                symbols.add(element.name);
+            }
+        }
+
+        return symbols;
+    }
+
+    /**
+     * Checks for unused imports.
+     * 
+     * This is a warning, not an error, to avoid being too strict.
+     */
+    checkUnusedImports(
+        imp: ImportStatement,
+        _accept: ValidationAcceptor,
+        _model: Model
+    ): void {
+        // Skip check for wildcard imports (no named imports)
+        if (!imp.symbols || imp.symbols.length === 0) {
+            return;
+        }
+
+        // For now, just a placeholder - would require tracking symbol usage
+        // across the entire document, which is complex
+        // TODO: Implement symbol usage tracking
+    }
+}
+
+/**
+ * Creates validation checks for import statements.
+ */
+export function createImportChecks(_services: DomainLangServices): ValidationChecks<DomainLangAstType> {
+
+    return {
+        ImportStatement: (imp, accept) => {
+            const document = imp.$document;
+            if (!document) return;
+
+            // Note: Langium's validation is synchronous, so async checks won't
+            // execute during document validation. These checks will run during
+            // the build phase when documents are fully loaded.
+            
+            // For now, just do basic syntax validation
+            if (!imp.uri) {
+                accept('error', 'Import statement must have a URI', { 
+                    node: imp,
+                    keyword: 'import'
+                });
+            }
+
+            // TODO: Implement async validation in a separate build phase
+            // This would require using DocumentBuilder.onBuildPhase() or similar
+        }
+    };
+}

package/src/validation/maps.ts

@@ -0,0 +1,72 @@
+import type { ValidationAcceptor } from 'langium';
+import type { ContextMap, DomainMap } from '../generated/ast.js';
+
+/**
+ * Validates that a context map contains at least one bounded context.
+ * Empty context maps are not useful for documentation purposes.
+ * 
+ * @param map - The context map to validate
+ * @param accept - The validation acceptor for reporting issues
+ */
+function validateContextMapHasContexts(
+    map: ContextMap,
+    accept: ValidationAcceptor
+): void {
+    if (!map.boundedContexts || map.boundedContexts.length === 0) {
+        accept('warning', `Context Map '${map.name}' contains no bounded contexts`, {
+            node: map,
+            keyword: 'contains'
+        });
+    }
+}
+
+/**
+ * Validates that a context map has at least one relationship if it contains multiple contexts.
+ * Multiple unrelated contexts should have documented relationships.
+ * 
+ * @param map - The context map to validate
+ * @param accept - The validation acceptor for reporting issues
+ */
+function validateContextMapHasRelationships(
+    map: ContextMap,
+    accept: ValidationAcceptor
+): void {
+    const contextCount = map.boundedContexts?.length ?? 0;
+    const relationshipCount = map.relationships?.length ?? 0;
+    
+    // Only warn if multiple contexts exist without relationships
+    if (contextCount > 1 && relationshipCount === 0) {
+        accept('info', `Context Map '${map.name}' contains ${contextCount} contexts but no documented relationships`, {
+            node: map,
+            keyword: 'ContextMap'
+        });
+    }
+}
+
+/**
+ * Validates that a domain map contains at least one domain.
+ * Empty domain maps are not useful for documentation purposes.
+ * 
+ * @param map - The domain map to validate
+ * @param accept - The validation acceptor for reporting issues
+ */
+function validateDomainMapHasDomains(
+    map: DomainMap,
+    accept: ValidationAcceptor
+): void {
+    if (!map.domains || map.domains.length === 0) {
+        accept('warning', `Domain Map '${map.name}' contains no domains`, {
+            node: map,
+            keyword: 'contains'
+        });
+    }
+}
+
+export const contextMapChecks = [
+    validateContextMapHasContexts,
+    validateContextMapHasRelationships
+];
+
+export const domainMapChecks = [
+    validateDomainMapHasDomains
+];

package/src/validation/metadata.ts

@@ -0,0 +1,14 @@
+import type { ValidationChecks } from 'langium';
+import type { Metadata, DomainLangAstType } from '../generated/ast.js';
+
+/**
+ * Validation checks for Metadata elements.
+ * - Ensures metadata keys are defined before use
+ */
+export const metadataChecks: ValidationChecks<DomainLangAstType> = {
+    Metadata(metadata: Metadata, accept) {
+        if (!metadata.name) {
+            accept('error', 'Metadata must have a name', { node: metadata });
+        }
+    },
+};

package/src/validation/model.ts

@@ -0,0 +1,37 @@
+import { setInferredRelationshipTypes } from '../services/relationship-inference.js';
+import { extractNames } from './shared.js';
+import type { ValidationAcceptor } from 'langium';
+import type { Model } from '../generated/ast.js';
+import { ValidationMessages, buildCodeDescription } from './constants.js';
+
+/**
+ * Validates that all elements in the model have unique fully qualified names.
+ * Also triggers relationship type inference.
+ * 
+ * @param model - The model to validate
+ * @param accept - The validation acceptor for reporting issues
+ */
+function validateModelUniqueNames(
+    model: Model, 
+    accept: ValidationAcceptor
+): void {
+    const uniqueNames = new Set<string>();
+    const names = extractNames(model);
+    
+    for (const {fqn, node} of names) {
+        const oldSize = uniqueNames.size;
+        uniqueNames.add(fqn);
+        if (uniqueNames.size === oldSize) {
+            accept('error', ValidationMessages.DUPLICATE_ELEMENT(fqn), { 
+                node: node, 
+                property: 'name',
+                codeDescription: buildCodeDescription('language.md', 'naming')
+            });
+        }
+    }
+    
+    // Enrich relationships with inferred types
+    setInferredRelationshipTypes(model);
+}
+
+export const modelChecks = [validateModelUniqueNames]; 

package/src/validation/relationships.ts

@@ -0,0 +1,154 @@
+import type { ValidationAcceptor } from 'langium';
+import type { Relationship, BoundedContextRef } from '../generated/ast.js';
+import { isThisRef } 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';
+    }
+    return ref.link?.$refText ?? 'unknown';
+}
+
+/**
+ * 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
+ */
+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'
+    );
+    
+    // ACL on left side with -> arrow means upstream has ACL (incorrect)
+    if (hasACLLeft && relationship.arrow === '->') {
+        const leftName = getContextName(relationship.left);
+        accept('warning',
+            ValidationMessages.ACL_ON_WRONG_SIDE(leftName, 'left'),
+            { node: relationship, property: 'leftPatterns', codeDescription: buildCodeDescription('language.md', 'integration-patterns') }
+        );
+    }
+    
+    // ACL on right side with <- arrow means upstream has ACL (incorrect)
+    if (hasACLRight && relationship.arrow === '<-') {
+        const rightName = getContextName(relationship.right);
+        accept('warning',
+            ValidationMessages.ACL_ON_WRONG_SIDE(rightName, 'right'),
+            { node: relationship, property: 'rightPatterns', codeDescription: buildCodeDescription('language.md', 'integration-patterns') }
+        );
+    }
+}
+
+/**
+ * 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
+ */
+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'
+    );
+    
+    // CF on left side with -> arrow means upstream is conformist (incorrect)
+    if (hasCFLeft && relationship.arrow === '->') {
+        const leftName = getContextName(relationship.left);
+        accept('warning',
+            ValidationMessages.CONFORMIST_ON_WRONG_SIDE(leftName, 'left'),
+            { node: relationship, property: 'leftPatterns', codeDescription: buildCodeDescription('language.md', 'integration-patterns') }
+        );
+    }
+    
+    // CF on right side with <- arrow means upstream is conformist (incorrect)
+    if (hasCFRight && relationship.arrow === '<-') {
+        const rightName = getContextName(relationship.right);
+        accept('warning',
+            ValidationMessages.CONFORMIST_ON_WRONG_SIDE(rightName, 'right'),
+            { node: relationship, property: 'rightPatterns', codeDescription: buildCodeDescription('language.md', 'integration-patterns') }
+        );
+    }
+}
+
+/**
+ * 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
+ */
+function validatePatternCount(
+    relationship: Relationship,
+    accept: ValidationAcceptor
+): void {
+    const leftCount = relationship.leftPatterns?.length ?? 0;
+    const rightCount = relationship.rightPatterns?.length ?? 0;
+    
+    if (leftCount > 3) {
+        accept('info',
+            ValidationMessages.TOO_MANY_PATTERNS(leftCount, 'left'),
+            { node: relationship, property: 'leftPatterns', codeDescription: buildCodeDescription('language.md', 'integration-patterns') }
+        );
+    }
+    
+    if (rightCount > 3) {
+        accept('info',
+            ValidationMessages.TOO_MANY_PATTERNS(rightCount, 'right'),
+            { node: relationship, property: 'rightPatterns', codeDescription: buildCodeDescription('language.md', 'integration-patterns') }
+        );
+    }
+}
+
+export const relationshipChecks = [
+    validateSharedKernelBidirectional,
+    validateACLPlacement,
+    validateConformistPlacement,
+    validatePatternCount
+];

package/src/validation/shared.ts

@@ -0,0 +1,14 @@
+import type { AstNode } from 'langium';
+import type { Container } from '../generated/ast.js';
+import { isContainer } from '../generated/ast.js';
+import { QualifiedNameProvider } from '../lsp/domain-lang-naming.js';
+
+export function* extractNames(element: Container): Generator<{fqn: string, node: AstNode}> {
+    const fqnProvider = new QualifiedNameProvider();
+    for (const child of element.children) {
+        yield {fqn: fqnProvider.getQualifiedName(child.$container, child.name), node: child};
+        if (isContainer(child)) {
+            yield* extractNames(child);
+        }
+    }
+}