declare module "@acme/core/bus" {
  export interface Events {
    "business.created": {
      id: string
      name: string
    }
    "business.deleted": {
      id: string
    }
  }
}

Bus.publish("type", properties)

Bus.createHandler

@serverless-stack/node

export interface Event {
  id: string
  source: "acme"
  type: string
  properties: any
  actor: Actor
}

export interface Events {}

export type EventTypes = keyof Events

export type FromType<T extends EventTypes> = payload<T, Events[T]>

export type AnyEvent = FromType<EventTypes>

export type payload<T extends string, P extends Record<string, any>> = {
  id: string
  source: "acme"
  type: T
  properties: P
  actor: Actor
}

export async function publish<T extends EventTypes>(
  type: T,
  properties: Events[T],
  actor?: Actor
) {
  const ctx = context()
  const payload: Event = {
    id: ulid(),
    source: "acme",
    type,
    properties,
    actor: actor ? actor : ctx.actor,
  }
  // Send event
  return payload
}

context()

actor

export function createHandler<T extends EventTypes>(
  cb: (event: FromType<T>, record: SQSRecord) => Promise<void>
) {
  const result = async (event: SQSEvent) => {
    const promises = []
    for (const record of event.Records) {
      const msg = JSON.parse(record.body)
      async function run() {
        try {
          await cb(msg.detail as FromType<T>, record)
          return { type: "success" }
        } catch (e) {
          console.error(e)
          return { type: "error", messageId: record.messageId }
        }
      }
      promises.push(run())
    }
    const results = await Promise.all(promises)
    return {
      batchItemFailures: results
        .filter((i) => i.type === "error")
        .map((i) => ({
          itemIdentifier: i,
        })),
    }
  }
  return AWSLambda.wrapHandler(result) // Sentry
}