@xano/xanoscript-language-server 11.0.3

package/lexer/security.js

@@ -0,0 +1,161 @@
+import { Identifier } from "./identifier.js";
+import { createTokenByName } from "./utils.js";
+
+// security
+export const SecurityToken = createTokenByName("security", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// check_password
+export const CheckPasswordToken = createTokenByName("check_password", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// create_password
+export const CreatePasswordToken = createTokenByName("create_password", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// create_uuid
+export const CreateUuidToken = createTokenByName("create_uuid", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// create_auth
+export const CreateAuthTokenToken = createTokenByName("create_auth_token", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// create_curve_key
+export const CreateCurveKeyToken = createTokenByName("create_curve_key", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// create_rsa_key
+export const CreateRsaKeyToken = createTokenByName("create_rsa_key", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// create_secret_key
+export const CreateSecretKeyToken = createTokenByName("create_secret_key", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// decrypt
+export const DecryptToken = createTokenByName("decrypt", {
+  llt: Identifier,
+  categories: [Identifier],
+});
+
+// encrypt
+export const EncryptToken = createTokenByName("encrypt", {
+  llt: Identifier,
+  categories: [Identifier],
+});
+
+// generate_pass
+export const GeneratePassToken = createTokenByName("generate_pass", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// generate_uuid
+export const GenerateUuidToken = createTokenByName("generate_uuid", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// jwe_decode
+export const JweDecodeToken = createTokenByName("jwe_decode", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// jwe_encode
+export const JweEncodeToken = createTokenByName("jwe_encode", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// jws_decode
+export const JwsDecodeToken = createTokenByName("jws_decode", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// jws_encode
+export const JwsEncodeToken = createTokenByName("jws_encode", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// random_bytes
+export const RandomBytesToken = createTokenByName("random_bytes", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// random_number
+export const RandomNumberToken = createTokenByName("random_number", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+export const SecurityTokens = [
+  CheckPasswordToken,
+  CreatePasswordToken,
+  CreateUuidToken,
+  CreateAuthTokenToken,
+  CreateCurveKeyToken,
+  CreateRsaKeyToken,
+  CreateSecretKeyToken,
+  DecryptToken,
+  EncryptToken,
+  GeneratePassToken,
+  GenerateUuidToken,
+  JweDecodeToken,
+  JweEncodeToken,
+  JwsDecodeToken,
+  JwsEncodeToken,
+  RandomBytesToken,
+  RandomNumberToken,
+  SecurityToken,
+];
+
+/**
+ * Maps a token name to a type
+ * @param {string} token the token name
+ */
+export function mapTokenToType(token) {
+  switch (token) {
+    case SecurityToken.name:
+    case CheckPasswordToken.name:
+    case CreatePasswordToken.name:
+    case CreateUuidToken.name:
+    case CreateAuthTokenToken.name:
+    case CreateCurveKeyToken.name:
+    case CreateRsaKeyToken.name:
+    case CreateSecretKeyToken.name:
+    case DecryptToken.name:
+    case EncryptToken.name:
+    case GeneratePassToken.name:
+    case GenerateUuidToken.name:
+    case JweDecodeToken.name:
+    case JweEncodeToken.name:
+    case JwsDecodeToken.name:
+    case JwsEncodeToken.name:
+    case RandomBytesToken.name:
+    case RandomNumberToken.name:
+      return "function";
+    default:
+      return null;
+  }
+}

package/lexer/storage.js

@@ -0,0 +1,99 @@
+import { Identifier } from "./identifier.js";
+import { createTokenByName } from "./utils.js";
+
+export const StorageToken = createTokenByName("storage", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// create_image
+export const CreateImageToken = createTokenByName("create_image", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// create_attachment
+export const CreateAttachmentToken = createTokenByName("create_attachment", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// read_file_resource
+export const ReadFileResourceToken = createTokenByName("read_file_resource", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// create_file_resource
+export const CreateFileResourceToken = createTokenByName(
+  "create_file_resource",
+  {
+    longer_alt: Identifier,
+    categories: [Identifier],
+  }
+);
+
+// read_file_resource
+export const ReadFileToken = createTokenByName("read_file", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// create_audio
+export const CreateAudioToken = createTokenByName("create_audio", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// create_video
+export const CreateVideoToken = createTokenByName("create_video", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// delete_file
+export const DeleteFileToken = createTokenByName("delete_file", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// sign_private_url
+export const SignPrivateUrlToken = createTokenByName("sign_private_url", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+export const StorageTokens = [
+  StorageToken,
+  CreateImageToken,
+  CreateAttachmentToken,
+  ReadFileResourceToken,
+  CreateFileResourceToken,
+  ReadFileToken,
+  CreateAudioToken,
+  CreateVideoToken,
+  DeleteFileToken,
+  SignPrivateUrlToken,
+];
+
+/**
+ * Maps a token name to a type
+ * @param {string} token the token name
+ */
+export function mapTokenToType(token) {
+  switch (token) {
+    case StorageToken.name:
+    case CreateImageToken.name:
+    case CreateAttachmentToken.name:
+    case ReadFileResourceToken.name:
+    case CreateFileResourceToken.name:
+    case ReadFileToken.name:
+    case DeleteFileToken.name:
+    case SignPrivateUrlToken.name:
+    case CreateAudioToken.name:
+    case CreateVideoToken.name:
+      return "function";
+    default:
+      return null;
+  }
+}

package/lexer/stream.js

@@ -0,0 +1,49 @@
+import { Identifier } from "./identifier.js";
+import { createTokenByName } from "./utils.js";
+
+// stream
+export const StreamToken = createTokenByName("stream", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// stream.from_csv
+export const FromCsvToken = createTokenByName("from_csv", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// stream.from_jsonl
+export const FromJsonlToken = createTokenByName("from_jsonl", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// stream.from_request
+export const FromRequestToken = createTokenByName("from_request", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+export const StreamTokens = [
+  StreamToken,
+  FromCsvToken,
+  FromJsonlToken,
+  FromRequestToken,
+];
+
+/**
+ * Maps a token name to a type
+ * @param {string} token the token name
+ */
+export function mapTokenToType(token) {
+  switch (token) {
+    case StreamToken.name:
+    case FromCsvToken.name:
+    case FromJsonlToken.name:
+    case FromRequestToken.name:
+      return "function";
+    default:
+      return null;
+  }
+}

package/lexer/table.js

@@ -0,0 +1,38 @@
+import { Identifier } from "./identifier.js";
+import { createTokenByName } from "./utils.js";
+
+// "table"
+export const TableToken = createTokenByName("table", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// "autocomplete"
+export const AutoCompleteToken = createTokenByName("autocomplete", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+// "items"
+export const ItemsToken = createTokenByName("items", {
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
+export const TableTokens = [TableToken, AutoCompleteToken, ItemsToken];
+
+/**
+ * Maps a token name to a type
+ * @param {string} token the token name
+ */
+export function mapTokenToType(token) {
+  switch (token) {
+    case TableToken.name:
+      return "keyword";
+    case AutoCompleteToken.name:
+    case ItemsToken.name:
+      return "identifier";
+    default:
+      return null;
+  }
+}

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

package/lexer/task.js

@@ -0,0 +1,83 @@
+import { Identifier } from "./identifier.js";
+import { createTokenByName } from "./utils.js";
+
+// "call"
+export const CallToken = createTokenByName("call", {
+  longer_alt: Identifier,
+  categories: [Identifier], // could also be an identifier
+});
+
+// "datasource"
+export const DataSourceToken = createTokenByName("datasource", {
+  longer_alt: Identifier,
+  categories: [Identifier], // could also be an identifier
+});
+
+// "ends_on"
+export const EndsOnToken = createTokenByName("ends_on", {
+  longer_alt: Identifier,
+  categories: [Identifier], // could also be an identifier
+});
+
+// "events"
+export const EventsToken = createTokenByName("events", {
+  longer_alt: Identifier,
+  categories: [Identifier], // could also be an identifier
+});
+
+// "freq"
+export const FreqToken = createTokenByName("freq", {
+  longer_alt: Identifier,
+  categories: [Identifier], // could also be an identifier
+});
+
+// "schedule"
+export const ScheduleToken = createTokenByName("schedule", {
+  longer_alt: Identifier,
+  categories: [Identifier], // could also be an identifier
+});
+
+// "starts_on"
+export const StartsOnToken = createTokenByName("starts_on", {
+  longer_alt: Identifier,
+  categories: [Identifier], // could also be an identifier
+});
+
+// "task"
+export const TaskToken = createTokenByName("task", {
+  longer_alt: Identifier,
+  categories: [Identifier], // could also be an identifier
+});
+
+export const TaskTokens = [
+  CallToken,
+  DataSourceToken,
+  EndsOnToken,
+  EventsToken,
+  FreqToken,
+  ScheduleToken,
+  StartsOnToken,
+  TaskToken,
+];
+
+/**
+ * Maps a token name to a type
+ * @param {string} token the token name
+ */
+export function mapTokenToType(token) {
+  switch (token) {
+    case DataSourceToken.name:
+    case ScheduleToken.name:
+    case TaskToken.name:
+      return "keyword";
+    case EndsOnToken.name:
+    case EventsToken.name:
+    case FreqToken.name:
+    case StartsOnToken.name:
+      return "variable";
+    case CallToken.name:
+      return "function";
+    default:
+      return null;
+  }
+}

package/lexer/tests/query/query_lexer.spec.js

@@ -0,0 +1,36 @@
+import { expect } from "chai";
+import { readdirSync, readFileSync } from "fs";
+import findLast from "lodash-es/findLast.js";
+import { describe, it } from "mocha";
+import { lexDocument } from "../../lexer.js";
+
+describe("Xanoscript Query Lexer", () => {
+  it("Can Lex valid query sources", () => {
+    const files = readdirSync("lexer/tests/query/valid_sources");
+    files.forEach((file) => {
+      const source = readFileSync(
+        `lexer/tests/query/valid_sources/${file}`,
+        "utf8"
+      );
+      const lexingResult = lexDocument(source);
+      const { errors, tokens } = lexingResult;
+      if (errors.length > 0) {
+        let richErrors = errors.map((error) => {
+          const previousToken = findLast(
+            tokens,
+            (token) => token.endOffset <= error.offset
+          );
+          return {
+            name: error.message,
+            file: `lexer/tests/query/valid_sources/${file}:${error.line}:${error.column}`,
+            "prev. Token": previousToken ? previousToken.image : "N/A",
+          };
+        });
+
+        console.table(richErrors);
+      }
+
+      expect(errors).to.be.empty;
+    });
+  });
+});

package/lexer/tests/query/valid_sources/basic_query.xs

@@ -0,0 +1,44 @@
+query xanoscript_all_basics verb=GET {
+  input {
+    text some_text_value filters=trim {
+      description = "and a description"
+      sensitive = true
+    }
+  }
+
+  stack {
+    var some_var {
+      value = $env.$remote_ip
+    }
+  
+    conditional {
+      if (`($some_var)|strlen > 4`) {
+        db.add 48 {
+          data = {id: "null", created_at: '"now"', "@meta": "null"}
+        } as empty1
+      }
+    
+      else {
+        api.request {
+          url = "https://api.example.com/webhook"
+          method = "GET"
+          params = `{"value": "yup it's long"}`
+        } as api1
+      }
+    }
+  
+    foreach (`["1","2","3","4","5","6"]`) {
+      each as item {
+        var.update some_var {
+          value = $some_var|concat:$item:" + "
+        }
+      
+        debug.log {
+          value = $some_var
+        }
+      }
+    }
+  }
+
+  response = $some_var
+}

package/lexer/tests/query/valid_sources/db_query.xs

@@ -0,0 +1,77 @@
+query db_query verb=GET {
+  input
+  stack {
+    db.query book {
+      where = `"book.id" == 123`
+      eval = [
+        {
+          name  : "book.name"
+          as    : "book_name"
+          filter: [
+            {name: "upper", disabled: true}
+            {name: "add", arg: [{value: 123}]}
+          ]
+        }
+      ]
+
+      return_aggregate = {
+        paging : {page: 1, per_page: 25, metadata: true}
+        sorting: [{sort: "book_name", order: "asc"}]
+        group  : [
+          {
+            name  : "book.name"
+            as    : "book_name"
+            filter: [{name: "lower"}]
+          }
+        ]
+        eval   : [
+          {name: "book.name", as: "book_name", filter: [{name: "sum"}]}
+        ]
+      }
+
+      external_classic = {
+        value      : "test"
+        permissions: {search: true, sort: true, page: true, per_page: false}
+      }
+
+      external = {
+        search  : "test"
+        sort    : "test"
+        page    : "test"
+        per_page: "test"
+        offset  : "test"
+      }
+
+      output = [
+        "itemsReceived"
+        "curPage"
+        "nextPage"
+        "prevPage"
+        "offset"
+        "perPage"
+        "items.book_name"
+      ]
+
+      addon = [
+        {
+          name  : "book"
+          as    : "_book"
+          offset: "items[]"
+          input : {book_id: "book_name"}
+          addon : [
+            {
+              name  : "book"
+              as    : "_book2222"
+              offset: "obj"
+              output: ["name", "name2"]
+              input : {book_id: $env.API_KEY}
+            }
+          ]
+        }
+      ]
+
+    } as book1
+  }
+  
+  response = null
+}

package/lexer/tests/query/valid_sources/empty_query.xs

@@ -0,0 +1,5 @@
+query empty_query verb=GET {
+  input
+  stack
+  response = null
+}

package/lexer/tests/query/valid_sources/header_query.xs

@@ -0,0 +1,15 @@
+query get_auth verb=GET {
+  input
+  stack {
+    var authToken {
+      value = "foo-bar"
+    }
+  
+    util.set_header {
+      value = "Set-Cookie: sessionId=your-session-id; HttpOnly; Secure; SameSite=None; Max-Age=3600"|string_replace:"your-session-id":$authToken
+      duplicates = "replace"
+    }
+  }
+
+  response = $authToken
+}

package/lexer/tests/table/basic_table.xs

@@ -0,0 +1,17 @@
+table empty {
+  auth = true
+  security = {
+    guid: "-iOFONN4cySSKJ0MTrPNojIWB5c"
+  }
+
+  schema {
+    int id
+    timestamp created_at?=now
+  }
+
+  index = [
+    {type: "primary", field: [{name: "id"}]} 
+    {type: "gin", field: [{name: "xdo", op: "jsonb_path_op"}]}
+    {type: "btree", field: [{name: "created_at", op: "desc"}]}
+  ]
+}

package/lexer/tests/table/empty_table.xs

@@ -0,0 +1,3 @@
+table empty {
+  auth = false
+}