@xano/xanoscript-language-server 11.0.3

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

@@ -0,0 +1,281 @@
+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.schemaParseAttributeFn_flat = this.RULE(
+    "schemaParseAttributeFn_flat",
+    () => {
+      const schema = { "[string]": "[number]" };
+      const name = this.CONSUME(Identifier);
+      this.CONSUME(EqualToken); // "="
+      this.SUBRULE(this.schemaParseAttributeFn, { ARGS: [name, schema] });
+    }
+  );
+
+  this.schemaParseAttributeFn_expression = this.RULE(
+    "schemaParseAttributeFn_expression",
+    () => {
+      const schema = {
+        value: "[expression]",
+        "description?": "[string]",
+      };
+      const name = this.CONSUME(Identifier);
+      this.SUBRULE(this.schemaParseAttributeFn, { ARGS: [name, schema] });
+    }
+  );
+
+  // this rule requires a foo field to be defined
+  this.schemaParseAttributeFn_all_optional = this.RULE(
+    "schemaParseAttributeFn_all_optional",
+    () => {
+      const schema = { "disabled?": "[boolean]", "description?": "[string]" };
+      const name = this.CONSUME(Identifier);
+      this.SUBRULE(this.schemaParseAttributeFn, { ARGS: [name, schema] });
+    }
+  );
+
+  this.schemaParseAttributeFn_deep = this.RULE(
+    "schemaParseAttributeFn_deep",
+    () => {
+      const schema = {
+        "[string]": {
+          test: ["[number]"],
+          bool: "[boolean]",
+          hey: "some constant",
+        },
+      };
+      const name = this.CONSUME(Identifier);
+      this.CONSUME(EqualToken); // "="
+      this.SUBRULE(this.schemaParseAttributeFn, { ARGS: [name, schema] });
+    }
+  );
+
+  this.schemaParseAttributeFn_stack = this.RULE(
+    "schemaParseAttributeFn_stack",
+    () => {
+      const schema = {
+        stack: "[stack]",
+        test: "[test-stack]",
+        value: "[number]",
+      };
+      const name = this.CONSUME(Identifier);
+      this.SUBRULE(this.schemaParseAttributeFn, { ARGS: [name, schema] });
+    }
+  );
+
+  this.schemaParseAttributeFn_optional = this.RULE(
+    "schemaParseAttributeFn_optional",
+    () => {
+      const schema = {
+        "[string]": {
+          "optional?": "[number]",
+          required: "[boolean]",
+        },
+      };
+      const name = this.CONSUME(Identifier);
+      this.CONSUME(EqualToken); // "="
+      this.SUBRULE(this.schemaParseAttributeFn, { ARGS: [name, schema] });
+    }
+  );
+
+  this.schemaParseAttributeFn_multiple = this.RULE(
+    "schemaParseAttributeFn_multiple",
+    () => {
+      const schema = {
+        "multi*": ["[number]"],
+        single: "[boolean]",
+      };
+      const name = this.CONSUME(Identifier);
+      this.CONSUME(EqualToken); // "="
+      this.SUBRULE(this.schemaParseAttributeFn, { ARGS: [name, schema] });
+    }
+  );
+
+  this.schemaParseAttributeFn_disabled = this.RULE(
+    "schemaParseAttributeFn_disabled",
+    () => {
+      const schema = {
+        "![string]": {
+          valid: "[boolean]",
+          "!invalid": "[boolean]",
+        },
+      };
+      const name = this.CONSUME(Identifier);
+      this.CONSUME(EqualToken); // "="
+      this.SUBRULE(this.schemaParseAttributeFn, { ARGS: [name, schema] });
+    }
+  );
+}
+
+function parse(inputText) {
+  parser.reset();
+  const lexResult = lexDocument(inputText);
+  parser.input = lexResult.tokens;
+  return parser;
+}
+
+describe("schemaParseAttributeFn", () => {
+  it("schemaParseAttributeFn accepts mix types and constants", () => {
+    parse(`value = {something = 345}`).schemaParseAttributeFn_flat();
+    expect(parser.errors).to.be.empty;
+
+    parse(`value = {
+      something = 123.2,
+      other_thing = 44
+    }`).schemaParseAttributeFn_flat();
+    expect(parser.errors).to.be.empty;
+
+    parse(
+      `value = { something = 123.2, other_thing = 44 }`
+    ).schemaParseAttributeFn_flat();
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("schemaParseAttributeFn immutable restricts to valid token", () => {
+    parse(`value = {123: 124}`).schemaParseAttributeFn_flat();
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("schemaParseAttributeFn accepts deep definition", () => {
+    parse(`value = {
+      something = {
+        test: [123, 456]
+        bool: true
+        hey: "some constant"
+      } 
+    }`).schemaParseAttributeFn_deep();
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("schemaParseAttributeFn rejects errors in deep definition", () => {
+    parse(`value = {
+      something = {
+        test: 123,
+        bool: true,
+        hey: "some constant"
+      } 
+    }`).schemaParseAttributeFn_deep();
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("schemaParseAttributeFn rejects missing attribute", () => {
+    parse(`value = {
+      something = {
+        test: [123, 456]
+        hey: "some constant"
+      } 
+    }`).schemaParseAttributeFn_deep();
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("schemaParseAttributeFn rejects membership format for attribute", () => {
+    parse(`value = {
+      some.thing.here = {
+        test: [123, 456]
+        bool: true
+        hey: "some constant"
+      } 
+    }`).schemaParseAttributeFn_deep();
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("schemaParseAttributeFn accepts optional attribute", () => {
+    parse(`value = {
+      something = {
+        optional: 123
+        required: true
+      } 
+    }`).schemaParseAttributeFn_optional();
+    expect(parser.errors).to.be.empty;
+
+    parse(`value = {
+      something = {
+        required: true
+      } 
+    }`).schemaParseAttributeFn_optional();
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("schemaParseAttributeFn can be empty when all optional attributes are missing", () => {
+    parse(`my_function`).schemaParseAttributeFn_all_optional();
+    expect(parser.errors).to.be.empty;
+  });
+  it("schemaParseAttributeFn accept disabled keys", () => {
+    parse(`value = {
+        !disabled = { valid: true, invalid: false }
+        no_disabled = { valid: false, !invalid: true }
+      }`).schemaParseAttributeFn_disabled();
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("schemaParseAttributeFn accept disabled keys", () => {
+    parse(`value = {
+        !disabled = { valid: true, invalid: false }
+        no_disabled = { !valid: false, !invalid: true }
+      }`).schemaParseAttributeFn_disabled();
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("schemaParseAttributeFn accept disabled keys", () => {
+    parse(`value = {
+        !disabled: { valid: true, invalid: false }
+        no_disabled: { !valid: false, !invalid: true }
+      }`).schemaParseAttributeFn_disabled();
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("schemaParseAttributeFn accepts multiple keys", () => {
+    parse(`value = {
+      multi = [123, 456]
+      single = true
+      multi = [789, 1011]
+    }`).schemaParseAttributeFn_multiple();
+    expect(parser.errors).to.be.empty;
+
+    parse(`value = {
+      single = true
+    }`).schemaParseAttributeFn_multiple();
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("schemaParseAttributeFn accepts an expression", () => {
+    parse(`my_var {
+      value = [123, 456]
+      description = "an array"
+    }`).schemaParseAttributeFn_expression();
+    expect(parser.errors).to.be.empty;
+
+    parse(`my_var {
+      value = 123|add:5
+      description = "an integer with a filter"
+    }`).schemaParseAttributeFn_expression();
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("schemaParseAttributeFn accepts a stack clause", () => {
+    parse(`my_var {
+      value = 12
+      test {
+        api.call my_function verb=GET {
+          api_group = "foo"
+          input = { key: $x1 }
+        }
+      }
+      stack {
+        var $x1 {
+          value = 12
+        }
+
+        function.run my_function {
+          input = { key: $x1 }
+        }
+      }
+    }`).schemaParseAttributeFn_stack();
+    expect(parser.errors).to.be.empty;
+  });
+});

package/parser/functions/schema/schemaParseConstantFn.js

@@ -0,0 +1,136 @@
+import { isArray, some } from "lodash-es";
+import {
+  FloatLiteral,
+  IntegerLiteral,
+  SingleQuotedStringLiteral,
+  StringLiteral,
+} from "../../../lexer/literal.js";
+import { MultiLineStringToken } from "../../../lexer/multiline.js";
+import { FalseToken, NullToken, TrueToken } from "../../../lexer/tokens.js";
+import { isSchemaGenericType } from "./utils.js";
+
+/**
+ * @param {import('../../base_parser.js').XanoBaseParser} $
+ */
+export function schemaParseConstantFn($) {
+  return (token, schema, captured = {}) => {
+    let attributeCapturedType = null;
+
+    const capturedValue = $.OR({
+      IGNORE_AMBIGUITIES: true,
+      DEF: [
+        {
+          ALT: () => {
+            attributeCapturedType = "string";
+            return $.CONSUME(StringLiteral); // e.g., "A instructions of the field"
+          },
+        },
+        {
+          ALT: () => {
+            attributeCapturedType = "string";
+            return $.CONSUME(MultiLineStringToken); // e.g., """field\ninstructions\n"""
+          },
+        },
+        {
+          ALT: () => {
+            attributeCapturedType = "string";
+            return $.CONSUME(SingleQuotedStringLiteral); // e.g., 'field instructions'
+          },
+        },
+        {
+          ALT: () => {
+            attributeCapturedType = "number";
+            return $.CONSUME(IntegerLiteral); // e.g., 42
+          },
+        },
+        {
+          ALT: () => {
+            attributeCapturedType = "number";
+            return $.CONSUME(FloatLiteral); // e.g., 42.54
+          },
+        },
+        {
+          ALT: () => {
+            attributeCapturedType = "boolean";
+            return $.CONSUME(TrueToken); // e.g., true
+          },
+        },
+        {
+          ALT: () => {
+            attributeCapturedType = "boolean";
+            return $.CONSUME(FalseToken); // e.g., false
+          },
+        },
+        {
+          ALT: () => {
+            attributeCapturedType = "null";
+            return $.CONSUME(NullToken); // e.g., null
+          },
+        },
+      ],
+    });
+
+    captured.value = capturedValue;
+
+    $.ACTION(() => {
+      const isMatch = matchValueToSchema(
+        attributeCapturedType,
+        capturedValue.image,
+        schema
+      );
+
+      if (!isMatch) {
+        $.addExpectedValueError(token, schema);
+      }
+    });
+  };
+}
+
+function matchValueToSchema(attributeCapturedType, value, schema) {
+  const schemaValue = schema !== null ? schema.toString() : schema;
+
+  // schema can be an array of type/values required
+  if (isArray(schema)) {
+    return some(schema, (s) =>
+      matchValueToSchema(attributeCapturedType, value, s)
+    );
+  }
+
+  switch (attributeCapturedType) {
+    case "string":
+      // remove the quotes for easier comparison
+      if (value.startsWith('"""') || value.startsWith("'''")) {
+        value = value.slice(4, -4).trim();
+      }
+      if (value.startsWith('"') || value.startsWith("'")) {
+        value = value.slice(1, -1);
+      }
+
+      return value === schemaValue;
+
+    case "number":
+    case "boolean":
+      return value === schemaValue;
+    case "null":
+      return schemaValue === null;
+    default:
+      throw new Error(
+        `schemaParseConstantFn called with non-constant attribute: ${schema}`
+      );
+  }
+}
+
+/**
+ * Check if an argument is a constant as opposed to a type, a constant has an expected value
+ * @param {*} attr
+ * @returns
+ */
+export function schemaExpectConstant(attr) {
+  if (isSchemaGenericType(attr)) return false;
+  return (
+    typeof attr === "string" ||
+    typeof attr === "number" ||
+    typeof attr === "boolean" ||
+    attr === null
+  );
+}

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

@@ -0,0 +1,122 @@
+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.schemaParseConstantFn_test_constant_string = this.RULE(
+    "schemaParseConstantFn_test_constant_string",
+    () => {
+      const schema = "value";
+      const name = this.CONSUME(Identifier);
+      this.CONSUME(EqualToken); // "="
+      this.SUBRULE(this.schemaParseConstantFn, { ARGS: [name, schema] });
+    }
+  );
+
+  // this rule requires a foo field to be defined
+  this.schemaParseConstantFn_test_constant_boolean = this.RULE(
+    "schemaParseConstantFn_test_constant_boolean",
+    () => {
+      const schema = true;
+      const name = this.CONSUME(Identifier);
+      this.CONSUME(EqualToken); // "="
+      this.SUBRULE(this.schemaParseConstantFn, { ARGS: [name, schema] });
+    }
+  );
+
+  // this rule requires a foo field to be defined
+  this.schemaParseConstantFn_test_constant_number = this.RULE(
+    "schemaParseConstantFn_test_constant_number",
+    () => {
+      const schema = 42;
+      const name = this.CONSUME(Identifier);
+      this.CONSUME(EqualToken); // "="
+      this.SUBRULE(this.schemaParseConstantFn, { ARGS: [name, schema] });
+    }
+  );
+
+  // check the null case too
+  // this rule requires a foo field to be defined
+  this.schemaParseConstantFn_test_constant_null = this.RULE(
+    "schemaParseConstantFn_test_constant_null",
+    () => {
+      const schema = null;
+      const name = this.CONSUME(Identifier);
+      this.CONSUME(EqualToken); // "="
+      this.SUBRULE(this.schemaParseConstantFn, { ARGS: [name, schema] });
+    }
+  );
+}
+
+function parse(inputText) {
+  parser.reset();
+  const lexResult = lexDocument(inputText);
+  parser.input = lexResult.tokens;
+  return parser;
+}
+
+describe("schemaParseConstantFn", () => {
+  it("schemaParseConstantFn constant string", () => {
+    parse(`something = "value"`).schemaParseConstantFn_test_constant_string();
+    expect(parser.errors).to.be.empty;
+
+    parse("something = `value`").schemaParseConstantFn_test_constant_string();
+    expect(parser.errors).to.not.be.empty;
+
+    parse(`something = """
+      value
+      """`).schemaParseConstantFn_test_constant_string();
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("schemaParseConstantFn rejects non valid string contstant", () => {
+    parse(`something = 123`).schemaParseConstantFn_test_constant_string();
+    expect(parser.errors).to.not.be.empty;
+
+    parse(`something = false`).schemaParseConstantFn_test_constant_string();
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("schemaParseConstantFn constant boolean", () => {
+    parse(`something = true`).schemaParseConstantFn_test_constant_boolean();
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("schemaParseConstantFn reject non valid boolean constant", () => {
+    parse(`something = 1`).schemaParseConstantFn_test_constant_boolean();
+    expect(parser.errors).to.not.be.empty;
+
+    parse(`something = false`).schemaParseConstantFn_test_constant_boolean();
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("schemaParseConstantFn constant number", () => {
+    parse(`something = 42`).schemaParseConstantFn_test_constant_number();
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("schemaParseConstantFn reject non valid number constant", () => {
+    parse(`something = 44`).schemaParseConstantFn_test_constant_number();
+    expect(parser.errors).to.not.be.empty;
+
+    parse(`something = 42.0`).schemaParseConstantFn_test_constant_number();
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("schemaParseConstantFn constant null", () => {
+    parse(`something = null`).schemaParseConstantFn_test_constant_null();
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("schemaParseConstantFn reject non valid null constant", () => {
+    parse(`something = 0`).schemaParseConstantFn_test_constant_null();
+    expect(parser.errors).to.not.be.empty;
+
+    parse(`something = false`).schemaParseConstantFn_test_constant_null();
+    expect(parser.errors).to.not.be.empty;
+  });
+});

package/parser/functions/schema/schemaParseEnum.js

@@ -0,0 +1,52 @@
+import { isArray, partition } from "lodash-es";
+import { isSchemaGenericType } from "./utils.js";
+
+/**
+ * @param {import('../../base_parser.js').XanoBaseParser} $
+ */
+export function schemaParseEnumFn($) {
+  return (token, schema, captured = {}) => {
+    const [immutables, constants] = partition(schema, isSchemaGenericType);
+    $.ACTION(() => {
+      if (constants.length > 0 && immutables.length > 0) {
+        throw new Error(
+          "schemaParseEnumFn does not support mixing constant and immutable types in the same enum, received: " +
+            JSON.stringify(schema)
+        );
+      }
+    });
+
+    // the following are exclusive, you can't have a [string] and a "foo" in the same enum
+    $.OR({
+      IGNORE_AMBIGUITIES: true,
+      DEF: [
+        {
+          GATE: () => constants.length > 0,
+          ALT: () =>
+            $.SUBRULE($.schemaParseConstantFn, {
+              ARGS: [token, constants, captured],
+            }),
+        },
+        {
+          GATE: () => immutables.length > 0,
+          ALT: () =>
+            $.SUBRULE($.schemaParseImmutableFn, {
+              ARGS: [token, immutables, captured],
+            }),
+        },
+      ],
+    });
+  };
+}
+
+/**
+ *
+ * @param {*} attr
+ * @returns
+ */
+export function schemaExpectEnum(attr) {
+  if (isArray(attr) && attr.length > 1) {
+    return true;
+  }
+  return false;
+}

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

@@ -0,0 +1,47 @@
+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.schemaParseEnumFn_immutable_and_const = this.RULE(
+    "schemaParseEnumFn_immutable_and_const",
+    () => {
+      const schema = ["[string]", "[number]"];
+      const name = this.CONSUME(Identifier);
+      this.CONSUME(EqualToken); // "="
+      this.SUBRULE(this.schemaParseEnumFn, { ARGS: [name, schema] });
+    }
+  );
+}
+
+function parse(inputText) {
+  parser.reset();
+  const lexResult = lexDocument(inputText);
+  parser.input = lexResult.tokens;
+  return parser;
+}
+
+describe("schemaParseEnumFn", () => {
+  it("schemaParseEnumFn accepts mix types and constants", () => {
+    parse(`something = 'test'`).schemaParseEnumFn_immutable_and_const();
+    expect(parser.errors).to.be.empty;
+
+    parse(`something = 123`).schemaParseEnumFn_immutable_and_const();
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("schemaParseEnumFn immutable restricts to valid token", () => {
+    parse(`something = false`).schemaParseEnumFn_immutable_and_const();
+    expect(parser.errors).to.not.be.empty;
+
+    parse(`something = [123]`).schemaParseEnumFn_immutable_and_const();
+    expect(parser.errors).to.not.be.empty;
+
+    parse(`something = {foo: "Bar"}`).schemaParseEnumFn_immutable_and_const();
+    expect(parser.errors).to.not.be.empty;
+  });
+});