Inngest Steps

// ❌ WRONG - will run 4 timesexport default inngest.createFunction(  { id: "bad-example", triggers: [{ event: "test" }] },  async ({ step }) => {    console.log("This logs 4 times!"); // Outside step = bad    await step.run("a", () => console.log("a"));    await step.run("b", () => console.log("b"));    await step.run("c", () => console.log("c"));  });
// ✅ CORRECT - logs once eachexport default inngest.createFunction(  { id: "good-example", triggers: [{ event: "test" }] },  async ({ step }) => {    await step.run("log-hello", () => console.log("hello"));    await step.run("a", () => console.log("a"));    await step.run("b", () => console.log("b"));    await step.run("c", () => console.log("c"));  });

// Basic usageconst result = await step.run("fetch-user", async () => {  const user = await db.user.findById(userId);  return user; // Always return useful data});
// Synchronous code works tooconst transformed = await step.run("transform-data", () => {  return processData(result);});
// Side effects (no return needed)await step.run("send-notification", async () => {  await sendEmail(user.email, "Welcome!");});

// Duration stringsawait step.sleep("wait-24h", "24h");await step.sleep("short-delay", "30s");await step.sleep("weekly-pause", "7d");
// Use in workflowsawait step.run("send-welcome", () => sendEmail(email));await step.sleep("wait-for-engagement", "3d");await step.run("send-followup", () => sendFollowupEmail(email));

const reminderDate = new Date("2024-12-25T09:00:00Z");await step.sleepUntil("wait-for-christmas", reminderDate);
// From event dataconst scheduledTime = new Date(event.data.remind_at);await step.sleepUntil("wait-for-scheduled-time", scheduledTime);

// Basic event waiting with timeoutconst approval = await step.waitForEvent("wait-for-approval", {  event: "app/invoice.approved",  timeout: "7d",  match: "data.invoiceId" // Simple matching});
// Expression-based matching (CEL syntax)const subscription = await step.waitForEvent("wait-for-subscription", {  event: "app/subscription.created",  timeout: "30d",  if: "event.data.userId == async.data.userId && async.data.plan == 'pro'"});
// Handle timeoutif (!approval) {  await step.run("handle-timeout", () => {    // Approval never came    return notifyAccountingTeam();  });}

const taskId = "task-" + crypto.randomUUID();
const signal = await step.waitForSignal("wait-for-task-completion", {  signal: taskId,  timeout: "1h",  onConflict: "replace" // Required: "replace" overwrites pending signal, "fail" throws an error});
// Send signal elsewhere via Inngest API or SDK// POST /v1/events with signal matching taskId

// Trigger other functionsawait step.sendEvent("notify-systems", {  name: "user/profile.updated",  data: { userId: user.id, changes: profileChanges }});
// Multiple events at onceawait step.sendEvent("batch-notifications", [  { name: "billing/invoice.created", data: { invoiceId } },  { name: "email/invoice.send", data: { email: user.email, invoiceId } }]);

const computeSquare = inngest.createFunction(  { id: "compute-square", triggers: [{ event: "calculate/square" }] },  async ({ event }) => {    return { result: event.data.number * event.data.number };  });
// Invoke and use resultconst square = await step.invoke("get-square", {  function: computeSquare,  data: { number: 4 }});
console.log(square.result); // 16, fully typed!
// For cross-app invocation (when you can't import the function directly):import { referenceFunction } from "inngest";
const externalFn = referenceFunction({  appId: "other-app",  functionId: "other-fn"});
const result = await step.invoke("call-external", {  function: externalFn,  data: { key: "value" }});

const allProducts = [];let cursor = null;let hasMore = true;
while (hasMore) {  // Same ID "fetch-page" reused - counters handled automatically  const page = await step.run("fetch-page", async () => {    return shopify.products.list({ cursor, limit: 50 });  });
  allProducts.push(...page.products);
  if (page.products.length < 50) {    hasMore = false;  } else {    cursor = page.products[49].id;  }}
await step.run("process-products", () => {  return processAllProducts(allProducts);});

// Create steps without awaitingconst sendEmail = step.run("send-email", async () => {  return await sendWelcomeEmail(user.email);});
const updateCRM = step.run("update-crm", async () => {  return await crmService.addUser(user);});
const createSubscription = step.run("create-subscription", async () => {  return await subscriptionService.create(user.id);});
// Run all in parallelconst [emailId, crmRecord, subscription] = await Promise.all([  sendEmail,  updateCRM,  createSubscription]);
// Parallel steps are optimized by default in v4export default inngest.createFunction(  {    id: "parallel-heavy-function",    triggers: [{ event: "process/batch" }]  },  async ({ event, step }) => {    const results = await Promise.all(      event.data.items.map((item, i) =>        step.run(`process-item-${i}`, () => processItem(item))      )    );  });
// ⚠️ Promise.race() behavior with v4's optimized parallelism:// All promises settle before race resolves. Use group.parallel() for true race:const winner = await group.parallel(async () => {  return Promise.race([    step.run("fast-service", () => callFastService()),    step.run("slow-service", () => callSlowService())  ]);});
// To disable optimized parallelism if needed:// At the client level: new Inngest({ id: "app", optimizeParallelism: false })// At the function level: { id: "fn", optimizeParallelism: false, triggers: [...] }

export default inngest.createFunction(  { id: "process-large-dataset", triggers: [{ event: "data/process.large" }] },  async ({ event, step }) => {    const chunks = chunkArray(event.data.items, 10);
    // Process chunks in parallel    const results = await Promise.all(      chunks.map((chunk, index) =>        step.run(`process-chunk-${index}`, () => processChunk(chunk))      )    );
    // Combine results    await step.run("combine-results", () => {      return aggregateResults(results);    });  });