@zubyjs/next 1.0.83

package/nft.js

@@ -0,0 +1,158 @@
+/**
+ * Dependency tracing using @vercel/nft
+ * Finds all imports and dependencies of API route files
+ * and updates imports to point to original folders
+ */
+import { dirname, resolve, relative } from 'path';
+import { existsSync } from 'fs';
+/**
+ * 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 async function createImportMap(apiFilePath, wrapperFilePath) {
+    const importMap = {};
+    try {
+        const fs = await import('fs/promises');
+        const content = await fs.readFile(apiFilePath, 'utf-8');
+        // Parse import/require statements
+        const importRegex = /(?:import|require)\s*\(?\s*['"]([^'"]+)['"]\s*\)?/g;
+        let match;
+        while ((match = importRegex.exec(content)) !== null) {
+            const importPath = match[1];
+            // Skip external packages and absolute paths
+            if (importPath.startsWith('@') ||
+                importPath.startsWith('/') ||
+                !importPath.includes('.') ||
+                importPath.includes('zuby')) {
+                continue;
+            }
+            // Resolve the import path relative to the API file
+            const resolvedPath = resolveImportPath(apiFilePath, importPath);
+            if (resolvedPath) {
+                // Calculate the correct relative path from wrapper to the actual import
+                const wrapperDir = dirname(wrapperFilePath);
+                const correctRelativePath = relative(wrapperDir, resolvedPath);
+                // Normalize for cross-platform compatibility
+                const normalizedPath = correctRelativePath.replace(/\\/g, '/');
+                importMap[importPath] = normalizedPath.startsWith('.')
+                    ? normalizedPath
+                    : `./${normalizedPath}`;
+            }
+        }
+    }
+    catch (error) {
+        console.warn(`Failed to create import map for ${apiFilePath}:`, error);
+    }
+    return importMap;
+}
+/**
+ * Resolve import path relative to the importing file
+ */
+export function resolveImportPath(fromFile, importPath) {
+    const fromDir = dirname(fromFile);
+    // Try the import path as-is
+    let resolved = resolve(fromDir, importPath);
+    if (existsSync(resolved))
+        return resolved;
+    // Try with .ts extension
+    if (existsSync(`${resolved}.ts`))
+        return `${resolved}.ts`;
+    if (existsSync(`${resolved}.tsx`))
+        return `${resolved}.tsx`;
+    if (existsSync(`${resolved}.js`))
+        return `${resolved}.js`;
+    if (existsSync(`${resolved}.jsx`))
+        return `${resolved}.jsx`;
+    if (existsSync(`${resolved}.mjs`))
+        return `${resolved}.mjs`;
+    if (existsSync(`${resolved}.cjs`))
+        return `${resolved}.cjs`;
+    // Try as directory with index file
+    if (existsSync(`${resolved}/index.ts`))
+        return `${resolved}/index.ts`;
+    if (existsSync(`${resolved}/index.tsx`))
+        return `${resolved}/index.tsx`;
+    if (existsSync(`${resolved}/index.js`))
+        return `${resolved}/index.js`;
+    if (existsSync(`${resolved}/index.jsx`))
+        return `${resolved}/index.jsx`;
+    return null;
+}
+/**
+ * Rewrite imports in wrapper content to point to original locations
+ * Updates relative imports to reference the correct paths from zuby-pages
+ */
+export function rewriteImportsInWrapper(wrapperContent, importMap) {
+    let updatedContent = wrapperContent;
+    for (const [originalPath, correctPath] of Object.entries(importMap)) {
+        // Match different import/require patterns
+        const patterns = [
+            new RegExp(`from\\s+['"]${escapeRegex(originalPath)}['"]`, 'g'),
+            new RegExp(`require\\s*\\(\\s*['"]${escapeRegex(originalPath)}['"]\\s*\\)`, 'g'),
+            new RegExp(`import\\s+['"]${escapeRegex(originalPath)}['"]`, 'g'),
+        ];
+        for (const pattern of patterns) {
+            updatedContent = updatedContent.replace(pattern, (match) => {
+                return match.replace(originalPath, correctPath);
+            });
+        }
+    }
+    return updatedContent;
+}
+/**
+ * Escape special regex characters
+ */
+function escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * Get all relative imports from a file
+ */
+export async function getRelativeImports(filePath) {
+    const imports = [];
+    try {
+        const fs = await import('fs/promises');
+        const content = await fs.readFile(filePath, 'utf-8');
+        // Parse import/require statements
+        const importRegex = /(?:import|require)\s*\(?\s*['"]([^'"]+)['"]\s*\)?/g;
+        let match;
+        while ((match = importRegex.exec(content)) !== null) {
+            const importPath = match[1];
+            // Only include relative imports
+            if (importPath.startsWith('.')) {
+                imports.push(importPath);
+            }
+        }
+    }
+    catch (error) {
+        console.warn(`Could not read ${filePath}:`, error);
+    }
+    return imports;
+}
+/**
+ * Get all external dependencies (not relative imports)
+ */
+export async function getExternalDependencies(filePath) {
+    const external = [];
+    try {
+        const fs = await import('fs/promises');
+        const content = await fs.readFile(filePath, 'utf-8');
+        // Parse import/require statements
+        const importRegex = /(?:import|require)\s*\(?\s*['"]([^'"]+)['"]\s*\)?/g;
+        let match;
+        while ((match = importRegex.exec(content)) !== null) {
+            const importPath = match[1];
+            // Only include external packages (not relative imports or zuby)
+            if (!importPath.startsWith('.') &&
+                !importPath.startsWith('/') &&
+                !importPath.includes('zuby')) {
+                external.push(importPath);
+            }
+        }
+    }
+    catch (error) {
+        console.warn(`Could not read ${filePath}:`, error);
+    }
+    return external;
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+    "name": "@zubyjs/next",
+    "version": "1.0.83",
+    "description": "Zuby.js Next.js compatibility plugin",
+    "type": "module",
+    "main": "index.js",
+    "scripts": {
+        "release": "cd ./dist && npm publish --access public && cd ..",
+        "bump-version": "npm version patch",
+        "build": "rm -rf dist/ stage/ && mkdir dist && tsc && cp -rf package.json README.md stage/next/src/* dist/ && rm -rf stage/",
+        "push-build": "npm run build && cd dist && yalc push --force && cd ..",
+        "test": "vitest run",
+        "test:coverage": "vitest run --coverage"
+    },
+    "publishConfig": {
+        "directory": "dist",
+        "linkDirectory": true
+    },
+    "peerDependencies": {
+        "zuby": "^1.0.0"
+    },
+    "bugs": {
+        "url": "https://gitlab.com/futrou/zuby.js/-/issues",
+        "email": "zuby@futrou.com"
+    },
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "git+https://gitlab.com/futrou/zuby.js.git"
+    },
+    "homepage": "https://zubyjs.com",
+    "keywords": [
+        "zuby-plugin",
+        "zuby",
+        "next",
+        "seo"
+    ],
+    "engines": {
+        "node": ">=18"
+    }
+}

package/types.d.ts

@@ -0,0 +1,125 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+/**
+ * Next.js API request object for compatibility
+ * Represents an incoming HTTP request in an API route
+ */
+export interface NextApiRequest {
+    /**
+     * The request URL
+     */
+    url?: string;
+    /**
+     * The request method (GET, POST, PUT, DELETE, PATCH, etc.)
+     */
+    method?: string;
+    /**
+     * Query parameters from the URL
+     * @example { id: '123', name: 'test' }
+     */
+    query: Record<string, string | string[]>;
+    /**
+     * Request cookies
+     * @example { sessionId: 'abc123' }
+     */
+    cookies: Record<string, string>;
+    /**
+     * Request headers
+     */
+    headers: Record<string, string | string[] | undefined>;
+    /**
+     * The request body
+     */
+    body?: any;
+    /**
+     * The base URL
+     */
+    baseUrl?: string;
+    /**
+     * The path after removing query string
+     */
+    pathname?: string;
+    /**
+     * HTTP version
+     */
+    httpVersion?: string;
+    /**
+     * The IP address of the requester
+     */
+    socket?: {
+        remoteAddress?: string;
+    };
+}
+/**
+ * Generic Next.js API response object for compatibility
+ * Represents the response object in an API route with typed body
+ * @template TBody The type of the response body
+ */
+export interface NextApiResponse<TBody = any> {
+    /**
+     * HTTP status code
+     */
+    statusCode: number;
+    /**
+     * Response headers
+     */
+    headers: Record<string, string | string[] | number>;
+    /**
+     * Set the status code (chainable)
+     */
+    status(code: number): this;
+    /**
+     * Set a header (chainable)
+     */
+    setHeader(name: string, value: string | string[] | number): this;
+    /**
+     * Get a header
+     */
+    getHeader(name: string): string | string[] | number | undefined;
+    /**
+     * Check if header was sent
+     */
+    headersSent: boolean;
+    /**
+     * Send a JSON response
+     */
+    json(body: TBody): void;
+    /**
+     * Send a text response
+     */
+    send(body: any): void;
+    /**
+     * Send a specific status with body
+     */
+    end(body?: any): void;
+    /**
+     * Write data to the response
+     */
+    write(chunk: string | Buffer): void;
+    /**
+     * Redirect to a URL
+     */
+    redirect(statusOrUrl: string | number, url?: string): void;
+    /**
+     * The actual response body
+     */
+    _responseBody?: any;
+    /**
+     * Whether response has been sent
+     */
+    _isResponseSent?: boolean;
+}
+/**
+ * Next.js API handler type for single method handlers
+ * @template TBody The type of the response body
+ * @example
+ * export default function handler(req: NextApiRequest, res: NextApiResponse<string>) {
+ *   return new Response('Hello world');
+ * }
+ */
+export type NextApiHandler<TBody = any> = (req: NextApiRequest, res: NextApiResponse<TBody>) => Response | Promise<Response> | void | Promise<void>;
+/**
+ * Next.js API method handler for specific HTTP methods
+ * @template TBody The type of the response body
+ */
+export type NextApiMethodHandler<TBody = any> = (req: NextApiRequest, res: NextApiResponse<TBody>) => Response | Promise<Response> | void | Promise<void>;

package/types.js

@@ -0,0 +1 @@
+export {};

package/utils.d.ts

@@ -0,0 +1,23 @@
+import type { TemplateFile } from 'zuby/templates/types.js';
+export interface NextPage extends TemplateFile {
+    hasGetStaticProps?: boolean;
+    hasGetServerSideProps?: boolean;
+}
+/**
+ * Scan the Next.js pages/api directory and convert to Zuby handler paths
+ * @param pagesDir The pages directory path
+ * @returns Array of TemplateFile objects for handlers
+ */
+export declare function scanNextApiPages(pagesDir: string): Promise<TemplateFile[]>;
+/**
+ * Scan the Next.js pages directory for React pages (excluding api subdirectory)
+ * @param pagesDir The pages directory path
+ * @returns Array of NextPage objects
+ */
+export declare function scanNextPages(pagesDir: string): Promise<NextPage[]>;
+/**
+ * Convert Next.js API route module to Zuby handler format
+ * Wraps default export and method exports (get, post, put, delete, patch)
+ * to return Response objects compatible with Zuby.js
+ */
+export declare function wrapNextApiModule(module: any): any;

package/utils.js

@@ -0,0 +1,336 @@
+import { relative } from 'path';
+import { readdir, stat } from 'fs/promises';
+/**
+ * Scan the Next.js pages/api directory and convert to Zuby handler paths
+ * @param pagesDir The pages directory path
+ * @returns Array of TemplateFile objects for handlers
+ */
+export async function scanNextApiPages(pagesDir) {
+    const apiDir = `${pagesDir}/api`;
+    const handlers = [];
+    try {
+        await scanDirectory(apiDir, apiDir, handlers, 'handler');
+    }
+    catch (error) {
+        // API directory might not exist, which is fine
+        if (error?.code !== 'ENOENT') {
+            throw error;
+        }
+    }
+    return handlers;
+}
+/**
+ * Scan the Next.js pages directory for React pages (excluding api subdirectory)
+ * @param pagesDir The pages directory path
+ * @returns Array of NextPage objects
+ */
+export async function scanNextPages(pagesDir) {
+    const pages = [];
+    try {
+        await scanPageDirectory(pagesDir, pagesDir, pages);
+    }
+    catch (error) {
+        // Pages directory might not exist, which is fine
+        if (error?.code !== 'ENOENT') {
+            throw error;
+        }
+    }
+    return pages;
+}
+/**
+ * Recursively scan a directory for API route files or page files
+ */
+async function scanDirectory(currentDir, baseDir, items, type = 'handler') {
+    const entries = await readdir(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = `${currentDir}/${entry.name}`;
+        const stats = await stat(fullPath);
+        if (stats.isDirectory()) {
+            await scanDirectory(fullPath, baseDir, items, type);
+        }
+        else {
+            const relativePath = relative(baseDir, fullPath);
+            const routePath = `/${relativePath
+                .replace(/\\/g, '/')
+                .replace(/\.(tsx?|jsx?)$/, '')
+                .replace(/\/index$/, '')
+                .replace(/\[(.+?)\]/g, ':$1')}`;
+            items.push({
+                path: routePath,
+                filename: fullPath,
+                templateType: type,
+            });
+        }
+    }
+}
+/**
+ * Recursively scan the pages directory for React page components
+ * Excludes the api subdirectory
+ */
+async function scanPageDirectory(currentDir, baseDir, pages) {
+    const entries = await readdir(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+        // Skip api directory
+        if (entry.isDirectory() && entry.name === 'api') {
+            continue;
+        }
+        const fullPath = `${currentDir}/${entry.name}`;
+        const stats = await stat(fullPath);
+        if (stats.isDirectory()) {
+            await scanPageDirectory(fullPath, baseDir, pages);
+        }
+        else {
+            const content = await readFileContent(fullPath);
+            const hasGetStaticProps = /export\s+(async\s+)?function\s+getStaticProps|export\s+const\s+getStaticProps/.test(content);
+            const hasGetServerSideProps = /export\s+(async\s+)?function\s+getServerSideProps|export\s+const\s+getServerSideProps/.test(content);
+            const relativePath = relative(baseDir, fullPath);
+            const routePath = `/${relativePath
+                .replace(/\\/g, '/')
+                .replace(/\.(tsx?)$/, '')
+                .replace(/\/index$/, '')}`;
+            pages.push({
+                path: routePath,
+                filename: fullPath,
+                templateType: 'page',
+                hasGetStaticProps,
+                hasGetServerSideProps,
+            });
+        }
+    }
+}
+/**
+ * Read file content as string
+ */
+async function readFileContent(filePath) {
+    try {
+        const fs = await import('fs/promises');
+        return await fs.readFile(filePath, 'utf-8');
+    }
+    catch {
+        return '';
+    }
+}
+/**
+ * Convert Next.js API route module to Zuby handler format
+ * Wraps default export and method exports (get, post, put, delete, patch)
+ * to return Response objects compatible with Zuby.js
+ */
+export function wrapNextApiModule(module) {
+    const wrapped = {
+        __nextApiHandlers: true,
+    };
+    // Handle default export (all methods)
+    if (typeof module.default === 'function') {
+        wrapped.default = wrapHandler(module.default);
+    }
+    // Handle method-specific exports
+    const httpMethods = ['get', 'post', 'put', 'delete', 'patch', 'head', 'options'];
+    for (const method of httpMethods) {
+        if (typeof module[method] === 'function') {
+            wrapped[method.toUpperCase()] = wrapHandler(module[method]);
+        }
+    }
+    return wrapped;
+}
+/**
+ * Wrap a Next.js API handler to return a Response object
+ */
+function wrapHandler(handler) {
+    return async (context) => {
+        const req = createNextApiRequest(context);
+        const res = createNextApiResponse();
+        try {
+            const result = await handler(req, res);
+            // If handler returns a Response, use it
+            if (result instanceof Response) {
+                return result;
+            }
+            // If response was explicitly sent, use that
+            if (res._isResponseSent && res._responseBody !== undefined) {
+                const body = res._responseBody;
+                const contentType = res.headers['content-type'] || 'application/json';
+                return new Response(typeof body === 'string' ? body : JSON.stringify(body), {
+                    status: res.statusCode,
+                    headers: normalizeHeaders(res.headers),
+                });
+            }
+            // Default: return empty 200 response
+            return new Response(null, {
+                status: res.statusCode || 200,
+                headers: normalizeHeaders(res.headers),
+            });
+        }
+        catch (error) {
+            // Return error response
+            return new Response(JSON.stringify({
+                error: 'Internal Server Error',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            }), {
+                status: 500,
+                headers: { 'content-type': 'application/json' },
+            });
+        }
+    };
+}
+/**
+ * Create a Next.js API request object from Zuby context
+ */
+function createNextApiRequest(context) {
+    const url = new URL(context.url || '/', 'http://localhost');
+    const query = {};
+    // Parse query parameters
+    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
+    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 (context.clientAddress) {
+        req.socket = { remoteAddress: context.clientAddress };
+    }
+    return req;
+}
+/**
+ * Create a Next.js API response object
+ */
+function createNextApiResponse() {
+    const res = {
+        statusCode: 200,
+        headers: {},
+        headersSent: false,
+        _responseBody: undefined,
+        _isResponseSent: false,
+        status(code) {
+            this.statusCode = code;
+            return this;
+        },
+        setHeader(name, value) {
+            this.headers[name.toLowerCase()] = value;
+            return this;
+        },
+        getHeader(name) {
+            return this.headers[name.toLowerCase()];
+        },
+        json(body) {
+            this.setHeader('content-type', 'application/json');
+            this._responseBody = JSON.stringify(body);
+            this._isResponseSent = true;
+            return this;
+        },
+        send(body) {
+            this._responseBody = body;
+            this._isResponseSent = true;
+            if (typeof body === 'string') {
+                this.setHeader('content-type', 'text/plain');
+            }
+            else if (typeof body === 'object') {
+                this.setHeader('content-type', 'application/json');
+                this._responseBody = JSON.stringify(body);
+            }
+            return this;
+        },
+        end(body) {
+            if (body !== undefined) {
+                this.send(body);
+            }
+            this._isResponseSent = true;
+            return this;
+        },
+        write(chunk) {
+            if (!this._responseBody) {
+                this._responseBody = '';
+            }
+            this._responseBody += chunk;
+            return true;
+        },
+        redirect(statusOrUrl, url) {
+            if (typeof statusOrUrl === 'string') {
+                this.statusCode = 302;
+                this._responseBody = statusOrUrl;
+            }
+            else {
+                this.statusCode = statusOrUrl;
+                this._responseBody = url;
+            }
+            this.setHeader('location', typeof statusOrUrl === 'string' ? statusOrUrl : url || '');
+            this._isResponseSent = true;
+            return this;
+        },
+    };
+    return res;
+}
+/**
+ * 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;
+}
+/**
+ * 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;
+}