Inngest Infrastructure

// packages/core/src/domain/events.ts
export type InngestEvents = {
  'organisation.create.provisional': {
    data: { accountId: string; name: string; recordId?: number };
  };
  'transaction.create': {
    data: { accountId: string; name: string; organisationId: string; segmentId?: string };
  };
};

// packages/core/src/application/jobs/organisation/create-provisional.ts
import { inngest } from '../../../infrastructure/inngest/client';

export const createProvisionalOrganisation = inngest.createFunction(
  {
    id: 'organisation-create-provisional',
    concurrency: { limit: 100 },
    throttle: { limit: 1000, period: '1m', burst: 100 },
  },
  { event: 'organisation.create.provisional' },
  async ({ event, step }) => {
    const { accountId, name, recordId } = event.data;

    // Step 1: Create organisation
    const org = await step.run('create-provisional', async () => {
      return new CreateProvisionalOrganisation().execute({ diffbotId: null, name });
    });

    // Step 2: Link to account
    if (accountId) {
      await step.run('link-to-account', async () => {
        await AccountRepository.addOrganisation(accountId, { organisationId: org.id, name: org.name, recordId });
      });
    }

    return { organisationId: org.id, name: org.name };
  }
);

const result1 = await step.run('step-1', () => doFirst());
const result2 = await step.run('step-2', () => doSecond(result1));

const [a, b] = await Promise.all([
  step.run('parallel-1', () => doA()),
  step.run('parallel-2', () => doB()),
]);

const childEvent = await step.waitForEvent('wait-for-child', {
  event: 'child.completed',
  match: 'data.parentId',
  timeout: '1h',
});

await step.sendEvent('emit-event', {
  name: 'something.happened',
  data: { id: '123' },
});

await step.run('optional-step', async () => {
  try {
    return await riskyOperation();
  } catch (error) {
    console.error('Non-fatal:', error);
    return null;  // Continue execution
  }
});

inngest.createFunction(
  {
    id: 'my-function',
    retries: 3,
    onFailure: async ({ error, event }) => {
      await notifyFailure(error, event);
    },
  },
  { event: 'my.event' },
  async ({ event, step }) => { ... }
);

{
  id: 'my-function',
  concurrency: {
    limit: 100,
    key: 'event.data.accountId',  // Per account
  },
  throttle: {
    limit: 1000,
    period: '1m',
    burst: 100,
  },
}

import { inngest } from '@repo/core/infrastructure/inngest/client';

// From use case or server action
await inngest.send({
  name: 'organisation.create.provisional',
  data: { accountId, name },
});