@xano/xanoscript-language-server 11.0.3

package/lexer/mcp_server_trigger.js

@@ -0,0 +1,42 @@
+import { Identifier } from "./identifier.js";
+import { createTokenByName } from "./utils.js";
+
+// "actions"
+export const ActionsToken = createTokenByName("actions", {
+  longer_alt: Identifier,
+  categories: [Identifier], // could also be an identifier
+});
+
+// "active"
+export const ActiveToken = createTokenByName("active", {
+  longer_alt: Identifier,
+  categories: [Identifier], // could also be an identifier
+});
+
+// "mcp_server_trigger"
+export const McpServerTriggerToken = createTokenByName("mcp_server_trigger", {
+  longer_alt: Identifier,
+  categories: [Identifier], // could also be an identifier
+});
+
+export const McpServerTriggerTokens = [
+  ActionsToken,
+  ActiveToken,
+  McpServerTriggerToken,
+];
+
+/**
+ * Maps a token name to a type
+ * @param {string} token the token name
+ */
+export function mapTokenToType(token) {
+  switch (token) {
+    case ActionsToken.name:
+    case McpServerTriggerToken.name:
+      return "keyword";
+    case ActiveToken.name:
+      return "variable";
+    default:
+      return null;
+  }
+}

package/lexer/middleware.js

@@ -0,0 +1,42 @@
+import { Identifier } from "./identifier.js";
+import { createTokenByName } from "./utils.js";
+
+// "exception_policy"
+export const ExceptionPolicyToken = createTokenByName("exception_policy", {
+  longer_alt: Identifier,
+  categories: [Identifier], // could also be an identifier
+});
+
+// "middleware"
+export const MiddlewareToken = createTokenByName("middleware", {
+  longer_alt: Identifier,
+  categories: [Identifier], // could also be an identifier
+});
+
+// "response_strategy"
+export const ResponseStrategyToken = createTokenByName("response_strategy", {
+  longer_alt: Identifier,
+  categories: [Identifier], // could also be an identifier
+});
+
+export const MiddlewareTokens = [
+  ExceptionPolicyToken,
+  MiddlewareToken,
+  ResponseStrategyToken,
+];
+
+/**
+ * Maps a token name to a type
+ * @param {string} token the token name
+ */
+export function mapTokenToType(token) {
+  switch (token) {
+    case MiddlewareToken.name:
+      return "keyword";
+    case ExceptionPolicyToken.name:
+    case ResponseStrategyToken.name:
+      return "variable";
+    default:
+      return null;
+  }
+}

package/lexer/multiline.js

@@ -0,0 +1,24 @@
+import { createToken } from "chevrotain";
+
+export const MultiLineStringToken = createToken({
+  name: '"""..."""',
+  pattern:
+    /("""\r?\n(?:[\s\S]*?\r?\n)?[ ]*""")|('''\r?\n(?:[\s\S]*?\r?\n)?[ ]*''')/,
+});
+
+export const MultiLineExpressionToken = createToken({
+  name: "MultiLineExpression",
+  pattern: /```\r?\n(?:[\s\S]*?\r?\n)?[ ]*```/,
+});
+export const MultilineTokens = [MultiLineStringToken, MultiLineExpressionToken];
+
+export function mapTokenToType(token) {
+  switch (token) {
+    case MultiLineStringToken.name:
+      return "tripleString";
+    case MultiLineExpressionToken.name:
+      return "tripleMacro";
+    default:
+      return null;
+  }
+}

package/lexer/multiline.spec.js

@@ -0,0 +1,179 @@
+import { expect } from "chai";
+import { Lexer } from "chevrotain";
+import { describe, it } from "mocha";
+import { MultiLineExpressionToken, MultiLineStringToken } from "./multiline.js";
+
+describe("MultiLineStringToken", () => {
+  const lexer = new Lexer([MultiLineStringToken, MultiLineExpressionToken]);
+
+  it("should match a valid multiline string with content LF", () => {
+    const input = '"""\nThis is a multiline string.\n   """';
+    const result = lexer.tokenize(input);
+    expect(result.errors).to.be.empty;
+    expect(result.tokens).to.have.lengthOf(1);
+    expect(result.tokens[0]).to.include({
+      tokenType: MultiLineStringToken,
+      image: input,
+      startOffset: 0,
+    });
+  });
+
+  it("should match a valid multiline string with content CRLF", () => {
+    const input = '"""\r\nThis is a multiline string.\r\n   """';
+    const result = lexer.tokenize(input);
+    expect(result.errors).to.be.empty;
+    expect(result.tokens).to.have.lengthOf(1);
+    expect(result.tokens[0]).to.include({
+      tokenType: MultiLineStringToken,
+      image: input,
+      startOffset: 0,
+    });
+  });
+
+  it("should match a valid multiline expression with content", () => {
+    const input = '```\n{"x": "test"}\n   ```';
+    const result = lexer.tokenize(input);
+    expect(result.errors).to.be.empty;
+    expect(result.tokens).to.have.lengthOf(1);
+    expect(result.tokens[0]).to.include({
+      tokenType: MultiLineExpressionToken,
+      image: input,
+      startOffset: 0,
+    });
+  });
+
+  it("should match a valid multiline string with content (single quote)", () => {
+    const input = "'''\nThis is a multiline string.\n   '''";
+    const result = lexer.tokenize(input);
+    expect(result.errors).to.be.empty;
+    expect(result.tokens).to.have.lengthOf(1);
+    expect(result.tokens[0]).to.include({
+      tokenType: MultiLineStringToken,
+      image: input,
+      startOffset: 0,
+    });
+  });
+
+  it("should match a valid empty multiline string", () => {
+    const input = '"""\n"""';
+    const result = lexer.tokenize(input);
+    expect(result.errors).to.be.empty;
+    expect(result.tokens).to.have.lengthOf(1);
+    expect(result.tokens[0]).to.include({
+      tokenType: MultiLineStringToken,
+      image: input,
+      startOffset: 0,
+    });
+  });
+  it("should match a valid empty multiline string (single quotes)", () => {
+    const input = "'''\n'''";
+    const result = lexer.tokenize(input);
+    expect(result.errors).to.be.empty;
+    expect(result.tokens).to.have.lengthOf(1);
+    expect(result.tokens[0]).to.include({
+      tokenType: MultiLineStringToken,
+      image: input,
+      startOffset: 0,
+    });
+  });
+
+  it("should match a valid empty multiline expression", () => {
+    const input = "```\n```";
+    const result = lexer.tokenize(input);
+    expect(result.errors).to.be.empty;
+    expect(result.tokens).to.have.lengthOf(1);
+    expect(result.tokens[0]).to.include({
+      tokenType: MultiLineExpressionToken,
+      image: input,
+      startOffset: 0,
+    });
+  });
+
+  it("should match a multiline string with a single string quote sentence inside", () => {
+    const input = '"""\nconsole.log("quoted"); // sentence.\n"""';
+    const result = lexer.tokenize(input);
+    expect(result.errors).to.be.empty;
+    expect(result.tokens).to.have.lengthOf(1);
+    expect(result.tokens[0]).to.include({
+      tokenType: MultiLineStringToken,
+      image: input,
+      startOffset: 0,
+    });
+  });
+
+  it("should match a multiline string followed by other content", () => {
+    const input = '"""\nContent here\n """\nnextToken';
+    const result = lexer.tokenize(input);
+    expect(result.tokens).to.have.lengthOf(1);
+    expect(result.tokens[0]).to.include({
+      tokenType: MultiLineStringToken,
+      image: '"""\nContent here\n """',
+      startOffset: 0,
+    });
+    // Errors for '\nnextToken' are expected
+  });
+
+  it("should reject a multiline string with no newline after opening quotes", () => {
+    const input = '""" Content\n"""';
+    const result = lexer.tokenize(input);
+    expect(result.tokens).to.be.empty;
+    expect(result.errors).to.not.be.empty;
+  });
+
+  it("should reject a multiline string with non-space characters before closing quotes", () => {
+    const input = '"""\nContent\nfoo """';
+    const result = lexer.tokenize(input);
+    expect(result.tokens).to.be.empty;
+    expect(result.errors).to.not.be.empty;
+  });
+
+  it("should reject a multiline string with tabs before closing quotes", () => {
+    const input = '"""\nContent\n\t"""';
+    const result = lexer.tokenize(input);
+    expect(result.tokens).to.be.empty;
+    expect(result.errors).to.not.be.empty;
+  });
+
+  it("should reject a multiline expression with tabs before closing quotes", () => {
+    const input = "```\nContent\n\t```";
+    const result = lexer.tokenize(input);
+    expect(result.tokens).to.be.empty;
+    expect(result.errors).to.not.be.empty;
+  });
+
+  it("should handle internal opposite quotes correctly (double quotes)", () => {
+    const input = '"""\nThis has \'\'\' inside\n """';
+    const result = lexer.tokenize(input);
+    expect(result.errors).to.be.empty;
+    expect(result.tokens).to.have.lengthOf(1);
+    expect(result.tokens[0]).to.include({
+      tokenType: MultiLineStringToken,
+      image: input,
+      startOffset: 0,
+    });
+  });
+
+  it("should handle internal opposite quotes correctly (single quotes)", () => {
+    const input = "'''\nThis has \"\"\" inside\n '''";
+    const result = lexer.tokenize(input);
+    expect(result.errors).to.be.empty;
+    expect(result.tokens).to.have.lengthOf(1);
+    expect(result.tokens[0]).to.include({
+      tokenType: MultiLineStringToken,
+      image: input,
+      startOffset: 0,
+    });
+  });
+
+  it("should handle internal triple quotes correctly", () => {
+    const input = '"""\nThis has """ inside\n """';
+    const result = lexer.tokenize(input);
+    expect(result.errors).to.be.empty;
+    expect(result.tokens).to.have.lengthOf(1);
+    expect(result.tokens[0]).to.include({
+      tokenType: MultiLineStringToken,
+      image: input,
+      startOffset: 0,
+    });
+  });
+});

package/lexer/object.js

@@ -0,0 +1,44 @@
+import { Identifier } from "./identifier.js";
+import { createTokenByName } from "./utils.js";
+
+// object
+export const ObjectToken = createTokenByName("object", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// object.entries
+export const EntriesToken = createTokenByName("entries", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// object.keys
+export const KeysToken = createTokenByName("keys", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// object.values
+export const ValuesToken = createTokenByName("values", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+export const ObjectTokens = [ObjectToken, EntriesToken, KeysToken, ValuesToken];
+
+/**
+ * Maps a token name to a type
+ * @param {string} token the token name
+ */
+export function mapTokenToType(token) {
+  switch (token) {
+    case ObjectToken.name:
+    case EntriesToken.name:
+    case KeysToken.name:
+    case ValuesToken.name:
+      return "function";
+    default:
+      return null;
+  }
+}

package/lexer/query.js

@@ -0,0 +1,99 @@
+import { Identifier } from "./identifier.js";
+import { createTokenByName } from "./utils.js";
+
+export const QueryToken = createTokenByName("query", {
+  longer_alt: Identifier,
+  categories: [Identifier], // could also be an identifier
+});
+
+export const VerbToken = createTokenByName("verb", {
+  longer_alt: Identifier,
+  categories: [Identifier], // could also be an identifier
+});
+
+// Following are the method for query endpoints
+export const GETToken = createTokenByName("GET", {
+  longer_alt: Identifier,
+  categories: [Identifier], // could also be an identifier
+});
+
+export const PATCHToken = createTokenByName("PATCH", {
+  longer_alt: Identifier,
+  categories: [Identifier], // could also be an identifier
+});
+export const POSTToken = createTokenByName("POST", {
+  longer_alt: Identifier,
+  categories: [Identifier], // could also be an identifier
+});
+export const PUTToken = createTokenByName("PUT", {
+  longer_alt: Identifier,
+  categories: [Identifier], // could also be an identifier
+});
+export const DELETEToken = createTokenByName("DELETE", {
+  categories: [Identifier], // could also be an identifier
+  longer_alt: Identifier,
+});
+
+// response_type
+export const ResponseTypeToken = createTokenByName("response_type", {
+  longer_alt: Identifier,
+  categories: [Identifier], // could also be an identifier
+});
+
+// dblink
+export const DbLinkToken = createTokenByName("dblink", {
+  longer_alt: Identifier,
+  categories: [Identifier], // could also be an identifier
+});
+
+// output
+export const OutputToken = createTokenByName("output", {
+  longer_alt: Identifier,
+  categories: [Identifier], // could also be an identifier
+});
+
+// addon
+export const AddonToken = createTokenByName("addon", {
+  longer_alt: Identifier,
+  categories: [Identifier], // could also be an identifier
+});
+
+export const QueryTokens = [
+  ResponseTypeToken,
+  QueryToken,
+  VerbToken,
+  GETToken,
+  PATCHToken,
+  POSTToken,
+  PUTToken,
+  DELETEToken,
+  DbLinkToken,
+  OutputToken,
+  AddonToken,
+];
+
+/**
+ * Maps a token name to a type
+ * @param {string} token the token name
+ */
+export function mapTokenToType(token) {
+  switch (token) {
+    case QueryToken.name:
+    case VerbToken.name:
+    case ResponseTypeToken.name:
+      return "keyword";
+    case GETToken.name:
+    case PATCHToken.name:
+    case POSTToken.name:
+    case PUTToken.name:
+    case DELETEToken.name:
+      return "enumMember";
+
+    case DbLinkToken.name:
+    case OutputToken.name:
+    case AddonToken.name:
+      return "property";
+    default:
+      return null;
+  }
+}

package/lexer/realtime_trigger.js

@@ -0,0 +1,50 @@
+import { Identifier } from "./identifier.js";
+import { createTokenByName } from "./utils.js";
+
+// "actions"
+export const ActionsToken = createTokenByName("actions", {
+  longer_alt: Identifier,
+  categories: [Identifier], // could also be an identifier
+});
+
+// "active"
+export const ActiveToken = createTokenByName("active", {
+  longer_alt: Identifier,
+  categories: [Identifier], // could also be an identifier
+});
+
+// "realtime_trigger"
+export const RealtimeTriggerToken = createTokenByName("realtime_trigger", {
+  longer_alt: Identifier,
+  categories: [Identifier], // could also be an identifier
+});
+
+// realtime_channel
+export const RealtimeChannelToken = createTokenByName("realtime_channel", {
+  longer_alt: Identifier,
+  categories: [Identifier], // could also be an identifier
+});
+
+export const RealtimeTriggerTokens = [
+  ActionsToken,
+  ActiveToken,
+  RealtimeTriggerToken,
+  RealtimeChannelToken,
+];
+
+/**
+ * Maps a token name to a type
+ * @param {string} token the token name
+ */
+export function mapTokenToType(token) {
+  switch (token) {
+    case ActionsToken.name:
+    case RealtimeTriggerToken.name:
+    case RealtimeChannelToken.name:
+      return "keyword";
+    case ActiveToken.name:
+      return "variable";
+    default:
+      return null;
+  }
+}

package/lexer/redis.js

@@ -0,0 +1,145 @@
+import { Identifier } from "./identifier.js";
+import { createTokenByName } from "./utils.js";
+
+// redis
+export const RedisToken = createTokenByName("redis", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// count
+export const CountToken = createTokenByName("count", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// decr
+export const DecrToken = createTokenByName("decr", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// del
+export const DelToken = createTokenByName("del", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// get
+export const GetToken = createTokenByName("get", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// has
+export const HasToken = createTokenByName("has", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// incr
+export const IncrToken = createTokenByName("incr", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// keys
+export const KeysToken = createTokenByName("keys", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// pop
+export const PopToken = createTokenByName("pop", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// push
+export const PushToken = createTokenByName("push", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// range
+export const RangeToken = createTokenByName("range", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// ratelimit
+export const RatelimitToken = createTokenByName("ratelimit", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// remove
+export const RemoveToken = createTokenByName("remove", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// set
+export const SetToken = createTokenByName("set", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// shift
+export const ShiftToken = createTokenByName("shift", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// unshift
+export const UnshiftToken = createTokenByName("unshift", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+export const RedisTokens = [
+  RedisToken,
+  CountToken,
+  DecrToken,
+  DelToken,
+  GetToken,
+  HasToken,
+  IncrToken,
+  KeysToken,
+  PopToken,
+  PushToken,
+  RangeToken,
+  RatelimitToken,
+  RemoveToken,
+  SetToken,
+  ShiftToken,
+  UnshiftToken,
+];
+
+/**
+ * Maps a token name to a type
+ * @param {string} token the token name
+ */
+export function mapTokenToType(token) {
+  switch (token) {
+    case RedisToken.name:
+    case CountToken.name:
+    case DecrToken.name:
+    case DelToken.name:
+    case GetToken.name:
+    case HasToken.name:
+    case IncrToken.name:
+    case KeysToken.name:
+    case PopToken.name:
+    case PushToken.name:
+    case RangeToken.name:
+    case RatelimitToken.name:
+    case RemoveToken.name:
+    case SetToken.name:
+    case ShiftToken.name:
+    case UnshiftToken.name:
+      return "function";
+    default:
+      return null;
+  }
+}