@xano/xanoscript-language-server 11.0.3

package/parser/functions/stream/streamFromCsvFn.spec.js

@@ -0,0 +1,69 @@
+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.streamFromCsvFn();
+  return parser;
+}
+
+describe("stream.from_csv", () => {
+  it("Check from_csv is taking required params", () => {
+    const input = `from_csv {
+      value = $file
+      separator = ","
+      enclosure = "'"
+      escape_char = "'"
+    } as $stream_1`;
+    const parser = parse(input);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("Check from_csv is missing required params", () => {
+    const input = `from_csv {
+      value = ""
+      separator = ","
+    } as $stream_1`;
+    const parser = parse(input);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("Check from_csv has duplicate attributes", () => {
+    const input = `from_csv {
+      value = $file
+      value = $another_file
+      separator = ","
+      enclosure = "'"
+      escape_char = "'"
+    } as $stream_1`;
+    const parser = parse(input);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("Check from_csv has illegal attributes", () => {
+    const input = `from_csv {
+      value = $file
+      separator = ","
+      enclosure = "'"
+      escape_char = "'"
+      illegalAttr = "value"
+    } as $stream_1`;
+    const parser = parse(input);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("Check from_csv with different separator", () => {
+    const input = `from_csv {
+      value = $file
+      separator = ";"
+      enclosure = "'"
+      escape_char = "'"
+    } as $stream_1`;
+    const parser = parse(input);
+    expect(parser.errors).to.be.empty;
+  });
+});

package/parser/functions/stream/streamFromJsonlFn.js

@@ -0,0 +1,21 @@
+import { FromJsonlToken } from "../../../lexer/stream.js";
+
+/**
+ * represent $var.x or $x, the only format accepting an assigment
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export function streamFromJsonlFn($) {
+  const requiredAttrs = ["value"];
+  const optionalAttrs = ["description", "disabled"];
+
+  return () => {
+    $.sectionStack.push("streamFromJsonl");
+    const fnToken = $.CONSUME(FromJsonlToken); // from_jsonl
+    $.SUBRULE($.functionAttrReq, {
+      ARGS: [fnToken, requiredAttrs, optionalAttrs],
+    });
+    $.SUBRULE($.asVariable, { ARGS: [fnToken] });
+
+    $.sectionStack.pop();
+  };
+}

package/parser/functions/stream/streamFromJsonlFn.spec.js

@@ -0,0 +1,47 @@
+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.streamFromJsonlFn();
+  return parser;
+}
+
+describe("stream.from_jsonl", () => {
+  it("Check from_jsonl is taking required params", () => {
+    const input = `from_jsonl {
+      value = $jsonl_file_resource
+    } as $stream1`;
+    const parser = parse(input);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("Check from_jsonl is missing required params", () => {
+    const input = `from_jsonl {
+    } as $stream1`;
+    const parser = parse(input);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("Check from_jsonl has duplicate attributes", () => {
+    const input = `from_jsonl {
+      value = $jsonl_file_resource
+      value = $another_jsonl_file
+    } as $stream1`;
+    const parser = parse(input);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("Check from_jsonl has illegal attributes", () => {
+    const input = `from_jsonl {
+      value = $jsonl_file_resource
+      illegalAttr = "value"
+    } as $stream1`;
+    const parser = parse(input);
+    expect(parser.errors).to.not.be.empty;
+  });
+});

package/parser/functions/stream/streamFromRequestFn.js

@@ -0,0 +1,50 @@
+import { FromRequestToken } from "../../../lexer/stream.js";
+
+/**
+ * stream.from_request {
+      url = "https://api.example.com/webhook"
+      method = "GET"
+      params = {}
+      headers = []
+      timeout = 10
+      follow_location = true
+      verify_host = false
+      verify_peer = false
+      ca_certificate = ""
+      certificate = ""
+      certificate_pass = ""
+      private_key = ""
+      private_key_pass = ""
+    } as stream1
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export function streamFromRequestFn($) {
+  return () => {
+    $.sectionStack.push("streamFromRequest");
+    const fnToken = $.CONSUME(FromRequestToken); // from_request
+    $.SUBRULE($.schemaParseAttributeFn, {
+      ARGS: [
+        fnToken,
+        {
+          url: "[expression]",
+          method: "[expression]",
+          "params?": "[expression]",
+          "headers?": "[expression]",
+          "timeout?": "[expression]",
+          "follow_location?": "[expression]",
+          "description?": "[string]",
+          "disabled?": "[boolean]",
+          "verify_host?": "[expression]",
+          "verify_peer?": "[expression]",
+          "ca_certificate?": "[expression]",
+          "certificate?": "[expression]",
+          "certificate_pass?": "[expression]",
+          "private_key?": "[expression]",
+          "private_key_pass?": "[expression]",
+        },
+      ],
+    });
+    $.SUBRULE($.asVariable, { ARGS: [fnToken] });
+    $.sectionStack.pop();
+  };
+}

package/parser/functions/stream/streamFromRequestFn.spec.js

@@ -0,0 +1,103 @@
+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.streamFromRequestFn();
+  return parser;
+}
+
+describe("stream.from_request", () => {
+  it("works with minimal parameters", () => {
+    const input = `from_request {
+      url = "https://api.example.com/webhook"
+      method = "GET"
+      params = {}|set:"my_var":"my_value"
+      headers = []
+      timeout = 10
+      follow_location = true
+    } as $stream_1`;
+    const parser = parse(input);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("works with all params", () => {
+    const input = `from_request {
+      url = "https://api.example.com/webhook"
+      method = "GET"
+      params = {}|set:"my_var":"my_value"
+      headers = []
+      timeout = 10
+      follow_location = true
+      verify_host = false
+      verify_peer = false
+      ca_certificate = ""
+      certificate = ""
+      certificate_pass = ""
+      private_key = ""
+      private_key_pass = ""
+    } as $stream_1`;
+    const parser = parse(input);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("has duplicate attributes", () => {
+    const input = `from_request {
+      url = "https://api.example.com/webhook"
+      url = "https://google.com.site/"
+      method = "GET"
+      params = {}|set:"my_var":"my_value"
+      headers = []
+      timeout = 10
+      follow_location = true
+    } as $stream_1`;
+    const parser = parse(input);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("rejects illegal attributes", () => {
+    const input = `from_request {
+      url = "https://api.example.com/webhook"
+      method = "GET"
+      params = {}|set:"my_var":"my_value"
+      headers = []
+      timeout = 10
+      follow_location = true
+      illegalAttr = "value"
+    } as $stream_1`;
+    const parser = parse(input);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("can be disabled", () => {
+    const input = `from_request {
+      url = "https://api.example.com/webhook"
+      method = "GET"
+      params = {}|set:"my_var":"my_value"
+      headers = []
+      timeout = 10
+      follow_location = true
+      disabled = true
+    } as $stream_1`;
+    const parser = parse(input);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("accepts a description", () => {
+    const input = `from_request {
+      url = "https://api.example.com/webhook"
+      method = "GET"
+      params = {}|set:"my_var":"my_value"
+      headers = []
+      timeout = 10
+      follow_location = true
+      description = "foo"
+    } as $stream_1`;
+    const parser = parse(input);
+    expect(parser.errors).to.be.empty;
+  });
+});

package/parser/functions/streamFn.js

@@ -0,0 +1,19 @@
+import { StreamToken } from "../../lexer/stream.js";
+import { DotToken } from "../../lexer/tokens.js";
+
+/**
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export function streamFn($) {
+  return () => {
+    $.sectionStack.push("stream");
+    $.CONSUME(StreamToken); // "stream"
+    $.CONSUME(DotToken); // "."
+    $.OR([
+      { ALT: () => $.SUBRULE($.streamFromCsvFn) }, // from_csv
+      { ALT: () => $.SUBRULE($.streamFromJsonlFn) }, // from_jsonl
+      { ALT: () => $.SUBRULE($.streamFromRequestFn) }, // from_request
+    ]);
+    $.sectionStack.pop();
+  };
+}

package/parser/functions/text/allTextWithReturnValueFn.js

@@ -0,0 +1,36 @@
+import {
+  ContainsToken,
+  EndsWithToken,
+  IContainsToken,
+  IEndsWithToken,
+  IStartsWithToken,
+  StartsWithToken,
+} from "../../../lexer/text.js";
+
+/**
+ * text.contains $x1 {
+ *   value = "Hello"
+ * } as $x2
+ * @param {import('../../base_parser.js').XanoBaseParser} $
+ */
+export function allTextWithReturnValueFn($) {
+  return () => {
+    const requiredAttrs = ["value"];
+    const optionalAttrs = ["description", "disabled"];
+    $.sectionStack.push("allTextWithReturnValueFn");
+    const fnToken = $.OR([
+      { ALT: () => $.CONSUME(ContainsToken) },
+      { ALT: () => $.CONSUME(EndsWithToken) },
+      { ALT: () => $.CONSUME(IContainsToken) },
+      { ALT: () => $.CONSUME(IEndsWithToken) },
+      { ALT: () => $.CONSUME(IStartsWithToken) },
+      { ALT: () => $.CONSUME(StartsWithToken) },
+    ]);
+    $.SUBRULE($.assignableVariableProperty); // $x1
+    $.SUBRULE($.functionAttrReq, {
+      ARGS: [fnToken, requiredAttrs, optionalAttrs],
+    });
+    $.SUBRULE($.asVariable, { ARGS: [fnToken] });
+    $.sectionStack.pop();
+  };
+}

package/parser/functions/text/allTextWithReturnValueFn.spec.js

@@ -0,0 +1,100 @@
+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.allTextWithReturnValueFn();
+  return parser;
+}
+
+describe("allTextWithReturnValueFn", () => {
+  it("allTextWithReturnValueFn accepts a value", () => {
+    const parser = parse(`starts_with $x1 {
+      value = "text"
+    } as $starts_with`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("allTextWithReturnValueFn requires a value", () => {
+    const parser = parse(`starts_with $x1 {
+      description = "foo"
+    } as $starts_with`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("allTextWithReturnValueFn accepts a description", () => {
+    const parser = parse(`starts_with $x1 {
+      value = "text"
+      description = "foo"
+    } as $starts_with`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("allTextWithReturnValueFn can be disabled", () => {
+    const parser = parse(`starts_with $x1 {
+      value = "text"
+      disabled = true
+    } as $starts_with`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("allTextWithReturnValueFn accepts a long form variable", () => {
+    const parser = parse(`starts_with $var.x1 {
+      value = "text"
+    } as $starts_with`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("allTextWithReturnValueFn accepts an attribute for assignment", () => {
+    const parser = parse(`starts_with $x1.bar {
+      value = "text"
+    } as $starts_with`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("allTextWithReturnValueFn can parse starts_with", () => {
+    const parser = parse(`starts_with $x1 {
+      value = "text"
+    } as $starts_with`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("allTextWithReturnValueFn can parse ends_with", () => {
+    const parser = parse(`ends_with $x1 {
+      value = "text"
+    } as $ends_with`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("allTextWithReturnValueFn can parse contains", () => {
+    const parser = parse(`contains $x1 {
+      value = "text"
+    } as $contains`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("allTextWithReturnValueFn can parse istarts_with", () => {
+    const parser = parse(`istarts_with $x1 {
+      value = "text"
+    } as $istarts_with`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("allTextWithReturnValueFn can parse iends_with", () => {
+    const parser = parse(`iends_with $x1 {
+      value = "text"
+    } as $iends_with`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("allTextWithReturnValueFn can parse icontains", () => {
+    const parser = parse(`icontains $x1 {
+      value = "text"
+    } as $icontains`);
+    expect(parser.errors).to.be.empty;
+  });
+});

package/parser/functions/text/allTextWithoutReturnValueFn.js

@@ -0,0 +1,34 @@
+import {
+  AppendToken,
+  LTrimToken,
+  PrependToken,
+  RTrimToken,
+  TrimToken,
+} from "../../../lexer/text.js";
+
+/**
+ * append $x1 {
+ *   value = "text"
+ * }
+ * @param {import('../../base_parser.js').XanoBaseParser} $
+ */
+export function allTextWithoutReturnValueFn($) {
+  return () => {
+    const requiredAttrs = ["value"];
+    const optionalAttrs = ["description", "disabled"];
+
+    $.sectionStack.push("allTextWithoutReturnValueFn");
+    const fnToken = $.OR([
+      { ALT: () => $.CONSUME(AppendToken) }, // append
+      { ALT: () => $.CONSUME(LTrimToken) }, // ltrim
+      { ALT: () => $.CONSUME(PrependToken) }, // prepend
+      { ALT: () => $.CONSUME(RTrimToken) }, // rtrim
+      { ALT: () => $.CONSUME(TrimToken) }, // trim
+    ]);
+    $.SUBRULE($.assignableVariableProperty); // $x1
+    $.SUBRULE($.functionAttrReq, {
+      ARGS: [fnToken, requiredAttrs, optionalAttrs],
+    });
+    $.sectionStack.pop();
+  };
+}

package/parser/functions/text/allTextWithoutReturnValueFn.spec.js

@@ -0,0 +1,122 @@
+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.allTextWithoutReturnValueFn();
+  return parser;
+}
+
+function parseFull(inputText) {
+  parser.reset();
+  const lexResult = lexDocument(inputText);
+  parser.input = lexResult.tokens;
+  parser.textFn();
+  return parser;
+}
+
+describe("allTextWithoutReturnValueFn", () => {
+  it("allTextWithoutReturnValueFn accepts a value", () => {
+    const parser = parse(`trim $x1 {
+      value = "text"
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("allTextWithoutReturnValueFn requires a value", () => {
+    const parser = parse(`trim $x1 {
+      description = "foo"
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("allTextWithoutReturnValueFn accepts a description", () => {
+    const parser = parse(`trim $x1 {
+      value = "text"
+      description = "foo"
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("allTextWithoutReturnValueFn can be disabled", () => {
+    const parser = parse(`trim $x1 {
+      value = "text"
+      disabled = true
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("allTextWithoutReturnValueFn accepts a long form variable", () => {
+    const parser = parse(`trim $var.x1 {
+      value = "text"
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("allTextWithoutReturnValueFn accepts an attribute for assignment", () => {
+    const parser = parse(`trim $x1.bar {
+      value = "text"
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("allTextWithoutReturnValueFn can parse ltrim", () => {
+    const parser = parse(`ltrim $x1 {
+      value = "text"
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("allTextWithoutReturnValueFn can parse rtrim", () => {
+    const parser = parse(`rtrim $x1 {
+      value = "text"
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("allTextWithoutReturnValueFn can parse trim", () => {
+    const parser = parse(`trim $x1 {
+      value = "text"
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("allTextWithoutReturnValueFn can parse prepend", () => {
+    const parser = parse(`prepend $x1 {
+      value = "text"
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("allTextWithoutReturnValueFn can parse append", () => {
+    const parser = parse(`append $x1 {
+      value = "text"
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("allTextWithoutReturnValueFn doesn't require as $var", () => {
+    const parser = parse(`append $x1 {
+      value = "text"
+    } as $append`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("allTextWithoutReturnValueFn works with text. namespace", () => {
+    const parser = parseFull(`text.trim $x1 {
+      value = "text"
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("allTextWithoutReturnValueFn errors without text. namespace", () => {
+    const parser = parseFull(`trim $x1 {
+      value = "text"
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+});

package/parser/functions/text/register.js

@@ -0,0 +1,17 @@
+import { allTextWithoutReturnValueFn } from "./allTextWithoutReturnValueFn.js";
+import { allTextWithReturnValueFn } from "./allTextWithReturnValueFn.js";
+
+/**
+ * Registers all the parsers in this folder
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export const register = ($) => {
+  $.allTextWithoutReturnValueFn = $.RULE(
+    "allTextWithoutReturnValueFn",
+    allTextWithoutReturnValueFn($)
+  );
+  $.allTextWithReturnValueFn = $.RULE(
+    "allTextWithReturnValueFn",
+    allTextWithReturnValueFn($)
+  );
+};

package/parser/functions/textFn.js

@@ -0,0 +1,33 @@
+import { TextToken } from "../../lexer/columns.js";
+import { DotToken } from "../../lexer/tokens.js";
+
+/**
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export function textFn($) {
+  return () => {
+    $.sectionStack.push("text");
+    $.CONSUME(TextToken); // "text"
+    $.CONSUME(DotToken); // "."
+    const nextToken = $.LA(1).image; // Get the next token
+    // Group 1: Functions related to text searching and matching, these functions return a value
+    const group1 = [
+      "contains",
+      "ends_with",
+      "icontains",
+      "iends_with",
+      "istarts_with",
+      "starts_with",
+    ];
+
+    // Group 2: Functions related to text manipulation, these functions do not return a value
+    const group2 = ["append", "ltrim", "prepend", "rtrim", "trim"];
+
+    if (group1.includes(nextToken)) {
+      $.SUBRULE($.allTextWithReturnValueFn);
+    } else if (group2.includes(nextToken)) {
+      $.SUBRULE($.allTextWithoutReturnValueFn);
+    }
+    $.sectionStack.pop();
+  };
+}