@xano/xanoscript-language-server 11.7.2 → 11.8.0

package/lexer/tokens.js

@@ -284,6 +284,12 @@ export const SensitiveToken = createTokenByName("sensitive", {
   categories: [Identifier], // could also be an identifier
 });
 
+// define the sensitivity of a column
+export const TriggerToken = createTokenByName("trigger", {
+  longer_alt: Identifier,
+  categories: [Identifier], // could also be an identifier
+});
+
 export const DescriptionToken = createTokenByName("description", {
   longer_alt: Identifier,
   categories: [Identifier], // could also be an identifier
@@ -350,6 +356,7 @@ export const allTokens = uniq([
   AuthToken,
   GuidToken,
   SensitiveToken,
+  TriggerToken,
   TagsToken,
   DescriptionToken,
   DocsToken,

package/package.json

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

package/parser/api_group_parser.js

@@ -21,6 +21,7 @@ export function apiGroupDeclaration($) {
     let hasHistory = false;
     let hasSwagger = false;
     let hasTags = false;
+    let hasMiddleware = false;
 
     $.sectionStack.push("apiGroupDeclaration");
     // Allow leading comments and newlines before the api_group declaration
@@ -44,6 +45,13 @@ export function apiGroupDeclaration($) {
             $.SUBRULE($.booleanValue);
           },
         },
+        {
+          GATE: () => !hasMiddleware,
+          ALT: () => {
+            hasMiddleware = true;
+            $.SUBRULE($.middlewareClause);
+          },
+        },
         {
           GATE: () => !hasCanonical,
           ALT: () => {

package/parser/api_group_parser.spec.js

@@ -39,6 +39,16 @@ describe("api_group", () => {
     expect(parser.errors).to.be.empty;
   });
 
+  it("should accept a middleware", () => {
+    const parser = xanoscriptParser(`api_group "some name" {
+      description = "Some description"
+      active = false
+      canonical = "HZ4jLtdc"
+      middleware = {pre: [{name: "M1"}], post: [{name: "M1"}]}
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
   it("should parse a disable swagger api_group", () => {
     const parser = xanoscriptParser(`api_group Authentication {
   active = false

package/parser/clauses/nakedStackFn.js

@@ -55,6 +55,10 @@ export function nakedStackFn($) {
           GATE: () => options.allowCallStatements,
           ALT: () => $.SUBRULE($.middlewareCallFn),
         },
+        {
+          GATE: () => options.allowCallStatements,
+          ALT: () => $.SUBRULE($.triggerCallFn),
+        },
         { ALT: () => $.SUBRULE($.workflowExpectFn) },
       ]);
     });

package/parser/clauses/viewClause.js

@@ -36,10 +36,12 @@ export function viewClause($) {
 
     // each key is the view name, ensure either search or hide is present
     for (const viewName in captured) {
-      if (!captured[viewName].search && !captured[viewName].hide) {
+      const hasSearch = !!captured[viewName].search;
+      const hasSort = !!captured[viewName].sort;
+      if (!hasSearch && !hasSort && !captured[viewName].hide) {
         $.addMissingError(
           parent,
-          `view ${viewName} must have either a search or hide criteria`
+          `view ${viewName} must have either a search, sort or hide criteria`,
         );
       }
     }

package/parser/clauses/viewClause.spec.js

@@ -109,13 +109,22 @@ describe("viewClause", () => {
     expect(parser.errors).to.be.empty;
   });
 
-  it("viewClause requires either a search or hide criteria", () => {
+  it("viewClause accept either a sort criteria", () => {
     const parser = parse(`view = {
       "no search criteria": {
         sort  : {id: "asc"}
         id    : "9ed7daad-682f-455e-bf02-ca53444cd429"
       }
     }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("viewClause requires either a search, sort or hide criteria", () => {
+    const parser = parse(`view = {
+      "no criteria": {
+        id    : "9ed7daad-682f-455e-bf02-ca53444cd429"
+      }
+    }`);
     expect(parser.errors).to.not.be.empty;
   });
 

package/parser/functions/register.js

@@ -32,6 +32,7 @@ import { streamFn } from "./streamFn.js";
 import { register as register_text } from "./text/register.js";
 import { textFn } from "./textFn.js";
 import { toolCallFn } from "./toolCallFn.js";
+import { triggerCallFn } from "./triggerCallFn.js";
 import { unitExpectFn } from "./unitExpectFn.js";
 import { register as register_util } from "./util/register.js";
 import { utilFn } from "./utilFn.js";
@@ -70,6 +71,7 @@ export const register = ($) => {
   $.unitExpectFn = $.RULE("unitExpectFn", unitExpectFn($));
   $.workflowExpectFn = $.RULE("workflowExpectFn", workflowExpectFn($));
   $.toolCallFn = $.RULE("toolCallFn", toolCallFn($));
+  $.triggerCallFn = $.RULE("triggerCallFn", triggerCallFn($));
   register_ai($);
   register_schema($);
   register_api($);

package/parser/functions/triggerCallFn.js

@@ -0,0 +1,48 @@
+import { CallToken } from "../../lexer/function.js";
+import { StringLiteral } from "../../lexer/literal.js";
+import { Identifier } from "../../lexer/tokens.js";
+import { DotToken, TriggerToken } from "../../lexer/tokens.js";
+
+/**
+ * @param {import('../../base_parser.js').XanoBaseParser} $
+ */
+export function triggerCallFn($) {
+  return () => {
+    $.sectionStack.push("triggerCallFn");
+
+    $.CONSUME(TriggerToken); // "trigger"
+    $.CONSUME(DotToken); // "."
+    const fnToken = $.CONSUME(CallToken); // "call"
+
+    // Validate that trigger.call is only used in allowed contexts
+    const validContexts = ["workflowTestDeclaration"];
+    const isInValidContext = validContexts.some((context) =>
+      $.sectionStack.includes(context),
+    );
+
+    if (!isInValidContext) {
+      $.addInvalidValueError(
+        fnToken,
+        "trigger.call can only be used within workflow_test contexts",
+      );
+    }
+
+    $.OR([
+      { ALT: () => $.CONSUME(StringLiteral) }, // "foo/bar"
+      { ALT: () => $.CONSUME(Identifier) }, // foo
+    ]);
+
+    $.SUBRULE($.schemaParseAttributeFn, {
+      ARGS: [
+        fnToken,
+        {
+          "description?": "[string]",
+          "disabled?": "[boolean]",
+          "input?": { "[string]": "[expression]" },
+        },
+      ],
+    });
+    $.SUBRULE($.asVariable, { ARGS: [fnToken] });
+    $.sectionStack.pop();
+  };
+}

package/parser/functions/triggerCallFn.spec.js

@@ -0,0 +1,51 @@
+import { expect } from "chai";
+import { describe, it } from "mocha";
+import { lexDocument } from "../../lexer/lexer.js";
+import { parser } from "../test_parser.js";
+
+function parse(inputText, context = null) {
+  parser.reset();
+  const lexResult = lexDocument(inputText);
+  parser.input = lexResult.tokens;
+
+  if (context) {
+    parser.sectionStack.push(context);
+    parser.triggerCallFn();
+    parser.sectionStack.pop();
+  } else {
+    parser.triggerCallFn();
+  }
+
+  return parser;
+}
+
+describe("triggerCallFn", () => {
+  it("should parse trigger.call statement", () => {
+    const parser = parse(
+      `trigger.call my_agent {
+      input = {
+        "key": "value"
+      }
+    } as $result`,
+      "workflowTestDeclaration",
+    );
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("trigger.call can be one liner without a body", () => {
+    const parser = parse(
+      `trigger.call my_agent as $result`,
+      "workflowTestDeclaration",
+    );
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should not allow trigger.call statement outside of workflowTestDeclaration", () => {
+    const parser = parse(`trigger.call my_agent {
+      input = {
+        "key": "value"
+      }
+    } as $result`);
+    expect(parser.errors).to.not.be.empty;
+  });
+});

package/parser/query_parser.spec.js

@@ -114,6 +114,22 @@ describe("query_parser", () => {
     expect(parser.errors).to.be.empty;
   });
 
+  it("should accept a middleware clause", () => {
+    const parser = xanoscriptParser(`query foo verb=GET {
+      input {
+        text user_id filters=trim
+      }
+
+      stack {
+      }
+
+      response = null
+
+      middleware = {pre: [{name: "M1"}], post: [{name: "M1"}]}
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
   it("should accept a test", () => {
     const parser = xanoscriptParser(`query test_expect verb=GET {
   input {

package/parser/table_parser.spec.js

@@ -34,6 +34,26 @@ describe("table_parser", () => {
     expect(parser.errors).to.be.empty;
   });
 
+  it("should parse a basic table with an ordering view", () => {
+    const parser = xanoscriptParser(`table foo {
+        auth = false
+
+        schema {
+          // Primary key
+          int id
+        }
+
+        view = {
+          asc: {
+            alias: "testAlias"
+            sort : {Country: "asc"}
+            id   : "b4530953-23df-401a-a2c9-9432b31cd808"
+          }
+        }
+      }`);
+    expect(parser.errors).to.be.empty;
+  });
+
   // autocomplete = [{ name: "id" }, { name: "cd" }];
   it("should parse a table with an autocomplete field", () => {
     const parser = xanoscriptParser(`table foo {