@xano/xanoscript-language-server 11.5.0 → 11.6.1

package/parser/generic/objectAttrReq.js

@@ -1,243 +0,0 @@
-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

@@ -1,412 +0,0 @@
-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");
-    });
-  });
-});