@xano/xanoscript-language-server 11.0.3

package/parser/functions/db/dbTruncateFn.spec.js

@@ -0,0 +1,42 @@
+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.dbTruncateFn();
+  return parser;
+}
+
+describe("dbTruncateFn", () => {
+  it("dbTruncateFn accepts a reset", () => {
+    const parser = parse(`truncate user {
+      reset = true
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("dbTruncateFn can be disabled", () => {
+    const parser = parse(`truncate user {
+      reset = false
+      disabled = true
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("dbTruncateFn accepts a description", () => {
+    const parser = parse(`truncate user {
+      reset = true
+      description = "get the user's email truncate"
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("dbTruncateFn does not require a reset", () => {
+    const parser = parse(`truncate user`);
+    expect(parser.errors).to.be.empty;
+  });
+});

package/parser/functions/db/register.js

@@ -0,0 +1,52 @@
+import { dbAddFn } from "./dbAddFn.js";
+import { dbAddonAttr } from "./dbAddonAttr.js";
+import { dbAddOrEditFn } from "./dbAddOrEditFn.js";
+import { dbBulkAddFn } from "./dbBulkAddFn.js";
+import { dbBulkDeleteFn } from "./dbBulkDeleteFn.js";
+import { dbBulkFn } from "./dbBulkFn.js";
+import { dbBulkPatchFn } from "./dbBulkPatchFn.js";
+import { dbBulkUpdateFn } from "./dbBulkUpdateFn.js";
+import { dbDelFn } from "./dbDelFn.js";
+import { dbDirectQueryFn } from "./dbDirectQueryFn.js";
+import { dbEditFn } from "./dbEditFn.js";
+import { dbExternalDirectQueryFn } from "./dbExternalDirectQueryFn.js";
+import { dbExternalFn } from "./dbExternalFn.js";
+import { dbGetFn } from "./dbGetFn.js";
+import { dbHasFn } from "./dbHasFn.js";
+import { dbPatchFn } from "./dbPatchFn.js";
+import { dbQueryFn } from "./dbQueryFn.js";
+import { dbSchemaFn } from "./dbSchemaFn.js";
+import { dbSetDatasourceFn } from "./dbSetDatasourceFn.js";
+import { dbTransactionFn } from "./dbTransactionFn.js";
+import { dbTruncateFn } from "./dbTruncateFn.js";
+
+/**
+ * Registers all the parsers in this folder
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export const register = ($) => {
+  $.dbAddFn = $.RULE("dbAddFn", dbAddFn($));
+  $.dbBulkFn = $.RULE("dbBulkFn", dbBulkFn($));
+  $.dbBulkAddFn = $.RULE("dbBulkAddFn", dbBulkAddFn($));
+  $.dbBulkDeleteFn = $.RULE("dbBulkDeleteFn", dbBulkDeleteFn($));
+  $.dbBulkUpdateFn = $.RULE("dbBulkUpdateFn", dbBulkUpdateFn($));
+  $.dbBulkPatchFn = $.RULE("dbBulkPatchFn", dbBulkPatchFn($));
+  $.dbDelFn = $.RULE("dbDelFn", dbDelFn($));
+  $.dbDirectQueryFn = $.RULE("dbDirectQueryFn", dbDirectQueryFn($));
+  $.dbEditFn = $.RULE("dbEditFn", dbEditFn($));
+  $.dbExternalDirectQueryFn = $.RULE(
+    "dbExternalDirectQueryFn",
+    dbExternalDirectQueryFn($)
+  );
+  $.dbExternalFn = $.RULE("dbExternalFn", dbExternalFn($));
+  $.dbGetFn = $.RULE("dbGetFn", dbGetFn($));
+  $.dbHasFn = $.RULE("dbHasnpmFn", dbHasFn($));
+  $.dbPatchFn = $.RULE("dbPatchFn", dbPatchFn($));
+  $.dbQueryFn = $.RULE("dbQueryFn", dbQueryFn($));
+  $.dbSchemaFn = $.RULE("dbSchemaFn", dbSchemaFn($));
+  $.dbSetDatasourceFn = $.RULE("dbSetDatasourceFn", dbSetDatasourceFn($));
+  $.dbTransactionFn = $.RULE("dbTransactionFn", dbTransactionFn($));
+  $.dbTruncateFn = $.RULE("dbTruncateFn", dbTruncateFn($));
+  $.dbAddOrEditFn = $.RULE("dbAddOrEditFn", dbAddOrEditFn($));
+  $.dbAddonAttr = $.RULE("dbAddonAttr", dbAddonAttr($));
+};

package/parser/functions/db/schema.js

@@ -0,0 +1,8 @@
+export const addonSchema = {
+  name: "[string]",
+  "input?": { "[string]": "[expression]" },
+  "as?": "[string]",
+  "output?": ["[string]"],
+};
+// allow for sub addons
+addonSchema["addon?"] = [addonSchema];

package/parser/functions/dbFn.js

@@ -0,0 +1,31 @@
+import { DbToken } from "../../lexer/db.js";
+import { DotToken } from "../../lexer/tokens.js";
+
+/**
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export function dbFn($) {
+  return () => {
+    $.sectionStack.push("db");
+    $.CONSUME(DbToken); // "db"
+    $.CONSUME(DotToken); // "."
+    $.OR([
+      { ALT: () => $.SUBRULE($.dbExternalFn) }, // "db.external"
+      { ALT: () => $.SUBRULE($.dbGetFn) }, // "db.get"
+      { ALT: () => $.SUBRULE($.dbHasFn) }, // "db.has"
+      { ALT: () => $.SUBRULE($.dbEditFn) }, // "db.edit"
+      { ALT: () => $.SUBRULE($.dbDelFn) }, // "db.delete"
+      { ALT: () => $.SUBRULE($.dbAddFn) }, // "db.add"
+      { ALT: () => $.SUBRULE($.dbDirectQueryFn) }, // "db.direct_query"
+      { ALT: () => $.SUBRULE($.dbSetDatasourceFn) }, // "db.set_datasource"
+      { ALT: () => $.SUBRULE($.dbQueryFn) }, // "db.query"
+      { ALT: () => $.SUBRULE($.dbSchemaFn) }, // "db.schema"
+      { ALT: () => $.SUBRULE($.dbTruncateFn) }, // "db.truncate"
+      { ALT: () => $.SUBRULE($.dbTransactionFn) }, // "db.transaction"
+      { ALT: () => $.SUBRULE($.dbPatchFn) }, // "db.patch"
+      { ALT: () => $.SUBRULE($.dbBulkFn) }, // "db.bulk"
+      { ALT: () => $.SUBRULE($.dbAddOrEditFn) }, // db.add_or_edit
+    ]);
+    $.sectionStack.pop();
+  };
+}

package/parser/functions/debug/debugLogFn.js

@@ -0,0 +1,21 @@
+import { DebugLogToken } from "../../../lexer/debug.js";
+
+/**
+ * represent $var.x or $x, the only format accepting an assigment
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export function debugLogFn($) {
+  const requiredAttrs = ["value"];
+  const optionalAttrs = ["description", "disabled"];
+
+  return () => {
+    $.sectionStack.push("debugLog");
+    const tokenFn = $.CONSUME(DebugLogToken); // log
+    // value is a required field
+    $.SUBRULE($.functionAttrReq, {
+      ARGS: [tokenFn, requiredAttrs, optionalAttrs],
+    });
+
+    $.sectionStack.pop();
+  };
+}

package/parser/functions/debug/debugLogFn.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.debugLogFn();
+  return parser;
+}
+
+describe("debugLogFn", () => {
+  it("debugLogFn accepts a value", () => {
+    const parser = parse(`log {
+      value = "live"
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("debugLogFn can be disabled", () => {
+    const parser = parse(`log {
+      value = "live"
+      disabled = true
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("debugLogFn accepts a description", () => {
+    const parser = parse(`log {
+      value = "live"
+      description = "check if a user exists"
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("debugLogFn requires a value", () => {
+    const parser = parse(`log {
+      description = "check if a user exists"
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+});

package/parser/functions/debug/debugStopFn.js

@@ -0,0 +1,21 @@
+import { DebugStopToken } from "../../../lexer/debug.js";
+
+/**
+ * represent $var.x or $x, the only format accepting an assigment
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export function debugStopFn($) {
+  const requiredAttrs = ["value"];
+  const optionalAttrs = ["description", "disabled"];
+
+  return () => {
+    $.sectionStack.push("debugStop");
+    const tokenFn = $.CONSUME(DebugStopToken); // stop
+    // value is a required field
+    $.SUBRULE($.functionAttrReq, {
+      ARGS: [tokenFn, requiredAttrs, optionalAttrs],
+    });
+
+    $.sectionStack.pop();
+  };
+}

package/parser/functions/debug/debugStopFn.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.debugStopFn();
+  return parser;
+}
+
+describe("debugStopFn", () => {
+  it("debugStopFn accepts a value", () => {
+    const parser = parse(`stop {
+      value = "live"
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("debugStopFn can be disabled", () => {
+    const parser = parse(`stop {
+      value = "live"
+      disabled = true
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("debugStopFn accepts a description", () => {
+    const parser = parse(`stop {
+      value = "live"
+      description = "check if a user exists"
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("debugStopFn requires a value", () => {
+    const parser = parse(`stop {
+      description = "check if a user exists"
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+});

package/parser/functions/debug/register.js

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

package/parser/functions/debugFn.js

@@ -0,0 +1,18 @@
+import { DebugToken } from "../../lexer/debug.js";
+import { DotToken } from "../../lexer/tokens.js";
+
+/**
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export function debugFn($) {
+  return () => {
+    $.sectionStack.push("debug");
+    $.CONSUME(DebugToken); // "debug"
+    $.CONSUME(DotToken); // "."
+    $.OR([
+      { ALT: () => $.SUBRULE($.debugLogFn) }, // debug.log
+      { ALT: () => $.SUBRULE($.debugStopFn) }, // debug.stop
+    ]);
+    $.sectionStack.pop();
+  };
+}

package/parser/functions/expect/register.js

@@ -0,0 +1,44 @@
+import { unitExpectToBeWithinFn } from "./unitExpectToBeWithinFn.js";
+import { unitExpectToThrowFn } from "./unitExpectToThrowFn.js";
+import { unitExpectWithArgumentsFn } from "./unitExpectWithArgumentsFn.js";
+import { unitExpectWithoutArgumentsFn } from "./unitExpectWithoutArgumentsFn.js";
+import { workflowExpectToBeWithinFn } from "./workflowExpectToBeWithinFn.js";
+import { workflowExpectToThrowFn } from "./workflowExpectToThrowFn.js";
+import { workflowExpectWithArgumentsFn } from "./workflowExpectWithArgumentsFn.js";
+import { workflowExpectWithoutArgumentsFn } from "./workflowExpectWithoutArgumentsFn.js";
+
+/**
+ * Registers all the parsers in this folder
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export const register = ($) => {
+  $.unitExpectWithArgumentsFn = $.RULE(
+    "unitExpectWithArgumentsFn",
+    unitExpectWithArgumentsFn($)
+  );
+  $.unitExpectWithoutArgumentsFn = $.RULE(
+    "unitExpectWithoutArgumentsFn",
+    unitExpectWithoutArgumentsFn($)
+  );
+  $.unitExpectToThrowFn = $.RULE("unitExpectToThrowFn", unitExpectToThrowFn($));
+  $.unitExpectToBeWithinFn = $.RULE(
+    "unitExpectToBeWithinFn",
+    unitExpectToBeWithinFn($)
+  );
+  $.workflowExpectWithArgumentsFn = $.RULE(
+    "workflowExpectWithArgumentsFn",
+    workflowExpectWithArgumentsFn($)
+  );
+  $.workflowExpectWithoutArgumentsFn = $.RULE(
+    "workflowExpectWithoutArgumentsFn",
+    workflowExpectWithoutArgumentsFn($)
+  );
+  $.workflowExpectToThrowFn = $.RULE(
+    "workflowExpectToThrowFn",
+    workflowExpectToThrowFn($)
+  );
+  $.workflowExpectToBeWithinFn = $.RULE(
+    "workflowExpectToBeWithinFn",
+    workflowExpectToBeWithinFn($)
+  );
+};

package/parser/functions/expect/unitExpectToBeWithinFn.js

@@ -0,0 +1,28 @@
+import { LParent, RParent } from "../../../lexer/control.js";
+import { ToBeWithinToken } from "../../../lexer/expect.js";
+import { DotToken, Identifier } from "../../../lexer/tokens.js";
+import { ResponseVariable } from "../../../lexer/variables.js";
+
+/**
+ * @param {import('../../base_parser.js').XanoBaseParser} $
+ */
+export function unitExpectToBeWithinFn($) {
+  const requiredAttrs = ["min", "max"];
+  const optionalAttrs = [];
+
+  return () => {
+    $.sectionStack.push("unitExpectToBeWithinFn");
+    const fnToken = $.CONSUME(ToBeWithinToken); // "to_be_within"
+    $.CONSUME(LParent); // "("
+    $.CONSUME(ResponseVariable); // "$response"
+    $.MANY(() => {
+      $.CONSUME(DotToken); // "."
+      $.CONSUME(Identifier); // "x", "users", etc.
+    });
+    $.CONSUME(RParent); // ")"
+    $.SUBRULE($.functionAttrReq, {
+      ARGS: [fnToken, requiredAttrs, optionalAttrs],
+    });
+    $.sectionStack.pop();
+  };
+}

package/parser/functions/expect/unitExpectToBeWithinFn.spec.js

@@ -0,0 +1,61 @@
+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.unitExpectToBeWithinFn();
+  return parser;
+}
+
+describe("unitExpectToBeWithinFn", () => {
+  it("unitExpectToBeWithinFn accepts args and a value argument", () => {
+    const parser = parse(`to_be_within ($response) {
+        min = 11
+        max = 13
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("unitExpectToBeWithinFn does not accept a non $response variable", () => {
+    const parser = parse(`to_equal ($foo) {
+      min = 11
+      max = 13
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("unitExpectToBeWithinFn does not accepts filters on value argument", () => {
+    const parser =
+      parse(`to_be_within (($response|get:foo:"bar")|first|concat:bar) {
+      min = 11
+      max = 13
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("unitExpectToBeWithinFn does not accept a missing min", () => {
+    const parser = parse(`to_be_within ($response) {
+      max = 13
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("unitExpectToBeWithinFn does not accept a missing max", () => {
+    const parser = parse(`to_be_within ($response) {
+      min = 11
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("unitExpectToBeWithinFn does not accept a missing value", () => {
+    const parser = parse(`to_be_within {
+      min = 11
+      max = 13
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+});

package/parser/functions/expect/unitExpectToThrowFn.js

@@ -0,0 +1,15 @@
+import { ToThrowToken } from "../../../lexer/expect.js";
+
+/**
+ * @param {import('../../base_parser.js').XanoBaseParser} $
+ */
+export function unitExpectToThrowFn($) {
+  return () => {
+    $.sectionStack.push("unitExpectToThrowFn");
+    const fnToken = $.CONSUME(ToThrowToken); // "to_throw"
+    $.SUBRULE($.schemaParseAttributeFn, {
+      ARGS: [fnToken, { "exception?": "[string]" }],
+    });
+    $.sectionStack.pop();
+  };
+}

package/parser/functions/expect/unitExpectToThrowFn.spec.js

@@ -0,0 +1,40 @@
+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.unitExpectToThrowFn();
+  return parser;
+}
+
+describe("unitExpectToThrowFn", () => {
+  it("unitExpectToThrowFn accepts data field", () => {
+    const parser = parse(`to_throw {
+      exception = "error"
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("unitExpectToThrowFn accepts an empty payload", () => {
+    const parser = parse(`to_throw`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("unitExpectToThrowFn does not accept an operand", () => {
+    const parser = parse(`to_throw ($response.x) {
+      exception = "foo"
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("unitExpectToThrowFn rejects an expression", () => {
+    const parser = parse(`to_throw {
+      exception = $var.exception
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+});

package/parser/functions/expect/unitExpectWithArgumentsFn.js

@@ -0,0 +1,49 @@
+import { LParent, RParent } from "../../../lexer/control.js";
+import {
+  ToBeGreaterThanToken,
+  ToBeLessThanToken,
+  ToContainToken,
+  ToEndWithToken,
+  ToEqualToken,
+  ToMatchToken,
+  ToNotEqualToken,
+  ToStartWithToken,
+} from "../../../lexer/expect.js";
+import { DotToken, Identifier } from "../../../lexer/tokens.js";
+import { ResponseVariable } from "../../../lexer/variables.js";
+
+/**
+ * @param {import('../../base_parser.js').XanoBaseParser} $
+ */
+export function unitExpectWithArgumentsFn($) {
+  return () => {
+    $.sectionStack.push("unitExpectWithArgumentsFn");
+    const fnToken = $.OR([
+      { ALT: () => $.CONSUME(ToEqualToken) }, // "to_equal"
+      { ALT: () => $.CONSUME(ToStartWithToken) }, // "to_start_with"
+      { ALT: () => $.CONSUME(ToEndWithToken) }, // "to_end_with"
+      { ALT: () => $.CONSUME(ToBeGreaterThanToken) }, // "to_be_greater_than"
+      { ALT: () => $.CONSUME(ToBeLessThanToken) }, // "to_be_less_than"
+      { ALT: () => $.CONSUME(ToMatchToken) }, // "to_match"
+      { ALT: () => $.CONSUME(ToNotEqualToken) }, // "to_not_equal"
+      { ALT: () => $.CONSUME(ToContainToken) }, // "to_contain"
+    ]);
+    $.CONSUME(LParent); // "("
+    $.CONSUME(ResponseVariable); // "$response"
+    $.MANY(() => {
+      $.CONSUME(DotToken); // "."
+      $.CONSUME(Identifier); // "x", "users", etc.
+    });
+    $.CONSUME(RParent); // ")"
+
+    $.SUBRULE($.schemaParseAttributeFn, {
+      ARGS: [
+        fnToken,
+        {
+          value: "[constant]",
+        },
+      ],
+    });
+    $.sectionStack.pop();
+  };
+}