@xano/xanoscript-language-server 11.12.2 → 12.0.0

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

@@ -1,223 +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.schemaParseObjectFn_flat = this.RULE("schemaParseObjectFn_flat", () => {
-    const schema = { "[string]": "[number]" };
-    const name = this.CONSUME(Identifier);
-    this.CONSUME(EqualToken); // "="
-    const obj = {};
-    this.SUBRULE(this.schemaParseObjectFn, {
-      ARGS: [name, schema, obj],
-    });
-  });
-
-  this.schemaParseObjectFn_deep = this.RULE("schemaParseObjectFn_deep", () => {
-    const schema = {
-      "[string]": {
-        test: ["[number]"],
-        bool: "[boolean]",
-        hey: "some constant",
-      },
-    };
-    const name = this.CONSUME(Identifier);
-    this.CONSUME(EqualToken); // "="
-    this.SUBRULE(this.schemaParseObjectFn, { ARGS: [name, schema] });
-  });
-
-  this.schemaParseObjectFn_disabled = this.RULE(
-    "schemaParseObjectFn_disabled",
-    () => {
-      const schema = {
-        "![string]": {
-          valid: "[boolean]",
-          "!invalid": "[boolean]",
-        },
-      };
-      const name = this.CONSUME(Identifier);
-      this.CONSUME(EqualToken); // "="
-      this.SUBRULE(this.schemaParseObjectFn, { ARGS: [name, schema] });
-    }
-  );
-
-  this.schemaParseObjectFn_optional = this.RULE(
-    "schemaParseObjectFn_optional",
-    () => {
-      const schema = {
-        "[string]": {
-          "optional?": "[number]",
-          required: "[boolean]",
-        },
-      };
-      const name = this.CONSUME(Identifier);
-      this.CONSUME(EqualToken); // "="
-      this.SUBRULE(this.schemaParseObjectFn, { ARGS: [name, schema] });
-    }
-  );
-
-  this.schemaParseObjectFn_multiple = this.RULE(
-    "schemaParseObjectFn_multiple",
-    () => {
-      const schema = {
-        "[string]": {
-          "multi*": "[number]",
-          required: "[boolean]",
-        },
-      };
-      const name = this.CONSUME(Identifier);
-      this.CONSUME(EqualToken); // "="
-      this.SUBRULE(this.schemaParseObjectFn, { ARGS: [name, schema] });
-    }
-  );
-}
-
-function parse(inputText) {
-  parser.reset();
-  const lexResult = lexDocument(inputText);
-  parser.input = lexResult.tokens;
-  return parser;
-}
-
-describe("schemaParseObjectFn", () => {
-  it("schemaParseObjectFn accepts mix types and constants", () => {
-    parse(`value = {something: 345}`).schemaParseObjectFn_flat();
-    expect(parser.errors).to.be.empty;
-
-    parse(`value = {
-      something: 123.2,
-      other_thing: 44
-    }`).schemaParseObjectFn_flat();
-    expect(parser.errors).to.be.empty;
-
-    parse(
-      `value = { something: 123.2, other_thing: 44 }`
-    ).schemaParseObjectFn_flat();
-    expect(parser.errors).to.be.empty;
-
-    parse(`value = {
-      something: 123.2,
-      other_thing: 44,
-    }`).schemaParseObjectFn_flat();
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("schemaParseObjectFn rejects duplicate keys", () => {
-    parse(
-      `value = {something: 345, something: 123}`
-    ).schemaParseObjectFn_flat();
-    expect(parser.errors).to.not.be.empty;
-
-    parse(
-      `value = {
-        my.property.key: 345, 
-        my.property.key: 123
-      }`
-    ).schemaParseObjectFn_flat();
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("schemaParseObjectFn accepts different sub-property on duplicate roots", () => {
-    parse(`value = {
-      my.property.foo: 345, 
-      my.property.key: 123
-    }`).schemaParseObjectFn_flat();
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("schemaParseObjectFn immutable restricts to valid token", () => {
-    parse(`value = {123: 124}`).schemaParseObjectFn_flat();
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("schemaParseObjectFn accepts deep definition", () => {
-    parse(`value = {
-      something: {
-        test: [123, 456]
-        bool: true
-        hey: "some constant"
-      } 
-    }`).schemaParseObjectFn_deep();
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("schemaParseObjectFn rejects errors in deep definition", () => {
-    parse(`value = {
-      something: {
-        test: 123,
-        bool: true,
-        hey: "some constant"
-      } 
-    }`).schemaParseObjectFn_deep();
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("schemaParseObjectFn rejects missing keys", () => {
-    parse(`value = {
-      something: {
-        test: [123, 456]
-        hey: "some constant"
-      } 
-    }`).schemaParseObjectFn_deep();
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("schemaParseObjectFn accepts membership format for keys", () => {
-    parse(`value = {
-      some.thing.here: {
-        test: [123, 456]
-        bool: true
-        hey: "some constant"
-      } 
-    }`).schemaParseObjectFn_deep();
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("schemaParseObjectFn accepts optional keys", () => {
-    parse(`value = {
-      something: {
-        optional: 123
-        required: true
-      } 
-    }`).schemaParseObjectFn_optional();
-    expect(parser.errors).to.be.empty;
-
-    parse(`value = {
-      something: {
-        required: true
-      } 
-    }`).schemaParseObjectFn_optional();
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("schemaParseObjectFn accept disabled keys", () => {
-    parse(`value = {
-      !disabled: { valid: true, invalid: false }
-      no_disabled: { valid: false, !invalid: true }
-    }`).schemaParseObjectFn_disabled();
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("schemaParseObjectFn accept disabled keys", () => {
-    parse(`value = {
-      !disabled: { valid: true, invalid: false }
-      no_disabled: { !valid: false, !invalid: true }
-    }`).schemaParseObjectFn_disabled();
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("schemaParseObjectFn accepts multiple keys", () => {
-    parse(`value = {
-      something: { multi: 123, multi: 456, required: true }
-    }`).schemaParseObjectFn_multiple();
-    expect(parser.errors).to.be.empty;
-    parse(`value = {
-      something: { required: true }
-    }`).schemaParseObjectFn_multiple();
-    expect(parser.errors).to.be.empty;
-  });
-});

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

@@ -1,27 +0,0 @@
-import { expect } from "chai";
-import { describe, it } from "mocha";
-import { getSchemaConstantValue, valueMatchRequirements } from "./utils.js";
-
-describe("schema/utils", () => {
-  describe("valueMatchRequirements", () => {
-    it("should return the correct requirement for multi attributes", () => {
-      expect(valueMatchRequirements("items", ["items"])).to.equal("items");
-      expect(valueMatchRequirements("items", ["items*"])).to.equal("items*");
-      expect(valueMatchRequirements("items", ["items?"])).to.equal("items?");
-      expect(valueMatchRequirements("items", ["!items?"])).to.equal("!items?");
-      expect(valueMatchRequirements("items", ["!items*"])).to.equal("!items*");
-      expect(valueMatchRequirements("items", ["!items"])).to.equal("!items");
-    });
-  });
-
-  describe("getSchemaConstantValue", () => {
-    it("should return the constant value without modifiers", () => {
-      // No changes were made to this function, so no tests were added.
-      expect(getSchemaConstantValue("[string]")).to.equal("[string]");
-      expect(getSchemaConstantValue("foo")).to.equal("foo");
-      expect(getSchemaConstantValue("foo*")).to.equal("foo");
-      expect(getSchemaConstantValue("foo?")).to.equal("foo");
-      expect(getSchemaConstantValue("!foo?")).to.equal("foo");
-    });
-  });
-});

package/parser/functions/security/securityCheckPasswordFn.spec.js

@@ -1,22 +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.securityCheckPasswordFn();
-  return parser;
-}
-
-describe("securityCheckPasswordFn", () => {
-  it("securityCheckPasswordFn accepts attributes and store value in a variable", () => {
-    const parser = parse(`check_password {
-      text_password = $input.password
-      hash_password = $user.password
-    } as $password_is_valid`);
-    expect(parser.errors).to.be.empty;
-  });
-});

package/parser/functions/security/securityCreateAuthTokenFn.spec.js

@@ -1,51 +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.securityCreateAuthTokenFn();
-  return parser;
-}
-
-describe("securityCreateAuthTokenFn", () => {
-  it("securityCreateAuthTokenFn accepts attributes and store value in a variable", () => {
-    const parser = parse(`create_auth_token {
-      table = "empty"
-      extras = {}
-      expiration = 86400
-      id = $user.id
-    } as $authToken`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("securityCreateAuthTokenFn requires an expiration attribute", () => {
-    const parser = parse(`create_auth_token {
-      table = "empty"
-      extras = {}
-      id = $user.id
-    } as $authToken`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("securityCreateAuthTokenFn requires an extra attribute", () => {
-    const parser = parse(`create_auth_token {
-      table = "empty"
-      expiration = 86400
-      id = $user.id
-    } as $authToken`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("securityCreateAuthTokenFn requires a table attribute", () => {
-    const parser = parse(`create_auth_token {
-      expiration = 86400
-      id = $user.id
-      extras = {"role": "admin"}
-    } as $authToken`);
-    expect(parser.errors).to.not.be.empty;
-  });
-});

package/parser/functions/security/securityCreateCurveKeyFn.spec.js

@@ -1,22 +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.securityCreateCurveKeyFn();
-  return parser;
-}
-
-describe("securityCreateCurveKeyFn", () => {
-  it("securityCreateCurveKeyFn accepts attributes and store value in a variable", () => {
-    const parser = parse(`create_curve_key {
-      curve = "P-256"
-      format = "object"
-    } as $crypto_key`);
-    expect(parser.errors).to.be.empty;
-  });
-});

package/parser/functions/security/securityCreatePasswordFn.spec.js

@@ -1,26 +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.securityCreatePasswordFn();
-  return parser;
-}
-
-describe("securityCreatePasswordFn", () => {
-  it("securityCreatePasswordFn accepts attributes and store value in a variable", () => {
-    const parser = parse(`create_password {
-      character_count = 12
-      require_lowercase = true
-      require_uppercase = true
-      require_digit = true
-      require_symbol = false
-      symbol_whitelist = ""
-    } as $password`);
-    expect(parser.errors).to.be.empty;
-  });
-});

package/parser/functions/security/securityCreateRsaKeyFn.spec.js

@@ -1,22 +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.securityCreateRsaKeyFn();
-  return parser;
-}
-
-describe("securityCreateRsaKeyFn", () => {
-  it("securityCreateRsaKeyFn accepts attributes and store value in a variable", () => {
-    const parser = parse(`create_rsa_key {
-      bits = 1024
-      format = "object"
-    } as $password_is_valid`);
-    expect(parser.errors).to.be.empty;
-  });
-});

package/parser/functions/security/securityCreateSecretKeyFn.spec.js

@@ -1,22 +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.securityCreateSecretKeyFn();
-  return parser;
-}
-
-describe("securityCreateSecretKeyFn", () => {
-  it("securityCreateSecretKeyFn accepts attributes and store value in a variable", () => {
-    const parser = parse(`create_secret_key {
-      bits = 1024
-      format = "object"
-    } as $password_is_valid`);
-    expect(parser.errors).to.be.empty;
-  });
-});

package/parser/functions/security/securityCreateUuidFn.spec.js

@@ -1,27 +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.securityCreateUuidFn();
-  return parser;
-}
-
-describe("securityCreateUuidFn", () => {
-  it("securityCreateUuidFn accepts attributes and store value in a variable", () => {
-    const parser = parse(`create_uuid {
-      text_password = $input.password
-      hash_password = $user.password
-    } as $password_is_valid`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("securityCreateUuidFn can be a single line", () => {
-    const parser = parse(`create_uuid as $password_is_valid`);
-    expect(parser.errors).to.be.empty;
-  });
-});

package/parser/functions/security/securityDecryptFn.spec.js

@@ -1,24 +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.securityDecryptFn();
-  return parser;
-}
-
-describe("securityDecryptFn", () => {
-  it("securityDecryptFn accepts attributes and store value in a variable", () => {
-    const parser = parse(`decrypt {
-      data = ""
-      algorithm = "aes-128-cbc"
-      key = ""
-      iv = ""
-    } as $password_is_valid`);
-    expect(parser.errors).to.be.empty;
-  });
-});

package/parser/functions/security/securityEncryptFn.spec.js

@@ -1,24 +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.securityEncryptFn();
-  return parser;
-}
-
-describe("securityEncryptFn", () => {
-  it("securityEncryptFn accepts attributes and store value in a variable", () => {
-    const parser = parse(`encrypt {
-      data = ""
-      algorithm = "aes-128-cbc"
-      key = ""
-      iv = ""
-    } as $password_is_valid`);
-    expect(parser.errors).to.be.empty;
-  });
-});

package/parser/functions/security/securityJweDecodeFn.spec.js

@@ -1,26 +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.securityJweDecodeFn();
-  return parser;
-}
-
-describe("securityJweDecodeFn", () => {
-  it("securityJweDecodeFn accepts attributes and store value in a variable", () => {
-    const parser = parse(`jwe_decode {
-      token = ""
-      key = ""
-      check_claims = {}
-      key_algorithm = "A256KW"
-      content_algorithm = "A256CBC-HS512"
-      timeDrift = 0
-    } as $password_is_valid`);
-    expect(parser.errors).to.be.empty;
-  });
-});

package/parser/functions/security/securityJweDecodeLegacyFn.spec.js

@@ -1,26 +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.securityJweDecodeLegacyFn();
-  return parser;
-}
-
-describe("securityJweDecodeLegacyFn", () => {
-  it("securityJweDecodeLegacyFn accepts attributes and store value in a variable", () => {
-    const parser = parse(`jwe_decode_legacy {
-      token = $input.magic_token
-      key = $env.magic_jwt_secret
-      audience = "Xano"
-      key_algorithm = "A256KW"
-      content_algorithm = "A256CBC-HS512"
-    } as $decoded_magic_token`);
-    console.log(parser.errors);
-    expect(parser.errors).to.be.empty;
-  });
-});

package/parser/functions/security/securityJweEncodeFn.spec.js

@@ -1,26 +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.securityJweEncodeFn();
-  return parser;
-}
-
-describe("securityJweEncodeFn", () => {
-  it("securityJweEncodeFn accepts attributes and store value in a variable", () => {
-    const parser = parse(`jwe_encode {
-      headers = {}
-      claims = {}
-      key = ""
-      key_algorithm = "A256KW"
-      content_algorithm = "A256CBC-HS512"
-      ttl = 0
-    } as $password_is_valid`);
-    expect(parser.errors).to.be.empty;
-  });
-});

package/parser/functions/security/securityJweEncodeLegacyFn.spec.js

@@ -1,25 +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.securityJweEncodeLegacyFn();
-  return parser;
-}
-
-describe("securityJweEncodeLegacyFn", () => {
-  it("securityJweEncodeLegacyFn accepts attributes and store value in a variable", () => {
-    const parser = parse(`jwe_encode_legacy {
-      payload = $jwt_payload
-      audience = "Xano"
-      key = $env.magic_jwt_secret
-      key_algorithm = "A256KW"
-      content_algorithm = "A256CBC-HS512"
-    } as $jwt`);
-    expect(parser.errors).to.be.empty;
-  });
-});

package/parser/functions/security/securityJwsDecodeFn.spec.js

@@ -1,25 +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.securityJwsDecodeFn();
-  return parser;
-}
-
-describe("securityJwsDecodeFn", () => {
-  it("securityJwsDecodeFn accepts attributes and store value in a variable", () => {
-    const parser = parse(`jws_decode {
-      token = ""
-      key = ""
-      check_claims = {}
-      signature_algorithm = "HS256"
-      timeDrift = 0
-    } as $password_is_valid`);
-    expect(parser.errors).to.be.empty;
-  });
-});

package/parser/functions/security/securityJwsEncodeFn.spec.js

@@ -1,25 +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.securityJwsEncodeFn();
-  return parser;
-}
-
-describe("securityJwsEncodeFn", () => {
-  it("securityJwsEncodeFn accepts attributes and store value in a variable", () => {
-    const parser = parse(`jws_encode {
-      headers = {}
-      claims = {}
-      key = ""
-      signature_algorithm = "HS256"
-      ttl = 0
-    } as $password_is_valid`);
-    expect(parser.errors).to.be.empty;
-  });
-});

package/parser/functions/security/securityRandomBytesFn.spec.js

@@ -1,21 +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.securityRandomBytesFn();
-  return parser;
-}
-
-describe("securityRandomBytesFn", () => {
-  it("securityRandomBytesFn accepts attributes and store value in a variable", () => {
-    const parser = parse(`random_bytes {
-      length = 1
-    } as $password_is_valid`);
-    expect(parser.errors).to.be.empty;
-  });
-});