@arcgis/coding-components 4.31.0-next.33 → 4.31.0-next.34

package/dist/components/sql-expr-mode.js

@@ -1,14 +1,10 @@
 /*!
  * All material copyright Esri, All Rights Reserved, unless otherwise specified.
  * See https://js.arcgis.com/4.31/esri/copyright.txt for details.
- * v4.31.0-next.33
+ * v4.31.0-next.34
  */
-import * as monaco from 'monaco-editor';
 import { editor, languages, Emitter } from 'monaco-editor';
-import { a as getFieldsFromLayerVariable, s as sqlExprDefaults } from './sql-expr-defaults.js';
-import { t as toCompletionItemKind } from './arcade-language-features.js';
-import { InsertTextFormat } from 'vscode-languageserver-types';
-import { h as importCoreSql, j as newLayersSupportFieldsIndex } from './fields.js';
+import { s as sqlExprDefaults } from './sql-expr-defaults.js';
 import { t as debounce } from './index2.js';
 
 /**
@@ -57,6 +53,142 @@ class SqlExprWorkerManager {
     }
 }
 
+// list of properties that sit on a SQLNode and can have children
+var ChildBearingProperties;
+(function (ChildBearingProperties) {
+    ChildBearingProperties["ARGS"] = "args";
+    ChildBearingProperties["CLAUSES"] = "clauses";
+    ChildBearingProperties["ELSE"] = "else";
+    ChildBearingProperties["END"] = "end";
+    ChildBearingProperties["EXPR"] = "expr";
+    ChildBearingProperties["LEFT"] = "left";
+    ChildBearingProperties["OPERAND"] = "operand";
+    ChildBearingProperties["QUALIFIER"] = "qualifier";
+    ChildBearingProperties["RIGHT"] = "right";
+    ChildBearingProperties["START"] = "start";
+    ChildBearingProperties["VALUE"] = "value";
+})(ChildBearingProperties || (ChildBearingProperties = {}));
+// list of node types that can have children
+var ChildBearingNodeTypes;
+(function (ChildBearingNodeTypes) {
+    ChildBearingNodeTypes["CASE_EXPRESSION"] = "case-expression";
+    ChildBearingNodeTypes["EXPRESSION_LIST"] = "expression-list";
+    ChildBearingNodeTypes["FUNCTION"] = "function";
+    ChildBearingNodeTypes["INTERVAL"] = "interval";
+    ChildBearingNodeTypes["INTERVAL_QUALIFIER"] = "interval-qualifier";
+    ChildBearingNodeTypes["WHEN_CLAUSE"] = "when-clause";
+    ChildBearingNodeTypes["UNARY_EXPRESSION"] = "unary-expression";
+    ChildBearingNodeTypes["BINARY_EXPRESSION"] = "binary-expression";
+})(ChildBearingNodeTypes || (ChildBearingNodeTypes = {}));
+// use object to ensure the list matches the types from the JS api
+const castDataTypesDict = {
+    date: "DATE",
+    float: "FLOAT",
+    integer: "INTEGER",
+    real: "REAL",
+    smallint: "SMALLINT",
+    time: "TIME",
+    timestamp: "TIMESTAMP",
+    varchar: "VARCHAR",
+};
+// convert the object to a list of strings for easier use, but keep type information
+Object.values(castDataTypesDict);
+const sqlExprKeywords = [
+    "AND",
+    "AS",
+    "BETWEEN",
+    "BOTH",
+    "CASE",
+    "CAST",
+    "CURRENT_DATE",
+    "CURRENT_TIME",
+    "CURRENT_TIMESTAMP",
+    "DATE",
+    "DAY",
+    "ELSE",
+    "END",
+    "ESCAPE",
+    "FALSE",
+    "FLOAT",
+    "FOR",
+    "FROM",
+    "HOUR",
+    "IN",
+    "INTEGER",
+    "INTERVAL",
+    "IS",
+    "LEADING",
+    "LIKE",
+    "MINUTE",
+    "MONTH",
+    "NOT",
+    "NULL",
+    "OR",
+    "POSITION",
+    "REAL",
+    "SECOND",
+    "SMALLINT",
+    "SUBSTRING",
+    "THEN",
+    "TIME",
+    "TIMESTAMP",
+    "TIMEZONE_HOUR",
+    "TIMEZONE_MINUTE",
+    "TO",
+    "TRAILING",
+    "TRIM",
+    "TRUE",
+    "VARCHAR",
+    "WHEN",
+    "WITH",
+    "YEAR",
+    "ZONE",
+];
+const sqlExprOperators = [
+    // Logical
+    "AND",
+    "BETWEEN",
+    "IN",
+    "LIKE",
+    "NOT",
+    "OR",
+    // Predicates
+    "IS",
+    "NULL",
+];
+const sqlExprFunctions = [
+    // Conversion
+    "CAST",
+    // Datetime
+    "EXTRACT",
+    "CURRENT_DATE",
+    "CURRENT_TIME",
+    "CURRENT_TIMESTAMP",
+    // Mathematical
+    "ABS",
+    "ACOS",
+    "ASIN",
+    "ATAN",
+    "CEILING",
+    "COS",
+    "FLOOR",
+    "LOG",
+    "LOG10",
+    "POWER",
+    "ROUND",
+    "SIGN",
+    "SIN",
+    "TAN",
+    // String
+    "CHAR_LENGTH",
+    "COALESCE",
+    "CONCAT",
+    "LOWER",
+    "POSITION",
+    "TRIM",
+    "UPPER",
+];
+
 const sqlExprLanguageConfig = {
     comments: {
         lineComment: "--",
@@ -91,104 +223,9 @@ const sqlExprLanguageSyntax = {
         { open: "[", close: "]", token: "delimiter.square" },
         { open: "(", close: ")", token: "delimiter.parenthesis" },
     ],
-    keywords: [
-        // This list is narrowed to the scope of esri's sql flavor
-        "AND",
-        "AS",
-        "BETWEEN",
-        "BOTH",
-        "CASE",
-        "CAST",
-        "CURRENT_DATE",
-        "CURRENT_TIME",
-        "CURRENT_TIMESTAMP",
-        "DATE",
-        "DAY",
-        "ELSE",
-        "END",
-        "ESCAPE",
-        "EXTRACT",
-        "FALSE",
-        "FLOAT",
-        "FOR",
-        "FROM",
-        "HOUR",
-        "IN",
-        "INTEGER",
-        "INTERVAL",
-        "IS",
-        "LEADING",
-        "LIKE",
-        "MINUTE",
-        "MONTH",
-        "NOT",
-        "NULL",
-        "OR",
-        "POSITION",
-        "REAL",
-        "SECOND",
-        "SMALLINT",
-        "SUBSTRING",
-        "THEN",
-        "TIME",
-        "TIMESTAMP",
-        "TIMEZONE_HOUR",
-        "TIMEZONE_MINUTE",
-        "TO",
-        "TRAILING",
-        "TRIM",
-        "TRUE",
-        "VARCHAR",
-        "WHEN",
-        "WITH",
-        "YEAR",
-        "ZONE",
-    ],
-    operators: [
-        // Logical
-        "AND",
-        "BETWEEN",
-        "IN",
-        "LIKE",
-        "NOT",
-        "OR",
-        // Predicates
-        "IS",
-        "NULL",
-    ],
-    builtinFunctions: [
-        // Conversion
-        "CAST",
-        // Datetime
-        "DATE",
-        "CURRENT_DATE",
-        "CURRENT_TIME",
-        "CURRENT_TIMESTAMP",
-        "DAY",
-        "MONTH",
-        "YEAR",
-        // Mathematical
-        "ABS",
-        "ACOS",
-        "ASIN",
-        "ATAN",
-        "CEILING",
-        "COS",
-        "FLOOR",
-        "LOG",
-        "LOG10",
-        "POWER",
-        "ROUND",
-        "SIGN",
-        "SIN",
-        "TAN",
-        // String
-        "CHAR_LENGTH",
-        "CONCAT",
-        "LOWER",
-        "TRIM",
-        "UPPER",
-    ],
+    keywords: sqlExprKeywords,
+    operators: sqlExprOperators,
+    builtinFunctions: sqlExprFunctions,
     builtinVariables: [],
     tokenizer: {
         root: [
@@ -256,661 +293,28 @@ const sqlExprLanguageSyntax = {
     },
 };
 
-async function sqlExpressionCompletion(range, model, position, sdkFunctions) {
-    try {
-        /*
-          Handles the case where we have a valid SQL expression in the editor and is
-          able to generate an AST from it and traverse it to provide completion items.
-        */
-        const editorValue = model.getValue();
-        const sql = await importCoreSql();
-        const fieldIndex = await newLayersSupportFieldsIndex([]);
-        const { parseTree } = await sql.parseWhereClause(editorValue, fieldIndex);
-        const completionItems = getCompletionItems(model, parseTree, range, position, sdkFunctions);
-        return completionItems;
-    }
-    catch {
-        /*
-          Handles the case where we have an incomplete SQL expression (i.e. if users are
-          still typing or has erroneous syntax). We fall back to a more lexical approach
-          in this way to "fail gracefully" in order to still provide completion items.
-        */
-        const errorRange = {
-            startColumn: 1,
-            endColumn: position.column,
-            startLineNumber: 1,
-            endLineNumber: position.lineNumber,
-        };
-        /* Matching a '(', ')', ' ', or ',' */
-        const delimiter = /(?:\(|\)|\s|,)/u;
-        /*
-          Filter callback function to filter out all non-function words, non-sql keywords, empty
-          strings and single quotes ('). Preserve all '(', ')', ',' and 'END' tokens
-          within our array.
-         */
-        const filterToken = (token) => {
-            const tokenIsAFunction = sdkFunctions[token] !== undefined;
-            const isParenLessFunction = isSqlParenLessFunction(token);
-            const excludedTokens = token !== "" && token !== "'";
-            const includedTokens = ["(", ")", ",", "END"].includes(token);
-            /*
-              Returns the tokens if they are either a standardized function, parenthesis-less function
-              or is one of the tokens that we specified to keep. Filters all empty string and
-              single quotations.
-            */
-            return excludedTokens && (tokenIsAFunction || isParenLessFunction || includedTokens);
-        };
-        const textValueUpToCursor = model.getValueInRange(errorRange).toUpperCase();
-        // TODO: test this...
-        const tokens = textValueUpToCursor
-            .split(delimiter)
-            .map((token) => token.trim())
-            .filter((token) => filterToken(token));
-        /* Keeps track of our current context item */
-        const contextStack = [];
-        for (let i = 0; i < tokens.length; i++) {
-            const token = tokens[i];
-            const nonEmptyContextStack = contextStack.length > 0;
-            /*
-              As long as we have not hit the last token in our list yet, we can do a
-              lookahead and see if the next token makes a valid sub-expression.
-            */
-            if (i < tokens.length - 1) {
-                const nextToken = tokens[i + 1];
-                const invalidFunctionCall = sdkFunctions[token] && nextToken !== "(";
-                if (invalidFunctionCall) {
-                    continue;
-                }
-            }
-            if (token === "(" || token === ",") {
-                if (nonEmptyContextStack) {
-                    const currentContext = contextStack[contextStack.length - 1];
-                    /*
-                      This marks the end of our parenthesis-less function's scope, hence
-                      we cleanse the context and let the next token update the context.
-                    */
-                    if (isSqlParenLessFunction(currentContext)) {
-                        contextStack.pop();
-                    }
-                }
-                continue;
-            }
-            else if (token === ")" || token === "END") {
-                /*
-                  If we have a non empty context stack, that means we are within another
-                  function's scope right now (another context). We will return to the outer
-                  scope to provide us the necessary completion items.
-                */
-                if (nonEmptyContextStack) {
-                    contextStack.pop();
-                }
-                continue;
-            }
-            /*
-              If we end off with a standardized function without a '(', we should not
-              update the context. We should only trigger completion if they have a '('
-              to indicate that it's a function call.
-            */
-            if (i === tokens.length - 1 && sdkFunctions[token]) {
-                continue;
-            }
-            /*
-              Very specific case where we have something like
-      
-              | TRIM(INTERVAL INTERVAL, ... |
-      
-              and we do not want the completion items for "INTERVAL" to persist even after
-              the context ends.
-      
-              In essence, we only update the context once.
-            */
-            if (i > 0) {
-                const prevTokenIsParenLess = isSqlParenLessFunction(tokens[i - 1]);
-                const curTokenIsParenLess = isSqlParenLessFunction(token);
-                if (!(curTokenIsParenLess && prevTokenIsParenLess)) {
-                    contextStack.push(token);
-                }
-            }
-            else if (i === 0) {
-                contextStack.push(token);
-            }
-        }
-        let completionItems = [];
-        [...new Set(contextStack)].forEach((context, index) => {
-            const autoCompletionItem = generateCompletionList(context, range, index);
-            completionItems = [...completionItems, ...autoCompletionItem];
-        });
-        return completionItems;
-    }
-}
-/*
-  Helper function that takes in our model/position information and traverse the
-  completed AST to generate an array of Monaco's completion items.
-
-  This function is invoked only if we have a valid SQL expression that can be parsed to
-  generate an AST. In other words, this is only invoked for our "success" case.
-*/
-const getCompletionItems = (model, node, range, position, sdkFunctions) => {
-    /*
-      Using an object here so that we can pass by reference to the function to
-      handle updating the state instead of pass by value if we use a primitive
-      type like string. This also allows us to extend the context and add more
-      data and attributes if we need to in the future.
-    */
-    const context = { contextString: "NONE", additionalContext: "NONE" };
-    traverseAST({ model, node, position, context, sdkFunctions });
-    const { contextString, additionalContext } = context;
-    const completionItems = generateCompletionList(contextString, range, 0);
-    const additionalItems = generateCompletionList(additionalContext, range, 1);
-    return [...completionItems, ...additionalItems];
-};
-/*
-  This function traverses the AST and finds which node and context we are currently
-  in to help provide the necessary completion items. This follows from having a complete
-  and valid SQL expression. The main purpose of this function is to provide the correct
-  completion items when users trigger IntelliSense via CTRL + Space.
-
-  This is a recursive function.
-*/
-// eslint-disable-next-line complexity
-const traverseAST = (
-/*
-  Keeping the node type as generic 'any' here as __esri.SQLNode does not have updated types
-  with the addition of the range property. Documentation is outdated and may or may not
-  contain mismatching property names (ListNode uses "expr" as property for all expressions
-  but representation is via "value") and some missing cases (e.g. case "parameter" is not
-  identified).
-*/
-{ model, node, position, context, sdkFunctions, delimiterPos, }) => {
-    /* Our current cursor position within the editor */
-    // const cursorRow: number = position.lineNumber;
-    // const cursorColumn: number = position.column;
-    switch (node.type) {
-        case "interval": {
-            /*
-              Here, we are using an interval node as a standalone and not within any
-              function call or expression list.
-            */
-            if (!delimiterPos) {
-                updateContext(context, "INTERVAL", false);
-                return;
-            }
-            /*
-              We can ensure that the match is never null since a fully generated AST
-              follows from a syntactically correct SQL expression.
-            */
-            const nextDelimPos = model.findNextMatch(
-            // @ts-ignore
-            /\)|,/u, {
-                lineNumber: node.location.end.line,
-                column: node.location.end.column,
-            }, true, true, null, true).range;
-            const [inlineFunc, funcWrapped] = getCursorWithinRange(position, delimiterPos, nextDelimPos);
-            if (inlineFunc ?? funcWrapped) {
-                updateContext(context, "INTERVAL", false);
-            }
-            return;
-        }
-        case "case-expression": {
-            /* Only update context if we are within the range */
-            // Representing the range for the "CASE" keyword for starting the case expression
-            const startPos = {
-                startColumn: node.location.start.column,
-                endColumn: node.location.start.column + "CASE".length,
-                startLineNumber: node.location.start.line,
-                endLineNumber: node.location.start.line,
-            };
-            // Representing the range for the "END" keyword for ending the case expression
-            const endPos = {
-                startColumn: node.location.end.column - "END".length,
-                endColumn: node.location.end.column,
-                startLineNumber: node.location.end.line,
-                endLineNumber: node.location.end.line,
-            };
-            const [inline, wrapped] = getCursorWithinRange(position, startPos, endPos);
-            if (inline ?? wrapped) {
-                updateContext(context, "CASE", false);
-            }
-            return;
-        }
-        case "expression-list": {
-            const exprList = node.value;
-            let delimiter;
-            exprList.forEach((expr, index) => {
-                /* The position of our opening delimiter '(' */
-                if (index === 0) {
-                    const match = model.findMatches("(", {
-                        startLineNumber: 1,
-                        endLineNumber: node.location.start.line,
-                        startColumn: 1,
-                        endColumn: node.location.start.column,
-                    }, false, true, null, true);
-                    delimiter = match[match.length - 1].range;
-                }
-                traverseAST({ model, node: expr, position, context, sdkFunctions, delimiterPos: delimiter });
-                /*
-                  Finds and updates our next delimiter position (i.e. the delimiter that immediately
-                  follows this current node)
-                */
-                delimiter = getDelimiterPosition(index + 1, expr, model, exprList.length);
-            });
-            return;
-        }
-        case "unary-expression":
-            traverseAST({ model, node: node.expr, position, context, sdkFunctions });
-            return;
-        case "binary-expression":
-            traverseAST({ model, node: node.left, position, context, sdkFunctions });
-            traverseAST({ model, node: node.right, position, context, sdkFunctions });
-            return;
-        case "null":
-        case "boolean":
-        case "string":
-        case "timestamp":
-        case "date":
-        case "time":
-        case "number":
-        case "current-time":
-            return;
-        case "column-reference": {
-            const columnName = node.column;
-            const isParenLessFunction = isSqlParenLessFunction(columnName);
-            /*
-              In this case, we are using a standalone column reference, not a part of any
-              expression list or function param. Update the context accordingly if it is
-              any of the parenthesis-less functions.
-            */
-            if (!delimiterPos) {
-                if (isParenLessFunction) {
-                    updateContext(context, columnName, false);
-                }
-                return;
-            }
-            /*
-              The delimiter right before we start our expression. This delimiter is useful for us
-              as it gives positional information for when the expression starts if it's used as a
-              parameter in a function.
-      
-              For example, if we have something like Function(a, b), then the range of b would have
-              a start column value of 13 (offset of 12) whereas "," would be 11 (offset of 10).
-      
-              This will be useful in the case where we want to provide completion items before our
-              keyword appears (if any).
-            */
-            const delimiterCharacter = model.getValueInRange(delimiterPos);
-            const nextDelimiterPos = model.findNextMatch(
-            /*
-              Function call only accepts string even though docs noted that RegExp is allowed.
-              "@param searchString — The string used to search. If it is a regular expression,
-              set isRegex to true"
-            */
-            // @ts-ignore
-            /\)|,/u, {
-                column: node.location.start.column,
-                lineNumber: node.location.start.line,
-            }, true, true, null, true).range;
-            const [inlineWithFunction, wrappedWithinFunction] = getCursorWithinRange(position, delimiterPos, nextDelimiterPos);
-            if (inlineWithFunction ?? wrappedWithinFunction) {
-                /*
-                  We updated our additional context here if this is our first argument within a function call.
-                  This is so we don't override the previous context with our current context, which may
-                  strip away certain completion items. For example, if we have the SQL expression
-                  CAST(INTERVAL), we still want the completion items for CAST as well as INTERVAL.
-                */
-                if (isParenLessFunction) {
-                    updateContext(context, columnName, delimiterCharacter === "(");
-                }
-            }
-            return;
-        }
-        case "data-type":
-            return;
-        case "function": {
-            const functionName = node.name;
-            const argsList = node.args.value;
-            const startRange = {
-                startLineNumber: node.location.start.line,
-                endLineNumber: node.location.start.line,
-                startColumn: node.location.start.column,
-                endColumn: node.location.start.column + functionName.length,
-            };
-            const endRange = {
-                startLineNumber: node.location.end.line,
-                endLineNumber: node.location.end.line,
-                startColumn: node.location.end.column,
-                endColumn: node.location.end.column,
-            };
-            const [inlineWithFunc, wrappedWithinFunc] = getCursorWithinRange(position, startRange, endRange);
-            if (inlineWithFunc ?? wrappedWithinFunc) {
-                updateContext(context, functionName, false);
-            }
-            let delimiterPosition;
-            argsList.forEach((arg, index) => {
-                const nodeType = arg.type;
-                let completionNodeType = false;
-                switch (nodeType) {
-                    case "function":
-                    case "column-reference":
-                    case "interval":
-                    case "case-expression":
-                        completionNodeType = true;
-                        break;
-                }
-                /*
-                  We can ensure that the match is never undefined since a fully generated AST
-                  follows from a syntactically correct SQL expression.
-                */
-                if (index === 0) {
-                    delimiterPosition = model.findNextMatch("(", {
-                        column: node.location.start.column,
-                        lineNumber: node.location.start.line,
-                    }, false, true, null, true).range;
-                }
-                /* TRIM(abc) === TRIM(BOTH ' ' FROM abc). In this case, our next delimiter is the end */
-                const trimFuncDefault = arg.type === "string" && arg.value === "BOTH";
-                /*
-                  If the current node is not a completion node type, and is the default trim function,
-                  then we will just use the current node as a reference to get the next delimiter position.
-                */
-                if (!completionNodeType && trimFuncDefault) {
-                    return;
-                }
-                traverseAST({ model, node: arg, position, context, sdkFunctions, delimiterPos: delimiterPosition });
-                delimiterPosition = getDelimiterPosition(index + 1, arg, model, argsList.length);
-            });
-            return;
-        }
-        /* Currently no support for parameter type (@) */
-        case "parameter":
-        case "when-clause":
-        case "interval-period":
-        case "interval-qualifier":
-            return;
-        default:
-            throw new Error("Invalid syntax.");
-    }
-};
-/*
-  Helper function that generates our list of completion items after traversing
-  our AST and updating the context.
-  
-  The sorting number is used as a way of grouping and organizing our completion lists.
-
-  - All default completion items have a sort value of 'z' (ASCII 122) + their corresponding
-    grouping value (e.g. 'za', 'zb', etc...)
-  - All completion items found by cursor matching have a value between 'a' - 'y' (ASCII 97-121)
-  - The higher the sorting number, the higher it will appear on our completion list
-*/
-const generateCompletionList = (functionName, range, sortingNumber) => {
-    const identifiers = getKeywords(functionName);
-    const completionItems = identifiers?.map((identifier) => {
-        const dataKind = dataTypes.includes(identifier.toUpperCase())
-            ? monaco.languages.CompletionItemKind.TypeParameter
-            : monaco.languages.CompletionItemKind.Keyword;
-        // ASCII value of 'y'
-        const asciiY = 121;
-        return {
-            label: identifier,
-            kind: dataKind,
-            insertText: identifier,
-            range,
-            sortText: String.fromCharCode(asciiY - sortingNumber),
-        };
-    });
-    return completionItems ?? [];
-};
-/*
-  Function to help us update our current context depending on where our cursor
-  is within the editor. This will allow us to gather the relevant completion items
-  depending on the value of the context (i.e. the function that our cursor is within).
-
-  This is invoked only during our traversal of the AST (i.e. "success" case).
-*/
-const updateContext = (oldContext, newContext, updateAdditionalContext) => {
-    // eslint-disable-next-line @typescript-eslint/no-unused-expressions
-    updateAdditionalContext ? (oldContext.additionalContext = newContext) : (oldContext.contextString = newContext);
-};
-/** source  */
-const sqlBinOps = [
-    "AND",
-    "OR",
-    "IS",
-    "ISNOT",
-    "IN",
-    "NOT IN",
-    "BETWEEN",
-    "NOTBETWEEN",
-    "LIKE",
-    "NOT LIKE",
-];
-/*
-  The current state of sorting completion items.
-
-  All fields that are provided by default (keywords, standardized functions, constants, etc.)
-  all have a sort value of "z". As we parse our SQL Expression and traverse an AST (if we can),
-  we will have new completion items depending on our cursor context. These completion items
-  should appear first at the top of our list, with the most recent context having the highest
-  appearance on our list. In this manner, we add new completion items with a smaller
-  lexicographic value than the previous to promote the correct ordering. (I.e. add in new completion
-  items with a sort value of "y" next, then "x", then "w", all the way until "a". It is unlikely
-  that we will need more than 26 difference context but if we do require more, we can make use of
-  double-lettered sort values).
-*/
-const sortTextValues = {
-    identifiers: "a",
-    fields: "aa",
-    constants: "ab",
-    literals: "ab",
-    functions: "ac",
-    snippets: "b",
-    keywords: "c",
-    dataType: "d",
-};
-function generateCompletionItems(fields, range, sdkFunctions) {
-    const fieldsCompletion = fields.map((field) => ({
-        label: field.completion?.label ?? field.name,
-        insertText: field.completion?.insertText ?? field.name,
-        sortText: `z${sortTextValues.fields}`,
-        detail: field.completion?.detail,
-        range,
-        kind: monaco.languages.CompletionItemKind.Variable,
-        documentation: field.completion?.documentation,
-    }));
-    //   {
-    //   const funcName = func.toLowerCase();
-    //   const apiContext = apiFunctions[funcName as keyof typeof apiFunctions] as ApiContextType;
-    //   const { name, snippet, parameters, returnValue, description, examples } = apiContext;
-    //   const completionItemData = {
-    //     kind: monaco.languages.CompletionItemKind.Function,
-    //     range,
-    //     sortText: `z${sortTextValues.functions}`,
-    //     detail: generateTypeDescription(name, parameters, returnValue),
-    //     documentation: generateCompletionDocumentation(description, examples),
-    //   };
-    //   /*
-    //     We take 2 different forms of the same function over our REST API.
-    //     e.g. CURRENT_TIME and CURRENT_TIME() are both accepted.
-    //   */
-    //   if (Array.isArray(snippet) && snippet.length) {
-    //     return [
-    //       { ...completionItemData, label: name, insertText: snippet[0]! },
-    //       snippet[1] && { ...completionItemData, label: name.slice(0, -2), insertText: snippet[1] },
-    //     ];
-    //   }
-    //   return [{ ...completionItemData, label: name, insertText: snippet }];
-    // }
-    // );
-    const sqlBinOpsCompletion = sqlBinOps.map((binOp) => {
-        const formatOperator = (binOp) => {
-            if (binOp === "ISNOT") {
-                return "IS NOT";
-            }
-            if (binOp === "NOTBETWEEN") {
-                return "NOT BETWEEN";
-            }
-            return binOp;
-        };
-        return {
-            label: formatOperator(binOp),
-            kind: monaco.languages.CompletionItemKind.Keyword,
-            insertText: formatOperator(binOp),
-            range,
-            sortText: `z${sortTextValues.keywords}`,
-        };
-    });
-    const sqlKeywordsCompletion = sqlParenLessFunctions.map((keyword) => {
-        if (keyword === "CASE") {
-            return {
-                label: keyword,
-                kind: monaco.languages.CompletionItemKind.Snippet,
-                insertText: `CASE
-	WHEN condition1 THEN result1 
-	ELSE result
-END`,
-                range,
-                sortText: `z${sortTextValues.snippets}`,
-            };
-        }
-        return {
-            label: keyword,
-            kind: monaco.languages.CompletionItemKind.Keyword,
-            insertText: keyword,
-            range,
-            sortText: `z${sortTextValues.keywords}`,
-        };
-    });
-    const sqlDataTypeCompletion = dataTypes.map((dataType) => ({
-        label: dataType,
-        kind: monaco.languages.CompletionItemKind.TypeParameter,
-        insertText: dataType,
-        range,
-        sortText: `z${sortTextValues.dataType}`,
-    }));
-    const sqlFunctionCompletion = Object.values(sdkFunctions).map((apiItem) => {
-        const entry = apiItem.completion;
-        const item = {
-            label: entry.label,
-            insertText: entry.insertText || entry.label,
-            sortText: `z${sortTextValues.functions}`,
-            filterText: entry.filterText,
-            detail: entry.detail,
-            range,
-            kind: toCompletionItemKind(entry.kind),
-        };
-        if (entry.insertTextFormat === InsertTextFormat.Snippet) {
-            item.insertTextRules = languages.CompletionItemInsertTextRule.InsertAsSnippet;
-        }
-        if (entry.documentation) {
-            if (typeof entry.documentation === "string") {
-                item.documentation = entry.documentation;
-            }
-            else {
-                item.documentation = {
-                    supportThemeIcons: false,
-                    value: entry.documentation.value,
-                    supportHtml: true,
-                };
-            }
-        }
-        return item;
-    });
-    return {
-        fieldsCompletion,
-        sqlFunctionCompletion,
-        sqlBinOpsCompletion,
-        sqlKeywordsCompletion,
-        sqlDataTypeCompletion,
-    };
-}
-
-// list of properties that sit on a SQLNode and can have children
-var ChildBearingProperties;
-(function (ChildBearingProperties) {
-    ChildBearingProperties["ARGS"] = "args";
-    ChildBearingProperties["CLAUSES"] = "clauses";
-    ChildBearingProperties["ELSE"] = "else";
-    ChildBearingProperties["END"] = "end";
-    ChildBearingProperties["EXPR"] = "expr";
-    ChildBearingProperties["LEFT"] = "left";
-    ChildBearingProperties["OPERAND"] = "operand";
-    ChildBearingProperties["QUALIFIER"] = "qualifier";
-    ChildBearingProperties["RIGHT"] = "right";
-    ChildBearingProperties["START"] = "start";
-    ChildBearingProperties["VALUE"] = "value";
-})(ChildBearingProperties || (ChildBearingProperties = {}));
-// list of node types that can have children
-var ChildBearingNodeTypes;
-(function (ChildBearingNodeTypes) {
-    ChildBearingNodeTypes["CASE_EXPRESSION"] = "case-expression";
-    ChildBearingNodeTypes["EXPRESSION_LIST"] = "expression-list";
-    ChildBearingNodeTypes["FUNCTION"] = "function";
-    ChildBearingNodeTypes["INTERVAL"] = "interval";
-    ChildBearingNodeTypes["INTERVAL_QUALIFIER"] = "interval-qualifier";
-    ChildBearingNodeTypes["WHEN_CLAUSE"] = "when-clause";
-    ChildBearingNodeTypes["UNARY_EXPRESSION"] = "unary-expression";
-    ChildBearingNodeTypes["BINARY_EXPRESSION"] = "binary-expression";
-})(ChildBearingNodeTypes || (ChildBearingNodeTypes = {}));
-const sqlFunctionParamKeywords = {
-    CAST: ["DATE", "FLOAT", "INTEGER", "REAL", "SMALLINT", "TIME", "TIMESTAMP", "VARCHAR"],
-    EXTRACT: ["YEAR", "MONTH", "DAY", "HOUR", "MINUTE", "SECOND"],
-    TRIM: ["LEADING", "TRAILING", "BOTH"],
-};
-
-function transposeSdkFunctions(sdkLibrary) {
-    return sdkLibrary.flatMap((category) => category.items).reduce((acc, item) => ({ ...acc, [item.name]: item }), {});
-}
 class SqlExprCompletionProvider {
-    constructor(
-    // private _worker: ISqlExprWorkerAccessor,
-    _defaults) {
+    constructor(_worker, _defaults) {
+        this._worker = _worker;
         this._defaults = _defaults;
-        this._sdkFunctions = transposeSdkFunctions([]);
     }
     async provideCompletionItems(model, position) {
-        const word = model.getWordUntilPosition(position);
-        const range = {
-            startLineNumber: position.lineNumber,
-            endLineNumber: position.lineNumber,
-            startColumn: word.startColumn,
-            endColumn: word.endColumn,
-        };
-        const apiContext = this._defaults.getApiContextForModel(model.uri);
-        // get the fields from the api context
-        const fields = apiContext.profile ? getFieldsFromLayerVariable(apiContext.profile) : [];
-        const sdkLibrary = await this._defaults.getApiLibrary(model.uri.toString());
-        this._sdkFunctions = transposeSdkFunctions(sdkLibrary);
-        const sqlContextCompletion = await sqlExpressionCompletion(range, model, position, this._sdkFunctions);
-        const { sqlKeywordsCompletion, sqlBinOpsCompletion, sqlFunctionCompletion, fieldsCompletion, sqlDataTypeCompletion, } = generateCompletionItems(fields, range, this._sdkFunctions);
-        /*
-              Filters our completion items list so that if we happen to have the same label but
-              different sortText order, we keep the sortText with the lowest ASCII value (i.e.
-              the smallest character in terms of lexicographic ordering).
-            */
-        const filteredItems = new Map();
-        [
-            ...sqlKeywordsCompletion,
-            ...sqlBinOpsCompletion,
-            ...sqlDataTypeCompletion,
-            ...sqlFunctionCompletion,
-            ...fieldsCompletion,
-            ...sqlContextCompletion,
-        ].forEach((item) => {
-            const { sortText } = item;
-            const label = item.label;
-            const itemExists = filteredItems.get(label);
-            if (!itemExists) {
-                filteredItems.set(label, item);
-            }
-            const currentOrder = sortText.charCodeAt(0);
-            const currentLowestOrder = filteredItems.get(label).sortText.charCodeAt(0);
-            if (currentOrder < currentLowestOrder) {
-                filteredItems.set(label, item);
-            }
-        });
-        const completionItems = Array.from(filteredItems.entries()).map(([, value]) => value);
-        return {
-            suggestions: completionItems,
-        };
+        try {
+            const worker = await this._worker(model.uri);
+            const word = model.getWordUntilPosition(position);
+            const range = {
+                startLineNumber: position.lineNumber,
+                endLineNumber: position.lineNumber,
+                startColumn: word.startColumn,
+                endColumn: word.endColumn,
+            };
+            const apiContext = this._defaults.getApiContextForModel(model.uri);
+            return await worker.doComplete(model.uri.toString(), range, position, apiContext);
+        }
+        catch (err) {
+            console.error(err);
+            return { suggestions: [] };
+        }
     }
 }
 // TODO: create DiagnosticsAdapter common class
@@ -989,117 +393,6 @@ class SqlExprDiagnosticsAdapter {
         }
     }
 }
-const sqlParenLessFunctions = ["INTERVAL", "CASE"];
-const dataTypes = sqlFunctionParamKeywords.CAST;
-/*
-  Helper function that takes in a context string and returns a string list of
-  all the keywords that are used by that identifier. This is used to generate
-  our completion items list for specific contexts.
-*/
-const getKeywords = (identifier) => {
-    switch (identifier.toLowerCase()) {
-        case "extract":
-            /* Need to revisit TIMEZONE_HOUR and TIMEZONE_MINUTE with the team */
-            return sqlFunctionParamKeywords.EXTRACT;
-        case "position":
-            return ["IN"];
-        case "trim":
-            return sqlFunctionParamKeywords.TRIM;
-        case "cast":
-            return ["AS", ...sqlFunctionParamKeywords.CAST];
-        case "interval":
-            return [...sqlFunctionParamKeywords.EXTRACT];
-        case "case":
-            return ["WHEN", "THEN", "ELSE", "END"];
-        default:
-            return [];
-    }
-};
-/*
-  Helper function that takes in an index and node and determines the next
-  delimiter position after the current index argument. This function is invoked
-  only when we have a list of arguments via a function call or expression list.
-*/
-const getDelimiterPosition = (index, node, model, lastIndex) => {
-    let delimiterPosition;
-    const start = node.location.start;
-    const end = node.location.end;
-    /*
-        We can ensure that the match is never null since a fully generated AST
-        follows from a syntactically correct SQL expression.
-      */
-    if (index === 0) {
-        delimiterPosition = model.findNextMatch("(", {
-            lineNumber: start.line,
-            column: start.column,
-        }, false, true, null, true).range;
-    }
-    else if (index === lastIndex) {
-        delimiterPosition = {
-            startLineNumber: end.line,
-            endLineNumber: end.line,
-            startColumn: end.column,
-            endColumn: end.column,
-        };
-    }
-    else {
-        delimiterPosition = model.findNextMatch(",", {
-            lineNumber: start.line,
-            column: start.column,
-        }, false, true, null, true).range;
-    }
-    return delimiterPosition;
-};
-/* Helper function to determine if our word is a SQL parenthesis-less function. */
-const isSqlParenLessFunction = (word) => {
-    const keyword = word.toUpperCase();
-    return sqlParenLessFunctions.includes(keyword);
-};
-/*
-  Helper function to determine if our cursor is within the range of a function.
-  This can be any of the patterns:
-  - function(<here>)
-  - function(<here>
-    <here>
-  <here>)
-*/
-const getCursorWithinRange = (position, startPos, endPos) => {
-    let inlineWithFunction = false;
-    let wrappedWithinFunction = false;
-    const cursorColumn = position.column;
-    const cursorRow = position.lineNumber;
-    /*
-      Handles the case if our function is inline. An expression following the pattern
-      
-      FUNCTION(arg) where our cursor position is in between the '(' and ')' of FUNCTION.
-      i.e. FUNCTION( | arg | ) where '|' represents the possible cursor position.
-    */
-    if (startPos.startLineNumber === endPos.startLineNumber &&
-        startPos.startLineNumber === cursorRow &&
-        cursorColumn > startPos.startColumn &&
-        cursorColumn < endPos.endColumn) {
-        inlineWithFunction = true;
-    }
-    /*
-      Handles the case where our function signature is multiline. That is, if we are
-      anywhere between the '(' and the ')' of some expression that follows the pattern:
-      
-      FUNCTION( |
-        | args |
-      | )
-      
-      where '|' represents the possible cursor position.
-    */
-    const functionWrap = (cursorRow === startPos.startLineNumber && cursorColumn > startPos.startColumn) ||
-        (cursorRow === endPos.startLineNumber && cursorColumn < endPos.endColumn) ||
-        (cursorRow > startPos.startLineNumber && cursorRow < endPos.endLineNumber);
-    if (startPos.startLineNumber !== endPos.startLineNumber) {
-        if (functionWrap) {
-            wrappedWithinFunction = true;
-        }
-    }
-    return [inlineWithFunction, wrappedWithinFunction];
-};
 
 let sqlExprWorker;
 /**
@@ -1151,10 +444,10 @@ function setupMode(defaults) {
     // Use the sql-expression Monarch Json to define the highlighting
     languages.setMonarchTokensProvider(sqlExprDefaults.languageId, sqlExprLanguageSyntax);
     languages.setLanguageConfiguration(sqlExprDefaults.languageId, sqlExprLanguageConfig);
-    const completionProvider = new SqlExprCompletionProvider(sqlExprDefaults);
+    const completionProvider = new SqlExprCompletionProvider(workerAccessor, sqlExprDefaults);
+    languages.registerCompletionItemProvider(sqlExprDefaults.languageId, completionProvider);
     // Creates and registers a Completion Adapter
     // Registers a completion item provider for our custom language
-    languages.registerCompletionItemProvider(sqlExprDefaults.languageId, completionProvider);
     // TODO: Creates and registers a Formatter
     // languages.registerDocumentFormattingEditProvider(
     //   SqlExprDefaults.languageId,