@likec4/language-server 1.23.1 → 1.24.1

package/dist/model/model-builder.js

@@ -1,532 +1,84 @@
 import {
-  compareRelations,
-  computeColorValues,
-  DeploymentElement,
   isScopedElementView,
-  LikeC4Model,
-  parentFqn,
-  sortByFqnHierarchically
+  LikeC4Model
 } from "@likec4/core";
-import { resolveRulesExtendedViews } from "@likec4/core/compute-view";
+import { loggable } from "@likec4/log";
 import { deepEqual as eq } from "fast-equals";
-import { Disposable, DocumentState, interruptAndCheck } from "langium";
+import {
+  Disposable,
+  DocumentState
+} from "langium";
 import {
   filter,
-  flatMap,
   groupBy,
-  hasAtLeast,
-  indexBy,
-  isBoolean,
-  isDefined,
-  isEmpty,
-  isNonNullish,
-  isNullish,
-  isNumber,
-  isTruthy,
-  map,
   mapToObj,
-  mapValues,
-  omit,
   pipe,
-  prop,
-  reduce,
-  reverse,
-  sort,
-  unique,
   values
 } from "remeda";
-import { isParsedLikeC4LangiumDocument } from "../ast.js";
-import { logger, logWarnError } from "../logger.js";
+import { logger as mainLogger, logWarnError } from "../logger.js";
 import { ADisposable } from "../utils/index.js";
-import { assignNavigateTo, resolveRelativePaths } from "../view-utils/index.js";
-function buildModel(services, docs) {
-  const c4Specification = {
-    tags: /* @__PURE__ */ new Set(),
-    deployments: {},
-    elements: {},
-    relationships: {},
-    colors: {}
-  };
-  const globals = {
-    predicates: {},
-    dynamicPredicates: {},
-    styles: {}
-  };
-  for (const doc of docs) {
-    const {
-      c4Specification: spec,
-      c4Globals
-    } = doc;
-    spec.tags.forEach((t) => c4Specification.tags.add(t));
-    Object.assign(c4Specification.elements, spec.elements);
-    Object.assign(c4Specification.relationships, spec.relationships);
-    Object.assign(c4Specification.colors, spec.colors);
-    Object.assign(c4Specification.deployments, spec.deployments);
-    Object.assign(globals.predicates, c4Globals.predicates);
-    Object.assign(globals.dynamicPredicates, c4Globals.dynamicPredicates);
-    Object.assign(globals.styles, c4Globals.styles);
-  }
-  function resolveLinks(doc, links) {
-    return map(
-      links,
-      (link) => {
-        try {
-          const relative = services.lsp.DocumentLinkProvider.relativeLink(doc, link.url);
-          if (relative && relative !== link.url) {
-            return {
-              ...link,
-              relative
-            };
-          }
-        } catch (e) {
-          logWarnError(e);
-        }
-        return link;
-      }
-    );
-  }
-  const customColorDefinitions = mapValues(
-    c4Specification.colors,
-    (c) => computeColorValues(c.color)
-  );
-  function toModelElement(doc) {
-    return ({
-      tags,
-      links: unresolvedLinks,
-      style: {
-        color,
-        shape,
-        icon,
-        opacity,
-        border,
-        size,
-        multiple,
-        padding,
-        textSize
-      },
-      id,
-      kind,
-      title,
-      description,
-      technology,
-      metadata
-    }) => {
-      try {
-        const __kind = c4Specification.elements[kind];
-        if (!__kind) {
-          logger.warn`No kind '${kind}' found for ${id}`;
-          return null;
-        }
-        const links = unresolvedLinks ? resolveLinks(doc, unresolvedLinks) : null;
-        color ??= __kind.style.color;
-        shape ??= __kind.style.shape;
-        icon ??= __kind.style.icon;
-        opacity ??= __kind.style.opacity;
-        border ??= __kind.style.border;
-        technology ??= __kind.technology;
-        multiple ??= __kind.style.multiple;
-        size ??= __kind.style.size;
-        padding ??= __kind.style.padding;
-        textSize ??= __kind.style.textSize;
-        return {
-          ...color && { color },
-          ...shape && { shape },
-          ...icon && { icon },
-          ...metadata && !isEmpty(metadata) && { metadata },
-          ...__kind.notation && { notation: __kind.notation },
-          style: {
-            ...border && { border },
-            ...size && { size },
-            ...padding && { padding },
-            ...textSize && { textSize },
-            ...isBoolean(multiple) && { multiple },
-            ...isNumber(opacity) && { opacity }
-          },
-          links,
-          tags: tags ?? null,
-          technology: technology ?? null,
-          description: description ?? null,
-          title,
-          kind,
-          id
-        };
-      } catch (e) {
-        logWarnError(e);
-      }
-      return null;
-    };
-  }
-  const elementsExtendData = /* @__PURE__ */ new Map();
-  function mergeAllC4ExtendElements(doc) {
-    for (const el of doc.c4ExtendElements) {
-      let links = el.links ? resolveLinks(doc, el.links) : null;
-      const existing = elementsExtendData.get(el.id);
-      if (existing) {
-        links = existing.links ? [...existing.links, ...links ?? []] : links;
-        let tags = [...existing.tags ?? [], ...el.tags ?? []];
-        if (!hasAtLeast(tags, 1)) {
-          tags = null;
-        }
-        elementsExtendData.set(el.id, {
-          tags,
-          links,
-          metadata: { ...existing.metadata, ...el.metadata }
-        });
-      } else {
-        elementsExtendData.set(el.id, {
-          tags: el.tags ?? null,
-          links,
-          metadata: { ...el.metadata }
-        });
-      }
-    }
-  }
-  function withExtendElementData(el) {
-    const extendData = elementsExtendData.get(el.id);
-    if (extendData) {
-      const links = [...el.links ?? [], ...extendData.links ?? []];
-      const tags = unique([...el.tags ?? [], ...extendData.tags ?? []]);
-      const metadata = { ...el.metadata, ...extendData.metadata };
-      return {
-        ...el,
-        tags: hasAtLeast(tags, 1) ? tags : null,
-        links: hasAtLeast(links, 1) ? links : null,
-        ...!isEmpty(metadata) && { metadata }
-      };
-    }
-    return el;
-  }
-  const elements = pipe(
-    docs,
-    flatMap((d) => {
-      mergeAllC4ExtendElements(d);
-      return map(d.c4Elements, toModelElement(d));
-    }),
-    filter(isTruthy),
-    // sort from root elements to nested, so that parent is always present
-    // Import to preserve the order from the source
-    sortByFqnHierarchically,
-    reduce(
-      (acc, el) => {
-        const parent = parentFqn(el.id);
-        if (parent && isNullish(acc[parent])) {
-          logger.debug`No parent found for ${el.id}`;
-          return acc;
-        }
-        acc[el.id] = withExtendElementData(el);
-        return acc;
-      },
-      {}
-    )
-  );
-  function toModelRelation(doc) {
-    return ({
-      astPath,
-      source,
-      target,
-      kind,
-      links: unresolvedLinks,
-      id,
-      ...model
-    }) => {
-      if (isNullish(elements[source]) || isNullish(elements[target])) {
-        logger.debug`Invalid relation ${id}
-  source: ${source} resolved: ${!!elements[source]}
-  target: ${target} resolved: ${!!elements[target]}
-  at ${doc.uri.path}\n`;
-        return null;
-      }
-      const links = unresolvedLinks ? resolveLinks(doc, unresolvedLinks) : null;
-      if (isNonNullish(kind) && kind in c4Specification.relationships) {
-        return {
-          ...c4Specification.relationships[kind],
-          ...model,
-          ...links && { links },
-          source,
-          target,
-          kind,
-          id
-        };
-      }
-      return {
-        ...links && { links },
-        ...model,
-        source,
-        target,
-        id
-      };
-    };
-  }
-  const relations = pipe(
-    docs,
-    flatMap((d) => map(d.c4Relations, toModelRelation(d))),
-    filter(isTruthy),
-    sort(compareRelations),
-    reverse(),
-    indexBy(prop("id"))
-  );
-  function toDeploymentElement(doc) {
-    return (parsed) => {
-      if (!DeploymentElement.isDeploymentNode(parsed)) {
-        if (!parsed.links || parsed.links.length === 0) {
-          return parsed;
-        }
-        const links = resolveLinks(doc, parsed.links);
-        return {
-          ...parsed,
-          links
-        };
-      }
-      try {
-        const __kind = c4Specification.deployments[parsed.kind];
-        if (!__kind) {
-          logger.warn`No kind ${parsed.kind} found for ${parsed.id}`;
-          return null;
-        }
-        let {
-          technology = __kind.technology,
-          notation = __kind.notation,
-          links,
-          style
-        } = parsed;
-        return {
-          ...parsed,
-          ...notation && { notation },
-          ...technology && { technology },
-          style: {
-            border: "dashed",
-            opacity: 10,
-            ...__kind.style,
-            ...style
-          },
-          links: links ? resolveLinks(doc, links) : null
-        };
-      } catch (e) {
-        logWarnError(e);
-      }
-      return null;
-    };
-  }
-  const deploymentElements = pipe(
-    docs,
-    flatMap((d) => map(d.c4Deployments, toDeploymentElement(d))),
-    filter(isTruthy),
-    // sort from root elements to nested, so that parent is always present
-    // Import to preserve the order from the source
-    sortByFqnHierarchically,
-    reduce(
-      (acc, el) => {
-        const parent = parentFqn(el.id);
-        if (parent && isNullish(acc[parent])) {
-          logger.debug`No parent found for deployment element ${el.id}`;
-          return acc;
-        }
-        acc[el.id] = el;
-        return acc;
-      },
-      {}
-    )
-  );
-  function toDeploymentRelation(doc) {
-    return ({
-      astPath,
-      source,
-      target,
-      kind,
-      links: unresolvedLinks,
-      id,
-      ...model
-    }) => {
-      if (isNullish(deploymentElements[source.id]) || isNullish(deploymentElements[target.id])) {
-        logger.warn`Invalid deployment relation ${id} at ${doc.uri.path} ${astPath}, source: ${source.id}(${!!deploymentElements[source.id]}), target: ${target.id}(${!!deploymentElements[target.id]})`;
-        return null;
-      }
-      const links = unresolvedLinks ? resolveLinks(doc, unresolvedLinks) : null;
-      if (isNonNullish(kind) && kind in c4Specification.relationships) {
-        return {
-          ...c4Specification.relationships[kind],
-          ...model,
-          ...links && { links },
-          source,
-          target,
-          kind,
-          id
-        };
-      }
-      return {
-        ...links && { links },
-        ...model,
-        source,
-        target,
-        id
-      };
-    };
-  }
-  const deploymentRelations = pipe(
-    docs,
-    flatMap((d) => map(d.c4DeploymentRelations, toDeploymentRelation(d))),
-    filter(isTruthy),
-    reduce(
-      (acc, el) => {
-        if (isDefined(acc[el.id])) {
-          logger.debug`Duplicate deployment relation ${el.id}`;
-          return acc;
-        }
-        acc[el.id] = el;
-        return acc;
-      },
-      {}
-    )
-  );
-  function toC4View(doc) {
-    const docUri = doc.uri.toString();
-    return (parsedAstView) => {
-      let {
-        id,
-        title,
-        description,
-        tags,
-        links: unresolvedLinks,
-        // ignore this property
-        astPath: _ignore,
-        // model should include discriminant __
-        ...model
-      } = parsedAstView;
-      if (parsedAstView.__ === "element" && isNullish(title) && "viewOf" in parsedAstView) {
-        title = elements[parsedAstView.viewOf]?.title ?? null;
-      }
-      if (isNullish(title) && id === "index") {
-        title = "Landscape view";
-      }
-      const links = unresolvedLinks ? resolveLinks(doc, unresolvedLinks) : null;
-      return {
-        ...model,
-        customColorDefinitions,
-        tags,
-        links,
-        docUri,
-        description,
-        title,
-        id
-      };
-    };
-  }
-  const parsedViews = pipe(
-    docs,
-    flatMap((d) => map(d.c4Views, toC4View(d))),
-    // Resolve relative paths and sort by
-    resolveRelativePaths
-  );
-  if (!parsedViews.some((v) => v.id === "index")) {
-    parsedViews.unshift({
-      __: "element",
-      id: "index",
-      title: "Landscape view",
-      description: null,
-      tags: null,
-      links: null,
-      customColorDefinitions,
-      rules: [
-        {
-          include: [
-            {
-              wildcard: true
-            }
-          ]
-        }
-      ]
-    });
-  }
-  const views = pipe(
-    parsedViews,
-    indexBy(prop("id")),
-    resolveRulesExtendedViews
-  );
-  return {
-    specification: {
-      tags: Array.from(c4Specification.tags),
-      elements: c4Specification.elements,
-      relationships: c4Specification.relationships,
-      deployments: c4Specification.deployments
-    },
-    elements,
-    relations,
-    globals,
-    views,
-    deployments: {
-      elements: deploymentElements,
-      relations: deploymentRelations
-    }
-  };
-}
+import { assignNavigateTo } from "../view-utils/index.js";
+import { buildModel } from "./builder/buildModel.js";
 const CACHE_KEY_PARSED_MODEL = "ParsedLikeC4Model";
 const CACHE_KEY_COMPUTED_MODEL = "ComputedLikeC4Model";
+const logger = mainLogger.getChild("ModelBuilder");
 export class LikeC4ModelBuilder extends ADisposable {
+  parser;
+  listeners = [];
+  cache;
+  DocumentBuilder;
+  LangiumDocuments;
   constructor(services) {
     super();
-    this.services = services;
-    this.langiumDocuments = services.shared.workspace.LangiumDocuments;
-    const parser = services.likec4.ModelParser;
+    this.parser = services.likec4.ModelParser;
+    this.cache = services.ValidatedWorkspaceCache;
+    this.DocumentBuilder = services.shared.workspace.DocumentBuilder;
+    this.LangiumDocuments = services.shared.workspace.LangiumDocuments;
     this.onDispose(
-      services.shared.workspace.DocumentBuilder.onUpdate((_changed, deleted) => {
+      this.DocumentBuilder.onUpdate((_changed, deleted) => {
         if (deleted.length > 0) {
           this.notifyListeners(deleted);
         }
       })
     );
     this.onDispose(
-      services.shared.workspace.DocumentBuilder.onBuildPhase(
+      this.DocumentBuilder.onBuildPhase(
         DocumentState.Validated,
-        async (docs, _cancelToken) => {
-          let parsed = [];
-          logger.debug`[ModelBuilder] onValidated (${docs.length} docs)`;
-          for (const doc of docs) {
-            try {
-              parsed.push(parser.parse(doc).uri);
-            } catch (e) {
-              logWarnError(e);
-            }
-          }
-          await interruptAndCheck(_cancelToken);
-          if (parsed.length > 0) {
-            this.notifyListeners(parsed);
-          }
+        (docs, _cancelToken) => {
+          this.notifyListeners(docs.map((d) => d.uri));
         }
       )
     );
-    logger.debug`[ModelBuilder] Created`;
+    logger.debug`created`;
   }
-  langiumDocuments;
-  listeners = [];
   /**
    * WARNING:
    * This method is internal and should to be called only when all documents are known to be parsed.
    * Otherwise, the model may be incomplete.
    */
-  unsafeSyncBuildModel() {
+  unsafeSyncParseModel() {
     const docs = this.documents();
     if (docs.length === 0) {
-      logger.debug("[ModelBuilder] No documents to build model from");
+      logger.debug("no documents to build model from");
       return null;
     }
-    const cache = this.services.WorkspaceCache;
+    const cache = this.cache;
     return cache.get(CACHE_KEY_PARSED_MODEL, () => {
-      logger.debug`[ModelBuilder] buildModel (${docs.length} docs)`;
-      return buildModel(this.services, docs);
+      logger.debug("unsafeSyncParseModel ({docslength} docs)", { docslength: docs.length });
+      return buildModel(docs);
     });
   }
-  async buildModel(cancelToken) {
-    const cache = this.services.WorkspaceCache;
+  async parseModel(cancelToken) {
+    const cache = this.cache;
     const cached = cache.get(CACHE_KEY_PARSED_MODEL);
     if (cached) {
-      return cached;
+      return await Promise.resolve(cached);
     }
-    return await this.services.shared.workspace.WorkspaceLock.read(async () => {
-      if (cancelToken) {
-        await interruptAndCheck(cancelToken);
-      }
-      return this.unsafeSyncBuildModel();
-    });
+    if (this.LangiumDocuments.all.some((doc) => doc.state < DocumentState.Validated)) {
+      logger.debug("parseModel: waiting for documents to be validated");
+      await this.DocumentBuilder.waitUntil(DocumentState.Validated, cancelToken);
+    }
+    return this.unsafeSyncParseModel();
   }
   previousViews = {};
   /**
@@ -534,16 +86,24 @@ export class LikeC4ModelBuilder extends ADisposable {
    * This method is internal and should to be called only when all documents are known to be parsed.
    * Otherwise, the model may be incomplete.
    */
-  unsafeSyncBuildComputedModel(model) {
-    const cache = this.services.WorkspaceCache;
-    const viewsCache = this.services.WorkspaceCache;
+  unsafeSyncBuildModel() {
+    const cache = this.cache;
+    const viewsCache = this.cache;
     return cache.get(CACHE_KEY_COMPUTED_MODEL, () => {
-      const computeView = LikeC4Model.makeCompute(model);
+      const parsed = this.unsafeSyncParseModel();
+      if (!parsed) {
+        return LikeC4Model.EMPTY;
+      }
+      const {
+        views: parsedViews,
+        ...model
+      } = parsed;
+      const computeView = LikeC4Model.makeCompute(parsed);
       const allViews = [];
-      for (const view of values(model.views)) {
+      for (const view of values(parsedViews)) {
         const result = computeView(view);
         if (!result.isSuccess) {
-          logWarnError(result.error);
+          logger.warn(loggable(result.error));
           continue;
         }
         allViews.push(result.view);
@@ -556,74 +116,69 @@ export class LikeC4ModelBuilder extends ADisposable {
         return [v.id, view];
       });
       this.previousViews = { ...views };
-      return {
-        ...omit(model, ["views"]),
+      return LikeC4Model.create({
+        ...model,
         views
-      };
+      });
     });
   }
-  async buildComputedModel(cancelToken) {
-    const cache = this.services.WorkspaceCache;
-    if (cache.has(CACHE_KEY_COMPUTED_MODEL)) {
-      return cache.get(CACHE_KEY_COMPUTED_MODEL);
+  async buildLikeC4Model(cancelToken) {
+    const cache = this.cache;
+    const cached = cache.get(CACHE_KEY_COMPUTED_MODEL);
+    if (cached) {
+      return await Promise.resolve(cached);
     }
-    return await this.services.shared.workspace.WorkspaceLock.read(async () => {
-      if (cancelToken) {
-        await interruptAndCheck(cancelToken);
-      }
-      const model = this.unsafeSyncBuildModel();
-      if (!model) {
-        return null;
-      }
-      return this.unsafeSyncBuildComputedModel(model);
-    });
+    const model = await this.parseModel(cancelToken);
+    if (!model) {
+      return LikeC4Model.EMPTY;
+    }
+    return this.unsafeSyncBuildModel();
   }
   async computeView(viewId, cancelToken) {
-    const cache = this.services.WorkspaceCache;
+    const cache = this.cache;
     const cacheKey = computedViewKey(viewId);
     if (cache.has(cacheKey)) {
       return cache.get(cacheKey);
     }
-    return await this.services.shared.workspace.WorkspaceLock.read(async () => {
-      if (cancelToken) {
-        await interruptAndCheck(cancelToken);
+    const parsed = await this.parseModel(cancelToken);
+    if (!parsed) {
+      return null;
+    }
+    return cache.get(cacheKey, () => {
+      const view = parsed.views[viewId];
+      if (!view) {
+        logger.warn(`[ModelBuilder] Cannot find view ${viewId}`);
+        return null;
       }
-      return cache.get(cacheKey, () => {
-        const model = this.unsafeSyncBuildModel();
-        const view = model?.views[viewId];
-        if (!view) {
-          logger.warn(`[ModelBuilder] Cannot find view ${viewId}`);
-          return null;
-        }
-        const result = LikeC4Model.makeCompute(model)(view);
-        if (!result.isSuccess) {
-          logWarnError(result.error);
-          return null;
-        }
-        let computedView = result.view;
-        const allElementViews = pipe(
-          model.views,
-          values(),
-          filter(isScopedElementView),
-          filter((v) => v.id !== viewId),
-          groupBy((v) => v.viewOf)
-        );
-        for (const node of computedView.nodes) {
-          if (!node.navigateTo) {
-            const viewsOfNode = allElementViews[node.id];
-            if (viewsOfNode) {
-              node.navigateTo = viewsOfNode[0].id;
-            }
+      const computeView = LikeC4Model.makeCompute(parsed);
+      const result = computeView(view);
+      if (!result.isSuccess) {
+        logWarnError(result.error);
+        return null;
+      }
+      let computedView = result.view;
+      const allElementViews = pipe(
+        parsed.views,
+        values(),
+        filter(isScopedElementView),
+        filter((v) => v.id !== viewId),
+        groupBy((v) => v.viewOf)
+      );
+      for (const node of computedView.nodes) {
+        if (!node.navigateTo) {
+          const viewsOfNode = allElementViews[node.id];
+          if (viewsOfNode) {
+            node.navigateTo = viewsOfNode[0].id;
           }
         }
-        const previous = this.previousViews[viewId];
-        if (previous && eq(computedView, previous)) {
-          computedView = previous;
-        } else {
-          this.previousViews[viewId] = computedView;
-        }
-        return computedView;
-      });
+      }
+      const previous = this.previousViews[viewId];
+      if (previous && eq(computedView, previous)) {
+        computedView = previous;
+      } else {
+        this.previousViews[viewId] = computedView;
+      }
+      return computedView;
     });
   }
   onModelParsed(callback) {
@@ -636,7 +191,7 @@ export class LikeC4ModelBuilder extends ADisposable {
     });
   }
   documents() {
-    return this.langiumDocuments.all.filter(isParsedLikeC4LangiumDocument).toArray();
+    return this.parser.documents().toArray();
   }
   notifyListeners(docs) {
     for (const listener of this.listeners) {