nuxt-openapi-hyperfetch 0.1.0-alpha.1

package/dist/generators/use-async-data/runtime/useApiAsyncData.js

@@ -0,0 +1,122 @@
+import { getGlobalHeaders, applyPick, mergeCallbacks, } from '../../shared/runtime/apiHelpers.js';
+/**
+ * Generic wrapper for API calls using Nuxt's useAsyncData
+ * Supports:
+ * - Lifecycle callbacks (onRequest, onSuccess, onError, onFinish)
+ * - Request modification via onRequest return value
+ * - Transform and pick operations
+ * - Global headers from useApiHeaders or $getApiHeaders
+ * - Watch pattern for reactive parameters
+ */
+export function useApiAsyncData(key, url, options) {
+    const { method = 'GET', body, headers = {}, params, transform, pick, onRequest, onSuccess, onError, onFinish, skipGlobalCallbacks, immediate = true, lazy = false, server = true, dedupe = 'cancel', watch: watchOption = true, ...restOptions } = options || {};
+    // Create reactive watch sources — use refs/computeds directly so Vue can track them
+    // watchOption: false disables auto-refresh entirely
+    const watchSources = watchOption === false
+        ? []
+        : [
+            ...(typeof url === 'function' ? [url] : []),
+            ...(body ? (isRef(body) ? [body] : typeof body === 'object' ? [() => body] : []) : []),
+            ...(params
+                ? isRef(params)
+                    ? [params]
+                    : typeof params === 'object'
+                        ? [() => params]
+                        : []
+                : []),
+        ];
+    // Fetch function for useAsyncData
+    const fetchFn = async () => {
+        // Get URL value for merging callbacks
+        const finalUrl = typeof url === 'function' ? url() : url;
+        // Merge local and global callbacks
+        const mergedCallbacks = mergeCallbacks(finalUrl, { onRequest, onSuccess, onError, onFinish }, skipGlobalCallbacks);
+        try {
+            // Get global headers
+            const globalHeaders = getGlobalHeaders();
+            // Prepare request context
+            const requestContext = {
+                url: finalUrl,
+                method: method,
+                headers: { ...globalHeaders, ...headers },
+                body,
+                params,
+            };
+            // Execute merged onRequest callback and potentially modify request
+            const modifiedContext = { ...requestContext };
+            if (mergedCallbacks.onRequest) {
+                const result = await mergedCallbacks.onRequest(requestContext);
+                // If onRequest returns modifications, apply them
+                if (result && typeof result === 'object') {
+                    const modifications = result;
+                    if (modifications.body !== undefined) {
+                        modifiedContext.body = modifications.body;
+                    }
+                    if (modifications.headers !== undefined) {
+                        modifiedContext.headers = {
+                            ...modifiedContext.headers,
+                            ...modifications.headers,
+                        };
+                    }
+                    if (modifications.params !== undefined) {
+                        modifiedContext.params = {
+                            ...modifiedContext.params,
+                            ...modifications.params,
+                        };
+                    }
+                }
+            }
+            // Make the request with $fetch — toValue() unrefs any Ref/ComputedRef
+            let data = await $fetch(modifiedContext.url, {
+                method: modifiedContext.method,
+                headers: modifiedContext.headers,
+                body: toValue(modifiedContext.body),
+                params: toValue(modifiedContext.params),
+                ...restOptions,
+            });
+            // Apply pick if provided
+            if (pick) {
+                data = applyPick(data, pick);
+            }
+            // Apply transform if provided
+            if (transform) {
+                data = transform(data);
+            }
+            // Call merged onSuccess callback
+            if (mergedCallbacks.onSuccess) {
+                await mergedCallbacks.onSuccess(data, {
+                    url: finalUrl,
+                    method,
+                    headers: modifiedContext.headers,
+                });
+            }
+            return data;
+        }
+        catch (error) {
+            // Call merged onError callback
+            if (mergedCallbacks.onError) {
+                await mergedCallbacks.onError(error, { url: finalUrl, method, headers });
+            }
+            throw error;
+        }
+        finally {
+            // Call merged onFinish callback
+            if (mergedCallbacks.onFinish) {
+                await mergedCallbacks.onFinish({
+                    url: finalUrl,
+                    method,
+                    headers: { ...getGlobalHeaders(), ...headers },
+                });
+            }
+        }
+    };
+    // Use Nuxt's useAsyncData
+    const result = useAsyncData(key, fetchFn, {
+        immediate,
+        lazy,
+        server,
+        dedupe,
+        watch: watchSources.length > 0 ? watchSources : undefined,
+    });
+    return result;
+}

package/dist/generators/use-async-data/runtime/useApiAsyncDataRaw.d.ts

@@ -0,0 +1,54 @@
+import { type ApiRequestOptions as BaseApiRequestOptions } from '../../shared/runtime/apiHelpers.js';
+/**
+ * Response structure for Raw version
+ * Includes data, headers, status, and statusText
+ */
+export interface RawResponse<T> {
+    data: T;
+    headers: Headers;
+    status: number;
+    statusText: string;
+}
+/**
+ * Extended options specific to useAsyncData Raw version
+ */
+export interface ApiAsyncDataRawOptions<T> extends Omit<BaseApiRequestOptions<T>, 'onSuccess'> {
+    /**
+     * Success callback that receives both data and full response
+     */
+    onSuccess?: (data: T, response: {
+        headers: Headers;
+        status: number;
+        statusText: string;
+        url: string;
+    }) => void | Promise<void>;
+    /**
+     * Whether to fetch data immediately on mount (default: true)
+     */
+    immediate?: boolean;
+    /**
+     * Lazy mode: don't block navigation (default: false)
+     */
+    lazy?: boolean;
+    /**
+     * Server-side rendering mode (default: true)
+     */
+    server?: boolean;
+    /**
+     * Deduplicate requests with the same key (default: 'cancel')
+     */
+    dedupe?: 'cancel' | 'defer';
+}
+/**
+ * Generic wrapper for API calls using Nuxt's useAsyncData - RAW VERSION
+ * Returns full response with headers and status information
+ *
+ * Supports:
+ * - Lifecycle callbacks (onRequest, onSuccess with response, onError, onFinish)
+ * - Request modification via onRequest return value
+ * - Transform (applies only to data, not full response)
+ * - Pick operations (applies only to data)
+ * - Global headers from useApiHeaders or $getApiHeaders
+ * - Watch pattern for reactive parameters
+ */
+export declare function useApiAsyncDataRaw<T>(key: string, url: string | (() => string), options?: ApiAsyncDataRawOptions<T>): any;

package/dist/generators/use-async-data/runtime/useApiAsyncDataRaw.js

@@ -0,0 +1,126 @@
+import { getGlobalHeaders, applyPick, mergeCallbacks, } from '../../shared/runtime/apiHelpers.js';
+/**
+ * Generic wrapper for API calls using Nuxt's useAsyncData - RAW VERSION
+ * Returns full response with headers and status information
+ *
+ * Supports:
+ * - Lifecycle callbacks (onRequest, onSuccess with response, onError, onFinish)
+ * - Request modification via onRequest return value
+ * - Transform (applies only to data, not full response)
+ * - Pick operations (applies only to data)
+ * - Global headers from useApiHeaders or $getApiHeaders
+ * - Watch pattern for reactive parameters
+ */
+export function useApiAsyncDataRaw(key, url, options) {
+    const { method = 'GET', body, headers = {}, params, transform, pick, onRequest, onSuccess, onError, onFinish, skipGlobalCallbacks, immediate = true, lazy = false, server = true, dedupe = 'cancel', ...restOptions } = options || {};
+    // Create reactive watch sources for callbacks
+    const watchSources = [
+        ...(typeof url === 'function' ? [url] : []),
+        ...(body && typeof body === 'object' ? [() => body] : []),
+        ...(params && typeof params === 'object' ? [() => params] : []),
+    ];
+    // Fetch function for useAsyncData
+    const fetchFn = async () => {
+        // Get URL value for merging callbacks
+        const finalUrl = typeof url === 'function' ? url() : url;
+        // Merge local and global callbacks
+        const mergedCallbacks = mergeCallbacks(finalUrl, { onRequest, onSuccess, onError, onFinish }, skipGlobalCallbacks);
+        try {
+            // Get global headers
+            const globalHeaders = getGlobalHeaders();
+            // Prepare request context
+            const requestContext = {
+                url: finalUrl,
+                method: method,
+                headers: { ...globalHeaders, ...headers },
+                body,
+                params,
+            };
+            // Execute merged onRequest callback and potentially modify request
+            const modifiedContext = { ...requestContext };
+            if (mergedCallbacks.onRequest) {
+                const result = await mergedCallbacks.onRequest(requestContext);
+                // If onRequest returns modifications, apply them
+                if (result && typeof result === 'object') {
+                    const modifications = result;
+                    if (modifications.body !== undefined) {
+                        modifiedContext.body = modifications.body;
+                    }
+                    if (modifications.headers !== undefined) {
+                        modifiedContext.headers = {
+                            ...modifiedContext.headers,
+                            ...modifications.headers,
+                        };
+                    }
+                    if (modifications.params !== undefined) {
+                        modifiedContext.params = {
+                            ...modifiedContext.params,
+                            ...modifications.params,
+                        };
+                    }
+                }
+            }
+            // Make the request with $fetch.raw to get full response
+            const response = await $fetch.raw(modifiedContext.url, {
+                method: modifiedContext.method,
+                headers: modifiedContext.headers,
+                body: modifiedContext.body,
+                params: modifiedContext.params,
+                ...restOptions,
+            });
+            // Extract data from response
+            let data = response._data;
+            // Apply pick if provided (only to data)
+            if (pick) {
+                data = applyPick(data, pick);
+            }
+            // Apply transform if provided (only to data)
+            if (transform) {
+                data = transform(data);
+            }
+            // Construct the raw response object
+            const rawResponse = {
+                data,
+                headers: response.headers,
+                status: response.status,
+                statusText: response.statusText,
+            };
+            // Call merged onSuccess callback with data and response context
+            if (mergedCallbacks.onSuccess) {
+                await mergedCallbacks.onSuccess(data, {
+                    headers: response.headers,
+                    status: response.status,
+                    statusText: response.statusText,
+                    url: finalUrl,
+                });
+            }
+            return rawResponse;
+        }
+        catch (error) {
+            // Call merged onError callback
+            if (mergedCallbacks.onError) {
+                await mergedCallbacks.onError(error, { url: finalUrl, method, headers });
+            }
+            throw error;
+        }
+        finally {
+            // Call merged onFinish callback
+            if (mergedCallbacks.onFinish) {
+                await mergedCallbacks.onFinish({
+                    url: finalUrl,
+                    method,
+                    headers: { ...getGlobalHeaders(), ...headers },
+                });
+            }
+        }
+    };
+    // Use Nuxt's useAsyncData
+    const result = useAsyncData(key, fetchFn, {
+        immediate,
+        lazy,
+        server,
+        dedupe,
+        watch: watchSources.length > 0 ? watchSources : undefined,
+    });
+    return result;
+}

package/dist/generators/use-async-data/templates.d.ts

@@ -0,0 +1,20 @@
+import type { MethodInfo } from './types.js';
+/**
+ * Options for code generation
+ */
+export interface GenerateOptions {
+    baseUrl?: string;
+    backend?: string;
+}
+/**
+ * Generate a useAsyncData composable function
+ */
+export declare function generateComposableFile(method: MethodInfo, apiImportPath: string, options?: GenerateOptions): string;
+/**
+ * Generate a useAsyncData composable function (Raw version with headers)
+ */
+export declare function generateRawComposableFile(method: MethodInfo, apiImportPath: string, options?: GenerateOptions): string;
+/**
+ * Generate index.ts that exports all composables
+ */
+export declare function generateIndexFile(composableNames: string[]): string;

package/dist/generators/use-async-data/templates.js

@@ -0,0 +1,191 @@
+/**
+ * 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 useAsyncData composable function
+ */
+export function generateComposableFile(method, apiImportPath, options) {
+    const header = generateFileHeader();
+    const imports = generateImports(method, apiImportPath, false);
+    const functionBody = generateFunctionBody(method, false, options);
+    return `${header}${imports}\n\n${functionBody}\n`;
+}
+/**
+ * Generate a useAsyncData composable function (Raw version with headers)
+ */
+export function generateRawComposableFile(method, apiImportPath, options) {
+    const header = generateFileHeader();
+    const imports = generateImports(method, apiImportPath, true);
+    const functionBody = generateFunctionBody(method, true, options);
+    return `${header}${imports}\n\n${functionBody}\n`;
+}
+/**
+ * Extract base type names from a type string
+ * Examples:
+ *   Pet[] -> Pet
+ *   Array<Pet> -> Pet
+ *   Pet -> Pet
+ *   { [key: string]: Pet } -> (empty, it's anonymous)
+ */
+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];
+    }
+    // For complex types, don't extract anything
+    return [];
+}
+/**
+ * Generate import statements
+ */
+function generateImports(method, apiImportPath, isRaw) {
+    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));
+    }
+    let imports = '';
+    // 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`;
+    }
+    // Import runtime helper (normal or raw)
+    if (isRaw) {
+        imports += `import { useApiAsyncDataRaw, type ApiAsyncDataRawOptions, type RawResponse } from '../runtime/useApiAsyncDataRaw';`;
+    }
+    else {
+        imports += `import { useApiAsyncData, type ApiAsyncDataOptions } from '../runtime/useApiAsyncData';`;
+    }
+    return imports;
+}
+/**
+ * Generate the composable function body
+ */
+function generateFunctionBody(method, isRaw, generateOptions) {
+    const hasParams = !!method.requestType;
+    const paramsArg = hasParams ? `params: MaybeRef<${method.requestType}>` : '';
+    // Determine the options type based on isRaw
+    const optionsType = isRaw
+        ? `ApiAsyncDataRawOptions<${method.responseType}>`
+        : `ApiAsyncDataOptions<${method.responseType}>`;
+    const optionsArg = `options?: ${optionsType}`;
+    const args = hasParams ? `${paramsArg}, ${optionsArg}` : optionsArg;
+    // Determine the response type generic
+    const responseTypeGeneric = method.responseType !== 'void' ? `<${method.responseType}>` : '';
+    // Generate unique key for useAsyncData
+    const composableName = isRaw && method.rawMethodName
+        ? `useAsyncData${method.rawMethodName.replace(/Raw$/, '')}Raw`
+        : method.composableName.replace(/^useFetch/, 'useAsyncData');
+    const key = `'${composableName}'`;
+    const url = generateUrl(method);
+    const fetchOptions = generateFetchOptions(method, generateOptions);
+    const description = method.description ? `/**\n * ${method.description}\n */\n` : '';
+    // Choose the correct wrapper function
+    const wrapperFunction = isRaw ? 'useApiAsyncDataRaw' : 'useApiAsyncData';
+    const pInit = hasParams ? `\n  const p = isRef(params) ? params : shallowRef(params)` : '';
+    return `${description}export const ${composableName} = (${args}) => {${pInit}
+  return ${wrapperFunction}${responseTypeGeneric}(${key}, ${url}, ${fetchOptions})
+}`;
+}
+/**
+ * Generate URL (with path params if needed)
+ */
+function generateUrl(method) {
+    if (method.pathParams.length === 0) {
+        return `'${method.path}'`;
+    }
+    let url = method.path;
+    for (const param of method.pathParams) {
+        const accessor = method.paramsShape === 'nested' ? `p.value.path.${param}` : `p.value.${param}`;
+        url = url.replace(`{${param}}`, `\${${accessor}}`);
+    }
+    return `() => \`${url}\``;
+}
+/**
+ * Generate fetch options object
+ */
+function generateFetchOptions(method, generateOptions) {
+    const options = [];
+    // Method
+    options.push(`method: '${method.httpMethod}'`);
+    // Base URL (if provided in config)
+    if (generateOptions?.baseUrl) {
+        options.push(`baseURL: '${generateOptions.baseUrl}'`);
+    }
+    // Body
+    if (method.hasBody) {
+        if (method.paramsShape === 'nested') {
+            options.push(`body: computed(() => p.value.body)`);
+        }
+        else if (method.bodyField) {
+            options.push(`body: computed(() => p.value.${method.bodyField})`);
+        }
+    }
+    // Query params (renamed to 'params' for $fetch)
+    if (method.hasQueryParams) {
+        if (method.paramsShape === 'nested') {
+            options.push(`params: computed(() => p.value.query)`);
+        }
+        else if (method.queryParams.length > 0) {
+            const queryObj = method.queryParams
+                .map((param) => `${param}: p.value.${param}`)
+                .join(',\n      ');
+            options.push(`params: computed(() => ({\n      ${queryObj}\n    }))`);
+        }
+    }
+    // Headers
+    if (Object.keys(method.headers).length > 0) {
+        const headersEntries = Object.entries(method.headers)
+            .map(([key, value]) => `'${key}': '${value}'`)
+            .join(',\n      ');
+        options.push(`headers: {\n      ${headersEntries},\n      ...options?.headers\n    }`);
+    }
+    // Spread options
+    options.push('...options');
+    const optionsStr = options.join(',\n    ');
+    return `{\n    ${optionsStr}\n  }`;
+}
+/**
+ * Generate index.ts that exports all composables
+ */
+export function generateIndexFile(composableNames) {
+    const header = generateFileHeader();
+    const exports = composableNames
+        .map((name) => `export { ${name} } from './composables/${name}'`)
+        .join('\n');
+    return `${header}${exports}\n`;
+}

package/dist/generators/use-async-data/types.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Re-export all types from shared types
+ */
+export * from '../shared/types.js';

package/dist/generators/use-async-data/types.js

@@ -0,0 +1,4 @@
+/**
+ * Re-export all types from shared types
+ */
+export * from '../shared/types.js';

package/dist/generators/use-fetch/generator.d.ts

@@ -0,0 +1,5 @@
+import { type GenerateOptions } from './templates.js';
+/**
+ * Main function to generate useFetch composables
+ */
+export declare function generateUseFetchComposables(inputDir: string, outputDir: string, options?: GenerateOptions): Promise<void>;

package/dist/generators/use-fetch/generator.js

@@ -0,0 +1,131 @@
+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 } from './templates.js';
+import { p, logSuccess, logError } from '../../cli/logger.js';
+/**
+ * Main function to generate useFetch composables
+ */
+export async function generateUseFetchComposables(inputDir, outputDir, 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;
+    // 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} 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, inputDir) {
+    // 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) {
+    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/dist/generators/use-fetch/parser.d.ts

@@ -0,0 +1,9 @@
+import type { ApiClassInfo } from './types.js';
+/**
+ * Get all API files from the input directory
+ */
+export declare function getApiFiles(inputDir: string): string[];
+/**
+ * Parse an API file and extract all methods
+ */
+export declare function parseApiFile(filePath: string): ApiClassInfo;