nuxt-openapi-hyperfetch 0.1.6-alpha.1 → 0.2.7-alpha.1

package/dist/generators/use-fetch/runtime/useApiRequest.js

@@ -3,8 +3,9 @@
  * Nuxt Runtime Helper - This file is copied to the generated output
  * It requires Nuxt 3 to be installed in the target project
  */
-import { watch } from 'vue';
+import { watch, ref, computed } from 'vue';
 import { getGlobalHeaders, getGlobalBaseUrl, applyPick, applyRequestModifications, mergeCallbacks, } from '../../shared/runtime/apiHelpers.js';
+import { getGlobalApiPagination, buildPaginationRequest, extractPaginationMetaFromBody, extractPaginationMetaFromHeaders, unwrapDataKey, } from '../../shared/runtime/pagination.js';
 /**
  * Enhanced useFetch wrapper with lifecycle callbacks and request interception
  *
@@ -42,18 +43,26 @@ import { getGlobalHeaders, getGlobalBaseUrl, applyPick, applyRequestModification
  * ```
  */
 export function useApiRequest(url, options) {
-    const { onRequest, onSuccess, onError, onFinish, skipGlobalCallbacks, transform, pick, ...fetchOptions } = options || {};
-    // Prepare request context for onRequest interceptor
+    const { onRequest, onSuccess, onError, onFinish, skipGlobalCallbacks, transform, pick, paginated, initialPage, initialPerPage, paginationConfig, ...fetchOptions } = options || {};
+    // Resolve URL value for callbacks and pattern matching
     const urlValue = typeof url === 'function' ? url() : url;
-    const requestContext = {
-        url: urlValue,
-        method: fetchOptions.method || 'GET',
-        body: fetchOptions.body,
-        headers: fetchOptions.headers,
-        query: fetchOptions.query,
-    };
+    // ---------------------------------------------------------------------------
+    // Pagination setup
+    // ---------------------------------------------------------------------------
+    const activePaginationConfig = paginationConfig ?? (paginated ? getGlobalApiPagination() : null);
+    const page = ref(initialPage ?? activePaginationConfig?.request.defaults.page ?? 1);
+    const perPage = ref(initialPerPage ?? activePaginationConfig?.request.defaults.perPage ?? 20);
+    // Reactive pagination state (populated after response)
+    const paginationState = ref({
+        currentPage: page.value,
+        totalPages: 0,
+        total: 0,
+        perPage: perPage.value,
+    });
+    // ---------------------------------------------------------------------------
     // Merge local and global callbacks
-    const mergedCallbacks = mergeCallbacks(urlValue, { onRequest, onSuccess, onError, onFinish }, skipGlobalCallbacks);
+    // ---------------------------------------------------------------------------
+    const mergedCallbacks = mergeCallbacks(urlValue, String(fetchOptions.method || 'GET'), { onRequest, onSuccess, onError, onFinish }, skipGlobalCallbacks);
     // Apply global headers configuration (from composable or plugin)
     const modifiedOptions = { ...fetchOptions };
     const globalHeaders = getGlobalHeaders();
@@ -70,30 +79,82 @@ export function useApiRequest(url, options) {
     if (!modifiedOptions.baseURL) {
         console.warn('[nuxt-openapi-hyperfetch] No baseURL configured. Set runtimeConfig.public.apiBaseUrl in nuxt.config.ts or pass baseURL in options.');
     }
-    // Execute merged onRequest interceptor and apply modifications
+    // ---------------------------------------------------------------------------
+    // Inject pagination request params before every request
+    // ---------------------------------------------------------------------------
+    if (paginated && activePaginationConfig) {
+        const existingOnRequestForPagination = modifiedOptions.onRequest;
+        modifiedOptions.onRequest = async (ctx) => {
+            // Inject page/perPage according to sendAs strategy
+            const paginationPayload = buildPaginationRequest(page.value, perPage.value, activePaginationConfig);
+            if (paginationPayload.query) {
+                ctx.options.query = { ...ctx.options.query, ...paginationPayload.query };
+            }
+            if (paginationPayload.body) {
+                ctx.options.body = {
+                    ...(ctx.options.body && typeof ctx.options.body === 'object' ? ctx.options.body : {}),
+                    ...paginationPayload.body,
+                };
+            }
+            if (paginationPayload.headers) {
+                ctx.options.headers = { ...ctx.options.headers, ...paginationPayload.headers };
+            }
+            if (existingOnRequestForPagination) {
+                await existingOnRequestForPagination(ctx);
+            }
+        };
+    }
+    // ---------------------------------------------------------------------------
+    // Extract pagination metadata from headers after response (metaSource: 'headers')
+    // ---------------------------------------------------------------------------
+    if (paginated && activePaginationConfig && activePaginationConfig.meta.metaSource === 'headers') {
+        const existingOnResponse = modifiedOptions.onResponse;
+        modifiedOptions.onResponse = async ({ response }) => {
+            const meta = extractPaginationMetaFromHeaders(response.headers, activePaginationConfig);
+            if (meta.total !== undefined)
+                paginationState.value.total = meta.total;
+            if (meta.totalPages !== undefined)
+                paginationState.value.totalPages = meta.totalPages;
+            if (meta.currentPage !== undefined)
+                paginationState.value.currentPage = meta.currentPage;
+            if (meta.perPage !== undefined)
+                paginationState.value.perPage = meta.perPage;
+            if (existingOnResponse) {
+                await existingOnResponse({ response });
+            }
+        };
+    }
+    // If page/perPage refs change, re-trigger useFetch (add them to watch array)
+    if (paginated) {
+        modifiedOptions.watch = [...(modifiedOptions.watch ?? []), page, perPage];
+    }
+    // Pass onRequest to useFetch's native interceptor so async callbacks are
+    // properly awaited by ofetch before the request is sent.
     if (mergedCallbacks.onRequest) {
-        try {
-            const result = mergedCallbacks.onRequest(requestContext);
-            // Handle async onRequest
-            if (result && typeof result === 'object' && 'then' in result) {
-                result
-                    .then((modifications) => {
-                    if (modifications) {
-                        applyRequestModifications(modifiedOptions, modifications);
-                    }
-                })
-                    .catch((error) => {
-                    console.error('Error in merged onRequest callback:', error);
-                });
-            }
-            // Handle sync onRequest with return value
-            else if (result && typeof result === 'object') {
-                applyRequestModifications(modifiedOptions, result);
+        const existingOnRequest = modifiedOptions.onRequest;
+        modifiedOptions.onRequest = async ({ options: fetchOpts }) => {
+            // Build context from the live options at request time
+            const requestContext = {
+                url: urlValue,
+                method: String(fetchOpts.method || modifiedOptions.method || 'GET'),
+                body: fetchOpts.body,
+                headers: fetchOpts.headers,
+                query: fetchOpts.query,
+            };
+            try {
+                const modifications = await mergedCallbacks.onRequest(requestContext);
+                if (modifications && typeof modifications === 'object') {
+                    applyRequestModifications(fetchOpts, modifications);
+                }
             }
-        }
-        catch (error) {
-            console.error('Error in merged onRequest callback:', error);
-        }
+            catch (error) {
+                console.error('Error in merged onRequest callback:', error);
+            }
+            // Chain any pre-existing onRequest interceptor
+            if (existingOnRequest) {
+                await existingOnRequest({ options: fetchOpts });
+            }
+        };
     }
     // Make the actual request using Nuxt's useFetch
     const result = useFetch(url, modifiedOptions);
@@ -106,7 +167,22 @@ export function useApiRequest(url, options) {
         const [prevData, prevError, prevPending] = prev ?? [undefined, undefined, undefined];
         // Apply transformations when data arrives
         if (data && data !== prevData) {
-            let processedData = data;
+            // Unwrap dataKey for paginated body-based responses BEFORE pick/transform
+            let processedData = paginated && activePaginationConfig && activePaginationConfig.meta.metaSource === 'body'
+                ? unwrapDataKey(data, activePaginationConfig)
+                : data;
+            // Extract body-based pagination meta from raw response
+            if (paginated && activePaginationConfig && activePaginationConfig.meta.metaSource === 'body') {
+                const meta = extractPaginationMetaFromBody(data, activePaginationConfig);
+                if (meta.total !== undefined)
+                    paginationState.value.total = meta.total;
+                if (meta.totalPages !== undefined)
+                    paginationState.value.totalPages = meta.totalPages;
+                if (meta.currentPage !== undefined)
+                    paginationState.value.currentPage = meta.currentPage;
+                if (meta.perPage !== undefined)
+                    paginationState.value.perPage = meta.perPage;
+            }
             // Step 1: Apply pick if specified
             if (pick) {
                 processedData = applyPick(processedData, pick);
@@ -123,7 +199,8 @@ export function useApiRequest(url, options) {
             // Update transformed data ref
             transformedData.value = processedData;
             // onSuccess - when data arrives and no error (using merged callback)
-            if (!error && !successExecuted && mergedCallbacks.onSuccess) {
+            // NOTE: data !== null/undefined check instead of truthy to handle 0, false, ''
+            if (data != null && !error && !successExecuted && mergedCallbacks.onSuccess) {
                 successExecuted = true;
                 try {
                     await mergedCallbacks.onSuccess(processedData);
@@ -146,9 +223,9 @@ export function useApiRequest(url, options) {
         // onFinish - when request completes (was pending, now not) (using merged callback)
         if (prevPending && !pending && mergedCallbacks.onFinish) {
             const finishContext = {
-                data: transformedData.value || undefined,
-                error: error || undefined,
-                success: !!transformedData.value && !error,
+                data: transformedData.value ?? undefined,
+                error: error ?? undefined,
+                success: data != null && !error,
             };
             try {
                 await mergedCallbacks.onFinish(finishContext);
@@ -158,9 +235,41 @@ export function useApiRequest(url, options) {
             }
         }
     }, { immediate: true });
-    // Return result with transformed data
-    return {
+    // Return result with transformed data and optional pagination
+    const baseResult = {
         ...result,
         data: transformedData,
     };
+    if (!paginated)
+        return baseResult;
+    // Pagination computed helpers
+    const hasNextPage = computed(() => paginationState.value.currentPage < paginationState.value.totalPages);
+    const hasPrevPage = computed(() => paginationState.value.currentPage > 1);
+    const goToPage = (n) => {
+        page.value = n;
+        successExecuted = false;
+        errorExecuted = false;
+    };
+    const nextPage = () => { if (hasNextPage.value)
+        goToPage(page.value + 1); };
+    const prevPage = () => { if (hasPrevPage.value)
+        goToPage(page.value - 1); };
+    const setPerPage = (n) => {
+        perPage.value = n;
+        page.value = 1;
+        successExecuted = false;
+        errorExecuted = false;
+    };
+    return {
+        ...baseResult,
+        pagination: computed(() => ({
+            ...paginationState.value,
+            hasNextPage: hasNextPage.value,
+            hasPrevPage: hasPrevPage.value,
+        })),
+        goToPage,
+        nextPage,
+        prevPage,
+        setPerPage,
+    };
 }

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

@@ -2,18 +2,18 @@
  * 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
+    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
 `;
 }
 /**
@@ -95,8 +95,8 @@ function generateFunctionBody(method, options) {
     const fetchOptions = generateFetchOptions(method, options);
     const description = method.description ? `/**\n * ${method.description}\n */\n` : '';
     const pInit = hasParams ? `\n  const p = shallowRef(params)` : '';
-    return `${description}export const ${method.composableName} = (${args}) => {${pInit}
-  return useApiRequest${responseTypeGeneric}(${url}, ${fetchOptions})
+    return `${description}export const ${method.composableName} = (${args}) => {${pInit}
+  return useApiRequest${responseTypeGeneric}(${url}, ${fetchOptions})
 }`;
 }
 /**

package/dist/index.js

@@ -5,6 +5,7 @@ import { generateOpenApiFiles, generateHeyApiFiles, checkJavaInstalled } from '.
 import { generateUseFetchComposables } from './generators/use-fetch/generator.js';
 import { generateUseAsyncDataComposables } from './generators/use-async-data/generator.js';
 import { generateNuxtServerRoutes } from './generators/nuxt-server/generator.js';
+import { generateConnectors } from './generators/components/connector-generator/generator.js';
 import { promptInitialInputs, promptInputPath, promptComposablesSelection, promptServerRoutePath, promptBffConfig, promptGeneratorBackend, } from './cli/prompts.js';
 import { MESSAGES } from './cli/messages.js';
 import { displayLogo } from './cli/logo.js';
@@ -210,4 +211,28 @@ program
         process.exit(1);
     }
 });
+program
+    .command('connectors')
+    .description('Generate headless connector composables from an OpenAPI spec')
+    .requiredOption('-i, --input <path>', 'Path to OpenAPI YAML or JSON spec')
+    .requiredOption('-o, --output <path>', 'Output directory for connector composables')
+    .option('--composables-dir <relPath>', 'Relative path from output dir to useAsyncData composables (default: ../use-async-data)')
+    .option('--runtime-dir <relPath>', 'Relative path from output dir where runtime helpers are copied (default: ../runtime)')
+    .action(async (options) => {
+    try {
+        displayLogo();
+        p.intro('Generating connector composables…');
+        await generateConnectors({
+            inputSpec: options.input,
+            outputDir: options.output,
+            composablesRelDir: options.composablesDir,
+            runtimeRelDir: options.runtimeDir,
+        });
+        p.outro('Done!');
+    }
+    catch (error) {
+        p.log.error(`Error: ${String(error)}`);
+        process.exit(1);
+    }
+});
 program.parse();

package/dist/module/index.d.ts

@@ -0,0 +1,4 @@
+import type { ModuleOptions } from './types.js';
+declare const _default: import("@nuxt/schema").NuxtModule<ModuleOptions, ModuleOptions, false>;
+export default _default;
+export type { ModuleOptions };

package/dist/module/index.js

@@ -0,0 +1,93 @@
+import { defineNuxtModule, addImportsDir } from '@nuxt/kit';
+import { execSync } from 'child_process';
+import * as path from 'path';
+import { checkJavaInstalled } from '../generate.js';
+import { generateUseFetchComposables } from '../generators/use-fetch/generator.js';
+import { generateUseAsyncDataComposables } from '../generators/use-async-data/generator.js';
+import { generateNuxtServerRoutes } from '../generators/nuxt-server/generator.js';
+import { createConsoleLogger } from '../cli/logger.js';
+export default defineNuxtModule({
+    meta: {
+        name: 'nuxt-openapi-hyperfetch',
+        configKey: 'openApiHyperFetch',
+    },
+    defaults: {
+        output: './composables/api',
+        generators: ['useFetch', 'useAsyncData'],
+        backend: 'heyapi',
+        enableDevBuild: true,
+        enableProductionBuild: true,
+        enableAutoGeneration: false,
+        enableAutoImport: true,
+    },
+    setup(options, nuxt) {
+        // --- Guard: input is required ---
+        if (!options.input) {
+            console.warn('[nuxt-openapi-hyperfetch] No input configured — skipping generation.\n' +
+                "Add `openApiHyperFetch: { input: './swagger.yaml' }` to your nuxt.config.ts");
+            return;
+        }
+        const resolvedInput = path.resolve(nuxt.options.rootDir, options.input);
+        const resolvedOutput = path.resolve(nuxt.options.rootDir, options.output);
+        const composablesOutputDir = path.join(resolvedOutput, 'composables');
+        const selectedGenerators = options.generators ?? ['useFetch', 'useAsyncData'];
+        const backend = options.backend ?? 'heyapi';
+        const logger = createConsoleLogger();
+        // --- Core generation function ---
+        const runGeneration = async () => {
+            logger.log.info('Generating OpenAPI composables...');
+            // 1. Generate OpenAPI SDK files
+            if (backend === 'official') {
+                if (!checkJavaInstalled()) {
+                    throw new Error('[nuxt-openapi-hyperfetch] Java not found. The official backend requires Java 11+.\n' +
+                        'Install from: https://adoptium.net or set backend: "heyapi" in nuxt.config.ts');
+                }
+                execSync(`npx @openapitools/openapi-generator-cli generate -i "${resolvedInput}" -g typescript-fetch -o "${resolvedOutput}"`, { stdio: 'inherit' });
+            }
+            else {
+                const { createClient } = await import('@hey-api/openapi-ts');
+                await createClient({
+                    input: resolvedInput,
+                    output: resolvedOutput,
+                    plugins: ['@hey-api/typescript', '@hey-api/sdk'],
+                });
+            }
+            // 2. Run selected composable generators
+            const genOptions = { backend };
+            if (selectedGenerators.includes('useFetch')) {
+                await generateUseFetchComposables(resolvedOutput, path.join(composablesOutputDir, 'use-fetch'), genOptions, logger);
+            }
+            if (selectedGenerators.includes('useAsyncData')) {
+                await generateUseAsyncDataComposables(resolvedOutput, path.join(composablesOutputDir, 'use-async-data'), genOptions, logger);
+            }
+            if (selectedGenerators.includes('nuxtServer')) {
+                const serverRoutePath = path.resolve(nuxt.options.rootDir, options.serverRoutePath ?? 'server/routes/api');
+                await generateNuxtServerRoutes(resolvedOutput, serverRoutePath, { enableBff: options.enableBff, backend }, logger);
+            }
+        };
+        // --- Hooks: dev build / production build ---
+        const isDev = nuxt.options.dev;
+        if ((isDev && options.enableDevBuild) || (!isDev && options.enableProductionBuild)) {
+            nuxt.hook('build:before', runGeneration);
+        }
+        // --- Hook: auto-regeneration on input file change (dev only) ---
+        if (options.enableAutoGeneration) {
+            nuxt.hook('builder:watch', async (event, watchedPath) => {
+                const absWatchedPath = path.resolve(nuxt.options.rootDir, watchedPath);
+                if (absWatchedPath === resolvedInput && (event === 'change' || event === 'add')) {
+                    logger.log.info(`Detected change in ${watchedPath}, regenerating composables...`);
+                    await runGeneration();
+                }
+            });
+        }
+        // --- Auto-import: register composable directories ---
+        if (options.enableAutoImport !== false) {
+            if (selectedGenerators.includes('useFetch')) {
+                addImportsDir(path.join(composablesOutputDir, 'use-fetch', 'composables'));
+            }
+            if (selectedGenerators.includes('useAsyncData')) {
+                addImportsDir(path.join(composablesOutputDir, 'use-async-data', 'composables'));
+            }
+        }
+    },
+});

package/dist/module/types.d.ts

@@ -0,0 +1,27 @@
+import type { GeneratorConfig } from '../cli/config.js';
+/**
+ * Configuration options for the nuxt-openapi-hyperfetch Nuxt module.
+ * Extends the CLI GeneratorConfig so the same fields work in both nxh.config.js and nuxt.config.ts.
+ */
+export interface ModuleOptions extends GeneratorConfig {
+    /**
+     * Generate composables before the dev server starts.
+     * @default true
+     */
+    enableDevBuild?: boolean;
+    /**
+     * Generate composables before the production build.
+     * @default true
+     */
+    enableProductionBuild?: boolean;
+    /**
+     * Watch the input file and regenerate composables on change (dev mode only).
+     * @default false
+     */
+    enableAutoGeneration?: boolean;
+    /**
+     * Automatically import generated useFetch/useAsyncData composables project-wide.
+     * @default true
+     */
+    enableAutoImport?: boolean;
+}

package/dist/module/types.js

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