nuxt-openapi-hyperfetch 0.1.0-alpha.1

package/dist/generators/nuxt-server/generator.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Main function to generate Nuxt Server Routes
+ */
+export declare function generateNuxtServerRoutes(inputDir: string, serverRoutePath: string, options?: {
+    enableBff?: boolean;
+    backend?: string;
+}): Promise<void>;

package/dist/generators/nuxt-server/generator.js

@@ -0,0 +1,206 @@
+import * as path from 'path';
+import fs from 'fs-extra';
+import { format } from 'prettier';
+import { getApiFiles as getApiFilesOfficial, parseApiFile as parseApiFileOfficial, } from './parser.js';
+import { getApiFiles as getApiFilesHeyApi, parseApiFile as parseApiFileHeyApi, } from '../shared/parsers/heyapi-parser.js';
+import { generateServerRouteFile, generateRouteFilePath, generateRoutesIndexFile, } from './templates.js';
+import { generateAuthContextStub, generateAuthTypesStub, generateTransformerStub, generateTransformerExamples, generateBffReadme, } from './bff-templates.js';
+import { p, logSuccess, logError, logNote } from '../../cli/logger.js';
+/**
+ * Main function to generate Nuxt Server Routes
+ */
+export async function generateNuxtServerRoutes(inputDir, serverRoutePath, options) {
+    const mainSpinner = p.spinner();
+    // Select parser based on chosen backend
+    const getApiFiles = options?.backend === 'heyapi' ? getApiFilesHeyApi : getApiFilesOfficial;
+    const parseApiFile = options?.backend === 'heyapi' ? parseApiFileHeyApi : parseApiFileOfficial;
+    const enableBff = options?.enableBff ?? false;
+    if (enableBff) {
+        p.log.info('BFF Mode: Enabled (transformers + auth)');
+    }
+    // 1. Get all API files
+    mainSpinner.start('Scanning API files');
+    const apiFiles = getApiFiles(inputDir);
+    mainSpinner.stop(`Found ${apiFiles.length} API file(s)`);
+    if (apiFiles.length === 0) {
+        throw new Error('No API files found in the input directory');
+    }
+    // 2. Parse each API file
+    mainSpinner.start('Parsing API files');
+    const allMethods = [];
+    for (const file of apiFiles) {
+        const fileName = path.basename(file);
+        try {
+            const apiInfo = parseApiFile(file);
+            allMethods.push(...apiInfo.methods);
+        }
+        catch (error) {
+            logError(`Error parsing ${fileName}: ${String(error)}`);
+        }
+    }
+    mainSpinner.stop(`Found ${allMethods.length} routes to generate`);
+    if (allMethods.length === 0) {
+        p.log.warn('No methods found to generate');
+        return;
+    }
+    // 3. Clean and create output directory
+    mainSpinner.start('Preparing output directory');
+    await fs.emptyDir(serverRoutePath);
+    mainSpinner.stop('Output directory ready');
+    // 4. Generate BFF structure if enabled
+    if (enableBff) {
+        await generateBffStructure(allMethods, serverRoutePath, inputDir);
+    }
+    // 5. Calculate relative import path from server routes to APIs
+    const relativePath = calculateRelativeImportPath(serverRoutePath, inputDir);
+    // 6. Generate each server route
+    mainSpinner.start('Generating server routes');
+    let successCount = 0;
+    let errorCount = 0;
+    for (const method of allMethods) {
+        try {
+            // Extract resource name from path
+            const resource = extractResourceFromPath(method.path);
+            const code = generateServerRouteFile(method, relativePath, {
+                enableBff: enableBff,
+                resource: resource,
+            });
+            const formattedCode = await formatCode(code);
+            const routeFilePath = generateRouteFilePath(method);
+            const fullPath = path.join(serverRoutePath, routeFilePath);
+            // Ensure directory exists
+            await fs.ensureDir(path.dirname(fullPath));
+            await fs.writeFile(fullPath, formattedCode, 'utf-8');
+            successCount++;
+        }
+        catch (error) {
+            logError(`Error generating ${method.path} [${method.httpMethod}]: ${String(error)}`);
+            errorCount++;
+        }
+    }
+    mainSpinner.stop(`Generated ${successCount} server routes`);
+    // 7. Generate configuration files
+    mainSpinner.start('Generating configuration files');
+    // Generate routes index (documentation)
+    const routesIndexCode = generateRoutesIndexFile(allMethods);
+    const formattedRoutesIndex = await formatCode(routesIndexCode);
+    await fs.writeFile(path.join(serverRoutePath, '_routes.ts'), formattedRoutesIndex, 'utf-8');
+    mainSpinner.stop('Configuration files generated');
+    // 8. Summary and Next Steps
+    if (errorCount > 0) {
+        p.log.warn(`Completed with ${errorCount} error(s)`);
+    }
+    logSuccess(`Generated ${successCount} server route(s) in ${serverRoutePath}`);
+    // Build next steps message
+    let nextSteps = '1. Configure API_BASE_URL and API_SECRET in your .env\n';
+    nextSteps += '2. Update nuxt.config.ts with runtimeConfig (add apiBaseUrl and apiSecret)';
+    if (enableBff) {
+        nextSteps += '\n3. Implement authentication in server/auth/context.ts';
+        nextSteps += '\n4. Add business logic to transformers in server/bff/transformers/';
+        nextSteps += '\n5. See server/bff/README.md for BFF documentation';
+        nextSteps += '\n6. Start your Nuxt dev server and test the routes';
+    }
+    else {
+        nextSteps += '\n3. Start your Nuxt dev server and test the routes';
+    }
+    logNote(nextSteps, 'Next steps');
+}
+/**
+ * Calculate relative import path from server routes to APIs
+ */
+function calculateRelativeImportPath(serverRoutePath, inputDir) {
+    // Use Nuxt's ~ alias (project root) so the path is stable regardless of serverRoutePath depth
+    const projectRoot = process.cwd();
+    const relativeInputDir = path.relative(projectRoot, path.resolve(inputDir));
+    // Convert Windows paths to Unix-style
+    return '~/' + relativeInputDir.replace(/\\/g, '/');
+}
+/**
+ * Format code with Prettier
+ */
+async function formatCode(code) {
+    try {
+        return await format(code, {
+            parser: 'typescript',
+            semi: false,
+            singleQuote: true,
+            trailingComma: 'es5',
+            printWidth: 100,
+        });
+    }
+    catch {
+        p.log.warn('Prettier formatting failed, using unformatted code');
+        return code;
+    }
+}
+/**
+ * Generate BFF structure (auth + transformers)
+ */
+async function generateBffStructure(allMethods, serverRoutePath, inputDir) {
+    const bffSpinner = p.spinner();
+    bffSpinner.start('Generating BFF structure (auth + transformers)');
+    const serverRoot = path.dirname(serverRoutePath);
+    // 1. Generate auth files (only if they don't exist)
+    const authDir = path.join(serverRoot, 'auth');
+    await fs.ensureDir(authDir);
+    const authContextPath = path.join(authDir, 'context.ts');
+    if (!fs.existsSync(authContextPath)) {
+        const authContextCode = generateAuthContextStub();
+        const formattedAuthContext = await formatCode(authContextCode);
+        await fs.writeFile(authContextPath, formattedAuthContext, 'utf-8');
+    }
+    const authTypesPath = path.join(authDir, 'types.ts');
+    if (!fs.existsSync(authTypesPath)) {
+        const authTypesCode = generateAuthTypesStub();
+        const formattedAuthTypes = await formatCode(authTypesCode);
+        await fs.writeFile(authTypesPath, formattedAuthTypes, 'utf-8');
+    }
+    // 2. Generate transformer stubs (only if they don't exist)
+    const bffDir = path.join(serverRoot, 'bff');
+    const transformersDir = path.join(bffDir, 'transformers');
+    await fs.ensureDir(transformersDir);
+    // Group methods by resource
+    const methodsByResource = new Map();
+    for (const method of allMethods) {
+        const resource = extractResourceFromPath(method.path);
+        if (!methodsByResource.has(resource)) {
+            methodsByResource.set(resource, []);
+        }
+        methodsByResource.get(resource).push(method);
+    }
+    // Generate transformer for each resource
+    for (const [resource, methods] of methodsByResource.entries()) {
+        const transformerPath = path.join(transformersDir, `${resource}.ts`);
+        if (!fs.existsSync(transformerPath)) {
+            const transformerCode = generateTransformerStub(resource, methods, inputDir);
+            const formattedTransformer = await formatCode(transformerCode);
+            await fs.writeFile(transformerPath, formattedTransformer, 'utf-8');
+        }
+    }
+    // 3. Generate examples file (always regenerated)
+    const examplesPath = path.join(bffDir, '_transformers.example.ts');
+    const examplesCode = generateTransformerExamples();
+    const formattedExamples = await formatCode(examplesCode);
+    await fs.writeFile(examplesPath, formattedExamples, 'utf-8');
+    // 4. Generate BFF README (always regenerated)
+    const bffReadmePath = path.join(bffDir, 'README.md');
+    const bffReadmeCode = generateBffReadme();
+    await fs.writeFile(bffReadmePath, bffReadmeCode, 'utf-8');
+    bffSpinner.stop('BFF structure generated');
+}
+/**
+ * Extract resource name from API path
+ * Examples:
+ *   /pet -> pet
+ *   /pet/{id} -> pet
+ *   /store/inventory -> store
+ *   /user/login -> user
+ */
+function extractResourceFromPath(path) {
+    // Remove leading slash
+    const cleanPath = path.startsWith('/') ? path.substring(1) : path;
+    // Get first segment
+    const firstSegment = cleanPath.split('/')[0];
+    // Remove any path params
+    return firstSegment.replace(/\{[^}]+\}/g, '').toLowerCase();
+}

package/dist/generators/nuxt-server/parser.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Re-export all parser functionality from use-fetch
+ * The parsing logic is identical for all generators
+ */
+export * from '../use-fetch/parser.js';

package/dist/generators/nuxt-server/parser.js

@@ -0,0 +1,5 @@
+/**
+ * Re-export all parser functionality from use-fetch
+ * The parsing logic is identical for all generators
+ */
+export * from '../use-fetch/parser.js';

package/dist/generators/nuxt-server/templates.d.ts

@@ -0,0 +1,35 @@
+import type { MethodInfo } from './types.js';
+/**
+ * Generate a complete server route file
+ */
+export declare function generateServerRouteFile(method: MethodInfo, apiImportPath: string, options?: {
+    enableBff?: boolean;
+    resource?: string;
+}): string;
+/**
+ * Calculate the file path for a server route
+ * Examples:
+ *   /pet + GET -> pet/index.get.ts
+ *   /pet + POST -> pet/index.post.ts
+ *   /pet/{petId} + GET -> pet/[id].get.ts
+ *   /pet/{petId}/uploadImage + POST -> pet/[id]/uploadImage.post.ts
+ *   /store/inventory + GET -> store/inventory.get.ts
+ *   /user/{username} + GET -> user/[username].get.ts
+ */
+export declare function generateRouteFilePath(method: MethodInfo): string;
+/**
+ * Generate nuxt.config.example.ts
+ */
+export declare function generateConfigFile(): string;
+/**
+ * Generate .env.example
+ */
+export declare function generateEnvFile(): string;
+/**
+ * Generate README.md
+ */
+export declare function generateReadme(serverPath: string): string;
+/**
+ * Generate index file that exports all route paths (optional, for documentation)
+ */
+export declare function generateRoutesIndexFile(methods: MethodInfo[]): string;

package/dist/generators/nuxt-server/templates.js

@@ -0,0 +1,412 @@
+import { camelCase, pascalCase } from 'change-case';
+/**
+ * Generate file header with auto-generation warning
+ */
+function generateFileHeader() {
+    return `/**
+ * ⚠️ AUTO-GENERATED FILE - DO NOT EDIT MANUALLY
+ * 
+ * This file was automatically generated by nuxt-openapi-generator.
+ * Any manual changes will be overwritten on the next generation.
+ * 
+ * @generated by nuxt-openapi-generator
+ * @see https://github.com/dmartindiaz/nuxt-openapi-hyperfetch
+ */
+
+/* eslint-disable */
+// @ts-nocheck
+`;
+}
+/**
+ * Generate a complete server route file
+ */
+export function generateServerRouteFile(method, apiImportPath, options) {
+    const header = generateFileHeader();
+    const imports = generateImports(method, apiImportPath);
+    const handlerBody = generateHandlerBody(method, options);
+    return `${header}${imports}\n\n${handlerBody}\n`;
+}
+/**
+ * Calculate the file path for a server route
+ * Examples:
+ *   /pet + GET -> pet/index.get.ts
+ *   /pet + POST -> pet/index.post.ts
+ *   /pet/{petId} + GET -> pet/[id].get.ts
+ *   /pet/{petId}/uploadImage + POST -> pet/[id]/uploadImage.post.ts
+ *   /store/inventory + GET -> store/inventory.get.ts
+ *   /user/{username} + GET -> user/[username].get.ts
+ */
+export function generateRouteFilePath(method) {
+    let routePath = method.path;
+    // Remove leading slash
+    if (routePath.startsWith('/')) {
+        routePath = routePath.substring(1);
+    }
+    // Replace path params: {petId} -> [id], {username} -> [username]
+    routePath = routePath.replace(/\{(\w+)\}/g, (match, paramName) => {
+        // Simplify common params
+        const simplified = paramName.toLowerCase().replace(/id$/, '');
+        return `[${simplified || 'id'}]`;
+    });
+    // Split path into segments
+    const segments = routePath.split('/').filter(Boolean);
+    // If empty or root, use 'index'
+    if (segments.length === 0) {
+        return `index.${method.httpMethod.toLowerCase()}.ts`;
+    }
+    // Check if last segment is a dynamic param [xxx]
+    const lastSegment = segments[segments.length - 1];
+    const isDynamicParam = lastSegment.startsWith('[') && lastSegment.endsWith(']');
+    // If last segment is dynamic, add index
+    if (isDynamicParam) {
+        return `${segments.join('/')}/index.${method.httpMethod.toLowerCase()}.ts`;
+    }
+    // Otherwise, use the last segment as filename
+    const fileName = segments.pop();
+    const dir = segments.length > 0 ? segments.join('/') + '/' : '';
+    return `${dir}${fileName}.${method.httpMethod.toLowerCase()}.ts`;
+}
+/**
+ * Extract base type names from a type string (same as use-fetch)
+ */
+function extractBaseTypes(type) {
+    if (!type) {
+        return [];
+    }
+    // Handle array syntax: Pet[]
+    const arrayMatch = type.match(/^(\w+)\[\]$/);
+    if (arrayMatch) {
+        return [arrayMatch[1]];
+    }
+    // Handle Array generic: Array<Pet>
+    const arrayGenericMatch = type.match(/^Array<(\w+)>$/);
+    if (arrayGenericMatch) {
+        return [arrayGenericMatch[1]];
+    }
+    // If it's a simple named type (single word, PascalCase), include it
+    if (/^[A-Z][a-zA-Z0-9]*$/.test(type)) {
+        return [type];
+    }
+    return [];
+}
+/**
+ * Generate import statements
+ */
+function generateImports(method, apiImportPath) {
+    const h3Imports = ['defineEventHandler', 'createError'];
+    // Add h3 imports based on method needs
+    if (method.pathParams.length > 0) {
+        h3Imports.push('getRouterParam');
+    }
+    if (method.hasQueryParams) {
+        h3Imports.push('getQuery');
+    }
+    if (method.hasBody) {
+        h3Imports.push('readBody');
+    }
+    let imports = `import { ${h3Imports.join(', ')} } from 'h3'\n`;
+    // Import types
+    const typeNames = new Set();
+    // Extract base types from request type
+    if (method.requestType) {
+        const extracted = extractBaseTypes(method.requestType);
+        extracted.forEach((t) => typeNames.add(t));
+    }
+    // Extract base types from response type
+    if (method.responseType && method.responseType !== 'void') {
+        const extracted = extractBaseTypes(method.responseType);
+        extracted.forEach((t) => typeNames.add(t));
+    }
+    // Import types from API (only if we have named types to import)
+    if (typeNames.size > 0) {
+        imports += `import type { ${Array.from(typeNames).join(', ')} } from '${apiImportPath}'\n`;
+    }
+    return imports;
+}
+/**
+ * Generate the handler body
+ */
+function generateHandlerBody(method, options) {
+    const description = method.description ? `/**\n * ${method.description}\n */\n` : '';
+    const pathParamCapture = generatePathParamCapture(method);
+    const queryCapture = generateQueryCapture(method);
+    const bodyCapture = generateBodyCapture(method);
+    const backendUrl = generateBackendUrl(method);
+    const fetchOptions = generateFetchOptions(method);
+    // BFF: Auth context loading
+    const authContextCode = options?.enableBff
+        ? `  // Try to load auth context (optional)
+  let auth = null
+  try {
+    const { getAuthContext } = await import('~/server/auth/context')
+    auth = await getAuthContext(event)
+  } catch {
+    // Auth not configured - continue without it
+  }
+  
+  `
+        : '';
+    // BFF: Transformer call
+    const transformerCode = options?.enableBff && options?.resource
+        ? `
+    // Try to transform data (optional)
+    try {
+      const { transform${pascalCase(options.resource)} } = await import('~/server/bff/transformers/${options.resource}')
+      return await transform${pascalCase(options.resource)}(data, event, auth)
+    } catch {
+      // Transformer not found - return raw data
+      return data
+    }`
+        : `
+    return data`;
+    return `${description}export default defineEventHandler(async (event): Promise<${method.responseType}> => {
+  ${pathParamCapture}${queryCapture}${bodyCapture}${authContextCode}const config = useRuntimeConfig()
+  const baseUrl = config.apiBaseUrl
+  
+  try {
+    const data = await $fetch<${method.responseType}>(${backendUrl}, {
+      ${fetchOptions}
+    })${transformerCode}
+  } catch (error: any) {
+    throw createError({
+      statusCode: error.statusCode || 500,
+      statusMessage: error.message || 'Request failed'
+    })
+  }
+})`;
+}
+/**
+ * Generate path param capture code
+ */
+function generatePathParamCapture(method) {
+    if (method.pathParams.length === 0) {
+        return '';
+    }
+    const captures = method.pathParams.map((param) => {
+        const paramName = camelCase(param);
+        const paramKey = param.toLowerCase().replace(/id$/, '') || 'id';
+        return `const ${paramName} = getRouterParam(event, '${paramKey}')
+  if (!${paramName}) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: '${param} is required'
+    })
+  }
+  `;
+    });
+    return captures.join('') + '\n  ';
+}
+/**
+ * Generate query param capture code
+ */
+function generateQueryCapture(method) {
+    if (!method.hasQueryParams) {
+        return '';
+    }
+    return 'const query = getQuery(event)\n  ';
+}
+/**
+ * Generate body capture code
+ */
+function generateBodyCapture(method) {
+    if (!method.hasBody) {
+        return '';
+    }
+    const typeAnnotation = method.requestType ? `<${method.requestType}>` : '';
+    return `const body = await readBody${typeAnnotation}(event)\n  `;
+}
+/**
+ * Generate backend URL with path params replaced
+ */
+function generateBackendUrl(method) {
+    let url = method.path;
+    // Replace {param} with ${paramName}
+    if (method.pathParams.length > 0) {
+        for (const param of method.pathParams) {
+            const paramName = camelCase(param);
+            url = url.replace(`{${param}}`, `\${${paramName}}`);
+        }
+        return `\`\${baseUrl}${url}\``;
+    }
+    // Static URL
+    return `\`\${baseUrl}${url}\``;
+}
+/**
+ * Generate $fetch options object
+ */
+function generateFetchOptions(method) {
+    const options = [];
+    // Method (if not GET)
+    if (method.httpMethod !== 'GET') {
+        options.push(`method: '${method.httpMethod}'`);
+    }
+    // Query params
+    if (method.hasQueryParams) {
+        options.push('query: query');
+    }
+    // Body
+    if (method.hasBody) {
+        options.push('body: body');
+    }
+    // Headers
+    const headerLines = [];
+    if (method.hasBody) {
+        headerLines.push(`'Content-Type': 'application/json'`);
+    }
+    headerLines.push(`...(config.apiSecret ? { 'Authorization': \`Bearer \${config.apiSecret}\` } : {})`);
+    options.push(`headers: {\n        ${headerLines.join(',\n        ')}\n      }`);
+    return options.join(',\n      ');
+}
+/**
+ * Generate nuxt.config.example.ts
+ */
+export function generateConfigFile() {
+    return `/**
+ * ⚠️ AUTO-GENERATED EXAMPLE FILE
+ * 
+ * Copy this configuration to your nuxt.config.ts
+ * @generated by nuxt-openapi-generator
+ */
+
+// nuxt.config.ts
+export default defineNuxtConfig({
+  runtimeConfig: {
+    // Private keys (server-only, never exposed to client)
+    apiSecret: process.env.API_SECRET || '',
+    apiBaseUrl: process.env.API_BASE_URL || 'https://petstore3.swagger.io/api/v3'
+  }
+})
+`;
+}
+/**
+ * Generate .env.example
+ */
+export function generateEnvFile() {
+    return `# ⚠️ AUTO-GENERATED EXAMPLE FILE
+# Copy this file to .env and configure your values
+# @generated by nuxt-openapi-generator
+
+# Backend API Configuration
+API_BASE_URL=https://petstore3.swagger.io/api/v3
+API_SECRET=your-api-secret-token-here
+`;
+}
+/**
+ * Generate README.md
+ */
+export function generateReadme(serverPath) {
+    return `<!--
+⚠️ AUTO-GENERATED DOCUMENTATION
+This file was automatically generated by nuxt-openapi-generator.
+@generated by nuxt-openapi-generator
+-->
+
+# Nuxt Server Routes
+
+Auto-generated server routes that proxy requests to your backend API.
+
+## 🔧 Configuration
+
+1. **Copy \`.env.example\` to \`.env\`**:
+   \`\`\`bash
+   cp .env.example .env
+   \`\`\`
+
+2. **Update \`.env\` with your backend URL**:
+   \`\`\`env
+   API_BASE_URL=https://your-backend-api.com/api/v3
+   API_SECRET=your-secret-token
+   \`\`\`
+
+3. **Update \`nuxt.config.ts\`** (see \`nuxt.config.example.ts\`):
+   \`\`\`typescript
+   export default defineNuxtConfig({
+     runtimeConfig: {
+       // All these variables are server-only
+       apiSecret: process.env.API_SECRET || '',
+       apiBaseUrl: process.env.API_BASE_URL || ''
+     }
+   })
+   \`\`\`
+
+## 🚀 Usage
+
+All routes are available at \`/api/*\`:
+
+\`\`\`typescript
+// In your Vue components
+const { data: pet } = await useFetch('/api/pet/123')
+
+// With query params
+const { data: pets } = await useFetch('/api/pet', { 
+  query: { status: 'available' } 
+})
+
+// POST request
+const { data: newPet } = await useFetch('/api/pet', {
+  method: 'POST',
+  body: { name: 'Fluffy', status: 'available' }
+})
+\`\`\`
+
+## 📁 Generated Routes
+
+- **${serverPath}/** - All server routes
+- Each file corresponds to an OpenAPI endpoint
+- Path params use dynamic routes: \`[id]\`, \`[username]\`
+- HTTP methods: \`.get.ts\`, \`.post.ts\`, \`.put.ts\`, \`.delete.ts\`
+
+## 🔒 Security
+
+- \`API_SECRET\` is only available server-side (never exposed to client)
+- All requests go through your Nuxt server (CORS handled automatically)
+- You can add custom authentication/validation logic in each route
+
+## 🛠️ Customization
+
+Each generated route can be customized:
+
+\`\`\`typescript
+// server/api/pet/[id].get.ts
+export default defineEventHandler(async (event) => {
+  const petId = getRouterParam(event, 'id')
+  
+  // Add custom logic here
+  // - Rate limiting
+  // - Caching
+  // - Request validation
+  // - Response transformation
+  
+  const config = useRuntimeConfig()
+  const data = await \$fetch(\`\${config.apiBaseUrl}/pet/\${petId}\`)
+  
+  return data
+})
+\`\`\`
+`;
+}
+/**
+ * Generate index file that exports all route paths (optional, for documentation)
+ */
+export function generateRoutesIndexFile(methods) {
+    const header = generateFileHeader();
+    const routes = methods.map((method) => {
+        const filePath = generateRouteFilePath(method);
+        const routePath = '/' +
+            filePath
+                .replace(/\\/g, '/')
+                .replace(/index\.(get|post|put|delete|patch)\.ts$/, '')
+                .replace(/\.(get|post|put|delete|patch)\.ts$/, '')
+                .replace(/\[(\w+)\]/g, ':$1');
+        return `  // ${method.httpMethod} ${routePath} -> ${filePath}`;
+    });
+    return `${header}/**
+ * Generated Server Routes
+ * 
+ * Available routes:
+${routes.join('\n')}
+ */
+
+export default {}
+`;
+}

package/dist/generators/nuxt-server/types.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Re-export all types from shared types
+ * Nuxt Server uses the same MethodInfo structure
+ */
+export * from '../shared/types.js';

package/dist/generators/nuxt-server/types.js

@@ -0,0 +1,5 @@
+/**
+ * Re-export all types from shared types
+ * Nuxt Server uses the same MethodInfo structure
+ */
+export * from '../shared/types.js';