@xano/xanoscript-language-server 11.0.3

package/parser/functions/schema/utils.js

@@ -0,0 +1,136 @@
+/**
+ * Check if an argument to a key is an enum (a list with at least 2 values)
+ */
+export function isEnumAttribute(attr) {
+  if (typeof attr !== "object" || !Array.isArray(attr)) return false;
+  return attr.length >= 2;
+}
+
+/**
+ * Check if an argument is an array type (an array with a single value)
+ */
+export function isArrayAttribute(attr) {
+  if (typeof attr !== "object" || !Array.isArray(attr)) return false;
+  return attr.length === 1;
+}
+
+/**
+ * If an attribute ends with a "?" it is optional
+ * @param {*} attr
+ * @returns
+ */
+export function isOptionalAttribute(attr) {
+  if (!attr || typeof attr !== "string") return false;
+  return attr.endsWith("?") || attr.endsWith("*");
+}
+
+/**
+ * If an attributes ends with a "*" it is multiple
+ * @param {*} attr
+ * @returns
+ */
+export function isMultiAttribute(attr) {
+  if (!attr || typeof attr !== "string") return false;
+  return attr.endsWith("*");
+}
+
+/**
+ * If an attribute ends with a "?" it is optional
+ * @param {*} attr
+ * @returns
+ */
+export function canBeDisabledAttribute(attr) {
+  if (!attr || typeof attr !== "string") return false;
+  return attr.startsWith("!");
+}
+
+/**
+ * if an attribute is within `[]` it's an object
+ */
+export function isSchemaGenericType(attr) {
+  if (!attr || typeof attr !== "string") return false;
+  if (isOptionalAttribute(attr)) {
+    attr = attr.slice(0, -1);
+  }
+  if (canBeDisabledAttribute(attr)) {
+    attr = attr.slice(1);
+  }
+  return attr.startsWith("[") && attr.endsWith("]");
+}
+
+/**
+ * takes constant attribute and returns its value
+ */
+export function getSchemaConstantValue(attr) {
+  if (canBeDisabledAttribute(attr)) {
+    attr = attr.slice(1);
+  }
+  if (isOptionalAttribute(attr)) {
+    attr = attr.slice(0, -1);
+  }
+  return attr;
+}
+
+/**
+ * takes a schema generic type attribute and returns its name
+ *
+ * [string] => string
+ * [number]? => number
+ * ![boolean] => boolean
+ * [string]* => string
+ * @param {*} attr
+ * @returns
+ */
+export function getSchemaGenericTypeName(attr) {
+  if (!isSchemaGenericType(attr)) return null;
+  if (isOptionalAttribute(attr)) {
+    attr = attr.slice(0, -1);
+  }
+  if (canBeDisabledAttribute(attr)) {
+    attr = attr.slice(1);
+  }
+  return attr.slice(1, -1);
+}
+
+/**
+ *
+ * @param {string} attr
+ * @param {string[]} types
+ * @returns
+ */
+export function schemaExpectOneOf(attr, types) {
+  if (isSchemaGenericType(attr)) {
+    return types.includes(getSchemaGenericTypeName(attr));
+  }
+  return false;
+}
+
+/**
+ * check if a value matches the requirements
+ * @param {*} value
+ * @param {*} requirements
+ * @returns {boolean|string} type name if matches, false if not, or the generic type that matches
+ */
+export const valueMatchRequirements = (value, requirements) => {
+  for (const requirement of requirements) {
+    // is the key a generic type? (there can be only one then)
+    if (isSchemaGenericType(requirement)) {
+      switch (getSchemaGenericTypeName(requirement)) {
+        case "string":
+          if (typeof value === "string") return requirement;
+          break;
+        case "number":
+          if (!isNaN(Number(value))) return requirement;
+          break;
+        case "boolean":
+          if (value === "true" || value === "false") return requirement;
+          break;
+      }
+    } else if (getSchemaConstantValue(requirement) === value) {
+      return requirement;
+    } else if (value === requirement) {
+      return requirement;
+    }
+  }
+  return false;
+};

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

@@ -0,0 +1,27 @@
+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/register.js

@@ -0,0 +1,64 @@
+import { securityCheckPasswordFn } from "./securityCheckPasswordFn.js";
+import { securityCreateAuthTokenFn } from "./securityCreateAuthTokenFn.js";
+import { securityCreateCurveKeyFn } from "./securityCreateCurveKeyFn.js";
+import { securityCreatePasswordFn } from "./securityCreatePasswordFn.js";
+import { securityCreateRsaKeyFn } from "./securityCreateRsaKeyFn.js";
+import { securityCreateSecretKeyFn } from "./securityCreateSecretKeyFn.js";
+import { securityCreateUuidFn } from "./securityCreateUuidFn.js";
+import { securityDecryptFn } from "./securityDecryptFn.js";
+import { securityEncryptFn } from "./securityEncryptFn.js";
+import { securityJweDecodeFn } from "./securityJweDecodeFn.js";
+import { securityJweEncodeFn } from "./securityJweEncodeFn.js";
+import { securityJwsDecodeFn } from "./securityJwsDecodeFn.js";
+import { securityJwsEncodeFn } from "./securityJwsEncodeFn.js";
+import { securityRandomBytesFn } from "./securityRandomBytesFn.js";
+import { securityRandomNumberFn } from "./securityRandomNumberFn.js";
+
+/**
+ * Registers all the parsers in this folder
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export const register = ($) => {
+  $.securityCheckPasswordFn = $.RULE(
+    "securityCheckPasswordFn",
+    securityCheckPasswordFn($)
+  );
+  $.securityCreateAuthTokenFn = $.RULE(
+    "securityCreateAuthTokenFn",
+    securityCreateAuthTokenFn($)
+  );
+  $.securityCreateCurveKeyFn = $.RULE(
+    "securityCreateCurveKeyFn",
+    securityCreateCurveKeyFn($)
+  );
+  $.securityCreatePasswordFn = $.RULE(
+    "securityCreatePasswordFn",
+    securityCreatePasswordFn($)
+  );
+  $.securityCreateRsaKeyFn = $.RULE(
+    "securityCreateRsaKeyFn",
+    securityCreateRsaKeyFn($)
+  );
+  $.securityCreateSecretKeyFn = $.RULE(
+    "securityCreateSecretKeyFn",
+    securityCreateSecretKeyFn($)
+  );
+  $.securityCreateUuidFn = $.RULE(
+    "securityCreateUuidFn",
+    securityCreateUuidFn($)
+  );
+  $.securityDecryptFn = $.RULE("securityDecryptFn", securityDecryptFn($));
+  $.securityEncryptFn = $.RULE("securityEncryptFn", securityEncryptFn($));
+  $.securityJweDecodeFn = $.RULE("securityJweDecodeFn", securityJweDecodeFn($));
+  $.securityJweEncodeFn = $.RULE("securityJweEncodeFn", securityJweEncodeFn($));
+  $.securityJwsDecodeFn = $.RULE("securityJwsDecodeFn", securityJwsDecodeFn($));
+  $.securityJwsEncodeFn = $.RULE("securityJwsEncodeFn", securityJwsEncodeFn($));
+  $.securityRandomBytesFn = $.RULE(
+    "securityRandomBytesFn",
+    securityRandomBytesFn($)
+  );
+  $.securityRandomNumberFn = $.RULE(
+    "securityRandomNumberFn",
+    securityRandomNumberFn($)
+  );
+};

package/parser/functions/security/securityCheckPasswordFn.js

@@ -0,0 +1,24 @@
+import { EqualToken, LCurly, RCurly } from "../../../lexer/control.js";
+import { CheckPasswordToken } from "../../../lexer/security.js";
+import { Identifier, NewlineToken } from "../../../lexer/tokens.js";
+
+/**
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export function securityCheckPasswordFn($) {
+  return () => {
+    $.sectionStack.push("securityCheckPasswordFn");
+    const fnToken = $.CONSUME(CheckPasswordToken); // "check_password"
+    $.CONSUME(LCurly); // "{"
+    $.MANY(() => {
+      $.AT_LEAST_ONE(() => $.CONSUME(NewlineToken));
+      $.CONSUME1(Identifier); // "field_name"
+      $.CONSUME(EqualToken); // "="
+      $.SUBRULE($.expressionFn);
+    });
+    $.MANY1(() => $.CONSUME1(NewlineToken));
+    $.CONSUME(RCurly); // "}"
+    $.SUBRULE($.asVariable, { ARGS: [fnToken] });
+    $.sectionStack.pop();
+  };
+}

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

@@ -0,0 +1,22 @@
+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.js

@@ -0,0 +1,24 @@
+import { EqualToken, LCurly, RCurly } from "../../../lexer/control.js";
+import { CreateAuthTokenToken } from "../../../lexer/security.js";
+import { Identifier, NewlineToken } from "../../../lexer/tokens.js";
+
+/**
+ * @param {import('../../base_parser.js').XanoBaseParser} $
+ */
+export function securityCreateAuthTokenFn($) {
+  return () => {
+    $.sectionStack.push("securityCreateAuthTokenFn");
+    const fnToken = $.CONSUME(CreateAuthTokenToken); // "create_auth_token"
+    $.CONSUME(LCurly); // "{"
+    $.MANY(() => {
+      $.AT_LEAST_ONE(() => $.CONSUME(NewlineToken));
+      $.CONSUME1(Identifier); // "field_name"
+      $.CONSUME(EqualToken); // "="
+      $.SUBRULE($.expressionFn);
+    });
+    $.MANY1(() => $.CONSUME1(NewlineToken));
+    $.CONSUME(RCurly); // "}"
+    $.SUBRULE($.asVariable, { ARGS: [fnToken] });
+    $.sectionStack.pop();
+  };
+}

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

@@ -0,0 +1,24 @@
+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 = ""
+    } as $authToken`);
+    expect(parser.errors).to.be.empty;
+  });
+});

package/parser/functions/security/securityCreateCurveKeyFn.js

@@ -0,0 +1,19 @@
+import { CreateCurveKeyToken } from "../../../lexer/security.js";
+
+/**
+ * @param {import('../../base_parser.js').XanoBaseParser} $
+ */
+export function securityCreateCurveKeyFn($) {
+  const requiredAttrs = ["curve", "format"];
+  const optionalAttrs = ["description", "disabled"];
+
+  return () => {
+    $.sectionStack.push("securityCreateCurveKeyFn");
+    const fnToken = $.CONSUME(CreateCurveKeyToken); // "create_curve_key"
+    $.SUBRULE($.functionAttrReq, {
+      ARGS: [fnToken, requiredAttrs, optionalAttrs],
+    });
+    $.SUBRULE($.asVariable, { ARGS: [fnToken] });
+    $.sectionStack.pop();
+  };
+}

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

@@ -0,0 +1,22 @@
+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.js

@@ -0,0 +1,26 @@
+import { CreatePasswordToken } from "../../../lexer/security.js";
+
+/**
+ * @param {import('../../base_parser.js').XanoBaseParser} $
+ */
+export function securityCreatePasswordFn($) {
+  const requiredAttrs = [
+    "character_count",
+    "require_lowercase",
+    "require_uppercase",
+    "require_digit",
+    "require_symbol",
+    "symbol_whitelist",
+  ];
+  const optionalAttrs = ["description", "disabled"];
+
+  return () => {
+    $.sectionStack.push("securityCreatePasswordFn");
+    const fnToken = $.CONSUME(CreatePasswordToken); // "create_password"
+    $.SUBRULE($.functionAttrReq, {
+      ARGS: [fnToken, requiredAttrs, optionalAttrs],
+    });
+    $.SUBRULE($.asVariable, { ARGS: [fnToken] });
+    $.sectionStack.pop();
+  };
+}

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

@@ -0,0 +1,26 @@
+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.js

@@ -0,0 +1,19 @@
+import { CreateRsaKeyToken } from "../../../lexer/security.js";
+
+/**
+ * @param {import('../../base_parser.js').XanoBaseParser} $
+ */
+export function securityCreateRsaKeyFn($) {
+  const requiredAttrs = ["bits", "format"];
+  const optionalAttrs = ["description", "disabled"];
+
+  return () => {
+    $.sectionStack.push("securityCreateRsaKeyFn");
+    const fnToken = $.CONSUME(CreateRsaKeyToken); // "create_rsa_key"
+    $.SUBRULE($.functionAttrReq, {
+      ARGS: [fnToken, requiredAttrs, optionalAttrs],
+    });
+    $.SUBRULE($.asVariable, { ARGS: [fnToken] });
+    $.sectionStack.pop();
+  };
+}

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

@@ -0,0 +1,22 @@
+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.js

@@ -0,0 +1,24 @@
+import { EqualToken, LCurly, RCurly } from "../../../lexer/control.js";
+import { CreateSecretKeyToken } from "../../../lexer/security.js";
+import { Identifier, NewlineToken } from "../../../lexer/tokens.js";
+
+/**
+ * @param {import('../../base_parser.js').XanoBaseParser} $
+ */
+export function securityCreateSecretKeyFn($) {
+  return () => {
+    $.sectionStack.push("securityCreateSecretKeyFn");
+    const fnToken = $.CONSUME(CreateSecretKeyToken); // "create_secret_key"
+    $.CONSUME(LCurly); // "{"
+    $.MANY(() => {
+      $.AT_LEAST_ONE(() => $.CONSUME(NewlineToken));
+      $.CONSUME1(Identifier); // "field_name"
+      $.CONSUME(EqualToken); // "="
+      $.SUBRULE($.expressionFn);
+    });
+    $.MANY1(() => $.CONSUME1(NewlineToken));
+    $.CONSUME(RCurly); // "}"
+    $.SUBRULE($.asVariable, { ARGS: [fnToken] });
+    $.sectionStack.pop();
+  };
+}

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

@@ -0,0 +1,22 @@
+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.js

@@ -0,0 +1,26 @@
+import { EqualToken, LCurly, RCurly } from "../../../lexer/control.js";
+import { CreateUuidToken } from "../../../lexer/security.js";
+import { Identifier, NewlineToken } from "../../../lexer/tokens.js";
+
+/**
+ * @param {import('../../base_parser.js').XanoBaseParser} $
+ */
+export function securityCreateUuidFn($) {
+  return () => {
+    $.sectionStack.push("securityCreateUuidFn");
+    const fnToken = $.CONSUME(CreateUuidToken); // "create_uuid"
+    $.OPTION(() => {
+      $.CONSUME(LCurly); // "{"
+      $.MANY(() => {
+        $.AT_LEAST_ONE(() => $.CONSUME(NewlineToken));
+        $.CONSUME1(Identifier); // "field_name"
+        $.CONSUME(EqualToken); // "="
+        $.SUBRULE($.expressionFn);
+      });
+      $.MANY1(() => $.CONSUME1(NewlineToken));
+      $.CONSUME(RCurly); // "}"
+    });
+    $.SUBRULE($.asVariable, { ARGS: [fnToken] });
+    $.sectionStack.pop();
+  };
+}

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

@@ -0,0 +1,27 @@
+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.js

@@ -0,0 +1,24 @@
+import { EqualToken, LCurly, RCurly } from "../../../lexer/control.js";
+import { DecryptToken } from "../../../lexer/security.js";
+import { Identifier, NewlineToken } from "../../../lexer/tokens.js";
+
+/**
+ * @param {import('../../base_parser.js').XanoBaseParser} $
+ */
+export function securityDecryptFn($) {
+  return () => {
+    $.sectionStack.push("securityDecryptFn");
+    const fnToken = $.CONSUME(DecryptToken); // "decrypt"
+    $.CONSUME(LCurly); // "{"
+    $.MANY(() => {
+      $.AT_LEAST_ONE(() => $.CONSUME(NewlineToken));
+      $.CONSUME1(Identifier); // "field_name"
+      $.CONSUME(EqualToken); // "="
+      $.SUBRULE($.expressionFn);
+    });
+    $.MANY1(() => $.CONSUME1(NewlineToken));
+    $.CONSUME(RCurly); // "}"
+    $.SUBRULE($.asVariable, { ARGS: [fnToken] });
+    $.sectionStack.pop();
+  };
+}

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

@@ -0,0 +1,24 @@
+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.js

@@ -0,0 +1,24 @@
+import { EqualToken, LCurly, RCurly } from "../../../lexer/control.js";
+import { EncryptToken } from "../../../lexer/security.js";
+import { Identifier, NewlineToken } from "../../../lexer/tokens.js";
+
+/**
+ * @param {import('../../base_parser.js').XanoBaseParser} $
+ */
+export function securityEncryptFn($) {
+  return () => {
+    $.sectionStack.push("securityEncryptFn");
+    const fnToken = $.CONSUME(EncryptToken); // "encrypt"
+    $.CONSUME(LCurly); // "{"
+    $.MANY(() => {
+      $.AT_LEAST_ONE(() => $.CONSUME(NewlineToken));
+      $.CONSUME1(Identifier); // "field_name"
+      $.CONSUME(EqualToken); // "="
+      $.SUBRULE($.expressionFn);
+    });
+    $.MANY1(() => $.CONSUME1(NewlineToken));
+    $.CONSUME(RCurly); // "}"
+    $.SUBRULE($.asVariable, { ARGS: [fnToken] });
+    $.sectionStack.pop();
+  };
+}

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

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