@likec4/language-server 1.42.1 → 1.44.0

package/dist/model/model-builder.mjs

@@ -1,285 +0,0 @@
-import {
-  _stage,
-  isScopedElementView
-} from "@likec4/core";
-import { computeView } from "@likec4/core/compute-view";
-import { LikeC4Model } from "@likec4/core/model";
-import { loggable } from "@likec4/log";
-import { deepEqual as eq } from "fast-equals";
-import {
-  Disposable,
-  DocumentState,
-  interruptAndCheck
-} from "langium";
-import {
-  filter,
-  flatMap,
-  groupBy,
-  hasAtLeast,
-  isNot,
-  mapToObj,
-  pipe,
-  prop,
-  values
-} from "remeda";
-import { isLikeC4Builtin } from "../likec4lib.mjs";
-import { logger as mainLogger, logWarnError } from "../logger.mjs";
-import { ADisposable, performanceMark } from "../utils/index.mjs";
-import { assignNavigateTo } from "../view-utils/index.mjs";
-import { buildModelData } from "./builder/buildModel.mjs";
-const parsedWithoutImportsCacheKey = (projectId) => `parsed-without-imports-${projectId}`;
-const parsedModelCacheKey = (projectId) => `parsed-model-${projectId}`;
-const computedModelCacheKey = (projectId) => `computed-model-${projectId}`;
-const builderLogger = mainLogger.getChild("model-builder");
-export class DefaultLikeC4ModelBuilder extends ADisposable {
-  projects;
-  parser;
-  listeners = [];
-  cache;
-  DocumentBuilder;
-  mutex;
-  constructor(services) {
-    super();
-    this.projects = services.shared.workspace.ProjectsManager;
-    this.parser = services.likec4.ModelParser;
-    this.cache = services.ValidatedWorkspaceCache;
-    this.DocumentBuilder = services.shared.workspace.DocumentBuilder;
-    this.mutex = services.shared.workspace.WorkspaceLock;
-    this.onDispose(
-      this.DocumentBuilder.onUpdate((_changed, deleted) => {
-        if (deleted.length > 0) {
-          this.notifyListeners(deleted);
-        }
-      })
-    );
-    this.onDispose(
-      this.DocumentBuilder.onBuildPhase(
-        DocumentState.Validated,
-        (docs, _cancelToken) => {
-          const validated = docs.map(prop("uri")).filter(isNot(isLikeC4Builtin));
-          if (validated.length > 0) {
-            this.notifyListeners(validated);
-          }
-        }
-      )
-    );
-    builderLogger.debug`created`;
-  }
-  /**
-   * 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.
-   *
-   * To avoid circular dependencies, we do not resolve imports here.
-   */
-  unsafeSyncParseModelData(projectId) {
-    const cache = this.cache;
-    const logger = builderLogger.getChild(projectId);
-    const key = parsedWithoutImportsCacheKey(projectId);
-    if (cache.has(key)) {
-      logger.debug`unsafeSyncBuildModelData from cache`;
-    }
-    return cache.get(key, () => {
-      try {
-        const project = this.projects.getProject(projectId);
-        const docs = this.documents(projectId);
-        if (docs.length === 0) {
-          logger.debug`no documents to build model`;
-          return null;
-        }
-        logger.debug`unsafeSyncBuildModelData`;
-        return buildModelData(project, docs);
-      } catch (e) {
-        logWarnError(e);
-        return null;
-      }
-    });
-  }
-  /**
-   * To avoid circular dependencies, first we parse all documents and then we join them.
-   */
-  unsafeSyncJoinedModelData(projectId) {
-    const logger = builderLogger.getChild(projectId);
-    const cache = this.cache;
-    const key = parsedModelCacheKey(projectId);
-    return cache.get(key, () => {
-      const result = this.unsafeSyncParseModelData(projectId);
-      if (!result) {
-        return null;
-      }
-      let parsedData = result.data;
-      if (result.imports.size > 0) {
-        logger.debug`processing imports of ${projectId}`;
-        const imports = [...result.imports.associations()].reduce((acc, [projectId2, fqns]) => {
-          const anotherProject = this.unsafeSyncParseModelData(projectId2);
-          if (anotherProject) {
-            const imported = pipe(
-              [...fqns],
-              flatMap((fqn) => anotherProject.data.elements[fqn] ?? [])
-            );
-            if (hasAtLeast(imported, 1)) {
-              acc[projectId2] = imported;
-            }
-          }
-          return acc;
-        }, {});
-        parsedData = {
-          ...result.data,
-          imports
-        };
-      }
-      return LikeC4Model.create(parsedData);
-    });
-  }
-  async parseModel(projectId, cancelToken) {
-    const project = this.projects.ensureProjectId(projectId);
-    const logger = builderLogger.getChild(project);
-    const cache = this.cache;
-    const cached = cache.get(parsedModelCacheKey(project));
-    if (cached) {
-      logger.debug`parseModel from cache`;
-      return cached;
-    }
-    const t0 = performanceMark();
-    return await this.mutex.read(async () => {
-      if (cancelToken) {
-        await interruptAndCheck(cancelToken);
-      }
-      const result = this.unsafeSyncJoinedModelData(project);
-      logger.debug`parseModel in ${t0.pretty}`;
-      return result;
-    });
-  }
-  previousViews = {};
-  /**
-   * 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(projectId) {
-    const logger = builderLogger.getChild(projectId);
-    const cache = this.cache;
-    const viewsCache = this.cache;
-    return cache.get(computedModelCacheKey(projectId), () => {
-      const parsedModel = this.unsafeSyncJoinedModelData(projectId);
-      if (!parsedModel) {
-        return LikeC4Model.EMPTY;
-      }
-      const allViews = [];
-      for (const view of values(parsedModel.$data.views)) {
-        const result = computeView(view, parsedModel);
-        if (!result.isSuccess) {
-          logger.warn(loggable(result.error));
-          continue;
-        }
-        allViews.push(result.view);
-      }
-      assignNavigateTo(allViews);
-      const views = mapToObj(allViews, (v) => {
-        const key = computedViewKey(projectId, v.id);
-        const previous = this.previousViews[key];
-        const view = previous && eq(v, previous) ? previous : v;
-        this.previousViews[key] = view;
-        viewsCache.set(key, view);
-        return [v.id, view];
-      });
-      return LikeC4Model.create({
-        ...parsedModel.$data,
-        [_stage]: "computed",
-        views
-      });
-    });
-  }
-  async buildLikeC4Model(projectId, cancelToken) {
-    const project = this.projects.ensureProjectId(projectId);
-    const logger = builderLogger.getChild(project);
-    const cache = this.cache;
-    const cached = cache.get(computedModelCacheKey(project));
-    if (cached) {
-      logger.debug("buildLikeC4Model from cache");
-      return cached;
-    }
-    const t0 = performanceMark();
-    return await this.mutex.read(async () => {
-      if (cancelToken) {
-        await interruptAndCheck(cancelToken);
-      }
-      const result = this.unsafeSyncBuildModel(project);
-      logger.debug(`buildLikeC4Model in ${t0.pretty}`);
-      return result;
-    });
-  }
-  async computeView(viewId, projectId, cancelToken) {
-    const project = this.projects.ensureProjectId(projectId);
-    const logger = builderLogger.getChild(project);
-    const cache = this.cache;
-    const cacheKey = computedViewKey(project, viewId);
-    if (cache.has(cacheKey)) {
-      return cache.get(cacheKey);
-    }
-    const parsed = await this.parseModel(project, cancelToken);
-    if (!parsed) {
-      return null;
-    }
-    return cache.get(cacheKey, () => {
-      const view = parsed.$data.views[viewId];
-      if (!view) {
-        logger.warn`computeView: cant find view ${viewId}`;
-        return null;
-      }
-      logger.debug`computeView: ${viewId}`;
-      const result = computeView(view, parsed);
-      if (!result.isSuccess) {
-        logWarnError(result.error);
-        return null;
-      }
-      let computedView = result.view;
-      const allElementViews = pipe(
-        parsed.$data.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[cacheKey];
-      if (previous && eq(computedView, previous)) {
-        computedView = previous;
-      } else {
-        this.previousViews[cacheKey] = computedView;
-      }
-      return computedView;
-    });
-  }
-  onModelParsed(callback) {
-    this.listeners.push(callback);
-    return Disposable.create(() => {
-      const index = this.listeners.indexOf(callback);
-      if (index >= 0) {
-        this.listeners.splice(index, 1);
-      }
-    });
-  }
-  documents(projectId) {
-    return this.parser.documents(projectId).toArray();
-  }
-  notifyListeners(docs) {
-    for (const listener of this.listeners) {
-      try {
-        listener(docs);
-      } catch (e) {
-        logWarnError(e);
-      }
-    }
-  }
-}
-function computedViewKey(projectId, viewId) {
-  return `computed-view-${projectId}-${viewId}`;
-}

package/dist/model/model-locator.mjs

@@ -1,239 +0,0 @@
-import { splitGlobalFqn } from "@likec4/core";
-import { ifilter, invariant, toArray } from "@likec4/core/utils";
-import { loggable } from "@likec4/log";
-import { AstUtils, DocumentState, GrammarUtils } from "langium";
-import { flatMap, isString, pipe } from "remeda";
-import { ast, isLikeC4LangiumDocument } from "../ast.mjs";
-import { logger as serverLogger } from "../logger.mjs";
-import { projectIdFrom } from "../utils/index.mjs";
-import { MergedSpecification } from "./builder/MergedSpecification.mjs";
-const { findNodeForKeyword, findNodeForProperty } = GrammarUtils;
-const { getDocument, streamAllContents } = AstUtils;
-const logger = serverLogger.getChild("ModelLocator");
-export class LikeC4ModelLocator {
-  constructor(services) {
-    this.services = services;
-    this.fqnIndex = services.likec4.FqnIndex;
-    this.deploymentsIndex = services.likec4.DeploymentsIndex;
-    this.langiumDocuments = services.shared.workspace.LangiumDocuments;
-    this.parser = services.likec4.ModelParser;
-    this.projects = services.shared.workspace.ProjectsManager;
-  }
-  fqnIndex;
-  deploymentsIndex;
-  langiumDocuments;
-  parser;
-  projects;
-  documents(projectId) {
-    return this.parser.documents(projectId);
-  }
-  // public getParsedElement(astNodeOrFqn: ast.Element): ParsedAstElement | null
-  // public getParsedElement(astNodeOrFqn: c4.Fqn, projectId?: c4.ProjectId): ParsedAstElement | null
-  getParsedElement(...args) {
-    let astNodeOrFqn;
-    let projectId;
-    if (args.length === 2) {
-      astNodeOrFqn = args[0];
-      projectId = args[1];
-    } else {
-      astNodeOrFqn = args[0];
-      projectId = isString(astNodeOrFqn) ? this.projects.ensureProjectId() : projectIdFrom(astNodeOrFqn);
-    }
-    if (isString(astNodeOrFqn)) {
-      const fqn2 = astNodeOrFqn;
-      const entry = this.fqnIndex.byFqn(projectId, astNodeOrFqn).head();
-      if (!entry) {
-        return null;
-      }
-      const doc2 = this.langiumDocuments.getDocument(entry.documentUri);
-      if (!doc2) {
-        return null;
-      }
-      return this.parser.parse(doc2).c4Elements.find((e) => e.id === fqn2) ?? null;
-    }
-    const fqn = this.fqnIndex.getFqn(astNodeOrFqn);
-    const doc = this.parser.parse(getDocument(astNodeOrFqn));
-    return doc.c4Elements.find((e) => e.id === fqn) ?? null;
-  }
-  locateElement(fqn, projectId) {
-    let [_projectId, _fqn] = splitGlobalFqn(fqn);
-    _projectId ??= this.projects.ensureProjectId(projectId);
-    const entry = this.fqnIndex.byFqn(_projectId, _fqn).head();
-    const docsegment = entry?.nameSegment ?? entry?.selectionSegment;
-    if (!entry || !docsegment) {
-      return null;
-    }
-    return {
-      uri: entry.documentUri.toString(),
-      range: docsegment.range
-    };
-  }
-  locateDeploymentElement(deploymentFqn, projectId) {
-    const _projectId = this.projects.ensureProjectId(projectId);
-    const fqn = deploymentFqn;
-    const entry = this.deploymentsIndex.byFqn(_projectId, fqn).head();
-    const docsegment = entry?.nameSegment ?? entry?.selectionSegment;
-    if (!entry || !docsegment) {
-      return null;
-    }
-    return {
-      uri: entry.documentUri.toString(),
-      range: docsegment.range
-    };
-  }
-  locateRelation(relationId, projectId) {
-    const project = this.projects.ensureProjectId(projectId);
-    for (const doc of this.documents(project)) {
-      const relation = doc.c4Relations.find((r) => r.id === relationId) ?? doc.c4DeploymentRelations.find((r) => r.id === relationId);
-      if (!relation) {
-        continue;
-      }
-      const node = this.services.workspace.AstNodeLocator.getAstNode(
-        doc.parseResult.value,
-        relation.astPath
-      );
-      if (!ast.isRelation(node) && !ast.isDeploymentRelation(node)) {
-        continue;
-      }
-      let targetNode = node.kind ? findNodeForProperty(node.$cstNode, "kind") : void 0;
-      targetNode ??= node.dotKind ? findNodeForProperty(node.$cstNode, "dotKind") : void 0;
-      targetNode ??= findNodeForKeyword(node.$cstNode, "->");
-      targetNode ??= findNodeForProperty(node.$cstNode, "title");
-      targetNode ??= findNodeForProperty(node.$cstNode, "target");
-      targetNode ??= node.$cstNode;
-      if (!targetNode) {
-        continue;
-      }
-      return {
-        uri: doc.uri.toString(),
-        range: {
-          start: targetNode.range.start,
-          end: targetNode.range.start
-        }
-      };
-    }
-    return null;
-  }
-  locateViewAst(viewId, projectId) {
-    const project = this.projects.ensureProjectId(projectId);
-    for (const doc of this.documents(project)) {
-      const view = doc.c4Views.find((r) => r.id === viewId);
-      if (!view) {
-        continue;
-      }
-      const viewAst = this.services.workspace.AstNodeLocator.getAstNode(
-        doc.parseResult.value,
-        view.astPath
-      );
-      if (ast.isLikeC4View(viewAst)) {
-        return {
-          doc,
-          view,
-          viewAst
-        };
-      }
-    }
-    return null;
-  }
-  locateView(viewId, projectId) {
-    const res = this.locateViewAst(viewId, projectId);
-    if (!res) {
-      return null;
-    }
-    const node = res.viewAst;
-    let targetNode = node.name ? findNodeForProperty(node.$cstNode, "name") : void 0;
-    targetNode ??= findNodeForKeyword(node.$cstNode, "view");
-    targetNode ??= node.$cstNode;
-    if (!targetNode) {
-      return null;
-    }
-    return {
-      uri: res.doc.uri.toString(),
-      range: targetNode.range
-    };
-  }
-  async locateDocumentTags(documentUri, cancelToken) {
-    const doc = this.langiumDocuments.getDocument(documentUri);
-    if (!doc || !isLikeC4LangiumDocument(doc)) {
-      return [];
-    }
-    if (doc.state < DocumentState.Validated) {
-      logger.debug(`Waiting for document ${doc.uri.path} to be Validated`);
-      await this.services.shared.workspace.DocumentBuilder.waitUntil(DocumentState.Validated, doc.uri, cancelToken);
-    }
-    const projectId = projectIdFrom(doc);
-    logger.debug(`locate document tags for ${doc.uri.path} in project ${projectId}`);
-    try {
-      const tagSpecs = new MergedSpecification(this.documents(projectId).toArray()).tags;
-      logger.debug(`Assigned colors to tags`, { tagSpecs });
-      const tags = pipe(
-        streamAllContents(doc.parseResult.value),
-        ifilter((astNode) => ast.isTag(astNode) || ast.isTagRef(astNode)),
-        toArray(),
-        flatMap((tagRef) => {
-          let name;
-          let $cstNode;
-          try {
-            if (ast.isTag(tagRef)) {
-              name = tagRef.name;
-              $cstNode = tagRef.$cstNode;
-            } else {
-              name = tagRef.tag.$refText;
-              $cstNode = tagRef.tag.$refNode;
-            }
-            const specification = tagSpecs[name];
-            invariant(specification, `Tag ${name} not found in merged specification`);
-            invariant($cstNode, `Tag ${name} does not have a $cstNode`);
-            return {
-              name,
-              color: specification.color,
-              range: $cstNode.range,
-              isSpecification: ast.isTag(tagRef)
-            };
-          } catch (err) {
-            logger.warn(`Fail on tag ${name}`, { err });
-            return [];
-          }
-        })
-      );
-      logger.debug(`Found ${tags.length} tags in document ${doc.uri.path}`);
-      return tags;
-    } catch (e) {
-      logger.warn(loggable(e));
-      return [];
-    }
-  }
-  locateDynamicViewStep(params) {
-    const { doc, viewAst } = this.locateViewAst(params.view, params.projectId) ?? {};
-    if (!doc || !viewAst) {
-      return null;
-    }
-    if (!ast.isDynamicView(viewAst) || !viewAst.body) {
-      logger.warn(`View ${params.view} is not a dynamic view`);
-      return null;
-    }
-    const astPath = this.services.workspace.AstNodeLocator.getAstNodePath(viewAst.body) + params.astPath;
-    const node = this.services.workspace.AstNodeLocator.getAstNode(doc.parseResult.value, astPath);
-    if (!node || !ast.isDynamicViewStep(node)) {
-      logger.warn(`Failed to locate dynamic view step ${astPath} in view ${params.view}`);
-      return null;
-    }
-    let targetNode = node.kind ? findNodeForProperty(node.$cstNode, "kind") : void 0;
-    targetNode ??= node.dotKind ? findNodeForProperty(node.$cstNode, "dotKind") : void 0;
-    targetNode ??= findNodeForKeyword(node.$cstNode, "->");
-    targetNode ??= findNodeForKeyword(node.$cstNode, "<-");
-    targetNode ??= findNodeForProperty(node.$cstNode, "title");
-    targetNode ??= findNodeForProperty(node.$cstNode, "target");
-    targetNode ??= node.$cstNode;
-    if (!targetNode) {
-      return null;
-    }
-    return {
-      uri: doc.uri.toString(),
-      range: {
-        start: targetNode.range.start,
-        end: targetNode.range.start
-      }
-    };
-  }
-}

package/dist/model/model-parser-where.mjs

@@ -1,81 +0,0 @@
-import { invariant, isAndOperator, isNonEmptyArray, isOrOperator, nonexhaustive } from "@likec4/core";
-import { ast } from "../ast.mjs";
-const parseEquals = ({ operator, not }, value) => {
-  if (operator.startsWith("!=")) {
-    return {
-      neq: value
-    };
-  }
-  if (operator.startsWith("=")) {
-    return {
-      eq: value
-    };
-  }
-  return not ? { neq: value } : { eq: value };
-};
-function parseParticipant(astNode) {
-  if (!ast.isWhereRelationParticipantKind(astNode) && !ast.isWhereRelationParticipantTag(astNode)) {
-    return null;
-  }
-  return astNode.participant;
-}
-export function parseWhereClause(astNode) {
-  switch (true) {
-    case ast.isWhereTagEqual(astNode): {
-      const tag = astNode.value.tag.ref?.name;
-      const participant = parseParticipant(astNode);
-      invariant(tag, "Expected tag name");
-      const tagOperator = { tag: parseEquals(astNode, tag) };
-      return participant ? { participant, operator: tagOperator } : tagOperator;
-    }
-    case ast.isWhereKindEqual(astNode): {
-      const kind = astNode.value?.ref?.name;
-      const participant = parseParticipant(astNode);
-      invariant(kind, "Expected kind name");
-      const kindOperator = { kind: parseEquals(astNode, kind) };
-      return participant ? { participant, operator: kindOperator } : kindOperator;
-    }
-    case (ast.isWhereElementNegation(astNode) || ast.isWhereRelationNegation(astNode)): {
-      return {
-        not: parseWhereClause(astNode.value)
-      };
-    }
-    case ast.isWhereBinaryExpression(astNode): {
-      const left = parseWhereClause(astNode.left);
-      const right = parseWhereClause(astNode.right);
-      const operator = astNode.operator.toLowerCase();
-      return createBinaryOperator(operator, left, right);
-    }
-    default:
-      nonexhaustive(astNode);
-  }
-}
-export function createBinaryOperator(operator, left, right) {
-  if (right === null) {
-    return left;
-  }
-  switch (operator) {
-    case "and": {
-      const operands = [
-        isAndOperator(left) ? left.and : left,
-        isAndOperator(right) ? right.and : right
-      ].flat();
-      invariant(isNonEmptyArray(operands), "Expected non-empty array");
-      return {
-        and: operands
-      };
-    }
-    case "or": {
-      const operands = [
-        isOrOperator(left) ? left.or : left,
-        isOrOperator(right) ? right.or : right
-      ].flat();
-      invariant(isNonEmptyArray(operands), "Expected non-empty array");
-      return {
-        or: operands
-      };
-    }
-    default:
-      nonexhaustive(operator);
-  }
-}