import { type ClienteApi, crearClienteApi } from "../api/cliente";
/** Lo que guarda la API falsa bajo `ruta`: los DTO de la API, por id. */
export interface Coleccion<T extends { id: string }> {
ruta: string;
/** El código que responde un elemento que no está: `producto.no_encontrado`. */
noEncontrado: string;
elementos: Map<string, T>;
}
/** Los elementos bajo `ruta` (`/productos`) de `entidad` (`producto`), empezando por `semilla`. */
export function coleccion<T extends { id: string }>(
ruta: string,
entidad: string,
semilla: T[] = [],
): Coleccion<T> {
const elementos = new Map(semilla.map((elemento) => [elemento.id, elemento]));
return { ruta, noEncontrado: `${entidad}.no_encontrado`, elementos };
}
/**
* Un `ClienteApi` que responde como la API generada, sobre colecciones en memoria: una página por
* `limite` / `desplazamiento`, un `404` con `<entidad>.no_encontrado`, `201`, `200` y `204`. Cada
* uno de `fallos` (`{ "POST /productos": "producto.duplicado" }`) responde su código en su lugar.
*/
export function apiFalsa(
colecciones: Coleccion<{ id: string }>[],
fallos: Record<string, string> = {},
): ClienteApi {
return crearClienteApi({
baseUrl: "http://localhost/api",
fetch: async (peticion) => {
const url = new URL(peticion.url);
const ruta = url.pathname.replace(/^\/api/, "");
const objetivo = colecciones.find((c) => ruta === c.ruta || ruta.startsWith(`${c.ruta}/`));
if (objetivo === undefined) return responderError(404, "http.404");
const fallo = fallos[`${peticion.method} ${objetivo.ruta}`];
if (fallo !== undefined) return responderError(400, fallo);
const id = ruta.slice(objetivo.ruta.length + 1);
return id === ""
? servirLista(objetivo, peticion, url)
: servirElemento(objetivo, peticion, id);
},
});
}
async function servirLista(objetivo: Coleccion<{ id: string }>, peticion: Request, url: URL) {
if (peticion.method === "POST") {
const creado = { ...(await peticion.json()), id: crypto.randomUUID() };
objetivo.elementos.set(creado.id, creado);
return Response.json(creado, { status: 201 });
}
const limite = Number(url.searchParams.get("limite") ?? 20);
const desplazamiento = Number(url.searchParams.get("desplazamiento") ?? 0);
const todos = [...objetivo.elementos.values()];
const elementos = todos.slice(desplazamiento, desplazamiento + limite);
return Response.json({ elementos, total: todos.length, limite, desplazamiento });
}
async function servirElemento(objetivo: Coleccion<{ id: string }>, peticion: Request, id: string) {
const encontrado = objetivo.elementos.get(id);
if (encontrado === undefined) return responderError(404, objetivo.noEncontrado);
if (peticion.method === "DELETE") {
objetivo.elementos.delete(id);
return new Response(null, { status: 204 });
}
if (peticion.method === "PUT") {
// Como la API, actualizar reemplaza todos los campos: el que no se manda queda vacío.
const actualizado = { ...(await peticion.json()), id };
objetivo.elementos.set(id, actualizado);
return Response.json(actualizado);
}
return Response.json(encontrado);
}
/** Un `RespuestaError` como lo responde la API. */
function responderError(estado: number, codigo: string) {
return Response.json({ codigo, mensaje: codigo }, { status: estado });
}