feat(apidom-ls): completion and validation fixes

Author: frantuma

package-lock.json

@@ -62,6 +62,8 @@ export interface ValidationProvider {
   ): Promise<Diagnostic[]>;
 
   configure(settings: LanguageSettings): void;
+
+  name(): string;
 }
 
 export interface LanguageSettings {

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

@@ -12,6 +12,9 @@ export {
 } from '@swagger-api/apidom-core';
 
 export { default as getLanguageService } from './apidom-language-service';
+export { JsonSchemaValidationProvider } from './services/validation/providers/json-schema-validation-provider';
+export { Asyncapi20JsonSchemaValidationProvider } from './services/validation/providers/asyncapi-20-json-schema-validation-provider';
+export { OpenAPi31JsonSchemaValidationProvider } from './services/validation/providers/openapi-31-json-schema-validation-provider';
 
 export { isJsonDoc, isAsyncDoc, getText } from './parser-factory';
 

packages/apidom-ls/src/index.ts

@@ -71,9 +71,23 @@ export async function parse(
   textDocument: TextDocument,
   metadataMaps: MetadataMaps | undefined,
 ): Promise<ParseResultElement> {
-  const parser = getParser(textDocument);
+  // TODO improve detection mechanism
   const text: string = textDocument.getText();
-  const result = await parser.parse(text, { sourceMap: true });
+  const async = isAsyncDoc(textDocument);
+  const json = isJsonDoc(textDocument);
+  let result;
+  if (async && json) {
+    result = await asyncapi2Adapter.parse(text, { sourceMap: true });
+  } else if (async && !json) {
+    result = await asyncapi2Adapter_Yaml.parse(text, { sourceMap: true });
+  } else if (!async && json) {
+    result = await openapi3_1Adapter.parse(text, { sourceMap: true });
+  } else if (!async && !json) {
+    result = await openapi3_1Adapter_Yaml.parse(text, { sourceMap: true });
+  } else {
+    // fallback
+    result = await openapi3_1Adapter.parse(text, { sourceMap: true });
+  }
   const { api } = result;
   if (api === undefined) return result;
   const docNs: string = isAsyncDoc(text) ? 'asyncapi' : 'openapi';

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

@@ -205,16 +205,14 @@ export class DefaultCompletionService implements CompletionService {
     // find the current node
     const node = findAtOffset({ offset, includeRightBound: true }, api);
     // only if we have a node
-    // TODO add jsonSchema completion, see experiments/apidom-monaco and vscode-json-languageservice
     if (node) {
-      // const sm = getSourceMap(node);
       const caretContext = this.resolveCaretContext(node, offset);
       const completionNode = this.resolveCompletionNode(node, caretContext);
-      // const completionNodeSm = getSourceMap(completionNode);
       const completionNodeContext = this.resolveCompletionNodeContext(caretContext);
       // const currentWord = DefaultCompletionService.getCurrentWord(textDocument, offset);
 
-      let overwriteRange: Range;
+      let overwriteRange: Range | undefined;
+      let quotes: string | undefined;
 
       const supportsCommitCharacters = false; // this.doesSupportsCommitCharacters(); disabled for now, waiting for new API: https://github.com/microsoft/vscode/issues/42544
 
@@ -225,6 +223,7 @@ export class DefaultCompletionService implements CompletionService {
           const item: CompletionItem = JSON.parse(JSON.stringify(suggestion));
           let { label } = item;
           const existing = proposed[label];
+          // don't suggest properties that are already present
           if (!existing) {
             label = label.replace(/[\n]/g, '↵');
             if (label.length > 60) {
@@ -257,9 +256,8 @@ export class DefaultCompletionService implements CompletionService {
         },
       };
 
-      // don't suggest properties that are already present
       if (
-        isObject(completionNode) && // TODO added to get type check on node
+        isObject(completionNode) &&
         (CompletionNodeContext.OBJECT === completionNodeContext ||
           CompletionNodeContext.VALUE_OBJECT === completionNodeContext) &&
         (caretContext === CaretContext.KEY_INNER ||
@@ -273,12 +271,6 @@ export class DefaultCompletionService implements CompletionService {
             proposed[p.key.toValue()] = CompletionItem.create('__');
           }
         }
-      }
-
-      if (schema) {
-        // TODO complete schema based, see json language service and "lsp" branch
-        // DefaultCompletionService.getJsonSchemaPropertyCompletions(schema, api, node, addValue, separatorAfter, collector);
-      } else {
         const inNewLine = text.substring(offset, text.indexOf('\n', offset)).trim().length === 0;
         DefaultCompletionService.getMetadataPropertyCompletions(
           api,
@@ -287,6 +279,116 @@ export class DefaultCompletionService implements CompletionService {
           !isJsonDoc(textDocument),
           inNewLine,
         );
+      } else if (
+        // in a primitive value node
+        !isObject(completionNode) &&
+        (caretContext === CaretContext.MEMBER ||
+          caretContext === CaretContext.PRIMITIVE_VALUE_INNER ||
+          caretContext === CaretContext.PRIMITIVE_VALUE_END ||
+          caretContext === CaretContext.PRIMITIVE_VALUE_START)
+      ) {
+        const inNewLine = text.substring(offset, text.indexOf('\n', offset)).trim().length === 0;
+        const nodeSourceMap = getSourceMap(completionNode);
+        // TODO Apidom doesn't hold quotes in its content currently, therefore we must use text + offset
+        const nodeValueFromText = text.substring(nodeSourceMap.offset, nodeSourceMap.endOffset);
+        quotes =
+          nodeValueFromText.charAt(0) === '"' || nodeValueFromText.charAt(0) === "'"
+            ? nodeValueFromText.charAt(0)
+            : undefined;
+        const word = DefaultCompletionService.getCurrentWord(textDocument, offset);
+        proposed[completionNode.toValue()] = CompletionItem.create('__');
+        proposed[nodeValueFromText] = CompletionItem.create('__');
+        let withQuotes = false;
+        // if node is not empty we must replace text
+        if (nodeValueFromText.length > 0) {
+          /*
+          cases:
+
+          - quoted string, offset inside quotes
+          - quoted string, offset before quotes
+          - quoted empty string, offset before quotes
+          - quoted empty string, offset before quoted
+          - non quoted string
+           */
+
+          enum CompletionOffsetContextEnum {
+            NON_QUOTED,
+            QUOTED_INSIDE,
+            QUOTED_BEFORE,
+            EMPTY_QUOTED_INSIDE,
+            EMPTY_QUOTED_BEFORE,
+          }
+
+          let completionOffsetContext = CompletionOffsetContextEnum.NON_QUOTED;
+
+          if (quotes && offset > nodeSourceMap.offset && completionNode.toValue().length > 0) {
+            completionOffsetContext = CompletionOffsetContextEnum.QUOTED_INSIDE;
+          } else if (
+            quotes &&
+            offset <= nodeSourceMap.offset &&
+            completionNode.toValue().length > 0
+          ) {
+            completionOffsetContext = CompletionOffsetContextEnum.QUOTED_BEFORE;
+          } else if (
+            quotes &&
+            offset <= nodeSourceMap.offset &&
+            completionNode.toValue().length === 0
+          ) {
+            completionOffsetContext = CompletionOffsetContextEnum.EMPTY_QUOTED_BEFORE;
+          } else if (
+            quotes &&
+            offset > nodeSourceMap.offset &&
+            completionNode.toValue().length === 0
+          ) {
+            completionOffsetContext = CompletionOffsetContextEnum.EMPTY_QUOTED_INSIDE;
+          }
+          const location = { offset: nodeSourceMap.offset, length: nodeSourceMap.length };
+          let targetRangeStart = location.offset;
+          let targetRangeEnd = location.offset + location.length;
+
+          if (completionOffsetContext === CompletionOffsetContextEnum.QUOTED_INSIDE) {
+            withQuotes = false;
+            targetRangeStart = location.offset + 1;
+            targetRangeEnd = location.offset - 1 + location.length;
+          } else if (completionOffsetContext === CompletionOffsetContextEnum.QUOTED_BEFORE) {
+            withQuotes = true;
+            targetRangeStart = location.offset;
+            targetRangeEnd = location.offset + location.length;
+          } else if (completionOffsetContext === CompletionOffsetContextEnum.EMPTY_QUOTED_INSIDE) {
+            withQuotes = false;
+            targetRangeStart = location.offset + 1;
+            targetRangeEnd = location.offset - 1 + location.length;
+          } else if (completionOffsetContext === CompletionOffsetContextEnum.EMPTY_QUOTED_BEFORE) {
+            withQuotes = true;
+            targetRangeStart = location.offset;
+            targetRangeEnd = location.offset + location.length;
+          }
+
+          overwriteRange = Range.create(
+            textDocument.positionAt(targetRangeStart),
+            textDocument.positionAt(targetRangeEnd),
+          );
+        } else {
+          // node is empty
+          overwriteRange = undefined;
+        }
+        DefaultCompletionService.getMetadataPropertyCompletions(
+          api,
+          completionNode,
+          collector,
+          !isJsonDoc(textDocument),
+          inNewLine,
+          word,
+          quotes,
+          withQuotes,
+        );
+      }
+
+      if (schema) {
+        // TODO complete schema based, see json language service and "lsp" branch
+        // DefaultCompletionService.getJsonSchemaPropertyCompletions(schema, api, node, addValue, separatorAfter, collector);
+      } else {
+        //
       }
     }
 
@@ -356,19 +458,48 @@ export class DefaultCompletionService implements CompletionService {
     collector: CompletionsCollector,
     yaml: boolean,
     inNewLine: boolean,
+    word?: string,
+    quotes?: string,
+    withQuotes?: boolean,
   ): void {
-    const apidomCompletions: CompletionItem[] = doc.meta
-      .get('metadataMap')
-      ?.get(node.element)
-      ?.get(yaml ? 'yaml' : 'json')
-      ?.get('completion')
-      ?.toValue();
+    const apidomCompletions: CompletionItem[] = [];
+    if (node.classes) {
+      const set: string[] = Array.from(new Set(node.classes.toValue()));
+      set.unshift(node.element);
+      set.forEach((s) => {
+        const classCompletions: CompletionItem[] = doc.meta
+          .get('metadataMap')
+          ?.get(s)
+          ?.get(yaml ? 'yaml' : 'json')
+          ?.get('completion')
+          ?.toValue();
+        if (classCompletions) {
+          apidomCompletions.push(...classCompletions);
+        }
+      });
+    }
+
     if (apidomCompletions) {
       for (const item of apidomCompletions) {
+        if (withQuotes) {
+          const completionTextQuotes =
+            item.insertText?.charAt(0) === '"' || item.insertText?.charAt(0) === "'"
+              ? item.insertText?.charAt(0)
+              : undefined;
+          if (!completionTextQuotes && quotes) {
+            item.insertText = quotes + item.insertText + quotes;
+          }
+        }
         if (inNewLine) {
           item.insertText = item.insertText?.substring(0, item.insertText?.length - 1);
         }
-        collector.add(item);
+
+        const strippedQuotesWord = quotes && word ? word.substring(1, word.length) : word!;
+        if (word && word.length > 0 && item.insertText?.startsWith(strippedQuotesWord)) {
+          collector.add(item);
+        } else if (!word) {
+          collector.add(item);
+        }
       }
     }
   }

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

@@ -15,4 +15,30 @@ export const standardLinterfunctions = [
       return true;
     },
   },
+  {
+    functionName: 'apilintFieldValueRegex',
+    function: (element: Element, key: string, regexString: string): boolean => {
+      if (element && isObject(element)) {
+        if (element.get(key)) {
+          const regex = new RegExp(regexString);
+          if (!regex.test(element.get(key).toValue())) {
+            return false;
+          }
+        }
+      }
+      return true;
+    },
+  },
+  {
+    functionName: 'apilintValueRegex',
+    function: (element: Element, regexString: string): boolean => {
+      if (element) {
+        const regex = new RegExp(regexString);
+        if (!regex.test(element.toValue())) {
+          return false;
+        }
+      }
+      return true;
+    },
+  },
 ];

packages/apidom-ls/src/services/validation/linter-functions.ts

@@ -16,4 +16,9 @@ export class Asyncapi20JsonSchemaValidationProvider extends JsonSchemaValidation
   namespaces(): string[] {
     return ['asyncapi'];
   }
+
+  // eslint-disable-next-line class-methods-use-this
+  name(): string {
+    return 'asyncapi schema';
+  }
 }

packages/apidom-ls/src/services/validation/providers/asyncapi-20-json-schema-validation-provider.ts

@@ -84,7 +84,10 @@ export abstract class JsonSchemaValidationProvider implements ValidationProvider
             return;
           }
           let range: Range;
-          const errorOnValue = error.keyword === 'pattern' || error.keyword === 'format';
+          const errorOnValue =
+            error.keyword === 'pattern' ||
+            error.keyword === 'format' ||
+            error.keyword === 'errorMessage';
           // if errors are related to root, mark only the first char
           if (!error.instancePath || error.instancePath.length === 0) {
             const endChar = !originalDocument || originalDocument.length === 0 ? 0 : 1;
@@ -127,14 +130,17 @@ export abstract class JsonSchemaValidationProvider implements ValidationProvider
             error.message || '',
             DiagnosticSeverity.Error,
             0,
+            this.name(),
           );
           diagnostics.push(diagnostic);
         });
       }
     }
   }
 
-  abstract break(): boolean;
+  public abstract break(): boolean;
 
-  abstract namespaces(): string[];
+  public abstract namespaces(): string[];
+
+  public abstract name(): string;
 }

packages/apidom-ls/src/services/validation/providers/json-schema-validation-provider.ts

@@ -21,4 +21,9 @@ export class OpenAPi31JsonSchemaValidationProvider extends JsonSchemaValidationP
   namespaces(): string[] {
     return ['openapi'];
   }
+
+  // eslint-disable-next-line class-methods-use-this
+  name(): string {
+    return 'openapi schema';
+  }
 }