@xano/developer-mcp 1.0.58 → 1.0.59

package/dist/xanoscript_docs/performance.md

@@ -137,143 +137,20 @@ db.bulk.add "order_item" {
 
 ## Caching Strategies
 
-### Redis Caching
-
-```xs
-// Check cache first
-redis.get { key = "user:" ~ $input.user_id } as $cached
-
-conditional {
-  if ($cached != null) {
-    var $user { value = $cached }
-  }
-  else {
-    db.get "user" {
-      field_name = "id"
-      field_value = $input.user_id
-    } as $user
-
-    // Cache for 5 minutes
-    redis.set {
-      key = "user:" ~ $input.user_id
-      data = $user
-      ttl = 300
-    }
-  }
-}
-```
-
-### Cache Invalidation
-
-```xs
-function "update_user" {
-  input { int user_id, object data }
-  stack {
-    db.patch "user" {
-      field_name = "id"
-      field_value = $input.user_id
-      data = $input.data
-    } as $user
-
-    // Invalidate cache
-    redis.del { key = "user:" ~ $input.user_id }
-  }
-  response = $user
-}
-```
-
-### Computed Value Caching
-
-```xs
-// Cache expensive computations
-redis.get { key = "stats:daily:" ~ now|format_timestamp:"Y-m-d" } as $cached_stats
-
-conditional {
-  if ($cached_stats == null) {
-    // Expensive aggregation
-    db.query "order" {
-      where = $db.order.created_at >= now|transform_timestamp:"start of day"
-    } as $orders
-
-    var $stats {
-      value = {
-        count: $orders|count,
-        total: $orders|map:$$.total|sum,
-        avg: $orders|map:$$.total|avg
-      }
-    }
-
-    redis.set {
-      key = "stats:daily:" ~ now|format_timestamp:"Y-m-d"
-      data = $stats
-      ttl = 300
-    }
-
-    var $cached_stats { value = $stats }
-  }
-}
-```
-
----
-
-## Organizing with Group
-
-The `group` statement is an organizational block for visually grouping related statements. It does **not** create parallel execution or a new scope — variables declared inside a group are accessible outside it.
-
-```xs
-// Use group to organize related variable initialization
-group {
-  stack {
-    var $total {
-      value = 0
-    }
-
-    var $count {
-      value = 0
-    }
-  }
-}
-
-// $total and $count are accessible here
-```
+> See `xanoscript_docs({ topic: "integrations/redis" })` for full Redis caching patterns (get/set, invalidation, computed value caching).
 
 ---
 
 ## Efficient Data Transformations
 
-### Use Filter Chains Wisely
-
 ```xs
 // Good: Single pass with chained filters
 $data|filter:$$.active|map:$$.name|unique
 
-// Avoid: Multiple passes over data
-var $active { value = $data|filter:$$.active }
-var $names { value = $active|map:$$.name }
-var $unique { value = $names|unique }
-```
-
-### Early Filtering
-
-```xs
 // Filter in database, not in code
 db.query "product" {
   where = $db.product.is_active == true && $db.product.price > 0
 } as $products
-
-// Not: Fetch all then filter
-db.query "product" as $all_products
-var $products { value = $all_products|filter:$$.is_active && $$.price > 0 }
-```
-
-### Limit Data Transfer
-
-```xs
-// Only fetch needed fields from external API
-api.request {
-  url = "https://api.example.com/users"
-  params = { fields: "id,name,email" }
-} as $result
 ```
 
 ---
@@ -308,92 +185,25 @@ redis.ratelimit {
 
 ## Response Optimization
 
-### Stream Large Responses
-
-```xs
-// Stream instead of loading into memory
-db.query "log" {
-  where = $db.log.created_at >= $input.start
-  return = { type: "stream" }
-} as $logs
-
-api.stream {
-  format = "jsonl"
-  value = $logs
-}
-```
-
-### Compress Responses
-
-Large JSON responses are automatically compressed when clients support it.
+For large responses, use `return = { type: "stream" }` with `api.stream` to avoid loading into memory. Large JSON responses are automatically compressed when clients support it.
 
-### Paginate API Responses
-
-```xs
-query "list_products" {
-  input {
-    int page?=1
-    int per_page?=25 filters=max:100
-  }
-  stack {
-    db.query "product" {
-      return = {
-        type: "list",
-        paging: {
-          page: $input.page,
-          per_page: $input.per_page,
-          totals: true
-        }
-      }
-    } as $products
-  }
-  response = $products
-}
-```
+> See `xanoscript_docs({ topic: "streaming" })` for streaming patterns.
 
 ---
 
 ## Query Analysis
 
-### Log Slow Queries
-
-```xs
-var $start { value = now|to_ms }
-
-db.query "product" {
-  where = $db.product.category == $input.category
-} as $products
-
-var $duration { value = (now|to_ms) - $start }
+Use `now|to_ms` before and after operations to measure duration, and `debug.log` to log slow queries.
 
-conditional {
-  if ($duration > 100) {
-    debug.log {
-      label = "SLOW_QUERY"
-      value = {
-        query: "product by category",
-        duration_ms: $duration,
-        result_count: $products|count
-      }
-    }
-  }
-}
-```
+> See `xanoscript_docs({ topic: "debugging" })` for timing and logging patterns.
 
 ---
 
 ## Best Practices Summary
 
-1. **Index frequently queried columns** - Check query patterns
-2. **Use appropriate return types** - count, exists, single
-3. **Paginate large results** - Never return unbounded lists
-4. **Avoid N+1 queries** - Use joins or batch fetching
-5. **Use bulk operations** - For batch inserts/updates
-6. **Cache expensive operations** - Redis with appropriate TTL
-7. **Use group for organization** - Group related statements for readability
-8. **Filter early** - In database, not application code
-9. **Stream large responses** - Don't load into memory
-10. **Monitor performance** - Log slow operations
+1. **Index frequently queried columns** - Use `select` for only needed fields; use `count`/`exists` return types
+2. **Avoid N+1 queries** - Use joins or bulk operations (`db.bulk.add`, `db.bulk.edit`)
+3. **Paginate large results** - Never return unbounded lists; cache expensive computations with Redis
 
 ---
 

package/dist/xanoscript_docs/realtime.md

@@ -265,135 +265,18 @@ Handle events from connected clients using `realtime_trigger`. For complete trig
 
 ---
 
-## Common Patterns
-
-### Chat Application
+## Common Pattern: Broadcast After Database Write
 
 ```xs
-function "send_chat_message" {
-  input {
-    int room_id
-    text content filters=trim|max:1000
-  }
-  stack {
-    // Save message
-    db.add "message" {
-      data = {
-        room_id: $input.room_id,
-        sender_id: $auth.id,
-        content: $input.content,
-        created_at: now
-      }
-    } as $message
-
-    // Broadcast to room
-    api.realtime_event {
-      channel = "room:" ~ $input.room_id
-      event = "new_message"
-      data = {
-        id: $message.id,
-        sender_id: $auth.id,
-        content: $input.content,
-        created_at: $message.created_at
-      }
-    }
-  }
-  response = $message
-}
-```
-
-### Live Dashboard Updates
-
-```xs
-function "update_metrics" {
-  stack {
-    // Calculate metrics
-    db.query "order" {
-      where = $db.order.created_at >= now|transform_timestamp:"-1 hour"
-    } as $recent_orders
-
-    var $metrics {
-      value = {
-        orders_last_hour: $recent_orders|count,
-        revenue_last_hour: $recent_orders|map:$$.total|sum,
-        updated_at: now
-      }
-    }
+// Save to database, then broadcast to subscribers
+db.add "message" {
+  data = { room_id: $input.room_id, sender_id: $auth.id, content: $input.content }
+} as $message
 
-    // Push to dashboard subscribers
-    api.realtime_event {
-      channel = "dashboard:metrics"
-      event = "update"
-      data = $metrics
-    }
-  }
-  response = $metrics
-}
-```
-
-### Collaborative Editing
-
-```xs
-realtime_trigger "document_edit" {
-  channel = "document:*"
-  event = "operation"
-  stack {
-    // Apply operation to document
-    function.run "apply_document_op" {
-      input = {
-        document_id: $input.document_id,
-        operation: $input.operation,
-        user_id: $auth.id
-      }
-    } as $result
-
-    // Broadcast to other editors
-    api.realtime_event {
-      channel = $channel
-      event = "remote_operation"
-      data = {
-        operation: $input.operation,
-        user_id: $auth.id,
-        version: $result.version
-      }
-    }
-  }
-}
-```
-
-### Notification System
-
-```xs
-function "notify_user" {
-  input {
-    int user_id
-    text type
-    text title
-    text body
-    json? data
-  }
-  stack {
-    // Save notification
-    db.add "notification" {
-      data = {
-        user_id: $input.user_id,
-        type: $input.type,
-        title: $input.title,
-        body: $input.body,
-        data: $input.data,
-        read: false,
-        created_at: now
-      }
-    } as $notification
-
-    // Push to user
-    api.realtime_event {
-      channel = "user:" ~ $input.user_id
-      event = "notification"
-      data = $notification
-    }
-  }
-  response = $notification
+api.realtime_event {
+  channel = "room:" ~ $input.room_id
+  event = "new_message"
+  data = $message
 }
 ```
 
@@ -401,39 +284,9 @@ function "notify_user" {
 
 ## Subscription Management
 
-Clients subscribe to channels client-side. Server controls what events to send.
+Clients subscribe to channels client-side. Server controls what events to send. Validate channel access with preconditions before broadcasting.
 
-### Authorization Pattern
-
-```xs
-// Validate user can access channel before sending
-function "send_to_room" {
-  input {
-    int room_id
-    text event
-    json data
-  }
-  stack {
-    // Check membership
-    db.query "room_member" {
-      where = $db.room_member.room_id == $input.room_id
-            && $db.room_member.user_id == $auth.id
-      return = { type: "exists" }
-    } as $is_member
-
-    precondition ($is_member) {
-      error_type = "accessdenied"
-      error = "Not a member of this room"
-    }
-
-    api.realtime_event {
-      channel = "room:" ~ $input.room_id
-      event = $input.event
-      data = $input.data
-    }
-  }
-}
-```
+> See `xanoscript_docs({ topic: "security" })` for authorization patterns.
 
 ---
 
@@ -442,6 +295,3 @@ function "send_to_room" {
 1. **Use channel namespacing** - `type:id` format for clarity
 2. **Keep payloads small** - Send IDs, let client fetch details
 3. **Validate before broadcast** - Don't trust client event data
-4. **Use triggers for client events** - Handle incoming realtime events
-5. **Consider fan-out carefully** - Large broadcasts can be expensive
-6. **Implement presence** - Track who's connected to channels

package/dist/xanoscript_docs/run.md

@@ -56,16 +56,6 @@ run.job "Random Dad Joke" {
 }
 ```
 
-### With Empty Input (Alternative)
-```xs
-run.job "Random Dad Joke" {
-  main = {
-    name: "fetch_dad_joke"
-    input: {}
-  }
-}
-```
-
 ### With Input Parameters
 ```xs
 run.job "Average of values" {
@@ -134,16 +124,6 @@ run.service "Random Dad Joke" {
 }
 ```
 
-### With Empty Input (Alternative)
-```xs
-run.service "Random Dad Joke" {
-  pre = {
-    name: "fetch_dad_joke"
-    input: {}
-  }
-}
-```
-
 ### With Initialization
 ```xs
 run.service "email proxy" {
@@ -173,169 +153,9 @@ run.service "webhook listener" {
 
 ## Supporting Files
 
-Jobs and services can include supporting tables and functions.
-
-### Table with Seed Data
-```xs
-table users {
-  auth = false
-  schema {
-    int id
-    text name
-    text email
-    timestamp created_at?=now
-  }
-  index = [
-    {type: "primary", field: [{name: "id"}]}
-  ]
-  items = [
-    {"id": 1, "name": "Alice", "email": "alice@example.com"}
-    {"id": 2, "name": "Bob", "email": "bob@example.com"}
-  ]
-}
-```
-
-### Function Definition
-```xs
-function "process_data" {
-  input {
-    json data
-  }
-  stack {
-    db.query users {
-      return = { type: "list" }
-    } as $users
-  }
-  response = $users
-}
-```
-
----
-
-## Complete Job Example
-
-```
-run.xs
-table/
-└── users.xs
-function/
-└── migrate_users.xs
-```
-
-### run.xs
-```xs
-run.job "Data Migration" {
-  main = {
-    name: "migrate_users"
-    input: {
-      batch_size: 100
-    }
-  }
-  env = ["source_db_url", "webhook_url"]
-}
-```
-
-### table/users.xs
-```xs
-table users {
-  auth = false
-  schema {
-    int id
-    text name
-    text email
-    timestamp migrated_at?
-  }
-  index = [
-    {type: "primary", field: [{name: "id"}]}
-  ]
-  items = [
-    {"id": 1, "name": "Alice", "email": "alice@example.com"}
-    {"id": 2, "name": "Bob", "email": "bob@example.com"}
-  ]
-}
-```
-
-### function/migrate_users.xs
-```xs
-function "migrate_users" {
-  input {
-    int batch_size
-  }
-  stack {
-    db.query users {
-      where = $db.users.migrated_at == null
-      paging = { page: 1, per_page: $input.batch_size }
-    } as $pending
-
-    foreach ($pending) {
-      each as $user {
-        db.edit users {
-          field_name = "id"
-          field_value = $user.id
-          data = { migrated_at: now }
-        }
-      }
-    }
-  }
-  response = { migrated: $pending|count }
-}
-```
-
----
-
-## Complete Service Example
-
-```
-run.xs
-table/
-└── event.xs
-api/
-└── events/
-    ├── api_group.xs
-    ├── list_get.xs
-    └── add_post.xs
-```
-
-### run.xs
-```xs
-run.service "Event Tracker" {
-  pre = {
-    name: "init_tracker"
-    input: {}
-  }
-  env = ["api_key"]
-}
-```
-
-### table/event.xs
-```xs
-table event {
-  auth = false
-  schema {
-    int id
-    timestamp created_at?=now
-    text name
-  }
-  index = [
-    {type: "primary", field: [{name: "id"}]}
-  ]
-  items = []
-}
-```
+Jobs and services can include supporting tables and functions in `table/` and `function/` subdirectories.
 
-### api/events/list_get.xs
-```xs
-query list verb=GET {
-  api_group = "events"
-  stack {
-    db.query event {
-      sort = { created_at: "desc" }
-      return = { type: "list" }
-    } as $events
-  }
-  response = $events
-}
-```
+> See `xanoscript_docs({ topic: "tables" })` and `xanoscript_docs({ topic: "functions" })` for table/function syntax.
 
 ---
 
@@ -364,8 +184,6 @@ query list verb=GET {
 1. **Name clearly** - Indicate purpose: `data-migration`, `email-proxy`
 2. **Use env for secrets** - Never hardcode API keys or credentials
 3. **Keep self-contained** - Include all required tables and functions
-4. **Seed test data** - Use `items` in table definitions for testing
-5. **Validate inputs** - Use preconditions in functions for input validation
 
 ---
 

package/dist/xanoscript_docs/schema.md

@@ -287,6 +287,4 @@ try_catch {
 
 1. **Define schemas upfront** - Use input blocks when structure is known
 2. **Use schema.parse for dynamic data** - External APIs, user-generated content
-3. **Validate at boundaries** - Parse external input, trust internal data
-4. **Provide clear error messages** - Use error_message for user-facing errors
-5. **Use immutable for config** - Prevent accidental modification
+3. **Validate at boundaries** - Parse external input, trust internal data; provide clear error messages