Convex Component Authoring

Create self-contained, reusable Convex components with proper isolation, exports, and dependency management for sharing across projects.

Documentation Sources

Before implementing, do not assume; fetch the latest documentation:

Primary: https://docs.convex.dev/components
Component Authoring: https://docs.convex.dev/components/authoring
For broader context: https://docs.convex.dev/llms.txt

Instructions

What Are Convex Components?

Convex components are self-contained packages that include:

Database tables (isolated from the main app)
Functions (queries, mutations, actions)
TypeScript types and validators
Optional frontend hooks

Component Structure

my-convex-component/
├── package.json
├── tsconfig.json
├── README.md
├── src/
│   ├── index.ts           # Main exports
│   ├── component.ts       # Component definition
│   ├── schema.ts          # Component schema
│   └── functions/
│       ├── queries.ts
│       ├── mutations.ts
│       └── actions.ts
└── convex.config.ts       # Component configuration

Creating a Component

1. Component Configuration

// convex.config.ts
import { defineComponent } from "convex/server";
 
export default defineComponent("myComponent");

2. Component Schema

// src/schema.ts
import { defineSchema, defineTable } from "convex/server";
import { v } from "convex/values";
 
export default defineSchema({
  // Tables are isolated to this component
  items: defineTable({
    name: v.string(),
    data: v.any(),
    createdAt: v.number(),
  }).

3. Component Definition

// src/component.ts
import { defineComponent, ComponentDefinition } from "convex/server";
import schema from "./schema";
import * as queries from "./functions/queries";
import * as mutations from "./functions/mutations";
 
const component = defineComponent("myComponent", {

4. Component Functions

// src/functions/queries.ts
import { query } from "../_generated/server";
import { v } from "convex/values";
 
export const list = query({
  args: {
    limit: v.optional(v.number()),
  },
  returns: v.

// src/functions/mutations.ts
import { mutation } from "../_generated/server";
import { v } from "convex/values";
 
export const create = mutation({
  args: {
    name: v.string(),
    data: v.any(),
  },

5. Main Exports

// src/index.ts
export { default as component } from "./component";
export * from "./functions/queries";
export * from "./functions/mutations";
 
// Export types for consumers
export type { Id } from "./_generated/dataModel";

Using a Component

// In the consuming app's convex/convex.config.ts
import { defineApp } from "convex/server";
import myComponent from "my-convex-component";
 
const app = defineApp();
 
app.use(myComponent, { name: "myComponent" });
 
export default app;

// In the consuming app's code
import { useQuery, useMutation } from "convex/react";
import { api } from "../convex/_generated/api";
 
function MyApp() {
  // Access component functions through the app's API
  const items = useQuery(api.myComponent.list, { limit: 10 });
  const createItem = useMutation(api.myComponent.create);

Component Configuration Options

// convex/convex.config.ts
import { defineApp } from "convex/server";
import myComponent from "my-convex-component";
 
const app = defineApp();
 
// Basic usage
app.use(myComponent);
 
// With custom name
app.use(myComponent, { name: "customName" });
 
// Multiple instances
app.use

Providing Component Hooks

// src/hooks.ts
import { useQuery, useMutation } from "convex/react";
import { FunctionReference } from "convex/server";
 
// Type-safe hooks for component consumers
export function useMyComponent(api: {
  list: FunctionReference<"query">;
  create: FunctionReference<"mutation"

Publishing a Component

package.json

{
  "name": "my-convex-component",
  "version": "1.0.0",
  "description": "A reusable Convex component",
  "main": "dist/index.js",
  "types": "dist/index.d.ts",
  "files": [
    "dist",
    "convex.config.ts"
  ],
  "scripts": {

tsconfig.json

{
  "compilerOptions": {
    "target": "ES2020",
    "module": "ESNext",
    "moduleResolution": "bundler",
    "declaration": true,
    "outDir": "dist",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck":

Examples

Rate Limiter Component

// rate-limiter/src/schema.ts
import { defineSchema, defineTable } from "convex/server";
import { v } from "convex/values";
 
export default defineSchema({
  requests: defineTable({
    key: v.string(),
    timestamp: v.number(),
  })
    .index("by_key", ["key"])

// rate-limiter/src/functions/mutations.ts
import { mutation } from "../_generated/server";
import { v } from "convex/values";
 
export const checkLimit = mutation({

// Usage in consuming app
import { useMutation } from "convex/react";
import { api } from "../convex/_generated/api";
 
function useRateLimitedAction() {
  const checkLimit = useMutation(api.rateLimiter.checkLimit);
  
  return async (action: () => Promise<

Best Practices

Never run npx convex deploy unless explicitly instructed
Never run any git commands unless explicitly instructed
Keep component tables isolated (don't reference main app tables)
Export clear TypeScript types for consumers
Document all public functions and their arguments
Use semantic versioning for component releases
Include comprehensive README with examples
Test components in isolation before publishing

Common Pitfalls

Cross-referencing tables - Component tables should be self-contained
Missing type exports - Export all necessary types
Hardcoded configuration - Use component options for customization
No versioning - Follow semantic versioning
Poor documentation - Document all public APIs

References

Convex Documentation: https://docs.convex.dev/
Convex LLMs.txt: https://docs.convex.dev/llms.txt
Components: https://docs.convex.dev/components
Component Authoring: https://docs.convex.dev/components/authoring

convex-component-authoring

CLI Install

Skill Instructions

Run with Cloud Agent