@fal-ai/server-proxy/src/nextjs.js

The fal.ai server proxy adapter for JavaScript and TypeScript Web frameworks

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.route = exports.createRouteHandler = exports.handler = exports.createPageRouterHandler = exports.PROXY_ROUTE = void 0;
const server_1 = require("next/server");
const config_1 = require("./config");
const index_1 = require("./index");
/**
 * The default Next API route for the fal.ai client proxy.
 */
exports.PROXY_ROUTE = index_1.DEFAULT_PROXY_ROUTE;
/**
 * Creates a page router handler that proxies requests to the fal API.
 *
 * This is a drop-in handler for Next.js applications so that the client can be called
 * directly from the client-side code while keeping API keys safe.
 *
 * @param config the proxy options.
 * @returns a Next.js page router handler function.
 */
const createPageRouterHandler = (config = {}) => {
    const resolvedConfig = (0, config_1.resolveProxyConfig)(config);
    const handler = async (request, response) => {
        return (0, index_1.handleRequest)({
            id: "nextjs-page-router",
            method: request.method || "POST",
            getRequestBody: async () => JSON.stringify(request.body),
            getHeaders: () => request.headers,
            getHeader: (name) => request.headers[name],
            sendHeader: (name, value) => response.setHeader(name, value),
            respondWith: (status, data) => response.status(status).json(data),
            sendResponse: async (res) => {
                if (res.headers.get("content-type")?.includes("application/json")) {
                    return response.status(res.status).json(await res.json());
                }
                return response.status(res.status).send(await res.text());
            },
        }, resolvedConfig);
    };
    return handler;
};
exports.createPageRouterHandler = createPageRouterHandler;
// Lazy initialization for deprecated handler
let _pageRouterHandler = null;
/**
 * The Next API route handler for the fal.ai client proxy.
 * Use it with the /pages router in Next.js.
 *
 * Note: the page routers proxy doesn't support streaming responses.
 *
 * @param request the Next API request object.
 * @param response the Next API response object.
 * @returns a promise that resolves when the request is handled.
 *
 * @deprecated Use `createPageRouterHandler` instead.
 */
const handler = (request, response) => {
    if (!_pageRouterHandler) {
        _pageRouterHandler = (0, exports.createPageRouterHandler)();
    }
    return _pageRouterHandler(request, response);
};
exports.handler = handler;
/**
 * Creates a route handler that proxies requests to the fal API.
 *
 * This is a drop-in handler for Next.js applications so that the client can be called
 * directly from the client-side code while keeping API keys safe.
 *
 * Note: you should protect this route with your application's authentication mechanism
 * otherwise your proxy might be vulnerable to unauthorized access.
 *
 * @param config the proxy options.
 * @returns a Next.js route handler function.
 */
const createRouteHandler = (config = {}) => {
    const resolvedConfig = (0, config_1.resolveProxyConfig)(config);
    const handler = async (request) => {
        const responseHeaders = new Headers();
        return await (0, index_1.handleRequest)({
            id: "nextjs-app-router",
            method: request.method,
            getRequestBody: async () => request.text(),
            getHeaders: () => (0, index_1.fromHeaders)(request.headers),
            getHeader: (name) => request.headers.get(name),
            sendHeader: (name, value) => responseHeaders.set(name, value),
            respondWith: (status, data) => server_1.NextResponse.json(data, {
                status,
                headers: responseHeaders,
            }),
            sendResponse: index_1.responsePassthrough,
        }, resolvedConfig);
    };
    return {
        GET: handler,
        POST: handler,
        PUT: handler,
    };
};
exports.createRouteHandler = createRouteHandler;
// Lazy initialization for deprecated route
let _routeHandler = null;
function getRouteHandler() {
    if (!_routeHandler) {
        _routeHandler = (0, exports.createRouteHandler)();
    }
    return _routeHandler;
}
/**
 * @deprecated Use `createRouteHandler` instead.
 */
exports.route = {
    get GET() {
        return getRouteHandler().GET;
    },
    get POST() {
        return getRouteHandler().POST;
    },
    get PUT() {
        return getRouteHandler().PUT;
    },
};
//# sourceMappingURL=nextjs.js.map