@likec4/language-server 1.17.0 → 1.18.0

package/src/validation/_shared.ts

@@ -1,4 +1,5 @@
-import { type AstNode, interruptAndCheck, type ValidationAcceptor, type ValidationCheck } from 'langium'
+import { type AstNode, type ValidationAcceptor, type ValidationCheck } from 'langium'
+import { isPromise } from 'remeda'
 import type { CancellationToken } from 'vscode-jsonrpc'
 import { logWarnError } from '../logger'
 
@@ -7,17 +8,18 @@ export const RESERVED_WORDS = [
   'it',
   'self',
   'super',
+  'instance',
   'likec4lib',
   'global'
 ]
 
 export function tryOrLog<T extends AstNode>(fn: ValidationCheck<T>): ValidationCheck<T> {
   return async (node: T, accept: ValidationAcceptor, cancelToken: CancellationToken) => {
-    if (cancelToken) {
-      await interruptAndCheck(cancelToken)
-    }
     try {
-      await fn(node, accept, cancelToken)
+      const result = fn(node, accept, cancelToken)
+      if (isPromise(result)) {
+        await result
+      }
     } catch (e) {
       logWarnError(e)
     }

package/src/validation/deployment-checks.ts

@@ -0,0 +1,144 @@
+import { nonNullable } from '@likec4/core'
+import { AstUtils, type ValidationCheck } from 'langium'
+import { ast } from '../ast'
+import type { LikeC4Services } from '../module'
+import type { LikeC4NameProvider } from '../references'
+import { RESERVED_WORDS, tryOrLog } from './_shared'
+
+const { getDocument } = AstUtils
+
+export const deploymentNodeChecks = (services: LikeC4Services): ValidationCheck<ast.DeploymentNode> => {
+  const DeploymentsIndex = services.likec4.DeploymentsIndex
+  const Names = services.references.NameProvider
+  return tryOrLog((el, accept) => {
+    const nodeName = Names.getName(el)
+    if (!nodeName) {
+      accept('error', 'DeploymentNode must be named', {
+        node: el
+      })
+      return
+    }
+    const range = nonNullable(Names.getNameNode(el), 'name CstNode not found').range
+
+    if (RESERVED_WORDS.includes(nodeName)) {
+      accept('error', `Reserved word: ${nodeName}`, {
+        node: el,
+        range
+      })
+    }
+    const fqnName = DeploymentsIndex.getFqnName(el)
+
+    const withSameName = DeploymentsIndex.byFqn(fqnName).limit(2).toArray()
+    if (withSameName.length > 1) {
+      accept(
+        'error',
+        `Duplicate node name "${fqnName}"`,
+        {
+          node: el,
+          range
+        }
+      )
+    }
+  })
+}
+
+export const deployedInstanceChecks = (services: LikeC4Services): ValidationCheck<ast.DeployedInstance> => {
+  const DeploymentsIndex = services.likec4.DeploymentsIndex
+  const Names = services.references.NameProvider as LikeC4NameProvider
+  // const Locator = services.workspace.AstNodeLocator
+  return tryOrLog((el, accept) => {
+    const artifactName = Names.getName(el)
+    if (!artifactName) {
+      accept('error', 'Deployed instance must be named, unique inside node', {
+        node: el
+      })
+      return
+    }
+    const range = nonNullable(Names.getNameNode(el), 'name CstNode not found').range
+
+    if (RESERVED_WORDS.includes(artifactName)) {
+      accept('error', `Reserved word: ${artifactName}`, {
+        node: el,
+        range
+      })
+    }
+    const fqnName = DeploymentsIndex.getFqnName(el)
+
+    const withSameName = DeploymentsIndex.byFqn(fqnName).limit(2).toArray()
+    if (withSameName.length > 1) {
+      accept(
+        'error',
+        `Duplicate instance name "${fqnName}"`,
+        {
+          node: el,
+          range
+        }
+      )
+    }
+  })
+}
+
+export const deploymentRelationChecks = (services: LikeC4Services): ValidationCheck<ast.DeploymentRelation> => {
+  // const DeploymentsIndex = services.likec4.DeploymentsIndex
+  // const Names = services.references.NameProvider as LikeC4NameProvider
+  // const Locator = services.workspace.AstNodeLocator
+  // const fqnIndex = services.likec4.FqnIndex
+  return tryOrLog((el, accept) => {
+    const source = el.source?.value?.ref
+    const target = el.target?.value?.ref
+
+    if (!source || !target) {
+      return
+    }
+
+    if (
+      ast.isElement(source) && ast.isDeploymentNode(target) || ast.isElement(target) && ast.isDeploymentNode(source)
+    ) {
+      const range = el.target.$cstNode?.range ?? el.source.$cstNode?.range
+      accept('error', 'Relations between deployment nodes and instance internals are not supported', {
+        node: el,
+        ...range && { range }
+      })
+    }
+
+    // const sourceEl = ast.isDeployedInstance(source)
+    //   ? elementRef(source.element)
+    //   : source
+    // const targetEl = ast.isDeployedInstance(target)
+    //   ? elementRef(target.element)
+    //   : target
+
+    // if (!sourceEl || !targetEl) {
+    //   return
+    // }
+
+    // const sourceFqn = ast.isElement(sourceEl) ? fqnIndex.getFqn(sourceEl) : DeploymentsIndex.getFqnName(sourceEl) as Fqn
+    // if (!sourceFqn) {
+    //   accept('error', 'Source not resolved', {
+    //     node: el,
+    //     property: 'source'
+    //   })
+    // }
+
+    // const targetFqn = ast.isElement(targetEl) ? fqnIndex.getFqn(targetEl) : DeploymentsIndex.getFqnName(targetEl) as Fqn
+    // if (!targetFqn) {
+    //   accept('error', 'Target not resolved', {
+    //     node: el,
+    //     property: 'target'
+    //   })
+    // }
+
+    // if (!!sourceFqn && sourceFqn === targetFqn) {
+    //   accept('error', 'Self-relation is not allowed', {
+    //     node: el
+    //   })
+    //   return
+    // }
+
+    // if (sourceFqn && targetFqn && isSameHierarchy(sourceFqn, targetFqn)) {
+    //   accept('error', 'Invalid parent-child relationship', {
+    //     node: el
+    //   })
+    // }
+  })
+}

package/src/validation/dynamic-view-step.ts

@@ -1,9 +1,9 @@
 import { isAncestor } from '@likec4/core'
 import type { ValidationCheck } from 'langium'
 import { ast } from '../ast'
-import { elementRef } from '../elementRef'
 import { logError } from '../logger'
 import type { LikeC4Services } from '../module'
+import { elementRef } from '../utils/elementRef'
 
 export const dynamicViewStep = (services: LikeC4Services): ValidationCheck<ast.DynamicViewStep> => {
   const fqnIndex = services.likec4.FqnIndex

package/src/validation/index.ts

@@ -1,6 +1,7 @@
 import { type ast } from '../ast'
 import { logger } from '../logger'
 import type { LikeC4Services } from '../module'
+import { deployedInstanceChecks, deploymentNodeChecks, deploymentRelationChecks } from './deployment-checks'
 import { dynamicViewRulePredicate } from './dynamic-view-rule'
 import { dynamicViewStep } from './dynamic-view-step'
 import { elementChecks } from './element'
@@ -18,6 +19,7 @@ import {
 } from './specification'
 import { viewChecks } from './view'
 import {
+  deploymentRefExpressionChecks,
   elementPredicateWithChecks,
   expandElementExprChecks,
   incomingExpressionChecks,
@@ -29,6 +31,11 @@ export function registerValidationChecks(services: LikeC4Services) {
   logger.info('registerValidationChecks')
   const registry = services.validation.ValidationRegistry
   registry.register<ast.LikeC4AstType>({
+    DeployedInstance: deployedInstanceChecks(services),
+    DeploymentNode: deploymentNodeChecks(services),
+    DeploymentRelation: deploymentRelationChecks(services),
+    DeploymentRefExpression: deploymentRefExpressionChecks(services),
+    // DeploymentRelationExpression: deploymentRelationExpressionChecks(services),
     NotesProperty: notesPropertyRuleChecks(services),
     OpacityProperty: opacityPropertyRuleChecks(services),
     IconProperty: iconPropertyRuleChecks(services),

package/src/validation/relation.ts

@@ -2,8 +2,8 @@ import { isSameHierarchy } from '@likec4/core'
 import type { ValidationCheck } from 'langium'
 import { isDefined } from 'remeda'
 import { ast } from '../ast'
-import { elementRef } from '../elementRef'
 import type { LikeC4Services } from '../module'
+import { elementRef } from '../utils/elementRef'
 import { tryOrLog } from './_shared'
 
 export const relationChecks = (services: LikeC4Services): ValidationCheck<ast.Relation> => {

package/src/validation/view-predicates/deployments.ts

@@ -0,0 +1,56 @@
+import { AstUtils, type ValidationCheck } from 'langium'
+import { isNonNullish, isNullish } from 'remeda'
+import { ast } from '../../ast'
+import type { LikeC4Services } from '../../module'
+import { tryOrLog } from '../_shared'
+
+// export const deploymentRelationExpressionChecks = (
+//   services: LikeC4Services
+// ): ValidationCheck<ast.DeploymentRelationExpression> => {
+//   return tryOrLog((node, accept) => {
+//     if (!AstUtils.hasContainerOfType(node, ast.isDirectedDeploymentRelationExpression)) {
+//       accept('warning', 'Not supported yet', {
+//         node
+//       })
+//       return
+//     }
+//   })
+// }
+
+export const deploymentRefExpressionChecks = (
+  services: LikeC4Services
+): ValidationCheck<ast.DeploymentRefExpression> => {
+  // const DeploymentsIndex = services.likec4.DeploymentsIndex
+  // const Names = services.references.NameProvider as LikeC4NameProvider
+  // const Locator = services.workspace.AstNodeLocator
+  // const fqnIndex = services.likec4.FqnIndex
+  return tryOrLog((node, accept) => {
+    const referenceTo = node.ref.value.ref
+    if (isNullish(referenceTo)) {
+      accept('error', 'Invalid empty reference', {
+        node
+      })
+      return
+    }
+
+    // Ignore follwoing checks for view rule style
+    if (AstUtils.hasContainerOfType(node, ast.isDeploymentViewRuleStyle)) {
+      return
+    }
+
+    switch (true) {
+      case ast.isElement(referenceTo): {
+        accept('error', 'Invalid reference, deployment nodes and instances are only allowed', {
+          node
+        })
+        break
+      }
+      case ast.isDeployedInstance(referenceTo) && isNonNullish(node.selector): {
+        accept('error', 'Only deployment nodes can be expanded', {
+          node
+        })
+        break
+      }
+    }
+  })
+}

package/src/validation/view-predicates/index.ts

@@ -1,3 +1,4 @@
+export * from './deployments'
 export * from './element-with'
 export * from './expanded-element'
 export * from './incoming'

package/src/view-utils/assignNavigateTo.ts

@@ -1,11 +1,11 @@
-import { type ComputedView, type Fqn, isComputedElementView, type ViewID } from '@likec4/core'
+import { ComputedNode, ComputedView, type Fqn, isElementView, type ViewId } from '@likec4/core'
 import { find, isNullish } from 'remeda'
 
 export function assignNavigateTo<R extends Iterable<ComputedView>>(views: R): R {
-  const allElementViews = new Map<Fqn, ViewID[]>()
+  const allElementViews = new Map<Fqn, ViewId[]>()
 
   for (const v of views) {
-    if (isComputedElementView(v) && v.viewOf && isNullish(v.extends)) {
+    if (ComputedView.isElement(v) && v.viewOf && isNullish(v.extends)) {
       const viewsOf = allElementViews.get(v.viewOf) ?? []
       viewsOf.push(v.id)
       allElementViews.set(v.viewOf, viewsOf)
@@ -15,11 +15,12 @@ export function assignNavigateTo<R extends Iterable<ComputedView>>(views: R): R
   // set default navigateTo
   for (const { id, nodes } of views) {
     for (const node of nodes) {
-      if (node.navigateTo) {
+      const modelRef = ComputedNode.modelRef(node)
+      if (node.navigateTo || !modelRef) {
         continue
       }
       // find first element view that is not the current one
-      const navigateTo = find(allElementViews.get(node.id) ?? [], v => v !== id)
+      const navigateTo = find(allElementViews.get(modelRef) ?? [], v => v !== id)
       if (navigateTo) {
         node.navigateTo = navigateTo
       }

package/src/view-utils/index.ts

@@ -1,3 +1,2 @@
 export * from './assignNavigateTo'
-export * from './resolve-extended-views'
 export * from './resolve-relative-paths'

package/dist/model-graph/index.cjs

@@ -1,10 +0,0 @@
-'use strict';
-
-const LikeC4ModelGraph = require('../shared/language-server.N8HLDQqz.cjs');
-
-
-
-exports.LikeC4ModelGraph = LikeC4ModelGraph.LikeC4ModelGraph;
-exports.computeDynamicView = LikeC4ModelGraph.computeDynamicView;
-exports.computeElementView = LikeC4ModelGraph.computeElementView;
-exports.computeView = LikeC4ModelGraph.computeView;

package/dist/model-graph/index.d.cts

@@ -1,81 +0,0 @@
-import { ModelGlobals, Element, Fqn, Relation, RelationID, ElementView, ComputedElementView, DynamicView, ComputedDynamicView } from '@likec4/core';
-
-type Params = {
-    elements: Record<Fqn, Element>;
-    relations: Record<RelationID, Relation>;
-    globals?: ModelGlobals;
-};
-type RelationEdge = {
-    source: Element;
-    target: Element;
-    relations: Relation[];
-};
-type FqnOrElement = Fqn | Element;
-type FqnsOrElements = ReadonlyArray<Fqn> | ReadonlyArray<Element>;
-/**
- * Used only for views calculations.
- * Subject to change.
- */
-declare class LikeC4ModelGraph {
-    #private;
-    readonly globals: ModelGlobals;
-    constructor({ elements, relations, globals }: Params);
-    get rootElements(): Element[];
-    get elements(): Element[];
-    element(id: Fqn): Element;
-    connectedRelations(id: Fqn): Relation[];
-    children(id: Fqn): Element[];
-    childrenOrElement(id: Fqn): Element[];
-    siblings(element: Fqn | Element): Element[];
-    /**
-     * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
-     * (from closest to root)
-     */
-    ancestors(element: Fqn | Element): Array<Element>;
-    /**
-     * Resolve siblings of the element and its ancestors
-     *  (from closest to root)
-     */
-    ascendingSiblings(element: Fqn | Element): Array<Element>;
-    /**
-     * Resolve all RelationEdges between element and others (any direction)
-     */
-    anyEdgesBetween(_element: Fqn | Element, others: ReadonlyArray<Fqn> | ReadonlyArray<Element>): Array<RelationEdge>;
-    /**
-     * Resolve all RelationEdges between elements (any direction)
-     */
-    edgesWithin<T extends Fqn[] | Element[]>(elements: T): Array<RelationEdge>;
-    /**
-     * Get directed RelationEdge between source and target if exists
-     */
-    edgesBetween(_sources: FqnOrElement | FqnsOrElements, _targets: FqnOrElement | FqnsOrElements): RelationEdge[];
-    private addElement;
-    private addRelation;
-    private _childrenOf;
-    private _incomingTo;
-    private _outgoingFrom;
-    private _internalOf;
-}
-
-declare function computeElementView(view: ElementView, graph: LikeC4ModelGraph): ComputedElementView<string, string>;
-type ComputeViewResult$1 = {
-    isSuccess: true;
-    view: ComputedElementView;
-} | {
-    isSuccess: false;
-    error: Error;
-    view: undefined;
-};
-declare function computeView(view: ElementView, graph: LikeC4ModelGraph): ComputeViewResult$1;
-
-type ComputeViewResult = {
-    isSuccess: true;
-    view: ComputedDynamicView;
-} | {
-    isSuccess: false;
-    error: Error;
-    view: undefined;
-};
-declare function computeDynamicView(view: DynamicView, graph: LikeC4ModelGraph): ComputeViewResult;
-
-export { LikeC4ModelGraph, computeDynamicView, computeElementView, computeView };

package/dist/model-graph/index.d.mts

@@ -1,81 +0,0 @@
-import { ModelGlobals, Element, Fqn, Relation, RelationID, ElementView, ComputedElementView, DynamicView, ComputedDynamicView } from '@likec4/core';
-
-type Params = {
-    elements: Record<Fqn, Element>;
-    relations: Record<RelationID, Relation>;
-    globals?: ModelGlobals;
-};
-type RelationEdge = {
-    source: Element;
-    target: Element;
-    relations: Relation[];
-};
-type FqnOrElement = Fqn | Element;
-type FqnsOrElements = ReadonlyArray<Fqn> | ReadonlyArray<Element>;
-/**
- * Used only for views calculations.
- * Subject to change.
- */
-declare class LikeC4ModelGraph {
-    #private;
-    readonly globals: ModelGlobals;
-    constructor({ elements, relations, globals }: Params);
-    get rootElements(): Element[];
-    get elements(): Element[];
-    element(id: Fqn): Element;
-    connectedRelations(id: Fqn): Relation[];
-    children(id: Fqn): Element[];
-    childrenOrElement(id: Fqn): Element[];
-    siblings(element: Fqn | Element): Element[];
-    /**
-     * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
-     * (from closest to root)
-     */
-    ancestors(element: Fqn | Element): Array<Element>;
-    /**
-     * Resolve siblings of the element and its ancestors
-     *  (from closest to root)
-     */
-    ascendingSiblings(element: Fqn | Element): Array<Element>;
-    /**
-     * Resolve all RelationEdges between element and others (any direction)
-     */
-    anyEdgesBetween(_element: Fqn | Element, others: ReadonlyArray<Fqn> | ReadonlyArray<Element>): Array<RelationEdge>;
-    /**
-     * Resolve all RelationEdges between elements (any direction)
-     */
-    edgesWithin<T extends Fqn[] | Element[]>(elements: T): Array<RelationEdge>;
-    /**
-     * Get directed RelationEdge between source and target if exists
-     */
-    edgesBetween(_sources: FqnOrElement | FqnsOrElements, _targets: FqnOrElement | FqnsOrElements): RelationEdge[];
-    private addElement;
-    private addRelation;
-    private _childrenOf;
-    private _incomingTo;
-    private _outgoingFrom;
-    private _internalOf;
-}
-
-declare function computeElementView(view: ElementView, graph: LikeC4ModelGraph): ComputedElementView<string, string>;
-type ComputeViewResult$1 = {
-    isSuccess: true;
-    view: ComputedElementView;
-} | {
-    isSuccess: false;
-    error: Error;
-    view: undefined;
-};
-declare function computeView(view: ElementView, graph: LikeC4ModelGraph): ComputeViewResult$1;
-
-type ComputeViewResult = {
-    isSuccess: true;
-    view: ComputedDynamicView;
-} | {
-    isSuccess: false;
-    error: Error;
-    view: undefined;
-};
-declare function computeDynamicView(view: DynamicView, graph: LikeC4ModelGraph): ComputeViewResult;
-
-export { LikeC4ModelGraph, computeDynamicView, computeElementView, computeView };

package/dist/model-graph/index.d.ts

@@ -1,81 +0,0 @@
-import { ModelGlobals, Element, Fqn, Relation, RelationID, ElementView, ComputedElementView, DynamicView, ComputedDynamicView } from '@likec4/core';
-
-type Params = {
-    elements: Record<Fqn, Element>;
-    relations: Record<RelationID, Relation>;
-    globals?: ModelGlobals;
-};
-type RelationEdge = {
-    source: Element;
-    target: Element;
-    relations: Relation[];
-};
-type FqnOrElement = Fqn | Element;
-type FqnsOrElements = ReadonlyArray<Fqn> | ReadonlyArray<Element>;
-/**
- * Used only for views calculations.
- * Subject to change.
- */
-declare class LikeC4ModelGraph {
-    #private;
-    readonly globals: ModelGlobals;
-    constructor({ elements, relations, globals }: Params);
-    get rootElements(): Element[];
-    get elements(): Element[];
-    element(id: Fqn): Element;
-    connectedRelations(id: Fqn): Relation[];
-    children(id: Fqn): Element[];
-    childrenOrElement(id: Fqn): Element[];
-    siblings(element: Fqn | Element): Element[];
-    /**
-     * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
-     * (from closest to root)
-     */
-    ancestors(element: Fqn | Element): Array<Element>;
-    /**
-     * Resolve siblings of the element and its ancestors
-     *  (from closest to root)
-     */
-    ascendingSiblings(element: Fqn | Element): Array<Element>;
-    /**
-     * Resolve all RelationEdges between element and others (any direction)
-     */
-    anyEdgesBetween(_element: Fqn | Element, others: ReadonlyArray<Fqn> | ReadonlyArray<Element>): Array<RelationEdge>;
-    /**
-     * Resolve all RelationEdges between elements (any direction)
-     */
-    edgesWithin<T extends Fqn[] | Element[]>(elements: T): Array<RelationEdge>;
-    /**
-     * Get directed RelationEdge between source and target if exists
-     */
-    edgesBetween(_sources: FqnOrElement | FqnsOrElements, _targets: FqnOrElement | FqnsOrElements): RelationEdge[];
-    private addElement;
-    private addRelation;
-    private _childrenOf;
-    private _incomingTo;
-    private _outgoingFrom;
-    private _internalOf;
-}
-
-declare function computeElementView(view: ElementView, graph: LikeC4ModelGraph): ComputedElementView<string, string>;
-type ComputeViewResult$1 = {
-    isSuccess: true;
-    view: ComputedElementView;
-} | {
-    isSuccess: false;
-    error: Error;
-    view: undefined;
-};
-declare function computeView(view: ElementView, graph: LikeC4ModelGraph): ComputeViewResult$1;
-
-type ComputeViewResult = {
-    isSuccess: true;
-    view: ComputedDynamicView;
-} | {
-    isSuccess: false;
-    error: Error;
-    view: undefined;
-};
-declare function computeDynamicView(view: DynamicView, graph: LikeC4ModelGraph): ComputeViewResult;
-
-export { LikeC4ModelGraph, computeDynamicView, computeElementView, computeView };

package/dist/model-graph/index.mjs

@@ -1 +0,0 @@
-export { L as LikeC4ModelGraph, b as computeDynamicView, c as computeElementView, a as computeView } from '../shared/language-server.BXFhlTPo.mjs';