@xano/xanoscript-language-server 11.0.3

package/lexer/utils.js

@@ -0,0 +1,56 @@
+import { createToken } from "chevrotain";
+
+const tokenRegistry = new Map();
+
+/**
+ * A factory function to create a token with a unique pattern
+ *
+ * @param {import('chevrotain').ITokenConfig} config The configuration object for the token
+ * @returns {import('chevrotain').TokenType}
+ */
+export function createUniqToken(config) {
+  const { pattern } = config;
+  const patternKey = pattern.toString(); // Convert RegExp to string for Map key
+  if (tokenRegistry.has(patternKey)) {
+    return tokenRegistry.get(patternKey);
+  }
+  const token = createToken(config);
+  tokenRegistry.set(patternKey, token);
+  return token;
+}
+
+/**
+ * A shorthand function to create a token with a name derived from the given name
+ *
+ * @param {string} name The name of the token will be used to generate its pattern
+ * @param {import('chevrotain').ITokenConfig} config The configuration object for the token
+ * @returns {import('chevrotain').TokenType}
+ */
+export function createTokenByName(name, config) {
+  return createUniqToken({
+    name: `${name} token`,
+    pattern: new RegExp(name),
+    label: name,
+    ...config,
+  });
+}
+
+export function __resetTokens() {
+  tokenRegistry.clear();
+}
+
+export function sortUniqTokens(tokens) {
+  // make tokens unique
+  tokens = Array.from(new Set(tokens));
+
+  // sort by pattern length
+  return tokens.sort((a, b) => {
+    if (a.PATTERN.source.length > b.PATTERN.source.length) {
+      return -1;
+    }
+    if (a.PATTERN.source.length < b.PATTERN.source.length) {
+      return 1;
+    }
+    return 0;
+  });
+}

package/lexer/utils.spec.js

@@ -0,0 +1,61 @@
+import { expect } from "chai";
+import { beforeEach,describe, it } from "mocha";
+import {
+  __resetTokens,
+  createTokenByName,
+  createUniqToken,
+  sortUniqTokens,
+} from "./utils.js";
+
+describe("createUniqToken", () => {
+  beforeEach(() => {
+    __resetTokens();
+  });
+
+  it("creates a token with a unique pattern", () => {
+    const token1 = createUniqToken({ pattern: /foo/ });
+    const token2 = createUniqToken({ pattern: /foo/ });
+    expect(token1).to.equal(token2);
+  });
+});
+
+describe("createTokenByName", () => {
+  beforeEach(() => {
+    __resetTokens();
+  });
+
+  it("creates a token with a name derived from the given name", () => {
+    const token = createTokenByName("foo");
+    expect(token.name).to.equal("foo token");
+    expect(token.LABEL).to.equal("foo");
+    expect(new RegExp(token.pattern).test("foo")).to.be.true;
+  });
+
+  it("creates a token with a name derived from the given name", () => {
+    const token = createTokenByName("$remote_ip", { pattern: /\$remote_ip/ });
+    expect(token.name).to.equal("$remote_ip token");
+    expect(token.LABEL).to.equal("$remote_ip");
+  });
+
+  it("does not create duplicate tokens", () => {
+    const token1 = createTokenByName("foo");
+    const token2 = createTokenByName("foo");
+    expect(token1).to.equal(token2);
+  });
+
+  it("differentiate between lowercase and uppercase", () => {
+    const token_get = createTokenByName("get");
+    const token_GET = createTokenByName("GET");
+    expect(token_get.name).to.not.equal(token_GET.name);
+  });
+});
+
+describe("sortUniqTokens", () => {
+  it("sorts tokens by pattern length", () => {
+    const token1 = createUniqToken({ pattern: /foo/ });
+    const token2 = createUniqToken({ pattern: /fooBar/ });
+    const token3 = createUniqToken({ pattern: /fooBarBaz/ });
+    const tokens = sortUniqTokens([token1, token2, token3]);
+    expect(tokens).to.deep.equal([token3, token2, token1]);
+  });
+});

package/lexer/var.js

@@ -0,0 +1,30 @@
+import { Identifier } from "./identifier.js";
+import { createTokenByName } from "./utils.js";
+
+// var
+export const VarToken = createTokenByName("var", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// var.update
+export const UpdateToken = createTokenByName("update", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+export const VarTokens = [VarToken, UpdateToken];
+
+/**
+ * Maps a token name to a type
+ * @param {string} token the token name
+ */
+export function mapTokenToType(token) {
+  switch (token) {
+    case VarToken.name:
+    case UpdateToken.name:
+      return "function";
+    default:
+      return null;
+  }
+}

package/lexer/variables.js

@@ -0,0 +1,217 @@
+import { createUniqToken } from "./utils.js";
+
+export const ShortFormVariable = createUniqToken({
+  name: "ShortFormVariable",
+  pattern: /(\$[a-zA-Z_]\w*)|(\$\$)/,
+  label: "$",
+});
+
+export const ResponseVariable = createUniqToken({
+  name: "ResponseVariable",
+  pattern: /\$response/,
+  label: "$response",
+  categories: [ShortFormVariable],
+  longer_alt: ShortFormVariable,
+});
+
+export const LongFormVariable = createUniqToken({
+  name: "LongFormVariable",
+  pattern: /\$var/,
+  label: "$var",
+  longer_alt: ShortFormVariable, // allow $variable to be matched as short form variable
+});
+
+// $this
+export const ContentThisToken = createUniqToken({
+  name: "$this",
+  pattern: /\$this/,
+  longer_alt: ShortFormVariable,
+  categories: [ShortFormVariable],
+});
+
+export const InputVariable = createUniqToken({
+  name: "InputVariable",
+  pattern: /\$input/,
+  longer_alt: ShortFormVariable,
+});
+
+export const EnvVariable = createUniqToken({
+  name: "EnvVariable",
+  pattern: /\$env/,
+  label: "$env",
+  longer_alt: ShortFormVariable,
+});
+
+export const AuthVariable = createUniqToken({
+  name: "AuthVariable",
+  pattern: /\$auth/,
+  label: "$auth",
+  longer_alt: ShortFormVariable,
+});
+
+export const RemoteIpVariable = createUniqToken({
+  name: "$remote_ip",
+  pattern: /\$remote_ip/,
+  longer_alt: ShortFormVariable,
+});
+
+// $tenant
+export const TenantVariable = createUniqToken({
+  name: "$tenant",
+  pattern: /\$tenant/,
+  longer_alt: ShortFormVariable,
+});
+
+export const ErrorVariable = createUniqToken({
+  name: "$error",
+  pattern: /\$error/,
+  longer_alt: ShortFormVariable,
+});
+
+export const RemotePortVariable = createUniqToken({
+  name: "$remote_port",
+  pattern: /\$remote_port/,
+  longer_alt: ShortFormVariable,
+});
+
+export const RemoteUserVariable = createUniqToken({
+  name: "$remote_user",
+  pattern: /\$remote_user/,
+  longer_alt: ShortFormVariable,
+});
+
+// $http_headers
+export const HttpHeadersVariable = createUniqToken({
+  name: "$http_headers",
+  pattern: /\$http_headers/,
+  longer_alt: ShortFormVariable,
+});
+
+// $webflow
+export const WebflowVariable = createUniqToken({
+  name: "$webflow",
+  pattern: /\$webflow/,
+  longer_alt: ShortFormVariable,
+});
+
+// $api_baseurl
+export const ApiBaseUrlVariable = createUniqToken({
+  name: "$api_baseurl",
+  pattern: /\$api_baseurl/,
+  longer_alt: ShortFormVariable,
+});
+
+// $request_uri
+export const RequestUriVariable = createUniqToken({
+  name: "$request_uri",
+  pattern: /\$request_uri/,
+  longer_alt: ShortFormVariable,
+});
+
+// $request_querystring
+export const RequestQuerystringVariable = createUniqToken({
+  name: "$request_querystring",
+  pattern: /\$request_querystring/,
+  longer_alt: ShortFormVariable,
+});
+
+// $request_auth_token
+export const RequestAuthTokenVariable = createUniqToken({
+  name: "$request_auth_token",
+  pattern: /\$request_auth_token/,
+  longer_alt: ShortFormVariable,
+});
+
+// $datasource
+export const DatasourceVariable = createUniqToken({
+  name: "$datasource",
+  pattern: /\$datasource/,
+  longer_alt: ShortFormVariable,
+});
+
+// $branch
+export const BranchVariable = createUniqToken({
+  name: "$branch",
+  pattern: /\$branch/,
+  longer_alt: ShortFormVariable,
+});
+
+export const RemotePasswordVariable = createUniqToken({
+  name: "$remote_passwd",
+  pattern: /\$remote_passwd/,
+  longer_alt: ShortFormVariable,
+});
+
+export const RemoteHostVariable = createUniqToken({
+  name: "$remote_host",
+  pattern: /\$remote_host/,
+  longer_alt: ShortFormVariable,
+});
+
+export const RequestMethod = createUniqToken({
+  name: "$request_method",
+  pattern: /\$request_method/,
+  longer_alt: ShortFormVariable,
+});
+
+export const VariableTokens = [
+  ResponseVariable,
+  ContentThisToken,
+  LongFormVariable,
+  InputVariable,
+  EnvVariable,
+  AuthVariable,
+  ErrorVariable,
+  RemoteIpVariable,
+  TenantVariable,
+  RemotePortVariable,
+  RemoteUserVariable,
+  RemotePasswordVariable,
+  RemoteHostVariable,
+  RequestMethod,
+  HttpHeadersVariable,
+  WebflowVariable,
+  ApiBaseUrlVariable,
+  RequestUriVariable,
+  RequestQuerystringVariable,
+  RequestAuthTokenVariable,
+  DatasourceVariable,
+  BranchVariable,
+  ShortFormVariable, // short form should be last to avoid conflicts with $env, $auth, etc.
+];
+
+/**
+ * Maps a token name to a type
+ * @param {string} token the token name
+ */
+export function mapTokenToType(token) {
+  switch (token) {
+    case InputVariable.name:
+    case ErrorVariable.name:
+    case EnvVariable.name:
+    case AuthVariable.name:
+    case RemoteIpVariable.name:
+    case TenantVariable.name:
+    case RemotePortVariable.name:
+    case RemoteUserVariable.name:
+    case RemotePasswordVariable.name:
+    case RemoteHostVariable.name:
+    case RequestMethod.name:
+    case ResponseVariable.name:
+    case LongFormVariable.name:
+    case HttpHeadersVariable.name:
+    case WebflowVariable.name:
+    case ApiBaseUrlVariable.name:
+    case RequestUriVariable.name:
+    case RequestQuerystringVariable.name:
+    case RequestAuthTokenVariable.name:
+    case DatasourceVariable.name:
+    case BranchVariable.name:
+      return "enumMember";
+    case ContentThisToken.name:
+    case ShortFormVariable.name:
+      return "variable";
+    default:
+      return null;
+  }
+}

package/lexer/workflow_test.js

@@ -0,0 +1,42 @@
+import { Identifier } from "./identifier.js";
+import { createTokenByName } from "./utils.js";
+
+// "datasource"
+export const DatasourceToken = createTokenByName("datasource", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// "workflow_test"
+export const WorkflowTestToken = createTokenByName("workflow_test", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// "exception"
+export const ExceptionToken = createTokenByName("exception", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+export const WorkflowTestTokens = [
+  DatasourceToken,
+  WorkflowTestToken,
+  ExceptionToken,
+];
+
+/**
+ * Maps a token name to a type
+ * @param {string} token the token name
+ */
+export function mapTokenToType(token) {
+  switch (token) {
+    case WorkflowTestToken.name:
+      return "keyword";
+    case ExceptionToken.name:
+    case DatasourceToken.name:
+      return "variable";
+    default:
+      return null;
+  }
+}

package/lexer/workspace.js

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

package/lexer/workspace_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
+});
+
+// "workspace_trigger"
+export const WorkspaceTriggerToken = createTokenByName("workspace_trigger", {
+  longer_alt: Identifier,
+  categories: [Identifier], // could also be an identifier
+});
+
+export const WorkspaceTriggerTokens = [
+  ActionsToken,
+  ActiveToken,
+  WorkspaceTriggerToken,
+];
+
+/**
+ * Maps a token name to a type
+ * @param {string} token the token name
+ */
+export function mapTokenToType(token) {
+  switch (token) {
+    case ActionsToken.name:
+    case WorkspaceTriggerToken.name:
+      return "keyword";
+    case ActiveToken.name:
+      return "variable";
+    default:
+      return null;
+  }
+}

package/lexer/zip.js

@@ -0,0 +1,63 @@
+import { Identifier } from "./identifier.js";
+import { createTokenByName } from "./utils.js";
+
+// zip
+export const ZipToken = createTokenByName("zip", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// add_to_archive
+export const AddToArchiveToken = createTokenByName("add_to_archive", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// create_archive
+export const CreateArchiveToken = createTokenByName("create_archive", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// delete_from_archive
+export const DeleteFromArchiveToken = createTokenByName("delete_from_archive", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// extract
+export const ExtractToken = createTokenByName("extract", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// view_archive
+export const ViewContentsToken = createTokenByName("view_contents", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+export const ZipTokens = [
+  ZipToken,
+  AddToArchiveToken,
+  CreateArchiveToken,
+  DeleteFromArchiveToken,
+  ExtractToken,
+  ViewContentsToken,
+];
+
+/**
+ * Maps a token name to a type
+ * @param {string} token the token name
+ */
+export function mapTokenToType(token) {
+  switch (token) {
+    case ZipToken.name:
+    case AddToArchiveToken.name:
+    case CreateArchiveToken.name:
+    case DeleteFromArchiveToken.name:
+    case ExtractToken.name:
+    case ViewContentsToken.name:
+      return "function";
+  }
+}

package/logic-assistant-script.js

@@ -0,0 +1,8 @@
+import { onCheckError } from "./onCheckError/onCheckError.js";
+
+function checkError(text, objectType) {
+  return onCheckError(text, objectType);
+}
+window.xsLanguageServer = {
+  checkError,
+};

package/onCheckError/onCheckError.js

@@ -0,0 +1,43 @@
+import { xanoscriptParser } from "../parser/parser";
+import { getSchemeFromContent } from "../utils";
+
+export function onCheckError(text, objectType) {
+  const scheme = getSchemeFromContent(objectType ?? text);
+
+  try {
+    // Parse the XanoScript file
+    const parser = xanoscriptParser(text, scheme);
+
+    if (parser.errors.length === 0) {
+      // If parsing succeeds, send an empty diagnostics array (no errors)
+      return [];
+    }
+
+    // If parsing fails, create a diagnostic (error message) to display in VS Code
+    const diagnostics = parser.errors.map((error) => {
+      const startOffset = error.token?.startOffset ?? 0;
+      const endOffset = error.token?.endOffset ?? 5;
+      // Calculate line and character positions from offset
+      const lines = text.substring(0, startOffset).split("\n");
+      const line = lines.length - 1;
+      const character = lines[lines.length - 1].length;
+
+      const endLines = text.substring(0, endOffset + 1).split("\n");
+      const endLine = endLines.length - 1;
+      const endCharacter = endLines[endLines.length - 1].length;
+
+      return {
+        range: {
+          start: { line, character },
+          end: { line: endLine, character: endCharacter },
+        },
+        message: error.message,
+        source: error.name || "XanoScript Parser",
+      };
+    });
+
+    return diagnostics;
+  } catch (error) {
+    console.error("Error checking for XanoScripterrors:", error);
+  }
+}