Inngest vs Temporal: Durable execution that developers love

export async function getUser(userId: string) {
  const user = await db.getUser(userId);
  if (!user) {
    throw InvalidAccountError('User not found');
  }
  return user;
}
export async function sendWelcomeEmail(email: string) {
  // ...
}
export async function startTrial(userId: string) {
  // ...
}

import { proxyActivities } from '@temporalio/workflow';
import { ApplicationFailure } from '@temporalio/common';

export async function welcomeWorkflow(
  userSignup: { id: string }
) {
  const {
    getUser,
    sendWelcomeEmail,
    startTrial
  } = proxyActivities<typeof activities>({
    retry: {
      initialInterval: '1 second',
      maximumInterval: '1 minute',
      backoffCoefficient: 2,
      maximumAttempts: 4,
      nonRetryableErrorTypes: ['InvalidAccountError'],
    },
    startToCloseTimeout: '1 minute',
  });

  const user = await getUser(userSignup.id);

  await sendWelcomeEmail(user.email);

  try {
    await startTrial(user.id);
  } catch (e) {
    throw ApplicationFailure.create({
      message: 'Failed to start trial'
    });
  }

  return 'Workflow complete';
}

import { Worker } from '@temporalio/worker';
import * as activities from './activities';
import { namespace, taskQueueName } from './shared';

async function run() {
  // Workflows are loaded from the workflowsPath
  // which modifies the code at runtime
  const worker = await Worker.create({
    workflowsPath: require.resolve('./workflows'),
    activities,
    namespace: 'acme-app',
    taskQueue: 'user-workflows',
  });

  await worker.run();
}

run().catch((err) => {
  console.error(err);
  process.exit(1);
});

import { Inngest, NonRetriableError } from 'inngest';

export const inngest = new Inngest({
  id: 'acme-app',
});

export const welcomeWorkflow = inngest.createFunction(
  { id: 'welcome-workflow', retries: 4 },
  { event: 'user.signup'},
  async ({ event, step }) => {
    const user = await step.run('get-user', async () => {
      const user = await db.getUser(userId);
      if (!user) {
        throw NonRetriableError('User not found');
      }
      return user;
    });

    await step.run('send-welcome-email', async () => {
      await sendWelcomeEmail(user.email);
    });

    await step.run('start-trial', async () => {
      await startTrial(user.id);
    });

    return 'Workflow complete';
  }
)

import { serve } from 'inngest/express';
import { inngest, welcomeWorkflow } from './workflows';

app.use('/api/inngest', serve({
  client: inngest,
  functions: [welcomeWorkflow]
}));

app.listen(3000);