@peaje/proxy 0.1.1 → 0.2.0

package/dist/vercel.cjs

@@ -52,7 +52,35 @@ var RUTAS_DINAMICAS = [
   { path: "/r/:slug", prefijo: "/r/", nota: "links con precio: el 402 en tu dominio" },
   { path: "/checkout_sessions/:id", prefijo: "/checkout_sessions/", nota: "leer una sesi\xF3n de checkout ACP" }
 ];
+var PREFIJOS_API_POR_DEFECTO = ["/api/", "/v1/"];
+var PATHS_RESERVADOS = [
+  "/",
+  "/login",
+  "/logout",
+  "/signin",
+  "/signout",
+  "/signup",
+  "/sign-in",
+  "/sign-out",
+  "/sign-up",
+  "/register",
+  "/auth",
+  "/oauth",
+  "/session",
+  "/account",
+  "/admin",
+  "/dashboard",
+  "/_next",
+  "/_vercel",
+  "/api/auth",
+  "/static",
+  "/assets",
+  "/favicon.ico",
+  "/robots.txt",
+  "/sitemap.xml"
+];
 var PEAJE_FETCH_HEADER = "x-peaje-fetch";
+var PEAJE_HOST_HEADER = "x-peaje-forwarded-host";
 
 // ../shared/src/kit/proxy-runtime.ts
 var PEAJE_ORIGIN_HEADER = "x-peaje-origin";
@@ -62,6 +90,38 @@ function iguales(a, b) {
   for (let i = 0; i < a.length; i++) d |= a.charCodeAt(i) ^ b.charCodeAt(i);
   return d === 0;
 }
+var HEADERS_NO_REENVIADOS = ["cookie"];
+function esReservado(path) {
+  const canon = pathCanonico(path).toLowerCase();
+  return PATHS_RESERVADOS.some((r) => r === "/" ? canon === "/" : canon === r || canon.startsWith(`${r}/`));
+}
+function prefijosApiValidos(prefijos = PREFIJOS_API_POR_DEFECTO) {
+  const out = [];
+  for (const crudo of prefijos) {
+    const segs = segmentosCanonicos(String(crudo ?? "")).map((s) => s.toLowerCase());
+    if (segs.length === 0) continue;
+    const path = `/${segs.join("/")}`;
+    if (esReservado(path)) continue;
+    if (!out.includes(`${path}/`)) out.push(`${path}/`);
+  }
+  return out;
+}
+function patronPermitido(patron, prefijos) {
+  if (!patronReenviable(patron)) return false;
+  const segs = patron.split("/").filter(Boolean);
+  const literal = (s) => s !== "*" && !s.startsWith(":");
+  const bajoPrefijo = prefijos.some((pre) => {
+    const ps = pre.split("/").filter(Boolean);
+    return segs.length > ps.length && ps.every((s, i) => literal(segs[i]) && segs[i].toLowerCase() === s);
+  });
+  if (!bajoPrefijo) return false;
+  const literales = [];
+  for (const s of segs) {
+    if (!literal(s)) break;
+    literales.push(s);
+  }
+  return !esReservado(`/${literales.join("/")}`);
+}
 function coincidePatron(patron, pathname) {
   const p = patron.split("/").filter(Boolean);
   const parts = segmentosCanonicos(pathname);
@@ -102,43 +162,43 @@ function crearProxyRuntime(opciones) {
   const base = opciones.base.replace(/\/+$/, "");
   const ttl = opciones.ttlMs ?? 6e4;
   const fetchImpl = opciones.fetchImpl ?? fetch;
-  let cache = {
-    at: 0,
-    rutas: opciones.respaldo?.rutas ?? [],
-    prefijos: opciones.respaldo?.prefijos ?? [],
-    patrones: opciones.respaldo?.patrones ?? []
-  };
+  const rutas = [...opciones.fijas?.rutas ?? RUTAS_PROXY.map((r) => r.path)];
+  const prefijos = [...opciones.fijas?.prefijos ?? RUTAS_DINAMICAS.map((r) => r.prefijo)];
+  const prefijosApi = prefijosApiValidos(opciones.prefijosApi ?? PREFIJOS_API_POR_DEFECTO);
+  let cache = { at: 0, patrones: [] };
   let refrescando = null;
   async function refrescar() {
     try {
       const res = await fetchImpl(`${base}/kit/manifest.json`, { signal: AbortSignal.timeout(5e3) });
       if (!res.ok) throw new Error(String(res.status));
       const m = await res.json();
-      cache = {
-        at: Date.now(),
-        rutas: Array.isArray(m.rutas) ? m.rutas : cache.rutas,
-        prefijos: Array.isArray(m.prefijos) ? m.prefijos : cache.prefijos,
-        patrones: Array.isArray(m.patrones) ? m.patrones : cache.patrones
-      };
+      const patrones2 = Array.isArray(m.patrones) ? m.patrones.filter((p) => typeof p?.method === "string" && typeof p?.path === "string") : cache.patrones;
+      cache = { at: Date.now(), patrones: patrones2 };
     } catch {
       cache = { ...cache, at: Date.now() };
     } finally {
       refrescando = null;
     }
   }
-  async function listas() {
+  async function patrones() {
     const vencido = Date.now() - cache.at >= ttl;
     if (vencido) {
       refrescando ??= refrescar();
       if (cache.at === 0) await refrescando;
     }
-    return cache;
+    return cache.patrones;
   }
   return {
+    /** Los prefijos de API efectivos, normalizados (para los avisos). */
+    prefijosApi,
     /** Rutas de API con precio que este sitio no puede cobrar por falta de secreto. */
     async sinSecreto() {
       if (opciones.secreto) return [];
-      return (await listas()).patrones.filter((p) => patronReenviable(p.path));
+      return (await patrones()).filter((p) => patronPermitido(p.path, prefijosApi));
+    },
+    /** Rutas de API con precio que no se reenvían por caer fuera de `prefijosApi` o en un path reservado. */
+    async fueraDePrefijos() {
+      return (await patrones()).filter((p) => patronReenviable(p.path) && !patronPermitido(p.path, prefijosApi));
     },
     /** Fuerza la carga del manifiesto (útil al arrancar o en tests). */
     cargar: () => refrescando ??= refrescar(),
@@ -150,14 +210,18 @@ function crearProxyRuntime(opciones) {
       const secreto = opciones.secreto || null;
       const prueba = input.headers.get(PEAJE_ORIGIN_HEADER);
       if (secreto && prueba && iguales(prueba, secreto)) return null;
-      const { rutas, prefijos, patrones } = await listas();
       const path = input.pathname;
       const canon = pathCanonico(path).toLowerCase();
       const esFetchDePeaje = input.headers.get(PEAJE_FETCH_HEADER) !== null;
       const fija = (rutas.includes(path) || rutas.some((r) => r.toLowerCase() === canon)) && !(canon === "/llms.txt" && esFetchDePeaje);
       const prefijo = prefijos.some((p) => path.startsWith(p) || canon.startsWith(p.toLowerCase()));
-      const method = input.method.toUpperCase();
-      const patron = secreto !== null && patrones.some((p) => p.method.toUpperCase() === method && patronReenviable(p.path) && coincidePatron(p.path, path));
+      let patron = false;
+      if (!fija && !prefijo && secreto !== null && !esReservado(path) && prefijosApi.some((pre) => canon.startsWith(pre))) {
+        const method = input.method.toUpperCase();
+        patron = (await patrones()).some(
+          (p) => p.method.toUpperCase() === method && patronPermitido(p.path, prefijosApi) && coincidePatron(p.path, path)
+        );
+      }
       if (!fija && !prefijo && !patron) return null;
       return { destino: `${base}${path}${input.search ?? ""}` };
     }
@@ -302,29 +366,36 @@ function baseDe({ slug, gateway }) {
 }
 var SALTO = ["host", "connection", "keep-alive", "proxy-connection", "transfer-encoding", "upgrade", "te", "trailer", "content-length"];
 var avisado = false;
+function avisar(runtime, conSecreto) {
+  if (!conSecreto) {
+    void runtime.sinSecreto().then((faltan) => {
+      if (faltan.length > 0) {
+        console.warn(
+          `[peaje] ${faltan.length} priced API route(s) are not charged on this domain because PEAJE_ORIGIN_SECRET is not set: ${faltan.map((p) => `${p.method} ${p.path}`).join(", ")}. Copy it from the Kit page of your Peaje dashboard into your hosting environment variables.`
+        );
+      }
+    });
+  }
+  void runtime.fueraDePrefijos().then((fuera) => {
+    if (fuera.length > 0) {
+      console.warn(
+        `[peaje] ${fuera.length} priced API route(s) are outside apiPrefixes (${runtime.prefijosApi.join(", ") || "none"}) or on a reserved path, so they are charged only at the gateway URL, not on this domain: ${fuera.map((p) => `${p.method} ${p.path}`).join(", ")}. A route under a prefix of its own (/weather/:city) is charged here once that prefix is in the apiPrefixes option; a single path at the root or a reserved path never is.`
+      );
+    }
+  });
+}
 function crearPeaje(opciones) {
   if (!opciones?.slug) throw new Error("@peaje/proxy: `slug` is required (the business slug from your Peaje dashboard).");
   const base = baseDe(opciones);
   const secreto = opciones.secret ?? env("PEAJE_ORIGIN_SECRET") ?? null;
   const fetchImpl = opciones.fetch ?? ((...a) => fetch(...a));
-  const runtime = crearProxyRuntime({
-    base,
-    secreto,
-    fetchImpl,
-    respaldo: { rutas: RUTAS_PROXY.map((x) => x.path), prefijos: RUTAS_DINAMICAS.map((x) => x.prefijo), patrones: [] }
-  });
+  const runtime = crearProxyRuntime({ base, secreto, fetchImpl, prefijosApi: opciones.apiPrefixes ?? PREFIJOS_API_POR_DEFECTO });
   return {
     base,
     async decidir({ method, url, headers }) {
-      if (!secreto && !avisado) {
+      if (!avisado) {
         avisado = true;
-        void runtime.sinSecreto().then((faltan) => {
-          if (faltan.length > 0) {
-            console.warn(
-              `[peaje] ${faltan.length} priced API route(s) are not charged on this domain because PEAJE_ORIGIN_SECRET is not set: ${faltan.map((p) => `${p.method} ${p.path}`).join(", ")}. Copy it from the Kit page of your Peaje dashboard into your hosting environment variables.`
-            );
-          }
-        });
+        avisar(runtime, Boolean(secreto));
       }
       const d = await runtime.decidir({ method, pathname: url.pathname, search: url.search, headers });
       return d?.destino ?? null;
@@ -332,8 +403,11 @@ function crearPeaje(opciones) {
     async reenviar(destino, { method, url, headers, body }) {
       const salida = new Headers(headers);
       for (const h of SALTO) salida.delete(h);
+      for (const h of HEADERS_NO_REENVIADOS) salida.delete(h);
       const primero = (h) => headers.get(h)?.split(",")[0]?.trim() || null;
-      salida.set("x-forwarded-host", primero("x-forwarded-host") ?? url.host);
+      const host = primero("x-forwarded-host") ?? url.host;
+      salida.set("x-forwarded-host", host);
+      salida.set(PEAJE_HOST_HEADER, host);
       salida.set("x-forwarded-proto", primero("x-forwarded-proto") ?? url.protocol.replace(":", ""));
       const sinBody = method === "GET" || method === "HEAD";
       const res = await fetchImpl(destino, { method, headers: salida, body: sinBody ? null : body, redirect: "manual" });
@@ -368,7 +442,9 @@ function peajeVercel(opciones, siguiente) {
     const destino = await peaje.decidir(entrada);
     if (destino) {
       const headers = new Headers(request.headers);
+      for (const h of HEADERS_NO_REENVIADOS) headers.delete(h);
       headers.set("x-forwarded-host", url.host);
+      headers.set(PEAJE_HOST_HEADER, url.host);
       headers.set("x-forwarded-proto", url.protocol.replace(":", ""));
       return respuestaMiddleware({ "x-middleware-rewrite": destino }, headers);
     }

package/dist/vercel.d.cts

@@ -1,23 +1,5 @@
 import { OpcionesPeaje } from './index.cjs';
 
-/**
- * `@peaje/proxy/vercel`: Routing Middleware de Vercel para proyectos que no
- * son Next (Vite, SPA estática, Remix, SvelteKit en Vercel). Va en
- * `middleware.ts` en la raíz, al lado de `package.json`:
- *
- *   import peaje from '@peaje/proxy/vercel'
- *   export default peaje({ slug: 'mi-negocio' })
- *   export const config = { matcher: ['/((?!assets/|favicon.ico).*)'] }
- *
- * Responde con el mismo contrato de headers que `rewrite()` y `next()` de
- * `@vercel/functions` (y antes `@vercel/edge`, y `NextResponse` en Next):
- * `x-middleware-rewrite` con el destino, `x-middleware-next` para seguir, y
- * `x-middleware-override-headers` + `x-middleware-request-<nombre>` para
- * cambiar los headers de la request. Así no hace falta instalar nada más: la
- * request no pasa por la función, Vercel la reescribe al gateway (método,
- * body y query intactos). Con un middleware propio: `peaje({ slug }, tuyo)`.
- */
-
 type Contexto = {
     waitUntil(promesa: Promise<unknown>): void;
 };

package/dist/vercel.d.ts

@@ -1,23 +1,5 @@
 import { OpcionesPeaje } from './index.js';
 
-/**
- * `@peaje/proxy/vercel`: Routing Middleware de Vercel para proyectos que no
- * son Next (Vite, SPA estática, Remix, SvelteKit en Vercel). Va en
- * `middleware.ts` en la raíz, al lado de `package.json`:
- *
- *   import peaje from '@peaje/proxy/vercel'
- *   export default peaje({ slug: 'mi-negocio' })
- *   export const config = { matcher: ['/((?!assets/|favicon.ico).*)'] }
- *
- * Responde con el mismo contrato de headers que `rewrite()` y `next()` de
- * `@vercel/functions` (y antes `@vercel/edge`, y `NextResponse` en Next):
- * `x-middleware-rewrite` con el destino, `x-middleware-next` para seguir, y
- * `x-middleware-override-headers` + `x-middleware-request-<nombre>` para
- * cambiar los headers de la request. Así no hace falta instalar nada más: la
- * request no pasa por la función, Vercel la reescribe al gateway (método,
- * body y query intactos). Con un middleware propio: `peaje({ slug }, tuyo)`.
- */
-
 type Contexto = {
     waitUntil(promesa: Promise<unknown>): void;
 };

package/dist/vercel.js

@@ -1,6 +1,8 @@
 import {
+  HEADERS_NO_REENVIADOS,
+  PEAJE_HOST_HEADER,
   crearPeaje
-} from "./chunk-6ADZXHC7.js";
+} from "./chunk-QHUY5N5S.js";
 
 // src/vercel.ts
 function respuestaMiddleware(control, requestHeaders) {
@@ -23,7 +25,9 @@ function peajeVercel(opciones, siguiente) {
     const destino = await peaje.decidir(entrada);
     if (destino) {
       const headers = new Headers(request.headers);
+      for (const h of HEADERS_NO_REENVIADOS) headers.delete(h);
       headers.set("x-forwarded-host", url.host);
+      headers.set(PEAJE_HOST_HEADER, url.host);
       headers.set("x-forwarded-proto", url.protocol.replace(":", ""));
       return respuestaMiddleware({ "x-middleware-rewrite": destino }, headers);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peaje/proxy",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Peaje for any server: answer HTTP 402 (MPP, x402) for your priced API routes on your own domain. Fetch handler plus Express, Hono and Vercel Routing Middleware adapters.",
   "license": "MIT",
   "repository": {
@@ -8,10 +8,13 @@
     "url": "git+https://github.com/sandragcarrillo/peaje.git",
     "directory": "packages/peaje-proxy"
   },
+  "homepage": "https://github.com/sandragcarrillo/peaje/tree/main/packages/peaje-proxy#readme",
+  "bugs": "https://github.com/sandragcarrillo/peaje/issues",
   "type": "module",
   "sideEffects": false,
   "files": [
-    "dist"
+    "dist",
+    "LICENSE"
   ],
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",