@xano/xanoscript-language-server 11.0.3

package/lexer/db.js

@@ -0,0 +1,190 @@
+import { Identifier } from "./identifier.js";
+import { createTokenByName } from "./utils.js";
+
+// db
+export const DbToken = createTokenByName("db", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// query
+export const QueryToken = createTokenByName("query", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// get
+export const GetToken = createTokenByName("get", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// add
+export const AddToken = createTokenByName("add", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// add_or_edit
+export const AddOrEditToken = createTokenByName("add_or_edit", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// del (stands for delete)
+export const DelToken = createTokenByName("del", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// delete
+export const DeleteToken = createTokenByName("delete", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// edit
+export const EditToken = createTokenByName("edit", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// update --- weirdly enough we have db.batch.update and db.edit
+export const UpdateToken = createTokenByName("update", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// has
+export const HasToken = createTokenByName("has", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// patch
+export const PatchToken = createTokenByName("patch", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// schema
+export const SchemaToken = createTokenByName("schema", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// transaction
+export const TransactionToken = createTokenByName("transaction", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// truncate
+export const TruncateToken = createTokenByName("truncate", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// direct_query
+export const DirectQueryToken = createTokenByName("direct_query", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// set_datasource
+export const SetDatasourceToken = createTokenByName("set_datasource", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// bulk
+export const BulkToken = createTokenByName("bulk", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// db.external
+export const ExternalToken = createTokenByName("external", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// db.external.mssql
+export const MssqlToken = createTokenByName("mssql", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// db.external.mysql
+export const MysqlToken = createTokenByName("mysql", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// db.external.postgres
+export const PostgresToken = createTokenByName("postgres", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// db.external.oracle
+export const OracleToken = createTokenByName("oracle", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+export const DbTokens = [
+  DbToken,
+  QueryToken,
+  GetToken,
+  AddOrEditToken,
+  AddToken,
+  DeleteToken,
+  DelToken,
+  EditToken,
+  UpdateToken,
+  HasToken,
+  PatchToken,
+  SchemaToken,
+  TransactionToken,
+  TruncateToken,
+  DirectQueryToken,
+  SetDatasourceToken,
+  BulkToken,
+  ExternalToken,
+  MssqlToken,
+  MysqlToken,
+  PostgresToken,
+  OracleToken,
+];
+
+export function mapTokenToType(token) {
+  switch (token) {
+    case SchemaToken.name:
+      return "keyword";
+    case DbToken.name:
+    case BulkToken.name:
+    case ExternalToken.name:
+    case MssqlToken.name:
+    case MysqlToken.name:
+    case PostgresToken.name:
+    case OracleToken.name:
+    case QueryToken.name:
+    case GetToken.name:
+    case AddToken.name:
+    case AddOrEditToken.name:
+    case DeleteToken.name:
+    case DelToken.name:
+    case EditToken.name:
+    case UpdateToken.name:
+    case HasToken.name:
+    case PatchToken.name:
+    case TransactionToken.name:
+    case TruncateToken.name:
+    case DirectQueryToken.name:
+    case SetDatasourceToken.name:
+      return "function";
+    default:
+      return null;
+  }
+}

package/lexer/debug.js

@@ -0,0 +1,37 @@
+import { Identifier } from "./identifier.js";
+import { createTokenByName } from "./utils.js";
+
+// debug
+export const DebugToken = createTokenByName("debug", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// debug.stop
+export const DebugStopToken = createTokenByName("stop", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// debug.log
+export const DebugLogToken = createTokenByName("log", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+export const DebugTokens = [DebugToken, DebugStopToken, DebugLogToken];
+
+/**
+ * Maps a token name to a type
+ * @param {string} token the token name
+ */
+export function mapTokenToType(token) {
+  switch (token) {
+    case DebugToken.name:
+    case DebugStopToken.name:
+    case DebugLogToken.name:
+      return "function";
+    default:
+      return null;
+  }
+}

package/lexer/expect.js

@@ -0,0 +1,157 @@
+import { Identifier } from "./identifier.js";
+import { createTokenByName } from "./utils.js";
+
+export const ExpectToken = createTokenByName("expect", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+export const ToBeTrueToken = createTokenByName("to_be_true", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+export const ToBeFalseToken = createTokenByName("to_be_false", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+export const ToBeInThePastToken = createTokenByName("to_be_in_the_past", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+export const ToBeInTheFutureToken = createTokenByName("to_be_in_the_future", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+export const ToBeDefinedToken = createTokenByName("to_be_defined", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+export const ToNotBeDefinedToken = createTokenByName("to_not_be_defined", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+export const ToBeNullToken = createTokenByName("to_be_null", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+export const ToNotBeNullToken = createTokenByName("to_not_be_null", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+export const ToBeEmptyToken = createTokenByName("to_be_empty", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+export const ToStartWithToken = createTokenByName("to_start_with", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+export const ToEndWithToken = createTokenByName("to_end_with", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+export const ToBeGreaterThanToken = createTokenByName("to_be_greater_than", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+export const ToBeLessThanToken = createTokenByName("to_be_less_than", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+export const ToMatchToken = createTokenByName("to_match", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+export const ToEqualToken = createTokenByName("to_equal", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+export const ToNotEqualToken = createTokenByName("to_not_equal", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+export const ToContainToken = createTokenByName("to_contain", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+export const ToBeWithinToken = createTokenByName("to_be_within", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+export const ToThrowToken = createTokenByName("to_throw", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+export const ExpectFnTokens = [
+  ExpectToken,
+  ToBeTrueToken,
+  ToBeFalseToken,
+  ToBeInThePastToken,
+  ToBeInTheFutureToken,
+  ToBeDefinedToken,
+  ToNotBeDefinedToken,
+  ToBeNullToken,
+  ToNotBeNullToken,
+  ToBeEmptyToken,
+  ToStartWithToken,
+  ToEndWithToken,
+  ToBeGreaterThanToken,
+  ToBeLessThanToken,
+  ToMatchToken,
+  ToEqualToken,
+  ToNotEqualToken,
+  ToContainToken,
+  ToBeWithinToken,
+  ToThrowToken,
+];
+
+/**
+ * Maps a token name to a type
+ * @param {string} token the token name
+ */
+export function mapTokenToType(token) {
+  switch (token) {
+    case ExpectToken.name:
+    case ToBeTrueToken.name:
+    case ToBeFalseToken.name:
+    case ToBeInThePastToken.name:
+    case ToBeInTheFutureToken.name:
+    case ToBeDefinedToken.name:
+    case ToNotBeDefinedToken.name:
+    case ToBeNullToken.name:
+    case ToNotBeNullToken.name:
+    case ToBeEmptyToken.name:
+    case ToStartWithToken.name:
+    case ToEndWithToken.name:
+    case ToBeGreaterThanToken.name:
+    case ToBeLessThanToken.name:
+    case ToMatchToken.name:
+    case ToEqualToken.name:
+    case ToNotEqualToken.name:
+    case ToContainToken.name:
+    case ToBeWithinToken.name:
+    case ToThrowToken.name:
+      return "function";
+    default:
+      return null;
+  }
+}

package/lexer/function.js

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

package/lexer/identifier.js

@@ -0,0 +1,6 @@
+import { createUniqToken } from "./utils.js";
+
+export const Identifier = createUniqToken({
+  name: "Identifier",
+  pattern: /[a-zA-Z_]\w*/,
+});

package/lexer/lexer.js

@@ -0,0 +1,26 @@
+import { Lexer } from "chevrotain";
+import { without } from "lodash-es";
+import { DisabledStatementToken, ExclamationToken } from "./cast.js";
+import { allTokens } from "./tokens.js";
+
+export const lexer = new Lexer(allTokens);
+// for the DisabledStatementToken to work, we need to remove the ExclamationToken from the lexer
+// otherwise the '!' will always be matched first
+// The parser will never use this lexer, it's only for highlighting (displaying disabled statements in a different color)
+export const lexerWithDisabled = new Lexer([
+  ...without(allTokens, ExclamationToken),
+  DisabledStatementToken,
+]);
+
+/**
+ * To be use for testing purposes, the lexer should be invoked with the input text
+ * from the parser.
+ *
+ * @param {string} inputText
+ * @returns {import('chevrotain').ILexingResult}
+ */
+export function lexDocument(inputText, disabled = false) {
+  return disabled
+    ? lexerWithDisabled.tokenize(inputText)
+    : lexer.tokenize(inputText);
+}

package/lexer/literal.js

@@ -0,0 +1,77 @@
+import { createUniqToken } from "./utils.js";
+
+// captures `...` for xano expressions
+export const ExpressionLiteral = createUniqToken({
+  name: "ExpressionLiteral",
+  label: "`...`",
+  pattern: /`([^`\\]|\\.)*`/,
+}); // Backtick-quoted template literals
+
+// captures "..."
+export const StringLiteral = createUniqToken({
+  name: "StringLiteral",
+  label: '"..."',
+  pattern: /"([^"\\]|\\.)*"/,
+});
+
+// captures '...'
+export const SingleQuotedStringLiteral = createUniqToken({
+  name: "SingleQuotedStringLiteral",
+  pattern: /'([^'\\]|\\.)*'/,
+  label: "''",
+});
+
+export const FloatLiteral = createUniqToken({
+  name: "FloatLiteral",
+  label: "floating point number",
+  pattern: /-?\d+\.\d+/,
+});
+
+export const IntegerLiteral = createUniqToken({
+  name: "IntegerLiteral",
+  label: "integer",
+  pattern: /-?\d+/,
+  longer_alt: FloatLiteral,
+});
+
+export const DoubleDollar = createUniqToken({
+  name: "DoubleDollar",
+  label: "$$",
+  pattern: /\$\$/,
+});
+
+export const TimestampLiteralToken = createUniqToken({
+  name: "TimestampLiteral",
+  pattern:
+    /\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])\s([01]\d|2[0-3]):([0-5]\d):([0-5]\d)[+-]\d{4}/,
+});
+
+export const LiteralTokens = [
+  TimestampLiteralToken,
+  ExpressionLiteral,
+  StringLiteral,
+  SingleQuotedStringLiteral,
+  FloatLiteral,
+  IntegerLiteral,
+];
+
+/**
+ * Maps a token name to a type
+ * @param {string} token the token name
+ */
+export function mapTokenToType(token) {
+  switch (token) {
+    case ExpressionLiteral.name:
+      return "macro";
+    case StringLiteral.name:
+    case TimestampLiteralToken.name:
+      return "doubleString";
+    case SingleQuotedStringLiteral.name:
+      return "singleString";
+    case IntegerLiteral.name:
+    case FloatLiteral.name:
+      return "number";
+    default:
+      return null;
+  }
+}

package/lexer/math.js

@@ -0,0 +1,97 @@
+import { Identifier } from "./identifier.js";
+import { createTokenByName } from "./utils.js";
+
+// math
+export const MathToken = createTokenByName("math", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// add
+export const AddToken = createTokenByName("add", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// div
+export const DivToken = createTokenByName("div", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// mod
+export const ModToken = createTokenByName("mod", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// mul
+export const MulToken = createTokenByName("mul", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// sub
+export const SubToken = createTokenByName("sub", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// bitwise
+export const BitwiseToken = createTokenByName("bitwise", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// and
+export const AndToken = createTokenByName("and", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// or
+export const OrToken = createTokenByName("or", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// xor
+export const XorToken = createTokenByName("xor", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+export const MathTokens = [
+  MathToken,
+  AddToken,
+  DivToken,
+  ModToken,
+  MulToken,
+  SubToken,
+  BitwiseToken,
+  AndToken,
+  OrToken,
+  XorToken,
+];
+
+/**
+ * Maps a token name to a type
+ * @param {string} token the token name
+ */
+export function mapTokenToType(token) {
+  switch (token) {
+    case MathToken.name:
+    case AddToken.name:
+    case DivToken.name:
+    case ModToken.name:
+    case MulToken.name:
+    case SubToken.name:
+    case BitwiseToken.name:
+    case AndToken.name:
+    case OrToken.name:
+    case XorToken.name:
+      return "function";
+    default:
+      return null;
+  }
+}

package/lexer/mcp_server.js

@@ -0,0 +1,51 @@
+import { Identifier } from "./identifier.js";
+import { ToolToken } from "./tool.js";
+import { createTokenByName } from "./utils.js";
+
+// "active"
+export const ActiveToken = createTokenByName("active", {
+  longer_alt: Identifier,
+  categories: [Identifier], // could also be an identifier
+});
+
+// "instructions"
+export const InstructionsToken = createTokenByName("instructions", {
+  longer_alt: Identifier,
+  categories: [Identifier], // could also be an identifier
+});
+
+// "mcp_server"
+export const McpServerToken = createTokenByName("mcp_server", {
+  longer_alt: Identifier,
+  categories: [Identifier], // could also be an identifier
+});
+
+// "tools"
+export const ToolsToken = createTokenByName("tools", {
+  longer_alt: ToolToken,
+  categories: [Identifier], // could also be an identifier
+});
+
+export const McpServerTokens = [
+  ActiveToken,
+  InstructionsToken,
+  McpServerToken,
+  ToolsToken,
+];
+
+/**
+ * Maps a token name to a type
+ * @param {string} token the token name
+ */
+export function mapTokenToType(token) {
+  switch (token) {
+    case ActiveToken.name:
+    case McpServerToken.name:
+    case ToolsToken.name:
+      return "keyword";
+    case InstructionsToken.name:
+      return "variable";
+    default:
+      return null;
+  }
+}