@xano/xanoscript-language-server 11.0.3

package/parser/clauses/middlewareClause.js

@@ -0,0 +1,39 @@
+import { EqualToken } from "../../lexer/control.js";
+import { MiddlewareToken } from "../../lexer/tokens.js";
+
+/**
+ * response = $entries
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ * @returns
+ */
+export function middlewareClause($) {
+  return () => {
+    $.sectionStack.push("middlewareClause");
+
+    const parent = $.CONSUME(MiddlewareToken); // "middleware"
+    $.CONSUME(EqualToken); // "="
+    $.SUBRULE($.schemaParseObjectFn, {
+      ARGS: [
+        parent,
+        {
+          "pre?": [
+            {
+              name: "[string]",
+              "active?": "[boolean]",
+              "required?": "[boolean]",
+            },
+          ],
+          "post?": [
+            {
+              name: "[string]",
+              "active?": "[boolean]",
+              "required?": "[boolean]",
+            },
+          ],
+        },
+      ],
+    });
+
+    $.sectionStack.pop();
+  };
+}

package/parser/clauses/middlewareClause.spec.js

@@ -0,0 +1,161 @@
+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.middlewareClause();
+  return parser;
+}
+
+describe("middlewareClause", () => {
+  it("middlewareClause accepts empty pre", () => {
+    const parser = parse(`middleware = {
+      pre: []
+    }`);
+
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("middlewareClause accepts empty post", () => {
+    const parser = parse(`middleware = {
+      post: []
+    }`);
+
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("middlewareClause accepts both pre and post", () => {
+    const parser = parse(`middleware = {
+      pre: []
+      post: []
+    }`);
+
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("middlewareClause accepts pre with single middleware object", () => {
+    const parser = parse(`middleware = {
+      pre: [{
+        name: "auth_middleware"
+      }]
+    }`);
+
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("middlewareClause accepts post with single middleware object", () => {
+    const parser = parse(`middleware = {
+      post: [{
+        name: "logging_middleware"
+      }]
+    }`);
+
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("middlewareClause accepts pre with multiple middleware objects", () => {
+    const parser = parse(`middleware = {
+      pre: [
+        {name: "auth_middleware"}
+        {name: "validation_middleware"}
+      ]
+    }`);
+
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("middlewareClause accepts middleware with required attribute", () => {
+    const parser = parse(`middleware = {
+      pre: [{
+        name: "auth_middleware"
+        required: true
+      }]
+    }`);
+
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("middlewareClause accepts middleware with required set to false", () => {
+    const parser = parse(`middleware = {
+      pre: [{
+        name: "optional_middleware"
+        required: false
+      }]
+    }`);
+
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("middlewareClause accepts complex configuration with both pre and post", () => {
+    const parser = parse(`middleware = {
+      pre: [
+        {name: "auth_middleware", required: true}
+        {name: "rate_limiter", required: false}
+      ]
+      post: [
+        {name: "logging_middleware"}
+      ]
+    }`);
+
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("middlewareClause accepts middleware object with only name", () => {
+    const parser = parse(`middleware = {
+      pre: [{
+        name: "auth_middleware"
+      }]
+    }`);
+
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("middlewareClause accepts middleware with both attributes using colon syntax", () => {
+    const parser = parse(`middleware = {
+      pre: [{name: "auth_middleware", required: true}]
+    }`);
+
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("middlewareClause rejects unknown attributes at top level", () => {
+    const parser = parse(`middleware = {
+      pre: []
+      unknown = true
+    }`);
+
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("middlewareClause accepts middleware with multiline formatting", () => {
+    const parser = parse(`middleware = {
+      pre: [
+        {
+          name: "auth_middleware"
+          required: true
+        }
+        {
+          name: "validation_middleware"
+          required: false
+        }
+      ]
+      post: [
+        {
+          name: "logging_middleware"
+        }
+      ]
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("middlewareClause cannot accepts empty middleware block", () => {
+    const parser = parse(`middleware = {
+    }`);
+
+    expect(parser.errors).to.not.be.empty;
+  });
+});

package/parser/clauses/nakedStackFn.js

@@ -0,0 +1,69 @@
+import { ExclamationToken } from "../../lexer/cast.js";
+import { CommentToken } from "../../lexer/comment.js";
+import { LCurly, RCurly } from "../../lexer/control.js";
+import { NewlineToken } from "../../lexer/tokens.js";
+
+export const DEFAULT_OPTIONS = {
+  allowExpectStatements: false,
+  allowCallStatements: false,
+};
+
+/**
+ * Similar to stackClause, but without the stack token
+ * this is so it can be used in a group, conditional, loops...
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export function nakedStackFn($) {
+  return (options = {}) => {
+    options = { ...DEFAULT_OPTIONS, ...options };
+
+    $.sectionStack.push("nakedStackFn");
+    $.CONSUME(LCurly); // "{"
+    $.MANY(() => {
+      $.AT_LEAST_ONE1(() => $.CONSUME1(NewlineToken)); // required new line before each clause
+      $.OPTION(() => $.CONSUME(ExclamationToken)); // optional "!" to continue on error
+      $.OR([
+        { ALT: () => $.CONSUME(CommentToken) },
+        { ALT: () => $.SUBRULE($.aiFn) },
+        { ALT: () => $.SUBRULE($.dbFn) },
+        { ALT: () => $.SUBRULE($.varFn) },
+        { ALT: () => $.SUBRULE($.arrayFn) },
+        { ALT: () => $.SUBRULE($.cloudFn) },
+        { ALT: () => $.SUBRULE($.securityFn) },
+        { ALT: () => $.SUBRULE($.mathFn) },
+        { ALT: () => $.SUBRULE($.textFn) },
+        { ALT: () => $.SUBRULE($.utilFn) },
+        { ALT: () => $.SUBRULE($.preconditionFn) },
+        { ALT: () => $.SUBRULE($.zipFn) },
+        { ALT: () => $.SUBRULE($.objectFn) },
+        { ALT: () => $.SUBRULE($.apiFn, { ARGS: [options] }) },
+        { ALT: () => $.SUBRULE($.webflowFn) },
+        { ALT: () => $.SUBRULE($.redisFn) },
+        { ALT: () => $.SUBRULE($.controlFn, { ARGS: [options] }) },
+        { ALT: () => $.SUBRULE($.debugFn) },
+        { ALT: () => $.SUBRULE($.storageFn) },
+        { ALT: () => $.SUBRULE($.streamFn) },
+        { ALT: () => $.SUBRULE($.actionCallFn) },
+        {
+          GATE: () => options.allowCallStatements,
+          ALT: () => $.SUBRULE($.toolCallFn),
+        },
+        {
+          GATE: () => options.allowCallStatements,
+          ALT: () => $.SUBRULE($.addonCallFn),
+        },
+        {
+          GATE: () => options.allowCallStatements,
+          ALT: () => $.SUBRULE($.middlewareCallFn),
+        },
+        {
+          GATE: () => options.allowExpectStatements,
+          ALT: () => $.SUBRULE($.workflowExpectFn),
+        },
+      ]);
+    });
+    $.AT_LEAST_ONE2(() => $.CONSUME2(NewlineToken));
+    $.CONSUME(RCurly); // "}"
+    $.sectionStack.pop();
+  };
+}

package/parser/clauses/nakedStackFn.spec.js

@@ -0,0 +1,63 @@
+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.nakedStackFn();
+  return parser;
+}
+
+describe("nakedStack", () => {
+  it("nakedStack accepts as single statement", () => {
+    const parser = parse(`{
+  var $some_var { 
+    value = "value"
+  }
+}`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("nakedStack accepts a disabled statement", () => {
+    const parser = parse(`{
+  !var $some_var { 
+    value = "value"
+  }
+}`);
+
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("nakedStack accepts a multiline statement", () => {
+    const parser = parse(`{
+  var $some_var { 
+    value = "value"
+  }
+
+  var.update $some_var { 
+    value = "value2"
+  }
+}`);
+
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("nakedStack accepts a multiline comments", () => {
+    const parser = parse(`{
+  var $some_var { 
+    value = "value"
+  }
+
+  // Comment here
+  // Another comment
+  
+  var.update $some_var { 
+    value = "value2"
+  }
+}`);
+    expect(parser.errors).to.be.empty;
+  });
+});

package/parser/clauses/outputClause.js

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

package/parser/clauses/register.js

@@ -0,0 +1,50 @@
+import { agentClause } from "./agentClause.js";
+import { authClause } from "./authClause.js";
+import { cacheClause } from "./cacheClause.js";
+import { canonicalClause } from "./canonicalClause.js";
+import { channelClause } from "./channelClause.js";
+import { dbTableClause } from "./dbTableClause.js";
+import { flexibleStringClause } from "./flexibleStringClause.js";
+import { historyClause } from "./historyClause.js";
+import { indexClause } from "./indexClause.js";
+import { inputClause } from "./inputClause.js";
+import { mcpServerClause } from "./mcpServerClause.js";
+import { middlewareClause } from "./middlewareClause.js";
+import { nakedStackFn } from "./nakedStackFn.js";
+import { outputClause } from "./outputClause.js";
+import { responseClause } from "./responseClause.js";
+import { scheduleClause } from "./scheduleClause.js";
+import { schemaClause } from "./schemaClause.js";
+import { stackClause } from "./stackClause.js";
+import { testClause } from "./testClause.js";
+import { viewClause } from "./viewClause.js";
+
+/**
+ * Registers all the parsers in this folder
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export const register = ($) => {
+  $.agentClause = $.RULE("agentClause", agentClause($));
+  $.authClause = $.RULE("authClause", authClause($));
+  $.cacheClause = $.RULE("cacheClause", cacheClause($));
+  $.canonicalClause = $.RULE("canonicalClause", canonicalClause($));
+  $.channelClause = $.RULE("channelClause", channelClause($));
+  $.dbTableClause = $.RULE("dbTableClause", dbTableClause($));
+  $.flexibleStringClause = $.RULE(
+    "flexibleStringClause",
+    flexibleStringClause($)
+  );
+  $.historyClause = $.RULE("historyClause", historyClause($));
+  $.indexClause = $.RULE("indexClause", indexClause($));
+  $.inputClause = $.RULE("inputClause", inputClause($));
+  $.outputClause = $.RULE("outputClause", outputClause($));
+  $.mcpServerClause = $.RULE("mcpServerClause", mcpServerClause($));
+  $.middlewareClause = $.RULE("middlewareClause", middlewareClause($));
+  $.nakedStackFn = $.RULE("nakedStackFn", nakedStackFn($));
+  $.responseClause = $.RULE("responseClause", responseClause($));
+  $.scheduleClause = $.RULE("scheduleClause", scheduleClause($));
+  $.schemaClause = $.RULE("schemaClause", schemaClause($));
+  $.stackClause = $.RULE("stackClause", stackClause($));
+  $.testClause = $.RULE("testClause", testClause($));
+  $.viewClause = $.RULE("viewClause", viewClause($));
+};

package/parser/clauses/responseClause.js

@@ -0,0 +1,17 @@
+import { EqualToken } from "../../lexer/control.js";
+import { ResponseToken } from "../../lexer/tokens.js";
+
+/**
+ * response = $entries
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ * @returns
+ */
+export function responseClause($) {
+  return () => {
+    $.sectionStack.push("responseClause");
+    const parent = $.CONSUME(ResponseToken); // "response"
+    $.CONSUME(EqualToken); // "="
+    $.SUBRULE($.expressionFn, { ARGS: [parent, { allowDisabledKeys: true }] }); // e.g., { !key: value }
+    $.sectionStack.pop();
+  };
+}

package/parser/clauses/responseClause.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.responseClause();
+  return parser;
+}
+
+describe("responseClause", () => {
+  it("responseClause accepts a variable value", () => {
+    const parser = parse(`response = $x1`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("responseClause accepts a variable value with a filter", () => {
+    const parser = parse(`response = $x1|trim`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("responseClause accepts a boolean value", () => {
+    const parser = parse(`response = true`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("responseClause accepts an object", () => {
+    const parser = parse(`response = {result1: $x1, x2: $x2}`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("responseClause accepts multiple line object", () => {
+    const parser = parse(`response = {
+      result1: $x1
+      x2: $x2
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+});

package/parser/clauses/scheduleClause.js

@@ -0,0 +1,37 @@
+import { EqualToken } from "../../lexer/control.js";
+import { ScheduleToken } from "../../lexer/task.js";
+
+/**
+ * schedule = [
+ *   {starts_on: 2025-10-14 12:47:59+0000}
+ *   {starts_on: 2025-10-14 12:48:02+0000, freq: 86400}
+ *   {
+ *     starts_on: 2025-10-14 12:48:05+0000
+ *     freq     : 259200
+ *     ends_on  : 2025-10-14 12:48:05+0000
+ *   }
+ * ]
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ * @returns
+ */
+export function scheduleClause($) {
+  return () => {
+    $.sectionStack.push("scheduleClause");
+    const parent = $.CONSUME(ScheduleToken); // "schedule"
+    $.CONSUME(EqualToken); // "="
+    $.SUBRULE($.schemaFn, {
+      ARGS: [
+        parent,
+        [
+          {
+            starts_on: "[timestamp]",
+            "ends_on?": "[timestamp]",
+            "freq?": "[number]",
+          },
+        ],
+      ],
+    });
+
+    $.sectionStack.pop();
+  };
+}

package/parser/clauses/scheduleClause.spec.js

@@ -0,0 +1,71 @@
+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.scheduleClause();
+  return parser;
+}
+
+describe("scheduleClause", () => {
+  it("scheduleClause accepts an empty event", () => {
+    const parser = parse(`schedule = []`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("scheduleClause accepts a start time alone", () => {
+    const parser = parse(`schedule = [
+      {starts_on: 2025-03-17 18:33:50+0000}
+    ]`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("scheduleClause reject a schedule without a start time", () => {
+    const parser = parse(`schedule = [
+      {ends_on: 2025-03-17 18:33:50+0000, freq: 172800}
+    ]`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("scheduleClause accepts a start time and frequency", () => {
+    const parser = parse(`schedule = [
+      {starts_on: 2025-03-17 18:33:55+0000, freq: 172800}
+    ]`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("scheduleClause requires a commas when time is defined on a single line", () => {
+    const parser = parse(`schedule = [
+      {starts_on: 2025-03-17 18:33:55+0000 freq: 172800}
+    ]`);
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("scheduleClause accepts a start time, frequency, and end time", () => {
+    const parser = parse(`schedule = [
+      {
+        starts_on: 2025-03-17 18:34:02+0000
+        freq: 604800
+        ends_on: 2029-03-15 18:34:02+0000
+      }
+    ]`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("scheduleClause accepts multiple times", () => {
+    const parser = parse(`schedule = [
+      {starts_on: 2025-03-17 18:33:50+0000}
+      {starts_on: 2025-03-17 18:33:55+0000, freq: 172800}
+      {
+        starts_on: 2025-03-17 18:34:02+0000
+        freq: 604800
+        ends_on: 2029-03-15 18:34:02+0000
+      }
+    ]`);
+    expect(parser.errors).to.be.empty;
+  });
+});

package/parser/clauses/schemaClause.js

@@ -0,0 +1,66 @@
+import { CommentToken } from "../../lexer/comment.js";
+import { LCurly, RCurly } from "../../lexer/control.js";
+import { NewlineToken, SchemaToken } from "../../lexer/tokens.js";
+
+const DEFAULT_CONFIG = {
+  include_file: true,
+  isTableSchema: false, // enforces that "id" column can only be int or uuid
+};
+
+/**
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export function schemaClause($) {
+  return (config = {}, schema = {}) => {
+    config = { ...DEFAULT_CONFIG, ...config };
+
+    // if not provided, we'll include the file definition
+    $.sectionStack.push("schemaClause");
+    const parent = $.CONSUME(SchemaToken); // "schema"
+    $.OPTION(() => {
+      $.CONSUME(LCurly); // "{"
+      $.MANY(() => {
+        $.AT_LEAST_ONE1(() => $.CONSUME1(NewlineToken)); // at least one new line
+        $.OR([
+          { ALT: () => $.CONSUME(CommentToken) },
+          {
+            ALT: () => $.SUBRULE($.objectColumnDefinition, { ARGS: [schema] }),
+          },
+          { ALT: () => $.SUBRULE($.enumColumnDefinition, { ARGS: [schema] }) },
+          {
+            ALT: () =>
+              $.SUBRULE($.columnDefinition, {
+                ARGS: [
+                  {
+                    include_file: config.include_file,
+                    isTableSchema: config.isTableSchema,
+                  },
+                  schema,
+                ],
+              }),
+          },
+        ]);
+      });
+      $.MANY1(() => $.CONSUME2(NewlineToken)); // at least one new line
+      $.CONSUME(RCurly); // "}"
+    });
+
+    if (config.isTableSchema) {
+      // a table should have an id column
+      const idColumn = schema["id"];
+      if (!idColumn) {
+        $.addMissingError(
+          parent,
+          "{} must have an 'id' of type uuid or int column defined"
+        );
+      } else if (!["int", "uuid"].includes(idColumn.typeToken.image)) {
+        $.addInvalidValueError(
+          idColumn.typeToken,
+          `The "id" column can only be of type "int" or "uuid"`
+        );
+      }
+    }
+
+    $.sectionStack.pop();
+  };
+}