@xano/xanoscript-language-server 11.0.3

package/parser/realtime_trigger_parser.spec.js

@@ -0,0 +1,469 @@
+import { expect } from "chai";
+import { describe, it } from "mocha";
+import { xanoscriptParser } from "./parser.js";
+
+describe("realtime_trigger", () => {
+  it("should parse a complete realtime_trigger with all clauses", () => {
+    const parser = xanoscriptParser(`realtime_trigger foo {
+      channel = "blah"
+      actions = {join: true, message: true}
+      active = true
+      description = "Test trigger"
+      tags = ["tag1", "tag2"]
+
+      input {
+        text message
+      }
+
+      stack {
+      }
+
+      response = null
+
+      history = false
+    }`);
+
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should parse a basic realtime_trigger with required clauses", () => {
+    const parser = xanoscriptParser(`realtime_trigger foo {
+      channel = "blah"
+      actions = {join: true}
+
+      input {
+      }
+
+      stack {
+      }
+
+      response = null
+    }`);
+
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should parse realtime_trigger with string literal name", () => {
+    const parser = xanoscriptParser(`realtime_trigger "my-trigger" {
+      channel = "blah"
+      actions = {join: true}
+
+      input {
+      }
+
+      stack {
+      }
+
+      response = null
+    }`);
+
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should error when missing channel clause", () => {
+    const parser = xanoscriptParser(`realtime_trigger foo {
+      actions = {join: false}
+
+      input {
+      }
+
+      stack {
+      }
+
+      response = null
+    }`);
+
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("should error when missing input clause", () => {
+    const parser = xanoscriptParser(`realtime_trigger foo {
+      channel = "blah"
+      actions = {join: false}
+
+      stack {
+      }
+
+      response = null
+    }`);
+
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("should error when missing stack clause", () => {
+    const parser = xanoscriptParser(`realtime_trigger foo {
+      channel = "blah"
+      actions = {join: false}
+
+      input {
+      }
+
+      response = null
+    }`);
+
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("should error when missing response clause", () => {
+    const parser = xanoscriptParser(`realtime_trigger foo {
+      channel = "blah"
+      actions = {join: false}
+
+      input {
+      }
+
+      stack {
+      }
+    }`);
+
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("should parse actions with join only", () => {
+    const parser = xanoscriptParser(`realtime_trigger foo {
+      channel = "blah"
+      actions = {join: true}
+
+      input {
+      }
+
+      stack {
+      }
+
+      response = null
+    }`);
+
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should parse actions with message only", () => {
+    const parser = xanoscriptParser(`realtime_trigger foo {
+      channel = "blah"
+      actions = {message: true}
+
+      input {
+      }
+
+      stack {
+      }
+
+      response = null
+    }`);
+
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should parse actions with both join and message", () => {
+    const parser = xanoscriptParser(`realtime_trigger foo {
+      channel = "blah"
+      actions = {join: false, message: true}
+
+      input {
+      }
+
+      stack {
+      }
+
+      response = null
+    }`);
+
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should not error when actions is empty", () => {
+    const parser = xanoscriptParser(`realtime_trigger foo {
+      channel = "blah"
+      actions = {}
+
+      input {
+      }
+
+      stack {
+      }
+
+      response = null
+    }`);
+
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should error when actions has duplicate fields", () => {
+    const parser = xanoscriptParser(`realtime_trigger foo {
+      channel = "blah"
+      actions = {join: true, join: false}
+
+      input {
+      }
+
+      stack {
+      }
+
+      response = null
+    }`);
+
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("should parse active attribute with true value", () => {
+    const parser = xanoscriptParser(`realtime_trigger foo {
+      channel = "blah"
+      actions = {join: true}
+      active = true
+
+      input {
+      }
+
+      stack {
+      }
+
+      response = null
+    }`);
+
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should parse active attribute with false value", () => {
+    const parser = xanoscriptParser(`realtime_trigger foo {
+      channel = "blah"
+      actions = {join: true}
+      active = false
+
+      input {
+      }
+
+      stack {
+      }
+
+      response = null
+    }`);
+
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should parse description attribute", () => {
+    const parser = xanoscriptParser(`realtime_trigger foo {
+      channel = "blah"
+      actions = {join: true}
+      description = "This is a test trigger"
+
+      input {
+      }
+
+      stack {
+      }
+
+      response = null
+    }`);
+
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should parse tags attribute", () => {
+    const parser = xanoscriptParser(`realtime_trigger foo {
+      channel = "blah"
+      actions = {join: true}
+      tags = ["websocket", "realtime"]
+
+      input {
+      }
+
+      stack {
+      }
+
+      response = null
+    }`);
+
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should parse history clause", () => {
+    const parser = xanoscriptParser(`realtime_trigger foo {
+      channel = "blah"
+      actions = {join: true}
+
+      input {
+      }
+
+      stack {
+      }
+
+      response = null
+
+      history = 100
+    }`);
+
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should error on duplicate channel clause", () => {
+    const parser = xanoscriptParser(`realtime_trigger foo {
+      channel = "blah"
+      channel = "other"
+      actions = {join: true}
+
+      input {
+      }
+
+      stack {
+      }
+
+      response = null
+    }`);
+
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("should error on duplicate actions clause", () => {
+    const parser = xanoscriptParser(`realtime_trigger foo {
+      channel = "blah"
+      actions = {join: true}
+      actions = {message: true}
+
+      input {
+      }
+
+      stack {
+      }
+
+      response = null
+    }`);
+
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("should error on duplicate active attribute", () => {
+    const parser = xanoscriptParser(`realtime_trigger foo {
+      channel = "blah"
+      actions = {join: true}
+      active = true
+      active = false
+
+      input {
+      }
+
+      stack {
+      }
+
+      response = null
+    }`);
+
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("should error on duplicate description attribute", () => {
+    const parser = xanoscriptParser(`realtime_trigger foo {
+      channel = "blah"
+      actions = {join: true}
+      description = "First"
+      description = "Second"
+
+      input {
+      }
+
+      stack {
+      }
+
+      response = null
+    }`);
+
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("should error on duplicate history clause", () => {
+    const parser = xanoscriptParser(`realtime_trigger foo {
+      channel = "blah"
+      actions = {join: true}
+
+      input {
+      }
+
+      stack {
+      }
+
+      response = null
+
+      history = false
+      history = false
+    }`);
+
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("should error on duplicate input clause", () => {
+    const parser = xanoscriptParser(`realtime_trigger foo {
+      channel = "blah"
+      actions = {join: true}
+
+      input {
+      }
+
+      input {
+      }
+
+      stack {
+      }
+
+      response = null
+    }`);
+
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("should error on duplicate response clause", () => {
+    const parser = xanoscriptParser(`realtime_trigger foo {
+      channel = "blah"
+      actions = {join: true}
+
+      input {
+      }
+
+      stack {
+      }
+
+      response = null
+
+      response = null
+    }`);
+
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("should error on duplicate stack clause", () => {
+    const parser = xanoscriptParser(`realtime_trigger foo {
+      channel = "blah"
+      actions = {join: true}
+
+      input {
+      }
+
+      stack {
+      }
+
+      stack {
+      }
+
+      response = null
+    }`);
+
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("should error on duplicate tags attribute", () => {
+    const parser = xanoscriptParser(`realtime_trigger foo {
+      channel = "blah"
+      actions = {join: true}
+      tags = ["tag1"]
+      tags = ["tag2"]
+
+      input {
+      }
+
+      stack {
+      }
+
+      response = null
+    }`);
+
+    expect(parser.errors).to.not.be.empty;
+  });
+});

package/parser/register.js

@@ -0,0 +1,88 @@
+import { addonDeclaration } from "./addon_parser.js";
+import { agentDeclaration } from "./agent_parser.js";
+import { agentTriggerDeclaration } from "./agent_trigger_parser.js";
+import { apiGroupDeclaration } from "./api_group_parser.js";
+import { register as register_attributes } from "./attributes/register.js";
+import { branchDeclaration } from "./branch_parser.js";
+import { register as register_clauses } from "./clauses/register.js";
+import { register as register_definitions } from "./definitions/register.js";
+import { functionDeclaration } from "./function_parser.js";
+import { register as register_functions } from "./functions/register.js";
+import { register as register_generic } from "./generic/register.js";
+import { mcpServerDeclaration } from "./mcp_server_parser.js";
+import { mcpServerTriggerDeclaration } from "./mcp_server_trigger_parser.js";
+import { register as register_metadata } from "./metadata/register.js";
+import { middlewareDeclaration } from "./middleware_parser.js";
+import { queryDeclaration } from "./query_parser.js";
+import { realtimeChannelDeclaration } from "./realtime_channel_parser.js";
+import { realtimeTriggerDeclaration } from "./realtime_trigger_parser.js";
+import { tableDeclaration } from "./table_parser.js";
+import { tableTriggerDeclaration } from "./table_trigger_parser.js";
+import { taskDeclaration } from "./task_parser.js";
+import { toolDeclaration } from "./tool_parser.js";
+import { workflowTestDeclaration } from "./workflow_test_parser.js";
+import { workspaceDeclaration } from "./workspace_parser.js";
+import { workspaceTriggerDeclaration } from "./workspace_trigger_parser.js";
+
+/**
+ * Registers all the parsers in this folder
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export const register = ($) => {
+  register_generic($);
+  register_definitions($);
+  register_attributes($);
+  register_functions($);
+  register_metadata($);
+  register_clauses($);
+
+  $.addonDeclaration = $.RULE("addonDeclaration", addonDeclaration($));
+  $.agentDeclaration = $.RULE("agentDeclaration", agentDeclaration($));
+  $.agentTriggerDeclaration = $.RULE(
+    "agentTriggerDeclaration",
+    agentTriggerDeclaration($)
+  );
+  $.queryDeclaration = $.RULE("queryDeclaration", queryDeclaration($));
+  $.apiGroupDeclaration = $.RULE("apiGroupDeclaration", apiGroupDeclaration($));
+  $.branchDeclaration = $.RULE("branchDeclaration", branchDeclaration($));
+  $.tableDeclaration = $.RULE("tableDeclaration", tableDeclaration($));
+  $.mcpServerDeclaration = $.RULE(
+    "mcpServerDeclaration",
+    mcpServerDeclaration($)
+  );
+  $.mcpServerTriggerDeclaration = $.RULE(
+    "mcpServerTriggerDeclaration",
+    mcpServerTriggerDeclaration($)
+  );
+  $.middlewareDeclaration = $.RULE(
+    "middlewareDeclaration",
+    middlewareDeclaration($)
+  );
+  $.realtimeTriggerDeclaration = $.RULE(
+    "realtimeTriggerDeclaration",
+    realtimeTriggerDeclaration($)
+  );
+  $.realtimeChannelDeclaration = $.RULE(
+    "realtimeChannelDeclaration",
+    realtimeChannelDeclaration($)
+  );
+  $.tableTriggerDeclaration = $.RULE(
+    "tableTriggerDeclaration",
+    tableTriggerDeclaration($)
+  );
+  $.taskDeclaration = $.RULE("taskDeclaration", taskDeclaration($));
+  $.toolDeclaration = $.RULE("toolDeclaration", toolDeclaration($));
+  $.workflowTestDeclaration = $.RULE(
+    "workflowTestDeclaration",
+    workflowTestDeclaration($)
+  );
+  $.workspaceDeclaration = $.RULE(
+    "workspaceDeclaration",
+    workspaceDeclaration($)
+  );
+  $.workspaceTriggerDeclaration = $.RULE(
+    "workspaceTriggerDeclaration",
+    workspaceTriggerDeclaration($)
+  );
+  $.functionDeclaration = $.RULE("functionDeclaration", functionDeclaration($));
+};

package/parser/table_parser.js

@@ -0,0 +1,126 @@
+import { CommentToken } from "../lexer/comment.js";
+import { EqualToken, LCurly, RCurly } from "../lexer/control.js";
+import { StringLiteral } from "../lexer/literal.js";
+import { AutoCompleteToken, ItemsToken, TableToken } from "../lexer/table.js";
+import { Identifier, NewlineToken } from "../lexer/tokens.js";
+
+// I have organize the parser with some for of hierachy
+// 1st comes the table declaration which should always be there in a table
+// Within the table comes the clauses (their name is always followed "Clause", like authClause, schemaClause, indexClause)
+// Each clause has a body, their name is always followed by "Body", like tableBody, schemaBody, etc.
+// Each clause body will contain a series of definitions, like columnDefinitions for the schema, index definitions, etc.
+// a definition can have metadata, like columnMetadataDefinition, filterDefinition, etc.
+// and finally, the metadata can have attributes.
+//
+// table array_columns {                       <--- tableDeclaration
+//   auth = false                              <--- authClause
+//   schema {                                  <--- schemaClause
+//     int id                                  <--- schemaBody & columnDefinition
+
+export function tableDeclaration($) {
+  return () => {
+    $.sectionStack.push("tableDeclaration");
+
+    // Allow leading comments and newlines before the table declaration
+    $.SUBRULE($.optionalCommentBlockFn);
+
+    $.CONSUME(TableToken); // "table"
+    $.OR1([
+      {
+        ALT: () =>
+          $.CONSUME(StringLiteral, {
+            ERR_MSG: "expected table name after table statement",
+          }),
+      },
+      {
+        ALT: () =>
+          $.CONSUME(Identifier, {
+            ERR_MSG: "expected table name after table statement",
+          }),
+      },
+    ]);
+
+    let hasSchema = false;
+    let hasView = false;
+    let hasAuth = false;
+    let hasDescription = false;
+    let hasTags = false;
+    let hasAutoComplete = false;
+    let hasIndex = false;
+    let hasItems = false;
+
+    const schema = {};
+
+    $.CONSUME(LCurly); // "{"
+    $.sectionStack.push("tableBody");
+    $.MANY(() => $.CONSUME(NewlineToken)); // Allow multiple new lines between clauses
+    $.MANY1(() => {
+      // Zero or more clauses, each potentially followed by new lines
+      $.OR([
+        { ALT: () => $.CONSUME(CommentToken) },
+        {
+          GATE: () => !hasDescription,
+          ALT: () => $.SUBRULE($.descriptionFieldAttribute),
+        },
+        {
+          GATE: () => !hasTags,
+          ALT: () => $.SUBRULE($.tagsAttribute),
+        },
+        {
+          GATE: () => !hasAuth,
+          ALT: () => $.SUBRULE($.authClause),
+        },
+        {
+          GATE: () => !hasView,
+          ALT: () => $.SUBRULE($.viewClause),
+        },
+        {
+          GATE: () => !hasItems,
+          ALT: () => {
+            hasItems = true;
+            const parent = $.CONSUME(ItemsToken);
+            $.CONSUME(EqualToken);
+            $.SUBRULE($.schemaParseArrayFn, {
+              ARGS: [
+                parent,
+                [
+                  {
+                    "[string]": "[expression]",
+                  },
+                ],
+              ],
+            });
+          },
+        },
+        {
+          GATE: () => !hasAutoComplete,
+          ALT: () => {
+            hasAutoComplete = true;
+            const parent = $.CONSUME(AutoCompleteToken);
+            $.CONSUME1(EqualToken);
+            $.SUBRULE1($.schemaParseArrayFn, {
+              ARGS: [parent, [{ "[string]": "[string]" }]],
+            });
+          },
+        },
+        {
+          GATE: () => !hasSchema,
+          ALT: () =>
+            $.SUBRULE($.schemaClause, {
+              ARGS: [{ isTableSchema: true }, schema],
+            }),
+        },
+        {
+          GATE: () => !hasIndex,
+          ALT: () => $.SUBRULE($.indexClause),
+        },
+      ]);
+      $.AT_LEAST_ONE1(() => $.CONSUME1(NewlineToken)); // Allow multiple new lines between clauses
+    });
+    $.sectionStack.pop();
+    $.CONSUME(RCurly); // "}"
+    $.MANY2(() => $.CONSUME2(NewlineToken));
+
+    $.sectionStack.pop();
+  };
+}