@xano/developer-mcp 1.0.36 → 1.0.38

package/README.md

@@ -346,7 +346,8 @@ Retrieves XanoScript programming language documentation with context-aware suppo
 | `agents` | AI agent configuration with LLM providers and tools |
 | `tools` | AI tools for agents and MCP servers |
 | `mcp-servers` | MCP server definitions exposing tools |
-| `testing` | Unit tests, mocks, and assertions |
+| `unit-testing` | Unit tests, mocks, and assertions within functions, APIs, and middleware |
+| `workflow-tests` | End-to-end workflow tests with data sources and tags |
 | `integrations` | External service integrations index |
 | `integrations/cloud-storage` | AWS S3, Azure Blob, and GCP Storage |
 | `integrations/search` | Elasticsearch, OpenSearch, and Algolia |
@@ -542,7 +543,8 @@ The server also exposes XanoScript documentation as MCP resources for direct acc
 | `xanoscript://docs/agents` | AI agent configuration |
 | `xanoscript://docs/tools` | AI tools for agents |
 | `xanoscript://docs/mcp-servers` | MCP server definitions |
-| `xanoscript://docs/testing` | Unit tests and mocks |
+| `xanoscript://docs/unit-testing` | Unit tests and mocks |
+| `xanoscript://docs/workflow-tests` | End-to-end workflow tests |
 | `xanoscript://docs/integrations` | External service integrations index |
 | `xanoscript://docs/integrations/cloud-storage` | AWS S3, Azure Blob, GCP Storage |
 | `xanoscript://docs/integrations/search` | Elasticsearch, OpenSearch, Algolia |

package/dist/xanoscript.js

@@ -81,10 +81,15 @@ export const XANOSCRIPT_DOCS_V2 = {
         applyTo: ["mcp_servers/**/*.xs"],
         description: "MCP server definitions exposing tools",
     },
-    testing: {
-        file: "testing.md",
-        applyTo: ["functions/**/*.xs", "apis/**/*.xs"],
-        description: "Unit tests, mocks, and assertions",
+    "unit-testing": {
+        file: "unit-testing.md",
+        applyTo: ["functions/**/*.xs", "apis/**/*.xs", "middleware/**/*.xs"],
+        description: "Unit tests, mocks, and assertions within functions, APIs, and middleware",
+    },
+    "workflow-tests": {
+        file: "workflow-tests.md",
+        applyTo: ["workflow_test/**/*.xs"],
+        description: "End-to-end workflow tests with data source selection and tags",
     },
     integrations: {
         file: "integrations.md",

package/dist/xanoscript.test.js

@@ -23,7 +23,8 @@ describe("xanoscript module", () => {
                 "agents",
                 "tools",
                 "mcp-servers",
-                "testing",
+                "unit-testing",
+                "workflow-tests",
                 "integrations",
                 "integrations/cloud-storage",
                 "integrations/search",
@@ -68,7 +69,7 @@ describe("xanoscript module", () => {
             expect(result).toContain("apis");
             expect(result).toContain("types");
             expect(result).toContain("database");
-            expect(result).toContain("testing");
+            expect(result).toContain("unit-testing");
             expect(result).toContain("addons");
         });
         it("should match functions files", () => {

package/dist/xanoscript_docs/README.md

@@ -19,6 +19,7 @@ XanoScript is the declarative scripting language for [Xano](https://xano.com), a
 | `tool`              | `tool/{name}.xs`                     | Tools for AI agents           |
 | `mcp_server`        | `mcp_server/{name}.xs`               | MCP server definitions        |
 | `mcp_server_trigger`| `mcp_server/trigger/{name}.xs`       | MCP server event handlers     |
+| `workflow_test`     | `workflow_test/{name}.xs`            | End-to-end workflow tests     |
 | `addon`             | `addon/{name}.xs`                    | Subqueries for related data   |
 | `middleware`        | `middleware/{name}.xs`               | Request/response interceptors |
 | `branch`            | `branch.xs`                          | Branch-level configuration    |
@@ -65,6 +66,8 @@ project/
 │   ├── my_server.xs                 # MCP server definitions
 │   └── trigger/
 │       └── on_connect.xs            # MCP server triggers
+├── workflow_test/
+│   └── checkout_flow.xs             # End-to-end workflow tests
 ├── middleware/
 │   └── auth_check.xs                # Request/response interceptors
 ├── addon/
@@ -229,7 +232,8 @@ Use `xanoscript_docs({ topic: "<topic>" })` to retrieve documentation.
 
 | Topic       | Description                                                | Key Sections |
 | ----------- | ---------------------------------------------------------- | ------------ |
-| `testing`   | Unit tests, mocks, and assertions                          | Test Syntax, Assertions |
+| `unit-testing` | Unit tests, mocks, and assertions within functions, APIs, and middleware | Test Syntax, Assertions, Mocking |
+| `workflow-tests` | End-to-end workflow tests with data sources and tags   | Data Sources, Tags, Common Patterns |
 | `debugging` | Logging, inspecting, and debugging XanoScript execution    | debug.log, Inspection |
 | `frontend`  | Static frontend development and deployment                 | File Structure |
 | `run`       | Run job and service configurations for the Xano Job Runner | Jobs, Services |

package/dist/xanoscript_docs/docs_index.json

@@ -128,10 +128,15 @@
       "purpose": "Request interceptors",
       "aliases": ["interceptors", "hooks"]
     },
-    "testing": {
-      "file": "testing.md",
-      "purpose": "Unit testing",
-      "aliases": ["tests", "unit-tests"]
+    "unit-testing": {
+      "file": "unit-testing.md",
+      "purpose": "Unit tests, mocks, and assertions",
+      "aliases": ["tests", "unit-tests", "mocks", "assertions"]
+    },
+    "workflow-tests": {
+      "file": "workflow-tests.md",
+      "purpose": "End-to-end workflow tests",
+      "aliases": ["e2e", "workflow", "integration-tests"]
     },
     "debugging": {
       "file": "debugging.md",
@@ -185,7 +190,7 @@
 
   "constructs": {
     "table": { "file": "tables.md", "triggers": "triggers.md" },
-    "function": { "file": "functions.md", "testing": "testing.md" },
+    "function": { "file": "functions.md", "testing": "unit-testing.md" },
     "query": { "file": "apis.md", "auth": "security.md" },
     "api_group": { "file": "apis.md" },
     "task": { "file": "tasks.md" },

package/dist/xanoscript_docs/tables.md

@@ -166,6 +166,15 @@ The `size` parameter specifies the vector dimensions (must match your embedding
 
 ## Indexes
 
+Each index field supports an optional `op` property to control sort order or operator class:
+
+| Index Type | `op` Values | Default | Description |
+|------------|-------------|---------|-------------|
+| `btree` | `asc`, `desc` | `asc` | Sort direction |
+| `gin` | `jsonb_path_op` | — | Operator class for JSON containment queries |
+| `search` | `A`, `B`, `C`, `D` | — | Weight category (A = highest relevance) |
+| `vector` | `vector_cosine_ops` | — | Distance function for similarity search |
+
 ### Primary Key
 
 ```xs

package/dist/xanoscript_docs/{testing.md → unit-testing.md}

@@ -1,10 +1,10 @@
 ---
-applyTo: "function/**/*.xs, api/**/*.xs"
+applyTo: "function/**/*.xs, api/**/*.xs, middleware/**/*.xs"
 ---
 
-# Testing
+# Unit Testing
 
-Unit tests and mocking in XanoScript.
+Unit tests, mocks, and assertions defined inline within functions, API endpoints, and middleware. Unit tests validate individual construct behavior in isolation — for end-to-end workflow testing across multiple constructs, see `workflow-tests`.
 
 ## Quick Reference
 
@@ -330,3 +330,15 @@ function "calculate_discount" {
 3. **Descriptive test names** - Explain what's being tested
 4. **One assertion focus** - Each test verifies one behavior
 5. **Keep tests independent** - No shared state between tests
+
+---
+
+## Related Topics
+
+| Topic             | Description                                        |
+| ----------------- | -------------------------------------------------- |
+| `workflow-tests`  | End-to-end workflow tests across multiple constructs |
+| `functions`       | Reusable function stacks (where unit tests live)   |
+| `apis`            | API endpoints (where unit tests live)              |
+| `middleware`      | Request/response interceptors (where unit tests live) |
+| `debugging`       | Logging and debugging test execution               |

package/dist/xanoscript_docs/workflow-tests.md

@@ -0,0 +1,333 @@
+---
+applyTo: "workflow_test/**/*.xs"
+---
+
+# Workflow Tests
+
+End-to-end workflow tests that call Xano constructs (APIs, functions, tasks, etc.) and validate results with assertions. The `stack` block supports all standard XanoScript statements (variables, conditionals, loops, database operations, etc.) in addition to the call functions and assertions documented below.
+
+## Quick Reference
+
+```xs
+workflow_test "<name>" {
+  datasource = "live"
+  stack { ... }
+  tags = ["tag1", "tag2"]
+}
+```
+
+| Property     | Required | Default | Description                                      |
+| ------------ | -------- | ------- | ------------------------------------------------ |
+| `datasource` | No       | (empty) | Data source to run against: custom name or `"live"` (not recommended — clones entire datasource) |
+| `stack`      | Yes      | —       | Test execution logic using call functions and assertions |
+| `tags`       | No       | `[]`    | Tags for organizing and filtering workflow tests  |
+
+---
+
+## Call Functions
+
+Call functions invoke Xano constructs and capture their results. Each returns a result that can be stored with `as $variable`.
+
+| Call Function     | Description                    | Required Properties                  |
+| ----------------- | ------------------------------ | ------------------------------------ |
+| `api.call`        | Call an API endpoint           | `api_group`, `verb` (on call), optional `headers` |
+| `addon.call`      | Call an addon                  | —                                    |
+| `function.call`   | Call a function                | optional `input`                     |
+| `middleware.call`  | Call a middleware               | `input` with `vars` and `type`       |
+| `task.call`       | Call a task                    | —                                    |
+| `tool.call`       | Call a tool                    | —                                    |
+| `trigger.call`    | Call a trigger                 | `input` with `new`, `old`, `action`, `datasource` |
+
+### api.call
+
+```xs
+api.call "<endpoint_name>" verb=GET {
+  api_group = "<group_name>"
+  headers = '["Content-Type: application/json"]'
+} as $result
+```
+
+### addon.call
+
+```xs
+addon.call "<addon_name>" as $result
+```
+
+### function.call
+
+```xs
+function.call "<function_name>" {
+  input = { key: "value" }
+} as $result
+```
+
+### middleware.call
+
+```xs
+middleware.call "<middleware_name>" {
+  input = {vars: {}, type: "pre"}
+} as $result
+```
+
+### task.call
+
+```xs
+task.call "<task_name>" as $result
+```
+
+### tool.call
+
+```xs
+tool.call "<tool_name>" as $result
+```
+
+### trigger.call
+
+```xs
+trigger.call "<trigger_name>" {
+  input = {new: {}, old: {}, action: "", datasource: ""}
+} as $result
+```
+
+---
+
+## Assertions
+
+Assertions validate results within the workflow test stack. Each takes a variable reference as the target.
+
+### Quick Reference
+
+| Assertion                  | Purpose                 | Properties          |
+| -------------------------- | ----------------------- | ------------------- |
+| `expect.to_be_defined`     | Value is defined        | —                   |
+| `expect.to_not_be_defined` | Value is not defined    | —                   |
+| `expect.to_be_empty`       | Value is empty          | —                   |
+| `expect.to_be_true`        | Value is true           | —                   |
+| `expect.to_be_false`       | Value is false          | —                   |
+| `expect.to_be_null`        | Value is null           | —                   |
+| `expect.to_not_be_null`    | Value is not null       | —                   |
+| `expect.to_be_in_the_past` | Timestamp is in the past| —                   |
+| `expect.to_be_in_the_future`| Timestamp is in the future| —               |
+| `expect.to_equal`          | Exact match             | `value`             |
+| `expect.to_not_equal`      | Not equal               | `value`             |
+| `expect.to_be_greater_than`| Greater than            | `value`             |
+| `expect.to_be_less_than`   | Less than               | `value`             |
+| `expect.to_be_within`      | Within range            | `min`, `max`        |
+| `expect.to_contain`        | Contains value          | `value`             |
+| `expect.to_start_with`     | Starts with string      | `value`             |
+| `expect.to_end_with`       | Ends with string        | `value`             |
+| `expect.to_match`          | Regex match             | `value` (pattern)   |
+| `expect.to_throw`          | Stack throws error      | `stack`, `exception` |
+
+### No-Property Assertions
+
+These take only the target variable:
+
+```xs
+expect.to_be_defined ($var)
+expect.to_not_be_defined ($var)
+expect.to_be_empty ($var)
+expect.to_be_true ($var)
+expect.to_be_false ($var)
+expect.to_be_null ($var)
+expect.to_not_be_null ($var)
+expect.to_be_in_the_past ($var)
+expect.to_be_in_the_future ($var)
+```
+
+### Value Assertions
+
+These take a `value` property for comparison. The value can be a literal or a variable reference:
+
+```xs
+expect.to_equal ($var) { value = "expected" }
+expect.to_not_equal ($var) { value = $other_var }
+expect.to_be_greater_than ($var) { value = 3 }
+expect.to_be_less_than ($var) { value = $other_var }
+expect.to_contain ($var) { value = "substring" }
+expect.to_start_with ($var) { value = "prefix" }
+expect.to_end_with ($var) { value = "suffix" }
+
+// Regex pattern
+expect.to_match ($var) { value = "^\\d+$" }
+```
+
+### Range Assertion
+
+```xs
+expect.to_be_within ($var) {
+  min = 1
+  max = 100
+}
+```
+
+### Error Assertion
+
+`expect.to_throw` wraps a `stack` block and checks that it throws a matching exception:
+
+```xs
+expect.to_throw {
+  stack {
+    security.create_uuid as $x1
+  }
+
+  exception = "error"
+}
+```
+
+---
+
+## Data Sources
+
+The `datasource` property controls which data source the test runs against.
+
+**Avoid using `datasource = "live"`.** When a workflow test runs, the entire datasource is cloned so that real data is not modified. This cloning step can be slow, especially for large datasources. Prefer running without a datasource or using a smaller custom datasource instead.
+
+### Default (No Data Source) — Recommended
+
+```xs
+workflow_test "basic_check" {
+  stack {
+    function.call "health_check" as $result
+    expect.to_be_defined ($result)
+  }
+}
+```
+
+### Custom Data Source
+
+```xs
+workflow_test "staging_data_check" {
+  datasource = "staging"
+  stack {
+    function.call "get_products" as $products
+    expect.to_be_defined ($products)
+  }
+}
+```
+
+### Live Data Source (Not Recommended)
+
+Using `datasource = "live"` clones the entire live datasource before running the test. Only use this when you specifically need to validate against production data.
+
+```xs
+workflow_test "live_data_check" {
+  datasource = "live"
+  stack {
+    function.call "get_active_users" as $users
+    expect.to_be_defined ($users)
+  }
+}
+```
+
+---
+
+## Tags
+
+Use tags to organize and filter workflow tests:
+
+```xs
+workflow_test "checkout_flow" {
+  tags = ["checkout", "critical", "e2e"]
+  stack {
+    function.call "create_cart" as $cart
+    expect.to_be_defined ($cart)
+  }
+}
+```
+
+---
+
+## Complete Example
+
+This example demonstrates all call functions and all assertion types:
+
+```xs
+workflow_test "comprehensive_test" {
+  datasource = "live"
+
+  stack {
+    // Call functions
+    api.call "test" verb=GET {
+      api_group = "test"
+      headers = '["Content-Type: application/json"]'
+    } as $endpoint1
+
+    addon.call "my_addon" as $addon1
+    function.call "my_function" {
+      input = {name: "Justin"}
+    } as $function1
+
+    middleware.call "my_middleware" {
+      input = {vars: {}, type: "pre"}
+    } as $middleware1
+
+    task.call "my_task" as $task1
+    tool.call "my_tool" as $tool1
+    trigger.call "my_trigger" {
+      input = {new: {}, old: {}, action: "", datasource: ""}
+    } as $trigger1
+
+    // No-property assertions
+    expect.to_be_defined ($endpoint1)
+    expect.to_be_empty ($addon1)
+    expect.to_be_false ($endpoint1)
+    expect.to_be_true ($addon1)
+    expect.to_be_null ($middleware1)
+    expect.to_not_be_null ($endpoint1)
+    expect.to_not_be_defined ($function1)
+    expect.to_be_in_the_past ($endpoint1)
+    expect.to_be_in_the_future ($endpoint1)
+
+    // Value assertions
+    expect.to_equal ($endpoint1) { value = $endpoint1 }
+    expect.to_not_equal ($endpoint1) { value = $addon1 }
+    expect.to_be_greater_than ($endpoint1) { value = 3 }
+    expect.to_be_less_than ($addon1) { value = $task1 }
+    expect.to_contain ($endpoint1) { value = "asdf" }
+    expect.to_start_with ($addon1) { value = "f" }
+    expect.to_end_with ($addon1) { value = "asdf" }
+
+    // Regex pattern
+    expect.to_match ($endpoint1) { value = ".*" }
+
+    // Range assertion
+    expect.to_be_within ($endpoint1) {
+      min = 1
+      max = 4
+    }
+
+    // Error assertion
+    expect.to_throw {
+      stack {
+        security.create_uuid as $x1
+      }
+
+      exception = "error"
+    }
+  }
+
+  tags = ["a", "b"]
+}
+```
+
+---
+
+## Best Practices
+
+1. **Use descriptive names** — Name tests after the workflow being tested: `user_signup_flow`, `checkout_process`
+2. **Tag for filtering** — Use tags like `critical`, `e2e`, `smoke` to organize test suites
+3. **Avoid `datasource = "live"`** — The entire datasource is cloned before each test run, which can be slow. Use no datasource or a smaller custom datasource instead
+4. **Keep tests independent** — Each workflow test should be self-contained and not depend on other tests
+5. **Use assertions over preconditions** — Prefer `expect.*` assertions for clearer test intent
+
+---
+
+## Related Topics
+
+| Topic          | Description                                |
+| -------------- | ------------------------------------------ |
+| `unit-testing` | Unit tests and assertions within functions |
+| `functions`    | Reusable function stacks called in tests   |
+| `database`     | Database operations used in test stacks    |
+| `debugging`    | Logging and debugging test execution       |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xano/developer-mcp",
-  "version": "1.0.36",
+  "version": "1.0.38",
   "description": "MCP server and library for Xano development - XanoScript validation, Meta API, Run API, and CLI documentation",
   "type": "module",
   "main": "dist/lib.js",