@xano/xanoscript-language-server 11.4.0 → 11.6.0

package/parser/generic/arrayOfObjectAttrReq.spec.js

@@ -1,254 +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.arrayOfObjectAttrReq_test_required = this.RULE(
-    "arrayOfObjectAttrReq_test_required",
-    () => {
-      const name = this.CONSUME(Identifier);
-      this.CONSUME(EqualToken); // "="
-      this.SUBRULE(this.arrayOfObjectAttrReq, { ARGS: [name, ["foo"]] });
-    }
-  );
-
-  this.arrayOfObjectAttrReq_test_optionals = this.RULE(
-    "arrayOfObjectAttrReq_test_optionals",
-    () => {
-      const name = this.CONSUME(Identifier);
-      this.CONSUME(EqualToken); // "="
-      this.SUBRULE(this.arrayOfObjectAttrReq, {
-        ARGS: [name, [], ["foo", "bar"]],
-      });
-    }
-  );
-
-  this.arrayOfObjectAttrReq_test_index = this.RULE(
-    "arrayOfObjectAttrReq_test_index",
-    () => {
-      const parent = this.CONSUME(Identifier);
-      this.CONSUME(EqualToken); // "="
-      this.SUBRULE(this.arrayOfObjectAttrReq, {
-        ARGS: [
-          parent,
-          ["type", "field"],
-          [],
-          {
-            types: {
-              type: "string",
-            },
-          },
-        ],
-      });
-    }
-  );
-
-  this.arrayOfObjectAttrReq_test_recursive_value = this.RULE(
-    "test_recursive_value",
-    () => {
-      const name = this.CONSUME(Identifier);
-      this.CONSUME(EqualToken); // "="
-      this.SUBRULE(this.arrayOfObjectAttrReq, {
-        ARGS: [
-          name,
-          ["name", "as", "input"],
-          ["addon"],
-          { recursive: ["addon"] },
-        ],
-      });
-    }
-  );
-  this.arrayOfObjectAttrReq_test_recursive_array_addon = this.RULE(
-    "test_recursive_array_addon",
-    () => {
-      const name = this.CONSUME(Identifier);
-      this.CONSUME(EqualToken); // "="
-      this.SUBRULE(this.arrayOfObjectAttrReq, {
-        ARGS: [
-          name,
-          ["name", "as", "input"],
-          ["addon"],
-          { recursiveArray: ["addon"] },
-        ],
-      });
-    }
-  );
-}
-
-function parse(inputText) {
-  parser.reset();
-  const lexResult = lexDocument(inputText);
-  parser.input = lexResult.tokens;
-  return parser;
-}
-
-describe("arrayOfObjectAttrReq", () => {
-  it("arrayOfObjectAttrReq accepts required attribute", () => {
-    parse(`something = [ {foo: "true"}]`).arrayOfObjectAttrReq_test_required();
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("arrayOfObjectAttrReq accepts multilines attributes", () => {
-    parse(`something = [ 
-      {
-        foo: true
-        bar: 12
-      }
-    ]`).arrayOfObjectAttrReq_test_optionals();
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("arrayOfObjectAttrReq accepts list of single lines", () => {
-    parse(`something = [ 
-      {foo: true, bar: 12}
-    ]`).arrayOfObjectAttrReq_test_optionals();
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("arrayOfObjectAttrReq accepts multiple values", () => {
-    parse(`something = [ 
-      {
-        foo: true
-      }
-      {
-        bar: 12
-      }
-    ]`).arrayOfObjectAttrReq_test_optionals();
-    expect(parser.errors).to.be.empty;
-
-    parse(
-      `something = [{ foo: true }, {bar: 12}]`
-    ).arrayOfObjectAttrReq_test_optionals();
-  });
-
-  it("arrayOfObjectAttrReq detects missing required attribute", () => {
-    parse(`something = [ {}]`).arrayOfObjectAttrReq_test_required();
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("arrayOfObjectAttrReq allow for recursive definition", () => {
-    parse(`addon = [
-      {
-        name : "client"
-        as   : "_client"
-        input: {client_id: ""}
-        addon: {
-          name : "client"
-          as   : "_client"
-          input: {client_id: ""}
-          addon: {
-            name : "client"
-            as   : "_client"
-            input: {client_id: ""}
-          }
-        }
-      }
-    ]`).arrayOfObjectAttrReq_test_recursive_value();
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("arrayOfObjectAttrReq detects missing definition on recursive attributes", () => {
-    parse(`addon = [
-      {
-        name : "client"
-        as   : "_client"
-        input: {client_id: ""}
-        addon: {
-          name : "client"
-          input: {client_id: ""}
-        }
-      }
-    ]`).arrayOfObjectAttrReq_test_recursive_value();
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("arrayOfObjectAttrReq allow for recursive array", () => {
-    parse(`addon = [
-      {
-        name : "client"
-        as   : "_client"
-        input: {client_id: ""}
-        addon: [
-          {
-            name : "client"
-            as   : "_client"
-            input: {client_id: ""}
-            addon: [
-              {
-                name : "client"
-                as   : "_client"
-                input: {client_id: ""}
-                addon: []
-              }
-            ]
-          }
-        ]
-      }
-    ]`).arrayOfObjectAttrReq_test_recursive_array_addon();
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("arrayOfObjectAttrReq detects missing definition on recursive array", () => {
-    parse(`addon = [
-      {
-        name : "client"
-        as   : "_client"
-        input: {client_id: ""}
-        addon: [
-          {
-            name : "client"
-            input: {client_id: ""}
-          }
-        ]
-      }
-    ]`).arrayOfObjectAttrReq_test_recursive_array_addon();
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("arrayOfObjectAttrReq accepts optional attributes", () => {
-    parse(`something = [{}]`).arrayOfObjectAttrReq_test_optionals();
-    expect(parser.errors).to.be.empty;
-
-    parse(`something = [{foo: true}]`).arrayOfObjectAttrReq_test_optionals();
-    expect(parser.errors).to.be.empty;
-
-    parse(`something = [{bar: "ok"}]`).arrayOfObjectAttrReq_test_optionals();
-    expect(parser.errors).to.be.empty;
-
-    parse(
-      `something = [{bar: "ok", "foo": 12.1}]`
-    ).arrayOfObjectAttrReq_test_optionals();
-    expect(parser.errors).to.be.empty;
-
-    parse(`something = [
-      {bar: "ok", "foo": 12.1},
-      {bar: "ok", "foo": 12.1}
-    ]`).arrayOfObjectAttrReq_test_optionals();
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("arrayOfObjectAttrReq can be used for single line index clause", () => {
-    parse(
-      `index = [{type: "primary", field: [{name: "id"}]}]`
-    ).arrayOfObjectAttrReq_test_index();
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("arrayOfObjectAttrReq can be used for index clause", () => {
-    parse(`index = [
-      {type: "primary", field: [{name: "id"}]}
-      {type: "gin", field: [{name: "xdo", op: "jsonb_path_op"}]}
-      {type: "btree", field: [{name: "created_at", op: "desc"}]}
-    ]`).arrayOfObjectAttrReq_test_index();
-    expect(parser.errors).to.be.empty;
-
-    parse(`index = [
-      {type: "primary", field: [{name: "id"}]}
-    ]`).arrayOfObjectAttrReq_test_index();
-    expect(parser.errors).to.be.empty;
-  });
-});

package/parser/generic/arrayOfStringLiterals.js

@@ -1,45 +0,0 @@
-import { CommaToken, LSquare, RSquare } from "../../lexer/control.js";
-import { StringLiteral } from "../../lexer/literal.js";
-import { NewlineToken } from "../../lexer/tokens.js";
-
-/**
- * Dynamicly raises error for missing and required attributes
- * @param {import('../base_parser.js').XanoBaseParser} $
- */
-export function arrayOfStringLiterals($) {
-  return () => {
-    $.CONSUME(LSquare); // "["
-    $.OPTION(() => {
-      $.OR([
-        // multi line, each value on a new line
-        // [
-        //   value
-        //   value2
-        // ]
-        {
-          ALT: () => {
-            $.CONSUME(NewlineToken);
-            $.AT_LEAST_ONE(() => {
-              $.CONSUME(StringLiteral);
-              $.OPTION1(() => $.CONSUME(CommaToken)); // optional comma
-              $.AT_LEAST_ONE1(() => $.CONSUME3(NewlineToken));
-            });
-          },
-        },
-        // one line, comma separated [ value, value2 ]
-        {
-          ALT: () => {
-            $.AT_LEAST_ONE_SEP({
-              SEP: CommaToken,
-              DEF: () => {
-                $.CONSUME1(StringLiteral);
-              },
-            });
-            $.MANY(() => $.CONSUME2(NewlineToken));
-          },
-        },
-      ]);
-    });
-    $.CONSUME(RSquare); // "]"
-  };
-}

package/parser/generic/arrayOfStringLiterals.spec.js

@@ -1,56 +0,0 @@
-import { expect } from "chai";
-import { describe, it } from "mocha";
-import { lexDocument } from "../../lexer/lexer.js";
-import { parser } from "../test_parser.js";
-
-function parse(inputText) {
-  parser.reset();
-  const lexResult = lexDocument(inputText);
-  parser.input = lexResult.tokens;
-  parser.arrayOfStringLiterals();
-  return parser;
-}
-
-describe("arrayOfStringLiterals", () => {
-  it("arrayOfStringLiterals accepts a single string ", () => {
-    const parser = parse(`[ "true" ]`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("arrayOfStringLiterals can be empty ", () => {
-    const parser = parse(`[]`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("arrayOfStringLiterals can be multilines without trailing commas", () => {
-    const parser = parse(`[
-      "foo"
-      "bar"
-    ]`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("arrayOfStringLiterals can be multilines with trailing commas ", () => {
-    const parser = parse(`[
-      "foo",
-      "bar"
-    ]`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("arrayOfStringLiterals can be compact ", () => {
-    const parser = parse(`["foo","bar"]`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("arrayOfStringLiterals cannot contain a non string ", () => {
-    let parser = parse(`[4]`);
-    expect(parser.errors).to.not.be.empty;
-
-    parser = parse(`[true]`);
-    expect(parser.errors).to.not.be.empty;
-
-    parser = parse(`["test", 4]`);
-    expect(parser.errors).to.not.be.empty;
-  });
-});

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);
-    }
-  };
-}