feat(apidom-ls): document cache

Author: frantuma

packages/apidom-ls/src/apidom-language-service.ts

@@ -8,6 +8,7 @@ import {
 } from 'vscode-languageserver-types';
 import { TextDocument } from 'vscode-languageserver-textdocument';
 import { SemanticTokensLegend } from 'vscode-languageserver-protocol';
+import { ParseResultElement } from '@swagger-api/apidom-core';
 
 import {
   ColorsContext,
@@ -22,6 +23,8 @@ import { DefaultSemanticTokensService } from './services/semantic-tokens/semanti
 import { DefaultHoverService } from './services/hover/hover-service';
 import { DefaultDerefService } from './services/deref/deref-service';
 import { DefaultDefinitionService } from './services/definition/definition-service';
+import { getDocumentCache } from './document-cache';
+import { parse } from './parser-factory';
 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 export default function getLanguageService(context: LanguageServiceContext): LanguageService {
@@ -43,12 +46,17 @@ export default function getLanguageService(context: LanguageServiceContext): Lan
     definitionService.configure(languageSettings);
   }
 
+  const documentCache = getDocumentCache<ParseResultElement>(10, 60, (document) =>
+    parse(document, context?.metadata?.metadataMaps),
+  );
+
   // TODO solve init and config
   if (context.metadata) {
     const languageSettings: LanguageSettings = {
       metadata: context.metadata,
       validate: true,
       validatorProviders: context.validatorProviders,
+      documentCache,
     };
     configureServices(languageSettings);
   }
@@ -93,5 +101,8 @@ export default function getLanguageService(context: LanguageServiceContext): Lan
     getColorPresentations(document: TextDocument, color: Color, range: Range): ColorPresentation[] {
       return [];
     },
+    terminate(): void {
+      documentCache.dispose();
+    },
   };
 }

packages/apidom-ls/src/apidom-language-types.ts

@@ -24,9 +24,10 @@ import {
   DefinitionParams,
   ReferenceParams,
 } from 'vscode-languageserver-protocol';
-import { Element } from 'minim';
+import { Element, ParseResultElement } from '@swagger-api/apidom-core';
 
 import { Metadata } from './utils/utils';
+import { DocumentCache } from './document-cache';
 
 // eslint-disable-next-line @typescript-eslint/naming-convention
 export enum SUPPORTED_LANGUAGES {
@@ -68,6 +69,7 @@ export interface LanguageSettings {
   allowComments?: boolean;
   validatorProviders?: ValidationProvider[];
   metadata?: Metadata;
+  documentCache?: DocumentCache<ParseResultElement>;
 }
 
 // export type SeverityLevel = 'error' | 'warning' | 'ignore';
@@ -147,4 +149,5 @@ export interface LanguageService {
   getColorPresentations(document: TextDocument, color: Color, range: Range): ColorPresentation[];
 
   format(document: TextDocument, range: Range, options: FormattingOptions): TextEdit[];
+  terminate(): void;
 }

packages/apidom-ls/src/document-cache.ts

@@ -0,0 +1,104 @@
+import { TextDocument } from 'vscode-languageserver-textdocument';
+
+/*
+ Adapted from https://github.com/microsoft/vscode/blob/main/extensions/json-language-features/server/src/languageModelCache.ts
+ */
+export interface DocumentCache<T> {
+  get(document: TextDocument): Promise<T | undefined>;
+  onDocumentRemoved(document: TextDocument): void;
+  dispose(): void;
+}
+
+export function getDocumentCache<T>(
+  maxEntries: number,
+  cleanupIntervalTimeInSec: number,
+  parse: (document: TextDocument) => Promise<T>,
+): DocumentCache<T> {
+  let documents: {
+    [uri: string]: {
+      version: number;
+      languageId: string;
+      cTime: number;
+      parsedDocument: T;
+    };
+  } = {};
+  let nModels = 0;
+
+  let cleanupInterval: ReturnType<typeof setInterval> | undefined;
+  if (cleanupIntervalTimeInSec > 0) {
+    cleanupInterval = setInterval(() => {
+      const cutoffTime = Date.now() - cleanupIntervalTimeInSec * 1000;
+      const uris = Object.keys(documents);
+      for (const uri of uris) {
+        const documentInfo = documents[uri];
+        if (documentInfo.cTime < cutoffTime) {
+          delete documents[uri];
+          // eslint-disable-next-line no-plusplus
+          nModels--;
+        }
+      }
+    }, cleanupIntervalTimeInSec * 1000);
+  }
+
+  return {
+    async get(document: TextDocument): Promise<T> {
+      const { version } = document;
+      const { languageId } = document;
+      const documentInfo = documents[document.uri];
+      if (
+        documentInfo &&
+        documentInfo.version === version &&
+        documentInfo.languageId === languageId
+      ) {
+        documentInfo.cTime = Date.now();
+        return documentInfo.parsedDocument;
+      }
+      const parsedDocument = await parse(document);
+      documents[document.uri] = {
+        parsedDocument,
+        version,
+        languageId,
+        cTime: Date.now(),
+      };
+      if (!documentInfo) {
+        // eslint-disable-next-line no-plusplus
+        nModels++;
+      }
+
+      if (nModels === maxEntries) {
+        let oldestTime = Number.MAX_VALUE;
+        let oldestUri = null;
+        // eslint-disable-next-line guard-for-in
+        for (const uri in documents) {
+          const documentInfoInstance = documents[uri];
+          if (documentInfoInstance.cTime < oldestTime) {
+            oldestUri = uri;
+            oldestTime = documentInfoInstance.cTime;
+          }
+        }
+        if (oldestUri) {
+          delete documents[oldestUri];
+          // eslint-disable-next-line no-plusplus
+          nModels--;
+        }
+      }
+      return parsedDocument;
+    },
+    onDocumentRemoved(document: TextDocument) {
+      const { uri } = document;
+      if (documents[uri]) {
+        delete documents[uri];
+        // eslint-disable-next-line no-plusplus
+        nModels--;
+      }
+    },
+    dispose() {
+      if (typeof cleanupInterval !== 'undefined') {
+        clearInterval(cleanupInterval);
+        cleanupInterval = undefined;
+        documents = {};
+        nModels = 0;
+      }
+    },
+  };
+}

packages/apidom-ls/src/parser-factory.ts

@@ -9,6 +9,9 @@ import * as openapi3_1Adapter_Yaml from '@swagger-api/apidom-parser-adapter-open
 // @ts-ignore
 import * as asyncapi2Adapter_Yaml from '@swagger-api/apidom-parser-adapter-asyncapi-yaml-2';
 import { TextDocument } from 'vscode-languageserver-textdocument';
+import { ParseResultElement } from '@swagger-api/apidom-core';
+
+import { setMetadataMap, MetadataMaps } from './utils/utils';
 
 export interface ParserOptions {
   sourceMap?: boolean;
@@ -63,3 +66,20 @@ export function getParser(document: TextDocument): ApiDOMParser {
   }
   return ApiDOMParser().use(openapi3_1Adapter);
 }
+
+export async function parse(
+  textDocument: TextDocument,
+  metadataMaps: MetadataMaps | undefined,
+): Promise<ParseResultElement> {
+  const parser = getParser(textDocument);
+  const text: string = textDocument.getText();
+  const result = await parser.parse(text, { sourceMap: true });
+  const { api } = result;
+  if (api === undefined) return result;
+  const docNs: string = isAsyncDoc(text) ? 'asyncapi' : 'openapi';
+  // TODO  (francesco@tumanischvili@smartbear.com) use the type related metadata at root level defining the tokenTypes and modifiers
+  setMetadataMap(api, docNs, metadataMaps); // TODO (francesco@tumanischvili@smartbear.com)  move to parser/adapter, extending the one standard
+  api.freeze(); // !! freeze and add parent !!
+
+  return result;
+}

packages/apidom-ls/src/services/completion/completion-service.ts

@@ -2,8 +2,6 @@ import {
   CompletionItem,
   CompletionItemKind,
   CompletionList,
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  InsertTextFormat,
   Position,
   Range,
   TextEdit,
@@ -24,9 +22,8 @@ import {
 } from '@swagger-api/apidom-core';
 
 import { LanguageSettings, CompletionContext } from '../../apidom-language-types';
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-import { setMetadataMap, getSourceMap, isMember, isObject } from '../../utils/utils';
-import { getParser, isJsonDoc, isAsyncDoc } from '../../parser-factory';
+import { getSourceMap, isMember, isObject } from '../../utils/utils';
+import { isJsonDoc } from '../../parser-factory';
 
 export interface CompletionsCollector {
   add(suggestion: unknown): void;
@@ -171,7 +168,6 @@ export class DefaultCompletionService implements CompletionService {
         : completionParamsOrPosition;
 
     // get right parser
-    const parser = getParser(textDocument);
     const text: string = textDocument.getText();
 
     const schema = false;
@@ -194,19 +190,12 @@ export class DefaultCompletionService implements CompletionService {
     }
 
     // parse
-    const { api } = await parser.parse(text, { sourceMap: true });
-
+    const result = await this.settings!.documentCache?.get(textDocument);
+    if (!result) return CompletionList.create();
+    const { api } = result;
     // if we cannot parse nothing to do
     if (api === undefined) return CompletionList.create();
 
-    // use the type related metadata at root level
-    setMetadataMap(
-      api,
-      isAsyncDoc(text) ? 'asyncapi' : 'openapi',
-      this.settings?.metadata?.metadataMaps,
-    ); // TODO move to parser/adapter, extending the one standard
-    api.freeze(); // !! freeze and add parent !!
-
     const completionList: CompletionList = {
       items: [],
       isIncomplete: false,

packages/apidom-ls/src/services/definition/definition-service.ts

@@ -6,8 +6,7 @@ import { DefinitionParams, ReferenceParams } from 'vscode-languageserver-protoco
 import { jsonPointerEvaluate } from '@swagger-api/apidom-reference';
 
 import { LanguageSettings } from '../../apidom-language-types';
-import { getParser, isAsyncDoc } from '../../parser-factory';
-import { getSourceMap, isArray, isMember, isObject, setMetadataMap } from '../../utils/utils';
+import { getSourceMap, isArray, isMember, isObject } from '../../utils/utils';
 
 export interface DefinitionService {
   doProvideDefinition(
@@ -35,26 +34,15 @@ export class DefaultDefinitionService implements DefinitionService {
     textDocument: TextDocument,
     definitionParams: DefinitionParams,
   ): Promise<Location | null> {
-    const parser = getParser(textDocument);
-    const text: string = textDocument.getText();
-
     const offset = textDocument.offsetAt(definitionParams.position);
 
-    const result = await parser.parse(text, { sourceMap: true });
-
+    const result = await this.settings!.documentCache?.get(textDocument);
+    if (!result) return null;
     const api: ObjectElement = <ObjectElement>result.api;
 
     // no API document has been parsed
     if (api === undefined) return null;
 
-    // use the type related metadata at root level
-    setMetadataMap(
-      api,
-      isAsyncDoc(text) ? 'asyncapi' : 'openapi',
-      this.settings?.metadata?.metadataMaps,
-    ); // TODO (francesco.tumanischvili@smartbear.com) move to parser/adapter, extending the one standard
-    api.freeze(); // !! freeze and add parent !!
-
     // TODO (francesco.tumanischvili@smartbear.com): handle by predicates and adapters, look for
     // refElements and/or metadata, replace current shaky handling by `$ref` key lookup
     const node = findAtOffset({ offset, includeRightBound: true }, api);
@@ -94,27 +82,16 @@ export class DefaultDefinitionService implements DefinitionService {
     textDocument: TextDocument,
     referenceParams: ReferenceParams,
   ): Promise<Location[] | null> {
-    const parser = getParser(textDocument);
-    const text: string = textDocument.getText();
-
     // const asyncapi: boolean = isAsyncDoc(textDocument);
     const offset = textDocument.offsetAt(referenceParams.position);
 
-    const result = await parser.parse(text, { sourceMap: true });
-
+    const result = await this.settings!.documentCache?.get(textDocument);
+    if (!result) return null;
     const api: ObjectElement = <ObjectElement>result.api;
 
     // no API document has been parsed
     if (api === undefined) return null;
 
-    // use the type related metadata at root level
-    setMetadataMap(
-      api,
-      isAsyncDoc(text) ? 'asyncapi' : 'openapi',
-      this.settings?.metadata?.metadataMaps,
-    ); // TODO (francesco.tumanischvili@smartbear.com) move to parser/adapter, extending the one standard
-    api.freeze(); // !! freeze and add parent !!
-
     // TODO(francesco.tumanischvili@smartbear.com): handle by predicates and adapters, look for
     // refElements and/or metadata, replace current shaky handling by `$ref` key lookup
     const node = findAtOffset({ offset, includeRightBound: true }, api);

packages/apidom-ls/src/services/hover/hover-service.ts

@@ -5,7 +5,7 @@ import { MarkupContent, Position, Range } from 'vscode-languageserver-types';
 
 import { LanguageSettings } from '../../apidom-language-types';
 import { getSourceMap, isMember, isObject, isArray, setMetadataMap } from '../../utils/utils';
-import { getParser, isAsyncDoc } from '../../parser-factory';
+import { isAsyncDoc } from '../../parser-factory';
 
 export interface HoverService {
   computeHover(textDocument: TextDocument, position: Position): Promise<Hover | undefined>;
@@ -27,7 +27,6 @@ export class DefaultHoverService implements HoverService {
     textDocument: TextDocument,
     position: Position,
   ): Promise<Hover | undefined> {
-    const parser = getParser(textDocument);
     const text: string = textDocument.getText();
     const asyncapi: boolean = isAsyncDoc(textDocument);
     const offset = textDocument.offsetAt(position);
@@ -36,9 +35,9 @@ export class DefaultHoverService implements HoverService {
       contents: { kind: 'markdown', value: '' },
     };
 
-    // parse
-    const { api } = await parser.parse(text, { sourceMap: true });
-
+    const result = await this.settings!.documentCache?.get(textDocument);
+    if (!result) return undefined;
+    const { api } = result;
     // no API document has been parsed
     if (api === undefined) return undefined;