@xano/xanoscript-language-server 11.0.3

package/parser/functions/storage/storageCreateFileResourceFn.spec.js

@@ -0,0 +1,72 @@
+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.storageCreateFileResourceFn();
+  return parser;
+}
+
+describe("storage.create_file_resource", () => {
+  it("Check create_file_resource is accepts a filedata and a filename", () => {
+    const parser = parse(`create_file_resource {
+      filename = "my_file.txt"
+      filedata = $file_content
+    } as $file_resource`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("create_file_resource requires a filedata", () => {
+    const parser = parse(`create_file_resource {
+      filename = "my_file.txt"
+    } as $file_resource`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("create_file_resource requires a filename", () => {
+    const parser = parse(`create_file_resource {
+      filedata = $file_content
+    } as $file_resource`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("create_file_resource rejects duplicate attributes", () => {
+    const parser = parse(`create_file_resource {
+      filename = "my_file.txt"
+      filedata = $file_content
+      filedata = $input.other_image
+    } as $file_resource`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("create_file_resource rejects illegal attributes", () => {
+    const parser = parse(`create_file_resource {
+      filename = "my_file.txt"
+      filedata = $file_content
+      illegalAttr = "value"
+    } as $file_resource`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("create_file_resource accepts description attribute", () => {
+    const parser = parse(`create_file_resource {
+      filename = "my_file.txt"
+      filedata = $file_content
+      description = "A description"
+    } as $file_resource`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("create_file_resource accepts disabled attribute", () => {
+    const parser = parse(`create_file_resource {
+      filename = "my_file.txt"
+      filedata = $file_content
+      disabled = true
+    } as $file_resource`);
+    expect(parser.errors).to.be.empty;
+  });
+});

package/parser/functions/storage/storageCreateImageFn.js

@@ -0,0 +1,25 @@
+import { CreateImageToken } from "../../../lexer/storage.js";
+
+/**
+ * @param {import('../../base_parser.js').XanoBaseParser} $
+ */
+export function storageCreateImageFn($) {
+  return () => {
+    $.sectionStack.push("storageCreateImageFn");
+    const fnToken = $.CONSUME(CreateImageToken); // "create_image"
+    $.SUBRULE($.schemaParseAttributeFn, {
+      ARGS: [
+        fnToken,
+        {
+          value: "[expression]",
+          access: ["public", "private"],
+          filename: "[expression]",
+          "description?": "[string]",
+          "disabled?": "[boolean]",
+        },
+      ],
+    });
+    $.SUBRULE($.asVariable, { ARGS: [fnToken] });
+    $.sectionStack.pop();
+  };
+}

package/parser/functions/storage/storageCreateImageFn.spec.js

@@ -0,0 +1,98 @@
+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.storageCreateImageFn();
+  return parser;
+}
+
+describe("storage.create_image", () => {
+  it("Check create_image is accepts a value and a filename", () => {
+    const parser = parse(`create_image {
+      access = "private"
+      value = $input.image
+      filename = "image.jpg"
+    } as $image`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("create_image requires a value", () => {
+    const parser = parse(`create_image {
+      access = "public"
+      filename = "my_file.txt"
+    } as $image`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("create_image requires a filename", () => {
+    const parser = parse(`create_image {
+      access = "public"
+      value = $input.image
+    } as $image`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("create_image rejects duplicate attributes", () => {
+    const parser = parse(`create_image {
+      access = "private"
+      value = $input.image
+      value = $input.other_image
+    } as $image`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("create_image rejects illegal attributes", () => {
+    const parser = parse(`create_image {
+      value = $input.image
+      filename = "image.jpg"
+      illegalAttr = "value"
+      access = "private"
+    } as $image`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("create_image accepts description attribute", () => {
+    const parser = parse(`create_image {
+      value = $input.image
+      access = "private"
+      filename = "image.jpg"
+      description = "A description"
+    } as $image`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("create_image accepts disabled attribute", () => {
+    const parser = parse(`create_image {
+      value = $input.image
+      access = "private"
+      filename = "image.jpg"
+      disabled = true
+    } as $image`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("create_image reject invalid access", () => {
+    const parser = parse(`create_image {
+      value = $input.image
+      filename = "image.jpg"
+      access = "unknown"
+      disabled = true
+    } as $image`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("create_image reject missing access", () => {
+    const parser = parse(`create_image {
+      value = $input.image
+      key = "list"
+      filename = "image.jpg"
+      disabled = true
+    } as $image`);
+    expect(parser.errors).to.not.be.empty;
+  });
+});

package/parser/functions/storage/storageCreateVideoFn.js

@@ -0,0 +1,29 @@
+import { CreateVideoToken } from "../../../lexer/storage.js";
+
+/**
+ * storage.create_video {
+ *   value = !input "file"
+ *   access = "public"
+ *   filename = !text ""
+ * } as $x4
+ */
+export function storageCreateVideoFn($) {
+  return () => {
+    $.sectionStack.push("storageCreateVideoFn");
+    const parent = $.CONSUME(CreateVideoToken); // "create_video"
+    $.SUBRULE($.schemaParseAttributeFn, {
+      ARGS: [
+        parent,
+        {
+          value: "[expression]",
+          "access?": ["public", "private"],
+          "filename?": "[expression]",
+          "description?": "[string]",
+          "disabled?": "[boolean]",
+        },
+      ],
+    });
+    $.SUBRULE($.asVariable, { ARGS: [parent] });
+    $.sectionStack.pop();
+  };
+}

package/parser/functions/storage/storageCreateVideoFn.spec.js

@@ -0,0 +1,99 @@
+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.storageCreateVideoFn();
+  return parser;
+}
+
+describe("storage.create_video", () => {
+  it("Check create_video is accepts a value and a filename", () => {
+    const parser = parse(`create_video {
+      access = "private"
+      value = $input.video
+      filename = "video.mpg"
+    } as $video`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("create_video requires a value", () => {
+    const parser = parse(`create_video {
+      access = "public"
+      filename = "my_file.txt"
+    } as $video`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("create_video does not require a filename", () => {
+    const parser = parse(`create_video {
+      access = "public"
+      value = $input.video
+    } as $video`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("create_video rejects duplicate attributes", () => {
+    const parser = parse(`create_video {
+      access = "private"
+      value = $input.video
+      value = $input.other_video
+    } as $video`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("create_video rejects illegal attributes", () => {
+    const parser = parse(`create_video {
+      value = $input.video
+      filename = "video.mpg"
+      illegalAttr = "value"
+      access = "private"
+    } as $video`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("create_video accepts description attribute", () => {
+    const parser = parse(`create_video {
+      value = $input.video
+      access = "private"
+      filename = "video.mpg"
+      description = "A description"
+    } as $video`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("create_video accepts disabled attribute", () => {
+    const parser = parse(`create_video {
+      value = $input.video
+      access = "private"
+      filename = "video.mpg"
+      disabled = true
+    } as $video`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("create_video reject invalid access", () => {
+    // TODO: fix the implementation to support this case
+    const parser = parse(`create_video {
+      value = $input.video
+      filename = "video.mpg"
+      access = "unknown"
+      disabled = true
+    } as $video`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("create_video reject missing access", () => {
+    const parser = parse(`create_video {
+      value = $input.video
+      key = "list"
+      filename = "video.mpg"
+      disabled = true
+    } as $video`);
+    expect(parser.errors).to.not.be.empty;
+  });
+});

package/parser/functions/storage/storageDeleteFileFn.js

@@ -0,0 +1,17 @@
+import { DeleteFileToken } from "../../../lexer/storage.js";
+/**
+ * @param {import('../../base_parser.js').XanoBaseParser} $
+ */
+export function storageDeleteFileFn($) {
+  return () => {
+    const requiredAttrs = ["pathname"];
+    const optionalAttrs = ["description", "disabled"];
+
+    $.sectionStack.push("storageDeleteFileFn");
+    const fnToken = $.CONSUME(DeleteFileToken); // "delete_file"
+    $.SUBRULE($.functionAttrReq, {
+      ARGS: [fnToken, requiredAttrs, optionalAttrs],
+    });
+    $.sectionStack.pop();
+  };
+}

package/parser/functions/storage/storageDeleteFileFn.spec.js

@@ -0,0 +1,67 @@
+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.storageDeleteFileFn();
+  return parser;
+}
+
+describe("storage.delete_file", () => {
+  it("Check delete_file is accepts a pathname", () => {
+    const parser = parse(`delete_file {
+      pathname = "foo_bar.txt"
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("delete_file requires a pathname", () => {
+    const parser = parse(`delete_file {
+      description = "A description"
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("delete_file rejects duplicate attributes", () => {
+    const parser = parse(`delete_file {
+      pathname = "foo_bar.txt"
+      pathname = "other_file.txt"
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("delete_file rejects illegal attributes", () => {
+    const parser = parse(`delete_file {
+      pathname = "foo_bar.txt"
+      illegalAttr = "value"
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("delete_file does not accept 'as' var keyword", () => {
+    const parser = parse(`delete_file {
+      pathname = "foo_bar.txt"
+    } as $deleted_file`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("delete_file accepts description attribute", () => {
+    const parser = parse(`delete_file {
+      pathname = "foo_bar.txt"
+      description = "A description"
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("delete_file accepts disabled attribute", () => {
+    const parser = parse(`delete_file {
+      pathname = "foo_bar.txt"
+      disabled = true
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+});

package/parser/functions/storage/storageReadFileResourceFn.js

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

package/parser/functions/storage/storageReadFileResourceFn.spec.js

@@ -0,0 +1,60 @@
+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.storageReadFileResourceFn();
+  return parser;
+}
+
+describe("storage.read_file_resource", () => {
+  it("Check read_file_resource is accepts a value and a filename", () => {
+    const parser = parse(`read_file_resource {
+      value = $input.image
+    } as $file_resource`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("read_file_resource requires a value", () => {
+    const parser = parse(`read_file_resource {
+      description = "my_file.txt"
+    } as $file_resource`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("read_file_resource rejects duplicate attributes", () => {
+    const parser = parse(`read_file_resource {
+      value = $input.image
+      value = $input.other_image
+    } as $file_resource`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("read_file_resource rejects illegal attributes", () => {
+    const parser = parse(`read_file_resource {
+      value = $input.image
+      illegalAttr = "value"
+    } as $file_resource`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("read_file_resource accepts description attribute", () => {
+    const parser = parse(`read_file_resource {
+      value = $input.image
+      description = "A description"
+    } as $file_resource`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("read_file_resource accepts disabled attribute", () => {
+    const parser = parse(`read_file_resource {
+      value = $input.image
+      disabled = true
+    } as $file_resource`);
+    expect(parser.errors).to.be.empty;
+  });
+});

package/parser/functions/storage/storageSignPrivateUrlFn.js

@@ -0,0 +1,19 @@
+import { SignPrivateUrlToken } from "../../../lexer/storage.js";
+
+/**
+ * @param {import('../../base_parser.js').XanoBaseParser} $
+ */
+export function storageSignPrivateUrlFn($) {
+  return () => {
+    const requiredAttrs = ["pathname", "ttl"];
+    const optionalAttrs = ["description", "disabled"];
+
+    $.sectionStack.push("storageSignPrivateUrlFn");
+    const fnToken = $.CONSUME(SignPrivateUrlToken); // "sign_private_url"
+    $.SUBRULE($.functionAttrReq, {
+      ARGS: [fnToken, requiredAttrs, optionalAttrs],
+    });
+    $.SUBRULE($.asVariable, { ARGS: [fnToken] });
+    $.sectionStack.pop();
+  };
+}

package/parser/functions/storage/storageSignPrivateUrlFn.spec.js

@@ -0,0 +1,72 @@
+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.storageSignPrivateUrlFn();
+  return parser;
+}
+
+describe("storage.sign_private_url", () => {
+  it("Check sign_private_url is accepts a pathname and a ttl", () => {
+    const parser = parse(`sign_private_url {
+      pathname = "foo_bar.txt"
+      ttl = 30
+    } as $signed_url`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("sign_private_url requires a ttl", () => {
+    const parser = parse(`sign_private_url {
+      pathname = "foo_bar.txt"
+    } as $signed_url`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("sign_private_url requires a pathname", () => {
+    const parser = parse(`sign_private_url {
+      ttl = 30
+    } as $signed_url`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("sign_private_url rejects duplicate attributes", () => {
+    const parser = parse(`sign_private_url {
+      pathname = "foo_bar.txt"
+      ttl = 30
+      ttl = 15
+    } as $signed_url`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("sign_private_url rejects illegal attributes", () => {
+    const parser = parse(`sign_private_url {
+      pathname = "foo_bar.txt"
+      ttl = 30
+      illegalAttr = "value"
+    } as $signed_url`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("sign_private_url accepts description attribute", () => {
+    const parser = parse(`sign_private_url {
+      pathname = "foo_bar.txt"
+      ttl = 30
+      description = "A description"
+    } as $signed_url`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("sign_private_url accepts disabled attribute", () => {
+    const parser = parse(`sign_private_url {
+      pathname = "foo_bar.txt"
+      ttl = 30
+      disabled = true
+    } as $signed_url`);
+    expect(parser.errors).to.be.empty;
+  });
+});

package/parser/functions/storageFn.js

@@ -0,0 +1,24 @@
+import { StorageToken } from "../../lexer/storage.js";
+import { DotToken } from "../../lexer/tokens.js";
+
+/**
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export function storageFn($) {
+  return () => {
+    $.sectionStack.push("storage");
+    $.CONSUME(StorageToken); // "storage"
+    $.CONSUME(DotToken); // "."
+    $.OR([
+      { ALT: () => $.SUBRULE($.storageCreateAttachmentFn) }, // storage.create_attachment
+      { ALT: () => $.SUBRULE($.storageCreateFileResourceFn) }, // storage.create_file_resource
+      { ALT: () => $.SUBRULE($.storageCreateImageFn) }, // storage.create_image
+      { ALT: () => $.SUBRULE($.storageDeleteFileFn) }, // storage.delete_file
+      { ALT: () => $.SUBRULE($.storageReadFileResourceFn) }, // storage.read_file_resource
+      { ALT: () => $.SUBRULE($.storageSignPrivateUrlFn) }, // storage.sign_private_url
+      { ALT: () => $.SUBRULE($.storageCreateAudioFn) }, // storage.create_audio
+      { ALT: () => $.SUBRULE($.storageCreateVideoFn) }, // storage.create_video
+    ]);
+    $.sectionStack.pop();
+  };
+}

package/parser/functions/stream/register.js

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

package/parser/functions/stream/streamFromCsvFn.js

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