gemi 0.42.1 → 0.43.0

package/dist/app/index.js

@@ -1,4 +1,4 @@
 // @bun
-import{o as a,p as b}from"../chunk-gsvzrj5r.js";import"../chunk-pjgfvdr6.js";import"../chunk-yeqwzeq7.js";import"../chunk-sbmg0hfr.js";import"../chunk-b3qebxqh.js";import"../chunk-n1xpxhm0.js";import"../chunk-bfnh3gwv.js";import"../chunk-cwq1vdcb.js";export{b as prismaExtension,a as App};
+import{o as a,p as b}from"../chunk-m359awjw.js";import"../chunk-q8haepmm.js";import"../chunk-fk9xtngd.js";import"../chunk-ty3q916e.js";import"../chunk-9r2k5ykk.js";import"../chunk-whj1a3vr.js";import"../chunk-sdx8r2qb.js";import"../chunk-6gtmkbh0.js";export{b as prismaExtension,a as App};
 
 //# debugId=15EBDBCE0B2D702364756E2164756E21

package/dist/bin/gemi.js

@@ -14098,7 +14098,7 @@ var require_util = __commonJS((exports) => {
     return url;
   }
   exports.urlGenerate = urlGenerate;
-  function normalize(aPath) {
+  function normalize2(aPath) {
     var path2 = aPath;
     var url = urlParse(aPath);
     if (url) {
@@ -14135,7 +14135,7 @@ var require_util = __commonJS((exports) => {
     }
     return path2;
   }
-  exports.normalize = normalize;
+  exports.normalize = normalize2;
   function join2(aRoot, aPath) {
     if (aRoot === "") {
       aRoot = ".";
@@ -14161,7 +14161,7 @@ var require_util = __commonJS((exports) => {
       aRootUrl.host = aPath;
       return urlGenerate(aRootUrl);
     }
-    var joined = aPath.charAt(0) === "/" ? aPath : normalize(aRoot.replace(/\/+$/, "") + "/" + aPath);
+    var joined = aPath.charAt(0) === "/" ? aPath : normalize2(aRoot.replace(/\/+$/, "") + "/" + aPath);
     if (aRootUrl) {
       aRootUrl.path = joined;
       return urlGenerate(aRootUrl);
@@ -14343,7 +14343,7 @@ var require_util = __commonJS((exports) => {
       }
       sourceURL = join2(urlGenerate(parsed), sourceURL);
     }
-    return normalize(sourceURL);
+    return normalize2(sourceURL);
   }
   exports.computeSourceURL = computeSourceURL;
 });
@@ -22105,7 +22105,7 @@ var require_options = __commonJS((exports) => {
     tokens: true
   };
   var hasOwn = defaults.hasOwnProperty;
-  function normalize(opts) {
+  function normalize2(opts) {
     var options = opts || defaults;
     function get(key) {
       return hasOwn.call(options, key) ? options[key] : defaults[key];
@@ -22132,7 +22132,7 @@ var require_options = __commonJS((exports) => {
       tokens: !!get("tokens")
     };
   }
-  exports.normalize = normalize;
+  exports.normalize = normalize2;
 });
 
 // ../../node_modules/.bun/recast@0.23.11/node_modules/recast/lib/mapping.js
@@ -49979,6 +49979,85 @@ class Controller {
   constructor() {}
 }
 
+// http/range.ts
+function parseInteger(raw) {
+  if (!/^\d+$/.test(raw)) {
+    return null;
+  }
+  const value = Number(raw);
+  return Number.isSafeInteger(value) ? value : null;
+}
+function parseRangeHeader(header) {
+  if (!header) {
+    return null;
+  }
+  const trimmed = header.trim();
+  if (!/^bytes=/i.test(trimmed)) {
+    return null;
+  }
+  const specs = trimmed.slice("bytes=".length).split(",").map((spec2) => spec2.trim());
+  const present = specs.filter((spec2) => spec2 !== "");
+  if (present.length !== 1) {
+    return null;
+  }
+  const spec = present[0];
+  const separator = spec.indexOf("-");
+  if (separator === -1) {
+    return null;
+  }
+  const rawStart = spec.slice(0, separator);
+  const rawEnd = spec.slice(separator + 1);
+  if (rawStart === "") {
+    const suffixLength = parseInteger(rawEnd);
+    if (suffixLength === null) {
+      return null;
+    }
+    return { kind: "suffix", suffixLength };
+  }
+  const start = parseInteger(rawStart);
+  if (start === null) {
+    return null;
+  }
+  if (rawEnd === "") {
+    return { kind: "offset", start, end: null };
+  }
+  const end = parseInteger(rawEnd);
+  if (end === null || end < start) {
+    return null;
+  }
+  return { kind: "offset", start, end };
+}
+function resolveRange(range, total) {
+  if (!Number.isFinite(total) || total <= 0) {
+    return null;
+  }
+  let start;
+  let end;
+  if (range.kind === "suffix") {
+    if (range.suffixLength <= 0) {
+      return null;
+    }
+    start = Math.max(0, total - range.suffixLength);
+    end = total - 1;
+  } else {
+    if (range.start >= total) {
+      return null;
+    }
+    start = range.start;
+    end = range.end === null ? total - 1 : Math.min(range.end, total - 1);
+    if (end < start) {
+      return null;
+    }
+  }
+  return { start, end, length: end - start + 1 };
+}
+function formatContentRange(start, end, total) {
+  return `bytes ${start}-${end}/${total}`;
+}
+function formatUnsatisfiedContentRange(total) {
+  return `bytes */${total}`;
+}
+
 // http/requestContext.ts
 import { AsyncLocalStorage } from "async_hooks";
 
@@ -50065,6 +50144,7 @@ class Store {
   csrfHmac = null;
   locale = null;
   metadata = new Metadata;
+  rangeRequest = null;
   constructor(req) {
     this.req = req;
   }
@@ -50325,6 +50405,9 @@ class HttpRequest {
   ctx() {
     return RequestContext.getStore();
   }
+  range() {
+    return parseRangeHeader(this.rawRequest.headers.get("Range"));
+  }
   refine(_input) {
     return {};
   }
@@ -50428,6 +50511,214 @@ function isConstructor(value) {
   return typeof value === "function" && value.prototype !== undefined;
 }
 
+// http/contentDisposition.ts
+function contentDisposition(name, download) {
+  const kind = download ? "attachment" : "inline";
+  const fallback = name.replace(/["\\]/g, "").replace(/[^\x20-\x7e]/g, "_");
+  return `${kind}; filename="${fallback}"; filename*=UTF-8''${encodeURIComponent(name)}`;
+}
+
+// http/createStreamResponse.ts
+function isReadResult(output) {
+  return "total" in output && "partial" in output && "body" in output;
+}
+function createUnsatisfiableResponse(total) {
+  return new Response(null, {
+    status: 416,
+    headers: {
+      "Accept-Ranges": "bytes",
+      "Content-Range": formatUnsatisfiedContentRange(total),
+      "Content-Length": "0",
+      "Cache-Control": "no-store"
+    }
+  });
+}
+async function normalize(output) {
+  if (output instanceof Blob) {
+    return {
+      body: output,
+      start: 0,
+      end: output.size - 1,
+      total: output.size,
+      partial: false,
+      type: output.type,
+      name: output.name,
+      download: false,
+      status: 200,
+      extraHeaders: {}
+    };
+  }
+  if (isReadResult(output)) {
+    return {
+      body: output.body,
+      start: output.start,
+      end: output.end,
+      total: output.total,
+      partial: output.partial,
+      type: output.type,
+      name: output.name,
+      download: false,
+      etag: output.etag,
+      lastModified: output.lastModified,
+      status: 200,
+      extraHeaders: {}
+    };
+  }
+  const body = output.file;
+  const blob = body instanceof Blob ? body : null;
+  const total = output.total ?? blob?.size ?? -1;
+  return {
+    body,
+    start: output.start ?? 0,
+    end: output.end ?? total - 1,
+    total,
+    partial: output.partial ?? false,
+    type: output.type ?? blob?.type ?? "",
+    name: output.name ?? body?.name,
+    download: output.download ?? false,
+    etag: output.etag,
+    lastModified: output.lastModified,
+    status: output.status ?? 200,
+    extraHeaders: output.headers ?? {}
+  };
+}
+async function createStreamResponse(output, options) {
+  if (output instanceof Response) {
+    return output;
+  }
+  if (!output) {
+    return new Response("Not found", { status: 404 });
+  }
+  const normalized = await normalize(output);
+  let { body, start, end, total, partial } = normalized;
+  if (body instanceof Blob && "exists" in body && typeof body.exists === "function") {
+    if (!await body.exists()) {
+      return new Response("Not found", { status: 404 });
+    }
+  }
+  const { range } = options;
+  if (range) {
+    if (total <= 0) {
+      return createUnsatisfiableResponse(Math.max(total, 0));
+    }
+    if (!partial) {
+      if (body instanceof Blob) {
+        const resolved = resolveRange(range, total);
+        if (!resolved) {
+          return createUnsatisfiableResponse(total);
+        }
+        body = body.slice(resolved.start, resolved.end + 1);
+        start = resolved.start;
+        end = resolved.end;
+        partial = true;
+      }
+    }
+  }
+  const isPartial = Boolean(range) && partial;
+  const status = isPartial ? 206 : normalized.status;
+  const headers = new Headers;
+  headers.set("Accept-Ranges", "bytes");
+  headers.set("Content-Type", normalized.type || "application/octet-stream");
+  if (isPartial) {
+    headers.set("Content-Range", formatContentRange(start, end, total));
+    headers.set("Content-Length", String(end - start + 1));
+  } else if (total >= 0) {
+    headers.set("Content-Length", String(total));
+  }
+  if (normalized.name) {
+    headers.set("Content-Disposition", contentDisposition(normalized.name, normalized.download));
+  }
+  if (normalized.etag) {
+    headers.set("ETag", normalized.etag);
+  }
+  if (normalized.lastModified) {
+    headers.set("Last-Modified", normalized.lastModified.toUTCString());
+  }
+  for (const [key, value] of Object.entries(normalized.extraHeaders)) {
+    headers.set(key, value);
+  }
+  if ((options.method ?? "GET").toUpperCase() === "HEAD") {
+    if (body && "cancel" in body && typeof body.cancel === "function") {
+      await body.cancel();
+    }
+    return new Response(null, { status, headers });
+  }
+  return new Response(body, { status, headers });
+}
+
+// http/errors.ts
+class AuthorizationError extends RequestBreakerError {
+  error;
+  constructor(error = "Not authorized") {
+    super("Authentication error");
+    this.name = "AuthenticationError";
+    this.error = error;
+    this.payload = {
+      api: {
+        status: 401,
+        data: { error: this.error }
+      },
+      view: {}
+    };
+  }
+}
+
+class InsufficientPermissionsError extends RequestBreakerError {
+  error;
+  constructor(error = "Insufficient permissions") {
+    super("Authentication error");
+    this.name = "AuthenticationError";
+    this.error = error;
+    this.payload = {
+      api: {
+        status: 401,
+        data: { error: this.error }
+      },
+      view: {}
+    };
+  }
+}
+
+class RangeNotSatisfiableError extends RequestBreakerError {
+  total;
+  constructor(total) {
+    super("Range not satisfiable");
+    this.total = total;
+    this.name = "RangeNotSatisfiableError";
+    this.payload = {
+      api: {
+        status: 416,
+        data: { error: { message: "Range not satisfiable" } },
+        headers: {
+          "Content-Range": formatUnsatisfiedContentRange(total),
+          "Accept-Ranges": "bytes",
+          "Cache-Control": "no-store"
+        }
+      },
+      view: {}
+    };
+  }
+}
+class AuthenticationError extends RequestBreakerError {
+  constructor() {
+    super("Authentication error");
+    this.name = "AuthenticationError";
+  }
+  payload = {
+    api: {
+      status: 401,
+      data: { error: "Authentication error" }
+    },
+    view: {
+      status: 302,
+      headers: {
+        "Cache-Control": "private, no-cache, no-store, max-age=0, must-revalidate",
+        Location: "/auth/sign-in"
+      }
+    }
+  };
+}
+
 // http/ApiRouter.ts
 function isController(candidate) {
   return isConstructor(candidate);
@@ -50494,6 +50785,40 @@ class FileHandler {
   }
 }
 
+class StreamRouteHandler extends RouteHandler {
+  __internal_brand = "StreamHandler";
+  async run(_req) {
+    const ctx = RequestContext.getStore();
+    const rawRequest = ctx?.req?.rawRequest;
+    const range = parseRangeHeader(rawRequest?.headers.get("Range"));
+    if (ctx) {
+      ctx.rangeRequest = range;
+    }
+    try {
+      const output = await super.run(_req);
+      return await createStreamResponse(output, {
+        range,
+        method: rawRequest?.method
+      });
+    } catch (err) {
+      if (err instanceof RangeNotSatisfiableError) {
+        return createUnsatisfiableResponse(err.total);
+      }
+      throw err;
+    } finally {
+      if (ctx) {
+        ctx.rangeRequest = null;
+      }
+    }
+  }
+}
+
+class StreamHandler {
+  constructor(...args) {
+    return new StreamRouteHandler(...args);
+  }
+}
+
 class ResourceRouteHandlers {
   __internal_brand = "ResourceRoutes";
   first;
@@ -50550,6 +50875,9 @@ class ApiRouter {
   file(handler, methodName) {
     return new FileHandler("GET", handler, methodName);
   }
+  stream(handler, methodName) {
+    return new StreamHandler("GET", handler, methodName);
+  }
   proxy(url, headers = {}) {
     return new ProxyHandler(url, headers);
   }
@@ -50651,11 +50979,6 @@ class RedirectRoute {
     return this;
   }
 }
-function contentDisposition(name, download) {
-  const kind = download ? "attachment" : "inline";
-  const fallback = name.replace(/["\\]/g, "").replace(/[^\x20-\x7e]/g, "_");
-  return `${kind}; filename="${fallback}"; filename*=UTF-8''${encodeURIComponent(name)}`;
-}
 async function createFileResponse(output, headers) {
   if (output instanceof Response) {
     return output;
@@ -50826,58 +51149,6 @@ import { randomBytes } from "crypto";
 // services/ServiceProvider.ts
 class ServiceProvider {
 }
-// http/errors.ts
-class AuthorizationError extends RequestBreakerError {
-  error;
-  constructor(error = "Not authorized") {
-    super("Authentication error");
-    this.name = "AuthenticationError";
-    this.error = error;
-    this.payload = {
-      api: {
-        status: 401,
-        data: { error: this.error }
-      },
-      view: {}
-    };
-  }
-}
-
-class InsufficientPermissionsError extends RequestBreakerError {
-  error;
-  constructor(error = "Insufficient permissions") {
-    super("Authentication error");
-    this.name = "AuthenticationError";
-    this.error = error;
-    this.payload = {
-      api: {
-        status: 401,
-        data: { error: this.error }
-      },
-      view: {}
-    };
-  }
-}
-
-class AuthenticationError extends RequestBreakerError {
-  constructor() {
-    super("Authentication error");
-    this.name = "AuthenticationError";
-  }
-  payload = {
-    api: {
-      status: 401,
-      data: { error: "Authentication error" }
-    },
-    view: {
-      status: 302,
-      headers: {
-        "Cache-Control": "private, no-cache, no-store, max-age=0, must-revalidate",
-        Location: "/auth/sign-in"
-      }
-    }
-  };
-}
 // kernel/context.ts
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
 var kernelContext = new AsyncLocalStorage2;
@@ -52140,6 +52411,12 @@ function isProxyHandler(option) {
   }
   return false;
 }
+function isStreamHandler(option) {
+  if ("__internal_brand" in option) {
+    return option.__internal_brand === "StreamHandler";
+  }
+  return false;
+}
 function createFlatApiRoutes(routes, rootPath = "", rootMiddleware = []) {
   const flatApiRoutes = {};
   function addRoute(path, method, exec, middleware) {
@@ -52176,6 +52453,9 @@ function createFlatApiRoutes(routes, rootPath = "", rootMiddleware = []) {
       const middleware = routeHandler.middlewares;
       const exec = routeHandler.run.bind(routeHandler);
       addRoute(path, method, exec, middleware);
+      if (isStreamHandler(option)) {
+        addRoute(path, "HEAD", exec, middleware);
+      }
     }
     if (isRouteHandlers(option)) {
       for (const [method, routeHandler] of Object.entries(option)) {
@@ -68426,6 +68706,42 @@ class ApiRouterServiceContainer extends ServiceContainer {
     }
     return data;
   }
+  mergeContextIntoResponse(response, headers, cookies) {
+    const entries = [];
+    headers?.forEach((value, key) => entries.push([key, value]));
+    const setCookies = [
+      ...typeof headers?.getSetCookie === "function" ? headers.getSetCookie() : [],
+      ...Array.from(cookies ?? [])
+    ];
+    if (entries.length === 0 && setCookies.length === 0) {
+      return response;
+    }
+    const apply = (target) => {
+      for (const [key, value] of entries) {
+        if (key.toLowerCase() === "set-cookie") {
+          continue;
+        }
+        if (!target.has(key)) {
+          target.set(key, value);
+        }
+      }
+      for (const cookie of setCookies) {
+        target.append("Set-Cookie", cookie);
+      }
+    };
+    try {
+      apply(response.headers);
+      return response;
+    } catch {
+      const merged = new Headers(response.headers);
+      apply(merged);
+      return new Response(response.body, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: merged
+      });
+    }
+  }
   async handleApiRequest(req) {
     const { params, path } = this.getRouteHandlerAndParams(req);
     const routeHandler = this.flatRoutes[path];
@@ -68451,16 +68767,22 @@ class ApiRouterServiceContainer extends ServiceContainer {
         return middlewareResponse;
       }
       const data = await this.getRouteData(path);
+      const headers = ctx.headers;
+      const cookies = ctx.cookies;
       if (data instanceof Response) {
-        return data;
+        const response = this.mergeContextIntoResponse(data, headers, cookies);
+        if (!req.url.includes("/__gemi__")) {
+          this.service.onRequestEnd(httpRequest);
+        }
+        ctx.destroy();
+        return response;
       }
-      const headers = ctx.headers;
-      headers.append("Content-Type", "application/json");
-      ctx.cookies.forEach((cookie) => headers.append("Set-Cookie", cookie.toString()));
-      ctx.destroy();
+      headers.set("Content-Type", "application/json");
+      cookies.forEach((cookie) => headers.append("Set-Cookie", cookie.toString()));
       if (!req.url.includes("/__gemi__")) {
         this.service.onRequestEnd(httpRequest);
       }
+      ctx.destroy();
       return new Response(JSON.stringify(data), {
         headers
       });
@@ -69077,7 +69399,7 @@ class ApiManifestGenerator {
     if (!this.routes.has(finalRoutePath)) {
       this.routes.set(finalRoutePath, new Map);
     }
-    if (method === "file") {
+    if (method === "file" || method === "stream") {
       return;
     } else if (method === "resource") {
       const idPrefixer = (path3) => path3 === "/" ? ":id" : `${path3}/:${toCamelCase(path3.split("/").pop())}Id`;
@@ -69291,5 +69613,5 @@ program.command("app:route-manifest").action(async () => {
 });
 program.parse();
 
-//# debugId=71D97BBCCC12C4B064756E2164756E21
+//# debugId=5C74742BDDA86B8864756E2164756E21
 //# sourceMappingURL=gemi.js.map