chore(deps): update dependency prettier to v3 (#869)

package.json

@@ -58,7 +58,7 @@
     "express": "^4.17.1",
     "glob": "^10.0.0",
     "jest": "^29.0.0",
-    "prettier": "2.8.8",
+    "prettier": "3.0.0",
     "prettier-plugin-packagejson": "^2.2.9",
     "ts-jest": "^29.0.0",
     "ts-node": "^10.0.0",

scripts/build.mjs

@@ -80,8 +80,8 @@ async function main() {
         sideEffects: false,
       },
       null,
-      2
-    )
+      2,
+    ),
   );
 }
 main();

scripts/generate-types.ts

@@ -26,7 +26,7 @@ const guessAtActionName = (name: string) => name.replace("$", ".");
 const getDefinitionName = (ref: string): string => {
   assert.ok(
     ref.startsWith("#/definitions/"),
-    `${ref} does not reference a valid definition`
+    `${ref} does not reference a valid definition`,
   );
 
   const [, name] = /^#\/definitions\/(.+)$/u.exec(ref) ?? [];
@@ -47,7 +47,7 @@ const buildEventProperties = ([
 ];
 
 const isJSONSchemaWithRef = (
-  object: JSONSchema7Definition
+  object: JSONSchema7Definition,
 ): object is JSONSchemaWithRef =>
   typeof object === "object" && object.$ref !== undefined;
 
@@ -69,7 +69,7 @@ const listEvents = () => {
 const getEmitterEvents = (): string[] => {
   return listEvents().reduce<string[]>(
     (properties, event) => properties.concat(buildEventProperties(event)),
-    []
+    [],
   );
 };
 
@@ -78,15 +78,15 @@ const outDir = "src/generated/";
 const generateTypeScriptFile = (name: string, contents: string[]) => {
   fs.writeFileSync(
     `${outDir}/${name}.ts`,
-    format(contents.join("\n"), { parser: "typescript" })
+    format(contents.join("\n"), { parser: "typescript" }),
   );
 };
 
 const asCode = (str: string): string => `\`${str}\``;
 const asLink = (event: string): string => {
   const link = `https://docs.github.com/en/developers/webhooks-and-events/webhooks/webhook-events-and-payloads#${event.replace(
     /[^a-z_0-9]/g,
-    ""
+    "",
   )}`;
 
   return `[${asCode(event)}](${link})`;
@@ -108,12 +108,12 @@ const updateReadme = (properties: string[]) => {
 
       return events;
     },
-    {}
+    {},
   );
 
   const rows = Object.entries(events).map(
     ([event, actions]) =>
-      `| ${asLink(event)} | ${actions.map(asCode).join("<br>")} |`
+      `| ${asLink(event)} | ${actions.map(asCode).join("<br>")} |`,
   );
 
   const table = format([headers, "| --- | --- |", ...rows].join("\n"), {
@@ -136,8 +136,8 @@ const updateReadme = (properties: string[]) => {
     "README.md",
     `${readme.slice(
       0,
-      tableStartIndex + TableStartString.length
-    )}\n\n${table}\n${readme.slice(tableEndIndex)}`
+      tableStartIndex + TableStartString.length,
+    )}\n\n${table}\n${readme.slice(tableEndIndex)}`,
   );
 };
 

src/event-handler/index.ts

@@ -18,19 +18,19 @@ import { removeListener } from "./remove-listener";
 interface EventHandler<TTransformed> {
   on<E extends EmitterWebhookEventName>(
     event: E | E[],
-    callback: HandlerFunction<E, TTransformed>
+    callback: HandlerFunction<E, TTransformed>,
   ): void;
   onAny(handler: (event: EmitterWebhookEvent) => any): void;
   onError(handler: (event: WebhookEventHandlerError) => any): void;
   removeListener<E extends EmitterWebhookEventName>(
     event: E | E[],
-    callback: HandlerFunction<E, TTransformed>
+    callback: HandlerFunction<E, TTransformed>,
   ): void;
   receive(event: EmitterWebhookEvent): Promise<void>;
 }
 
 export function createEventHandler<TTransformed>(
-  options: Options<TTransformed>
+  options: Options<TTransformed>,
 ): EventHandler<TTransformed> {
   const state: State = {
     hooks: {},

src/event-handler/on.ts

@@ -9,7 +9,7 @@ import type {
 function handleEventHandlers(
   state: State,
   webhookName: EmitterWebhookEventName | "error" | "*",
-  handler: Function
+  handler: Function,
 ) {
   if (!state.hooks[webhookName]) {
     state.hooks[webhookName] = [];
@@ -20,11 +20,11 @@ function handleEventHandlers(
 export function receiverOn(
   state: State,
   webhookNameOrNames: EmitterWebhookEventName | EmitterWebhookEventName[],
-  handler: Function
+  handler: Function,
 ) {
   if (Array.isArray(webhookNameOrNames)) {
     webhookNameOrNames.forEach((webhookName) =>
-      receiverOn(state, webhookName, handler)
+      receiverOn(state, webhookName, handler),
     );
     return;
   }
@@ -42,7 +42,7 @@ export function receiverOn(
 
   if (!emitterEventNames.includes(webhookNameOrNames)) {
     state.log.warn(
-      `"${webhookNameOrNames}" is not a known webhook name (https://developer.github.com/v3/activity/events/types/)`
+      `"${webhookNameOrNames}" is not a known webhook name (https://developer.github.com/v3/activity/events/types/)`,
     );
   }
 
@@ -51,14 +51,14 @@ export function receiverOn(
 
 export function receiverOnAny(
   state: State,
-  handler: (event: EmitterWebhookEvent) => any
+  handler: (event: EmitterWebhookEvent) => any,
 ) {
   handleEventHandlers(state, "*", handler);
 }
 
 export function receiverOnError(
   state: State,
-  handler: (event: WebhookEventHandlerError) => any
+  handler: (event: WebhookEventHandlerError) => any,
 ) {
   handleEventHandlers(state, "error", handler);
 }

src/event-handler/receive.ts

@@ -17,7 +17,7 @@ type EventAction = Extract<
 function getHooks(
   state: State,
   eventPayloadAction: EventAction | null,
-  eventName: EmitterWebhookEventName
+  eventName: EmitterWebhookEventName,
 ): Function[] {
   const hooks = [state.hooks[eventName], state.hooks["*"]];
 
@@ -54,7 +54,7 @@ export function receiverHandle(state: State, event: EmitterWebhookEvent) {
   const hooks = getHooks(
     state,
     "action" in event.payload ? event.payload.action : null,
-    event.name
+    event.name,
   );
 
   if (hooks.length === 0) {

src/event-handler/remove-listener.ts

@@ -3,11 +3,11 @@ import type { EmitterWebhookEventName, State } from "../types";
 export function removeListener(
   state: State,
   webhookNameOrNames: "*" | EmitterWebhookEventName | EmitterWebhookEventName[],
-  handler: Function
+  handler: Function,
 ) {
   if (Array.isArray(webhookNameOrNames)) {
     webhookNameOrNames.forEach((webhookName) =>
-      removeListener(state, webhookName, handler)
+      removeListener(state, webhookName, handler),
     );
     return;
   }

src/index.ts

@@ -23,17 +23,17 @@ class Webhooks<TTransformed = unknown> {
   public verify: (eventPayload: string, signature: string) => Promise<boolean>;
   public on: <E extends EmitterWebhookEventName>(
     event: E | E[],
-    callback: HandlerFunction<E, TTransformed>
+    callback: HandlerFunction<E, TTransformed>,
   ) => void;
   public onAny: (callback: (event: EmitterWebhookEvent) => any) => void;
   public onError: (callback: (event: WebhookEventHandlerError) => any) => void;
   public removeListener: <E extends EmitterWebhookEventName | "*">(
     event: E | E[],
-    callback: RemoveHandlerFunction<E, TTransformed>
+    callback: RemoveHandlerFunction<E, TTransformed>,
   ) => void;
   public receive: (event: EmitterWebhookEvent) => Promise<void>;
   public verifyAndReceive: (
-    options: EmitterWebhookEventWithStringPayloadAndSignature
+    options: EmitterWebhookEventWithStringPayloadAndSignature,
   ) => Promise<void>;
 
   constructor(options: Options<TTransformed> & { secret: string }) {

src/middleware/node/index.ts

@@ -8,7 +8,7 @@ export function createNodeMiddleware(
   {
     path = "/api/github/webhooks",
     log = createLogger(),
-  }: MiddlewareOptions = {}
+  }: MiddlewareOptions = {},
 ) {
   return middleware.bind(null, webhooks, {
     path,

src/middleware/node/middleware.ts

@@ -18,7 +18,7 @@ export async function middleware(
   options: Required<MiddlewareOptions>,
   request: IncomingMessage,
   response: ServerResponse,
-  next?: Function
+  next?: Function,
 ): Promise<boolean> {
   let pathname: string;
   try {
@@ -30,7 +30,7 @@ export async function middleware(
     response.end(
       JSON.stringify({
         error: `Request URL could not be parsed: ${request.url}`,
-      })
+      }),
     );
     return true;
   }
@@ -57,7 +57,7 @@ export async function middleware(
     response.end(
       JSON.stringify({
         error: `Unsupported "Content-Type" header value. Must be "application/json"`,
-      })
+      }),
     );
     return true;
   }
@@ -71,7 +71,7 @@ export async function middleware(
     response.end(
       JSON.stringify({
         error: `Required headers missing: ${missingHeaders}`,
-      })
+      }),
     );
 
     return true;
@@ -123,7 +123,7 @@ export async function middleware(
     response.end(
       JSON.stringify({
         error: errorMessage,
-      })
+      }),
     );
 
     return true;

src/middleware/node/on-unhandled-request-default.ts

@@ -6,14 +6,14 @@ type ServerResponse = any;
 
 export function onUnhandledRequestDefault(
   request: IncomingMessage,
-  response: ServerResponse
+  response: ServerResponse,
 ) {
   response.writeHead(404, {
     "content-type": "application/json",
   });
   response.end(
     JSON.stringify({
       error: `Unknown route: ${request.method} ${request.url}`,
-    })
+    }),
   );
 }

src/types.ts

@@ -8,7 +8,7 @@ import type { emitterEventNames } from "./generated/webhook-names";
 
 export type EmitterWebhookEventName = (typeof emitterEventNames)[number];
 export type EmitterWebhookEvent<
-  TEmitterEvent extends EmitterWebhookEventName = EmitterWebhookEventName
+  TEmitterEvent extends EmitterWebhookEventName = EmitterWebhookEventName,
 > = TEmitterEvent extends `${infer TWebhookEvent}.${infer TAction}`
   ? BaseWebhookEvent<Extract<TWebhookEvent, WebhookEventName>> & {
       payload: { action: TAction };
@@ -38,12 +38,12 @@ type TransformMethod<T> = (event: EmitterWebhookEvent) => T | PromiseLike<T>;
 
 export type HandlerFunction<
   TName extends EmitterWebhookEventName,
-  TTransformed
+  TTransformed,
 > = (event: EmitterWebhookEvent<TName> & TTransformed) => any;
 
 export type RemoveHandlerFunction<
   TName extends EmitterWebhookEventName | "*",
-  TTransformed
+  TTransformed,
 > = (event: EmitterWebhookEvent<Exclude<TName, "*">> & TTransformed) => any;
 
 type Hooks = {

src/verify-and-receive.ts

@@ -7,22 +7,22 @@ import type {
 
 export async function verifyAndReceive(
   state: State & { secret: string },
-  event: EmitterWebhookEventWithStringPayloadAndSignature
+  event: EmitterWebhookEventWithStringPayloadAndSignature,
 ): Promise<any> {
   // verify will validate that the secret is not undefined
   const matchesSignature = await verify(
     state.secret,
     event.payload,
-    event.signature
+    event.signature,
   );
 
   if (!matchesSignature) {
     const error = new Error(
-      "[@octokit/webhooks] signature does not match event payload and secret"
+      "[@octokit/webhooks] signature does not match event payload and secret",
     );
 
     return state.eventHandler.receive(
-      Object.assign(error, { event, status: 400 })
+      Object.assign(error, { event, status: 400 }),
     );
   }
 

test/integration/event-handler-test.ts

@@ -89,7 +89,7 @@ describe("when a handler throws an error", () => {
 
       expect(errors.length).toBe(1);
       expect((Array.from(error) as { message: string }[])[0].message).toBe(
-        "oops"
+        "oops",
       );
 
       expect(error instanceof Error).toBeTruthy();