@xano/xanoscript-language-server 11.0.3

package/parser/functions/util/utilSendEmailFn.js

@@ -0,0 +1,108 @@
+import { SendEmailToken } from "../../../lexer/util.js";
+import { getVarName } from "../../generic/utils.js";
+
+/**
+ * util.send_email {
+ *   to = "user@example.com"
+ *   subject = "Hello"
+ *   body = "This is a test email."
+ * }
+ * @param {import('../../base_parser.js').XanoBaseParser} $
+ */
+export function utilSendEmailFn($) {
+  return () => {
+    $.sectionStack.push("utilSendEmailFn");
+    const tokenFn = $.CONSUME(SendEmailToken); // "send_email"
+    const captured = {};
+    $.SUBRULE($.schemaParseAttributeFn, {
+      ARGS: [
+        tokenFn,
+        {
+          "description?": "[string]", // description is optional
+          "disabled?": "[boolean]", // disabled is optional
+          "service_provider?": ["resend", "xano"], // service_provider is optional
+          "api_key?": "[expression]",
+          "subject?": "[expression]",
+          "message?": "[expression]",
+          "to?": "[expression]",
+          "bcc?": "[expression]",
+          "cc?": "[expression]",
+          "from?": "[expression]",
+          "reply_to?": "[expression]",
+          "scheduled_at?": "[expression]",
+          "mock?": { "![string]": "[expression]" },
+        },
+        captured,
+      ],
+    });
+    $.SUBRULE($.asVariable, { ARGS: [tokenFn] });
+
+    const validFieldsPerProvider = {
+      xano: [
+        "description",
+        "disabled",
+        "service_provider",
+        "subject",
+        "message",
+        "mock",
+      ],
+      resend: [
+        "description",
+        "disabled",
+        "service_provider",
+        "api_key",
+        "subject",
+        "message",
+        "to",
+        "bcc",
+        "cc",
+        "from",
+        "reply_to",
+        "scheduled_at",
+        "mock",
+      ],
+    };
+
+    const requiredFieldsPerProvider = {
+      xano: ["subject", "message"],
+      resend: ["api_key", "subject", "message", "from", "to"],
+    };
+
+    $.ACTION(() => {
+      const service_provider = getVarName(captured.service_provider?.value);
+      const requiredFields = requiredFieldsPerProvider[service_provider] || [];
+      for (const field of requiredFields) {
+        if (!Object.prototype.hasOwnProperty.call(captured, field)) {
+          $.addMissingError(
+            tokenFn,
+            `Missing required field '${field}' for service_provider '${service_provider}'`
+          );
+        }
+      }
+
+      const validFields = validFieldsPerProvider[service_provider] || [];
+      const allFields = new Set([
+        ...validFieldsPerProvider.xano,
+        ...validFieldsPerProvider.resend,
+      ]);
+      const definedKeys = [];
+      for (const field in captured) {
+        const fieldValue = getVarName(captured[field].key);
+        definedKeys.push(fieldValue);
+        if (!allFields.has(fieldValue)) {
+          $.addIllegalAttributeError(
+            captured[field].key,
+            `Field '${fieldValue}' is not allowed in send_email`
+          );
+        } else if (!validFields.includes(fieldValue)) {
+          // in this context the service_provider will not used this field, add a warning
+          $.addWarning(
+            `${fieldValue} is not used with service_provider '${service_provider}'`,
+            captured[field].key
+          );
+        }
+      }
+    });
+    $.sectionStack.pop();
+  };
+}

package/parser/functions/util/utilSendEmailFn.spec.js

@@ -0,0 +1,62 @@
+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.utilSendEmailFn();
+  return parser;
+}
+
+describe("utilSendEmailFn", () => {
+  it("utilSendEmailFn accepts a xano provider call", () => {
+    const parser = parse(`send_email {
+      service_provider = "xano"
+      subject = "hellow"
+      message = "Hey there"
+    } as $xano_email`);
+
+    expect(parser.errors).to.be.empty;
+    expect(parser.warnings).to.be.empty;
+  });
+
+  it("utilSendEmailFn add warnings when unused fields are present", () => {
+    const parser = parse(`send_email {
+      service_provider = "xano"
+      subject = "hellow"
+      message = "Hey there"
+      cc = ["me@me.com", "john@be.com"]
+      from = "admin@xano.com"
+    } as $xano_email`);
+    expect(parser.warnings).to.not.be.empty;
+  });
+
+  it("utilSendEmailFn accepts a resend provider call", () => {
+    const parser = parse(`send_email {
+      api_key = $env.secret_key
+      service_provider = "resend"
+      subject = "hellow"
+      message = "Hey there"
+      to = "some_email@xano.com"
+      bcc = []|push:"foo@goo.com"
+      cc = ["me@me.com", "john@be.com"]
+      from = "admin@xano.com"
+      reply_to = "no-reply@xano.com"
+      scheduled_at = "2025-11-26T01:01:02.00"
+    } as $resend_email`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("utilSendEmailFn rejects missing api key fields for resend provider", () => {
+    const parser = parse(`send_email {
+      service_provider = "resend"
+      to = "some_email@xano.com"
+      subject = "hellow"
+      message = "Hey there"
+    } as $xano_email`);
+    expect(parser.errors).to.not.be.empty;
+  });
+});

package/parser/functions/util/utilSetHeaderFn.js

@@ -0,0 +1,22 @@
+import { SetHeaderToken } from "../../../lexer/util.js";
+
+/**
+ * util.set_header {
+ *   value: "Set-Cookie: sessionId=e8bb43229de9; HttpOnly; Server; Domain=foo.example.com"
+ *   duplicate: "duplicate"
+ * }
+ * @param {import('../../base_parser.js').XanoBaseParser} $
+ */
+export function utilSetHeaderFn($) {
+  return () => {
+    const requiredAttrs = ["value", "duplicates"];
+    const optionalAttrs = ["description", "disabled"];
+
+    $.sectionStack.push("utilSetHeaderFn");
+    const tokenFn = $.CONSUME(SetHeaderToken); // "set_header"
+    $.SUBRULE($.functionAttrReq, {
+      ARGS: [tokenFn, requiredAttrs, optionalAttrs],
+    });
+    $.sectionStack.pop();
+  };
+}

package/parser/functions/util/utilSetHeaderFn.spec.js

@@ -0,0 +1,48 @@
+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.utilSetHeaderFn();
+  return parser;
+}
+
+describe("utilSetHeaderFn", () => {
+  it("utilSetHeaderFn accepts a value", () => {
+    const parser = parse(`set_header {
+      value = "Set-Cookie: sessionId=e8bb43229de9; HttpOnly; Secure; Domain=foo.example.com"
+      duplicates = "replace"
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("utilSetHeaderFn accepts a description", () => {
+    const parser = parse(`set_header {
+      value = "Set-Cookie: sessionId=e8bb43229de9; HttpOnly; Secure; Domain=foo.example.com"
+      duplicates = "replace"
+      description = "foo"
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("utilSetHeaderFn can be disabled", () => {
+    const parser = parse(`set_header {
+      value = "Set-Cookie: sessionId=e8bb43229de9; HttpOnly; Secure; Domain=foo.example.com"
+      duplicates = "replace"
+      disabled = true
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("utilSetHeaderFn does not accept an output as value", () => {
+    const parser = parse(`set_header {
+      value = "Set-Cookie: sessionId=e8bb43229de9; HttpOnly; Secure; Domain=foo.example.com"
+      duplicates = "replace"
+    } as $x4`);
+    expect(parser.errors).to.not.be.empty;
+  });
+});

package/parser/functions/util/utilSleepFn.js

@@ -0,0 +1,19 @@
+import { SleepToken } from "../../../lexer/util.js";
+
+/**
+ * util.sleep" as $x3
+ * @param {import('../../base_parser.js').XanoBaseParser} $
+ */
+export function utilSleepFn($) {
+  return () => {
+    const requiredAttrs = ["value"];
+    const optionalAttrs = ["description", "disabled"];
+
+    $.sectionStack.push("utilSleepFn");
+    const tokenFn = $.CONSUME(SleepToken); // "sleep"
+    $.SUBRULE($.functionAttrReq, {
+      ARGS: [tokenFn, requiredAttrs, optionalAttrs],
+    });
+    $.sectionStack.pop();
+  };
+}

package/parser/functions/util/utilSleepFn.spec.js

@@ -0,0 +1,44 @@
+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.utilSleepFn();
+  return parser;
+}
+
+describe("utilSleepFn", () => {
+  it("utilSleepFn can have an empty body", () => {
+    const parser = parse(`sleep {
+      value = 1000  
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("utilSleepFn accepts a description", () => {
+    const parser = parse(`sleep {
+      value = 1000  
+      description = "foo"
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("utilSleepFn can be disabled", () => {
+    const parser = parse(`sleep {
+      value = 1000  
+      disabled = true
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("utilSleepFn requires a value", () => {
+    const parser = parse(`sleep {
+      description = "foo"
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+});

package/parser/functions/util/utilTemplateFn.js

@@ -0,0 +1,19 @@
+import { TemplateToken } from "../../../lexer/util.js";
+
+/**
+ * util.template {...} as $x3
+ * @param {import('../../base_parser.js').XanoBaseParser} $
+ */
+export function utilTemplateFn($) {
+  const requiredAttrs = ["value"];
+  const optionalAttrs = ["description", "disabled"];
+  return () => {
+    $.sectionStack.push("utilTemplateFn");
+    const fnToken = $.CONSUME(TemplateToken); // "template_engine"
+    $.SUBRULE($.functionAttrReq, {
+      ARGS: [fnToken, requiredAttrs, optionalAttrs],
+    });
+    $.SUBRULE($.asVariable, { ARGS: [fnToken] });
+    $.sectionStack.pop();
+  };
+}

package/parser/functions/util/utilTemplateFn.spec.js

@@ -0,0 +1,78 @@
+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.utilTemplateFn();
+  return parser;
+}
+
+describe("utilTemplateFn", () => {
+  it("utilTemplateFn accepts data field", () => {
+    const parser = parse(`template_engine {
+      value = """
+        console.log("hello world");
+        """
+    } as $script`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("utilTemplateFn handles twig controls", () => {
+    const parser = parse(`template_engine {
+      value = """
+        {% set user = {
+            'isActive': true,
+            'isPending': false
+        } %}
+        
+        {% if user.isActive %}
+            Active user
+        {% elseif user.isPending %}
+            Pending activation
+        {% else %}
+            Inactive user
+        {% endif %}
+        """
+    } as $elif`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("utilTemplateFn can be disabled", () => {
+    const parser = parse(`template_engine {
+      value = """
+        console.log("hello world");
+        """
+      disabled = true
+    } as $new_user`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("utilTemplateFn can be a single line string", () => {
+    const parser = parse(`template_engine {
+      value = 'console.log("hello world");'
+      disabled = true
+    } as $new_user`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("utilTemplateFn accepts a description", () => {
+    const parser = parse(`template_engine {
+      description = "template function"
+      value = """
+        console.log("hello world");
+        """
+    } as $new_user`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("utilTemplateFn requires a code field", () => {
+    const parser = parse(`template_engine {
+      description = "template new user"
+    } as $user`);
+    expect(parser.errors).to.not.be.empty;
+  });
+});

package/parser/functions/utilFn.js

@@ -0,0 +1,39 @@
+import { DotToken } from "../../lexer/tokens.js";
+import { UtilToken } from "../../lexer/util.js";
+
+/**
+ * util.geo_distance
+ * util.get_all_input
+ * util.get_env
+ * util.get_raw_input
+ * util.get_vars
+ * util.ip_lookup
+ * util.post_process
+ * util.precondition
+ * util.set_header
+ * util.sleep
+ * util.template
+ * util.send_email
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export function utilFn($) {
+  return () => {
+    $.sectionStack.push("util");
+    $.CONSUME(UtilToken); // "util"
+    $.CONSUME(DotToken); // "."
+    $.OR([
+      { ALT: () => $.SUBRULE($.utilIpLookupFn) }, // "util.ip_lookup"
+      { ALT: () => $.SUBRULE($.utilGetEnvFn) }, // "util.get_env"
+      { ALT: () => $.SUBRULE($.utilSleepFn) }, // "util.sleep"
+      { ALT: () => $.SUBRULE($.utilGetAllInputFn) }, // "util.get_all_input"
+      { ALT: () => $.SUBRULE($.utilGetRawInputFn) }, // "util.get_raw_input"
+      { ALT: () => $.SUBRULE($.utilGetVarsFn) }, // "util.get_vars"
+      { ALT: () => $.SUBRULE($.utilGeoDistanceFn) }, // "util.geo_distance"
+      { ALT: () => $.SUBRULE($.utilPostProcessFn) }, // "util.post_process"
+      { ALT: () => $.SUBRULE($.utilSetHeaderFn) }, // "util.set_header"
+      { ALT: () => $.SUBRULE($.utilTemplateFn) }, // "util.template"
+      { ALT: () => $.SUBRULE($.utilSendEmailFn) }, // "util.send_email"
+    ]);
+    $.sectionStack.pop();
+  };
+}

package/parser/functions/varFn.js

@@ -0,0 +1,51 @@
+import { DotToken } from "../../lexer/tokens.js";
+import { UpdateToken, VarToken } from "../../lexer/var.js";
+import { ShortFormVariable } from "../../lexer/variables.js";
+
+/**
+ * represent $var.x or $x, the only format accepting an assigment
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export function varFn($) {
+  return () => {
+    $.sectionStack.push("var");
+
+    const nameToken = $.CONSUME(VarToken); // "var"
+    $.OR([
+      {
+        // "var $users"
+        ALT: () => {
+          const variable = $.CONSUME(ShortFormVariable);
+          if (variable.image) {
+            // we can directly add the variable here but
+            // not necessary for the `assignableVariableProperty` below
+            // which will add it on its own
+            $.addVariable(variable.image, "unknown");
+          }
+        },
+      },
+      {
+        // "var.update $users"
+        ALT: () => {
+          $.CONSUME(DotToken);
+          $.CONSUME(UpdateToken);
+          $.SUBRULE($.assignableVariableProperty);
+        },
+      },
+    ]);
+
+    $.SUBRULE($.schemaParseAttributeFn, {
+      ARGS: [
+        nameToken,
+        {
+          value: "[expression]",
+          "description?": "[string]",
+          "disabled?": "[boolean]",
+          "mock?": { "![string]": "[expression]" },
+        },
+      ],
+    });
+
+    $.sectionStack.pop();
+  };
+}

package/parser/functions/varFn.spec.js

@@ -0,0 +1,173 @@
+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.varFn();
+  return parser;
+}
+
+describe("varFn", () => {
+  it("varFn accepts a string literal as value", () => {
+    const parser = parse(`var $user {
+      value = "email"
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("varFn accepts the attribute of a filtered value", () => {
+    const parser = parse(`var $user_enabled {
+      value = ($user_preferences|first).enabled
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("varFn accepts a filter in the value", () => {
+    const parser = parse(`var $transaction_count {
+      value = $daily_sales|count
+      description = "Count number of transactions"
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("varFn accepts a multiline object with commas separated values", () => {
+    const parser = parse(`var $rank_order {
+      value = {
+        "ensign": 1,
+        "lieutenant junior grade": 2,
+        "lieutenant": 3,
+        "lieutenant commander": 4,
+        "commander": 5,
+        "captain": 6,
+        "commodore": 7,
+        "rear admiral": 8,
+        "vice admiral": 9,
+        "admiral": 10
+      }
+      description = "Defines a numerical order for Starfleet ranks."
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("varFn accepts a description marker", () => {
+    const parser = parse(`var $user {
+      value = 12.345
+      description = "The user's email address"
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("varFn requires a value field ", () => {
+    const parser = parse(`var $user {
+      description = "The user's email address"
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("varFn fields can be defined in random order", () => {
+    const parser = parse(`var $user {
+      description = "The user's email address"
+      value = $email
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("varFn accepts a system env variable", () => {
+    const parser = parse(`var $user {
+      value = $env.$remote_ip
+      description = "The user's email address"
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("varFn expect a variable name", () => {
+    const parser = parse(`var {
+      value = "email"
+      description = "The user's email address"
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("varFn expect an as variable to be an identifier", () => {
+    const parser = parse(`var "user" {
+      value = "email"
+      description = "The user's email address"
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("varFn can update a value", () => {
+    const parser = parse(`var.update $user.foo {
+      value = "email"
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should allow accessing a property from an object defined in place", () => {
+    let parser = parse(`var $config {
+      value = {
+        api_key: "12345",
+        timeout: 30
+      }.api_key
+      description = "API key from config"
+    }`);
+    expect(parser.errors).to.be.empty;
+
+    parser = parse(`var $config {
+      value = {
+        api_key: "12345",
+        timeout: 30
+      }["api_key"]
+      description = "API key from config"
+    }`);
+    expect(parser.errors).to.be.empty;
+
+    parser = parse(`var $config {
+      value = {
+        api_key: "12345",
+        timeout: 30
+      }.["api_key"]
+      description = "API key from config"
+    }`);
+    expect(parser.errors).to.be.empty;
+
+    parser = parse(`var $config {
+      value = {
+        api_key: "12345",
+        timeout: 30
+      }.api-key
+      description = "API key from config"
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("should allow accessing an index from an array defined in place", () => {
+    let parser = parse(`var $config {
+      value = [1,2,3].0
+      description = "API key from config"
+    }`);
+    expect(parser.errors).to.be.empty;
+
+    parser = parse(`var $config {
+      value = [1,2,3][1]
+      description = "API key from config"
+    }`);
+    expect(parser.errors).to.be.empty;
+
+    parser = parse(`var $config {
+      value = [1,2,3].[1]
+      description = "API key from config"
+    }`);
+    expect(parser.errors).to.be.empty;
+
+    parser = parse(`var $config {
+      value = [1,2,3][$index]
+      description = "API key from config"
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+});

package/parser/functions/webflowFn.js

@@ -0,0 +1,19 @@
+import { WebflowToken } from "../../lexer/api.js";
+import { DotToken } from "../../lexer/tokens.js";
+
+/**
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export function webflowFn($) {
+  return () => {
+    $.sectionStack.push("webflow");
+    $.CONSUME(WebflowToken); // "webflow"
+    $.CONSUME(DotToken); // "."
+    $.OR([
+      {
+        ALT: () => $.SUBRULE($.webflowRequestFn), // "webflow.request"
+      },
+    ]);
+    $.sectionStack.pop();
+  };
+}