deleteMany

Remove multiple records that match a filter.

const result = await client.user.deleteMany({
  where: { archived: true },
});

console.log(`Deleted ${result.count} records`);

Basic Delete

Remove records matching a filter:

// Delete all inactive users
const result = await client.user.deleteMany({
  where: { active: false },
});

console.log(`Deleted ${result.count} users`);

Complex Filters

Multiple conditions:

// Delete archived users inactive for 6 months
const result = await client.user.deleteMany({
  where: {
    archived: true,
    lastLogin: {
      lt: new Date(Date.now() - 180 * 24 * 60 * 60 * 1000),
    },
  },
});

Return Value

Returns count of deleted records:

const result = await client.user.deleteMany({
  where: { active: false },
});

console.log(result.count); // Number of deleted records

Delete All

Remove all records (use with caution):

// Delete everything in a table
const result = await client.user.deleteMany({
  where: {}, // No filter = all records
});

console.log(`Deleted all ${result.count} users`);

With Options

const result = await client.user.deleteMany(
  {
    where: { archived: true },
  },
  {
    tx: transaction, // Use existing transaction
    silent: false, // Emit events (default: false)
    addToOutbox: true, // Queue for sync (default: true if sync is enabled)
  }
);

Cascading Deletes

Dependent records are handled per schema definition:

// If Todo has @relation with onDelete: Cascade
const result = await client.user.deleteMany({
  where: { role: "test" },
});
// All associated todos are automatically deleted

Safe Delete Pattern

Verify count before deleting:

// Preview what will be deleted
const preview = await client.user.findMany({
  where: { archived: true },
});

console.log(`Will delete ${preview.length} users`);

if (preview.length > 0 && confirm("Delete?")) {
  const result = await client.user.deleteMany({
    where: { archived: true },
  });
  console.log(`Deleted ${result.count} records`);
}

Batch Delete

Delete in batches to optimize performance:

const batch = 100;
let deleted = 0;

for (let i = 0; i < 10; i++) {
  // Find ids to delete (limit batch size)
  const records = await client.user.findMany({
    where: { archived: true },
    select: { id: true },
    take: batch,
  });

  if (records.length === 0) break;

  const result = await client.user.deleteMany({
    where: { id: { in: records.map((r) => r.id) } },
  });

  deleted += result.count;
}

console.log(`Deleted ${deleted} total records`);

Remove dependent records first (if not cascaded):

// Delete all todos first (if schema doesn't cascade)
const todoResult = await client.todo.deleteMany({
  where: { userId: { in: userIds } },
});

// Then delete users
const userResult = await client.user.deleteMany({
  where: { id: { in: userIds } },
});

console.log(`Deleted ${todoResult.count} todos and ${userResult.count} users`);

Or use a transaction:

const result = await client.$transaction(async (tx) => {
  const todoCount = await tx.todo.deleteMany({
    where: { userId: { in: userIds } },
  });

  const userCount = await tx.user.deleteMany({
    where: { id: { in: userIds } },
  });

  return { todos: todoCount.count, users: userCount.count };
});

Events

deleteMany emits delete events for each record (unless silent: true):

client.user.subscribe(["delete"], (event) => {
  console.log("User deleted:", event.detail.id);
});

await client.user.deleteMany({
  where: { archived: true },
});
// Logs event for each deleted user

Soft Delete Pattern

Instead of permanent deletion, mark records:

// Mark as deleted instead of removing
const result = await client.user.updateMany({
  where: { archived: true },
  data: { deletedAt: new Date() },
});

// Query only active records
const activeUsers = await client.user.findMany({
  where: { deletedAt: null },
});

// Later, permanently delete old soft-deleted records
const thirtyDaysAgo = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000);

const deleted = await client.user.deleteMany({
  where: {
    deletedAt: { lt: thirtyDaysAgo },
  },
});

Common Use Cases

Clean up archived data:

const result = await client.user.deleteMany({
  where: { archived: true },
});
console.log(`Deleted ${result.count} archived users`);

Remove test data:

const result = await client.user.deleteMany({
  where: { email: { endsWith: "@test.example.com" } },
});

Cleanup old sessions:

const expiredSessions = new Date(Date.now() - 24 * 60 * 60 * 1000);

const result = await client.session.deleteMany({
  where: { expiresAt: { lt: expiredSessions } },
});

Delete inactive records:

const ninetyDaysAgo = new Date(Date.now() - 90 * 24 * 60 * 60 * 1000);

const result = await client.user.deleteMany({
  where: {
    active: false,
    lastLogin: { lt: ninetyDaysAgo },
  },
});