@xano/xanoscript-language-server 11.0.3

package/parser/middleware_parser.js

@@ -0,0 +1,137 @@
+import { EqualToken, LCurly, RCurly } from "../lexer/control.js";
+import { StringLiteral } from "../lexer/literal.js";
+import {
+  ExceptionPolicyToken,
+  MiddlewareToken,
+  ResponseStrategyToken,
+} from "../lexer/middleware.js";
+import { Identifier, NewlineToken } from "../lexer/tokens.js";
+
+export function middlewareDeclaration($) {
+  return () => {
+    let hasDescription = false;
+    let hasDocs = false;
+    let hasExceptionPolicy = false;
+    let hasHistory = false;
+    let hasInput = false;
+    let hasResponse = false;
+    let hasResponseStrategy = false;
+    let hasStack = false;
+    let hasTags = false;
+
+    const testNames = [];
+
+    $.sectionStack.push("middlewareDeclaration");
+    // Allow leading comments and newlines before the middleware declaration
+    $.SUBRULE($.optionalCommentBlockFn);
+
+    const parent = $.CONSUME(MiddlewareToken);
+    $.OR([
+      { ALT: () => $.CONSUME(Identifier) },
+      { ALT: () => $.CONSUME(StringLiteral) },
+    ]);
+    $.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: () => !hasExceptionPolicy,
+          ALT: () => {
+            hasExceptionPolicy = true;
+
+            $.CONSUME(ExceptionPolicyToken);
+            $.CONSUME(EqualToken);
+            $.SUBRULE($.enumValue, {
+              ARGS: ["silent", "rethrow", "critical"],
+            });
+          },
+        },
+        {
+          GATE: () => !hasHistory,
+          ALT: () => {
+            hasHistory = true;
+            $.SUBRULE($.historyClause);
+          },
+        },
+        {
+          GATE: () => !hasInput,
+          ALT: () => {
+            hasInput = true;
+            $.SUBRULE($.inputClause);
+          },
+        },
+        {
+          GATE: () => !hasResponse,
+          ALT: () => {
+            hasResponse = true;
+            $.SUBRULE($.responseClause);
+          },
+        },
+        {
+          GATE: () => !hasResponseStrategy,
+          ALT: () => {
+            hasResponseStrategy = true;
+
+            $.CONSUME(ResponseStrategyToken);
+            $.CONSUME2(EqualToken);
+            $.SUBRULE2($.enumValue, { ARGS: ["merge", "replace"] });
+          },
+        },
+        {
+          GATE: () => !hasStack,
+          ALT: () => {
+            hasStack = true;
+            $.SUBRULE($.stackClause);
+          },
+        },
+        {
+          GATE: () => !hasTags,
+          ALT: () => {
+            hasTags = true;
+            $.SUBRULE($.tagsAttribute);
+          },
+        },
+        {
+          // no GATE here, you can have multiple test clauses
+          ALT: () => {
+            $.SUBRULE($.testClause, { ARGS: [testNames] });
+          },
+        },
+      ]);
+    });
+
+    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/middleware_parser.spec.js

@@ -0,0 +1,203 @@
+import { expect } from "chai";
+import { describe, it } from "mocha";
+import { xanoscriptParser } from "./parser.js";
+
+describe("middleware_parser", () => {
+  it("should parse a basic middleware", () => {
+    const parser = xanoscriptParser(`middleware foo {
+      input {
+      }
+
+      stack {
+      }
+
+      response = null
+    }`);
+
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should not parse a basic a middleware with slashes", () => {
+    const parser = xanoscriptParser(`middleware foo/bar {
+      input {
+      }
+
+      stack {
+      }
+
+      response = null
+    }`);
+
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("should parse a basic a string middleware url", () => {
+    const parser = xanoscriptParser(`middleware "foo/bar" {
+      input {
+      }
+
+      stack {
+      }
+
+      response = null
+    }`);
+
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("middleware don't accept dynamic params", () => {
+    const parser = xanoscriptParser(`middleware foo/{user_id} {
+      input {
+        text user_id filters=trim
+      }
+
+      stack {
+      }
+
+      response = null
+    }`);
+
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  describe("ResponseStrategy", () => {
+    it("should parse middleware with response_strategy = 'merge'", () => {
+      const parser = xanoscriptParser(`middleware test_merge {
+        response_strategy = "merge"
+
+        input {
+        }
+
+        stack {
+        }
+
+        response = null
+      }`);
+
+      expect(parser.errors).to.be.empty;
+    });
+
+    it("should parse middleware with response_strategy = 'replace'", () => {
+      const parser = xanoscriptParser(`middleware test_replace {
+        response_strategy = "replace"
+
+        input {
+        }
+
+        stack {
+        }
+
+        response = null
+      }`);
+
+      expect(parser.errors).to.be.empty;
+    });
+
+    it("should error on invalid response_strategy value", () => {
+      const parser = xanoscriptParser(`middleware test_invalid {
+        response_strategy = "invalid"
+
+        input {
+        }
+
+        stack {
+        }
+
+        response = null
+      }`);
+
+      expect(parser.errors).to.not.be.empty;
+      expect(parser.errors[0].message).to.include('Invalid value "invalid"');
+      expect(parser.errors[0].message).to.include(
+        'Must be one of: "merge", "replace"'
+      );
+    });
+  });
+
+  describe("ExceptionPolicy", () => {
+    it("should parse middleware with exception_policy = 'silent'", () => {
+      const parser = xanoscriptParser(`middleware test_silent {
+        exception_policy = "silent"
+
+        input {
+        }
+
+        stack {
+        }
+
+        response = null
+      }`);
+
+      expect(parser.errors).to.be.empty;
+    });
+
+    it("should parse middleware with exception_policy = 'rethrow'", () => {
+      const parser = xanoscriptParser(`middleware test_rethrow {
+        exception_policy = "rethrow"
+
+        input {
+        }
+
+        stack {
+        }
+
+        response = null
+      }`);
+
+      expect(parser.errors).to.be.empty;
+    });
+
+    it("should parse middleware with exception_policy = 'critical'", () => {
+      const parser = xanoscriptParser(`middleware test_critical {
+        exception_policy = "critical"
+
+        input {
+        }
+
+        stack {
+        }
+
+        response = null
+      }`);
+
+      expect(parser.errors).to.be.empty;
+    });
+
+    it("should error on invalid exception_policy value", () => {
+      const parser = xanoscriptParser(`middleware test_invalid {
+        exception_policy = "invalid"
+
+        input {
+        }
+
+        stack {
+        }
+
+        response = null
+      }`);
+
+      expect(parser.errors).to.not.be.empty;
+      expect(parser.errors[0].message).to.include('Invalid value "invalid"');
+      expect(parser.errors[0].message).to.include(
+        'Must be one of: "silent", "rethrow", "critical"'
+      );
+    });
+  });
+
+  it("should parse middleware with both response_strategy and exception_policy", () => {
+    const parser = xanoscriptParser(`middleware test_combined {
+      response_strategy = "merge"
+      exception_policy = "rethrow"
+
+      input {
+      }
+
+      stack {
+      }
+
+      response = null
+    }`);
+
+    expect(parser.errors).to.be.empty;
+  });
+});

package/parser/parser.js

@@ -0,0 +1,87 @@
+import { lexDocument } from "../lexer/lexer.js";
+import { allTokens } from "../lexer/tokens.js";
+import { getSchemeFromContent } from "../utils.js";
+import { XanoBaseParser } from "./base_parser.js";
+
+/**
+ * Will parse the content of the file based on its scheme (db:/, task:/, api:/...)
+ * @param {string} scheme
+ * @param {string} text
+ * @returns
+ */
+export function xanoscriptParser(text, scheme) {
+  if (!scheme) {
+    scheme = getSchemeFromContent(text);
+  }
+  const lexResult = lexDocument(text);
+  parser.input = lexResult.tokens;
+  switch (scheme.toLowerCase()) {
+    case "addon":
+      parser.addonDeclaration();
+      return parser;
+    case "agent":
+      parser.agentDeclaration();
+      return parser;
+    case "agent_trigger":
+      parser.agentTriggerDeclaration();
+      return parser;
+    case "api":
+      parser.queryDeclaration();
+      return parser;
+    case "api_group":
+      parser.apiGroupDeclaration();
+      return parser;
+    case "branch":
+      parser.branchDeclaration();
+      return parser;
+    case "db":
+      parser.tableDeclaration();
+      return parser;
+    case "mcp_server":
+      parser.mcpServerDeclaration();
+      return parser;
+    case "mcp_server_trigger":
+      parser.mcpServerTriggerDeclaration();
+      return parser;
+    case "middleware":
+      parser.middlewareDeclaration();
+      return parser;
+    case "realtime_trigger":
+      parser.realtimeTriggerDeclaration();
+      return parser;
+    case "realtime_channel":
+      parser.realtimeChannelDeclaration();
+      return parser;
+    case "table_trigger":
+      parser.tableTriggerDeclaration();
+      return parser;
+    case "task":
+      parser.taskDeclaration();
+      return parser;
+    case "tool":
+      parser.toolDeclaration();
+      return parser;
+    case "workflow_test":
+      parser.workflowTestDeclaration();
+      return parser;
+    case "workspace":
+      parser.workspaceDeclaration();
+      return parser;
+    case "workspace_trigger":
+      parser.workspaceTriggerDeclaration();
+      return parser;
+    case "cfn":
+    default: // Default to function parser
+      parser.functionDeclaration();
+      return parser;
+  }
+}
+
+export class XanoScriptParser extends XanoBaseParser {
+  constructor() {
+    super(allTokens);
+    this.performSelfAnalysis(); // Validates grammar and prepares parser
+  }
+}
+
+export const parser = new XanoScriptParser();

package/parser/query_parser.js

@@ -0,0 +1,183 @@
+import { ApiGroupToken } from "../lexer/api_group.js";
+import { CommentToken } from "../lexer/comment.js";
+import { EqualToken, LCurly, RCurly } from "../lexer/control.js";
+import { StringLiteral } from "../lexer/literal.js";
+import {
+  DELETEToken,
+  GETToken,
+  PATCHToken,
+  POSTToken,
+  PUTToken,
+  QueryToken,
+  ResponseTypeToken,
+  VerbToken,
+} from "../lexer/query.js";
+import { AuthToken, Identifier, NewlineToken } from "../lexer/tokens.js";
+import { getVarName } from "./generic/utils.js";
+
+export function queryDeclaration($) {
+  return () => {
+    let hasAuth = false;
+    let hasCache = false;
+    let hasDescription = false;
+    let hasDocs = false;
+    let hasHistory = false;
+    let hasInput = false;
+    let hasMiddleware = false;
+    let hasResponse = false;
+    let hasStack = false;
+    let hasTags = false;
+    let hasApiGroup = false;
+    let hasResponseType = false;
+
+    const testNames = [];
+
+    $.sectionStack.push("queryDeclaration");
+    // Allow leading comments and newlines before the query declaration
+    $.SUBRULE($.optionalCommentBlockFn);
+
+    const parent = $.CONSUME(QueryToken);
+    $.OR([
+      { ALT: () => $.CONSUME(StringLiteral) }, // "foo/bar"
+      { ALT: () => $.CONSUME(Identifier) }, // foo
+    ]);
+    $.CONSUME(VerbToken);
+    $.CONSUME(EqualToken);
+    $.OR1([
+      { ALT: () => $.CONSUME(DELETEToken) },
+      { ALT: () => $.CONSUME(GETToken) },
+      { ALT: () => $.CONSUME(PATCHToken) },
+      { ALT: () => $.CONSUME(POSTToken) },
+      { ALT: () => $.CONSUME(PUTToken) },
+    ]);
+    $.CONSUME(LCurly); // "{"
+    $.MANY(() => {
+      $.AT_LEAST_ONE(() => $.CONSUME(NewlineToken)); // at least one new line
+      $.OR2([
+        {
+          ALT: () => $.CONSUME(CommentToken),
+        },
+        {
+          GATE: () => !hasAuth,
+          ALT: () => {
+            hasAuth = true;
+            $.CONSUME(AuthToken); // "auth"
+            $.CONSUME1(EqualToken); // "="
+            $.CONSUME1(StringLiteral); // "user"
+          },
+        },
+        {
+          GATE: () => !hasResponseType,
+          ALT: () => {
+            hasResponseType = true;
+            $.CONSUME(ResponseTypeToken);
+            $.CONSUME8(EqualToken);
+            const valueToken = $.CONSUME2(StringLiteral);
+            const value = getVarName(valueToken);
+            if (!["stream", "standard"].includes(value)) {
+              $.addInvalidValueError(
+                valueToken,
+                "response_type must be either 'stream' or 'standard'"
+              );
+            }
+          },
+        },
+        {
+          GATE: () => !hasCache,
+          ALT: () => {
+            hasCache = true;
+            $.SUBRULE($.cacheClause);
+          },
+        },
+        {
+          GATE: () => !hasDescription,
+          ALT: () => {
+            hasDescription = true;
+            $.SUBRULE($.descriptionFieldAttribute);
+          },
+        },
+        {
+          GATE: () => !hasApiGroup,
+          ALT: () => {
+            hasApiGroup = true;
+            $.CONSUME(ApiGroupToken);
+            $.CONSUME2(EqualToken);
+            $.CONSUME3(StringLiteral);
+          },
+        },
+        {
+          GATE: () => !hasDocs,
+          ALT: () => {
+            hasDocs = true;
+            $.SUBRULE($.docsFieldAttribute);
+          },
+        },
+        {
+          GATE: () => !hasHistory,
+          ALT: () => {
+            hasHistory = true;
+            $.SUBRULE($.historyClause);
+          },
+        },
+        {
+          GATE: () => !hasInput,
+          ALT: () => {
+            hasInput = true;
+            $.SUBRULE($.inputClause);
+          },
+        },
+        {
+          GATE: () => !hasMiddleware,
+          ALT: () => {
+            hasMiddleware = true;
+            $.SUBRULE($.middlewareClause);
+          },
+        },
+        {
+          GATE: () => !hasResponse,
+          ALT: () => {
+            hasResponse = true;
+            $.SUBRULE($.responseClause);
+          },
+        },
+        {
+          GATE: () => !hasStack,
+          ALT: () => {
+            hasStack = true;
+            $.SUBRULE($.stackClause);
+          },
+        },
+        {
+          GATE: () => !hasTags,
+          ALT: () => {
+            hasTags = true;
+            $.SUBRULE($.tagsAttribute);
+          },
+        },
+        {
+          // no GATE here, you can have multiple test clauses
+          ALT: () => {
+            $.SUBRULE($.testClause, { ARGS: [testNames] });
+          },
+        },
+      ]);
+    });
+
+    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();
+  };
+}