@xano/xanoscript-language-server 11.0.3

package/parser/generic/objectAttrReq.js

@@ -0,0 +1,243 @@
+import { MismatchedTokenException } from "chevrotain";
+import { ColonToken, CommaToken, LCurly, RCurly } from "../../lexer/control.js";
+import { StringLiteral } from "../../lexer/literal.js";
+import { MultiLineStringToken } from "../../lexer/multiline.js";
+import { Identifier, NewlineToken } from "../../lexer/tokens.js";
+import { getVarName } from "./utils.js";
+
+const DEFAULT_OPTIONS = {
+  allowDuplicates: [],
+  allowQueryExpression: false,
+  recursive: [],
+  recursiveArray: [],
+  allowVariables: true,
+  types: {},
+};
+
+/**
+ * Dynamicly raises error for missing and required attributes
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export function objectAttrReq($) {
+  /**
+   * @param {import('chevrotain').IToken} parent
+   * @param {string[]} required the required attributes
+   * @param {string[]} optional the optional attributes
+   * @param {Object} options additional options
+   * @param {string[]} options.allowDuplicates attributes that are allowed to be duplicated
+   * @param {string[]} options.allowQueryExpression attributes that are allowed to be duplicated
+   * @param {string[]} options.recursive the same rules applies to sub-objects deeper in the tree
+   * @param {string[]} options.recursiveArray the same rules applies to sub-arrays deeper in the tree
+   * @param {boolean} options.allowVariables whether to allow variables as values
+   * @param {Object} options.types a map of attribute names to their expected types (string, number, boolean)
+   *                                 if the type is not specified, any value is allowed
+   **/
+  return (parent, required, optional, options = {}) => {
+    // setup basic defaults
+    required = required || [];
+    optional = optional || [];
+
+    options = {
+      ...DEFAULT_OPTIONS,
+      ...options,
+    };
+
+    const definedAttributes = [];
+    const allowedAttributes = [...required, ...optional];
+    let identifier;
+
+    $.CONSUME(LCurly); // "{"
+    $.OPTION(() => {
+      $.OR([
+        {
+          // one line, comma separated { key: value, key2: value2 }
+          ALT: () => {
+            $.AT_LEAST_ONE_SEP({
+              SEP: CommaToken,
+              DEF: () => {
+                identifier = $.OR1([
+                  { ALT: () => $.CONSUME(Identifier) }, // key
+                  { ALT: () => $.CONSUME(StringLiteral) }, // "value"
+                ]);
+                definedAttributes.push(identifier);
+                const varName = getVarName(identifier);
+                $.CONSUME(ColonToken);
+                if (options.recursive.includes(varName)) {
+                  $.SUBRULE($.objectAttrReq, {
+                    ARGS: [identifier, required, optional, options],
+                  });
+                } else if (options.recursiveArray.includes(varName)) {
+                  $.SUBRULE($.arrayOfObjectAttrReq, {
+                    ARGS: [identifier, required, optional, options],
+                  });
+                } else {
+                  const varType = options.types[varName];
+                  if (typeof varType === "function") {
+                    varType.call(null, $, identifier); // custom function handler
+                  } else if (Array.isArray(varType)) {
+                    // Treat array as enum - value must be one of the array elements
+                    const stringToken = $.CONSUME3(StringLiteral);
+                    const providedValue = getVarName(stringToken);
+
+                    // Check if the provided value is in the allowed array
+                    if (!varType.includes(providedValue)) {
+                      $.addMissingError(
+                        stringToken,
+                        `Invalid value "${providedValue}". Must be one of: ${varType
+                          .map((v) => `"${v}"`)
+                          .join(", ")}`
+                      );
+                    }
+                  } else {
+                    $.OR4([
+                      {
+                        GATE: () => varType === "boolean",
+                        ALT: () => $.SUBRULE($.booleanValue), // boolean
+                      },
+                      {
+                        GATE: () => varType === "number",
+                        ALT: () => $.SUBRULE($.numberValue), // number
+                      },
+                      {
+                        GATE: () => varType === "string",
+                        ALT: () => $.CONSUME3(StringLiteral), // "..."
+                      },
+                      {
+                        GATE: () => varType === "object",
+                        ALT: () =>
+                          $.SUBRULE1($.objectWithAttributes, {
+                            ARGS: [options],
+                          }),
+                      },
+                      {
+                        GATE: () => !varType,
+                        ALT: () =>
+                          $.SUBRULE($.expressionFn, {
+                            ARGS: [identifier, options],
+                          }), // anything goes
+                      },
+                    ]);
+                  }
+                }
+              },
+            });
+          },
+        },
+        {
+          // multi line, each key value pair on a new line
+          // {
+          //   key: value
+          //   key2: value2
+          // }
+          ALT: () => {
+            $.CONSUME(NewlineToken);
+            $.AT_LEAST_ONE(() => {
+              const identifier = $.OR2([
+                { ALT: () => $.CONSUME2(Identifier) }, // key
+                { ALT: () => $.CONSUME2(StringLiteral) }, // "other key"
+              ]);
+              definedAttributes.push(identifier);
+              $.CONSUME1(ColonToken);
+              const varName = getVarName(identifier);
+              if (options.recursive.includes(varName)) {
+                $.SUBRULE($.objectAttrReq, {
+                  ARGS: [identifier, required, optional, options],
+                });
+              } else if (options.recursiveArray.includes(varName)) {
+                $.SUBRULE($.arrayOfObjectAttrReq, {
+                  ARGS: [identifier, required, optional, options],
+                });
+              } else {
+                const varType = options.types[varName];
+                if (typeof varType === "function") {
+                  varType.call(null, $, identifier); // custom function handler
+                } else if (Array.isArray(varType)) {
+                  // Treat array as enum - value must be one of the array elements
+                  const stringToken = $.CONSUME3(StringLiteral);
+                  const providedValue = getVarName(stringToken);
+
+                  // Check if the provided value is in the allowed array
+                  if (!varType.includes(providedValue)) {
+                    $.SAVE_ERROR(
+                      new MismatchedTokenException(
+                        `Invalid value "${providedValue}". Must be one of: ${varType
+                          .map((v) => `"${v}"`)
+                          .join(", ")}`,
+                        stringToken,
+                        stringToken
+                      )
+                    );
+                  }
+                } else {
+                  $.OR3([
+                    {
+                      GATE: () => varType === "boolean",
+                      ALT: () => $.SUBRULE1($.booleanValue), // boolean
+                    },
+                    {
+                      GATE: () => varType === "number",
+                      ALT: () => $.SUBRULE1($.numberValue), // number
+                    },
+                    {
+                      GATE: () => varType === "string",
+                      ALT: () =>
+                        $.OR5([
+                          { ALT: () => $.CONSUME1(StringLiteral) }, // "..."
+                          { ALT: () => $.CONSUME(MultiLineStringToken) },
+                        ]),
+                    },
+                    {
+                      GATE: () => varType === "object",
+                      ALT: () =>
+                        $.SUBRULE($.objectWithAttributes, { ARGS: [options] }),
+                    },
+                    {
+                      GATE: () => !varType,
+                      ALT: () =>
+                        $.SUBRULE1($.expressionFn, {
+                          ARGS: [identifier, options],
+                        }), // anything goes
+                    },
+                  ]);
+                }
+              }
+              $.OPTION1(() => $.CONSUME(CommaToken)); // ","
+              $.AT_LEAST_ONE1(() => $.CONSUME1(NewlineToken));
+            });
+          },
+        },
+      ]);
+    });
+    $.CONSUME(RCurly); // "}"
+
+    // detects duplicate attributes
+    const duplicateAttributes = definedAttributes.filter(
+      (token, index) =>
+        !options.allowDuplicates.includes(getVarName(token)) &&
+        definedAttributes.findIndex(
+          (t) => getVarName(t) === getVarName(token)
+        ) !== index
+    );
+
+    for (const token of duplicateAttributes) {
+      $.addDuplicateAttributeError(token);
+    }
+
+    // report any illegal attributes
+    const illegalAttributes = definedAttributes.filter(
+      (token) => !allowedAttributes.includes(getVarName(token))
+    );
+    for (const token of illegalAttributes) {
+      $.addIllegalAttributeError(token);
+    }
+
+    // report any missing attributes
+    const definedAttrNames = definedAttributes.map(getVarName);
+    const missingAttributes = required.filter(
+      (reqAttrName) => !definedAttrNames.includes(reqAttrName)
+    );
+    if (missingAttributes.length > 0) {
+      $.addMissingAttributeError(parent, missingAttributes);
+    }
+  };
+}

package/parser/generic/objectAttrReq.spec.js

@@ -0,0 +1,412 @@
+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.objectAttrReq_test_required = this.RULE(
+    "objectAttrReq_test_required",
+    () => {
+      const name = this.CONSUME(Identifier);
+      this.CONSUME(EqualToken); // "="
+      this.SUBRULE(this.objectAttrReq, { ARGS: [name, ["foo"]] });
+    }
+  );
+
+  // this rule has no required fields and two optional fields
+  this.objectAttrReq_test_optionals = this.RULE(
+    "objectAttrReq_test_optionals",
+    () => {
+      const name = this.CONSUME(Identifier);
+      this.CONSUME(EqualToken); // "="
+      this.SUBRULE(this.objectAttrReq, { ARGS: [name, [], ["foo", "bar"]] });
+    }
+  );
+
+  // this rule has one required and one optional field
+  this.objectAttrReq_test_optional_and_required = this.RULE(
+    "objectAttrReq_test_optional_and_required",
+    () => {
+      const name = this.CONSUME(Identifier);
+      this.CONSUME(EqualToken); // "="
+      this.SUBRULE(this.objectAttrReq, {
+        ARGS: [name, ["required"], ["option"]],
+      });
+    }
+  );
+
+  // this rule has one required and one optional field
+  this.objectAttrReq_test_type_req = this.RULE(
+    "objectAttrReq_test_type_req",
+    () => {
+      const name = this.CONSUME(Identifier);
+      this.CONSUME(EqualToken); // "="
+      this.SUBRULE(this.objectAttrReq, {
+        ARGS: [
+          name,
+          [],
+          ["bool", "string", "integer", "decimal", "number", "func"],
+          {
+            types: {
+              bool: "boolean",
+              string: "string",
+              integer: "integer",
+              decimal: "decimal",
+              number: "number",
+              func: ($, identifier) => {
+                $.SUBRULE(this.objectAttrReq, {
+                  ARGS: [
+                    identifier,
+                    ["test"],
+                    [],
+                    {
+                      types: {
+                        test: "string",
+                      },
+                    },
+                  ],
+                });
+              },
+            },
+          },
+        ],
+      });
+    }
+  );
+
+  // this rule tests array types as enums
+  this.objectAttrReq_test_enum_req = this.RULE(
+    "objectAttrReq_test_enum_req",
+    () => {
+      const name = this.CONSUME(Identifier);
+      this.CONSUME(EqualToken); // "="
+      this.SUBRULE(this.objectAttrReq, {
+        ARGS: [
+          name,
+          [],
+          ["status"],
+          {
+            types: {
+              status: ["active", "pending", "inactive"], // array treated as enum
+            },
+          },
+        ],
+      });
+    }
+  );
+
+  // this rule allows duplicates for the "arg" field
+  this.objectAttrReq_test_allow_duplicates = this.RULE(
+    "objectAttrReq_test_allow_duplicates",
+    () => {
+      const name = this.CONSUME(Identifier);
+      this.CONSUME(EqualToken); // "="
+      this.SUBRULE(this.objectAttrReq, {
+        ARGS: [name, [], ["arg"], { allowDuplicates: ["arg"] }],
+      });
+    }
+  );
+
+  this.objectAttrReq_test_allow_array_object = this.RULE(
+    "objectAttrReq_test_allow_array_object",
+    () => {
+      const name = this.CONSUME(Identifier);
+      this.CONSUME(EqualToken); // "="
+      this.SUBRULE(this.objectAttrReq, {
+        ARGS: [name, [], ["arr", "obj"]],
+      });
+    }
+  );
+
+  this.objectAttrReq_test_obj_in_arr_in_obj = this.RULE(
+    "objectAttrReq_test_obj_in_arr_in_obj",
+    () => {
+      const name = this.CONSUME(Identifier);
+      this.CONSUME(EqualToken); // "="
+      this.SUBRULE(this.objectAttrReq, {
+        ARGS: [name, [], ["type", "field"]],
+      });
+    }
+  );
+
+  this.objectAttrReq_test_allow_multiple_format = this.RULE(
+    "objectAttrReq_test_allow_multiple_format",
+    () => {
+      const name = this.CONSUME(Identifier);
+      this.CONSUME(EqualToken); // "="
+      this.SUBRULE(this.objectAttrReq, {
+        ARGS: [name, [], ["singleline", "multiline"]],
+      });
+    }
+  );
+}
+
+function parse(inputText) {
+  parser.reset();
+  const lexResult = lexDocument(inputText);
+  parser.input = lexResult.tokens;
+  return parser;
+}
+
+describe("objectAttrReq", () => {
+  it("objectAttrReq matched requirements", () => {
+    parse(`something = { 
+      foo: "bar" 
+    }`).objectAttrReq_test_required();
+
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("objectAttrReq discover missing requirements", () => {
+    parse(`something = { 
+      foot: "bar" 
+    }`).objectAttrReq_test_required();
+
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("objectAttrReq discover optional requirements", () => {
+    // should allow one optional requirement
+    parse(`something = { 
+      foo: "bar" 
+    }`).objectAttrReq_test_optionals();
+
+    expect(parser.errors).to.be.empty;
+
+    // should allow one optional requirement
+    parse(`something = { 
+      bar: "foo" 
+    }`).objectAttrReq_test_optionals();
+
+    expect(parser.errors).to.be.empty;
+
+    // should allow all optional requirements
+    parse(`something = { 
+      bar: "foo" 
+      foo: "bar" 
+    }`).objectAttrReq_test_optionals();
+
+    expect(parser.errors).to.be.empty;
+
+    // should allow no optional requirements defined
+    parse(`something = {}`).objectAttrReq_test_optionals();
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("objectAttrReq allows object fields", () => {
+    parse(`something = { 
+      obj: { foo: "bar" }
+    }`).objectAttrReq_test_allow_array_object();
+
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("objectAttrReq allows single line object ", () => {
+    parse(`something = { obj: "bar" }`).objectAttrReq_test_allow_array_object();
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("objectAttrReq key can be a string", () => {
+    parse(`something = { 
+      "obj": "bar" 
+    }`).objectAttrReq_test_allow_array_object();
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("objectAttrReq accepts optional commas", () => {
+    parse(
+      `something = { obj: "bar", "arr": "bar" }`
+    ).objectAttrReq_test_allow_array_object();
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("objectAttrReq allows array fields", () => {
+    parse(`something = { 
+      arr: [1,2, 3]
+    }`).objectAttrReq_test_allow_array_object();
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("objectAttrReq allows obj in array in obj", () => {
+    parse(
+      `x = {type: "primary", field: [{name: "id"}]}`
+    ).objectAttrReq_test_obj_in_arr_in_obj();
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("objectAttrReq allows array fields", () => {
+    parse(`something = { 
+      arr: [1,2, 3]
+      obj: { foo: "bar", bar: "foo" }
+    }`).objectAttrReq_test_allow_array_object();
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("objectAttrReq allows a mix of single and multiline values", () => {
+    parse(`something = { 
+      multiline: {
+        foo: "bar"
+        bar: "foo"
+      }
+      singleline: { foo: "bar", bar: "foo" }
+    }`).objectAttrReq_test_allow_multiple_format();
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("objectAttrReq allows specific duplicates", () => {
+    // foo is defined twice
+    parse(`something = { 
+      arg: "fizz" 
+      arg: "buzz" 
+    }`).objectAttrReq_test_allow_duplicates();
+
+    expect(parser.errors).to.be.empty;
+
+    // foo is defined twice
+    parse(`something = { 
+      arg: "fizz" 
+      arg: "buzz" 
+      foo: "bar"
+      foo: "baz"
+    }`).objectAttrReq_test_allow_duplicates();
+
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("objectAttrReq detects duplicates", () => {
+    // foo is defined twice
+    parse(`something = { 
+      foo: "fizz" 
+      foo: "buzz" 
+    }`).objectAttrReq_test_required();
+
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("objectAttrReq detects string literal duplicates", () => {
+    // foo is defined twice
+    parse(`something = { 
+      "foo": "fizz" 
+      foo: "buzz" 
+    }`).objectAttrReq_test_required();
+
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("objectAttrReq enforces optional requirements", () => {
+    // foot is not an optional requirement
+    parse(`something = { 
+      foot = "bar" 
+    }`).objectAttrReq_test_optionals();
+
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("objectAttrReq enforces optional and required fields", () => {
+    // all optional and required fields are present
+    parse(`something = {
+      option: "bar"
+      required: "bar"
+    }`).objectAttrReq_test_optional_and_required();
+    expect(parser.errors).to.be.empty;
+
+    // optional field is missing (all good)
+    parse(`something = {
+      required: "bar"
+    }`).objectAttrReq_test_optional_and_required();
+
+    expect(parser.errors).to.be.empty;
+
+    // required field is missing (not good)
+    parse(`something = { 
+      option: "bar" 
+    }`).objectAttrReq_test_optional_and_required();
+
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  describe("objectAttrReq types", () => {
+    it("enforces string types when provided", () => {
+      parse(`typed = { 
+        string: "4"
+      }`).objectAttrReq_test_type_req();
+
+      expect(parser.errors).to.be.empty;
+
+      parse(`typed = { 
+        string: 4
+      }`).objectAttrReq_test_type_req();
+
+      expect(parser.errors).to.not.be.empty;
+    });
+
+    it("enforces boolean types when provided", () => {
+      parse(`typed = { 
+        bool: true
+      }`).objectAttrReq_test_type_req();
+
+      expect(parser.errors).to.be.empty;
+
+      parse(`typed = { 
+        bool: 4
+      }`).objectAttrReq_test_type_req();
+
+      expect(parser.errors).to.not.be.empty;
+    });
+
+    it("enforces number types when provided", () => {
+      parse(`typed = { 
+        number: 4
+      }`).objectAttrReq_test_type_req();
+
+      expect(parser.errors).to.be.empty;
+
+      parse(`typed = { 
+        number: 0.5
+      }`).objectAttrReq_test_type_req();
+
+      expect(parser.errors).to.be.empty;
+
+      parse(`typed = { 
+        number: "4"
+      }`).objectAttrReq_test_type_req();
+
+      expect(parser.errors).to.not.be.empty;
+    });
+
+    it("enforces function types when provided", () => {
+      parse(`typed = {
+        func: { test: "1" }
+      }`).objectAttrReq_test_type_req();
+
+      expect(parser.errors).to.be.empty;
+    });
+
+    it("enforces array types as enums when provided", () => {
+      // Valid enum value
+      parse(`typed = {
+        status: "active"
+      }`).objectAttrReq_test_enum_req();
+
+      expect(parser.errors).to.be.empty;
+
+      // Another valid enum value
+      parse(`typed = {
+        status: "pending"
+      }`).objectAttrReq_test_enum_req();
+
+      expect(parser.errors).to.be.empty;
+
+      // Invalid enum value
+      parse(`typed = {
+        status: "invalid"
+      }`).objectAttrReq_test_enum_req();
+
+      expect(parser.errors).to.not.be.empty;
+      expect(parser.errors[0].message).to.include("Must be one of");
+    });
+  });
+});