types.ts

import { RequestError } from "@octokit/request-error";
import type {
  WebhookEventMap,
  WebhookEventName,
} from "@octokit/webhooks-definitions/schema";
import type { emitterEventNames } from "./generated/webhook-names";

export type EmitterWebhookEventName = typeof emitterEventNames[number];
export type EmitterWebhookEvent<
  TEmitterEvent extends EmitterWebhookEventName = EmitterWebhookEventName
> = TEmitterEvent extends `${infer TWebhookEvent}.${infer TAction}`
  ? BaseWebhookEvent<Extract<TWebhookEvent, WebhookEventName>> & {
      payload: { action: TAction };
    }
  : BaseWebhookEvent<Extract<TEmitterEvent, WebhookEventName>>;

interface BaseWebhookEvent<TName extends WebhookEventName> {
  id: string;
  name: TName;
  payload: WebhookEventMap[TName];
}

export interface Options<
  T extends EmitterWebhookEvent,
  TTransformed = unknown
> {
  path?: string;
  secret?: string;
  transform?: TransformMethod<T, TTransformed>;
}

type TransformMethod<T extends EmitterWebhookEvent, V = T> = (
  event: EmitterWebhookEvent
) => V | PromiseLike<V>;

type EnsureArray<T> = T extends any[] ? T : [T];

export type HandlerFunction<
  TName extends EmitterWebhookEventName | EmitterWebhookEventName[],
  TTransformed
> = (
  event: EmitterWebhookEvent<EnsureArray<TName>[number]> & TTransformed
) => any;

type Hooks = {
  [key: string]: Function[];
};

export interface State extends Options<any> {
  eventHandler?: any;
  hooks: Hooks;
}

/**
 * Error object with optional properties coming from `octokit.request` errors
 */
export type WebhookError = Error & Partial<RequestError>;

// todo: rename to "EmitterErrorEvent"
export interface WebhookEventHandlerError extends AggregateError<WebhookError> {
  event: EmitterWebhookEvent;
}

/**
 * Workaround for TypeScript incompatibility with types exported by aggregate-error.
 * Credit: https://git.io/JUEEr
 * @copyright Sindre Sorhus
 * @license MIT (https://git.io/JUEEK)
 * @see https://github.com/octokit/webhooks.js/pull/270/files
 */
declare class AggregateError<T extends Error = Error>
  extends Error
  implements Iterable<T> {
  readonly name: "AggregateError";
  constructor(errors: ReadonlyArray<T | { [key: string]: any } | string>);

  [Symbol.iterator](): IterableIterator<T>;
}