nuxt-openapi-hyperfetch 0.1.0-alpha.1

package/src/generators/use-fetch/generator.ts

@@ -0,0 +1,169 @@
+import * as path from 'path';
+import fs from 'fs-extra';
+import { fileURLToPath } from 'url';
+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 { generateComposableFile, generateIndexFile, type GenerateOptions } from './templates.js';
+import type { MethodInfo } from './types.js';
+import { p, logSuccess, logError } from '../../cli/logger.js';
+
+/**
+ * Main function to generate useFetch composables
+ */
+export async function generateUseFetchComposables(
+  inputDir: string,
+  outputDir: string,
+  options?: GenerateOptions
+): Promise<void> {
+  const mainSpinner = p.spinner();
+
+  // Select parser based on chosen backend
+  const getApiFiles = options?.backend === 'heyapi' ? getApiFilesHeyApi : getApiFilesOfficial;
+  const parseApiFile = options?.backend === 'heyapi' ? parseApiFileHeyApi : parseApiFileOfficial;
+
+  // 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: MethodInfo[] = [];
+
+  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} methods to generate`);
+
+  if (allMethods.length === 0) {
+    p.log.warn('No methods found to generate');
+    return;
+  }
+
+  // 3. Clean and create output directories
+  mainSpinner.start('Preparing output directories');
+  const composablesDir = path.join(outputDir, 'composables');
+  const runtimeDir = path.join(outputDir, 'runtime');
+  const sharedRuntimeDir = path.join(outputDir, 'shared', 'runtime');
+  await fs.emptyDir(composablesDir);
+  await fs.ensureDir(runtimeDir);
+  await fs.ensureDir(sharedRuntimeDir);
+  mainSpinner.stop('Output directories ready');
+
+  // 4. Copy runtime helpers
+  mainSpinner.start('Copying runtime files');
+  // Derive __dirname equivalent for ESM
+  const __dirname = path.dirname(fileURLToPath(import.meta.url));
+  // When compiled, __dirname points to dist/generators/use-fetch/
+  // We need to go back to src/ to get the original .ts files
+
+  // Copy useApiRequest.ts
+  const runtimeSource = path.resolve(
+    __dirname,
+    '../../../src/generators/use-fetch/runtime/useApiRequest.ts'
+  );
+  const runtimeDest = path.join(runtimeDir, 'useApiRequest.ts');
+  await fs.copyFile(runtimeSource, runtimeDest);
+
+  // Copy shared apiHelpers.ts
+  const sharedHelpersSource = path.resolve(
+    __dirname,
+    '../../../src/generators/shared/runtime/apiHelpers.ts'
+  );
+  const sharedHelpersDest = path.join(sharedRuntimeDir, 'apiHelpers.ts');
+  await fs.copyFile(sharedHelpersSource, sharedHelpersDest);
+  mainSpinner.stop('Runtime files copied');
+
+  // 5. Calculate relative import path from composables to APIs
+  const relativePath = calculateRelativeImportPath(composablesDir, inputDir);
+
+  // 6. Generate each composable
+  mainSpinner.start('Generating composables');
+  let successCount = 0;
+  let errorCount = 0;
+
+  for (const method of allMethods) {
+    try {
+      const code = generateComposableFile(method, relativePath, options);
+      const formattedCode = await formatCode(code);
+      const fileName = `${method.composableName}.ts`;
+      const filePath = path.join(composablesDir, fileName);
+
+      await fs.writeFile(filePath, formattedCode, 'utf-8');
+      successCount++;
+    } catch (error) {
+      logError(`Error generating ${method.composableName}: ${String(error)}`);
+      errorCount++;
+    }
+  }
+
+  // 7. Generate index.ts
+  const indexCode = generateIndexFile(allMethods.map((m) => m.composableName));
+  const formattedIndex = await formatCode(indexCode);
+  await fs.writeFile(path.join(outputDir, 'index.ts'), formattedIndex, 'utf-8');
+  mainSpinner.stop(`Generated ${successCount} composables`);
+
+  // 8. Summary
+  if (errorCount > 0) {
+    p.log.warn(`Completed with ${errorCount} error(s)`);
+  }
+  logSuccess(`Generated ${successCount} useFetch composable(s) in ${outputDir}`);
+}
+
+/**
+ * Calculate relative import path from composables to APIs
+ */
+function calculateRelativeImportPath(composablesDir: string, inputDir: string): string {
+  // Import from the root index.ts which exports apis, models, and runtime
+  let relativePath = path.relative(composablesDir, inputDir);
+
+  // Convert Windows paths to Unix-style
+  relativePath = relativePath.replace(/\\/g, '/');
+
+  // Ensure it starts with './' or '../'
+  if (!relativePath.startsWith('.')) {
+    relativePath = './' + relativePath;
+  }
+
+  // Remove .ts extension and trailing /
+  relativePath = relativePath.replace(/\.ts$/, '').replace(/\/$/, '');
+
+  return relativePath;
+}
+
+/**
+ * Format code with Prettier
+ */
+async function formatCode(code: string): Promise<string> {
+  try {
+    return await format(code, {
+      parser: 'typescript',
+      semi: true,
+      singleQuote: true,
+      trailingComma: 'es5',
+      printWidth: 80,
+      tabWidth: 2,
+    });
+  } catch {
+    p.log.warn('Could not format code with Prettier');
+    return code;
+  }
+}

package/src/generators/use-fetch/parser.ts

@@ -0,0 +1,341 @@
+import { Project, SourceFile, MethodDeclaration, SyntaxKind, Node } from 'ts-morph';
+import * as path from 'path';
+import { existsSync, readdirSync } from 'node:fs';
+import type { ApiClassInfo, MethodInfo } from './types.js';
+import { pascalCase } from 'change-case';
+import { p } from '../../cli/logger.js';
+
+/**
+ * Get all API files from the input directory
+ */
+export function getApiFiles(inputDir: string): string[] {
+  const apisDir = path.join(inputDir, 'apis');
+
+  if (!existsSync(apisDir)) {
+    throw new Error(`APIs directory not found: ${apisDir}`);
+  }
+
+  const files = readdirSync(apisDir);
+  return files
+    .filter((file: string) => file.endsWith('.ts') && file !== 'index.ts')
+    .map((file: string) => path.join(apisDir, file));
+}
+
+/**
+ * Parse an API file and extract all methods
+ */
+export function parseApiFile(filePath: string): ApiClassInfo {
+  const project = new Project();
+  const sourceFile = project.addSourceFileAtPath(filePath);
+
+  // Find the API class (e.g., PetApi, StoreApi)
+  const classes = sourceFile.getClasses();
+  if (classes.length === 0) {
+    throw new Error(`No class found in ${filePath}`);
+  }
+
+  const apiClass = classes[0];
+  const className = apiClass.getName() || '';
+
+  // Get all public methods (excluding Raw and RequestOpts)
+  const methods = getPublicMethods(apiClass.getMethods());
+
+  const methodInfos: MethodInfo[] = [];
+
+  for (const method of methods) {
+    try {
+      const methodInfo = extractMethodInfo(method, sourceFile);
+      if (methodInfo) {
+        methodInfos.push(methodInfo);
+      }
+    } catch (error) {
+      p.log.warn(`Could not parse method ${method.getName()}: ${String(error)}`);
+    }
+  }
+
+  return {
+    className,
+    methods: methodInfos,
+  };
+}
+
+/**
+ * Filter to get only public methods (not Raw, not RequestOpts)
+ */
+function getPublicMethods(methods: MethodDeclaration[]): MethodDeclaration[] {
+  return methods.filter((method) => {
+    const name = method.getName();
+    const isAsync = method.isAsync();
+    const isPublic =
+      !method.hasModifier(SyntaxKind.PrivateKeyword) &&
+      !method.hasModifier(SyntaxKind.ProtectedKeyword);
+
+    return isPublic && isAsync && !name.endsWith('Raw') && !name.endsWith('RequestOpts');
+  });
+}
+
+/**
+ * Extract method information
+ */
+function extractMethodInfo(method: MethodDeclaration, sourceFile: SourceFile): MethodInfo | null {
+  const methodName = method.getName();
+  const composableName = `useFetch${pascalCase(methodName)}`;
+
+  // Get parameters
+  const params = method.getParameters();
+  let requestType = params.length > 0 ? params[0].getType().getText() : undefined;
+
+  // Clean up type text: remove import() expressions and fix formatting
+  if (requestType) {
+    // Remove all import("path") expressions
+    requestType = requestType.replace(/import\([^)]+\)\./g, '');
+
+    // If it's the default RequestInit | InitOverrideFunction, treat as no params
+    if (requestType === 'RequestInit | InitOverrideFunction') {
+      requestType = undefined;
+    }
+  }
+
+  // Get return type
+  const returnType = method.getReturnType();
+  const responseType = extractResponseType(returnType.getText());
+
+  // Find corresponding RequestOpts method
+  const requestOptsMethodName = `${methodName}RequestOpts`;
+  const requestOptsMethod = sourceFile.getClasses()[0].getMethod(requestOptsMethodName);
+
+  if (!requestOptsMethod) {
+    p.log.warn(`Could not find ${requestOptsMethodName} method`);
+    return null;
+  }
+
+  // Parse request options
+  const requestOpts = parseRequestOptions(requestOptsMethod);
+
+  // Get description from JSDoc
+  const jsDocs = method.getJsDocs();
+  const description = jsDocs.length > 0 ? jsDocs[0].getDescription().trim() : undefined;
+
+  // Detect if Raw method exists
+  const rawMethodName = `${methodName}Raw`;
+  const classDeclaration = sourceFile.getClasses()[0];
+  const hasRawMethod = classDeclaration.getMethod(rawMethodName) !== undefined;
+
+  return {
+    name: methodName,
+    composableName,
+    requestType,
+    responseType,
+    httpMethod: requestOpts.method,
+    path: requestOpts.path,
+    hasBody: requestOpts.hasBody,
+    bodyField: requestOpts.bodyField,
+    hasQueryParams: requestOpts.queryParams.length > 0,
+    queryParams: requestOpts.queryParams,
+    pathParams: extractPathParams(requestOpts.path),
+    headers: requestOpts.headers,
+    description,
+    hasRawMethod,
+    rawMethodName: hasRawMethod ? rawMethodName : undefined,
+  };
+}
+
+/**
+ * Extract response type from Promise<Type>
+ */
+function extractResponseType(returnTypeText: string): string {
+  // Match Promise<Type>
+  const match = returnTypeText.match(/Promise<(.+)>$/);
+  if (match) {
+    // Remove all import("path") expressions
+    return match[1].replace(/import\([^)]+\)\./g, '');
+  }
+  return 'void';
+}
+
+/**
+ * Parse the RequestOpts method to extract request details
+ */
+function parseRequestOptions(method: MethodDeclaration): {
+  path: string;
+  method: string;
+  headers: Record<string, string>;
+  hasBody: boolean;
+  bodyField?: string;
+  queryParams: string[];
+} {
+  const result = {
+    path: '',
+    method: 'GET',
+    headers: {} as Record<string, string>,
+    hasBody: false,
+    bodyField: undefined as string | undefined,
+    queryParams: [] as string[],
+  };
+
+  // Find the return statement
+  const returnStatements = method.getDescendantsOfKind(SyntaxKind.ReturnStatement);
+  if (returnStatements.length === 0) {
+    return result;
+  }
+
+  const returnStmt = returnStatements[0];
+  const objectLiteral = returnStmt.getFirstDescendantByKind(SyntaxKind.ObjectLiteralExpression);
+
+  if (!objectLiteral) {
+    return result;
+  }
+
+  // Parse each property
+  for (const prop of objectLiteral.getProperties()) {
+    if (prop.getKind() !== SyntaxKind.PropertyAssignment) {
+      continue;
+    }
+
+    const propAssignment = prop.asKind(SyntaxKind.PropertyAssignment);
+    if (!propAssignment) {
+      continue;
+    }
+
+    const propName = propAssignment.getName();
+    const initializer = propAssignment.getInitializer();
+
+    if (!initializer) {
+      continue;
+    }
+
+    switch (propName) {
+      case 'path': {
+        // Extract path from variable assignment
+        const pathValue = extractStringValue(initializer, method);
+        if (pathValue) {
+          result.path = pathValue;
+        }
+        break;
+      }
+      case 'method': {
+        const methodValue = extractStringValue(initializer, method);
+        if (methodValue) {
+          result.method = methodValue;
+        }
+        break;
+      }
+      case 'body': {
+        result.hasBody = true;
+        // Try to extract body field (e.g., params['pet'] or params.pet)
+        const bodyText = initializer.getText();
+        const bodyMatch = bodyText.match(/requestParameters(?:\['(\w+)'\]|\.(\w+))/);
+        if (bodyMatch) {
+          result.bodyField = bodyMatch[1] || bodyMatch[2];
+        }
+        break;
+      }
+      case 'headers': {
+        // Extract headers if it's an object literal
+        if (initializer.getKind() === SyntaxKind.ObjectLiteralExpression) {
+          const headersObj = initializer.asKind(SyntaxKind.ObjectLiteralExpression);
+          if (headersObj) {
+            for (const headerProp of headersObj.getProperties()) {
+              if (headerProp.getKind() === SyntaxKind.PropertyAssignment) {
+                const headerAssignment = headerProp.asKind(SyntaxKind.PropertyAssignment);
+                if (headerAssignment) {
+                  const headerName = headerAssignment.getName();
+                  const headerValue = headerAssignment.getInitializer();
+                  if (headerValue && headerValue.getKind() === SyntaxKind.StringLiteral) {
+                    result.headers[headerName] = headerValue.getText().slice(1, -1);
+                  }
+                }
+              }
+            }
+          }
+        }
+        break;
+      }
+    }
+  }
+
+  // Extract query parameters from the method body
+  result.queryParams = extractQueryParams(method);
+
+  return result;
+}
+
+/**
+ * Extract string value from expression
+ */
+function extractStringValue(node: Node, method: MethodDeclaration): string | null {
+  // Direct string literal
+  if (node.getKind() === SyntaxKind.StringLiteral) {
+    return node.getText().slice(1, -1); // Remove quotes
+  }
+
+  // Template literal
+  if (
+    node.getKind() === SyntaxKind.TemplateExpression ||
+    node.getKind() === SyntaxKind.NoSubstitutionTemplateLiteral
+  ) {
+    return node.getText().slice(1, -1); // Remove backticks
+  }
+
+  // Variable reference - try to find its value
+  if (node.getKind() === SyntaxKind.Identifier) {
+    const varName = node.getText();
+
+    // Find variable declarations in the method body
+    const varDeclarations = method.getDescendantsOfKind(SyntaxKind.VariableDeclaration);
+    for (const varDecl of varDeclarations) {
+      if (varDecl.getName() === varName) {
+        const initializer = varDecl.getInitializer();
+        if (initializer) {
+          if (initializer.getKind() === SyntaxKind.StringLiteral) {
+            return initializer.getText().slice(1, -1);
+          }
+          if (
+            initializer.getKind() === SyntaxKind.TemplateExpression ||
+            initializer.getKind() === SyntaxKind.NoSubstitutionTemplateLiteral
+          ) {
+            return initializer.getText().slice(1, -1);
+          }
+        }
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Extract query parameters from method body
+ */
+function extractQueryParams(method: MethodDeclaration): string[] {
+  const params: string[] = [];
+  const methodText = method.getText();
+
+  // Look for queryParameters['paramName'] or queryParameters.paramName
+  const regex = /queryParameters(?:\['(\w+)'\]|\.(\w+))/g;
+  let match;
+
+  while ((match = regex.exec(methodText)) !== null) {
+    const paramName = match[1] || match[2];
+    if (paramName && !params.includes(paramName)) {
+      params.push(paramName);
+    }
+  }
+
+  return params;
+}
+
+/**
+ * Extract path parameters from path string (e.g., /pet/{petId} -> ['petId'])
+ */
+function extractPathParams(path: string): string[] {
+  const regex = /\{(\w+)\}/g;
+  const params: string[] = [];
+  let match;
+
+  while ((match = regex.exec(path)) !== null) {
+    params.push(match[1]);
+  }
+
+  return params;
+}