@cequrebackends/cequre-ts 0.11.4

package/dist/index-mfqj7cwr.js

@@ -0,0 +1,165 @@
+// @bun
+// adapters/bun/bun-response.ts
+var UPGRADED = Symbol("cequre.bun.upgraded");
+var JSON_CONTENT_TYPE = "application/json";
+var DEFAULT_JSON_HEADERS = { "Content-Type": JSON_CONTENT_TYPE };
+function mergeHeaders(init, headers) {
+  const merged = new Headers(init?.headers);
+  if (headers) {
+    for (const [key, value] of new Headers(headers)) {
+      merged.set(key, value);
+    }
+  }
+  return merged;
+}
+function json(data, init = {}) {
+  if (!init.headers && init.status === undefined && init.statusText === undefined) {
+    return new Response(JSON.stringify(data), { headers: DEFAULT_JSON_HEADERS });
+  }
+  const headers = mergeHeaders(init, { "Content-Type": JSON_CONTENT_TYPE });
+  return new Response(JSON.stringify(data), { ...init, headers });
+}
+function empty(status = 204, init = {}) {
+  return new Response(null, { ...init, status });
+}
+function redirect(location, status = 302, init = {}) {
+  const headers = mergeHeaders(init, { Location: location });
+  return new Response(null, { ...init, status, headers });
+}
+function error(message, status = 500, code = "INTERNAL_ERROR", init = {}) {
+  return json({
+    error: code,
+    message
+  }, { ...init, status });
+}
+function notFound(message = "Not found") {
+  return error(message, 404, "NOT_FOUND");
+}
+function methodNotAllowed(allowedMethods) {
+  return error("Method not allowed", 405, "METHOD_NOT_ALLOWED", {
+    headers: { Allow: allowedMethods.join(", ") }
+  });
+}
+function file(file2, init = {}) {
+  if (typeof file2 === "string") {
+    return new Response(Bun.file(file2), init);
+  }
+  if (file2 instanceof Uint8Array) {
+    return new Response(new Uint8Array(file2).buffer, init);
+  }
+  return new Response(file2, init);
+}
+function stream(data, init = {}) {
+  if (data instanceof ReadableStream) {
+    const headers2 = mergeHeaders(init, { "Content-Type": "text/plain" });
+    return new Response(data, { ...init, headers: headers2 });
+  }
+  const iterator = Symbol.asyncIterator in data ? data[Symbol.asyncIterator]() : data[Symbol.iterator]();
+  const encoder = new TextEncoder;
+  const readable = new ReadableStream({
+    async pull(controller) {
+      try {
+        const { value, done } = await iterator.next();
+        if (done) {
+          controller.close();
+        } else {
+          let chunk = value;
+          if (typeof chunk !== "string" && !(chunk instanceof Uint8Array)) {
+            chunk = JSON.stringify(chunk) + `
+`;
+          }
+          if (typeof chunk === "string") {
+            chunk = encoder.encode(chunk);
+          }
+          controller.enqueue(chunk);
+        }
+      } catch (err) {
+        if (typeof iterator.return === "function") {
+          try {
+            await iterator.return();
+          } catch {}
+        }
+        controller.error(err);
+      }
+    },
+    cancel() {
+      if (typeof iterator.return === "function") {
+        iterator.return();
+      }
+    }
+  });
+  const headers = mergeHeaders(init, { "Content-Type": "text/plain" });
+  return new Response(readable, { ...init, headers });
+}
+function toResponse(result) {
+  if (result === UPGRADED)
+    return;
+  if (result instanceof Response)
+    return result;
+  if (result === undefined)
+    return empty();
+  if (typeof result === "string")
+    return new Response(result);
+  if (result !== null && typeof result === "object") {
+    if (typeof result.next === "function" && ((Symbol.asyncIterator in result) || (Symbol.iterator in result))) {
+      return stream(result);
+    }
+  }
+  return json(result);
+}
+function routeErrorToResponse(errorValue, request) {
+  console.error("Cequre Unhandled Route Error:", errorValue);
+  const message = errorValue instanceof Error ? errorValue.message : String(errorValue);
+  return error(message, 500, "INTERNAL_ERROR", {
+    headers: request ? { "X-Cequre-Path": new URL(request.url).pathname } : undefined
+  });
+}
+
+// adapters/bun/bun-media.ts
+function CequreStreamMedia(request, absolutePathOrUrl, options = {}) {
+  const provider = options.provider || "local";
+  if (provider === "s3") {
+    return new Response(null, {
+      status: 302,
+      headers: {
+        Location: absolutePathOrUrl
+      }
+    });
+  }
+  const file2 = Bun.file(absolutePathOrUrl);
+  const rangeHeader = request.headers.get("Range");
+  const maxChunkSize = options.maxChunkSize || 1024 * 1024 * 2;
+  if (!rangeHeader) {
+    return new Response(file2);
+  }
+  const parts = rangeHeader.replace(/bytes=/, "").split("-");
+  const reqStart = parseInt(parts[0], 10);
+  const reqEnd = parts[1] ? parseInt(parts[1], 10) : file2.size - 1;
+  if (isNaN(reqStart) || reqStart >= file2.size) {
+    return new Response("Requested range not satisfiable", {
+      status: 416,
+      headers: {
+        "Content-Range": `bytes */${file2.size}`
+      }
+    });
+  }
+  let end = reqEnd;
+  if (end - reqStart + 1 > maxChunkSize) {
+    end = reqStart + maxChunkSize - 1;
+  }
+  if (end >= file2.size) {
+    end = file2.size - 1;
+  }
+  const chunk = file2.slice(reqStart, end + 1);
+  return new Response(chunk, {
+    status: 206,
+    headers: {
+      "Content-Range": `bytes ${reqStart}-${end}/${file2.size}`,
+      "Accept-Ranges": "bytes",
+      "Content-Length": chunk.size.toString(),
+      "Content-Type": file2.type || "application/octet-stream"
+    }
+  });
+}
+
+export { UPGRADED, json, empty, redirect, error, notFound, methodNotAllowed, file, stream, toResponse, routeErrorToResponse, CequreStreamMedia };