OpenParable
Skip to content
← Back to skills

Convex Backend

Development
convex-backend

Convex Backend is an Agent Skill for development published in the CloudAI-X/claude-workflow-v2 repository on GitHub: a SKILL.md instruction file an AI agent can load to do this task.

Convex backend development guidelines. Use when writing Convex functions, schemas, queries, mutations, actions, or any backend code in a Convex project. Triggers on tasks involving Convex database operations, real-time subscriptions, file storage, or serverless functions.

View on GitHub ↗
QUICK START

How to use this skill

Bring this guide into your coding agent with a prompt tailored to the tool you use.

  1. Open your project in Codex.
  2. Copy and paste the prompt below.
  3. Review files and risks before approving any action.
Prompt to paste
Inspect the Agent Skill at https://github.com/CloudAI-X/claude-workflow-v2/blob/HEAD/skills/convex-backend/SKILL.md and all supporting files. Report provenance, permissions, scripts, dependencies, and security risks. Propose an exact installation into .agents/skills/convex-backend, but wait for my approval before writing files or running scripts.

Copying this prompt does not install or run the skill. Review third-party files before use.

Convex Backend Guidelines

When to Load

  • Trigger: Convex-specific development, writing Convex functions, schemas, queries, mutations, actions, or real-time subscriptions
  • Skip: Project does not use Convex as its backend

Comprehensive guide for building Convex backends with TypeScript. Covers function syntax, validators, schemas, queries, mutations, actions, scheduling, and file storage.

When to Apply

Reference these guidelines when:

  • Writing new Convex functions (queries, mutations, actions)
  • Defining database schemas and validators
  • Implementing real-time data fetching
  • Setting up cron jobs or scheduled functions
  • Working with file storage
  • Designing API structure

Rule Categories

CategoryImpactDescription
Function SyntaxCRITICALNew function syntax with args/returns/handler
ValidatorsCRITICALType-safe argument and return validation
Schema DesignHIGHTable definitions, indexes, system fields
Query PatternsHIGHEfficient data fetching with indexes
Mutation PatternsMEDIUMDatabase writes, patch vs replace
Action PatternsMEDIUMExternal API calls, Node.js runtime
SchedulingMEDIUMCrons and delayed function execution
File StorageLOWBlob storage and metadata

Quick Reference

Function Registration

// Public functions (exposed to clients)
import { query, mutation, action } from "./_generated/server";

// Internal functions (only callable from other Convex functions)
import {
  internalQuery,
  internalMutation,
  internalAction,
} from "./_generated/server";

Function Syntax (Always Use This)

export const myFunction = query({
  args: { name: v.string() },
  returns: v.string(),
  handler: async (ctx, args) => {
    return "Hello " + args.name;
  },
});

Common Validators

TypeValidatorExample
Stringv.string()"hello"
Numberv.number()3.14
Booleanv.boolean()true
IDv.id("tableName")doc._id
Arrayv.array(v.string())["a", "b"]
Objectv.object({...}){name: "x"}
Optionalv.optional(v.string())undefined
Unionv.union(v.string(), v.number())"x" or 1
Literalv.literal("status")"status"
Nullv.null()null

Function References

// Public functions
import { api } from "./_generated/api";
api.example.myQuery; // convex/example.ts → myQuery

// Internal functions
import { internal } from "./_generated/api";
internal.example.myInternalMutation;

Query with Index

// Schema
messages: defineTable({...}).index("by_channel", ["channelId"])

// Query
await ctx.db
  .query("messages")
  .withIndex("by_channel", (q) => q.eq("channelId", channelId))
  .order("desc")
  .take(10);

Key Rules

  1. Always include args and returns validators on all functions
  2. Use v.null() for void returns - never omit return validator
  3. Use withIndex() not filter() - define indexes in schema
  4. Use internalQuery/Mutation/Action for private functions
  5. Actions cannot access ctx.db - use runQuery/runMutation instead
  6. Include type annotations when calling functions in same file

Full Compiled Document

For the complete guide with all rules and detailed code examples, see AGENTS.md.