nuxt-openapi-hyperfetch 0.1.0-alpha.1

package/src/generators/nuxt-server/templates.ts

@@ -0,0 +1,483 @@
+import type { MethodInfo } from './types.js';
+import { camelCase, pascalCase } from 'change-case';
+
+/**
+ * Generate file header with auto-generation warning
+ */
+function generateFileHeader(): string {
+  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: MethodInfo,
+  apiImportPath: string,
+  options?: {
+    enableBff?: boolean;
+    resource?: string;
+  }
+): string {
+  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: MethodInfo): string {
+  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: string): string[] {
+  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: MethodInfo, apiImportPath: string): string {
+  const h3Imports: string[] = ['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<string>();
+
+  // 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: MethodInfo,
+  options?: {
+    enableBff?: boolean;
+    resource?: string;
+  }
+): string {
+  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: MethodInfo): string {
+  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: MethodInfo): string {
+  if (!method.hasQueryParams) {
+    return '';
+  }
+  return 'const query = getQuery(event)\n  ';
+}
+
+/**
+ * Generate body capture code
+ */
+function generateBodyCapture(method: MethodInfo): string {
+  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: MethodInfo): string {
+  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: MethodInfo): string {
+  const options: string[] = [];
+
+  // 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: string[] = [];
+  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(): string {
+  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(): string {
+  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: string): string {
+  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: MethodInfo[]): string {
+  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/src/generators/nuxt-server/types.ts

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