feat: add first method definitions

Author: theBenForce

src/providers/AppsyncSignatureHelpProvider.ts

@@ -1,31 +1,55 @@
-import { SignatureHelpProvider, TextDocument, Position, CancellationToken, SignatureHelp, MarkdownString } from "vscode";
+import { SignatureHelpProvider, TextDocument, Position, CancellationToken, SignatureHelp, MarkdownString, SignatureInformation, CompletionItemKind } from "vscode";
+
+import allTypes from "./allTypes";
 
 export class AppsyncSignatureHelpProvider implements SignatureHelpProvider {
+    _methodReference: Record<string, Array<SignatureInformation>> = {};
+    constructor() {
+        allTypes.forEach((itemSettings) => {
+            itemSettings.prefixes.forEach(prefix => {
+                itemSettings.properties.filter(prop => prop.kind === CompletionItemKind.Method)
+                    .forEach(prop => {
+                        prop.names.forEach(name => {
+                            this._methodReference[`${prefix}${name}`] = prop.signatures?.map(sig => {
+                                sig.documentation = sig.documentation ?? prop.documentation;
+                                sig.label = sig.label ?? `${name}()`;
+                                return sig;
+                            }) ?? [
+                                    {
+                                        label: `${name}()`,
+                                        documentation: new MarkdownString(prop.documentation),
+                                        parameters: []
+                                    }
+                                ];
+                        });
+                    });
+            });
+        });
+    }
+
     public async provideSignatureHelp(
         document: TextDocument, position: Position, token: CancellationToken):
         Promise<SignatureHelp | undefined> {
 
         let linePrefix = document.lineAt(position).text.substr(0, position.character);
+        let methodName = linePrefix.substring(0, linePrefix.lastIndexOf("("));
+        let commaCount = linePrefix.substring(methodName.length).split(",").length - 1;
 
         if (token.isCancellationRequested || linePrefix.endsWith(")")) { return undefined; }
 
+
+        const methodRef = Object.entries(this._methodReference).find(([key]) => methodName.endsWith(key))?.[1];
+
+        if (!methodRef) {
+            return undefined;
+        }
+
         const result = new SignatureHelp();
 
-        result.signatures = [
-            {
-                label: "someMethod(firstParam)",
-                documentation: linePrefix,
-                parameters: [
-                    {
-                        label: "firstParam",
-                        documentation: new MarkdownString("Something")
-                    }
-                ]
-            }
-        ];
-
-        result.activeSignature = 0;
-        result.activeParameter = 0;
+        result.signatures = methodRef;
+
+        result.activeSignature = Math.max(0, methodRef.findIndex(value => value.parameters.length > commaCount));
+        result.activeParameter = commaCount;
 
         return result;
     }

src/providers/allTypes.ts

@@ -0,0 +1,8 @@
+
+import context from "./context";
+import util from "./util";
+
+export default [
+    ...context,
+    ...util
+];

src/providers/context/arguments.ts

@@ -0,0 +1,9 @@
+import { AutocompleteData } from "../dataTypes";
+import map from "../standard/map";
+
+export default [{
+    prefixes: ['$ctx.args.', '$context.args.', '$ctx.arguments.', '$context.arguments.'],
+    properties: [
+        ...map
+    ]
+}] as Array<AutocompleteData.CompletionItemSettings>;

src/providers/context/index.ts

@@ -2,19 +2,26 @@
 import { AutocompleteData } from '../dataTypes';
 import identity from "./identity";
 import info from "./info";
+import args from './arguments';
+import source from './source';
+import stash from './stash';
 
-export default [{
-    prefixes: ['$ctx.', '$context.'],
-    properties: [
-        { names: ["arguments"], documentation: "A map that contains all GraphQL arguments for this field." },
-        { names: ["identity"], documentation: "An object that contains information about the caller." },
-        { names: ["source"], documentation: "A map that contains the resolution of the parent field." },
-        { names: ["stash"], documentation: "The stash is a map that is made available inside each resolver and function mapping template. The same stash instance lives through a single resolver execution. This means that you can use the stash to pass arbitrary data across request and response mapping templates, and across functions in a pipeline resolver. The stash exposes the same methods as the Java Map data structure." },
-        { names: ["result"], documentation: "A container for the results of this resolver. This field is only available to response mapping templates." },
-        { names: ["prev.result"], documentation: "It represents the result of whatever previous operation was executed in a pipeline resolver. If the previous operation was the pipeline resolver request mapping template, then `$ctx.prev.result` represents the output of the evaluation of the template, and is made available to the first function in the pipeline. If the previous operation was the first function, then `$ctx.prev.result` represents the output of the first function, and is made available to the second function in the pipeline. If the previous operation was the last function, then `$ctx.prev.result` represents the output of the first function, and is made available to the pipeline resolver response mapping template." },
-        { names: ["info"], documentation: "An object that contains information about the GraphQL request." }
-    ]
-},
-...identity,
-...info
+export default [
+    {
+        prefixes: ['$ctx.', '$context.'],
+        properties: [
+            { names: ["arguments", "args"], documentation: "A map that contains all GraphQL arguments for this field." },
+            { names: ["identity"], documentation: "An object that contains information about the caller." },
+            { names: ["source"], documentation: "A map that contains the resolution of the parent field." },
+            { names: ["stash"], documentation: "The stash is a map that is made available inside each resolver and function mapping template. The same stash instance lives through a single resolver execution. This means that you can use the stash to pass arbitrary data across request and response mapping templates, and across functions in a pipeline resolver. The stash exposes the same methods as the Java Map data structure." },
+            { names: ["result"], documentation: "A container for the results of this resolver. This field is only available to response mapping templates." },
+            { names: ["prev.result"], documentation: "It represents the result of whatever previous operation was executed in a pipeline resolver. If the previous operation was the pipeline resolver request mapping template, then `$ctx.prev.result` represents the output of the evaluation of the template, and is made available to the first function in the pipeline. If the previous operation was the first function, then `$ctx.prev.result` represents the output of the first function, and is made available to the second function in the pipeline. If the previous operation was the last function, then `$ctx.prev.result` represents the output of the first function, and is made available to the pipeline resolver response mapping template." },
+            { names: ["info"], documentation: "An object that contains information about the GraphQL request." }
+        ]
+    },
+    ...identity,
+    ...info,
+    ...args,
+    ...source,
+    ...stash,
 ] as Array<AutocompleteData.CompletionItemSettings>;

src/providers/context/source.ts

@@ -0,0 +1,9 @@
+import { AutocompleteData } from "../dataTypes";
+import map from "../standard/map";
+
+export default [{
+    prefixes: ['$ctx.source.', '$context.source.'],
+    properties: [
+        ...map
+    ]
+}] as Array<AutocompleteData.CompletionItemSettings>;

src/providers/context/stash.ts

@@ -0,0 +1,9 @@
+import { AutocompleteData } from "../dataTypes";
+import map from "../standard/map";
+
+export default [{
+    prefixes: ['$ctx.stash.', '$context.stash.'],
+    properties: [
+        ...map
+    ]
+}] as Array<AutocompleteData.CompletionItemSettings>;

src/providers/index.ts

@@ -1,6 +1,5 @@
 import * as vscode from "vscode";
-import context from "./context";
-import util from "./util";
+import allTypes from "./allTypes";
 import { AutocompleteData } from "./dataTypes";
 import { AppsyncSignatureHelpProvider } from "./AppsyncSignatureHelpProvider";
 
@@ -66,6 +65,5 @@ export default (ctx: vscode.ExtensionContext) => {
         '$' // triggered whenever a '$' is being typed
     );
 
-    context.forEach(register);
-    util.forEach(register);
+    allTypes.forEach(register);
 };

src/providers/map.ts

@@ -0,0 +1,36 @@
+import { AutocompleteData } from '../dataTypes';
+import { CompletionItemKind } from 'vscode';
+
+/**
+ * Methods defined by the Java [Map](https://docs.oracle.com/javase/8/docs/api/java/util/Map.html) class
+ */
+export default [
+    {
+        names: ["clear"], kind: CompletionItemKind.Method, documentation: "Removes all of the mappings from this map (optional operation)."
+    },
+    {
+        names: ["containsKey"], kind: CompletionItemKind.Method, documentation: "Returns true if this map contains a mapping for the specified key.",
+        signatures: [
+            {
+                label: 'boolean containsKey(Object key)',
+                parameters: [
+                    { label: 'key', documentation: 'key whose presence in this map is to be tested' }
+                ]
+            }
+        ]
+    },
+    { names: ["containsValue"], kind: CompletionItemKind.Method, documentation: "Returns true if this map maps one or more keys to the specified value." },
+    { names: ["entrySet"], kind: CompletionItemKind.Method, documentation: "Returns a Set view of the mappings contained in this map." },
+    { names: ["get"], kind: CompletionItemKind.Method, documentation: "Returns the value to which the specified key is mapped, or null if this map contains no mapping for the key." },
+    { names: ["getOrDefault"], kind: CompletionItemKind.Method, documentation: "Returns the value to which the specified key is mapped, or defaultValue if this map contains no mapping for the key." },
+    { names: ["isEmpty"], kind: CompletionItemKind.Method, documentation: "Returns true if this map contains no key-value mappings." },
+    { names: ["keySet"], kind: CompletionItemKind.Method, documentation: "Returns a Set view of the keys contained in this map." },
+    { names: ["merge"], kind: CompletionItemKind.Method, documentation: "If the specified key is not already associated with a value or is associated with null, associates it with the given non-null value." },
+    { names: ["put"], kind: CompletionItemKind.Method, documentation: "Associates the specified value with the specified key in this map (optional operation)." },
+    { names: ["putAll"], kind: CompletionItemKind.Method, documentation: "Copies all of the mappings from the specified map to this map (optional operation)." },
+    { names: ["putIfAbsent"], kind: CompletionItemKind.Method, documentation: "If the specified key is not already associated with a value (or is mapped to null) associates it with the given value and returns null, else returns the current value." },
+    { names: ["replace"], kind: CompletionItemKind.Method, documentation: "Replaces the entry for the specified key only if it is currently mapped to some value." },
+    { names: ["replaceAll"], kind: CompletionItemKind.Method, documentation: "Replaces each entry's value with the result of invoking the given function on that entry until all entries have been processed or the function throws an exception." },
+    { names: ["size"], kind: CompletionItemKind.Method, documentation: "Returns the number of key-value mappings in this map." },
+    { names: ["values"], kind: CompletionItemKind.Method, documentation: "Returns a Collection view of the values contained in this map." },
+] as Array<AutocompleteData.Item>;

src/providers/standard/map.ts

@@ -1,6 +1,6 @@
 
 import { AutocompleteData } from '../dataTypes';
-import { CompletionItemKind } from "vscode";
+import { CompletionItemKind, MarkdownString } from "vscode";
 import time from "./time";
 import list from "./list";
 import map from "./map";
@@ -19,7 +19,66 @@ export default [{
         { names: ["toJson"], kind: CompletionItemKind.Method, documentation: 'Takes an object and returns a “stringified” JSON representation of that object.' },
         { names: ["autoId"], kind: CompletionItemKind.Method, documentation: 'Returns a 128-bit randomly generated UUID.' },
         { names: ["unauthorized"], kind: CompletionItemKind.Method, documentation: 'Throws Unauthorized for the field being resolved. This can be used in request or response mapping templates to decide if the caller should be allowed to resolve the field.' },
-        { names: ["error"], kind: CompletionItemKind.Method, documentation: 'Throws a custom error. This can be used in request or response mapping templates if the template detects an error with the request or with the invocation result.' },
+        {
+            names: ["error"], kind: CompletionItemKind.Method, documentation: 'Throws a custom error. This can be used in request or response mapping templates if the template detects an error with the request or with the invocation result.',
+            signatures: [
+                {
+                    label: "error(String error)",
+                    documentation: "Throws a custom error. This can be used in request or response mapping templates if the template detects an error with the request or with the invocation result.",
+                    parameters: [
+                        {
+                            label: "String error"
+                        }
+                    ]
+                },
+                {
+                    label: "error(String error, String errorType)",
+                    documentation: new MarkdownString("Throws a custom error. This can be used in request or response mapping templates if the template detects an error with the request or with the invocation result. Additionally, an `errorType` can be specified."),
+                    parameters: [
+                        {
+                            label: "String error"
+                        },
+                        {
+                            label: "String errorType"
+                        }
+                    ]
+                },
+                {
+                    label: "error(String error, String errorType, Object data)",
+                    documentation: new MarkdownString("Throws a custom error. This can be used in request or response mapping templates if the template detects an error with the request or with the invocation result. Additionally, an `errorType` and a `data` field can be specified. The `data` value will be added to the corresponding error block inside `errors` in the GraphQL response. **Note**: `data` will be filtered based on the query selection set."),
+                    parameters: [
+                        {
+                            label: "String error"
+                        },
+                        {
+                            label: "String errorType"
+                        },
+                        {
+                            label: "Object data"
+                        }
+                    ]
+                },
+                {
+                    label: "error(String error, String errorType, Object data, Object errorInfo)",
+                    documentation: new MarkdownString("Throws a custom error. This can be used in request or response mapping templates if the template detects an error with the request or with the invocation result. Additionally, an `errorType` field, a `data` field, and a `errorInfo` field can be specified. The data value will be added to the corresponding error block inside errors in the GraphQL response. **Note**: `data` will be filtered based on the query selection set. The `errorInfo` value will be added to the corresponding `error` block inside `errors` in the GraphQL response. **Note**: `errorInfo` will NOT be filtered based on the query selection set."),
+                    parameters: [
+                        {
+                            label: "String error"
+                        },
+                        {
+                            label: "String errorType"
+                        },
+                        {
+                            label: "Object data"
+                        },
+                        {
+                            label: "Object errorInfo"
+                        }
+                    ]
+                }
+            ]
+
+        },
         { names: ["appendError"], kind: CompletionItemKind.Method, documentation: 'Appends a custom error. This can be used in request or response mapping templates if the template detects an error with the request or with the invocation result. Unlike `$util.error(String)`, the template evaluation will not be interrupted, so that data can be returned to the caller.' },
         { names: ["validate"], kind: CompletionItemKind.Method, documentation: 'If the condition is false, throw a CustomTemplateException with the specified message.' },
         { names: ["isNull"], kind: CompletionItemKind.Method, documentation: 'Returns true if the supplied object is null.' },