# Bulk Operation

> Bulk API operation request and response with per-operation status tracking.

- Name: `bulk-operation`
- Categories: api
- Detail page: https://open-types.dev/types/bulk-operation

## Install

```bash
# Types only
npx shadcn add @open-types/bulk-operation

# Types + Zod v4 validators
npx shadcn add @open-types/bulk-operation-zod

# Types + real-world examples
npx shadcn add @open-types/bulk-operation-examples
```

## Types

```typescript
export type BulkOperationMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";

export interface BulkOperationRequest {
  id: string;
  method: BulkOperationMethod;
  path: string;
  body?: Record<string, unknown>;
}

export interface BulkOperationResult {
  id: string;
  status: number;
  body?: Record<string, unknown>;
  error?: string;
}

export interface BulkOperation {
  operations: BulkOperationRequest[];
}

export interface BulkOperationResponse {
  results: BulkOperationResult[];
}
```

## Zod validator

```typescript
import * as z from "zod";
import type {
  BulkOperation,
  BulkOperationMethod,
  BulkOperationRequest,
  BulkOperationResponse,
  BulkOperationResult,
} from "../types/bulk-operation";

export const bulkOperationMethodSchema = z.enum([
  "GET",
  "POST",
  "PUT",
  "PATCH",
  "DELETE",
]) satisfies z.ZodType<BulkOperationMethod>;

export const bulkOperationRequestSchema = z.object({
  id: z.string().min(1, { error: "Operation ID is required" }),
  method: bulkOperationMethodSchema,
  path: z.string().min(1, { error: "Path is required" }),
  body: z.record(z.string(), z.unknown()).optional(),
}) satisfies z.ZodType<BulkOperationRequest>;

export const bulkOperationResultSchema = z.object({
  id: z.string().min(1, { error: "Result ID is required" }),
  status: z
    .number()
    .int()
    .min(100, { error: "Status must be a valid HTTP status code" })
    .max(599, { error: "Status must be a valid HTTP status code" }),
  body: z.record(z.string(), z.unknown()).optional(),
  error: z.string().optional(),
}) satisfies z.ZodType<BulkOperationResult>;

export const bulkOperationSchema = z.object({
  operations: z
    .array(bulkOperationRequestSchema)
    .min(1, { error: "At least one operation is required" }),
}) satisfies z.ZodType<BulkOperation>;

export const bulkOperationResponseSchema = z.object({
  results: z.array(bulkOperationResultSchema),
}) satisfies z.ZodType<BulkOperationResponse>;

export type {
  BulkOperation,
  BulkOperationMethod,
  BulkOperationRequest,
  BulkOperationResponse,
  BulkOperationResult,
} from "../types/bulk-operation";
```

## Examples

```typescript
// Source: hand-crafted; modeled after Shopify/Stripe-style batch APIs
import type {
  BulkOperationMethod,
  BulkOperationRequest,
  BulkOperationResult,
  BulkOperation,
  BulkOperationResponse,
} from "../types/bulk-operation";

export const bulkOperationMethodExamples = {
  get: "GET",
  post: "POST",
  put: "PUT",
  patch: "PATCH",
  delete: "DELETE",
} as const satisfies Record<string, BulkOperationMethod>;

const createOrder = {
  id: "op_1",
  method: "POST",
  path: "/v1/orders",
  body: { customer: "cus_321", items: [{ sku: "sku_abc", quantity: 2 }] },
} as const satisfies BulkOperationRequest;

const fetchOrder = {
  id: "op_2",
  method: "GET",
  path: "/v1/orders/ord_42",
} as const satisfies BulkOperationRequest;

const deleteOrder = {
  id: "op_3",
  method: "DELETE",
  path: "/v1/orders/ord_43",
} as const satisfies BulkOperationRequest;

export const bulkOperationRequestExamples = {
  create: createOrder,
  fetch: fetchOrder,
  remove: deleteOrder,
  update: {
    id: "op_4",
    method: "PATCH",
    path: "/v1/orders/ord_44",
    body: { status: "fulfilled" },
  } satisfies BulkOperationRequest,
} as const;

export const bulkOperationResultExamples = {
  ok: {
    id: "op_1",
    status: 201,
    body: { id: "ord_new", status: "created" },
  } satisfies BulkOperationResult,
  noContent: { id: "op_3", status: 204 } satisfies BulkOperationResult,
  failure: {
    id: "op_2",
    status: 404,
    error: "Order not found",
  } satisfies BulkOperationResult,
  validation: {
    id: "op_5",
    status: 422,
    body: { errors: [{ field: "quantity", message: "must be positive" }] },
    error: "Validation failed",
  } satisfies BulkOperationResult,
} as const;

export const bulkOperationExamples = {
  mixedMethods: {
    operations: [createOrder, fetchOrder, deleteOrder],
  } satisfies BulkOperation,
  singleOp: { operations: [createOrder] } satisfies BulkOperation,
} as const;

export const bulkOperationResponseExamples = {
  mixed: {
    results: [
      bulkOperationResultExamples.ok,
      bulkOperationResultExamples.failure,
      bulkOperationResultExamples.noContent,
    ],
  } satisfies BulkOperationResponse,
  empty: { results: [] } satisfies BulkOperationResponse,
} as const;
```