@warlock.js/core 4.0.162 → 4.0.163

package/esm/http/response.js

@@ -0,0 +1,974 @@
+import config from'@mongez/config';import events from'@mongez/events';import {fileExistsAsync}from'@mongez/fs';import {isScalar,isIterable,isPlainObject}from'@mongez/supportive-is';import {log}from'@warlock.js/logger';import fs from'fs';import mime from'mime';import path from'path';import {renderReact}from'../react/index.js';var ResponseStatus;
+(function (ResponseStatus) {
+    ResponseStatus[ResponseStatus["OK"] = 200] = "OK";
+    ResponseStatus[ResponseStatus["CREATED"] = 201] = "CREATED";
+    ResponseStatus[ResponseStatus["ACCEPTED"] = 202] = "ACCEPTED";
+    ResponseStatus[ResponseStatus["MOVED_PERMANENTLY"] = 301] = "MOVED_PERMANENTLY";
+    ResponseStatus[ResponseStatus["FOUND"] = 302] = "FOUND";
+    ResponseStatus[ResponseStatus["SEE_OTHER"] = 303] = "SEE_OTHER";
+    ResponseStatus[ResponseStatus["NOT_MODIFIED"] = 304] = "NOT_MODIFIED";
+    ResponseStatus[ResponseStatus["TEMPORARY_REDIRECT"] = 307] = "TEMPORARY_REDIRECT";
+    ResponseStatus[ResponseStatus["PERMANENT_REDIRECT"] = 308] = "PERMANENT_REDIRECT";
+    ResponseStatus[ResponseStatus["NO_CONTENT"] = 204] = "NO_CONTENT";
+    ResponseStatus[ResponseStatus["BAD_REQUEST"] = 400] = "BAD_REQUEST";
+    ResponseStatus[ResponseStatus["UNAUTHORIZED"] = 401] = "UNAUTHORIZED";
+    ResponseStatus[ResponseStatus["FORBIDDEN"] = 403] = "FORBIDDEN";
+    ResponseStatus[ResponseStatus["NOT_FOUND"] = 404] = "NOT_FOUND";
+    ResponseStatus[ResponseStatus["METHOD_NOT_ALLOWED"] = 405] = "METHOD_NOT_ALLOWED";
+    ResponseStatus[ResponseStatus["CONFLICT"] = 409] = "CONFLICT";
+    ResponseStatus[ResponseStatus["TOO_MANY_REQUESTS"] = 429] = "TOO_MANY_REQUESTS";
+    ResponseStatus[ResponseStatus["INTERNAL_SERVER_ERROR"] = 500] = "INTERNAL_SERVER_ERROR";
+    ResponseStatus[ResponseStatus["SERVICE_UNAVAILABLE"] = 503] = "SERVICE_UNAVAILABLE";
+})(ResponseStatus || (ResponseStatus = {}));
+class Response {
+    /**
+     * Current route
+     */
+    route;
+    /**
+     * Fastify response object
+     */
+    baseResponse;
+    /**
+     * Current status code
+     */
+    currentStatusCode = 200;
+    /**
+     * Current response body
+     */
+    currentBody;
+    /**
+     * A flag to determine if response is being sent
+     */
+    isSending = false;
+    /**
+     * Request object
+     */
+    request;
+    /**
+     * Internal events related to this particular response object
+     */
+    events = new Map();
+    /**
+     * Parsed body
+     * This will return the parsed body of the response
+     * Please note that if this property is called before the response is sent, it will return undefined
+     */
+    parsedBody;
+    /**
+     * Get Current response body
+     */
+    get body() {
+        return this.currentBody;
+    }
+    /**
+     * Set response body
+     */
+    set body(body) {
+        this.currentBody = body;
+    }
+    /**
+     * Add event on sending response
+     */
+    onSending(callback) {
+        this.events.set("sending", [...(this.events.get("sending") || []), callback]);
+        return this;
+    }
+    /**
+     * Add event on sent response
+     */
+    onSent(callback) {
+        this.events.set("sent", [...(this.events.get("sent") || []), callback]);
+        return this;
+    }
+    /**
+     * Set the Fastify response object
+     */
+    setResponse(response) {
+        this.baseResponse = response;
+        // Listen to the 'finish' event to track when response is fully sent
+        // This works for all response types: JSON, streams, buffers, files, etc.
+        this.baseResponse.raw.once("finish", () => {
+            this.request.endTime = Date.now();
+        });
+        return this;
+    }
+    /**
+     * Reset the response state
+     */
+    reset() {
+        this.route = {};
+        this.currentBody = null;
+        this.currentStatusCode = 200;
+    }
+    /**
+     * Set current route
+     */
+    setRoute(route) {
+        this.route = route;
+        return this;
+    }
+    /**
+     * Get the content type
+     */
+    get contentType() {
+        return this.baseResponse.getHeader("Content-Type");
+    }
+    /**
+     * Set the content type
+     */
+    setContentType(contentType) {
+        this.baseResponse.header("Content-Type", contentType);
+        return this;
+    }
+    /**
+     * Get the status code
+     */
+    get statusCode() {
+        return this.currentStatusCode ?? this.baseResponse.statusCode;
+    }
+    /**
+     * Check if response status is ok
+     */
+    get isOk() {
+        return this.currentStatusCode >= 200 && this.currentStatusCode < 300;
+    }
+    /**
+     * Check if the response has been sent
+     */
+    get sent() {
+        return this.baseResponse.sent;
+    }
+    /**
+     * Add a listener to the response event
+     */
+    static on(event, listener) {
+        return events.subscribe(`response.${event}`, listener);
+    }
+    /**
+     * Trigger the response event
+     */
+    static async trigger(event, ...args) {
+        // make a timeout to make sure the request events is executed first
+        return new Promise((resolve) => {
+            setTimeout(async () => {
+                await events.triggerAllAsync(`response.${event}`, ...args);
+                resolve(true);
+            }, 0);
+        });
+    }
+    /**
+     * Parse body
+     */
+    async parseBody() {
+        return await this.parse(this.currentBody);
+    }
+    /**
+     * Parse the given value
+     */
+    async parse(value) {
+        // if it is a falsy value, return it
+        if (!value || isScalar(value))
+            return value;
+        // if it has a `toJSON` method, call it and await the result then return it
+        if (value.toJSON) {
+            value.request = this.request;
+            return await value.toJSON();
+        }
+        // if it is iterable, an array or array-like object then parse each item
+        if (isIterable(value)) {
+            const values = Array.from(value);
+            return Promise.all(values.map(async (item) => {
+                return await this.parse(item);
+            }));
+        }
+        // if not plain object, then return it
+        if (!isPlainObject(value)) {
+            return value;
+        }
+        // loop over the object and check if the value and call `parse` on it
+        for (const key in value) {
+            const subValue = value[key];
+            value[key] = await this.parse(subValue);
+        }
+        return value;
+    }
+    /**
+     * Make a log message
+     */
+    log(message, level = "info") {
+        if (!config.get("http.log"))
+            return;
+        log({
+            module: "response",
+            action: this.route.method + " " + this.route.path.replace("/*", "") + `:${this.request.id}`,
+            message,
+            type: level,
+            context: {
+                request: this.request,
+                response: this,
+            },
+        });
+    }
+    /**
+     * Check if returning response is json
+     */
+    get isJson() {
+        return this.getHeader("Content-Type") === "application/json";
+    }
+    /**
+     * Send the response
+     * @param data - Response data
+     * @param statusCode - HTTP status code
+     * @param triggerEvents - Whether to trigger response events (default: true)
+     */
+    async send(data, statusCode, triggerEvents = true) {
+        if (statusCode) {
+            this.currentStatusCode = statusCode;
+        }
+        if (data === this)
+            return this;
+        if (data) {
+            this.currentBody = data;
+        }
+        if (!this.currentStatusCode) {
+            this.currentStatusCode = 200;
+        }
+        this.log("Sending response");
+        // trigger the sending event
+        if (Array.isArray(this.currentBody) || isPlainObject(this.currentBody)) {
+            this.setContentType("application/json");
+        }
+        if (triggerEvents) {
+            await Response.trigger("sending", this);
+            for (const callback of this.events.get("sending") || []) {
+                await callback(this);
+            }
+            if (this.isJson) {
+                await Response.trigger("sendingJson", this);
+                for (const callback of this.events.get("sendingJson") || []) {
+                    await callback(this);
+                }
+                if (this.isOk) {
+                    await Response.trigger("sendingSuccessJson", this);
+                    for (const callback of this.events.get("sendingSuccessJson") || []) {
+                        await callback(this);
+                    }
+                }
+            }
+        }
+        // parse the body and make sure it is transformed to sync data instead of async data
+        if (typeof this.currentBody !== "string") {
+            this.parsedBody = await this.parseBody();
+        }
+        else {
+            this.parsedBody = data;
+        }
+        // Set the status first
+        this.baseResponse.status(this.currentStatusCode);
+        // Then send the response with the parsed body
+        await this.baseResponse.send(this.parsedBody);
+        this.log("Response sent");
+        if (triggerEvents) {
+            // trigger the sent event
+            Response.trigger("sent", this);
+            for (const callback of this.events.get("sent") || []) {
+                callback(this);
+            }
+            // trigger the success event if the status code is 2xx
+            if (this.currentStatusCode >= 200 && this.currentStatusCode < 300) {
+                Response.trigger("success", this);
+            }
+            // trigger the successCreate event if the status code is 201
+            if (this.currentStatusCode === 201) {
+                Response.trigger("successCreate", this);
+            }
+            // trigger the badRequest event if the status code is 400
+            if (this.currentStatusCode === 400) {
+                Response.trigger("badRequest", this);
+            }
+            // trigger the unauthorized event if the status code is 401
+            if (this.currentStatusCode === 401) {
+                Response.trigger("unauthorized", this);
+            }
+            // trigger the forbidden event if the status code is 403
+            if (this.currentStatusCode === 403) {
+                Response.trigger("forbidden", this);
+            }
+            // trigger the notFound event if the status code is 404
+            if (this.currentStatusCode === 404) {
+                Response.trigger("notFound", this);
+            }
+            // trigger the throttled event if the status code is 429
+            if (this.currentStatusCode === 429) {
+                Response.trigger("throttled", this);
+            }
+            // trigger the serverError event if the status code is 500
+            if (this.currentStatusCode === 500) {
+                Response.trigger("serverError", this);
+            }
+            // trigger the error event if the status code is 4xx or 5xx
+            if (this.currentStatusCode >= 400) {
+                Response.trigger("error", this);
+            }
+        }
+        return this;
+    }
+    /**
+     * Send html response
+     */
+    html(data, statusCode) {
+        return this.setContentType("text/html").send(data, statusCode);
+    }
+    /**
+     * Render the given react component
+     */
+    render(element, status = 200) {
+        return this.setStatusCode(status).html(renderReact(element));
+    }
+    /**
+     * Send xml response
+     */
+    xml(data, statusCode) {
+        return this.setContentType("text/xml").send(data, statusCode);
+    }
+    /**
+     * Send plain text response
+     */
+    text(data, statusCode) {
+        return this.setContentType("text/plain").send(data, statusCode);
+    }
+    /**
+     * Create a streaming response for progressive/chunked data sending
+     *
+     * This method allows you to send data in chunks and control when the response ends.
+     * Perfect for Server-Sent Events (SSE), progressive rendering, or streaming large responses.
+     *
+     * @example
+     * ```ts
+     * const stream = response.stream("text/html");
+     * stream.send("<html><body>");
+     * stream.send("<h1>Hello</h1>");
+     * stream.render(<MyComponent />);
+     * stream.send("</body></html>");
+     * stream.end();
+     * ```
+     *
+     * @param contentType - The content type for the stream (default: "text/plain")
+     * @returns Stream controller with send(), render(), and end() methods
+     */
+    stream(contentType = "text/plain") {
+        // Set headers using the response API
+        this.setContentType(contentType);
+        this.header("Transfer-Encoding", "chunked");
+        this.header("Cache-Control", "no-cache");
+        this.header("Connection", "keep-alive");
+        this.header("X-Content-Type-Options", "nosniff");
+        // Trigger sending events
+        Response.trigger("sending", this);
+        for (const callback of this.events.get("sending") || []) {
+            callback(this);
+        }
+        this.log("Starting stream");
+        // Track stream state
+        let isEnded = false;
+        const chunks = [];
+        // Write headers to start the stream
+        // Note: We use raw here because we need chunked encoding control
+        // This is the only valid use case for bypassing Fastify's abstraction
+        this.baseResponse.raw.writeHead(this.statusCode, this.getHeaders());
+        return {
+            /**
+             * Send a chunk of data to the client
+             * @param data - Data to send (string, Buffer, or any serializable data)
+             */
+            send: (data) => {
+                if (isEnded) {
+                    throw new Error("Cannot send data: stream has already ended");
+                }
+                this.baseResponse.raw.write(data);
+                return this;
+            },
+            /**
+             * Render a React component and send it as a chunk
+             * @param element - React element or component to render
+             */
+            render: (element) => {
+                if (isEnded) {
+                    throw new Error("Cannot render: stream has already ended");
+                }
+                const html = renderReact(element);
+                chunks.push(html);
+                this.baseResponse.raw.write(html);
+                return this;
+            },
+            /**
+             * End the stream and trigger completion events
+             */
+            end: () => {
+                if (isEnded) {
+                    return this;
+                }
+                isEnded = true;
+                // Store the streamed content for logging/debugging
+                this.currentBody = chunks;
+                this.parsedBody = chunks;
+                // End the response
+                this.baseResponse.raw.end();
+                this.log("Stream ended");
+                // Trigger sent events
+                Response.trigger("sent", this);
+                for (const callback of this.events.get("sent") || []) {
+                    callback(this);
+                }
+                // Trigger success event if status is 2xx
+                if (this.isOk) {
+                    Response.trigger("success", this);
+                }
+                // Trigger status-specific events
+                if (this.currentStatusCode === 201) {
+                    Response.trigger("successCreate", this);
+                }
+                return this;
+            },
+            /**
+             * Check if the stream has ended
+             */
+            get ended() {
+                return isEnded;
+            },
+        };
+    }
+    /**
+     * Create a Server-Sent Events (SSE) stream
+     *
+     * SSE is a standard for pushing real-time updates from server to client.
+     * Perfect for live notifications, progress updates, or real-time data feeds.
+     *
+     * @example
+     * ```ts
+     * const sse = response.sse();
+     *
+     * // Send events
+     * sse.send("message", { text: "Hello!" });
+     * sse.send("notification", { type: "info", message: "Update available" }, "msg-123");
+     *
+     * // Keep connection alive
+     * const keepAlive = setInterval(() => sse.comment("ping"), 30000);
+     *
+     * // Clean up when done
+     * clearInterval(keepAlive);
+     * sse.end();
+     * ```
+     *
+     * @returns SSE controller with send(), comment(), and end() methods
+     */
+    sse() {
+        // Set SSE-specific headers
+        this.setContentType("text/event-stream");
+        this.header("Cache-Control", "no-cache, no-store, must-revalidate");
+        this.header("Connection", "keep-alive");
+        this.header("X-Accel-Buffering", "no"); // Disable nginx buffering
+        // Trigger sending events
+        Response.trigger("sending", this);
+        for (const callback of this.events.get("sending") || []) {
+            callback(this);
+        }
+        this.log("Starting SSE stream");
+        // Track stream state
+        let isEnded = false;
+        const events = [];
+        const disconnectHandlers = [];
+        // Write headers to start the stream
+        this.baseResponse.raw.writeHead(this.statusCode, this.getHeaders());
+        // Detect client disconnect — set isEnded silently and invoke cleanup handlers.
+        // Without this, background jobs keep writing to a dead socket after the client drops.
+        this.baseResponse.raw.on("close", () => {
+            if (!isEnded) {
+                isEnded = true;
+                this.log("SSE client disconnected");
+                for (const handler of disconnectHandlers) {
+                    handler();
+                }
+            }
+        });
+        const controller = {
+            /**
+             * Send an SSE event
+             * @param event - Event name (e.g., "message", "chunk", "done")
+             * @param data - Event data (will be JSON stringified)
+             * @param id - Optional event ID for client-side Last-Event-ID tracking (reconnect support)
+             */
+            send: (event, data, id) => {
+                // Silent no-op after disconnect — background jobs should not crash when
+                // the client drops mid-stream. The onDisconnect handler handles cleanup.
+                if (isEnded)
+                    return controller;
+                let message = "";
+                if (id)
+                    message += `id: ${id}\n`;
+                message += `event: ${event}\n`;
+                message += `data: ${JSON.stringify(data)}\n\n`;
+                events.push({ event, data, id });
+                this.baseResponse.raw.write(message);
+                return controller;
+            },
+            /**
+             * Send a comment (keeps connection alive, invisible to client)
+             * Useful for preventing timeout on long-lived connections
+             * @param text - Comment text
+             */
+            comment: (text) => {
+                // Silent no-op after disconnect
+                if (isEnded)
+                    return controller;
+                this.baseResponse.raw.write(`: ${text}\n\n`);
+                return controller;
+            },
+            /**
+             * End the SSE stream and trigger completion events
+             */
+            end: () => {
+                if (isEnded)
+                    return controller;
+                isEnded = true;
+                // Store the events for logging/debugging
+                this.currentBody = events;
+                this.parsedBody = events;
+                // End the response
+                this.baseResponse.raw.end();
+                this.log("SSE stream ended");
+                // Trigger sent events
+                Response.trigger("sent", this);
+                for (const callback of this.events.get("sent") || []) {
+                    callback(this);
+                }
+                // Trigger success event if status is 2xx
+                if (this.isOk) {
+                    Response.trigger("success", this);
+                }
+                return controller;
+            },
+            /**
+             * Register a handler to be called when the client disconnects.
+             * Use this to clean up EventEmitter listeners, cancel background jobs, etc.
+             *
+             * @example
+             * ```ts
+             * const sse = response.sse();
+             * const listener = (chunk) => sse.send("chunk", { chunk });
+             * eventBus.on(aiMessageId, listener);
+             * sse.onDisconnect(() => eventBus.off(aiMessageId, listener));
+             * ```
+             */
+            onDisconnect: (handler) => {
+                disconnectHandlers.push(handler);
+                return controller;
+            },
+            /**
+             * Check if the stream has ended (either via end() or client disconnect)
+             */
+            get ended() {
+                return isEnded;
+            },
+        };
+        return controller;
+    }
+    /**
+     * Set the status code
+     */
+    setStatusCode(statusCode) {
+        this.currentStatusCode = statusCode;
+        return this;
+    }
+    /**
+     * Redirect the user to another route
+     */
+    redirect(url, statusCode = 302) {
+        this.baseResponse.redirect(url, statusCode);
+        return this;
+    }
+    /**
+     * Permanent redirect
+     */
+    permanentRedirect(url) {
+        this.baseResponse.redirect(url, 301);
+        return this;
+    }
+    /**
+     * Get the response time
+     */
+    getResponseTime() {
+        return this.baseResponse.elapsedTime;
+    }
+    /**
+     * Remove a specific header
+     */
+    removeHeader(key) {
+        this.baseResponse.removeHeader(key);
+        return this;
+    }
+    /**
+     * Get a specific header
+     */
+    getHeader(key) {
+        return this.baseResponse.getHeader(key);
+    }
+    /**
+     * Get the response headers
+     */
+    getHeaders() {
+        return this.baseResponse.getHeaders();
+    }
+    /**
+     * Set multiple headers
+     */
+    headers(headers) {
+        this.baseResponse.headers(headers);
+        return this;
+    }
+    /**
+     * Set the response header
+     */
+    header(key, value) {
+        this.baseResponse.header(key, value);
+        return this;
+    }
+    /**
+     * Set a cookie on the response
+     *
+     * @example
+     * response.cookie('theme', 'dark', { maxAge: 3600, httpOnly: true })
+     */
+    cookie(name, value, options) {
+        const defaultOptions = config.get("http.cookies.options", {});
+        this.baseResponse.setCookie(name, JSON.stringify(value), { ...defaultOptions, ...options });
+        return this;
+    }
+    /**
+     * Clear a cookie from the response
+     *
+     * @example
+     * response.clearCookie('token', { path: '/' });
+     */
+    clearCookie(name, options) {
+        const defaultOptions = config.get("http.cookies.options", {});
+        this.baseResponse.clearCookie(name, { ...defaultOptions, ...options });
+        return this;
+    }
+    /**
+     * Alias to header method
+     */
+    setHeader(key, value) {
+        return this.header(key, value);
+    }
+    /**
+     * Send an error response with status code 500
+     */
+    serverError(data) {
+        return this.send(data, 500);
+    }
+    /**
+     * Send a forbidden response with status code 403
+     */
+    forbidden(data = {
+        error: "You are not allowed to access this resource, FORBIDDEN",
+    }) {
+        return this.send(data, 403);
+    }
+    /**
+     * Send a service unavailable response with status code 503
+     */
+    serviceUnavailable(data) {
+        return this.send(data, 503);
+    }
+    /**
+     * Send an unauthorized response with status code 401
+     */
+    unauthorized(data = {
+        error: "unauthorized",
+    }) {
+        return this.send(data, 401);
+    }
+    /**
+     * Send a not found response with status code 404
+     */
+    notFound(data = {
+        error: "notFound",
+    }) {
+        return this.send(data, 404);
+    }
+    /**
+     * Send a bad request response with status code 400
+     */
+    badRequest(data) {
+        return this.send(data, 400);
+    }
+    /**
+     * Send a success response with status code 201
+     */
+    successCreate(data) {
+        return this.send(data, 201);
+    }
+    /**
+     * Send a success response
+     */
+    success(data = { success: true }) {
+        return this.send(data);
+    }
+    /**
+     * Send a no content response with status code 204
+     */
+    noContent() {
+        return this.baseResponse.status(204).send();
+    }
+    /**
+     * Send an accepted response with status code 202
+     * Used for async operations that have been accepted but not yet processed
+     */
+    accepted(data = { message: "Request accepted for processing" }) {
+        return this.send(data, 202);
+    }
+    /**
+     * Send a conflict response with status code 409
+     */
+    conflict(data = { error: "Resource conflict" }) {
+        return this.send(data, 409);
+    }
+    /**
+     * Send an unprocessable entity response with status code 422
+     * Used for semantic validation errors
+     */
+    unprocessableEntity(data) {
+        return this.send(data, 422);
+    }
+    /**
+     * Apply response options (cache, disposition, etag)
+     * Shared helper for sendFile and sendBuffer
+     */
+    applyResponseOptions(options, defaultFilename) {
+        // Set content type if provided
+        if (options.contentType) {
+            this.baseResponse.type(options.contentType);
+        }
+        // Set cache headers if specified
+        if (options.cacheTime) {
+            const cacheControl = options.immutable
+                ? `public, max-age=${options.cacheTime}, immutable`
+                : `public, max-age=${options.cacheTime}`;
+            this.header("Cache-Control", cacheControl);
+            this.header("Expires", new Date(Date.now() + options.cacheTime * 1000).toUTCString());
+        }
+        // Set ETag if provided (for conditional requests)
+        if (options.etag) {
+            this.header("ETag", options.etag);
+            // Check If-None-Match for conditional request
+            const ifNoneMatch = this.request.header("if-none-match");
+            if (ifNoneMatch && ifNoneMatch === options.etag) {
+                this.log("Content not modified (ETag match), sending 304");
+                this.baseResponse.status(304).send();
+                return true; // Indicates 304 was sent
+            }
+        }
+        // Set Content-Disposition if inline or filename is specified
+        if (options.inline !== undefined || options.filename) {
+            const disposition = options.inline ? "inline" : "attachment";
+            const filename = options.filename || defaultFilename || "file";
+            this.header("Content-Disposition", `${disposition}; filename=\"${filename}\"`);
+        }
+        return false; // No 304 sent
+    }
+    /**
+     * Send a file as a response
+     */
+    async sendFile(filePath, options) {
+        this.log(`Sending file: ${filePath}`);
+        // Check if file exists first
+        if (!(await fileExistsAsync(filePath))) {
+            return this.notFound({
+                error: "File Not Found",
+            });
+        }
+        try {
+            // Normalize options to object format
+            const opts = typeof options === "number" ? { cacheTime: options } : options || {};
+            // Get file stats for ETag and Last-Modified
+            const stats = await fs.promises.stat(filePath);
+            const lastModified = stats.mtime;
+            // Generate ETag based on file size and modification time
+            const etag = `"${stats.size}-${stats.mtime.getTime()}"`;
+            // Set Last-Modified header
+            this.header("Last-Modified", lastModified.toUTCString());
+            this.header("ETag", etag);
+            // Set content type
+            const contentType = this.getFileContentType(filePath);
+            this.baseResponse.type(contentType);
+            // Apply common response options (cache, disposition)
+            const defaultFilename = path.basename(filePath);
+            const sent304 = this.applyResponseOptions({ ...opts, etag, contentType }, defaultFilename);
+            if (sent304)
+                return this.baseResponse;
+            // Check conditional request headers
+            const ifNoneMatch = this.request.header("if-none-match");
+            const ifModifiedSince = this.request.header("if-modified-since");
+            // Handle If-None-Match (ETag validation)
+            if (ifNoneMatch && ifNoneMatch === etag) {
+                this.log("File not modified (ETag match), sending 304");
+                return this.baseResponse.status(304).send();
+            }
+            // Handle If-Modified-Since (Last-Modified validation)
+            if (ifModifiedSince) {
+                const modifiedSinceDate = new Date(ifModifiedSince);
+                if (lastModified.getTime() <= modifiedSinceDate.getTime()) {
+                    this.log("File not modified (Last-Modified check), sending 304");
+                    return this.baseResponse.status(304).send();
+                }
+            }
+            // Use streaming for efficient file sending
+            const stream = fs.createReadStream(filePath);
+            // Handle stream errors
+            stream.on("error", (error) => {
+                this.log(`Error reading file: ${error.message}`, "error");
+                if (!this.baseResponse.sent) {
+                    this.serverError({
+                        error: "Error reading file",
+                        message: error.message,
+                    });
+                }
+            });
+            // Send the stream (endTime will be set by finish event listener)
+            return this.baseResponse.send(stream);
+        }
+        catch (error) {
+            this.log(`Error sending file: ${error.message}`, "error");
+            return this.serverError({
+                error: "Error sending file",
+                message: error.message,
+            });
+        }
+    }
+    /**
+     * Send buffer as a response
+     * Useful for dynamically generated content (e.g., resized images, generated PDFs)
+     */
+    sendBuffer(buffer, options) {
+        this.log("Sending buffer");
+        // Normalize options to object format
+        const opts = typeof options === "number" ? { cacheTime: options } : options || {};
+        // Apply common response options (cache, disposition, etag)
+        const sent304 = this.applyResponseOptions(opts);
+        if (sent304)
+            return this.baseResponse;
+        // Note: endTime is set in the main send() method for non-streaming responses
+        return this.baseResponse.send(buffer);
+    }
+    /**
+     * Send an Image instance as a response
+     * Automatically detects image format and sets content type
+     */
+    async sendImage(image, // Type as 'any' to avoid circular dependency with Image class
+    options) {
+        this.log("Sending image");
+        // Normalize options to object format
+        const opts = typeof options === "number" ? { cacheTime: options } : options || {};
+        // Get image metadata to determine format
+        const metadata = await image.metadata();
+        const format = metadata.format || "jpeg";
+        // Convert image to buffer
+        const buffer = await image.toBuffer();
+        // Auto-set content type if not provided
+        const contentType = opts.contentType || `image/${format}`;
+        // Auto-generate ETag if not provided
+        // Format: "format-widthxheight-size" (e.g., "jpeg-800x600-45231")
+        // This catches changes in dimensions, quality, filters, and format
+        if (!opts.etag) {
+            const width = metadata.width || 0;
+            const height = metadata.height || 0;
+            opts.etag = `"${format}-${width}x${height}-${buffer.length}"`;
+        }
+        // Apply common response options with auto-detected content type
+        const sent304 = this.applyResponseOptions({ ...opts, contentType });
+        if (sent304)
+            return this.baseResponse;
+        // Note: endTime is set in the main send() method for non-streaming responses
+        return this.baseResponse.send(buffer);
+    }
+    /**
+     * Send file and cache it
+     * Cache time in seconds
+     * Cache time will be one year
+     */
+    sendCachedFile(path, cacheTime = 31536000) {
+        return this.sendFile(path, cacheTime);
+    }
+    /**
+     * Download the given file path
+     */
+    download(path, filename) {
+        return this.downloadFile(path, filename);
+    }
+    /**
+     * Download the given file path
+     */
+    async downloadFile(filePath, filename) {
+        // Check if file exists first
+        if (!(await fileExistsAsync(filePath))) {
+            return this.notFound({
+                error: "File Not Found",
+            });
+        }
+        try {
+            if (!filename) {
+                filename = path.basename(filePath);
+            }
+            this.baseResponse.header("Content-Disposition", `attachment; filename="${filename}"`);
+            // this.baseResponse.header("Content-Type", this.getFileContentType(filePath));
+            this.baseResponse.header("Content-Type", "application/octet-stream");
+            const stream = fs.createReadStream(filePath);
+            // Handle stream errors
+            stream.on("error", (error) => {
+                this.log(`Error reading file for download: ${error.message}`, "error");
+                if (!this.baseResponse.sent) {
+                    this.serverError({
+                        error: "Error reading file",
+                        message: error.message,
+                    });
+                }
+            });
+            // Send the stream (endTime will be set by finish event listener)
+            return this.baseResponse.send(stream);
+        }
+        catch (error) {
+            this.log(`Error downloading file: ${error.message}`, "error");
+            return this.serverError({
+                error: "Error downloading file",
+                message: error.message,
+            });
+        }
+    }
+    /**
+     * Get content type of the given path
+     */
+    getFileContentType(filePath) {
+        const type = mime.getType(filePath) || "application/octet-stream";
+        return type;
+    }
+    /**
+     * Mark the response as failed
+     */
+    failedSchema(result) {
+        const { errors, inputKey, inputError, status } = config.get("validation.response", {
+            errors: "errors",
+            inputKey: "input",
+            inputError: "error",
+            status: 400,
+        });
+        log.error("request", "validation", `${this.request.id} - Validation failed`);
+        return this.send({
+            [errors]: result.errors.map((error) => ({
+                [inputKey]: error.input,
+                [inputError]: error.error,
+            })),
+        }, status);
+    }
+}export{Response,ResponseStatus};//# sourceMappingURL=response.js.map