@likec4/language-server 1.2.0 → 1.2.2

package/src/validation/element.ts

@@ -0,0 +1,52 @@
+import { AstUtils, type ValidationCheck } from 'langium'
+import type { ast } from '../ast'
+import type { LikeC4Services } from '../module'
+
+const { getDocument } = AstUtils
+
+export const elementChecks = (services: LikeC4Services): ValidationCheck<ast.Element> => {
+  const fqnIndex = services.likec4.FqnIndex
+  return (el, accept) => {
+    const fqn = fqnIndex.getFqn(el)
+    if (!fqn) {
+      accept('error', 'Not indexed element', {
+        node: el,
+        property: 'name'
+      })
+      return
+    }
+    const withSameFqn = fqnIndex
+      .byFqn(fqn)
+      .filter(v => v.el !== el)
+      .head()
+    if (withSameFqn) {
+      const isAnotherDoc = withSameFqn.doc.uri !== getDocument(el).uri
+      accept(
+        'error',
+        `Duplicate element name ${el.name !== fqn ? el.name + ' (' + fqn + ')' : el.name}`,
+        {
+          node: el,
+          property: 'name',
+          ...isAnotherDoc && {
+            relatedInformation: [
+              {
+                location: {
+                  range: withSameFqn.el.$cstNode!.range,
+                  uri: withSameFqn.doc.uri.toString()
+                },
+                message: `conflicting element`
+              }
+            ]
+          }
+        }
+      )
+    }
+    // for (let i = 3; i < el.props.length; i++) {
+    //   accept('error', `Too many properties, max 3 allowed`, {
+    //     node: el,
+    //     property: 'props',
+    //     index: i
+    //   })
+    // }
+  }
+}

package/{dist/validation/index.js → src/validation/index.ts}

@@ -1,9 +1,11 @@
-import { logger } from "../logger.js";
-import { dynamicViewRulePredicate } from "./dynamic-view-rule.js";
-import { dynamicViewStep } from "./dynamic-view-step.js";
-import { elementChecks } from "./element.js";
-import { opacityPropertyRuleChecks } from "./property-checks.js";
-import { relationChecks } from "./relation.js";
+import { type ast } from '../ast'
+import { logger } from '../logger'
+import type { LikeC4Services } from '../module'
+import { dynamicViewRulePredicate } from './dynamic-view-rule'
+import { dynamicViewStep } from './dynamic-view-step'
+import { elementChecks } from './element'
+import { opacityPropertyRuleChecks } from './property-checks'
+import { relationChecks } from './relation'
 import {
   elementKindChecks,
   modelRuleChecks,
@@ -11,18 +13,19 @@ import {
   relationshipChecks,
   specificationRuleChecks,
   tagChecks
-} from "./specification.js";
-import { viewChecks } from "./view.js";
+} from './specification'
+import { viewChecks } from './view'
 import {
   customElementExprChecks,
   expandElementExprChecks,
   incomingExpressionChecks,
   outgoingExpressionChecks
-} from "./view-predicates/index.js";
-export function registerValidationChecks(services) {
-  logger.info("registerValidationChecks");
-  const registry = services.validation.ValidationRegistry;
-  registry.register({
+} from './view-predicates'
+
+export function registerValidationChecks(services: LikeC4Services) {
+  logger.info('registerValidationChecks')
+  const registry = services.validation.ValidationRegistry
+  registry.register<ast.LikeC4AstType>({
     OpacityProperty: opacityPropertyRuleChecks(services),
     SpecificationRule: specificationRuleChecks(services),
     Model: modelRuleChecks(services),
@@ -39,17 +42,18 @@ export function registerValidationChecks(services) {
     RelationshipKind: relationshipChecks(services),
     IncomingExpr: incomingExpressionChecks(services),
     OutgoingExpr: outgoingExpressionChecks(services)
-  });
-  const connection = services.shared.lsp.Connection;
+  })
+  const connection = services.shared.lsp.Connection
   if (connection) {
+    // workaround for bug in langium
     services.shared.workspace.DocumentBuilder.onUpdate((_, deleted) => {
       for (const uri of deleted) {
-        logger.debug(`clear diagnostics for deleted ${uri.path}`);
+        logger.debug(`clear diagnostics for deleted ${uri.path}`)
         void connection.sendDiagnostics({
           uri: uri.toString(),
           diagnostics: []
-        });
+        })
       }
-    });
+    })
   }
 }

package/src/validation/property-checks.ts

@@ -0,0 +1,17 @@
+import type { ValidationCheck } from 'langium'
+import type { ast } from '../ast'
+import type { LikeC4Services } from '../module'
+
+export const opacityPropertyRuleChecks = (
+  _: LikeC4Services
+): ValidationCheck<ast.OpacityProperty> => {
+  return (node, accept) => {
+    const opacity = parseFloat(node.value)
+    if (isNaN(opacity) || opacity < 0 || opacity > 100) {
+      accept('warning', `Value ignored, must be between 0% and 100%`, {
+        node,
+        property: 'value'
+      })
+    }
+  }
+}

package/src/validation/relation.ts

@@ -0,0 +1,57 @@
+import { isSameHierarchy } 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'
+
+export const relationChecks = (services: LikeC4Services): ValidationCheck<ast.Relation> => {
+  const fqnIndex = services.likec4.FqnIndex
+  return (el, accept) => {
+    try {
+      const targetEl: ast.Element | undefined = elementRef(el.target)
+      const target = targetEl && fqnIndex.getFqn(targetEl)
+      if (!target) {
+        accept('error', 'Target not found (not parsed/indexed yet)', {
+          node: el,
+          property: 'target'
+        })
+      }
+      let sourceEl
+      if (ast.isExplicitRelation(el)) {
+        sourceEl = elementRef(el.source)
+        if (!sourceEl) {
+          return accept('error', 'Source not found (not parsed/indexed yet)', {
+            node: el,
+            property: 'source'
+          })
+        }
+      } else {
+        sourceEl = el.$container.$container
+      }
+
+      const source = fqnIndex.getFqn(sourceEl)
+
+      if (!source) {
+        accept('error', 'Source not found (not parsed/indexed yet)', {
+          node: el
+        })
+      }
+
+      if (source && target && isSameHierarchy(source, target)) {
+        accept('error', 'Invalid parent-child relationship', {
+          node: el
+        })
+      }
+
+      if (el.tags?.value && el.body?.tags?.value) {
+        accept('error', 'Relation cannot have tags in both header and body', {
+          node: el,
+          property: 'tags'
+        })
+      }
+    } catch (e) {
+      logError(e)
+    }
+  }
+}

package/src/validation/specification.ts

@@ -0,0 +1,118 @@
+import { AstUtils, type ValidationCheck } from 'langium'
+import { ast } from '../ast'
+import type { LikeC4Services } from '../module'
+
+export const specificationRuleChecks = (
+  _: LikeC4Services
+): ValidationCheck<ast.SpecificationRule> => {
+  return (node, accept) => {
+    if (node.$containerIndex && node.$containerIndex > 0) {
+      accept('error', `Only one specification per document is allowed`, {
+        node: node,
+        property: 'name'
+      })
+    }
+  }
+}
+
+export const modelRuleChecks = (_: LikeC4Services): ValidationCheck<ast.Model> => {
+  return (node, accept) => {
+    if (node.$containerIndex && node.$containerIndex > 0) {
+      accept('error', `Only one model per document is allowed`, {
+        node: node,
+        property: 'name'
+      })
+    }
+  }
+}
+
+export const modelViewsChecks = (_: LikeC4Services): ValidationCheck<ast.ModelViews> => {
+  return (node, accept) => {
+    if (node.$containerIndex && node.$containerIndex > 0) {
+      accept('error', `Only one views block per document is allowed`, {
+        node: node,
+        property: 'name'
+      })
+    }
+  }
+}
+
+export const elementKindChecks = (services: LikeC4Services): ValidationCheck<ast.ElementKind> => {
+  const index = services.shared.workspace.IndexManager
+  return (node, accept) => {
+    const sameKind = index
+      .allElements(ast.ElementKind)
+      .filter(n => n.name === node.name && n.node !== node)
+      .head()
+    if (sameKind) {
+      const isAnotherDoc = sameKind.documentUri !== AstUtils.getDocument(node).uri
+      accept('error', `Duplicate element kind '${node.name}'`, {
+        node: node,
+        property: 'name',
+        ...isAnotherDoc && {
+          relatedInformation: [
+            {
+              location: {
+                range: sameKind.nameSegment!.range,
+                uri: sameKind.documentUri.toString()
+              },
+              message: `conflicting definition`
+            }
+          ]
+        }
+      })
+    }
+  }
+}
+
+export const tagChecks = (services: LikeC4Services): ValidationCheck<ast.Tag> => {
+  const index = services.shared.workspace.IndexManager
+  return (node, accept) => {
+    const tagname = '#' + node.name
+    const sameTag = index
+      .allElements(ast.Tag)
+      .filter(n => n.name === tagname && n.node !== node)
+      .head()
+    if (sameTag) {
+      const isAnotherDoc = sameTag.documentUri !== AstUtils.getDocument(node).uri
+      accept(
+        'error',
+        `Duplicate tag '${node.name}'`,
+        {
+          node,
+          property: 'name',
+          ...isAnotherDoc && {
+            relatedInformation: [
+              {
+                location: {
+                  range: sameTag.nameSegment!.range,
+                  uri: sameTag.documentUri.toString()
+                },
+                message: `conflicting definition`
+              }
+            ]
+          }
+        }
+      )
+    }
+  }
+}
+
+export const relationshipChecks = (
+  services: LikeC4Services
+): ValidationCheck<ast.RelationshipKind> => {
+  const index = services.shared.workspace.IndexManager
+  return (node, accept) => {
+    const sameKinds = index
+      .allElements(ast.RelationshipKind)
+      .filter(n => n.name === node.name)
+      .limit(2)
+      .count()
+    if (sameKinds > 1) {
+      accept('error', `Duplicate RelationshipKind '${node.name}'`, {
+        node: node,
+        property: 'name'
+      })
+    }
+  }
+}

package/src/validation/view-predicates/custom-element-expr.ts

@@ -0,0 +1,21 @@
+import type { ValidationCheck } from 'langium'
+import { ast } from '../../ast'
+import type { LikeC4Services } from '../../module'
+
+export const customElementExprChecks = (
+  _services: LikeC4Services
+): ValidationCheck<ast.CustomElementExpr> => {
+  return (el, accept) => {
+    if (ast.isExcludePredicate(el.$container)) {
+      accept('error', 'Invalid inside "exclude"', {
+        node: el
+      })
+    }
+    if (!ast.isElementRef(el.target)) {
+      accept('error', 'Invalid target for customization', {
+        node: el,
+        property: 'target'
+      })
+    }
+  }
+}

package/{dist/validation/view-predicates/expanded-element.js → src/validation/view-predicates/expanded-element.ts}

@@ -1,29 +1,34 @@
-import { nonexhaustive } from "@likec4/core";
-import { ast } from "../../ast.js";
-export const expandElementExprChecks = (_services) => {
+import { nonexhaustive } from '@likec4/core'
+import type { ValidationCheck } from 'langium'
+import { ast } from '../../ast'
+import type { LikeC4Services } from '../../module'
+
+export const expandElementExprChecks = (
+  _services: LikeC4Services
+): ValidationCheck<ast.ExpandElementExpr> => {
   return (el, accept) => {
     switch (true) {
       case ast.isIncludePredicate(el.$container):
       case ast.isDynamicViewRulePredicate(el.$container):
       case ast.isViewRuleStyle(el.$container):
-        return;
+        return
       case ast.isCustomElementExpr(el.$container):
-        return accept("warning", `Custom rules apply only to parent`, {
+        return accept('warning', `Custom rules apply only to parent`, {
           node: el
-        });
+        })
       case ast.isExcludePredicate(el.$container):
-        return accept("warning", `Ignored, as can't be used in exclude`, {
+        return accept('warning', `Ignored, as can't be used in exclude`, {
           node: el
-        });
+        })
       case ast.isInOutExpr(el.$container):
       case ast.isIncomingExpr(el.$container):
       case ast.isOutgoingExpr(el.$container):
       case ast.isRelationExpr(el.$container):
-        return accept("warning", `Wrong usage of expanded element in relations predicate`, {
+        return accept('warning', `Wrong usage of expanded element in relations predicate`, {
           node: el
-        });
+        })
       default:
-        nonexhaustive(el.$container);
+        nonexhaustive(el.$container)
     }
-  };
-};
+  }
+}

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

@@ -0,0 +1,19 @@
+import type { ValidationCheck } from 'langium'
+import { isNullish } from 'remeda'
+import { ast } from '../../ast'
+import type { LikeC4Services } from '../../module'
+
+export const incomingExpressionChecks = (
+  _services: LikeC4Services
+): ValidationCheck<ast.IncomingExpr> => {
+  return (el, accept) => {
+    if (ast.isWildcardExpr(el.to) && ast.isViewRulePredicate(el.$container)) {
+      const view = el.$container.$container.$container
+      if (isNullish(view.viewOf)) {
+        accept('warning', 'Predicate is ignored as it concerns all relationships', {
+          node: el
+        })
+      }
+    }
+  }
+}

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

@@ -0,0 +1,4 @@
+export * from './custom-element-expr'
+export * from './expanded-element'
+export * from './incoming'
+export * from './outgoing'

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

@@ -0,0 +1,19 @@
+import type { ValidationCheck } from 'langium'
+import { isNullish } from 'remeda'
+import { ast } from '../../ast'
+import type { LikeC4Services } from '../../module'
+
+export const outgoingExpressionChecks = (
+  _services: LikeC4Services
+): ValidationCheck<ast.OutgoingExpr> => {
+  return (el, accept) => {
+    if (ast.isWildcardExpr(el.from)) {
+      const view = el.$container.$container.$container
+      if (view.$type === 'ElementView' && isNullish(view.viewOf)) {
+        accept('warning', 'Predicate is ignored as it concerns all relationships', {
+          node: el
+        })
+      }
+    }
+  }
+}

package/src/validation/view.ts

@@ -0,0 +1,26 @@
+import type { ValidationCheck } from 'langium'
+import { ast } from '../ast'
+import type { LikeC4Services } from '../module'
+
+export const viewChecks = (services: LikeC4Services): ValidationCheck<ast.LikeC4View> => {
+  const index = services.shared.workspace.IndexManager
+  return (el, accept) => {
+    // if (el.extends) {
+    //   // TODO: circular dependency check
+    // }
+    if (!el.name) {
+      return
+    }
+    const anotherViews = index
+      .allElements(ast.LikeC4View)
+      .filter(n => n.name === el.name)
+      .limit(2)
+      .count()
+    if (anotherViews > 1) {
+      accept('error', `Duplicate view '${el.name}'`, {
+        node: el,
+        property: 'name'
+      })
+    }
+  }
+}

package/src/view-utils/assignNavigateTo.ts

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

package/src/view-utils/index.ts

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

package/src/view-utils/resolve-extended-views.ts

@@ -0,0 +1,57 @@
+import graphlib from '@dagrejs/graphlib'
+import { isExtendsElementView, type View } from '@likec4/core'
+
+// '@dagrejs/graphlib' is a CommonJS module
+// Here is a workaround to import it
+const { Graph, alg } = graphlib
+
+/**
+ * Resolve rules of extended views
+ * (Removes invalid views)
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function resolveRulesExtendedViews<V extends Record<any, View>>(
+  unresolvedViews: V
+): V {
+  const g = new Graph({
+    directed: true,
+    multigraph: false,
+    compound: false
+  })
+  for (const view of Object.values(unresolvedViews)) {
+    g.setNode(view.id)
+    if (isExtendsElementView(view)) {
+      // view -> parent
+      g.setEdge(view.id, view.extends)
+    }
+  }
+
+  // Remove circular dependencies
+  const cycles = alg.findCycles(g)
+  if (cycles.length > 0) {
+    cycles.flat().forEach(id => g.removeNode(id))
+  }
+
+  const ordered = alg.postorder(g, g.sources())
+
+  return ordered.reduce((acc, id) => {
+    const view = unresolvedViews[id]
+    if (!view) {
+      return acc
+    }
+    if (isExtendsElementView(view)) {
+      const extendsFrom = acc[view.extends]
+      if (!extendsFrom) {
+        return acc
+      }
+      return Object.assign(acc, {
+        [view.id]: {
+          ...extendsFrom,
+          ...view,
+          rules: [...extendsFrom.rules, ...view.rules]
+        }
+      })
+    }
+    return Object.assign(acc, { [view.id]: view })
+  }, {} as V)
+}

package/src/view-utils/resolve-relative-paths.ts

@@ -0,0 +1,84 @@
+import type { View } from '@likec4/core'
+import { invariant } from '@likec4/core'
+import { hasAtLeast, unique, zip } from 'remeda'
+
+function commonAncestorPath(views: View[], sep = '/') {
+  if (views.length <= 1) return ''
+  const uniqURIs = unique(views.flatMap(({ docUri }) => (docUri ? [docUri] : [])))
+  if (uniqURIs.length === 0) return ''
+  if (uniqURIs.length === 1) {
+    invariant(hasAtLeast(uniqURIs, 1))
+    return new URL(uniqURIs[0]).pathname
+  }
+  invariant(hasAtLeast(uniqURIs, 2), 'Expected at least 2 unique URIs')
+  const [baseUri, ...tail] = uniqURIs
+  const parts = new URL(baseUri).pathname.split(sep)
+  let endOfPrefix = parts.length
+  for (const uri of tail) {
+    if (uri === baseUri) {
+      continue
+    }
+    const compare = new URL(uri).pathname.split(sep)
+    for (let i = 0; i < endOfPrefix; i++) {
+      if (compare[i] !== parts[i]) {
+        endOfPrefix = i
+      }
+    }
+    if (endOfPrefix === 0) return ''
+  }
+  const prefix = parts.slice(0, endOfPrefix).join(sep)
+  return prefix.endsWith(sep) ? prefix : prefix + sep
+}
+
+export function resolveRelativePaths(views: View[]): View[] {
+  const commonPrefix = commonAncestorPath(views)
+  return (
+    views
+      // For each view, compute the relative path to the common prefix
+      // Store array of path segments
+      .map(view => {
+        if (!view.docUri) {
+          return {
+            ...view,
+            parts: []
+          }
+        }
+        const path = new URL(view.docUri).pathname
+        const parts = path.replace(commonPrefix, '').split('/')
+        parts.pop() // remove filename
+        return {
+          ...view,
+          parts
+        }
+      })
+      // Sort views by path segments
+      .sort((a, b) => {
+        if (a.parts.length === b.parts.length) {
+          if (a.parts.length === 0) {
+            return 0
+          }
+          if (a.parts.length === 1 && hasAtLeast(a.parts, 1) && hasAtLeast(b.parts, 1)) {
+            return a.parts[0].localeCompare(b.parts[0])
+          }
+          for (const [_a, _b] of zip(a.parts, b.parts)) {
+            const compare = _a.localeCompare(_b)
+            if (compare !== 0) {
+              return compare
+            }
+          }
+          return 0
+        }
+        return a.parts.length - b.parts.length
+      })
+      // Build relativePath from path segments
+      .map(({ parts, ...view }) => {
+        if (view.docUri) {
+          return {
+            ...view,
+            relativePath: parts.join('/')
+          }
+        }
+        return view
+      })
+  )
+}

package/dist/Rpc.d.ts

@@ -1,10 +0,0 @@
-import type { LikeC4Services } from './module';
-import { Disposable } from 'langium';
-export declare class Rpc implements Disposable {
-    private services;
-    private disposables;
-    constructor(services: LikeC4Services);
-    init(): void;
-    dispose(): void;
-}
-//# sourceMappingURL=Rpc.d.ts.map