@zubyjs/next 1.0.83

package/index.js

@@ -0,0 +1,300 @@
+import { mkdir, writeFile } from 'fs/promises';
+import { existsSync } from 'fs';
+import { resolve, relative, sep } from 'path';
+import { scanNextApiPages, scanNextPages } from './utils.js';
+import { createImportMap, rewriteImportsInWrapper } from './nft.js';
+export const ZUBY_PAGES_DIR = './zuby-pages';
+/**
+ * Zuby.js Next.js compatibility plugin
+ * Converts Next.js pages and API routes to Zuby.js handlers
+ *
+ * Features:
+ * - Automatically scans ./pages directory
+ * - Converts ./pages/api routes to Zuby handlers
+ * - Converts React page components to Zuby pages
+ * - Supports Next.js API route syntax (get, post, put, delete, etc.)
+ * - Provides NextApiRequest and NextApiResponse compatibility objects
+ * - Handles both default and method-specific exports
+ * - Supports getStaticProps (prerender = true) and getServerSideProps (prerender = false)
+ * - Passes page props through context
+ *
+ * @param options Plugin options
+ * @returns ZubyPlugin
+ *
+ * @example
+ * // pages/api/hello.ts
+ * export default function handler(req, res) {
+ *   return new Response('Hello from Zuby!');
+ * }
+ *
+ * // pages/api/posts/[id].ts
+ * export async function get(req, res) {
+ *   const post = await fetchPost(req.query.id);
+ *   return new Response(JSON.stringify(post));
+ * }
+ *
+ * export async function post(req, res) {
+ *   const newPost = await createPost(req.body);
+ *   return new Response(JSON.stringify(newPost), { status: 201 });
+ * }
+ *
+ * // pages/index.tsx with static generation
+ * export default function HomePage(props) {
+ *   return <h1>Posts: {props.count}</h1>;
+ * }
+ *
+ * export async function getStaticProps() {
+ *   return { props: { count: 42 } };
+ * }
+ *
+ * // pages/about.tsx with server-side rendering
+ * export default function AboutPage(props) {
+ *   return <h1>About - User: {props.user}</h1>;
+ * }
+ *
+ * export async function getServerSideProps(context) {
+ *   return { props: { user: 'John' } };
+ * }
+ */
+export default ({ autoDetectApiRoutes = true, pagesDir = './pages', traceDependencies = true, } = {}) => ({
+    name: 'zuby-next-plugin',
+    description: 'Next.js compatibility plugin',
+    buildStep: true,
+    hooks: {
+        'zuby:config:setup': async ({ config, logger, addHandler }) => {
+            // Validate configuration
+            if (config.srcPagesDir && config.srcPagesDir !== './pages') {
+                logger?.error(`[zuby-next-plugin] The srcPagesDir zuby.config.mjs option cannot be used together with the next.js pages router. Please keep srcPagesDir to the default './pages'.`);
+                return;
+            }
+            // Create zuby-pages directory
+            if (!existsSync(ZUBY_PAGES_DIR)) {
+                await mkdir(ZUBY_PAGES_DIR, { recursive: true });
+            }
+            config.srcPagesDir = ZUBY_PAGES_DIR;
+            const nextPagesDir = resolve(config.srcDir || '.', pagesDir);
+            // Scan and convert Next.js pages/api if enabled
+            if (autoDetectApiRoutes) {
+                try {
+                    const apiHandlers = await scanNextApiPages(nextPagesDir);
+                    for (const handler of apiHandlers) {
+                        // Create wrapper file for each handler
+                        // Convert /api/hello to api/hello.ts to maintain Next.js structure
+                        const handlerPathNormalized = handler.path
+                            .replace(/^\//, '') // Remove leading slash
+                            .replace(/\//g, sep); // Convert / to platform separator
+                        const wrapperPath = resolve(ZUBY_PAGES_DIR, handlerPathNormalized + '.ts');
+                        // Calculate relative path from wrapper to original handler file
+                        const relativePathToHandler = relative(resolve(wrapperPath, '..'), handler.filename);
+                        logger?.info(`[zuby-next-plugin] Generating wrapper for ${handler.path}`);
+                        let wrapperContent = generateHandlerWrapper(handler.path, relativePathToHandler);
+                        // Trace and rewrite imports if enabled
+                        if (traceDependencies) {
+                            try {
+                                const importMap = await createImportMap(handler.filename, wrapperPath);
+                                wrapperContent = rewriteImportsInWrapper(wrapperContent, importMap);
+                                if (Object.keys(importMap).length > 0) {
+                                    logger?.info(`[zuby-next-plugin] Rewritten imports for ${handler.path}: ${Object.keys(importMap).length} mappings`);
+                                }
+                            }
+                            catch (error) {
+                                logger?.warn(`[zuby-next-plugin] Failed to trace dependencies for ${handler.path}: ${error}`);
+                            }
+                        }
+                        // Ensure directory exists
+                        const wrapperDir = resolve(wrapperPath, '..');
+                        if (!existsSync(wrapperDir)) {
+                            await mkdir(wrapperDir, { recursive: true });
+                        }
+                        await writeFile(wrapperPath, wrapperContent);
+                        // Register handler with Zuby
+                        addHandler(wrapperPath, handler.path);
+                        logger?.info(`[zuby-next-plugin] Converted API route: ${handler.path}`);
+                    }
+                }
+                catch (error) {
+                    if (error?.code !== 'ENOENT') {
+                        logger?.warn(`[zuby-next-plugin] Failed to scan API routes: ${error}`);
+                    }
+                }
+            }
+            // Scan and convert Next.js pages
+            try {
+                const pages = await scanNextPages(nextPagesDir);
+                for (const page of pages) {
+                    logger?.info(`[zuby-next-plugin] Generating wrapper for page ${page.path}`);
+                    // Create wrapper file for each page
+                    const pagePathNormalized = page.path
+                        .replace(/^\//, '') // Remove leading slash
+                        .replace(/\//g, sep); // Convert / to platform separator
+                    const wrapperPath = resolve(ZUBY_PAGES_DIR, pagePathNormalized + '.ts');
+                    // Calculate relative path from wrapper to original page file
+                    const relativePathToPage = relative(resolve(wrapperPath, '..'), page.filename);
+                    const hasStaticProps = page.hasGetStaticProps || false;
+                    const hasServerSideProps = page.hasGetServerSideProps || false;
+                    logger?.info(`[zuby-next-plugin] Generating wrapper for page ${page.path}`);
+                    let wrapperContent = generatePageWrapper(page.path, relativePathToPage, hasStaticProps, hasServerSideProps);
+                    // Trace and rewrite imports if enabled
+                    if (traceDependencies) {
+                        try {
+                            const importMap = await createImportMap(page.filename, wrapperPath);
+                            wrapperContent = rewriteImportsInWrapper(wrapperContent, importMap);
+                            if (Object.keys(importMap).length > 0) {
+                                logger?.info(`[zuby-next-plugin] Rewritten imports for ${page.path}: ${Object.keys(importMap).length} mappings`);
+                            }
+                        }
+                        catch (error) {
+                            logger?.warn(`[zuby-next-plugin] Failed to trace dependencies for ${page.path}: ${error}`);
+                        }
+                    }
+                    // Ensure directory exists
+                    const wrapperDir = resolve(wrapperPath, '..');
+                    if (!existsSync(wrapperDir)) {
+                        await mkdir(wrapperDir, { recursive: true });
+                    }
+                    await writeFile(wrapperPath, wrapperContent);
+                    // Register page with Zuby
+                    addHandler(wrapperPath, page.path);
+                    logger?.info(`[zuby-next-plugin] Converted page: ${page.path}`);
+                }
+            }
+            catch (error) {
+                if (error?.code !== 'ENOENT') {
+                    logger?.warn(`[zuby-next-plugin] Failed to scan pages: ${error}`);
+                }
+            }
+        },
+    },
+});
+/**
+ * Generate a wrapper file for Next.js API routes
+ * This wrapper converts Next.js handlers to Zuby handler format
+ */
+function generateHandlerWrapper(nextApiPath, importPath) {
+    // Normalize path for cross-platform compatibility and ensure it's relative
+    const normalizedPath = importPath
+        .replace(/\\/g, '/') // Convert backslashes to forward slashes
+        .replace(/\.tsx?$/, '') // Remove .ts or .tsx extension
+        .replace(/^(?!\.\/|\.\.\/|\/)/, './'); // Add ./ prefix if not already present
+    return `import nextApiModule from '${normalizedPath}';
+import { createNextApiRequest } from '@zubyjs/next/nextApiRequest.js';
+import { createNextApiResponse, nextApiResponseToResponse } from '@zubyjs/next/nextApiResponse.js';
+import type { PageContext } from 'zuby';
+
+async function wrapHandler(handler: Function, context: any) {
+    const req = createNextApiRequest(context);
+    const res = createNextApiResponse();
+
+    try {
+        const result = await handler(req, res);
+
+        if (result instanceof Response) {
+            return result;
+        }
+
+        return nextApiResponseToResponse(res);
+    } catch (error) {
+        return new Response(
+            JSON.stringify({
+                error: 'Internal Server Error',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            }),
+            {
+                status: 500,
+                headers: { 'content-type': 'application/json' },
+            },
+        );
+    }
+}
+
+export default async (context: PageContext) => {
+    const method = context.request?.method?.toLowerCase() || 'get';
+
+    // Try method-specific handler first
+    if (typeof nextApiModule[method] === 'function') {
+        return wrapHandler(nextApiModule[method], context);
+    }
+
+    // Fall back to default handler
+    if (typeof nextApiModule.default === 'function') {
+        return wrapHandler(nextApiModule.default, context);
+    }
+
+    if (typeof nextApiModule === 'function') {
+        return wrapHandler(nextApiModule, context);
+    }
+
+    return new Response('Method not allowed', { status: 405 });
+};
+`;
+}
+/**
+ * Generate a wrapper file for Next.js pages with getStaticProps or getServerSideProps
+ * This wrapper creates a handler that renders the React component
+ */
+function generatePageWrapper(pagePath, importPath, hasStaticProps, hasServerSideProps) {
+    // Normalize path for cross-platform compatibility and ensure it's relative
+    const normalizedPath = importPath
+        .replace(/\\/g, '/') // Convert backslashes to forward slashes
+        .replace(/\.tsx?$/, '') // Remove .ts or .tsx extension
+        .replace(/^(?!\.\/|\.\.\/|\/)/, './'); // Add ./ prefix if not already present
+    const prenderMode = hasStaticProps ? 'true' : 'false';
+    return `import pageModule from '${normalizedPath}';
+import type { PageContext } from 'zuby';
+
+// Re-export the React component as default
+export const Component = pageModule.default;
+
+// Export prerender setting based on getStaticProps/getServerSideProps
+export const prerender = ${prenderMode};
+
+// Page handler that calls getStaticProps or getServerSideProps if available
+export default async (context: PageContext) => {
+    let props: Record<string, any> = {};
+
+    // Call getStaticProps if available
+    if (typeof pageModule.getStaticProps === 'function') {
+        try {
+            const result = await pageModule.getStaticProps({
+                params: context.params || {},
+            });
+            if (result && result.props) {
+                props = result.props;
+            }
+        } catch (error) {
+            console.error('[zuby-next-plugin] Error in getStaticProps:', error);
+        }
+    }
+
+    // Call getServerSideProps if available
+    if (typeof pageModule.getServerSideProps === 'function') {
+        try {
+            const result = await pageModule.getServerSideProps({
+                params: context.params || {},
+                req: {
+                    headers: Object.fromEntries(
+                        context.request?.headers?.entries?.() || []
+                    ),
+                    method: context.request?.method || 'GET',
+                    url: context.url || '/',
+                } as any,
+                res: {} as any,
+            });
+            if (result && result.props) {
+                props = result.props;
+            }
+        } catch (error) {
+            console.error('[zuby-next-plugin] Error in getServerSideProps:', error);
+        }
+    }
+
+    // Store props in context for the page to access
+    context.props = props;
+
+    // Return empty response - the component will be rendered by Zuby
+    return new Response(null, { status: 200 });
+};
+`;
+}
+export { createNextApiRequest } from './nextApiRequest.js';
+export { createNextApiResponse, nextApiResponseToResponse, getResponseState } from './nextApiResponse.js';

package/nextApiRequest.d.ts

@@ -0,0 +1,6 @@
+import type { NextApiRequest } from './types.js';
+/**
+ * Create a NextApiRequest object from Zuby PageContext
+ * Parses query parameters, cookies, headers, and body from the request
+ */
+export declare function createNextApiRequest(context: any): NextApiRequest;

package/nextApiRequest.js

@@ -0,0 +1,79 @@
+/**
+ * Create a NextApiRequest object from Zuby PageContext
+ * Parses query parameters, cookies, headers, and body from the request
+ */
+export function createNextApiRequest(context) {
+    const url = new URL(context.url || '/', 'http://localhost');
+    const query = {};
+    // Parse query parameters from URL
+    url.searchParams.forEach((value, key) => {
+        if (query[key]) {
+            if (Array.isArray(query[key])) {
+                query[key].push(value);
+            }
+            else {
+                query[key] = [query[key], value];
+            }
+        }
+        else {
+            query[key] = value;
+        }
+    });
+    // Add path parameters from context
+    if (context.params) {
+        Object.assign(query, context.params);
+    }
+    const req = {
+        url: context.url || '/',
+        method: context.request?.method || 'GET',
+        query,
+        cookies: parseCookies(context.request?.headers?.get('cookie')),
+        headers: headersToRecord(context.request?.headers),
+        baseUrl: `${url.protocol}//${url.host}`,
+        pathname: url.pathname,
+        body: context.body,
+    };
+    // Add socket info for client IP if available
+    if (context.clientAddress) {
+        req.socket = { remoteAddress: context.clientAddress };
+    }
+    return req;
+}
+/**
+ * Parse cookies from cookie header string
+ */
+function parseCookies(cookieHeader) {
+    const cookies = {};
+    if (!cookieHeader)
+        return cookies;
+    cookieHeader.split(';').forEach((cookie) => {
+        const [name, value] = cookie.trim().split('=');
+        if (name && value) {
+            cookies[name] = decodeURIComponent(value);
+        }
+    });
+    return cookies;
+}
+/**
+ * Convert Headers object to Record
+ */
+function headersToRecord(headers) {
+    const record = {};
+    if (!headers)
+        return record;
+    headers.forEach((value, key) => {
+        const lowerKey = key.toLowerCase();
+        if (record[lowerKey]) {
+            if (Array.isArray(record[lowerKey])) {
+                record[lowerKey].push(value);
+            }
+            else {
+                record[lowerKey] = [record[lowerKey], value];
+            }
+        }
+        else {
+            record[lowerKey] = value;
+        }
+    });
+    return record;
+}

package/nextApiResponse.d.ts

@@ -0,0 +1,26 @@
+import type { NextApiResponse } from './types.js';
+/**
+ * Internal response state for tracking what's been sent
+ */
+interface InternalResponseState {
+    statusCode: number;
+    headers: Record<string, string | string[] | number>;
+    body?: any;
+    sent: boolean;
+}
+/**
+ * Create a NextApiResponse object with optional body type
+ * Tracks response state and provides methods compatible with Next.js API responses
+ * @template TBody The type of the response body
+ */
+export declare function createNextApiResponse<TBody = any>(): NextApiResponse<TBody>;
+/**
+ * Get the internal state from a response object
+ * Used to convert the response into a Response object
+ */
+export declare function getResponseState(res: NextApiResponse): InternalResponseState;
+/**
+ * Convert a NextApiResponse to a Response object for Zuby
+ */
+export declare function nextApiResponseToResponse(res: NextApiResponse): Response;
+export {};

package/nextApiResponse.js

@@ -0,0 +1,135 @@
+/**
+ * Create a NextApiResponse object with optional body type
+ * Tracks response state and provides methods compatible with Next.js API responses
+ * @template TBody The type of the response body
+ */
+export function createNextApiResponse() {
+    const state = {
+        statusCode: 200,
+        headers: {},
+        sent: false,
+    };
+    const res = {
+        statusCode: state.statusCode,
+        headers: state.headers,
+        headersSent: false,
+        status(code) {
+            state.statusCode = code;
+            this.statusCode = code;
+            return this;
+        },
+        setHeader(name, value) {
+            const lowerName = name.toLowerCase();
+            state.headers[lowerName] = value;
+            this.headers[lowerName] = value;
+            return this;
+        },
+        getHeader(name) {
+            const lowerName = name.toLowerCase();
+            return state.headers[lowerName];
+        },
+        json(body) {
+            this.setHeader('content-type', 'application/json');
+            state.body = JSON.stringify(body);
+            state.sent = true;
+            this.headersSent = true;
+            return this;
+        },
+        send(body) {
+            state.body = body;
+            state.sent = true;
+            this.headersSent = true;
+            if (typeof body === 'string') {
+                this.setHeader('content-type', 'text/plain');
+            }
+            else if (typeof body === 'object') {
+                this.setHeader('content-type', 'application/json');
+                state.body = JSON.stringify(body);
+            }
+            return this;
+        },
+        end(body) {
+            if (body !== undefined) {
+                this.send(body);
+            }
+            state.sent = true;
+            this.headersSent = true;
+            return this;
+        },
+        write(chunk) {
+            if (!state.body) {
+                state.body = '';
+            }
+            state.body += chunk;
+            return true;
+        },
+        redirect(statusOrUrl, url) {
+            if (typeof statusOrUrl === 'string') {
+                state.statusCode = 302;
+                state.body = statusOrUrl;
+                this.statusCode = 302;
+                this.setHeader('location', statusOrUrl);
+            }
+            else {
+                state.statusCode = statusOrUrl;
+                this.statusCode = statusOrUrl;
+                this.setHeader('location', url || '');
+                state.body = url;
+            }
+            state.sent = true;
+            this.headersSent = true;
+            return this;
+        },
+    };
+    // Attach internal state to response object for later retrieval
+    res.__state__ = state;
+    return res;
+}
+/**
+ * Get the internal state from a response object
+ * Used to convert the response into a Response object
+ */
+export function getResponseState(res) {
+    return res.__state__ || {
+        statusCode: res.statusCode || 200,
+        headers: res.headers || {},
+        sent: false,
+    };
+}
+/**
+ * Convert a NextApiResponse to a Response object for Zuby
+ */
+export function nextApiResponseToResponse(res) {
+    const state = getResponseState(res);
+    let body = null;
+    if (state.body !== undefined) {
+        if (typeof state.body === 'string') {
+            body = state.body;
+        }
+        else if (Buffer.isBuffer(state.body)) {
+            body = Buffer.from(state.body);
+        }
+        else {
+            body = JSON.stringify(state.body);
+        }
+    }
+    return new Response(body, {
+        status: state.statusCode || 200,
+        headers: normalizeHeaders(state.headers),
+    });
+}
+/**
+ * Normalize headers to Response headers format
+ */
+function normalizeHeaders(headers) {
+    const normalized = {};
+    Object.entries(headers).forEach(([key, value]) => {
+        if (Array.isArray(value)) {
+            normalized[key] = value.join(', ');
+        }
+        else {
+            normalized[key] = String(value);
+        }
+    });
+    return normalized;
+}

package/nft.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Dependency tracing using @vercel/nft
+ * Finds all imports and dependencies of API route files
+ * and updates imports to point to original folders
+ */
+export interface ImportMap {
+    [importPath: string]: string;
+}
+/**
+ * Trace all imports in a file and create a map for rewriting them
+ * This analyzes the wrapper file location and creates relative paths
+ * back to the original import locations
+ */
+export declare function createImportMap(apiFilePath: string, wrapperFilePath: string): Promise<ImportMap>;
+/**
+ * Resolve import path relative to the importing file
+ */
+export declare function resolveImportPath(fromFile: string, importPath: string): string | null;
+/**
+ * Rewrite imports in wrapper content to point to original locations
+ * Updates relative imports to reference the correct paths from zuby-pages
+ */
+export declare function rewriteImportsInWrapper(wrapperContent: string, importMap: ImportMap): string;
+/**
+ * Get all relative imports from a file
+ */
+export declare function getRelativeImports(filePath: string): Promise<string[]>;
+/**
+ * Get all external dependencies (not relative imports)
+ */
+export declare function getExternalDependencies(filePath: string): Promise<string[]>;