@xano/xanoscript-language-server 11.0.3

package/parser/tests/task/valid_sources/daily_sales_report.xs

@@ -0,0 +1,56 @@
+task daily_sales_report {
+  description = "Daily at 11 PM UTC generate a sales report by querying all payment transactions from the past 24 hours and calculating the total sales amount and transaction count. The task automatically executes every day starting from May 1, 2026, providing a summary of daily sales performance."
+  stack {
+    var $twenty_four_hours_ago {
+      value = (now|to_timestamp|transform_timestamp:"24 hours ago":"UTC")
+      description = "Calculate timestamp for 24 hours ago"
+    }
+  
+    db.query payment_transactions {
+      description = "Get all transactions from the past 24 hours"
+      where = $db.payment_transactions.transaction_date >= $twenty_four_hours_ago
+    } as $daily_sales
+  
+    var $transaction_count {
+      value = $daily_sales|count
+      description = "Count number of transactions"
+    }
+  
+    var $total_sales {
+      value = ($daily_sales[$$].amount)|sum
+      description = "Initialize total sales amount"
+    }
+  
+    var $report_date {
+      value = now|to_timestamp
+      description = "Current timestamp for the report"
+    }
+  
+    db.transaction {
+      description = "Store daily sales report with data consistency"
+      stack {
+        db.add reports {
+          data = {
+            report_type      : "daily_sales"
+            report_date      : $report_date
+            total_sales      : $total_sales
+            transaction_count: $transaction_count
+            period_start     : $twenty_four_hours_ago
+            period_end       : $report_date
+          }
+        
+          description = "Insert daily sales report into reports table"
+        } as $report_result
+      
+        debug.log {
+          value = "Daily sales report generated successfully"
+          description = "Log successful report generation"
+        }
+      }
+    }
+  }
+
+  schedule = [{starts_on: 2026-05-01 23:00:00+0000, freq: 86400}]
+
+  history = "inherit"
+}

package/parser/tests/task/valid_sources/inactive_event.xs

@@ -0,0 +1,11 @@
+task "my_test_task" {
+  active = false
+
+  stack {
+  }
+  
+  schedule = []
+
+  history = "inherit"
+
+}

package/parser/tests/workflow_test/valid_sources/basic_workflow_test.xs

@@ -0,0 +1,13 @@
+workflow_test new_test {
+  stack {
+    function.call add {
+      input = {a: 5, b: 10}
+    } as $sum
+  
+    expect.to_equal ($sum) {
+      value = 15
+    }
+  
+    task.call "count to 10" as $test1
+  }
+}

package/parser/tests/workflow_test/workflow_test_parser.spec.js

@@ -0,0 +1,52 @@
+import { expect } from "chai";
+import { readdirSync, readFileSync } from "fs";
+import { truncate } from "lodash-es";
+import { describe, it } from "mocha";
+import { dirname, join } from "path";
+import { xanoscriptParser } from "../../parser.js";
+
+describe("Xanoscript WorkflowTest Parser", () => {
+  it("parses all the valid sources", () => {
+    const errors = [];
+    const files = readdirSync(
+      join(dirname("./"), "parser/tests/workflow_test/valid_sources")
+    );
+    files.forEach((file) => {
+      const source = readFileSync(
+        join(dirname("./"), "parser/tests/workflow_test/valid_sources", file),
+        "utf8"
+      );
+      const parser = xanoscriptParser(source);
+
+      if (parser.errors.length > 0) {
+        parser.errors.forEach((error) => {
+          errors.push({
+            previous: error.previousToken
+              ? `${error.previousToken.tokenType.name} (${truncate(
+                  error.previousToken.image,
+                  {
+                    length: 20,
+                  }
+                )})`
+              : "N/A",
+            file: `parser/tests/api_group/valid_sources/${file}:${error.token.startLine}:${error.token.startColumn}`,
+            stack: parser.sectionStack[parser.sectionStack.length - 1],
+            message: truncate(error.message, { length: 50 }),
+            token: `${error.token.tokenType.name} (${truncate(
+              error.token.image,
+              {
+                length: 20,
+              }
+            )})`,
+          });
+        });
+      }
+    });
+
+    if (errors.length > 0) {
+      console.table(errors);
+    }
+
+    expect(errors).to.be.empty;
+  });
+});

package/parser/tool_parser.js

@@ -0,0 +1,121 @@
+import { LCurly, RCurly } from "../lexer/control.js";
+import { StringLiteral } from "../lexer/literal.js";
+import { Identifier, NewlineToken } from "../lexer/tokens.js";
+import { InstructionsToken, ToolToken } from "../lexer/tool.js";
+
+export function toolDeclaration($) {
+  return () => {
+    let hasDescription = false;
+    let hasDocs = false;
+    let hasHistory = false;
+    let hasInput = false;
+    let hasInstructions = false;
+    let hasMiddleware = false;
+    let hasResponse = false;
+    let hasStack = false;
+    let hasTags = false;
+
+    $.sectionStack.push("toolDeclaration");
+    // Allow leading comments and newlines before the tool declaration
+    $.SUBRULE($.optionalCommentBlockFn);
+
+    const parent = $.CONSUME(ToolToken);
+    $.OR([
+      { ALT: () => $.CONSUME(StringLiteral) },
+      { ALT: () => $.CONSUME(Identifier) },
+    ]);
+    $.CONSUME(LCurly); // "{"
+    $.MANY(() => {
+      $.AT_LEAST_ONE(() => $.CONSUME(NewlineToken)); // at least one new line
+      $.OR2([
+        { ALT: () => $.SUBRULE($.commentBlockFn) },
+        {
+          GATE: () => !hasDescription,
+          ALT: () => {
+            hasDescription = true;
+            $.SUBRULE($.descriptionFieldAttribute);
+          },
+        },
+        {
+          GATE: () => !hasDocs,
+          ALT: () => {
+            hasDocs = true;
+            $.SUBRULE($.docsFieldAttribute);
+          },
+        },
+        {
+          GATE: () => !hasHistory,
+          ALT: () => {
+            hasHistory = true;
+            $.SUBRULE($.historyClause);
+          },
+        },
+        {
+          GATE: () => !hasInput,
+          ALT: () => {
+            hasInput = true;
+            $.SUBRULE($.inputClause);
+          },
+        },
+        {
+          GATE: () => !hasInstructions,
+          ALT: () => {
+            hasInstructions = true;
+
+            // instructions = {string or multiline string}
+            $.SUBRULE($.flexibleStringClause, {
+              ARGS: [InstructionsToken],
+            });
+          },
+        },
+        {
+          GATE: () => !hasMiddleware,
+          ALT: () => {
+            hasMiddleware = true;
+            $.SUBRULE($.middlewareClause);
+          },
+        },
+        {
+          GATE: () => !hasResponse,
+          ALT: () => {
+            hasResponse = true;
+            $.SUBRULE($.responseClause);
+          },
+        },
+        {
+          GATE: () => !hasStack,
+          ALT: () => {
+            hasStack = true;
+            $.SUBRULE($.stackClause, {
+              ARGS: [{ allowCallStatements: true }],
+            });
+          },
+        },
+        {
+          GATE: () => !hasTags,
+          ALT: () => {
+            hasTags = true;
+            $.SUBRULE($.tagsAttribute);
+          },
+        },
+      ]);
+    });
+
+    if (!hasInput) {
+      $.addMissingError(parent, "{} is missing an input clause");
+    }
+
+    if (!hasStack) {
+      $.addMissingError(parent, "{} is missing a stack clause");
+    }
+
+    if (!hasResponse) {
+      $.addMissingError(parent, "{} is missing a response clause");
+    }
+
+    $.MANY1(() => $.CONSUME1(NewlineToken)); // optional new line
+    $.CONSUME(RCurly); // "}"
+    $.MANY2(() => $.CONSUME2(NewlineToken)); // optional new line
+    $.sectionStack.pop();
+  };
+}

package/parser/tool_parser.spec.js

@@ -0,0 +1,102 @@
+import { expect } from "chai";
+import { describe, it } from "mocha";
+import { xanoscriptParser } from "./parser.js";
+
+describe("tool_parser", () => {
+  it("should parse a basic tool", () => {
+    const parser = xanoscriptParser(`tool foo {
+      input {
+      }
+
+      stack {
+      }
+
+      response = null
+    }`);
+
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should parse a basic a string tool url", () => {
+    const parser = xanoscriptParser(`tool "foo/bar" {
+      input {
+      }
+
+      stack {
+      }
+
+      response = null
+    }`);
+
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("tool don't accept dynamic params", () => {
+    const parser = xanoscriptParser(`tool foo/{user_id} {
+      input {
+        text user_id filters=trim
+      }
+
+      stack {
+      }
+
+      response = null
+    }`);
+
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("should parse a tool with instructions as a string", () => {
+    const parser = xanoscriptParser(`tool foo {
+      instructions = "This tool does something"
+
+      input {
+      }
+
+      stack {
+      }
+
+      response = null
+    }`);
+
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should parse a tool with instructions as a multiline string", () => {
+    const parser = xanoscriptParser(`tool foo {
+      instructions = """
+        This tool does multiple things:
+        - First thing
+        - Second thing
+      """
+
+      input {
+      }
+
+      stack {
+      }
+
+      response = null
+    }`);
+
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should parse a tool with multiple clauses including instructions", () => {
+    const parser = xanoscriptParser(`tool foo {
+      description = "A test tool"
+      instructions = "Follow these instructions"
+
+      input {
+        text param
+      }
+
+      stack {
+      }
+
+      response = null
+    }`);
+
+    expect(parser.errors).to.be.empty;
+  });
+});

package/parser/workflow_test_parser.js

@@ -0,0 +1,73 @@
+import { EqualToken, LCurly, RCurly } from "../lexer/control.js";
+import { StringLiteral } from "../lexer/literal.js";
+import { Identifier, NewlineToken } from "../lexer/tokens.js";
+import { DatasourceToken, WorkflowTestToken } from "../lexer/workflow_test.js";
+
+export function workflowTestDeclaration($) {
+  return () => {
+    let hasDatasource = false;
+    let hasDescription = false;
+    let hasStack = false;
+    let hasTags = false;
+
+    $.sectionStack.push("workflowTestDeclaration");
+    // Allow leading comments and newlines before the workflow_test declaration
+    $.SUBRULE($.optionalCommentBlockFn);
+
+    const parent = $.CONSUME(WorkflowTestToken);
+    $.OR([
+      { ALT: () => $.CONSUME(StringLiteral) },
+      { ALT: () => $.CONSUME(Identifier) },
+    ]);
+    $.CONSUME(LCurly); // "{"
+    $.MANY(() => {
+      $.AT_LEAST_ONE(() => $.CONSUME(NewlineToken)); // at least one new line
+      $.OR2([
+        { ALT: () => $.SUBRULE($.commentBlockFn) },
+        {
+          GATE: () => !hasDatasource,
+          ALT: () => {
+            hasDatasource = true;
+            $.CONSUME(DatasourceToken);
+            $.CONSUME(EqualToken);
+            $.CONSUME2(StringLiteral);
+          },
+        },
+        {
+          GATE: () => !hasDescription,
+          ALT: () => {
+            hasDescription = true;
+            $.SUBRULE($.descriptionFieldAttribute);
+          },
+        },
+        {
+          GATE: () => !hasStack,
+          ALT: () => {
+            hasStack = true;
+            $.SUBRULE($.stackClause, {
+              ARGS: [
+                { allowExpectStatements: true, allowCallStatements: true },
+              ],
+            });
+          },
+        },
+        {
+          GATE: () => !hasTags,
+          ALT: () => {
+            hasTags = true;
+            $.SUBRULE($.tagsAttribute);
+          },
+        },
+      ]);
+    });
+
+    if (!hasStack) {
+      $.addMissingError(parent, "{} is missing a stack clause");
+    }
+
+    $.MANY1(() => $.CONSUME1(NewlineToken)); // optional new line
+    $.CONSUME(RCurly); // "}"
+    $.MANY2(() => $.CONSUME2(NewlineToken)); // optional new line
+    $.sectionStack.pop();
+  };
+}

package/parser/workflow_test_parser.spec.js

@@ -0,0 +1,71 @@
+import { expect } from "chai";
+import { describe, it } from "mocha";
+import { xanoscriptParser } from "./parser.js";
+
+describe("workflow_test_parser", () => {
+  it("should parse a basic workflow test with expect", () => {
+    const parser = xanoscriptParser(`workflow_test foo {
+      stack {
+        var $a {
+          value = 22
+        }
+        var $b {
+          value = $a + 20
+        }
+
+        expect.to_equal ($b) {
+          value = 42
+        }
+      }
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should be able to call an addon function in a workflow test", () => {
+    const parser = xanoscriptParser(`workflow_test test {
+      stack {
+        addon.call "" {
+          input = {ids: []|push:1|push:2}
+        } as $addon1
+      }
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should parse a workflow test with a function test call", () => {
+    const parser = xanoscriptParser(`workflow_test foo {
+      stack {
+        function.call add {
+          input = {a: 5, b: 10}
+        } as $sums
+      
+        expect.to_equal ($sum) {
+          value = 15
+        }
+      }
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should parse a workflow test with a task test call", () => {
+    const parser = xanoscriptParser(`workflow_test foo {
+      stack {
+        task.call "count to 10" as $test1
+      }
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should parse a workflow test with an api call", () => {
+    const parser = xanoscriptParser(`workflow_test foo {
+      stack {
+        api.call sum verb=GET {
+          api_group = "new api"
+          headers = ""
+          input = {a: 22, b: 33}
+        } as $sum
+      }
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+});

package/parser/workspace_parser.js

@@ -0,0 +1,38 @@
+import { StringLiteral } from "../lexer/literal.js";
+import { Identifier, NewlineToken } from "../lexer/tokens.js";
+import { WorkspaceToken } from "../lexer/workspace.js";
+
+export function workspaceDeclaration($) {
+  return () => {
+    $.sectionStack.push("workspaceDeclaration");
+    // Allow leading comments and newlines before the workspace declaration
+    $.SUBRULE($.optionalCommentBlockFn);
+
+    const parent = $.CONSUME(WorkspaceToken); // workspace
+    $.OR([
+      { ALT: () => $.CONSUME(StringLiteral) },
+      { ALT: () => $.CONSUME(Identifier) },
+    ]);
+
+    $.SUBRULE($.schemaParseAttributeFn, {
+      ARGS: [
+        parent,
+        {
+          "env?": { "[string]": "[string]" },
+          "acceptance?": { "ai_terms?": "[boolean]" },
+          "description?": "[string]",
+          "preferences?": {
+            "internal_docs?": "[boolean]",
+            "sql_columns?": "[boolean]",
+            "sql_names?": "[boolean]",
+            "track_performance?": "[boolean]",
+          },
+          "realtime?": { "canonical?": "[string]" },
+        },
+      ],
+    });
+
+    $.MANY2(() => $.CONSUME2(NewlineToken)); // optional new line
+    $.sectionStack.pop();
+  };
+}

package/parser/workspace_parser.spec.js

@@ -0,0 +1,142 @@
+import { expect } from "chai";
+import { describe, it } from "mocha";
+import { xanoscriptParser } from "./parser.js";
+
+describe("workspace_parser", () => {
+  it("should parse a basic workspace with identifier", () => {
+    const parser = xanoscriptParser(`workspace my_workspace`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should parse a basic workspace with string literal", () => {
+    const parser = xanoscriptParser(`workspace "my workspace"`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should parse workspace with description", () => {
+    const parser = xanoscriptParser(`workspace my_workspace {
+      description = "This is my workspace"
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should parse workspace with acceptance clause", () => {
+    const parser = xanoscriptParser(`workspace my_workspace {
+      acceptance = {
+        ai_terms: true
+      }
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should parse workspace with preferences clause", () => {
+    const parser = xanoscriptParser(`workspace my_workspace {
+      preferences = {
+        internal_docs: true
+        sql_columns: false
+        sql_names: true
+        track_performance: false
+      }
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should parse workspace with realtime clause", () => {
+    const parser = xanoscriptParser(`workspace my_workspace {
+      realtime = {
+        canonical: "wss://example.com"
+      }
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should parse workspace with all clauses", () => {
+    const parser = xanoscriptParser(`workspace my_workspace {
+      description = "Full workspace example"
+
+      acceptance = {
+        ai_terms: true
+      }
+
+      preferences = {
+        internal_docs: true
+        sql_columns: true
+        sql_names: false
+        track_performance: true
+      }
+
+      realtime = {
+        canonical: "wss://example.com/realtime"
+      }
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should parse workspace with partial preferences", () => {
+    const parser = xanoscriptParser(`workspace my_workspace {
+      preferences = {
+        internal_docs: true
+      }
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should not allow duplicate acceptance clauses", () => {
+    const parser = xanoscriptParser(`workspace my_workspace {
+      acceptance = {
+        ai_terms: true
+      }
+      acceptance = {
+        ai_terms: false
+      }
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("should not allow duplicate description clauses", () => {
+    const parser = xanoscriptParser(`workspace my_workspace {
+      description = "First description"
+      description = "Second description"
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("should not allow duplicate preferences clauses", () => {
+    const parser = xanoscriptParser(`workspace my_workspace {
+      preferences = {
+        internal_docs: true
+      }
+      preferences = {
+        sql_columns: false
+      }
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("should not allow duplicate realtime clauses", () => {
+    const parser = xanoscriptParser(`workspace my_workspace {
+      realtime = {
+        canonical: "wss://example.com"
+      }
+      realtime = {
+        canonical: "wss://other.com"
+      }
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("should require workspace name", () => {
+    const parser = xanoscriptParser(`workspace {
+    }`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("should parse workspace with empty clauses", () => {
+    const parser = xanoscriptParser(`workspace my_workspace {
+      acceptance = {}
+      preferences = {}
+      realtime = {}
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+});