Function parseRequest

apps/sim/lib/api/server/validation.ts:232–282

(
  contract: C,
  request: NextRequest,
  context: TContext,
  options?: ParseRequestOptions
)

}

export async function parseRequest<C extends AnyApiRouteContract, TContext>(
  contract: C,
  request: NextRequest,
  context: TContext,
  options?: ParseRequestOptions
): Promise<
  { success: true; data: ParsedRequest<C> } | { success: false; response: NextResponse<unknown> }
> {
  const rawParams = await parseContextParams(context)
  const rawQuery = searchParamsToObject(request.nextUrl.searchParams)
  const rawHeaders = headersToObject(request.headers)

  let body: unknown
  if (shouldReadJsonBody(contract)) {
    const parsedBody = await parseJsonBody(request, options?.invalidJson, options?.maxBodyBytes)
    if (!parsedBody.success) {
      return options?.invalidJsonResponse && parsedBody.reason === 'invalid_json'
        ? { success: false, response: options.invalidJsonResponse() }
        : parsedBody
    }
    body = parsedBody.data
  }

  const params = contract.params
    ? validateRequestSchema(contract.params, rawParams, options)
    : undefined
  if (params && !params.success) return params

  const query = contract.query
    ? validateRequestSchema(contract.query, rawQuery, options)
    : undefined
  if (query && !query.success) return query

  const headers = contract.headers
    ? validateRequestSchema(contract.headers, rawHeaders, options)
    : undefined
  if (headers && !headers.success) return headers

  const parsedBody = contract.body ? validateRequestSchema(contract.body, body, options) : undefined
  if (parsedBody && !parsedBody.success) return parsedBody

  return {
    success: true,
    data: {
      params: params?.data as ContractParams<C>,
      query: query?.data as ContractQuery<C>,
      headers: headers?.data as ContractHeaders<C>,
      body: parsedBody?.data as ContractBody<C>,
    },
  }
}

function validateRequestSchema<S extends ApiSchema>(
  schema: S,