@xano/xanoscript-language-server 12.16.3 → 12.16.4

package/lexer/microservice.js

@@ -0,0 +1,169 @@
+import { Identifier } from "./identifier.js";
+import { createTokenByName } from "./utils.js";
+
+// Tokens for the top-level `microservice <name> { ... }` entity.
+//
+// The `microservice` keyword itself is NOT defined here — it reuses
+// `MicroserviceToken` from `lexer/api.js` (also used by the inline
+// `api.microservice` statement). Defining a second token for the same keyword
+// would create two token types matching "microservice" and break lexing.
+//
+// Common words (`config`, `env`, `command`, `arg`, `ports`, `resources`, ...)
+// all carry `longer_alt: Identifier` + `categories: [Identifier]` so they still
+// behave as ordinary identifiers everywhere else in the grammar.
+
+// ── Block keywords (introduce nested `{ ... }` blocks) ──
+
+// "deployment"
+export const DeploymentToken = createTokenByName("deployment", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// "container"
+export const ContainerToken = createTokenByName("container", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// "config"
+export const ConfigToken = createTokenByName("config", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// "volume"
+export const VolumeToken = createTokenByName("volume", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// "ingress"
+export const IngressToken = createTokenByName("ingress", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// "chart"
+export const ChartToken = createTokenByName("chart", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// ── Leaf attribute keywords (`key = value`) ──
+
+// "kind"
+export const KindToken = createTokenByName("kind", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// "tenant_deploy"
+export const TenantDeployToken = createTokenByName("tenant_deploy", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// "replicas"
+export const ReplicasToken = createTokenByName("replicas", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// "docker"
+export const DockerToken = createTokenByName("docker", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// "strategy"
+export const StrategyToken = createTokenByName("strategy", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// "pull_secret"
+export const PullSecretToken = createTokenByName("pull_secret", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// "command"
+export const CommandToken = createTokenByName("command", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// "arg"
+export const ArgToken = createTokenByName("arg", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// "env"
+export const EnvToken = createTokenByName("env", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// "ports"
+export const PortsToken = createTokenByName("ports", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// "resources"
+export const ResourcesToken = createTokenByName("resources", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+export const MicroserviceTokens = [
+  DeploymentToken,
+  ContainerToken,
+  ConfigToken,
+  VolumeToken,
+  IngressToken,
+  ChartToken,
+  KindToken,
+  TenantDeployToken,
+  ReplicasToken,
+  DockerToken,
+  StrategyToken,
+  PullSecretToken,
+  CommandToken,
+  ArgToken,
+  EnvToken,
+  PortsToken,
+  ResourcesToken,
+];
+
+/**
+ * Maps a token name to a semantic type
+ * @param {string} token the token name
+ */
+export function mapTokenToType(token) {
+  switch (token) {
+    case DeploymentToken.name:
+    case ContainerToken.name:
+    case ConfigToken.name:
+    case VolumeToken.name:
+    case IngressToken.name:
+    case ChartToken.name:
+      return "keyword";
+    case KindToken.name:
+    case TenantDeployToken.name:
+    case ReplicasToken.name:
+    case DockerToken.name:
+    case StrategyToken.name:
+    case PullSecretToken.name:
+    case CommandToken.name:
+    case ArgToken.name:
+    case EnvToken.name:
+    case PortsToken.name:
+    case ResourcesToken.name:
+      return "variable";
+    default:
+      return null;
+  }
+}

package/lexer/tokens.js

@@ -96,6 +96,10 @@ import {
   mapTokenToType as mapMessageTokenToType,
   MessageTokens,
 } from "./message.js";
+import {
+  mapTokenToType as mapMicroserviceTokenToType,
+  MicroserviceTokens,
+} from "./microservice.js";
 import {
   mapTokenToType as mapMiddlewareTokenToType,
   MiddlewareTokens,
@@ -386,6 +390,7 @@ export const allTokens = uniq([
   ...AgentTriggerTokens,
   ...McpServerTriggerTokens,
   ...McpServerTokens,
+  ...MicroserviceTokens,
   ...RealtimeServerTriggerTokens,
   ...RealtimeTriggerTokens,
   ...ChannelTriggerTokens,
@@ -501,6 +506,7 @@ const tokenMappers = [
   mapMcpServerTokenToType,
   mapMcpServerTriggerTokenToType,
   mapMessageTokenToType,
+  mapMicroserviceTokenToType,
   mapMiddlewareTokenToType,
   mapMultilineTokenToType,
   mapObjectTokenToType,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xano/xanoscript-language-server",
-  "version": "12.16.3",
+  "version": "12.16.4",
   "description": "Language Server Protocol implementation for XanoScript",
   "type": "module",
   "main": "server.js",

package/parser/microservice_parser.js

@@ -0,0 +1,413 @@
+import { MicroserviceToken } from "../lexer/api.js";
+import { ImageToken } from "../lexer/columns.js";
+import { EqualToken, LCurly, RCurly } from "../lexer/control.js";
+import { StringLiteral } from "../lexer/literal.js";
+import {
+  ArgToken,
+  ChartToken,
+  CommandToken,
+  ConfigToken,
+  ContainerToken,
+  DeploymentToken,
+  DockerToken,
+  EnvToken,
+  IngressToken,
+  KindToken,
+  PortsToken,
+  PullSecretToken,
+  ReplicasToken,
+  ResourcesToken,
+  StrategyToken,
+  TenantDeployToken,
+  VolumeToken,
+} from "../lexer/microservice.js";
+import { Identifier, NewlineToken, TypeToken } from "../lexer/tokens.js";
+
+// Grammar for the top-level `microservice <name> { ... }` entity.
+//
+// Grounded against cloud-client's authoritative XanoScript schema DSL
+// (extensions/MVP/includes/xano/script/kind/schema/{core,component}/*.yaml):
+//
+//   microservice <name> {
+//     description|guid|kind|tenant_deploy = "..."   # static:text (optional)
+//     config <name> { type? value? }                # REPEATING
+//     volume <name> { size? class? }                # REPEATING
+//     ingress <name> { domain? path? }              # REPEATING
+//     chart { ref? version? values? }               # single
+//     deployment {                                  # single
+//       replicas? = 1  docker? = "..."  strategy? = "..."
+//       container <name> {                          # REPEATING
+//         image? pull_secret? type? = "..."
+//         command? arg? env? = [ {...} ]  ports? = [ {...} ]  resources? = {...}
+//         volume <name> { type? persistent? emptyDir? config? }  # REPEATING
+//       }
+//     }
+//   }
+//
+// Blocks that mix leaf attributes with nested/repeating sub-blocks
+// (microservice, deployment, container) use explicit gated OR-loops — mirroring
+// channel_parser.js / mcp_server_parser.js. Leaf-only blocks
+// (config/volume/ingress/chart/container_volume) delegate their `key = value`
+// body to schemaParseAttributeFn, which validates the key set for free.
+
+export function microserviceDeclaration($) {
+  return () => {
+    let hasDescription = false;
+    let hasGuid = false;
+    let hasKind = false;
+    let hasTenantDeploy = false;
+    let hasDeployment = false;
+    let hasChart = false;
+
+    $.sectionStack.push("microserviceDeclaration");
+    // Allow leading comments and newlines before the microservice declaration
+    $.SUBRULE($.optionalCommentBlockFn);
+    $.CONSUME(MicroserviceToken); // "microservice"
+    const nameToken = $.OR([
+      { ALT: () => $.CONSUME(StringLiteral) },
+      { ALT: () => $.CONSUME(Identifier) },
+    ]);
+    $.validateDeclarationName(nameToken, "microservice");
+    $.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: () => !hasGuid,
+          ALT: () => {
+            hasGuid = true;
+            $.SUBRULE($.guidFieldAttribute);
+          },
+        },
+        {
+          GATE: () => !hasKind,
+          ALT: () => {
+            hasKind = true;
+            const t = $.CONSUME(KindToken); // "kind"
+            $.CONSUME(EqualToken); // "="
+            $.SUBRULE($.schemaFn, { ARGS: [t, "[string]"] });
+          },
+        },
+        {
+          GATE: () => !hasTenantDeploy,
+          ALT: () => {
+            hasTenantDeploy = true;
+            const t = $.CONSUME(TenantDeployToken); // "tenant_deploy"
+            $.CONSUME1(EqualToken); // "="
+            $.SUBRULE1($.schemaFn, { ARGS: [t, "[string]"] });
+          },
+        },
+        {
+          GATE: () => !hasDeployment,
+          ALT: () => {
+            hasDeployment = true;
+            $.SUBRULE($.microserviceDeploymentClause);
+          },
+        },
+        {
+          GATE: () => !hasChart,
+          ALT: () => {
+            hasChart = true;
+            $.SUBRULE($.microserviceChartClause);
+          },
+        },
+        // config / volume / ingress are repeating — no single-shot gate.
+        {
+          ALT: () => $.SUBRULE($.microserviceConfigClause),
+        },
+        {
+          ALT: () => $.SUBRULE($.microserviceVolumeClause),
+        },
+        {
+          ALT: () => $.SUBRULE($.microserviceIngressClause),
+        },
+      ]);
+    });
+
+    // All fields are optional — only the declaration name is required.
+
+    $.MANY1(() => $.CONSUME1(NewlineToken)); // optional new line
+    $.CONSUME(RCurly); // "}"
+    $.MANY2(() => $.CONSUME2(NewlineToken)); // optional new line
+    $.sectionStack.pop();
+  };
+}
+
+// deployment { replicas? docker? strategy?  container <name> { ... } }
+export function microserviceDeploymentClause($) {
+  return () => {
+    let hasReplicas = false;
+    let hasDocker = false;
+    let hasStrategy = false;
+
+    $.CONSUME(DeploymentToken); // "deployment"
+    $.CONSUME(LCurly); // "{"
+    $.MANY(() => {
+      $.AT_LEAST_ONE(() => $.CONSUME(NewlineToken));
+      $.OR([
+        {
+          ALT: () => $.SUBRULE($.commentBlockFn),
+        },
+        {
+          GATE: () => !hasReplicas,
+          ALT: () => {
+            hasReplicas = true;
+            const t = $.CONSUME(ReplicasToken); // "replicas"
+            $.CONSUME(EqualToken); // "="
+            $.SUBRULE($.schemaFn, { ARGS: [t, "[number]"] });
+          },
+        },
+        {
+          GATE: () => !hasDocker,
+          ALT: () => {
+            hasDocker = true;
+            const t = $.CONSUME(DockerToken); // "docker"
+            $.CONSUME1(EqualToken); // "="
+            $.SUBRULE1($.schemaFn, { ARGS: [t, "[string]"] });
+          },
+        },
+        {
+          GATE: () => !hasStrategy,
+          ALT: () => {
+            hasStrategy = true;
+            const t = $.CONSUME(StrategyToken); // "strategy"
+            $.CONSUME2(EqualToken); // "="
+            $.SUBRULE2($.schemaFn, { ARGS: [t, "[string]"] });
+          },
+        },
+        // container is repeating — no single-shot gate.
+        {
+          ALT: () => $.SUBRULE($.microserviceContainerClause),
+        },
+      ]);
+    });
+
+    $.MANY1(() => $.CONSUME1(NewlineToken));
+    $.CONSUME(RCurly); // "}"
+  };
+}
+
+// container <name> { image? pull_secret? type? command? arg? env? ports? resources?  volume <name> { ... } }
+export function microserviceContainerClause($) {
+  return () => {
+    let hasImage = false;
+    let hasPullSecret = false;
+    let hasType = false;
+    let hasCommand = false;
+    let hasArg = false;
+    let hasEnv = false;
+    let hasPorts = false;
+    let hasResources = false;
+
+    $.CONSUME(ContainerToken); // "container"
+    const nameToken = $.OR([
+      { ALT: () => $.CONSUME(StringLiteral) },
+      { ALT: () => $.CONSUME(Identifier) },
+    ]);
+    $.validateDeclarationName(nameToken, "container");
+    $.CONSUME(LCurly); // "{"
+    $.MANY(() => {
+      $.AT_LEAST_ONE(() => $.CONSUME(NewlineToken));
+      $.OR2([
+        {
+          ALT: () => $.SUBRULE($.commentBlockFn),
+        },
+        {
+          GATE: () => !hasImage,
+          ALT: () => {
+            hasImage = true;
+            const t = $.CONSUME(ImageToken); // "image"
+            $.CONSUME(EqualToken); // "="
+            $.SUBRULE($.schemaFn, { ARGS: [t, "[string]"] });
+          },
+        },
+        {
+          GATE: () => !hasPullSecret,
+          ALT: () => {
+            hasPullSecret = true;
+            const t = $.CONSUME(PullSecretToken); // "pull_secret"
+            $.CONSUME1(EqualToken); // "="
+            $.SUBRULE1($.schemaFn, { ARGS: [t, "[string]"] });
+          },
+        },
+        {
+          GATE: () => !hasType,
+          ALT: () => {
+            hasType = true;
+            const t = $.CONSUME(TypeToken); // "type"
+            $.CONSUME2(EqualToken); // "="
+            $.SUBRULE2($.schemaFn, { ARGS: [t, "[string]"] });
+          },
+        },
+        {
+          GATE: () => !hasCommand,
+          ALT: () => {
+            hasCommand = true;
+            const t = $.CONSUME(CommandToken); // "command"
+            $.CONSUME3(EqualToken); // "="
+            // !static:objects { name } -> [ { name: "..." } ]
+            $.SUBRULE3($.schemaFn, { ARGS: [t, [{ name: "[string]" }]] });
+          },
+        },
+        {
+          GATE: () => !hasArg,
+          ALT: () => {
+            hasArg = true;
+            const t = $.CONSUME(ArgToken); // "arg"
+            $.CONSUME4(EqualToken); // "="
+            // !static:objects { name } -> [ { name: "..." } ]
+            $.SUBRULE4($.schemaFn, { ARGS: [t, [{ name: "[string]" }]] });
+          },
+        },
+        {
+          GATE: () => !hasEnv,
+          ALT: () => {
+            hasEnv = true;
+            const t = $.CONSUME(EnvToken); // "env"
+            $.CONSUME5(EqualToken); // "="
+            // !static:objects { name, value?, from_env? }
+            //   -> [ { name: "...", value: "..." },
+            //        { name: "...", from_env: "WORKSPACE_VAR" } ]
+            //
+            // `value` is a literal; `from_env` names a WORKSPACE environment
+            // variable resolved at DEPLOY time (so the secret never enters the
+            // document). The two are mutually exclusive — the server rejects an
+            // entry carrying both — but that is a semantic rule, not a shape
+            // one, so the grammar accepts either key and leaves the diagnostic
+            // to the backend transform.
+            $.SUBRULE5($.schemaFn, {
+              ARGS: [
+                t,
+                [{ name: "[string]", "value?": "[string]", "from_env?": "[string]" }],
+              ],
+            });
+          },
+        },
+        {
+          GATE: () => !hasPorts,
+          ALT: () => {
+            hasPorts = true;
+            const t = $.CONSUME(PortsToken); // "ports"
+            $.CONSUME6(EqualToken); // "="
+            // static:object[] -> [ { ...any } ]
+            $.SUBRULE6($.schemaFn, { ARGS: [t, [{ "[string]?": "[constant]" }]] });
+          },
+        },
+        {
+          GATE: () => !hasResources,
+          ALT: () => {
+            hasResources = true;
+            const t = $.CONSUME(ResourcesToken); // "resources"
+            $.CONSUME7(EqualToken); // "="
+            // static:object -> { ...any }
+            $.SUBRULE7($.schemaFn, { ARGS: [t, { "[string]?": "[constant]" }] });
+          },
+        },
+        // volume is repeating — no single-shot gate.
+        {
+          ALT: () => $.SUBRULE($.microserviceContainerVolumeClause),
+        },
+      ]);
+    });
+
+    $.MANY1(() => $.CONSUME1(NewlineToken));
+    $.CONSUME(RCurly); // "}"
+  };
+}
+
+// container-level volume <name> { type? persistent? emptyDir? config? }
+export function microserviceContainerVolumeClause($) {
+  return () => {
+    const parent = $.CONSUME(VolumeToken); // "volume"
+    const nameToken = $.OR([
+      { ALT: () => $.CONSUME(StringLiteral) },
+      { ALT: () => $.CONSUME(Identifier) },
+    ]);
+    $.validateDeclarationName(nameToken, "volume");
+    $.SUBRULE($.schemaParseAttributeFn, {
+      ARGS: [
+        parent,
+        {
+          "type?": "[string]",
+          "persistent?": { "[string]?": "[constant]" },
+          "emptyDir?": { "[string]?": "[constant]" },
+          "config?": { "[string]?": "[constant]" },
+        },
+      ],
+    });
+  };
+}
+
+// microservice-level config <name> { type? value? }
+export function microserviceConfigClause($) {
+  return () => {
+    const parent = $.CONSUME(ConfigToken); // "config"
+    const nameToken = $.OR([
+      { ALT: () => $.CONSUME(StringLiteral) },
+      { ALT: () => $.CONSUME(Identifier) },
+    ]);
+    $.validateDeclarationName(nameToken, "config");
+    $.SUBRULE($.schemaParseAttributeFn, {
+      ARGS: [parent, { "type?": "[string]", "value?": "[string]" }],
+    });
+  };
+}
+
+// microservice-level volume <name> { size? class? }
+export function microserviceVolumeClause($) {
+  return () => {
+    const parent = $.CONSUME(VolumeToken); // "volume"
+    const nameToken = $.OR([
+      { ALT: () => $.CONSUME(StringLiteral) },
+      { ALT: () => $.CONSUME(Identifier) },
+    ]);
+    $.validateDeclarationName(nameToken, "volume");
+    $.SUBRULE($.schemaParseAttributeFn, {
+      ARGS: [parent, { "size?": "[string]", "class?": "[string]" }],
+    });
+  };
+}
+
+// ingress <name> { domain? path? = [ { service? path? } ] }
+export function microserviceIngressClause($) {
+  return () => {
+    const parent = $.CONSUME(IngressToken); // "ingress"
+    const nameToken = $.OR([
+      { ALT: () => $.CONSUME(StringLiteral) },
+      { ALT: () => $.CONSUME(Identifier) },
+    ]);
+    $.validateDeclarationName(nameToken, "ingress");
+    $.SUBRULE($.schemaParseAttributeFn, {
+      ARGS: [
+        parent,
+        {
+          "domain?": "[string]",
+          "path?": [{ "service?": "[string]", "path?": "[string]" }],
+        },
+      ],
+    });
+  };
+}
+
+// chart { ref? version? values? }
+export function microserviceChartClause($) {
+  return () => {
+    const parent = $.CONSUME(ChartToken); // "chart"
+    $.SUBRULE($.schemaParseAttributeFn, {
+      ARGS: [
+        parent,
+        { "ref?": "[string]", "version?": "[string]", "values?": "[string]" },
+      ],
+    });
+  };
+}

package/parser/parser.js

@@ -57,6 +57,9 @@ export function xanoscriptParser(text, scheme, preTokenized = null) {
     case "message":
       parser.messageDeclaration();
       return parser;
+    case "microservice":
+      parser.microserviceDeclaration();
+      return parser;
     case "middleware":
       parser.middlewareDeclaration();
       return parser;

package/parser/register.js

@@ -16,6 +16,16 @@ 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 {
+  microserviceChartClause,
+  microserviceConfigClause,
+  microserviceContainerClause,
+  microserviceContainerVolumeClause,
+  microserviceDeclaration,
+  microserviceDeploymentClause,
+  microserviceIngressClause,
+  microserviceVolumeClause,
+} from "./microservice_parser.js";
 import { middlewareDeclaration } from "./middleware_parser.js";
 import { queryDeclaration } from "./query_parser.js";
 import { realtimeChannelDeclaration } from "./realtime_channel_parser.js";
@@ -75,6 +85,38 @@ export const register = ($) => {
     mcpServerTriggerDeclaration($)
   );
   $.messageDeclaration = $.RULE("messageDeclaration", messageDeclaration($));
+  $.microserviceDeclaration = $.RULE(
+    "microserviceDeclaration",
+    microserviceDeclaration($)
+  );
+  $.microserviceDeploymentClause = $.RULE(
+    "microserviceDeploymentClause",
+    microserviceDeploymentClause($)
+  );
+  $.microserviceContainerClause = $.RULE(
+    "microserviceContainerClause",
+    microserviceContainerClause($)
+  );
+  $.microserviceContainerVolumeClause = $.RULE(
+    "microserviceContainerVolumeClause",
+    microserviceContainerVolumeClause($)
+  );
+  $.microserviceConfigClause = $.RULE(
+    "microserviceConfigClause",
+    microserviceConfigClause($)
+  );
+  $.microserviceVolumeClause = $.RULE(
+    "microserviceVolumeClause",
+    microserviceVolumeClause($)
+  );
+  $.microserviceIngressClause = $.RULE(
+    "microserviceIngressClause",
+    microserviceIngressClause($)
+  );
+  $.microserviceChartClause = $.RULE(
+    "microserviceChartClause",
+    microserviceChartClause($)
+  );
   $.middlewareDeclaration = $.RULE(
     "middlewareDeclaration",
     middlewareDeclaration($)

package/utils.js

@@ -30,6 +30,7 @@ const schemeByFirstWord = {
   mcp_server: "mcp_server",
   mcp_server_trigger: "mcp_server_trigger",
   message: "message",
+  microservice: "microservice",
   middleware: "middleware",
   query: "api",
   realtime_server: "realtime_server",