oaspect 0.1.0

package/dist/server.js

@@ -0,0 +1,120 @@
+// src/server.js
+var DROPPED_HEADERS = /* @__PURE__ */ new Set([
+  "host",
+  "connection",
+  "content-length",
+  "transfer-encoding",
+  "keep-alive",
+  "upgrade",
+  "accept-encoding"
+]);
+var json = (body, status = 200) => Response.json(body, { status });
+function decodeBase64(data) {
+  const binary = atob(String(data ?? ""));
+  const bytes = new Uint8Array(binary.length);
+  for (let index = 0; index < binary.length; index += 1) bytes[index] = binary.charCodeAt(index);
+  return bytes;
+}
+function formDataFromParts(parts) {
+  const data = new FormData();
+  for (const part of parts) {
+    if (part?.file) {
+      const blob = new Blob([decodeBase64(part.file.data)], { type: part.file.type || "application/octet-stream" });
+      data.append(String(part.name), blob, String(part.file.name || "file"));
+    } else {
+      data.append(String(part?.name), String(part?.value ?? ""));
+    }
+  }
+  return data;
+}
+function normalizeHosts(allowedHosts) {
+  if (allowedHosts === "*") return "*";
+  return (allowedHosts ?? []).map((host) => String(host).trim().toLowerCase()).filter(Boolean);
+}
+function createProxyHandler({ allowedHosts, timeoutMs = 3e4, rewriteHost } = {}) {
+  const hosts = normalizeHosts(allowedHosts);
+  if (hosts !== "*" && hosts.length === 0) {
+    throw new Error('createProxyHandler: allowedHosts must list at least one host (or be "*")');
+  }
+  const allowed = (target) => hosts === "*" || hosts.includes(target.host.toLowerCase()) || hosts.includes(target.hostname.toLowerCase());
+  return async function proxy(request) {
+    if (request.method !== "POST") return json({ error: "Method not allowed." }, 405);
+    let payload;
+    try {
+      payload = await request.json();
+    } catch {
+      return json({ error: "Invalid request body." }, 400);
+    }
+    const { method = "GET", url, headers = {}, body, form } = payload ?? {};
+    let target;
+    try {
+      target = new URL(url);
+    } catch {
+      return json({ error: `Invalid URL: ${url}` }, 400);
+    }
+    if (target.protocol !== "http:" && target.protocol !== "https:") {
+      return json({ error: "Only http and https are supported." }, 400);
+    }
+    if (!allowed(target)) return json({ error: `${target.host} is not an allowed host.` }, 403);
+    if (rewriteHost) target = rewriteHost(new URL(target));
+    const upperMethod = String(method).toUpperCase();
+    const multipart = Array.isArray(form);
+    const forwarded = Object.fromEntries(
+      Object.entries(headers).filter(([key]) => !DROPPED_HEADERS.has(key.toLowerCase()) && !(multipart && key.toLowerCase() === "content-type"))
+    );
+    const started = Date.now();
+    try {
+      const response = await fetch(target, {
+        method: upperMethod,
+        headers: forwarded,
+        body: upperMethod === "GET" || upperMethod === "HEAD" ? void 0 : multipart ? formDataFromParts(form) : body,
+        redirect: "manual",
+        signal: AbortSignal.timeout(timeoutMs)
+      });
+      const text = await response.text();
+      return json({
+        status: response.status,
+        statusText: response.statusText,
+        headers: [...response.headers.entries()],
+        body: text,
+        duration: Date.now() - started
+      });
+    } catch (error) {
+      const code = error.cause?.code ? ` (${error.cause.code})` : "";
+      return json({ error: `Could not reach ${target.origin}: ${error.message}${code}` }, 502);
+    }
+  };
+}
+function createSpecHandler({ url, fallback, cacheSeconds = 60, timeoutMs = 1e4, rewriteHost } = {}) {
+  if (!url && fallback === void 0) throw new Error("createSpecHandler: pass url, fallback or both");
+  let cached = null;
+  const respond = (text, source, contentType) => new Response(text, {
+    headers: {
+      "Content-Type": contentType ?? (text.trimStart().startsWith("{") ? "application/json; charset=utf-8" : "application/yaml; charset=utf-8"),
+      "Cache-Control": `public, max-age=${cacheSeconds}`,
+      "x-oaspect-spec-source": source
+    }
+  });
+  return async function spec() {
+    if (url) {
+      if (cached && Date.now() - cached.at < cacheSeconds * 1e3) return respond(cached.text, "remote", cached.type);
+      try {
+        const target = rewriteHost ? rewriteHost(new URL(url)) : url;
+        const response = await fetch(target, { signal: AbortSignal.timeout(timeoutMs) });
+        if (!response.ok) throw new Error(`HTTP ${response.status}`);
+        const text2 = await response.text();
+        cached = { text: text2, type: response.headers.get("content-type") ?? void 0, at: Date.now() };
+        return respond(text2, "remote", cached.type);
+      } catch (error) {
+        if (fallback === void 0) return json({ error: `Could not load ${url}: ${error.message}` }, 502);
+      }
+    }
+    const text = typeof fallback === "function" ? await fallback() : fallback;
+    return respond(text, url ? "fallback" : "static");
+  };
+}
+export {
+  createProxyHandler,
+  createSpecHandler,
+  formDataFromParts
+};