improve(integrations/slack): sentry alert on error

packages/web/app/src/lib/fetch-json.ts

@@ -0,0 +1,134 @@
+import { z } from 'zod';
+import { Kit } from './kit';
+
+export async function fetchJson<schema extends undefined | z.ZodType = undefined>(
+  url: string,
+  requestInit?: RequestInit,
+  schema?: schema,
+): Promise<
+  (schema extends z.ZodType ? z.infer<schema> : Kit.Json.Value) | FetchJsonErrors.FetchJsonErrors
+> {
+  const response = await fetch(url, requestInit)
+    // @see https://developer.mozilla.org/en-US/docs/Web/API/Window/fetch#exceptions
+    .catch(Kit.oneOf(error => error instanceof TypeError || error instanceof DOMException));
+
+  if (response instanceof TypeError) {
+    return new FetchJsonErrors.FetchJsonRequestTypeError({ requestInit }, response);
+  }
+
+  if (response instanceof DOMException) {
+    return new FetchJsonErrors.FetchJsonRequestNetworkError({}, response);
+  }
+
+  const json = await response
+    .json()
+    .then(value => value as Kit.Json.Value)
+    // @see https://developer.mozilla.org/en-US/docs/Web/API/Response/json#exceptions
+    .catch(
+      Kit.oneOf(
+        error =>
+          error instanceof SyntaxError ||
+          error instanceof TypeError ||
+          error instanceof DOMException,
+      ),
+    );
+
+  if (json instanceof DOMException) {
+    return new FetchJsonErrors.FetchJsonRequestNetworkError({}, json);
+  }
+
+  if (json instanceof TypeError) {
+    return new FetchJsonErrors.FetchJsonResponseTypeError({ response }, json);
+  }
+
+  if (json instanceof SyntaxError) {
+    return new FetchJsonErrors.FetchJsonResponseSyntaxError({ response }, json);
+  }
+
+  if (schema) {
+    const result = schema.safeParse(json);
+    if (!result.success) {
+      return new FetchJsonErrors.FetchJsonResponseSchemaError(
+        { response, json, schema },
+        result.error,
+      );
+    }
+    return result.data as any; // z.infer<Exclude<schema, undefined>>;
+  }
+
+  return json as any; // Kit.Json.Value;
+}
+
+// =================================
+// Error Classes
+// =================================
+
+// eslint-disable-next-line @typescript-eslint/no-namespace
+export namespace FetchJsonErrors {
+  export type FetchJsonErrors = FetchJsonResponseErrors | FetchJsonRequestErrors;
+
+  // --------------------------------
+  // Response Error Classes
+  // --------------------------------
+
+  export type FetchJsonRequestErrors = FetchJsonRequestTypeError | FetchJsonRequestNetworkError;
+
+  export class FetchJsonRequestNetworkError extends Kit.Errors.ContextualError<
+    'FetchJsonRequestNetworkError',
+    {},
+    DOMException
+  > {
+    message = 'Network failure.';
+  }
+
+  export class FetchJsonRequestTypeError extends Kit.Errors.ContextualError<
+    'FetchJsonRequestTypeError',
+    { requestInit?: RequestInit },
+    TypeError
+  > {
+    message = 'Invalid request.';
+  }
+
+  // --------------------------------
+  // Response Error Classes
+  // --------------------------------
+
+  export abstract class FetchJsonResponseError<
+    $Name extends string,
+    $Context extends {
+      response: Response;
+    },
+    $Cause extends z.ZodError | SyntaxError | TypeError | DOMException,
+  > extends Kit.Errors.ContextualError<$Name, $Context, $Cause> {
+    message = 'Invalid response.';
+  }
+
+  export type FetchJsonResponseErrors =
+    | FetchJsonResponseSyntaxError
+    | FetchJsonResponseSchemaError
+    | FetchJsonResponseTypeError;
+
+  export class FetchJsonResponseTypeError extends FetchJsonResponseError<
+    'FetchJsonResponseTypeError',
+    { response: Response },
+    TypeError
+  > {
+    message = 'Response is malformed.';
+  }
+
+  export class FetchJsonResponseSyntaxError extends FetchJsonResponseError<
+    'FetchJsonResponseSyntaxError',
+    { response: Response },
+    SyntaxError
+  > {
+    message = 'Response body is not valid JSON.';
+  }
+
+  export class FetchJsonResponseSchemaError extends FetchJsonResponseError<
+    'FetchJsonResponseSchemaError',
+    { response: Response; json: Kit.Json.Value; schema: z.ZodType },
+    z.ZodError
+  > {
+    message = 'Response body JSON violates the schema.';
+  }
+}

packages/web/app/src/lib/kit/errors.ts

@@ -0,0 +1,33 @@
+// eslint-disable-next-line @typescript-eslint/no-namespace
+export namespace Errors {
+  export abstract class ContextualError<
+    $Name extends string = string,
+    $Context extends object = object,
+    $Cause extends Error | undefined = Error | undefined,
+  > extends Error {
+    public name: $Name;
+    public context: $Context;
+    public cause: $Cause;
+    constructor(
+      ...args: undefined extends $Cause
+        ? [context: $Context, cause?: $Cause]
+        : [context: $Context, cause: $Cause]
+    ) {
+      const [context, cause] = args;
+      super('Something went wrong.', { cause });
+      this.name = this.constructor.name as $Name;
+      this.context = context;
+      this.cause = cause as $Cause;
+    }
+  }
+
+  export class TypedAggregateError<$Error extends Error> extends AggregateError {
+    constructor(
+      public errors: $Error[],
+      message?: string,
+    ) {
+      super(errors, message);
+      this.name = this.constructor.name;
+    }
+  }
+}

packages/web/app/src/lib/kit/helpers.ts

@@ -8,3 +8,20 @@ export const tryOr = <$PrimaryResult, $FallbackResult>(
     return fallback();
   }
 };
+
+export const oneOf = <type extends readonly unknown[]>(
+  ...guards: OneOfCheck<type>
+): ((value: unknown) => type[number]) => {
+  return (value: unknown) => {
+    for (const guard of guards) {
+      if (guard(value)) {
+        return value;
+      }
+    }
+    throw new Error(`Unexpected value received by oneOf: ${value}`);
+  };
+};
+
+type OneOfCheck<types extends readonly unknown[]> = {
+  [index in keyof types]: (value: unknown) => value is types[index];
+};

packages/web/app/src/lib/kit/index_.ts

@@ -3,3 +3,4 @@ export * from './types/headers';
 export * from './helpers';
 export * from './json';
 export * from './zod-helpers';
+export * from './errors';

packages/web/app/src/lib/slack-api.ts

@@ -0,0 +1,73 @@
+import { stringify } from 'node:querystring';
+import { z } from 'zod';
+import { fetchJson } from './fetch-json';
+
+// eslint-disable-next-line @typescript-eslint/no-namespace
+export namespace SlackAPI {
+  // ==================================
+  // Data Utilities
+  // ==================================
+
+  export const createOauth2AuthorizeUrl = (parameters: {
+    state: string;
+    clientId: string;
+    redirectUrl: string;
+    scopes: string[];
+  }) => {
+    const url = new URL('https://slack.com/oauth/v2/authorize');
+    const searchParams = new URLSearchParams({
+      scope: parameters.scopes.join(','),
+      client_id: parameters.clientId,
+      redirect_uri: parameters.redirectUrl,
+      state: parameters.state,
+    });
+
+    url.search = searchParams.toString();
+    return url.toString();
+  };
+
+  // ==================================
+  // Request Methods
+  // ==================================
+
+  // ----------------------------------
+  // OAuth2AccessResult
+  // ----------------------------------
+
+  const OAuth2AccessResult = z.discriminatedUnion('ok', [
+    z.object({
+      ok: z.literal(true),
+      access_token: z.string(),
+    }),
+    z.object({
+      ok: z.literal(false),
+      error: z.string(),
+    }),
+  ]);
+
+  export type OAuth2AccessResult = z.infer<typeof OAuth2AccessResult>;
+
+  export interface OAuth2AccessPayload {
+    clientId: string;
+    clientSecret: string;
+    code: string;
+  }
+
+  export async function requestOauth2Access(payload: OAuth2AccessPayload) {
+    return fetchJson(
+      'https://slack.com/api/oauth.v2.access',
+      {
+        method: 'POST',
+        headers: {
+          'content-type': 'application/x-www-form-urlencoded',
+        },
+        body: stringify({
+          client_id: payload.clientId,
+          client_secret: payload.clientSecret,
+          code: payload.code,
+        }),
+      },
+      OAuth2AccessResult,
+    );
+  }
+}