@xano/xanoscript-language-server 11.0.3

package/parser/functions/schema/schemaFn.js

@@ -0,0 +1,173 @@
+import { isArray } from "lodash-es";
+import { schemaExpectArray } from "./schemaParseArrayFn.js";
+import { schemaExpectConstant } from "./schemaParseConstantFn.js";
+import { schemaExpectEnum } from "./schemaParseEnum.js";
+import { schemaExpectObject } from "./schemaParseObjectFn.js";
+import { schemaExpectOneOf } from "./utils.js";
+
+const getErrorMessageForSchema = (schema) => {
+  if (
+    schemaExpectOneOf(schema, [
+      "string",
+      "number",
+      "boolean",
+      "timestamp",
+      "null",
+    ])
+  ) {
+    if (isArray(schema)) {
+      return `Expected one of the following types:  ${schema.join(", ")}`;
+    } else {
+      return `Expected a ${schema}`;
+    }
+  } else if (schemaExpectConstant(schema)) {
+    if (isArray(schema)) {
+      return `Expected one of the following constants: ${schema.join(", ")}`;
+    } else {
+      return `Expected a ${schema}`;
+    }
+  } else if (schemaExpectArray(schema)) {
+    return `Expected an array of ${schema[0]}`;
+  } else if (schemaExpectObject(schema)) {
+    return `Expected an object {}`;
+  } else if (schemaExpectEnum(schema)) {
+    return `Expected one of the following enum values: ${schema.join(", ")}`;
+  } else if (schemaExpectOneOf(schema, ["mock"])) {
+    return `Expected a mock`;
+  } else if (schemaExpectOneOf(schema, ["expression"])) {
+    return `Expected an expression`;
+  } else if (schemaExpectOneOf(schema, ["query"])) {
+    return `Expected a database query expression`;
+  } else if (schemaExpectOneOf(schema, ["constant"])) {
+    return `Expected a value expression (no variables allowed)`;
+  } else if (schemaExpectOneOf(schema, ["stack"])) {
+    return `Expected a stack definition`;
+  } else {
+    return `Invalid schema: received ${JSON.stringify(schema)}`;
+  }
+};
+
+/**
+ * Parses input based on a schema definition
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export function schemaFn($) {
+  return (token, schema, captured = {}, options) => {
+    $.sectionStack.push("schema");
+
+    $.OR({
+      IGNORE_AMBIGUITIES: true,
+      ERR_MSG: getErrorMessageForSchema(schema),
+      DEF: [
+        {
+          GATE: () =>
+            schemaExpectOneOf(
+              schema,
+              ["string", "number", "boolean", "timestamp"],
+              captured
+            ),
+          ALT: () => {
+            $.SUBRULE($.schemaParseImmutableFn, {
+              ARGS: [token, schema, captured],
+            });
+            return true;
+          },
+        },
+        {
+          GATE: () => schemaExpectConstant(schema),
+          ALT: () => {
+            $.SUBRULE($.schemaParseConstantFn, {
+              ARGS: [token, schema, captured],
+            });
+            return true;
+          },
+        },
+        {
+          GATE: () => schemaExpectArray(schema),
+          ALT: () => {
+            $.SUBRULE($.schemaParseArrayFn, {
+              ARGS: [token, schema, captured],
+            });
+            return true;
+          },
+        },
+        {
+          GATE: () => schemaExpectObject(schema),
+          ALT: () => {
+            $.SUBRULE($.schemaParseObjectFn, {
+              ARGS: [token, schema, captured],
+            });
+            return true;
+          },
+        },
+        {
+          GATE: () => schemaExpectEnum(schema),
+          ALT: () => {
+            $.SUBRULE($.schemaParseEnumFn, { ARGS: [token, schema, captured] });
+            return true;
+          },
+        },
+        {
+          // FIXME: this is slowing down parsing significantly
+          // handles "[expression]" and "[query]" types
+          GATE: () =>
+            schemaExpectOneOf(schema, [
+              "expression",
+              "constant",
+              "query",
+              "stack",
+              "test-stack",
+            ]),
+          ALT: () => {
+            $.OR1({
+              IGNORE_AMBIGUITIES: true,
+              DEF: [
+                {
+                  GATE: () =>
+                    schemaExpectOneOf(schema, ["stack", "test-stack"]),
+                  ALT: () => {
+                    const isTest = schemaExpectOneOf(schema, ["test-stack"]);
+                    $.SUBRULE($.nakedStackFn, {
+                      ARGS: [
+                        {
+                          allowExpectStatements: isTest,
+                          allowCallStatements: isTest,
+                        },
+                      ],
+                    });
+                  },
+                },
+                {
+                  GATE: () =>
+                    schemaExpectOneOf(schema, [
+                      "expression",
+                      "query",
+                      "constant",
+                    ]),
+                  ALT: () => {
+                    // a different set of filters is allowed on query expressions
+                    const isQuery = schemaExpectOneOf(schema, ["query"]);
+                    const isValue = schemaExpectOneOf(schema, ["constant"]);
+                    $.SUBRULE($.expressionFn, {
+                      ARGS: [
+                        token,
+                        options || {
+                          allowQueryExpression: isQuery,
+                          allowVariable: !isValue,
+                          allowExpression: !isValue,
+                          allowComparison: !isValue,
+                        },
+                      ],
+                    }); // e.g., $foo.test
+                  },
+                },
+              ],
+            });
+          },
+        },
+      ],
+    });
+
+    $.sectionStack.pop();
+  };
+}

package/parser/functions/schema/schemaFn.spec.js

@@ -0,0 +1,92 @@
+import { expect } from "chai";
+import { describe, it } from "mocha";
+import { EqualToken } from "../../../lexer/control.js";
+import { lexDocument } from "../../../lexer/lexer.js";
+import { Identifier } from "../../../lexer/tokens.js";
+import { parser } from "../../test_parser.js";
+
+export function parserExtension() {
+  // this rule requires a foo field to be defined
+  this.schemaFn_test_immutable = this.RULE("schemaFn_test_immutable", () => {
+    const schema = "[string]";
+    const name = this.CONSUME(Identifier);
+    this.CONSUME(EqualToken); // "="
+    this.SUBRULE(this.schemaFn, { ARGS: [name, schema] });
+  });
+
+  // this rule requires a foo field to be defined
+  this.schemaFn_test_expression = this.RULE("schemaFn_test_expression", () => {
+    const schema = "[expression]";
+    const name = this.CONSUME(Identifier);
+    this.CONSUME(EqualToken); // "="
+    this.SUBRULE(this.schemaFn, { ARGS: [name, schema] });
+  });
+
+  // this rule requires a foo field to be defined
+  this.schemaFn_test_mock = this.RULE("schemaFn_test_mock", () => {
+    const schema = "[mock]";
+    const name = this.CONSUME(Identifier);
+    this.CONSUME(EqualToken); // "="
+    this.SUBRULE(this.schemaFn, { ARGS: [name, schema] });
+  });
+
+  // this rule requires a foo field to be defined
+  this.schemaFn_test_enum = this.RULE("schemaFn_test_enum", () => {
+    const schema = ["yes", 123];
+    const name = this.CONSUME(Identifier);
+    this.CONSUME(EqualToken); // "="
+    this.SUBRULE(this.schemaFn, { ARGS: [name, schema] });
+  });
+}
+
+function parse(inputText) {
+  parser.reset();
+  const lexResult = lexDocument(inputText);
+  parser.input = lexResult.tokens;
+  return parser;
+}
+
+describe("schemaFn", () => {
+  it("schemaFn immutable restrictions", () => {
+    parse(`something = "foo"`).schemaFn_test_immutable();
+    expect(parser.errors).to.be.empty;
+
+    parse(`something = 'bar'`).schemaFn_test_immutable();
+    expect(parser.errors).to.be.empty;
+
+    parse(`something = bar`).schemaFn_test_immutable();
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("schemaFn rejects a bad immutable", () => {
+    parse(`something = true`).schemaFn_test_immutable();
+    expect(parser.errors).to.not.be.empty;
+
+    parse(`something = 123`).schemaFn_test_immutable();
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("schemaFn rejects a bad value", () => {
+    parse(`something = true|something`).schemaFn_test_expression();
+    expect(parser.errors).to.not.be.empty;
+
+    parse(`something = 12 3`).schemaFn_test_expression();
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("schemaFn accepts a value", () => {
+    parse(`something = true|not`).schemaFn_test_expression();
+    expect(parser.errors).to.be.empty;
+
+    parse(`something = [123 + 123]`).schemaFn_test_expression();
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("schemaFn accepts an enum", () => {
+    parse(`something = "yes"`).schemaFn_test_enum();
+    expect(parser.errors).to.be.empty;
+
+    parse(`something = 123`).schemaFn_test_enum();
+    expect(parser.errors).to.be.empty;
+  });
+});

package/parser/functions/schema/schemaParseArrayFn.js

@@ -0,0 +1,47 @@
+import { first } from "lodash-es";
+import { CommaToken, LSquare, RSquare } from "../../../lexer/control.js";
+import { NewlineToken } from "../../../lexer/tokens.js";
+
+/**
+ * @param {import('../../base_parser.js').XanoBaseParser} $
+ */
+export function schemaParseArrayFn($) {
+  return (token, schema, captured = {}, options) => {
+    let needSeparator = false;
+    captured.value = [];
+    $.CONSUME(LSquare); // "["
+    $.MANY1(() => $.CONSUME(NewlineToken));
+    $.MANY(() => {
+      const localCaptured = {};
+      $.SUBRULE($.schemaFn, {
+        ARGS: [token, first(schema), localCaptured, options],
+      });
+      if (needSeparator) {
+        $.addInvalidValueError(
+          "Expected a comma, a new line or closing bracket"
+        );
+      }
+      captured.value.push(localCaptured);
+      needSeparator = true;
+      $.OPTION(() => {
+        needSeparator = false;
+        return $.CONSUME1(CommaToken);
+      });
+      $.MANY2(() => {
+        needSeparator = false;
+        $.CONSUME1(NewlineToken);
+      });
+    });
+    $.CONSUME(RSquare); // "]"
+  };
+}
+
+/**
+ *
+ * @param {*} attr
+ * @returns
+ */
+export function schemaExpectArray(attr) {
+  if (typeof attr !== "object" || !Array.isArray(attr)) return false;
+  return attr.length == 1;
+}

package/parser/functions/schema/schemaParseArrayFn.spec.js

@@ -0,0 +1,134 @@
+import { expect } from "chai";
+import { describe, it } from "mocha";
+import { EqualToken } from "../../../lexer/control.js";
+import { lexDocument } from "../../../lexer/lexer.js";
+import { Identifier } from "../../../lexer/tokens.js";
+import { parser } from "../../test_parser.js";
+
+export function parserExtension() {
+  // this rule requires a foo field to be defined
+  this.schemaParseArrayFn_string_arr = this.RULE(
+    "schemaParseArrayFn_string_arr",
+    () => {
+      const schema = ["[string]"];
+      const name = this.CONSUME(Identifier);
+      this.CONSUME(EqualToken); // "="
+      this.SUBRULE(this.schemaParseArrayFn, { ARGS: [name, schema] });
+    }
+  );
+
+  // this rule requires a foo field to be defined
+  this.schemaParseArrayFn_string_arr_of_arr = this.RULE(
+    "schemaParseArrayFn_string_arr_of_arr",
+    () => {
+      const schema = [["[string]"]];
+      const name = this.CONSUME(Identifier);
+      this.CONSUME(EqualToken); // "="
+      this.SUBRULE(this.schemaParseArrayFn, { ARGS: [name, schema] });
+    }
+  );
+
+  // this rule requires a foo field to be defined
+  this.schemaParseArrayFn_number_arr = this.RULE(
+    "schemaParseArrayFn_number_arr",
+    () => {
+      const schema = ["[number]"];
+      const name = this.CONSUME(Identifier);
+      this.CONSUME(EqualToken); // "="
+      this.SUBRULE(this.schemaParseArrayFn, { ARGS: [name, schema] });
+    }
+  );
+
+  // this rule requires a foo field to be defined
+  this.schemaParseArrayFn_expression_arr = this.RULE(
+    "schemaParseArrayFn_expression_arr",
+    () => {
+      const schema = ["[expression]"];
+      const name = this.CONSUME(Identifier);
+      this.CONSUME(EqualToken); // "="
+      this.SUBRULE(this.schemaParseArrayFn, { ARGS: [name, schema] });
+    }
+  );
+}
+
+function parse(inputText) {
+  parser.reset();
+  const lexResult = lexDocument(inputText);
+  parser.input = lexResult.tokens;
+  return parser;
+}
+
+describe("schemaParseArrayFn", () => {
+  it("schemaParseArrayFn accepts an array of strings", () => {
+    parse(`something = ["test", 'bar']`).schemaParseArrayFn_string_arr();
+    expect(parser.errors).to.be.empty;
+
+    parse(`something = [
+      """
+        and
+        test
+      """
+      'bar'
+    ]`).schemaParseArrayFn_string_arr();
+    expect(parser.errors).to.be.empty;
+
+    parse(`something = []`).schemaParseArrayFn_number_arr();
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("schemaParseArrayFn rejects invalid types ", () => {
+    parse(`something = [false]`).schemaParseArrayFn_string_arr();
+    expect(parser.errors).to.not.be.empty;
+
+    parse(`something = [123]`).schemaParseArrayFn_string_arr();
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("schemaParseArrayFn rejects invalid format ", () => {
+    parse(`something = [123 321]`).schemaParseArrayFn_number_arr();
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("schemaParseArrayFn accept valid number array", () => {
+    parse(`something = [
+      123, 
+      321
+    ]`).schemaParseArrayFn_number_arr();
+    expect(parser.errors).to.be.empty;
+
+    parse(`something = [1,
+      2, 
+      3,
+    ]`).schemaParseArrayFn_number_arr();
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("schemaParseArrayFn rejects bad types", () => {
+    parse(`something = [true]`).schemaParseArrayFn_number_arr();
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("schemaParseArrayFn accepts an array of array of strings", () => {
+    parse(
+      `something = [["test", 'bar'], ["foo"]]`
+    ).schemaParseArrayFn_string_arr_of_arr();
+    expect(parser.errors).to.be.empty;
+
+    parse(`something = [
+      ['test', "bar"], 
+      ["foo"]
+    ]`).schemaParseArrayFn_string_arr_of_arr();
+    expect(parser.errors).to.be.empty;
+
+    parse(`something = []`).schemaParseArrayFn_string_arr_of_arr();
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("schemaParseArrayFn accepts an array of expressions", () => {
+    parse(`something = [1,
+      $var.test
+      $input.value + 2,
+    ]`).schemaParseArrayFn_expression_arr();
+    expect(parser.errors).to.be.empty;
+  });
+});

package/parser/functions/schema/schemaParseAttributeFn.js

@@ -0,0 +1,194 @@
+import { get, isPlainObject, keys, some } from "lodash-es";
+import { ExclamationToken } from "../../../lexer/cast.js";
+import {
+  CommaToken,
+  EqualToken,
+  LCurly,
+  RCurly,
+} from "../../../lexer/control.js";
+import { StringLiteral } from "../../../lexer/literal.js";
+import { Identifier, NewlineToken } from "../../../lexer/tokens.js";
+import {
+  canBeDisabledAttribute,
+  isMultiAttribute,
+  isOptionalAttribute,
+  isSchemaGenericType,
+  valueMatchRequirements,
+} from "./utils.js";
+
+export function schemaParseAttributeFn($) {
+  $.requireRules(_schemaParseAttributeFn);
+
+  return (token, schema, captured = {}) => {
+    // attribute can be fully ignored when all the keys are optional
+    const isAllOptional = keys(schema).every((k) => isOptionalAttribute(k));
+
+    $.OR([
+      {
+        GATE: () => isAllOptional,
+        ALT: () => {
+          $.OPTION(() =>
+            $.SUBRULE($._schemaParseAttributeFn, {
+              ARGS: [token, schema, captured],
+            })
+          );
+        },
+      },
+      {
+        GATE: () => !isAllOptional,
+        ALT: () =>
+          $.SUBRULE1($._schemaParseAttributeFn, {
+            ARGS: [token, schema, captured],
+          }),
+      },
+    ]);
+  };
+}
+
+/**
+ * Similar to schemaParseObjectFn but for attributes (uses = instead of :)
+ * captured object will contain the tokens of the captured keys on the object
+ * allowing for better error messages later on
+ * @param {import('../../base_parser.js').XanoBaseParser} $
+ */
+function _schemaParseAttributeFn($) {
+  return (token, schema, captured = {}) => {
+    let needSeparator = false;
+    let lastToken = null;
+
+    // grab all the keys, they contain the schema for the keys
+    const objectKeys = keys(schema);
+    const missingKeys = [...objectKeys];
+    const attrNames = [];
+
+    // you cannot have a generic mixed with another generic
+    $.ACTION(() => {
+      if (
+        objectKeys.length > 1 &&
+        some(objectKeys, (k) => isSchemaGenericType(k))
+      ) {
+        throw new Error(
+          "schemaParseAttributeFn supports only one generic type when multiple keys are defined"
+        );
+      }
+    });
+
+    $.CONSUME(LCurly); // "{"
+    $.MANY(() => {
+      $.MANY1(() => {
+        needSeparator = false;
+        $.CONSUME(NewlineToken);
+      });
+
+      if (needSeparator) {
+        $.addInvalidValueError(
+          lastToken,
+          "Expected a comma, a new line or closing bracket"
+        );
+      }
+
+      const disabledToken = $.OPTION1(() => $.CONSUME(ExclamationToken)); // "!"
+
+      // first we capture the key
+      let objectKeyToken;
+      const keyValue = $.OR([
+        {
+          ALT: () => {
+            objectKeyToken = $.CONSUME1(Identifier);
+            return objectKeyToken.image;
+          },
+        },
+        {
+          ALT: () => {
+            const objectKeyToken = $.CONSUME1(StringLiteral);
+            return objectKeyToken.image.slice(1, -1);
+          },
+        },
+      ]);
+
+      const subSchemaKey = valueMatchRequirements(keyValue, objectKeys);
+      if (!subSchemaKey) {
+        $.addInvalidValueError(
+          objectKeyToken,
+          `The argument '${keyValue}' is not valid in this context`
+        );
+      } else if (disabledToken && !canBeDisabledAttribute(subSchemaKey)) {
+        $.addInvalidValueError(
+          disabledToken,
+          `The argument '${keyValue}' cannot be disabled`
+        );
+      }
+
+      if (attrNames.includes(keyValue) && !isMultiAttribute(subSchemaKey)) {
+        $.addInvalidValueError(
+          objectKeyToken,
+          `Duplicate argument '${keyValue}' found`
+        );
+      } else {
+        attrNames.push(keyValue);
+        captured[keyValue] = { key: objectKeyToken, value: null };
+      }
+
+      // remove from missing keys
+      missingKeys.splice(missingKeys.indexOf(subSchemaKey), 1);
+
+      const subSchema = get(schema, subSchemaKey, null);
+
+      const isStack = ["[stack]", "[test-stack]"].includes(subSchema);
+      $.OR1([
+        {
+          GATE: () => !isStack,
+          ALT: () => $.CONSUME(EqualToken), // "="
+        },
+        {
+          GATE: () => isStack,
+          ALT: () => false,
+        },
+      ]);
+
+      $.SUBRULE($.schemaFn, {
+        ARGS: [objectKeyToken, subSchema, captured[keyValue]],
+      });
+
+      needSeparator = true;
+      $.MANY2(() => {
+        needSeparator = false;
+        $.CONSUME1(NewlineToken);
+      });
+
+      $.OPTION(() => {
+        needSeparator = false;
+        $.CONSUME1(CommaToken);
+      });
+    });
+    $.CONSUME(RCurly); // "}"
+
+    if (missingKeys.length) {
+      const missingKeyNames = missingKeys.filter(
+        (k) => !isOptionalAttribute(k)
+      );
+      if (missingKeyNames.length > 1) {
+        $.addInvalidValueError(
+          lastToken || token,
+          `The following required arguments are missing: ${missingKeyNames.join(
+            ", "
+          )}`
+        );
+      } else if (missingKeyNames.length === 1) {
+        $.addInvalidValueError(
+          lastToken || token,
+          `Missing required argument '${missingKeyNames[0]}'`
+        );
+      }
+    }
+  };
+}
+
+/**
+ *
+ * @param {*} attr
+ * @returns
+ */
+export function schemaExpectObject(attr) {
+  return isPlainObject(attr);
+}