@likec4/language-server 1.7.4 → 1.8.1

package/src/model-graph/utils/applyCustomElementProperties.ts

@@ -1,6 +1,6 @@
 import type { ComputedNode, ViewRule } from '@likec4/core'
-import { Expr, nonNullable } from '@likec4/core'
-import { isEmpty, isNonNullish, isNullish, omitBy, pickBy } from 'remeda'
+import { Expr } from '@likec4/core'
+import { isEmpty, isNullish, omitBy } from 'remeda'
 import { elementExprToPredicate } from './elementExpressionToPredicate'
 
 export function applyCustomElementProperties(_rules: ViewRule[], _nodes: ComputedNode[]) {
@@ -15,12 +15,13 @@ export function applyCustomElementProperties(_rules: ViewRule[], _nodes: Compute
     } of rules
   ) {
     const { border, opacity, ...rest } = omitBy(props, isNullish)
+    const notEmpty = !isEmpty(rest)
     const satisfies = elementExprToPredicate(expr)
     nodes.forEach((node, i) => {
       if (!satisfies(node)) {
         return
       }
-      if (!isEmpty(rest)) {
+      if (notEmpty) {
         node = {
           ...node,
           isCustomized: true,

package/src/model-graph/utils/applyViewRuleStyles.ts

@@ -25,6 +25,9 @@ export function applyViewRuleStyles(_rules: ViewRule[], nodes: ComputedNode[]) {
       if (isDefined(rule.style.icon)) {
         n.icon = rule.style.icon
       }
+      if (isDefined(rule.notation)) {
+        n.notation = rule.notation
+      }
       let styleOverride: ComputedNode['style'] | undefined
       if (isDefined(rule.style.border)) {
         styleOverride = { border: rule.style.border }

package/src/model-graph/utils/buildElementNotations.ts

@@ -0,0 +1,63 @@
+import type { ComputedNode, ElementNotation } from '@likec4/core'
+import { entries, flatMap, groupBy, map, mapValues, pipe, piped, prop, sortBy, unique } from 'remeda'
+
+/**
+ * Build element notations from computed nodes:
+ * 1. Group by notation
+ * 2. Group by shape
+ * 3. Group by color
+ * 4. For each group get unique kinds
+ * 5. Unwind the groups
+ */
+export function buildElementNotations(nodes: ComputedNode[]): ElementNotation[] {
+  return pipe(
+    nodes,
+    groupBy(prop('notation')),
+    mapValues(
+      piped(
+        groupBy(prop('shape')),
+        mapValues(
+          piped(
+            groupBy(prop('color')),
+            mapValues(
+              piped(
+                map(prop('kind')),
+                unique()
+              )
+            ),
+            entries(),
+            map(([color, kinds]) => ({
+              kinds,
+              color
+            }))
+          )
+        ),
+        entries(),
+        flatMap(([shape, colors]) =>
+          colors.map(({ color, kinds }) => ({
+            shape,
+            color,
+            kinds
+          }))
+        )
+      )
+    ),
+    entries(),
+    flatMap(([title, shapes]) =>
+      shapes.map(({ shape, color, kinds }) => ({
+        title,
+        shape,
+        color,
+        kinds
+      }))
+    ),
+    sortBy(
+      prop('title'),
+      prop('shape'),
+      [
+        n => n.kinds.length,
+        'desc'
+      ]
+    )
+  )
+}

package/src/references/scope-computation.ts

@@ -82,15 +82,15 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
     docExports: AstNodeDescription[],
     document: LikeC4LangiumDocument
   ) {
-    if (isNullish(likec4lib) || likec4lib.length === 0) {
+    if (isNullish(likec4lib)) {
       return
     }
-    for (const iconAst of likec4lib.flatMap(l => l.icons)) {
-      try {
+    try {
+      for (const iconAst of likec4lib.flatMap(l => l.icons)) {
         docExports.push(this.descriptions.createDescription(iconAst, iconAst.name, document))
-      } catch (e) {
-        logError(e)
       }
+    } catch (e) {
+      logError(e)
     }
   }
 

package/src/references/scope-provider.ts

@@ -1,4 +1,4 @@
-import type { likec4 as c4 } from '@likec4/core'
+import { invariant, type likec4 as c4 } from '@likec4/core'
 import type { AstNode } from 'langium'
 import {
   type AstNodeDescription,
@@ -7,6 +7,7 @@ import {
   DONE_RESULT,
   EMPTY_SCOPE,
   EMPTY_STREAM,
+  MapScope,
   type ReferenceInfo,
   type Scope,
   type Stream,
@@ -102,6 +103,17 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
           if (parent) {
             return new StreamScope(this.scopeElementRef(parent))
           }
+          // if we have elementRef "this" or "it" we resolve it to the closest element
+          if (context.reference.$refText === 'this' || context.reference.$refText === 'it') {
+            const closestElement = AstUtils.getContainerOfType(container, ast.isElement)
+            if (closestElement) {
+              return new MapScope([
+                this.descriptions.createDescription(closestElement, context.reference.$refText)
+              ])
+            } else {
+              return EMPTY_SCOPE
+            }
+          }
         }
         return this.computeScope(context)
       } catch (e) {
@@ -116,26 +128,26 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
 
   protected computeScope(context: ReferenceInfo) {
     const referenceType = this.reflection.getReferenceType(context)
+    // computeScope is called only for elements
+    invariant(referenceType === ast.Element, 'Invalid reference type')
     const scopes: Stream<AstNodeDescription>[] = []
     const doc = getDocument(context.container)
     const precomputed = doc.precomputedScopes
 
     if (precomputed) {
       const byReferenceType = (desc: AstNodeDescription) => this.reflection.isSubtype(desc.type, referenceType)
-
       let container: AstNode | undefined = context.container
       while (container) {
         const elements = precomputed.get(container).filter(byReferenceType)
         if (elements.length > 0) {
           scopes.push(stream(elements))
         }
-        if (referenceType === ast.Element) {
-          if (ast.isExtendElementBody(container)) {
-            scopes.push(this.scopeExtendElement(container.$container))
-          }
-          if (ast.isElementViewBody(container)) {
-            scopes.push(this.scopeElementView(container.$container))
-          }
+
+        if (ast.isExtendElementBody(container)) {
+          scopes.push(this.scopeExtendElement(container.$container))
+        }
+        if (ast.isElementViewBody(container)) {
+          scopes.push(this.scopeElementView(container.$container))
         }
         container = container.$container
       }

package/src/validation/_shared.ts

@@ -0,0 +1,24 @@
+import { type AstNode, interruptAndCheck, type ValidationAcceptor, type ValidationCheck } from 'langium'
+import type { CancellationToken } from 'vscode-jsonrpc'
+import { logWarnError } from '../logger'
+
+export const RESERVED_WORDS = [
+  'this',
+  'it',
+  'self',
+  'super',
+  'likec4lib'
+]
+
+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)
+    } catch (e) {
+      logWarnError(e)
+    }
+  }
+}

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

@@ -9,10 +9,6 @@ export const dynamicViewRulePredicate = (
   return (predicate, accept) => {
     const expr = elementExpressionFromPredicate(predicate.value)
     switch (true) {
-      case ast.isElementRef(expr):
-      case ast.isElementDescedantsExpression(expr):
-      case ast.isExpandElementExpression(expr):
-        return
       case ast.isElementKindExpression(expr):
       case ast.isElementTagExpression(expr):
       case ast.isWildcardExpression(expr): {
@@ -21,8 +17,6 @@ export const dynamicViewRulePredicate = (
         })
         return
       }
-      default:
-        nonexhaustive(expr)
     }
   }
 }

package/src/validation/element.ts

@@ -1,13 +1,14 @@
 import { AstUtils, type ValidationCheck } from 'langium'
 import type { ast } from '../ast'
 import type { LikeC4Services } from '../module'
+import { RESERVED_WORDS, tryOrLog } from './_shared'
 
 const { getDocument } = AstUtils
 
 export const elementChecks = (services: LikeC4Services): ValidationCheck<ast.Element> => {
   const fqnIndex = services.likec4.FqnIndex
   const locator = services.workspace.AstNodeLocator
-  return (el, accept) => {
+  return tryOrLog((el, accept) => {
     const fqn = fqnIndex.getFqn(el)
     if (!fqn) {
       accept('error', 'Not indexed element', {
@@ -16,6 +17,12 @@ export const elementChecks = (services: LikeC4Services): ValidationCheck<ast.Ele
       })
       return
     }
+    if (RESERVED_WORDS.includes(el.name)) {
+      accept('error', `Reserved word: ${el.name}`, {
+        node: el,
+        property: 'name'
+      })
+    }
     const doc = getDocument(el)
     const docUri = doc.uri
     const elPath = locator.getAstNodePath(el)
@@ -45,12 +52,5 @@ export const elementChecks = (services: LikeC4Services): ValidationCheck<ast.Ele
         }
       )
     }
-    // for (let i = 3; i < el.props.length; i++) {
-    //   accept('error', `Too many properties, max 3 allowed`, {
-    //     node: el,
-    //     property: 'props',
-    //     index: i
-    //   })
-    // }
-  }
+  })
 }

package/src/validation/index.ts

@@ -5,7 +5,7 @@ import { dynamicViewRulePredicate } from './dynamic-view-rule'
 import { dynamicViewStep } from './dynamic-view-step'
 import { elementChecks } from './element'
 import { iconPropertyRuleChecks, opacityPropertyRuleChecks } from './property-checks'
-import { relationChecks } from './relation'
+import { relationBodyChecks, relationChecks } from './relation'
 import {
   elementKindChecks,
   modelRuleChecks,
@@ -37,6 +37,7 @@ export function registerValidationChecks(services: LikeC4Services) {
     Element: elementChecks(services),
     ElementKind: elementKindChecks(services),
     Relation: relationChecks(services),
+    RelationBody: relationBodyChecks(services),
     Tag: tagChecks(services),
     DynamicViewPredicateIterator: dynamicViewRulePredicate(services),
     ElementPredicateWith: elementPredicateWithChecks(services),

package/src/validation/property-checks.ts

@@ -28,7 +28,7 @@ export const iconPropertyRuleChecks = (
       })
     }
     if (
-      ast.isStyleProperties(container) && ast.isElementBody(container.$container)
+      ast.isElementStyleProperty(container) && ast.isElementBody(container.$container)
       && container.$container.props.some(p => ast.isIconProperty(p))
     ) {
       accept('warning', `Redundant as icon defined on element`, {

package/src/validation/relation.ts

@@ -1,57 +1,63 @@
 import { isSameHierarchy } from '@likec4/core'
 import type { ValidationCheck } from 'langium'
+import { isDefined } from 'remeda'
 import { ast } from '../ast'
 import { elementRef } from '../elementRef'
-import { logError } from '../logger'
 import type { LikeC4Services } from '../module'
+import { tryOrLog } from './_shared'
 
 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)', {
+  return tryOrLog((el, accept) => {
+    const targetEl: ast.Element | undefined = elementRef(el.target)
+    const target = targetEl && fqnIndex.getFqn(targetEl)
+    if (!target) {
+      accept('error', 'Target not resolved', {
+        node: el,
+        property: 'target'
+      })
+    }
+    let sourceEl
+    if (isDefined(el.source)) {
+      sourceEl = elementRef(el.source)
+      if (!sourceEl) {
+        return accept('error', 'Source not resolved', {
           node: el,
-          property: 'target'
+          property: 'source'
         })
       }
-      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)', {
+    } else {
+      if (!ast.isElementBody(el.$container)) {
+        return accept('error', 'Sourceless relation must be nested', {
           node: el
         })
       }
+      sourceEl = el.$container.$container
+    }
 
-      if (source && target && isSameHierarchy(source, target)) {
-        accept('error', 'Invalid parent-child relationship', {
-          node: el
-        })
-      }
+    const source = fqnIndex.getFqn(sourceEl)
 
-      if (el.tags?.values && el.body?.tags?.values) {
-        accept('error', 'Relation cannot have tags in both header and body', {
-          node: el,
-          property: 'tags'
-        })
-      }
-    } catch (e) {
-      logError(e)
+    if (!source) {
+      accept('error', 'Source not resolved', {
+        node: el
+      })
+    }
+
+    if (source && target && isSameHierarchy(source, target)) {
+      accept('error', 'Invalid parent-child relationship', {
+        node: el
+      })
+    }
+  })
+}
+
+export const relationBodyChecks = (_services: LikeC4Services): ValidationCheck<ast.RelationBody> => {
+  return tryOrLog((body, accept) => {
+    const relation = body.$container
+    if (relation.tags?.values && body.tags?.values) {
+      accept('error', 'Relation cannot have tags in both header and body', {
+        node: body.tags
+      })
     }
-  }
+  })
 }

package/src/validation/specification.ts

@@ -1,6 +1,7 @@
 import { AstUtils, type ValidationCheck } from 'langium'
 import { ast } from '../ast'
 import type { LikeC4Services } from '../module'
+import { RESERVED_WORDS, tryOrLog } from './_shared'
 
 export const specificationRuleChecks = (
   _: LikeC4Services
@@ -39,7 +40,13 @@ export const modelViewsChecks = (_: LikeC4Services): ValidationCheck<ast.ModelVi
 
 export const elementKindChecks = (services: LikeC4Services): ValidationCheck<ast.ElementKind> => {
   const index = services.shared.workspace.IndexManager
-  return (node, accept) => {
+  return tryOrLog((node, accept) => {
+    if (RESERVED_WORDS.includes(node.name)) {
+      accept('error', `Reserved word: ${node.name}`, {
+        node: node,
+        property: 'name'
+      })
+    }
     const sameKind = index
       .allElements(ast.ElementKind)
       .filter(n => n.name === node.name && n.node !== node)
@@ -62,7 +69,7 @@ export const elementKindChecks = (services: LikeC4Services): ValidationCheck<ast
         }
       })
     }
-  }
+  })
 }
 
 export const tagChecks = (services: LikeC4Services): ValidationCheck<ast.Tag> => {
@@ -103,6 +110,12 @@ export const relationshipChecks = (
 ): ValidationCheck<ast.RelationshipKind> => {
   const index = services.shared.workspace.IndexManager
   return (node, accept) => {
+    if (RESERVED_WORDS.includes(node.name)) {
+      accept('error', `Reserved word: ${node.name}`, {
+        node: node,
+        property: 'name'
+      })
+    }
     const sameKinds = index
       .allElements(ast.RelationshipKind)
       .filter(n => n.name === node.name)

package/src/validation/view.ts

@@ -1,6 +1,7 @@
 import { type ValidationCheck } from 'langium'
 import { ast } from '../ast'
 import type { LikeC4Services } from '../module'
+import { RESERVED_WORDS } from './_shared'
 
 export const viewChecks = (services: LikeC4Services): ValidationCheck<ast.LikeC4View> => {
   const index = services.shared.workspace.IndexManager
@@ -15,6 +16,12 @@ export const viewChecks = (services: LikeC4Services): ValidationCheck<ast.LikeC4
     if (!el.name) {
       return
     }
+    if (RESERVED_WORDS.includes(el.name)) {
+      accept('error', `Reserved word: ${el.name}`, {
+        node: el,
+        property: 'name'
+      })
+    }
     const anotherViews = index
       .allElements(ast.LikeC4View)
       .filter(n => n.name === el.name)

package/src/view-utils/view-hash.ts

@@ -1,6 +1,6 @@
 import type { ComputedView } from '@likec4/core/types'
 import objectHash from 'object-hash'
-import { isString, pick } from 'remeda'
+import { isTruthy, map, mapToObj, pick, pipe } from 'remeda'
 import type { SetOptional } from 'type-fest'
 
 export function calcViewLayoutHash<V extends ComputedView>(view: SetOptional<V, 'hash'>): V {
@@ -8,26 +8,20 @@ export function calcViewLayoutHash<V extends ComputedView>(view: SetOptional<V,
     id: view.id,
     __: view.__ ?? 'element',
     autoLayout: view.autoLayout,
-    nodes: view.nodes
-      .map(pick(['id', 'title', 'description', 'technology', 'shape', 'icon', 'children']))
-      .toSorted((a, b) => a.id.localeCompare(b.id)),
-    edges: view.edges
-      .map(pick(['id', 'source', 'target', 'label', 'description', 'technology', 'dir', 'head', 'tail', 'line']))
-      .toSorted((a, b) => a.id.localeCompare(b.id))
+    nodes: pipe(
+      view.nodes,
+      map(pick(['id', 'title', 'description', 'technology', 'shape', 'icon', 'children'])),
+      mapToObj(({ id, icon, ...node }) => [id, { ...node, icon: isTruthy(icon) ? 'Y' : 'N' }])
+    ),
+    edges: pipe(
+      view.edges,
+      map(pick(['source', 'target', 'label', 'description', 'technology', 'dir', 'head', 'tail', 'line'])),
+      mapToObj(({ source, target, ...edge }) => [`${source}:${target}`, edge])
+    )
   }
   view.hash = objectHash(tohash, {
     ignoreUnknown: true,
-    respectType: false,
-    replacer(value) {
-      if (!isString(value)) {
-        return value
-      }
-      value = value.trim()
-      if (value.match('^(aws|tech|gcp|https|http)')) {
-        value = 'U' // hide urls
-      }
-      return value
-    }
+    respectType: false
   })
   return view as V
 }