Skip to content

armgit / papra

Public Imported from GitHub
0

The minimalistic document archiving platform.

3.6 KB
Raw Blame
import type { ApiContract } from './api.contracts';
import type { ApiContextResolver, ApiHandlerInput } from './api.routes';
import type { ApiResponse } from './responses/responses.types';
import { addRoute, createRouter, findRoute } from 'rou3';
import { parseBody } from './requests/parsers/body.parser';
import { parseParams } from './requests/parsers/params.parser';
import { parseQuery } from './requests/parsers/query.parser';
import { apiErrorResponse, internalServerErrorResponse } from './responses/responses';
import { serializeApiResponse } from './responses/serialize/responses.serialize';
import { isCustomError } from '../shared/errors/errors';
import type { Logger } from '../shared/logger/logger';
import { createLogger } from '../shared/logger/logger';

// Heterogeneous routes erase their input types only inside the dispatcher. A handler
// cannot be called until its own contract has validated the request.
type RegisteredApiRoute = {
  contract: ApiContract;
  resolveContext?: ApiContextResolver;
  handler: (input: never) => Promise<ApiResponse>;
};

export function buildApiRequestHandler({
  routes,
  logger = createLogger({ namespace: 'api' }),
}: {
  routes: RegisteredApiRoute[];
  logger?: Logger;
}) {
  const router = createRouter<RegisteredApiRoute>();

  for (const route of routes) {
    addRoute(router, route.contract.method, route.contract.path, route);
  }

  const handleRequest = async ({
    request,
  }: {
    request: Request;
  }): Promise<Response | undefined> => {
    const url = new URL(request.url);
    const method = request.method.toUpperCase();
    const routeMatch =
      findRoute(router, method, url.pathname) ??
      (method === 'HEAD' ? findRoute(router, 'GET', url.pathname) : undefined);

    if (!routeMatch) {
      // Let the caller handle unmatched requests without consuming their body.
      return undefined;
    }

    try {
      const {
        data: { handler, contract, resolveContext },
        params,
      } = routeMatch;

      const context = await resolveContext?.({ request });

      const paramsResult = parseParams({ params, schema: contract.request?.params });

      if (!paramsResult.success) {
        return paramsResult.response;
      }

      const queryResult = parseQuery({ url, schema: contract.request?.query });

      if (!queryResult.success) {
        return queryResult.response;
      }

      const bodyResult = await parseBody({ request, bodySchemas: contract.request?.body });

      if (!bodyResult.success) {
        return bodyResult.response;
      }

      const validatedHandler = handler as (
        input: ApiHandlerInput<ApiContract, unknown>,
      ) => Promise<ApiResponse>;
      const handlerResult = await validatedHandler({
        body: bodyResult.body,
        query: queryResult.query,
        params: paramsResult.params,
        request,
        context,
      });

      return serializeApiResponse({
        handlerResult,
        responseDefinitions: contract.responses,
        method: contract.method,
      });
    } catch (error) {
      logger.error({ error }, error instanceof Error ? error.message : 'An error occurred');

      if (isCustomError(error) && !error.isInternal) {
        return apiErrorResponse({
          status: error.statusCode,
          message: error.message,
          code: error.code,
        });
      }

      return internalServerErrorResponse();
    }
  };

  return async ({ request }: { request: Request }): Promise<Response | undefined> => {
    const response = await handleRequest({ request });

    if (request.method.toUpperCase() === 'HEAD' && response !== undefined) {
      return new Response(null, response);
    }

    return response;
  };
}