convex-migrations

Name: convex-migrations - Agent Skill
Rating: 3.4 (190 reviews)
Author: waynesutton

190

Schema migration strategies for evolving applications including adding new fields, backfilling data, removing deprecated fields, index migrations, and zero-downtime migration patterns

Download Folder View on GitHub

CLI Install

Recommended

Use the skills CLI to install this skill with one command. Auto-detects all installed AI assistants.

Method 1 - skills CLI

npx skills i waynesutton/convexskills/skills/convex-migrations

Method 2 - openskills (supports sync & update)

npx openskills install waynesutton/convexskills

Auto-detects Claude Code, Cursor, Codex CLI, Gemini CLI, and more. One install, works everywhere.

Installation Path

Download and extract to one of the following locations:

~/.claude/skills/convex-migrations/

SKILL.md

agents

assets

Skill Instructions

Back

Run with Cloud Agent

No setup needed. Let our cloud agents run this skill for you.

Select Provider

Select Model

Claude Sonnet 4.5

$0.20/task

Best for coding tasks

Environment setup included

Convex Migrations

Evolve your Convex database schema safely with patterns for adding fields, backfilling data, removing deprecated fields, and maintaining zero-downtime deployments.

Documentation Sources

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

Primary: https://docs.convex.dev/database/schemas
Schema Overview: https://docs.convex.dev/database
Migration Patterns: https://stack.convex.dev/migrate-data-postgres-to-convex
For broader context: https://docs.convex.dev/llms.txt

Instructions

Migration Philosophy

Convex handles schema evolution differently than traditional databases:

No explicit migration files or commands
Schema changes deploy instantly with npx convex dev
Existing data is not automatically transformed
Use optional fields and backfill mutations for safe migrations

Adding New Fields

Start with optional fields, then backfill:

// Step 1: Add optional field to schema
// convex/schema.ts
import { defineSchema, defineTable } from "convex/server";
import { v } from "convex/values";
 
export default defineSchema({
  users: defineTable({
    name: v.string(),
    email: v.string(),
    // New field - start as optional
    avatarUrl: v.optional(v.string

// Step 2: Update code to handle both cases
// convex/users.ts
import { query } from "./_generated/server";
import { v } from "convex/values";
 
export const getUser = query({
  args: { userId: v.id("users") },
  returns: v.union(
    v.

// Step 3: Backfill existing documents
// convex/migrations.ts
import { internalMutation } from "./_generated/server";
import { internal } from "./_generated/api";
import { v } from "convex/values";
 
const

// Step 4: After backfill completes, make field required
// convex/schema.ts
export default defineSchema({
  users: defineTable({
    name: v.string(),
    email: v.string(),
    avatarUrl: v.string(), // Now required
  }),
});

Removing Fields

Remove field usage before removing from schema:

// Step 1: Stop using the field in queries and mutations
// Mark as deprecated in code comments
 
// Step 2: Remove field from schema (make optional first if needed)
// convex/schema.ts
export default defineSchema({
  posts: defineTable({
    title: v.string(),
    content: v.string(),

Renaming Fields

Renaming requires copying data to new field, then removing old:

// Step 1: Add new field as optional
// convex/schema.ts
export default defineSchema({
  users: defineTable({
    userName: v.string(), // Old field
    displayName: v.

Adding Indexes

Add indexes before using them in queries:

// Step 1: Add index to schema
// convex/schema.ts
export default defineSchema({
  posts: defineTable({
    title: v.string(),
    authorId: v.id("users"),
    publishedAt: v.optional(v.number()),

Changing Field Types

Type changes require careful migration:

// Example: Change from string to number for a "priority" field
 
// Step 1: Add new field with new type
// convex/schema.ts
export default defineSchema({
  tasks: defineTable

Migration Runner Pattern

Create a reusable migration system:

// convex/schema.ts
import { defineSchema, defineTable } from "convex/server";
import { v } from "convex/values";
 
export default defineSchema({
  migrations: defineTable({
    name: v.string(),
    startedAt: v.number(),
    completedAt: v.optional(v.number()),

// convex/migrations.ts
import

// convex/migrations/addUserTimestamps.ts
import { internalMutation } from "../_generated/server";
import { internal }

Examples

Schema with Migration Support

// convex/schema.ts
import { defineSchema, defineTable } from "convex/server";
import { v } from "convex/values";
 
export default defineSchema({

Best Practices

Never run npx convex deploy unless explicitly instructed
Never run any git commands unless explicitly instructed
Always start with optional fields when adding new data
Backfill data in batches to avoid timeouts
Test migrations on development before production
Keep track of completed migrations to avoid re-running
Update code to handle both old and new data during transition
Remove deprecated fields only after all code stops using them
Use pagination for large datasets
Add appropriate indexes before running queries on new fields

Common Pitfalls

Making new fields required immediately - Breaks existing documents
Not handling undefined values - Causes runtime errors
Large batch sizes - Causes function timeouts
Forgetting to update indexes - Queries fail or perform poorly
Running migrations without tracking - May run multiple times
Removing fields before code update - Breaks existing functionality
Not testing on development - Production data issues

References

Convex Documentation: https://docs.convex.dev/
Convex LLMs.txt: https://docs.convex.dev/llms.txt
Schemas: https://docs.convex.dev/database/schemas
Database Overview: https://docs.convex.dev/database
Migration Patterns: https://stack.convex.dev/migrate-data-postgres-to-convex

avatarUrl: v.union(v.string(), v.null()),

handler: async (ctx, args) => {

const user = await ctx.db.get(args.userId);

if (!user) return null;

// Handle missing field gracefully

avatarUrl: user.avatarUrl ?? null,

export const backfillAvatarUrl = internalMutation({

cursor: v.optional(v.string()),

processed: v.number(),

hasMore: v.boolean(),

handler: async (ctx, args) => {

const result = await ctx.db

.paginate({ numItems: BATCH_SIZE, cursor: args.cursor ?? null });

for (const user of result.page) {

// Only update if field is missing

if (user.avatarUrl === undefined) {

await ctx.db.patch(user._id, {

avatarUrl: generateDefaultAvatar(user.name),

// Schedule next batch if needed

if (!result.isDone) {

await ctx.scheduler.runAfter(0, internal.migrations.backfillAvatarUrl, {

cursor: result.continueCursor,

hasMore: !result.isDone,

function generateDefaultAvatar(name: string): string {

return `https://api.dicebear.com/7.x/initials/svg?seed=${encodeURIComponent(name)}`;

authorId: v.id("users"),

// legacyField: v.optional(v.string()), // Remove this line

// Step 3: Optionally clean up existing data

// convex/migrations.ts

export const removeDeprecatedField = internalMutation({

cursor: v.optional(v.string()),

handler: async (ctx, args) => {

const result = await ctx.db

.paginate({ numItems: 100, cursor: args.cursor ?? null });

for (const post of result.page) {

// Use replace to remove the field entirely

const { legacyField, ...rest } = post as typeof post & { legacyField?: string };

if (legacyField !== undefined) {

await ctx.db.replace(post._id, rest);

if (!result.isDone) {

await ctx.scheduler.runAfter(0, internal.migrations.removeDeprecatedField, {

cursor: result.continueCursor,

// Step 2: Update code to read from new field with fallback

export const getUser = query({

args: { userId: v.id("users") },

displayName: v.string(),

handler: async (ctx, args) => {

const user = await ctx.db.get(args.userId);

if (!user) throw new Error("User not found");

// Read new field, fall back to old

displayName: user.displayName ?? user.userName,

// Step 3: Backfill to copy data

export const backfillDisplayName = internalMutation({

args: { cursor: v.optional(v.string()) },

handler: async (ctx, args) => {

const result = await ctx.db

.paginate({ numItems: 100, cursor: args.cursor ?? null });

for (const user of result.page) {

if (user.displayName === undefined) {

await ctx.db.patch(user._id, {

displayName: user.userName,

if (!result.isDone) {

await ctx.scheduler.runAfter(0, internal.migrations.backfillDisplayName, {

cursor: result.continueCursor,

// Step 4: After backfill, update schema to make new field required

// and remove old field

export default defineSchema({

users: defineTable({

displayName: v.string(),

.index("by_author", ["authorId"])

.index("by_status_and_published", ["status", "publishedAt"]),

// Step 2: Deploy schema change

// Run: npx convex dev

// Step 3: Now use the index in queries

export const getPublishedPosts = query({

returns: v.array(v.object({

publishedAt: v.number(),

handler: async (ctx) => {

const posts = await ctx.db

.withIndex("by_status_and_published", (q) =>

q.eq("status", "published")

.filter((p) => p.publishedAt !== undefined)

publishedAt: p.publishedAt!,

priority: v.string(), // Old: "low", "medium", "high"

priorityLevel: v.optional(v.number()), // New: 1, 2, 3

// Step 2: Backfill with type conversion

export const migratePriorityToNumber = internalMutation({

args: { cursor: v.optional(v.string()) },

handler: async (ctx, args) => {

const result = await ctx.db

.paginate({ numItems: 100, cursor: args.cursor ?? null });

const priorityMap: Record<string, number> = {

for (const task of result.page) {

if (task.priorityLevel === undefined) {

await ctx.db.patch(task._id, {

priorityLevel: priorityMap[task.priority] ?? 1,

if (!result.isDone) {

await ctx.scheduler.runAfter(0, internal.migrations.migratePriorityToNumber, {

cursor: result.continueCursor,

// Step 3: Update code to use new field

export const getTask = query({

args: { taskId: v.id("tasks") },

priorityLevel: v.number(),

handler: async (ctx, args) => {

const task = await ctx.db.get(args.taskId);

if (!task) throw new Error("Task not found");

const priorityMap: Record<string, number> = {

priorityLevel: task.priorityLevel ?? priorityMap[task.priority] ?? 1,

// Step 4: After backfill, update schema

export default defineSchema({

tasks: defineTable({

// priority field removed

priorityLevel: v.number(),

v.literal("running"),

v.literal("completed"),

error: v.optional(v.string()),

processed: v.number(),

}).index("by_name", ["name"]),

// Your other tables...

{ internalMutation, internalQuery }

"./_generated/server"

import { internal } from "./_generated/api";

import { v } from "convex/values";

// Check if migration has run

export const hasMigrationRun = internalQuery({

args: { name: v.string() },

returns: v.boolean(),

handler: async (ctx, args) => {

const migration = await ctx.db

.query("migrations")

.withIndex("by_name", (q) => q.eq("name", args.name))

return migration?.status === "completed";

// Start a migration

export const startMigration = internalMutation({

args: { name: v.string() },

returns: v.id("migrations"),

handler: async (ctx, args) => {

// Check if already exists

const existing = await ctx.db

.query("migrations")

.withIndex("by_name", (q) => q.eq("name", args.name))

if (existing.status === "completed") {

throw new Error(`Migration ${args.name} already completed`);

if (existing.status === "running") {

throw new Error(`Migration ${args.name} already running`);

// Reset failed migration

await ctx.db.patch(existing._id, {

startedAt: Date.now(),

return existing._id;

return await ctx.db.insert("migrations", {

startedAt: Date.now(),

// Update migration progress

export const updateMigrationProgress = internalMutation({

migrationId: v.id("migrations"),

processed: v.number(),

handler: async (ctx, args) => {

const migration = await ctx.db.get(args.migrationId);

if (!migration) return null;

await ctx.db.patch(args.migrationId, {

processed: migration.processed + args.processed,

// Complete a migration

export const completeMigration = internalMutation({

args: { migrationId: v.id("migrations") },

handler: async (ctx, args) => {

await ctx.db.patch(args.migrationId, {

status: "completed",

completedAt: Date.now(),

export const failMigration = internalMutation({

migrationId: v.id("migrations"),

handler: async (ctx, args) => {

await ctx.db.patch(args.migrationId, {

import { v } from "convex/values";

const MIGRATION_NAME = "add_user_timestamps_v1";

const BATCH_SIZE = 100;

export const run = internalMutation({

migrationId: v.optional(v.id("migrations")),

cursor: v.optional(v.string()),

handler: async (ctx, args) => {

// Initialize migration on first run

let migrationId = args.migrationId;

const hasRun = await ctx.runQuery(internal.migrations.hasMigrationRun, {

name: MIGRATION_NAME,

console.log(`Migration ${MIGRATION_NAME} already completed`);

migrationId = await ctx.runMutation(internal.migrations.startMigration, {

name: MIGRATION_NAME,

const result = await ctx.db

.paginate({ numItems: BATCH_SIZE, cursor: args.cursor ?? null });

for (const user of result.page) {

if (user.createdAt === undefined) {

await ctx.db.patch(user._id, {

createdAt: user._creationTime,

updatedAt: user._creationTime,

await ctx.runMutation(internal.migrations.updateMigrationProgress, {

// Continue or complete

if (!result.isDone) {

await ctx.scheduler.runAfter(0, internal.migrations.addUserTimestamps.run, {

cursor: result.continueCursor,