import { Inngest } from "inngest";

const inngest = new Inngest({ id: "my-app" });

// Define a function triggered by an event
export const processOrder = inngest.createFunction(
  { id: "process-order" },
  { event: "order/created" },
  async ({ event, step }) => {
    // Step 1: Validate order
    const validated = await step.run("validate-order", async () => {
      return validateOrder(event.data.orderId);
    });

    // Step 2: Process payment
    const payment = await step.run("process-payment", async () => {
      return processPayment(validated.orderId, validated.amount);
    });

    // Step 3: Send confirmation
    await step.run("send-confirmation", async () => {
      return sendEmail(event.data.email, payment.receiptUrl);
    });
  }
);

// Send an event to trigger the function
await inngest.send({
  name: "order/created",
  data: { orderId: "123", email: "user@example.com" }
});

import { task } from "@trigger.dev/sdk/v3";

// Define a task
export const processOrder = task({
  id: "process-order",
  retry: {
    maxAttempts: 3,
    minTimeoutInMs: 1000,
    maxTimeoutInMs: 10000,
  },
  run: async (payload: { orderId: string; email: string }) => {
    // Validate order
    const validated = await validateOrder(payload.orderId);

    // Process payment
    const payment = await processPayment(validated.orderId, validated.amount);

    // Send confirmation
    await sendEmail(payload.email, payment.receiptUrl);

    return { success: true, paymentId: payment.id };
  },
});

// Trigger the task
await processOrder.trigger({
  orderId: "123",
  email: "user@example.com"
});

# Run self-hosted Inngest
docker run -p 8288:8288 inngest/inngest

# Clone and run with Docker Compose
git clone https://github.com/triggerdotdev/trigger.dev
docker compose up

// Send an event - the producer doesn't need to know who consumes it
await inngest.send({
  name: "order/placed",
  data: { orderId: "123", amount: 500 }
})

// Multiple functions can listen to the same event (fan-out)
inngest.createFunction(
  { id: "send-confirmation" },
  { event: "order/placed" },
  async ({ event }) => { /* Send confirmation email */ }
)

inngest.createFunction(
  { id: "update-inventory" },
  { event: "order/placed" },
  async ({ event }) => { /* Update inventory */ }
)

inngest.createFunction(
  { id: "notify-warehouse" },
  { event: "order/placed" },
  async ({ event }) => { /* Notify warehouse */ }
)

// Define individual tasks
export const sendConfirmation = task({
  id: "send-confirmation",
  run: async ({ orderId, amount }) => { /* Send confirmation email */ }
})

export const updateInventory = task({
  id: "update-inventory",
  run: async ({ orderId, amount }) => { /* Update inventory */ }
})

export const notifyWarehouse = task({
  id: "notify-warehouse",
  run: async ({ orderId, amount }) => { /* Notify warehouse */ }
})

// Manual parallel triggering required
async function onOrderPlaced(orderId: string, amount: number) {
  await Promise.all([
    sendConfirmation.trigger({ orderId, amount }),
    updateInventory.trigger({ orderId, amount }),
    notifyWarehouse.trigger({ orderId, amount }),
  ])
}

export const dailyReport = inngest.createFunction(
  { id: "daily-report" },
  { cron: "0 9 * * *" }, // Every day at 9 AM
  async ({ step }) => {
    const data = await step.run("fetch-data", async () => {
      return fetchAnalyticsData();
    });

    await step.run("generate-report", async () => {
      return generateReport(data);
    });

    await step.run("send-email", async () => {
      return sendReportEmail(data);
    });
  }
);

export const dailyReport = schedules.task({
  id: "daily-report",
  cron: "0 9 * * *", // Every day at 9 AM
  run: async () => {
    const data = await fetchAnalyticsData();
    const report = await generateReport(data);
    await sendReportEmail(report);

    return { success: true };
  },
});

export const riskyOperation = inngest.createFunction(
  {
    id: "risky-operation",
    retries: 5,
  },
  { event: "operation/start" },
  async ({ event, step }) => {
    // Each step has its own retry logic
    const result = await step.run("api-call", async () => {
      return callExternalAPI(event.data.id);
    });

    // Sleep between operations
    await step.sleep("wait-for-processing", "30s");

    await step.run("verify-result", async () => {
      return verifyAPIResult(result.id);
    });
  }
);

export const riskyOperation = task({
  id: "risky-operation",
  retry: {
    maxAttempts: 5,
    factor: 2,
    minTimeoutInMs: 1000,
    maxTimeoutInMs: 30000,
  },
  run: async (payload: { id: string }) => {
    const result = await callExternalAPI(payload.id);

    // Wait between operations
    await wait.for({ seconds: 30 });

    await verifyAPIResult(result.id);

    return { success: true };
  },
});