@xano/xanoscript-language-server 11.0.3

package/parser/clauses/cacheClause.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.cacheClause();
+  return parser;
+}
+
+describe("cacheClause", () => {
+  it("cacheClause defines the cache", () => {
+    const parser = parse(`cache = {
+      ttl       : 3600
+      input     : true
+      auth      : true
+      datasource: true
+      ip        : false
+      headers   : ["foo=bar"]
+      env       : ["some_var"]
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("cacheClause headers and env are optionals", () => {
+    const parser = parse(`cache = {
+      ttl       : 3600
+      input     : true
+      auth      : true
+      datasource: true
+      ip        : false
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("cacheClause ttl should be int", () => {
+    const parser = parse(`cache = {
+      ttl       : "foo"
+      input     : true
+      auth      : true
+      datasource: true
+      ip        : false
+      headers   : ["foo=bar"]
+      env       : ["some_var"]
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("cacheClause input should be boolean", () => {
+    const parser = parse(`cache = {
+      ttl       : 3600
+      input     : "foo"
+      auth      : true
+      datasource: true
+      ip        : false
+      headers   : ["foo=bar"]
+      env       : ["some_var"]
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("cacheClause auth should be boolean", () => {
+    const parser = parse(`cache = {
+      ttl       : 3600
+      input     : true
+      auth      : "foo"
+      datasource: true
+      ip        : false
+      headers   : ["foo=bar"]
+      env       : ["some_var"]
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("cacheClause datasource should be boolean", () => {
+    const parser = parse(`cache = {
+      ttl       : 3600
+      input     : true
+      auth      : true
+      datasource: "foo"
+      ip        : false
+      headers   : ["foo=bar"]
+      env       : ["some_var"]
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("cacheClause ip should be boolean", () => {
+    const parser = parse(`cache = {
+      ttl       : 3600
+      input     : true
+      auth      : true
+      datasource: true
+      ip        : "foo"
+      headers   : ["foo=bar"]
+      env       : ["some_var"]
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+});

package/parser/clauses/canonicalClause.js

@@ -0,0 +1,23 @@
+import { CanonicalToken } from "../../lexer/columns.js";
+import { EqualToken } from "../../lexer/control.js";
+import { StringLiteral } from "../../lexer/literal.js";
+
+/**
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ * @returns
+ */
+export const canonicalClause = ($) => () => {
+  $.sectionStack.push("canonicalClause");
+
+  const parent = $.CONSUME(CanonicalToken); // canonical
+  $.CONSUME(EqualToken); // =
+
+  const result = $.CONSUME(StringLiteral); // "alsdkfjlskdjf"
+
+  // Don't allow empty values inside quotes
+  if (result.image === `""`) {
+    $.addMissingError(parent, "canonical cannot be empty");
+  }
+
+  $.sectionStack.pop();
+};

package/parser/clauses/canonicalClause.spec.js

@@ -0,0 +1,34 @@
+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.canonicalClause();
+  return parser;
+}
+
+describe("canonicalClause", () => {
+  it("canonicalClause accepts string", () => {
+    const parser = parse(`canonical = "test"`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("canonicalClause doesn't allow empty string with double quotes", () => {
+    const parser = parse(`canonical = ""`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("canonicalClause doesn't allow empty string with single quotes", () => {
+    const parser = parse(`canonical = ''`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("canonicalClause only allows strings (not numerical)", () => {
+    const parser = parse(`canonical = '123'`);
+    expect(parser.errors).to.not.be.empty;
+  });
+});

package/parser/clauses/channelClause.js

@@ -0,0 +1,23 @@
+import { ChannelToken } from "../../lexer/columns.js";
+import { EqualToken } from "../../lexer/control.js";
+import { StringLiteral } from "../../lexer/literal.js";
+
+/**
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ * @returns
+ */
+export const channelClause = ($) => () => {
+  $.sectionStack.push("channelClause");
+
+  const parent = $.CONSUME(ChannelToken); // channel
+  $.CONSUME(EqualToken); // =
+
+  const result = $.CONSUME(StringLiteral); // "channel_name"
+
+  // Don't allow empty values inside quotes
+  if (result.image === `""`) {
+    $.addMissingError(parent, "channel cannot be empty");
+  }
+
+  $.sectionStack.pop();
+};

package/parser/clauses/channelClause.spec.js

@@ -0,0 +1,34 @@
+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.channelClause();
+  return parser;
+}
+
+describe("channelClause", () => {
+  it("channelClause accepts string", () => {
+    const parser = parse(`channel = "test"`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("channelClause doesn't allow empty string with double quotes", () => {
+    const parser = parse(`channel = ""`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("channelClause doesn't allow empty string with single quotes", () => {
+    const parser = parse(`channel = ''`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("channelClause only allows strings (not numerical)", () => {
+    const parser = parse(`channel = '123'`);
+    expect(parser.errors).to.not.be.empty;
+  });
+});

package/parser/clauses/dbTableClause.js

@@ -0,0 +1,23 @@
+import { EqualToken } from "../../lexer/control.js";
+import { StringLiteral } from "../../lexer/literal.js";
+import { TableToken } from "../../lexer/table.js";
+
+/**
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ * @returns
+ */
+export const dbTableClause = ($) => () => {
+  $.sectionStack.push("dbTableClause");
+
+  const parent = $.CONSUME(TableToken); // table
+  $.CONSUME(EqualToken); // =
+
+  const result = $.CONSUME(StringLiteral); // "tablename"
+
+  // Don't allow empty values inside quotes
+  if (result.image === `""`) {
+    $.addMissingError(parent, "table cannot be empty");
+  }
+
+  $.sectionStack.pop();
+};

package/parser/clauses/dbTableClause.spec.js

@@ -0,0 +1,34 @@
+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.dbTableClause();
+  return parser;
+}
+
+describe("dbTableClause", () => {
+  it("dbTableClause accepts string", () => {
+    const parser = parse(`table = "test"`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("dbTableClause doesn't allow empty string with double quotes", () => {
+    const parser = parse(`table = ""`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("dbTableClause doesn't allow empty string with single quotes", () => {
+    const parser = parse(`table = ''`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("dbTableClause only allows strings (not numerical)", () => {
+    const parser = parse(`table = '123'`);
+    expect(parser.errors).to.not.be.empty;
+  });
+});

package/parser/clauses/flexibleStringClause.js

@@ -0,0 +1,43 @@
+import { EqualToken } from "../../lexer/control.js";
+import { Identifier } from "../../lexer/identifier.js";
+import { StringLiteral } from "../../lexer/literal.js";
+import { MultiLineStringToken } from "../../lexer/multiline.js";
+
+/**
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export function flexibleStringClause($) {
+  /**
+   * @param {import('chevrotain').TokenType} token
+   * @param allowEmpty
+   */
+  return (args) => {
+    // During parser initialization, args is undefined
+    // Use a placeholder token for grammar recording
+    const token = args?.[0] || Identifier;
+    const allowEmpty = args?.[1] ?? true;
+
+    $.sectionStack.push(token.name + "Clause");
+
+    $.CONSUME(token); // "tokenLabel"
+    $.CONSUME(EqualToken); // "="
+
+    const result = $.OR([
+      {
+        ALT: () => $.CONSUME(StringLiteral), // e.g., "A instructions of the field"
+      },
+      {
+        ALT: () => $.CONSUME(MultiLineStringToken), // e.g., "fieldinstructions"
+      },
+    ]);
+
+    if (!allowEmpty) {
+      // Don't allow empty values inside quotes
+      if (result.image === `""`) {
+        $.addMissingError(result, "value cannot be empty");
+      }
+    }
+
+    $.sectionStack.pop();
+  };
+}

package/parser/clauses/historyClause.js

@@ -0,0 +1,19 @@
+import { EqualToken } from "../../lexer/control.js";
+import { HistoryToken } from "../../lexer/tokens.js";
+
+/**
+ * Parses the history clause.
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export function historyClause($) {
+  return () => {
+    $.sectionStack.push("historyClause");
+    const parent = $.CONSUME(HistoryToken); // "history"
+    $.CONSUME(EqualToken); // "="
+    $.SUBRULE($.schemaParseEnumFn, {
+      ARGS: [parent, [false, "inherit", 0, 10, 100, 1000, 10000, "all"]],
+    });
+
+    $.sectionStack.pop();
+  };
+}

package/parser/clauses/historyClause.spec.js

@@ -0,0 +1,53 @@
+import { expect } from "chai";
+import { describe, it } from "mocha";
+import { lexDocument } from "../../lexer/lexer.js";
+import { parser } from "../test_parser.js";
+
+function parse(inputText) {
+  const lexResult = lexDocument(inputText);
+  parser.input = lexResult.tokens;
+  parser.historyClause();
+  return parser;
+}
+
+describe("historyClause", () => {
+  it("historyClause can be disabled", () => {
+    const parser = parse(`history = false`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("historyClause accepts a limit", () => {
+    let parser = parse(`history = 0`);
+    expect(parser.errors).to.be.empty;
+    parser = parse(`history = 10`);
+    expect(parser.errors).to.be.empty;
+    parser = parse(`history = 12`);
+    expect(parser.errors).to.not.be.empty;
+    parser = parse(`history = 100`);
+    expect(parser.errors).to.be.empty;
+    parser = parse(`history = 1000`);
+    expect(parser.errors).to.be.empty;
+    parser = parse(`history = 10000`);
+    expect(parser.errors).to.be.empty;
+    parser = parse(`history = 100000`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("historyClause can be inherited", () => {
+    const parser = parse(`history = "inherit"`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("historyClause accepts all", () => {
+    let parser = parse(`history = "all"`);
+    expect(parser.errors).to.be.empty;
+
+    parser = parse(`history = all`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("historyClause does not accept a limit that is not a valid number", () => {
+    const parser = parse(`history = 1234`);
+    expect(parser.errors).to.not.be.empty;
+  });
+});

package/parser/clauses/indexClause.js

@@ -0,0 +1,36 @@
+import { EqualToken } from "../../lexer/control.js";
+import { IndexToken } from "../../lexer/tokens.js";
+
+/**
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ * @returns
+ */
+export function indexClause($) {
+  return () => {
+    $.sectionStack.push("indexClause");
+    const parent = $.CONSUME(IndexToken); // "index"
+    $.CONSUME(EqualToken); // "="
+    $.SUBRULE($.schemaFn, {
+      ARGS: [
+        parent,
+        [
+          {
+            type: [
+              "primary",
+              "btree",
+              "gin",
+              "btree|unique",
+              "search",
+              "vector",
+            ],
+            field: [{ name: "[string]", "op?": "[string]" }],
+            "lang?": "[string]",
+            "name?": "[string]",
+          },
+        ],
+      ],
+    });
+
+    $.sectionStack.pop();
+  };
+}

package/parser/clauses/indexClause.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) {
+  const lexResult = lexDocument(inputText);
+  parser.input = lexResult.tokens;
+  parser.indexClause();
+  return parser;
+}
+
+describe("indexClause", () => {
+  it("indexClause accepts many indices", () => {
+    const parser = parse(`index = [
+    {type: "primary", field: [{name: "id"}]}
+    {type: "gin", field: [{name: "xdo", op: "jsonb_path_op"}]}
+    {type: "btree", field: [{name: "created_at", op: "desc"}]}
+    {
+      type : "vector"
+      field: [{name: "name_vector", op: "vector_ip_ops"}]
+    }
+  ]`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("indexClause accepts one index", () => {
+    const parser = parse(`index = [
+    {type: "primary", field: [{name: "id"}]}
+  ]`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("indexClause accepts single and multiline indices", () => {
+    const parser = parse(`index = [
+    {type: "primary", field: [{name: "id"}]}
+    {type: "gin", field: [{name: "xdo", op: "jsonb_path_op"}]}
+    {
+      type : "btree"
+      field: [
+        {name: "meeting_id", op: "asc"}
+        {name: "member_id", op: "asc"}
+      ]
+    }
+  ]`);
+    expect(parser.errors).to.be.empty;
+  });
+});

package/parser/clauses/inputClause.js

@@ -0,0 +1,35 @@
+import { LCurly, RCurly } from "../../lexer/control.js";
+import { InputToken, NewlineToken } from "../../lexer/tokens.js";
+
+/**
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export function inputClause($) {
+  return () => {
+    $.sectionStack.push("inputClause");
+    $.CONSUME(InputToken); // "input"
+    // unlike schema, input can be mentioned without any fields
+    $.OPTION(() => {
+      $.CONSUME(LCurly); // "{"
+      $.MANY(() => {
+        $.AT_LEAST_ONE1(() => $.CONSUME1(NewlineToken)); // at least one new line
+        $.SUBRULE($.optionalCommentBlockFn);
+
+        $.OR([
+          { ALT: () => $.SUBRULE($.objectColumnDefinition) },
+          { ALT: () => $.SUBRULE($.enumColumnDefinition) },
+          {
+            ALT: () =>
+              $.SUBRULE($.columnDefinition, { ARGS: [{ include_file: true }] }),
+          },
+          {
+            ALT: () => $.SUBRULE($.dbLinkColumnDefinition),
+          },
+        ]);
+      });
+      $.AT_LEAST_ONE2(() => $.CONSUME2(NewlineToken)); // at least one new line
+      $.CONSUME(RCurly); // "}"
+    });
+    $.sectionStack.pop();
+  };
+}

package/parser/clauses/inputClause.spec.js

@@ -0,0 +1,79 @@
+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.inputClause();
+  return parser;
+}
+
+describe("inputClause", () => {
+  it("inputClause accepts filters and field definition", () => {
+    const parser = parse(`input {
+    email email_input? filters=trim|lower
+  }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("inputClause can be empty", () => {
+    const parser = parse(`input`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("inputClause field accepts a description as a comment", () => {
+    const parser = parse(`input {
+        // this is a label
+        text label
+
+        // another comment
+        int rank
+      }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("inputClause accepts a description", () => {
+    const parser = parse(`input {
+        text label {
+          description = "This is a description"
+        }
+      }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("inputClause field accepts a sensitivity marker", () => {
+    const parser = parse(`input {
+        decimal value {
+          sensitive = true
+        }
+      }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("inputClause field accepts a file type", () => {
+    const parser = parse(`input {
+        dblink {
+          table = "book_club_meeting_registration"
+        }
+      }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("inputClause field accepts dblink definition", () => {
+    const parser = parse(`input {
+        file my_file?
+      }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("inputClause accepts multiple fields", () => {
+    const parser = parse(`input {
+            int rank
+            text label
+          }`);
+    expect(parser.errors).to.be.empty;
+  });
+});

package/parser/clauses/mcpServerClause.js

@@ -0,0 +1,23 @@
+import { McpServerToken } from "../../lexer/columns.js";
+import { EqualToken } from "../../lexer/control.js";
+import { StringLiteral } from "../../lexer/literal.js";
+
+/**
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ * @returns
+ */
+export const mcpServerClause = ($) => () => {
+  $.sectionStack.push("mcpServerClause");
+
+  const parent = $.CONSUME(McpServerToken); // mcp_server
+  $.CONSUME(EqualToken); // =
+
+  const result = $.CONSUME(StringLiteral); // "mcpserver_name"
+
+  // Don't allow empty values inside quotes
+  if (result.image === `""`) {
+    $.addMissingError(parent, "mcp_server cannot be empty");
+  }
+
+  $.sectionStack.pop();
+};

package/parser/clauses/mcpServerClause.spec.js

@@ -0,0 +1,34 @@
+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.mcpServerClause();
+  return parser;
+}
+
+describe("mcpServerClause", () => {
+  it("mcpServerClause accepts string", () => {
+    const parser = parse(`mcp_server = "test"`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("mcpServerClause doesn't allow empty string with double quotes", () => {
+    const parser = parse(`mcp_server = ""`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("mcpServerClause doesn't allow empty string with single quotes", () => {
+    const parser = parse(`mcp_server = ''`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("mcpServerClause only allows strings (not numerical)", () => {
+    const parser = parse(`mcp_server = '123'`);
+    expect(parser.errors).to.not.be.empty;
+  });
+});