astro-routify 1.2.2 → 1.5.0

package/dist/core/responseHelpers.js

@@ -47,22 +47,32 @@ export const methodNotAllowed = (body = 'Method Not Allowed', headers) => create
  * 429 Too Many Requests
  */
 export const tooManyRequests = (body = 'Too Many Requests', headers) => createResponse(429, body, headers);
+/**
+ * Returns a response with JSON body and specified status.
+ */
+export const json = (body, status = 200, headers) => createResponse(status, body, headers);
 /**
  * 500 Internal Server Error
+ *
+ * In production, you might want to avoid leaking error details.
  */
-export const internalError = (err, headers) => createResponse(500, err instanceof Error ? err.message : String(err), headers);
+export const internalError = (err, headers) => {
+    const message = err instanceof Error ? err.message : String(err);
+    return createResponse(500, message, headers);
+};
 /**
  * Sends a binary or stream-based file response with optional content-disposition.
  *
- * @param content - The file data (Blob, ArrayBuffer, or stream)
+ * @param content - The file state (Blob, ArrayBuffer, or stream)
  * @param contentType - MIME type of the file
  * @param fileName - Optional download filename
  * @param headers - Optional extra headers
  * @returns A ResultResponse for download-ready content
  */
 export const fileResponse = (content, contentType, fileName, headers) => {
-    const disposition = fileName
-        ? { 'Content-Disposition': `attachment; filename="${fileName}"` }
+    const sanitizedFileName = fileName?.replace(/"/g, '\\"');
+    const disposition = sanitizedFileName
+        ? { 'Content-Disposition': `attachment; filename="${sanitizedFileName}"` }
         : {};
     return {
         status: 200,
@@ -74,29 +84,120 @@ export const fileResponse = (content, contentType, fileName, headers) => {
         },
     };
 };
+function isPlainObject(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null));
+}
+/**
+ * Type guard to detect ReadableStreams, used for streamed/binary responses.
+ *
+ * @param value - Any value to test
+ * @returns True if it looks like a ReadableStream
+ */
+export function isReadableStream(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        typeof value.getReader === 'function');
+}
 /**
- * Converts an internal `ResultResponse` into a native `Response` object
+ * Converts an internal `ResultResponse` or any `HandlerResult` into a native `Response` object
  * for use inside Astro API routes.
  *
- * Automatically applies `Content-Type: application/json` for object bodies.
+ * Automatically applies appropriate Content-Type headers.
  *
- * @param result - A ResultResponse returned from route handler
+ * @param result - A ResultResponse or other supported type returned from route handler
  * @returns A native Response
  */
 export function toAstroResponse(result) {
-    if (!result)
+    if (result instanceof Response)
+        return result;
+    if (result === undefined) {
         return new Response(null, { status: 204 });
-    const { status, body, headers } = result;
-    if (body === undefined || body === null) {
-        return new Response(null, { status, headers });
     }
-    const isObject = typeof body === 'object' || Array.isArray(body);
-    const finalHeaders = {
-        ...(headers ?? {}),
-        ...(isObject ? { 'Content-Type': 'application/json; charset=utf-8' } : {}),
-    };
-    return new Response(isObject ? JSON.stringify(body) : body, {
-        status,
-        headers: finalHeaders,
-    });
+    if (result === null) {
+        return new Response('null', {
+            status: 200,
+            headers: { 'Content-Type': 'application/json; charset=utf-8' },
+        });
+    }
+    // If it's a ResultResponse object (has status)
+    if (typeof result === 'object' &&
+        'status' in result &&
+        typeof result.status === 'number') {
+        const { status, body, headers } = result;
+        if (body === undefined) {
+            return new Response(null, { status, headers });
+        }
+        if (body === null) {
+            const finalHeaders = new Headers();
+            finalHeaders.set('Content-Type', 'application/json; charset=utf-8');
+            if (headers) {
+                const h = new Headers(headers);
+                h.forEach((value, key) => finalHeaders.set(key, value));
+            }
+            return new Response('null', { status, headers: finalHeaders });
+        }
+        if (body instanceof Response)
+            return body;
+        const isJson = typeof body === 'number' ||
+            typeof body === 'boolean' ||
+            isPlainObject(body) ||
+            Array.isArray(body);
+        const isBinary = body instanceof ArrayBuffer ||
+            body instanceof Uint8Array ||
+            body instanceof Blob ||
+            isReadableStream(body);
+        const finalHeaders = new Headers();
+        // 1. Apply inferred defaults
+        if (isJson) {
+            finalHeaders.set('Content-Type', 'application/json; charset=utf-8');
+        }
+        else if (isBinary) {
+            finalHeaders.set('Content-Type', 'application/octet-stream');
+        }
+        // 2. Explicit headers take precedence
+        if (headers) {
+            const h = new Headers(headers);
+            h.forEach((value, key) => {
+                finalHeaders.set(key, value);
+            });
+        }
+        return new Response(isJson ? JSON.stringify(body) : body, {
+            status,
+            headers: finalHeaders,
+        });
+    }
+    // Direct values
+    if (typeof result === 'string') {
+        return new Response(result, {
+            status: 200,
+            headers: { 'Content-Type': 'text/plain; charset=utf-8' },
+        });
+    }
+    if (typeof result === 'number' || typeof result === 'boolean') {
+        return new Response(JSON.stringify(result), {
+            status: 200,
+            headers: { 'Content-Type': 'application/json; charset=utf-8' },
+        });
+    }
+    if (result instanceof ArrayBuffer ||
+        result instanceof Uint8Array ||
+        result instanceof Blob ||
+        isReadableStream(result)) {
+        return new Response(result, {
+            status: 200,
+            headers: { 'Content-Type': 'application/octet-stream' },
+        });
+    }
+    if (result instanceof FormData || result instanceof URLSearchParams) {
+        return new Response(result, { status: 200 });
+    }
+    if (Array.isArray(result) || isPlainObject(result)) {
+        return new Response(JSON.stringify(result), {
+            status: 200,
+            headers: { 'Content-Type': 'application/json; charset=utf-8' },
+        });
+    }
+    return new Response(null, { status: 204 });
 }

package/dist/core/stream.d.ts

@@ -3,7 +3,7 @@ import { type Route } from './defineRoute';
 import { HttpMethod } from './HttpMethod';
 import { HeadersInit } from 'undici';
 /**
- * A writer for streaming raw data to the response body.
+ * A writer for streaming raw state to the response body.
  *
  * This is used inside the `stream()` route handler to emit bytes
  * or strings directly to the client with backpressure awareness.
@@ -47,7 +47,7 @@ export interface StreamOptions {
     keepAlive?: boolean;
 }
 /**
- * Defines a generic streaming route that can write raw chunks of data
+ * Defines a generic streaming route that can write raw chunks of state
  * to the response in real time using a `ReadableStream`.
  *
  * Suitable for Server-Sent Events (SSE), long-polling, streamed HTML,
@@ -56,7 +56,7 @@ export interface StreamOptions {
  * @example
  * stream('/clock', async ({ response }) => {
  *   const timer = setInterval(() => {
- *     response.write(`data: ${new Date().toISOString()}\n\n`);
+ *     response.write(`state: ${new Date().toISOString()}\n\n`);
  *   }, 1000);
  *
  *   setTimeout(() => {

package/dist/core/stream.js

@@ -1,7 +1,7 @@
 import { defineRoute } from './defineRoute';
 import { HttpMethod } from './HttpMethod';
 /**
- * Defines a generic streaming route that can write raw chunks of data
+ * Defines a generic streaming route that can write raw chunks of state
  * to the response in real time using a `ReadableStream`.
  *
  * Suitable for Server-Sent Events (SSE), long-polling, streamed HTML,
@@ -10,7 +10,7 @@ import { HttpMethod } from './HttpMethod';
  * @example
  * stream('/clock', async ({ response }) => {
  *   const timer = setInterval(() => {
- *     response.write(`data: ${new Date().toISOString()}\n\n`);
+ *     response.write(`state: ${new Date().toISOString()}\n\n`);
  *   }, 1000);
  *
  *   setTimeout(() => {
@@ -35,8 +35,8 @@ export function stream(path, handler, options) {
             write: (chunk) => {
                 if (closed || !controllerRef)
                     return;
-                const bytes = typeof chunk === 'string' ?
-                    encoder.encode(`data: ${chunk}\n\n`)
+                const bytes = typeof chunk === 'string'
+                    ? (contentType === 'text/event-stream' ? encoder.encode(`state: ${chunk}\n\n`) : encoder.encode(chunk))
                     : chunk;
                 controllerRef.enqueue(bytes);
             },
@@ -56,17 +56,24 @@ export function stream(path, handler, options) {
         const body = new ReadableStream({
             start(controller) {
                 controllerRef = controller;
+                const onAbort = () => {
+                    closed = true;
+                    try {
+                        controller.close();
+                    }
+                    catch { /* noop */ }
+                    console.debug('Request aborted — streaming stopped.');
+                };
+                ctx.request.signal.addEventListener('abort', onAbort, { once: true });
                 Promise.resolve(handler({ ...ctx, response: writer }))
                     .catch((err) => {
                     try {
                         controller.error(err);
                     }
                     catch { /* noop */ }
-                });
-                ctx.request.signal.addEventListener('abort', () => {
-                    closed = true;
-                    controller.close();
-                    console.debug('Request aborted — streaming stopped.');
+                })
+                    .finally(() => {
+                    ctx.request.signal.removeEventListener('abort', onAbort);
                 });
             },
             cancel() {

package/dist/core/streamJsonArray.d.ts

@@ -6,7 +6,7 @@ import { JsonStreamWriter } from './internal/createJsonStreamRoute';
  * Defines a JSON streaming route that emits a valid JSON array.
  *
  * This helper returns a valid `application/json` response containing
- * a streamable array of JSON values. Useful for large data exports
+ * a streamable array of JSON values. Useful for large state exports
  * or APIs where the full array can be streamed as it's generated.
  *
  * Unlike `streamJsonND()`, this wraps all values in `[` and `]`

package/dist/core/streamJsonArray.js

@@ -4,7 +4,7 @@ import { createJsonStreamRoute } from './internal/createJsonStreamRoute';
  * Defines a JSON streaming route that emits a valid JSON array.
  *
  * This helper returns a valid `application/json` response containing
- * a streamable array of JSON values. Useful for large data exports
+ * a streamable array of JSON values. Useful for large state exports
  * or APIs where the full array can be streamed as it's generated.
  *
  * Unlike `streamJsonND()`, this wraps all values in `[` and `]`