@xano/xanoscript-language-server 12.7.0 → 12.9.0

package/README.md

@@ -57,8 +57,12 @@ The parser supports the following XanoScript constructs:
 | `mcp_server` | MCP server definitions |
 | `mcp_server_trigger` | MCP server trigger handlers |
 | `middleware` | Middleware definitions |
-| `realtime_channel` | Realtime channel definitions |
-| `realtime_trigger` | Realtime trigger handlers |
+| `realtime_channel` | Realtime v1 channel definitions |
+| `realtime_trigger` | Realtime v1 trigger handlers |
+| `channel` | Realtime v2 channel definitions (path templates) |
+| `message` | Realtime v2 channel message handlers |
+| `channel_trigger` | Realtime v2 channel lifecycle triggers (join/leave) |
+| `realtime_server_trigger` | Realtime v2 connection lifecycle triggers (connect/disconnect) |
 | `tool` | Tool definitions |
 | `workspace` | Workspace definitions |
 | `workspace_trigger` | Workspace trigger handlers |

package/lexer/channel.js

@@ -0,0 +1,72 @@
+import { ServerDetailsToken } from "./ai.js";
+import { Identifier } from "./identifier.js";
+import { createTokenByName } from "./utils.js";
+
+// "server" (channel's realtime_server reference).
+// longer_alt points at server_details so the longer keyword still wins.
+export const ServerToken = createTokenByName("server", {
+  longer_alt: [ServerDetailsToken, Identifier],
+  categories: [Identifier], // could also be an identifier
+});
+
+// "access"
+export const AccessToken = createTokenByName("access", {
+  longer_alt: Identifier,
+  categories: [Identifier], // could also be an identifier
+});
+
+// "publish"
+export const PublishToken = createTokenByName("publish", {
+  longer_alt: Identifier,
+  categories: [Identifier], // could also be an identifier
+});
+
+// "conversation"
+export const ConversationToken = createTokenByName("conversation", {
+  longer_alt: Identifier,
+  categories: [Identifier], // could also be an identifier
+});
+
+// "delivery"
+export const DeliveryToken = createTokenByName("delivery", {
+  longer_alt: Identifier,
+  categories: [Identifier], // could also be an identifier
+});
+
+// "rate_limit"
+export const RateLimitToken = createTokenByName("rate_limit", {
+  longer_alt: Identifier,
+  categories: [Identifier], // could also be an identifier
+});
+
+// ServerToken must be lexed AFTER `server_details` (a longer AI keyword) so it
+// does not shadow it; the rest must be lexed BEFORE shorter-prefix keywords
+// (e.g. `delivery` before `del`). They are therefore spread at two different
+// points in the master token list — see lexer/tokens.js.
+export const ChannelServerToken = ServerToken;
+
+export const ChannelObjectTokens = [
+  AccessToken,
+  PublishToken,
+  ConversationToken,
+  DeliveryToken,
+  RateLimitToken,
+];
+
+/**
+ * Maps a token name to a type
+ * @param {string} token the token name
+ */
+export function mapTokenToType(token) {
+  switch (token) {
+    case ServerToken.name:
+    case AccessToken.name:
+    case PublishToken.name:
+    case ConversationToken.name:
+    case DeliveryToken.name:
+    case RateLimitToken.name:
+      return "keyword";
+    default:
+      return null;
+  }
+}

package/lexer/channel_trigger.js

@@ -0,0 +1,23 @@
+import { Identifier } from "./identifier.js";
+import { createTokenByName } from "./utils.js";
+
+// "channel_trigger"
+export const ChannelTriggerToken = createTokenByName("channel_trigger", {
+  longer_alt: Identifier,
+  categories: [Identifier], // could also be an identifier
+});
+
+export const ChannelTriggerTokens = [ChannelTriggerToken];
+
+/**
+ * Maps a token name to a type
+ * @param {string} token the token name
+ */
+export function mapTokenToType(token) {
+  switch (token) {
+    case ChannelTriggerToken.name:
+      return "keyword";
+    default:
+      return null;
+  }
+}

package/lexer/message.js

@@ -0,0 +1,31 @@
+import { Identifier } from "./identifier.js";
+import { createTokenByName } from "./utils.js";
+
+// "message"
+export const MessageToken = createTokenByName("message", {
+  longer_alt: Identifier,
+  categories: [Identifier], // could also be an identifier
+});
+
+// "deliver_to"
+export const DeliverToToken = createTokenByName("deliver_to", {
+  longer_alt: Identifier,
+  categories: [Identifier], // could also be an identifier
+});
+
+export const MessageTokens = [MessageToken, DeliverToToken];
+
+/**
+ * Maps a token name to a type
+ * @param {string} token the token name
+ */
+export function mapTokenToType(token) {
+  switch (token) {
+    case MessageToken.name:
+      return "keyword";
+    case DeliverToToken.name:
+      return "variable";
+    default:
+      return null;
+  }
+}

package/lexer/realtime.js

@@ -0,0 +1,26 @@
+import { Identifier } from "./identifier.js";
+import { createTokenByName } from "./utils.js";
+
+// realtime
+export const RealtimeToken = createTokenByName("realtime", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// get_session
+export const GetSessionToken = createTokenByName("get_session", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+export const RealtimeStatementTokens = [RealtimeToken, GetSessionToken];
+
+export function mapTokenToType(token) {
+  switch (token) {
+    case RealtimeToken.name:
+    case GetSessionToken.name:
+      return "function";
+    default:
+      return null;
+  }
+}

package/lexer/realtime_server_trigger.js

@@ -0,0 +1,38 @@
+import { Identifier } from "./identifier.js";
+import { createTokenByName } from "./utils.js";
+
+// "realtime_server_trigger"
+export const RealtimeServerTriggerToken = createTokenByName(
+  "realtime_server_trigger",
+  {
+    longer_alt: Identifier,
+    categories: [Identifier], // could also be an identifier
+  }
+);
+
+// "realtime_server" (parent-reference keyword used by realtimeServerClause).
+// longer_alt points at the trigger token so `realtime_server_trigger` wins
+// over the shorter `realtime_server` prefix.
+export const RealtimeServerToken = createTokenByName("realtime_server", {
+  longer_alt: RealtimeServerTriggerToken,
+  categories: [Identifier], // could also be an identifier
+});
+
+export const RealtimeServerTriggerTokens = [
+  RealtimeServerTriggerToken,
+  RealtimeServerToken,
+];
+
+/**
+ * Maps a token name to a type
+ * @param {string} token the token name
+ */
+export function mapTokenToType(token) {
+  switch (token) {
+    case RealtimeServerTriggerToken.name:
+    case RealtimeServerToken.name:
+      return "keyword";
+    default:
+      return null;
+  }
+}

package/lexer/tokens.js

@@ -39,6 +39,15 @@ import {
   mapTokenToType as mapBranchTokenToType,
 } from "./branch.js";
 import { CastTokens, mapTokenToType as mapCastTokenToType } from "./cast.js";
+import {
+  ChannelObjectTokens,
+  ChannelServerToken,
+  mapTokenToType as mapChannelObjectTokenToType,
+} from "./channel.js";
+import {
+  ChannelTriggerTokens,
+  mapTokenToType as mapChannelTriggerTokenToType,
+} from "./channel_trigger.js";
 import { CloudTokens, mapTokenToType as mapCloudTokenToType } from "./cloud.js";
 import {
   ColumnTokens,
@@ -83,6 +92,10 @@ import {
   mapTokenToType as mapMcpServerTriggerTokenToType,
   McpServerTriggerTokens,
 } from "./mcp_server_trigger.js";
+import {
+  mapTokenToType as mapMessageTokenToType,
+  MessageTokens,
+} from "./message.js";
 import {
   mapTokenToType as mapMiddlewareTokenToType,
   MiddlewareTokens,
@@ -96,6 +109,14 @@ import {
   ObjectTokens,
 } from "./object.js";
 import { mapTokenToType as mapQueryTokenToType, QueryTokens } from "./query.js";
+import {
+  mapTokenToType as mapRealtimeTokenToType,
+  RealtimeStatementTokens,
+} from "./realtime.js";
+import {
+  mapTokenToType as mapRealtimeServerTriggerTokenToType,
+  RealtimeServerTriggerTokens,
+} from "./realtime_server_trigger.js";
 import {
   mapTokenToType as mapRealtimeTriggerTokenToType,
   RealtimeTriggerTokens,
@@ -365,7 +386,13 @@ export const allTokens = uniq([
   ...AgentTriggerTokens,
   ...McpServerTriggerTokens,
   ...McpServerTokens,
+  ...RealtimeServerTriggerTokens,
   ...RealtimeTriggerTokens,
+  ...ChannelTriggerTokens,
+  ...MessageTokens,
+  // channel-object keywords (access/publish/conversation/delivery/rate_limit)
+  // must precede shorter-prefix keywords like `del` (db/redis)
+  ...ChannelObjectTokens,
   ...ArrayFnTokens,
   ...ColumnTokens,
   ...LiteralTokens,
@@ -412,6 +439,10 @@ export const allTokens = uniq([
   ...WorkflowTestTokens,
   ...ApiGroupTokens,
   ...ApiFnTokens,
+  // bare `realtime` must be lexed AFTER the longer `realtime_*` keywords
+  // (realtime_trigger/realtime_channel/realtime_server + api.realtime_event)
+  // so it does not shadow them (UNREACHABLE lexer error otherwise).
+  ...RealtimeStatementTokens,
   ...VariableTokens,
   ...TableTokens,
   ...CloudTokens,
@@ -427,6 +458,9 @@ export const allTokens = uniq([
   ...VarTokens,
   ...MathTokens,
   ...AiTokens, // AI tokens must come before AgentTokens to avoid conflicts
+  // `server` must be lexed AFTER `server_details` (an AI keyword) so it does not
+  // shadow it; its longer_alt keeps `server_details` input matching correctly.
+  ChannelServerToken,
   ...AgentTokens, // Must come before ToolTokens because of ToolsToken
   ...ToolTokens,
   ...AddonTokens,
@@ -450,6 +484,8 @@ const tokenMappers = [
   mapArrayTokenToType,
   mapBranchTokenToType,
   mapCastTokenToType,
+  mapChannelObjectTokenToType,
+  mapChannelTriggerTokenToType,
   mapCloudTokenToType,
   mapColumnTokenToType,
   mapCommentTokenToType,
@@ -464,10 +500,13 @@ const tokenMappers = [
   mapMathTokenToType,
   mapMcpServerTokenToType,
   mapMcpServerTriggerTokenToType,
+  mapMessageTokenToType,
   mapMiddlewareTokenToType,
   mapMultilineTokenToType,
   mapObjectTokenToType,
   mapQueryTokenToType,
+  mapRealtimeTokenToType,
+  mapRealtimeServerTriggerTokenToType,
   mapRealtimeTriggerTokenToType,
   mapRedisTokenToType,
   mapRunTokenToType,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xano/xanoscript-language-server",
-  "version": "12.7.0",
+  "version": "12.9.0",
   "description": "Language Server Protocol implementation for XanoScript",
   "type": "module",
   "main": "server.js",
@@ -41,6 +41,8 @@
   "scripts": {
     "test-one": "mocha",
     "test": "mocha \"**/*.spec.js\"",
+    "coverage": "c8 mocha \"**/*.spec.js\"",
+    "coverage:report": "c8 --reporter=html --reporter=text mocha \"**/*.spec.js\"",
     "test-alt": "NODE_OPTIONS=\"--trace-warnings\" mocha --loader node \"*/**/*.spec.js\"",
     "lint": "eslint . --ext .js",
     "lint:fix": "eslint . --ext .js --fix",
@@ -60,6 +62,7 @@
   },
   "devDependencies": {
     "@eslint/js": "^9.22.0",
+    "c8": "^11.0.0",
     "chai": "^5.2.0",
     "eslint": "^9.22.0",
     "eslint-plugin-simple-import-sort": "^12.1.1",

package/parser/channel_parser.js

@@ -0,0 +1,189 @@
+import {
+  AccessToken,
+  ConversationToken,
+  DeliveryToken,
+  PublishToken,
+  RateLimitToken,
+  ServerToken,
+} from "../lexer/channel.js";
+import { ChannelToken } from "../lexer/columns.js";
+import { EqualToken, LCurly, RCurly } from "../lexer/control.js";
+import { StringLiteral } from "../lexer/literal.js";
+import { Identifier, NewlineToken } from "../lexer/tokens.js";
+
+export function channelDeclaration($) {
+  return () => {
+    let hasServer = false;
+    let hasAccess = false;
+    let hasPublish = false;
+    let hasConversation = false;
+    let hasDelivery = false;
+    let hasRateLimit = false;
+    let hasHistory = false;
+    let hasInput = false;
+    let hasDescription = false;
+    let hasGuid = false;
+    let hasTags = false;
+
+    $.sectionStack.push("channelDeclaration");
+    // Allow leading comments and newlines before the channel declaration
+    $.SUBRULE($.optionalCommentBlockFn);
+
+    const parent = $.CONSUME(ChannelToken); // channel
+    const nameToken = $.OR([
+      { ALT: () => $.CONSUME(StringLiteral) },
+      { ALT: () => $.CONSUME(Identifier) },
+    ]);
+    $.validateDeclarationName(nameToken, "channel");
+    $.CONSUME(LCurly); // "{"
+    $.MANY(() => {
+      $.AT_LEAST_ONE(() => $.CONSUME(NewlineToken)); // at least one new line
+      $.OR2([
+        {
+          ALT: () => $.SUBRULE($.commentBlockFn),
+        },
+        {
+          GATE: () => !hasServer,
+          ALT: () => {
+            hasServer = true;
+            const subParent = $.CONSUME(ServerToken); // "server"
+            $.CONSUME(EqualToken); // "="
+            const result = $.CONSUME2(StringLiteral); // "server_name"
+            if (result.image === `""`) {
+              $.addMissingError(subParent, "server cannot be empty");
+            }
+          },
+        },
+        {
+          GATE: () => !hasAccess,
+          ALT: () => {
+            hasAccess = true;
+            const subParent = $.CONSUME(AccessToken); // "access"
+            $.CONSUME2(EqualToken); // "="
+            $.SUBRULE($.schemaParseObjectFn, {
+              ARGS: [
+                subParent,
+                {
+                  "anonymous?": "[boolean]",
+                  "presence?": "[boolean]",
+                },
+              ],
+            });
+          },
+        },
+        {
+          GATE: () => !hasPublish,
+          ALT: () => {
+            hasPublish = true;
+            const subParent = $.CONSUME(PublishToken); // "publish"
+            $.CONSUME3(EqualToken); // "="
+            $.SUBRULE1($.schemaParseObjectFn, {
+              ARGS: [
+                subParent,
+                {
+                  "who?": ["nobody", "anyone", "authenticated"],
+                  "direct?": "[boolean]",
+                },
+              ],
+            });
+          },
+        },
+        {
+          GATE: () => !hasConversation,
+          ALT: () => {
+            hasConversation = true;
+            const subParent = $.CONSUME(ConversationToken); // "conversation"
+            $.CONSUME4(EqualToken); // "="
+            $.SUBRULE2($.schemaParseObjectFn, {
+              ARGS: [
+                subParent,
+                {
+                  "active?": "[boolean]",
+                  "limit?": "[number]",
+                  "ttl?": "[number]",
+                },
+              ],
+            });
+          },
+        },
+        {
+          GATE: () => !hasDelivery,
+          ALT: () => {
+            hasDelivery = true;
+            const subParent = $.CONSUME(DeliveryToken); // "delivery"
+            $.CONSUME5(EqualToken); // "="
+            $.SUBRULE3($.schemaParseObjectFn, {
+              ARGS: [
+                subParent,
+                {
+                  "guarantee?": ["at_most_once", "at_least_once"],
+                  "per_recipient?": "[boolean]",
+                },
+              ],
+            });
+          },
+        },
+        {
+          GATE: () => !hasRateLimit,
+          ALT: () => {
+            hasRateLimit = true;
+            const subParent = $.CONSUME(RateLimitToken); // "rate_limit"
+            $.CONSUME6(EqualToken); // "="
+            $.SUBRULE4($.schemaParseObjectFn, {
+              ARGS: [
+                subParent,
+                {
+                  "messages_per_minute?": "[number]",
+                },
+              ],
+            });
+          },
+        },
+        {
+          GATE: () => !hasHistory,
+          ALT: () => {
+            hasHistory = true;
+            $.SUBRULE($.historyClause);
+          },
+        },
+        {
+          GATE: () => !hasInput,
+          ALT: () => {
+            hasInput = true;
+            $.SUBRULE($.inputClause);
+          },
+        },
+        {
+          GATE: () => !hasDescription,
+          ALT: () => {
+            hasDescription = true;
+            $.SUBRULE($.descriptionFieldAttribute);
+          },
+        },
+        {
+          GATE: () => !hasGuid,
+          ALT: () => {
+            hasGuid = true;
+            $.SUBRULE($.guidFieldAttribute);
+          },
+        },
+        {
+          GATE: () => !hasTags,
+          ALT: () => {
+            hasTags = true;
+            $.SUBRULE($.tagsAttribute);
+          },
+        },
+      ]);
+    });
+
+    if (!hasServer) {
+      $.addMissingError(parent, "{} is missing a server clause");
+    }
+
+    $.MANY1(() => $.CONSUME1(NewlineToken)); // optional new line
+    $.CONSUME(RCurly); // "}"
+    $.MANY2(() => $.CONSUME2(NewlineToken)); // optional new line
+    $.sectionStack.pop();
+  };
+}

package/parser/channel_trigger_parser.js

@@ -0,0 +1,145 @@
+import { ChannelTriggerToken } from "../lexer/channel_trigger.js";
+import { EqualToken, LCurly, RCurly } from "../lexer/control.js";
+import { StringLiteral } from "../lexer/literal.js";
+import { ActionsToken, ActiveToken } from "../lexer/mcp_server_trigger.js";
+import { Identifier, NewlineToken } from "../lexer/tokens.js";
+
+export function channelTriggerDeclaration($) {
+  return () => {
+    let hasActions = false;
+    let hasActive = false;
+    let hasChannel = false;
+    let hasDescription = false;
+    let hasGuid = false;
+    let hasHistory = false;
+    let hasInput = false;
+    let hasResponse = false;
+    let hasStack = false;
+    let hasTags = false;
+
+    $.sectionStack.push("channelTriggerDeclaration");
+    // Allow leading comments and newlines before the channel_trigger declaration
+    $.SUBRULE($.optionalCommentBlockFn);
+
+    const parent = $.CONSUME(ChannelTriggerToken); // channel_trigger
+    const nameToken = $.OR([
+      { ALT: () => $.CONSUME(StringLiteral) },
+      { ALT: () => $.CONSUME(Identifier) },
+    ]);
+    $.validateDeclarationName(nameToken, "channel_trigger");
+    $.CONSUME(LCurly); // "{"
+    $.MANY(() => {
+      $.AT_LEAST_ONE(() => $.CONSUME(NewlineToken)); // at least one new line
+      $.OR2([
+        {
+          ALT: () => $.SUBRULE($.commentBlockFn),
+        },
+        {
+          GATE: () => !hasActions,
+          ALT: () => {
+            hasActions = true;
+
+            const subParent = $.CONSUME(ActionsToken); // "actions"
+            $.CONSUME(EqualToken); // "="
+
+            $.SUBRULE($.schemaParseObjectFn, {
+              ARGS: [
+                subParent,
+                {
+                  "join?": "[boolean]",
+                  "leave?": "[boolean]",
+                },
+              ],
+            });
+          },
+        },
+        {
+          GATE: () => !hasActive,
+          ALT: () => {
+            hasActive = true;
+            $.CONSUME(ActiveToken);
+            $.CONSUME2(EqualToken);
+            $.SUBRULE($.booleanValue);
+          },
+        },
+        {
+          GATE: () => !hasChannel,
+          ALT: () => {
+            hasChannel = true;
+            $.SUBRULE($.channelClause);
+          },
+        },
+        {
+          GATE: () => !hasDescription,
+          ALT: () => {
+            hasDescription = true;
+            $.SUBRULE($.descriptionFieldAttribute);
+          },
+        },
+        {
+          GATE: () => !hasGuid,
+          ALT: () => {
+            hasGuid = true;
+            $.SUBRULE($.guidFieldAttribute);
+          },
+        },
+        {
+          GATE: () => !hasHistory,
+          ALT: () => {
+            hasHistory = true;
+            $.SUBRULE($.historyClause);
+          },
+        },
+        {
+          GATE: () => !hasInput,
+          ALT: () => {
+            hasInput = true;
+            $.SUBRULE($.inputClause);
+          },
+        },
+        {
+          GATE: () => !hasResponse,
+          ALT: () => {
+            hasResponse = true;
+            $.SUBRULE($.responseClause);
+          },
+        },
+        {
+          GATE: () => !hasStack,
+          ALT: () => {
+            hasStack = true;
+            $.SUBRULE($.stackClause);
+          },
+        },
+        {
+          GATE: () => !hasTags,
+          ALT: () => {
+            hasTags = true;
+            $.SUBRULE($.tagsAttribute);
+          },
+        },
+      ]);
+    });
+
+    if (!hasChannel) {
+      $.addMissingError(parent, "{} is missing a channel clause");
+    }
+
+    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/clauses/indexClause.js

@@ -22,6 +22,7 @@ export function indexClause($) {
               "btree|unique",
               "search",
               "vector",
+              "hash",
             ],
             field: [{ name: "[string]", "op?": "[string]" }],
             "lang?": "[string]",

package/parser/clauses/nakedStackFn.js

@@ -36,6 +36,7 @@ export function nakedStackFn($) {
               { ALT: () => $.SUBRULE($.mathFn) },
               { ALT: () => $.SUBRULE($.textFn) },
               { ALT: () => $.SUBRULE($.utilFn) },
+              { ALT: () => $.SUBRULE($.realtimeFn) },
               { ALT: () => $.SUBRULE($.preconditionFn) },
               { ALT: () => $.SUBRULE($.zipFn) },
               { ALT: () => $.SUBRULE($.objectFn) },

package/parser/clauses/realtimeServerClause.js

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

package/parser/clauses/register.js

@@ -12,6 +12,7 @@ import { mcpServerClause } from "./mcpServerClause.js";
 import { middlewareClause } from "./middlewareClause.js";
 import { nakedStackFn } from "./nakedStackFn.js";
 import { outputClause } from "./outputClause.js";
+import { realtimeServerClause } from "./realtimeServerClause.js";
 import { responseClause } from "./responseClause.js";
 import { scheduleClause } from "./scheduleClause.js";
 import { schemaClause } from "./schemaClause.js";
@@ -39,6 +40,10 @@ export const register = ($) => {
   $.inputClause = $.RULE("inputClause", inputClause($));
   $.outputClause = $.RULE("outputClause", outputClause($));
   $.mcpServerClause = $.RULE("mcpServerClause", mcpServerClause($));
+  $.realtimeServerClause = $.RULE(
+    "realtimeServerClause",
+    realtimeServerClause($)
+  );
   $.middlewareClause = $.RULE("middlewareClause", middlewareClause($));
   $.nakedStackFn = $.RULE("nakedStackFn", nakedStackFn($));
   $.responseClause = $.RULE("responseClause", responseClause($));

package/parser/functions/realtime/realtimeGetSessionFn.js

@@ -0,0 +1,20 @@
+import { GetSessionToken } from "../../../lexer/realtime.js";
+
+/**
+ * @param {import('../../base_parser.js').XanoBaseParser} $
+ */
+export function realtimeGetSessionFn($) {
+  // realtime.get_session as $session
+  return () => {
+    const requiredAttrs = [];
+    const optionalAttrs = ["description", "disabled"];
+
+    $.sectionStack.push("realtimeGetSessionFn");
+    const fnToken = $.CONSUME(GetSessionToken); // "get_session"
+    $.SUBRULE($.functionAttrReq, {
+      ARGS: [fnToken, requiredAttrs, optionalAttrs],
+    });
+    $.SUBRULE($.asVariable, { ARGS: [fnToken] });
+    $.sectionStack.pop();
+  };
+}

package/parser/functions/realtime/register.js

@@ -0,0 +1,12 @@
+import { realtimeGetSessionFn } from "./realtimeGetSessionFn.js";
+
+/**
+ * Registers all the parsers in this folder
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export const register = ($) => {
+  $.realtimeGetSessionFn = $.RULE(
+    "realtimeGetSessionFn",
+    realtimeGetSessionFn($),
+  );
+};

package/parser/functions/realtimeFn.js

@@ -0,0 +1,18 @@
+import { RealtimeToken } from "../../lexer/realtime.js";
+import { DotToken } from "../../lexer/tokens.js";
+
+/**
+ * realtime.get_session
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export function realtimeFn($) {
+  return () => {
+    $.sectionStack.push("realtime");
+    $.CONSUME(RealtimeToken); // "realtime"
+    $.CONSUME(DotToken); // "."
+    $.OR([
+      { ALT: () => $.SUBRULE($.realtimeGetSessionFn) }, // "realtime.get_session"
+    ]);
+    $.sectionStack.pop();
+  };
+}

package/parser/functions/register.js

@@ -22,6 +22,8 @@ import { mathFn } from "./mathFn.js";
 import { middlewareCallFn } from "./middlewareCallFn.js";
 import { register as register_object } from "./object/register.js";
 import { objectFn } from "./objectFn.js";
+import { register as register_realtime } from "./realtime/register.js";
+import { realtimeFn } from "./realtimeFn.js";
 import { register as register_redis } from "./redis/register.js";
 import { redisFn } from "./redisFn.js";
 import { register as register_schema } from "./schema/register.js";
@@ -63,6 +65,7 @@ export const register = ($) => {
   $.debugFn = $.RULE("debugFn", debugFn($));
   $.mathFn = $.RULE("mathFn", mathFn($));
   $.objectFn = $.RULE("objectFn", objectFn($));
+  $.realtimeFn = $.RULE("realtimeFn", realtimeFn($));
   $.redisFn = $.RULE("redisFn", redisFn($));
   $.securityFn = $.RULE("securityFn", securityFn($));
   $.storageFn = $.RULE("storageFn", storageFn($));
@@ -86,6 +89,7 @@ export const register = ($) => {
   register_debug($);
   register_math($);
   register_object($);
+  register_realtime($);
   register_redis($);
   register_security($);
   register_storage($);

package/parser/message_parser.js

@@ -0,0 +1,161 @@
+import { EqualToken, LCurly, RCurly } from "../lexer/control.js";
+import { StringLiteral } from "../lexer/literal.js";
+import { DeliverToToken, MessageToken } from "../lexer/message.js";
+import { AuthToken, Identifier, NewlineToken } from "../lexer/tokens.js";
+
+export function messageDeclaration($) {
+  return () => {
+    let hasAuth = false;
+    let hasChannel = false;
+    let hasDeliverTo = false;
+    let hasDescription = false;
+    let hasGuid = false;
+    let hasHistory = false;
+    let hasInput = false;
+    let hasMiddleware = false;
+    let hasResponse = false;
+    let hasStack = false;
+    let hasTags = false;
+
+    $.sectionStack.push("messageDeclaration");
+    // Allow leading comments and newlines before the message declaration
+    $.SUBRULE($.optionalCommentBlockFn);
+
+    const parent = $.CONSUME(MessageToken);
+    const nameToken = $.OR([
+      { ALT: () => $.CONSUME(StringLiteral) },
+      { ALT: () => $.CONSUME(Identifier) },
+    ]);
+    $.validateDeclarationName(nameToken, "message");
+    $.CONSUME(LCurly); // "{"
+    $.MANY(() => {
+      $.AT_LEAST_ONE(() => $.CONSUME(NewlineToken)); // at least one new line
+      $.OR2([
+        { ALT: () => $.SUBRULE($.commentBlockFn) },
+        {
+          GATE: () => !hasAuth,
+          ALT: () => {
+            hasAuth = true;
+            // message auth references an auth DBO by name, e.g. auth = "user"
+            $.CONSUME(AuthToken); // "auth"
+            $.CONSUME2(EqualToken); // "="
+            $.CONSUME2(StringLiteral); // "user"
+          },
+        },
+        {
+          GATE: () => !hasChannel,
+          ALT: () => {
+            hasChannel = true;
+            $.SUBRULE($.channelClause);
+          },
+        },
+        {
+          GATE: () => !hasDeliverTo,
+          ALT: () => {
+            hasDeliverTo = true;
+
+            const subParent = $.CONSUME(DeliverToToken); // "deliver_to"
+            $.CONSUME(EqualToken); // "="
+            $.SUBRULE($.schemaParseEnumFn, {
+              ARGS: [
+                subParent,
+                ["channel", "sender", "others", "explicit"],
+              ],
+            });
+          },
+        },
+        {
+          GATE: () => !hasDescription,
+          ALT: () => {
+            hasDescription = true;
+            $.SUBRULE($.descriptionFieldAttribute);
+          },
+        },
+        {
+          GATE: () => !hasGuid,
+          ALT: () => {
+            hasGuid = true;
+            $.SUBRULE($.guidFieldAttribute);
+          },
+        },
+        {
+          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, {
+              ARGS: [{ allowCallStatements: true }],
+            });
+          },
+        },
+        {
+          GATE: () => !hasTags,
+          ALT: () => {
+            hasTags = true;
+            $.SUBRULE($.tagsAttribute);
+          },
+        },
+      ]);
+    });
+
+    if (!hasChannel) {
+      $.addMissingError(
+        parent,
+        `{} ${nameToken.image} is missing a channel clause`,
+      );
+    }
+
+    if (!hasInput) {
+      $.addMissingError(
+        parent,
+        `{} ${nameToken.image} is missing an input clause`,
+      );
+    }
+
+    if (!hasStack) {
+      $.addMissingError(
+        parent,
+        `{} ${nameToken.image} is missing a stack clause`,
+      );
+    }
+
+    if (!hasResponse) {
+      $.addMissingError(
+        parent,
+        `{} ${nameToken.image} is missing a response clause`,
+      );
+    }
+
+    $.MANY1(() => $.CONSUME1(NewlineToken)); // optional new line
+    $.CONSUME(RCurly); // "}"
+    $.MANY2(() => $.CONSUME2(NewlineToken)); // optional new line
+    $.sectionStack.pop();
+  };
+}

package/parser/parser.js

@@ -36,6 +36,12 @@ export function xanoscriptParser(text, scheme, preTokenized = null) {
     case "branch":
       parser.branchDeclaration();
       return parser;
+    case "channel":
+      parser.channelDeclaration();
+      return parser;
+    case "channel_trigger":
+      parser.channelTriggerDeclaration();
+      return parser;
     case "error_trigger":
       parser.errorTriggerDeclaration();
       return parser;
@@ -48,9 +54,15 @@ export function xanoscriptParser(text, scheme, preTokenized = null) {
     case "mcp_server_trigger":
       parser.mcpServerTriggerDeclaration();
       return parser;
+    case "message":
+      parser.messageDeclaration();
+      return parser;
     case "middleware":
       parser.middlewareDeclaration();
       return parser;
+    case "realtime_server_trigger":
+      parser.realtimeServerTriggerDeclaration();
+      return parser;
     case "realtime_trigger":
       parser.realtimeTriggerDeclaration();
       return parser;

package/parser/realtime_server_trigger_parser.js

@@ -0,0 +1,145 @@
+import { EqualToken, LCurly, RCurly } from "../lexer/control.js";
+import { StringLiteral } from "../lexer/literal.js";
+import { ActionsToken, ActiveToken } from "../lexer/mcp_server_trigger.js";
+import { RealtimeServerTriggerToken } from "../lexer/realtime_server_trigger.js";
+import { Identifier, NewlineToken } from "../lexer/tokens.js";
+
+export function realtimeServerTriggerDeclaration($) {
+  return () => {
+    let hasActions = false;
+    let hasActive = false;
+    let hasDescription = false;
+    let hasGuid = false;
+    let hasHistory = false;
+    let hasInput = false;
+    let hasRealtimeServer = false;
+    let hasResponse = false;
+    let hasStack = false;
+    let hasTags = false;
+
+    $.sectionStack.push("realtimeServerTriggerDeclaration");
+    // Allow leading comments and newlines before the declaration
+    $.SUBRULE($.optionalCommentBlockFn);
+
+    const parent = $.CONSUME(RealtimeServerTriggerToken); // realtime_server_trigger
+    const nameToken = $.OR([
+      { ALT: () => $.CONSUME(StringLiteral) },
+      { ALT: () => $.CONSUME(Identifier) },
+    ]);
+    $.validateDeclarationName(nameToken, "realtime_server_trigger");
+    $.CONSUME(LCurly); // "{"
+    $.MANY(() => {
+      $.AT_LEAST_ONE(() => $.CONSUME(NewlineToken)); // at least one new line
+      $.OR2([
+        {
+          ALT: () => $.SUBRULE($.commentBlockFn),
+        },
+        {
+          GATE: () => !hasActions,
+          ALT: () => {
+            hasActions = true;
+
+            const subParent = $.CONSUME(ActionsToken); // "actions"
+            $.CONSUME(EqualToken); // "="
+
+            $.SUBRULE($.schemaParseObjectFn, {
+              ARGS: [
+                subParent,
+                {
+                  "connect?": "[boolean]",
+                  "disconnect?": "[boolean]",
+                },
+              ],
+            });
+          },
+        },
+        {
+          GATE: () => !hasActive,
+          ALT: () => {
+            hasActive = true;
+            $.CONSUME(ActiveToken);
+            $.CONSUME2(EqualToken);
+            $.SUBRULE($.booleanValue);
+          },
+        },
+        {
+          GATE: () => !hasDescription,
+          ALT: () => {
+            hasDescription = true;
+            $.SUBRULE($.descriptionFieldAttribute);
+          },
+        },
+        {
+          GATE: () => !hasGuid,
+          ALT: () => {
+            hasGuid = true;
+            $.SUBRULE($.guidFieldAttribute);
+          },
+        },
+        {
+          GATE: () => !hasHistory,
+          ALT: () => {
+            hasHistory = true;
+            $.SUBRULE($.historyClause);
+          },
+        },
+        {
+          GATE: () => !hasInput,
+          ALT: () => {
+            hasInput = true;
+            $.SUBRULE($.inputClause);
+          },
+        },
+        {
+          GATE: () => !hasRealtimeServer,
+          ALT: () => {
+            hasRealtimeServer = true;
+            $.SUBRULE($.realtimeServerClause);
+          },
+        },
+        {
+          GATE: () => !hasResponse,
+          ALT: () => {
+            hasResponse = true;
+            $.SUBRULE($.responseClause);
+          },
+        },
+        {
+          GATE: () => !hasStack,
+          ALT: () => {
+            hasStack = true;
+            $.SUBRULE($.stackClause);
+          },
+        },
+        {
+          GATE: () => !hasTags,
+          ALT: () => {
+            hasTags = true;
+            $.SUBRULE($.tagsAttribute);
+          },
+        },
+      ]);
+    });
+
+    if (!hasRealtimeServer) {
+      $.addMissingError(parent, "{} is missing a realtime_server clause");
+    }
+
+    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/register.js

@@ -4,6 +4,8 @@ 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 { channelDeclaration } from "./channel_parser.js";
+import { channelTriggerDeclaration } from "./channel_trigger_parser.js";
 import { register as register_clauses } from "./clauses/register.js";
 import { register as register_definitions } from "./definitions/register.js";
 import { errorTriggerDeclaration } from "./error_trigger_parser.js";
@@ -12,10 +14,12 @@ 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 { messageDeclaration } from "./message_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 { realtimeServerTriggerDeclaration } from "./realtime_server_trigger_parser.js";
 import { realtimeTriggerDeclaration } from "./realtime_trigger_parser.js";
 import {
   runDeclaration,
@@ -51,6 +55,11 @@ export const register = ($) => {
   $.queryDeclaration = $.RULE("queryDeclaration", queryDeclaration($));
   $.apiGroupDeclaration = $.RULE("apiGroupDeclaration", apiGroupDeclaration($));
   $.branchDeclaration = $.RULE("branchDeclaration", branchDeclaration($));
+  $.channelDeclaration = $.RULE("channelDeclaration", channelDeclaration($));
+  $.channelTriggerDeclaration = $.RULE(
+    "channelTriggerDeclaration",
+    channelTriggerDeclaration($)
+  );
   $.errorTriggerDeclaration = $.RULE(
     "errorTriggerDeclaration",
     errorTriggerDeclaration($)
@@ -64,10 +73,15 @@ export const register = ($) => {
     "mcpServerTriggerDeclaration",
     mcpServerTriggerDeclaration($)
   );
+  $.messageDeclaration = $.RULE("messageDeclaration", messageDeclaration($));
   $.middlewareDeclaration = $.RULE(
     "middlewareDeclaration",
     middlewareDeclaration($)
   );
+  $.realtimeServerTriggerDeclaration = $.RULE(
+    "realtimeServerTriggerDeclaration",
+    realtimeServerTriggerDeclaration($)
+  );
   $.realtimeTriggerDeclaration = $.RULE(
     "realtimeTriggerDeclaration",
     realtimeTriggerDeclaration($)

package/utils.js

@@ -23,12 +23,16 @@ const schemeByFirstWord = {
   agent_trigger: "agent_trigger",
   api_group: "api_group",
   branch: "branch",
+  channel: "channel",
+  channel_trigger: "channel_trigger",
   error_trigger: "error_trigger",
   function: "cfn",
   mcp_server: "mcp_server",
   mcp_server_trigger: "mcp_server_trigger",
+  message: "message",
   middleware: "middleware",
   query: "api",
+  realtime_server_trigger: "realtime_server_trigger",
   realtime_trigger: "realtime_trigger",
   realtime_channel: "realtime_channel",
   run: "run",