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

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

@@ -5,18 +5,18 @@ import { getApiFiles as getApiFilesOfficial, parseApiFile as parseApiFileOfficia
 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';
+import { createClackLogger } from '../../cli/logger.js';
 /**
  * Main function to generate Nuxt Server Routes
  */
-export async function generateNuxtServerRoutes(inputDir, serverRoutePath, options) {
-    const mainSpinner = p.spinner();
+export async function generateNuxtServerRoutes(inputDir, serverRoutePath, options, logger = createClackLogger()) {
+    const mainSpinner = logger.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)');
+        logger.log.info('BFF Mode: Enabled (transformers + auth)');
     }
     // 1. Get all API files
     mainSpinner.start('Scanning API files');
@@ -35,12 +35,12 @@ export async function generateNuxtServerRoutes(inputDir, serverRoutePath, option
             allMethods.push(...apiInfo.methods);
         }
         catch (error) {
-            logError(`Error parsing ${fileName}: ${String(error)}`);
+            logger.log.error(`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');
+        logger.log.warn('No methods found to generate');
         return;
     }
     // 3. Clean and create output directory
@@ -49,7 +49,7 @@ export async function generateNuxtServerRoutes(inputDir, serverRoutePath, option
     mainSpinner.stop('Output directory ready');
     // 4. Generate BFF structure if enabled
     if (enableBff) {
-        await generateBffStructure(allMethods, serverRoutePath, inputDir);
+        await generateBffStructure(allMethods, serverRoutePath, inputDir, logger);
     }
     // 5. Calculate relative import path from server routes to APIs
     const relativePath = calculateRelativeImportPath(serverRoutePath, inputDir);
@@ -65,7 +65,7 @@ export async function generateNuxtServerRoutes(inputDir, serverRoutePath, option
                 enableBff: enableBff,
                 resource: resource,
             });
-            const formattedCode = await formatCode(code);
+            const formattedCode = await formatCode(code, logger);
             const routeFilePath = generateRouteFilePath(method);
             const fullPath = path.join(serverRoutePath, routeFilePath);
             // Ensure directory exists
@@ -74,7 +74,7 @@ export async function generateNuxtServerRoutes(inputDir, serverRoutePath, option
             successCount++;
         }
         catch (error) {
-            logError(`Error generating ${method.path} [${method.httpMethod}]: ${String(error)}`);
+            logger.log.error(`Error generating ${method.path} [${method.httpMethod}]: ${String(error)}`);
             errorCount++;
         }
     }
@@ -83,14 +83,14 @@ export async function generateNuxtServerRoutes(inputDir, serverRoutePath, option
     mainSpinner.start('Generating configuration files');
     // Generate routes index (documentation)
     const routesIndexCode = generateRoutesIndexFile(allMethods);
-    const formattedRoutesIndex = await formatCode(routesIndexCode);
+    const formattedRoutesIndex = await formatCode(routesIndexCode, logger);
     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)`);
+        logger.log.warn(`Completed with ${errorCount} error(s)`);
     }
-    logSuccess(`Generated ${successCount} server route(s) in ${serverRoutePath}`);
+    logger.log.success(`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)';
@@ -103,7 +103,7 @@ export async function generateNuxtServerRoutes(inputDir, serverRoutePath, option
     else {
         nextSteps += '\n3. Start your Nuxt dev server and test the routes';
     }
-    logNote(nextSteps, 'Next steps');
+    logger.note(nextSteps, 'Next steps');
 }
 /**
  * Calculate relative import path from server routes to APIs
@@ -118,7 +118,7 @@ function calculateRelativeImportPath(serverRoutePath, inputDir) {
 /**
  * Format code with Prettier
  */
-async function formatCode(code) {
+async function formatCode(code, logger) {
     try {
         return await format(code, {
             parser: 'typescript',
@@ -129,15 +129,15 @@ async function formatCode(code) {
         });
     }
     catch {
-        p.log.warn('Prettier formatting failed, using unformatted code');
+        logger.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();
+async function generateBffStructure(allMethods, serverRoutePath, inputDir, logger) {
+    const bffSpinner = logger.spinner();
     bffSpinner.start('Generating BFF structure (auth + transformers)');
     const serverRoot = path.dirname(serverRoutePath);
     // 1. Generate auth files (only if they don't exist)
@@ -146,13 +146,13 @@ async function generateBffStructure(allMethods, serverRoutePath, inputDir) {
     const authContextPath = path.join(authDir, 'context.ts');
     if (!fs.existsSync(authContextPath)) {
         const authContextCode = generateAuthContextStub();
-        const formattedAuthContext = await formatCode(authContextCode);
+        const formattedAuthContext = await formatCode(authContextCode, logger);
         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);
+        const formattedAuthTypes = await formatCode(authTypesCode, logger);
         await fs.writeFile(authTypesPath, formattedAuthTypes, 'utf-8');
     }
     // 2. Generate transformer stubs (only if they don't exist)
@@ -173,14 +173,14 @@ async function generateBffStructure(allMethods, serverRoutePath, inputDir) {
         const transformerPath = path.join(transformersDir, `${resource}.ts`);
         if (!fs.existsSync(transformerPath)) {
             const transformerCode = generateTransformerStub(resource, methods, inputDir);
-            const formattedTransformer = await formatCode(transformerCode);
+            const formattedTransformer = await formatCode(transformerCode, logger);
             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);
+    const formattedExamples = await formatCode(examplesCode, logger);
     await fs.writeFile(examplesPath, formattedExamples, 'utf-8');
     // 4. Generate BFF README (always regenerated)
     const bffReadmePath = path.join(bffDir, 'README.md');

package/dist/generators/shared/runtime/apiHelpers.d.ts

@@ -40,39 +40,62 @@ export interface FinishContext<T> {
     success: boolean;
 }
 /**
- * Global callbacks configuration
- * Can be provided via Nuxt plugin: $getGlobalApiCallbacks
+ * A single rule in the global callbacks configuration.
+ * Each rule independently targets specific URL patterns and/or HTTP methods.
+ * Rules are executed in order; any rule may return false to suppress the local callback.
  */
-export interface GlobalCallbacksConfig {
+export interface GlobalCallbacksRule {
     /**
-     * Optional URL patterns to match (Opción 3)
-     * Only apply global callbacks to URLs matching these patterns
+     * URL glob patterns — only apply this rule to matching URLs.
      * Supports wildcards: '/api/**', '/api/public/*', etc.
-     * If omitted, callbacks apply to all requests
+     * If omitted, the rule applies to all URLs.
      */
     patterns?: string[];
     /**
-     * Called before every request matching patterns
-     * Return false to prevent local callback execution (Opción 2)
-     * Return modified context to change request
+     * HTTP methods — only apply this rule to matching methods (case-insensitive).
+     * Example: ['DELETE', 'POST']
+     * If omitted, the rule applies to all methods.
+     */
+    methods?: string[];
+    /**
+     * Called before the request is sent.
+     * Return modified context (headers/body/query) to alter the request.
+     * Return false to prevent local onRequest execution (Opción 2).
      */
     onRequest?: (context: RequestContext) => void | Promise<void> | ModifiedRequestContext | Promise<ModifiedRequestContext> | boolean | Promise<boolean>;
     /**
-     * Called when request succeeds
-     * Return false to prevent local callback execution (Opción 2)
+     * Called when the request succeeds.
+     * Return false to prevent local onSuccess execution (Opción 2).
      */
     onSuccess?: (data: any, context?: any) => void | Promise<void> | boolean | Promise<boolean>;
     /**
-     * Called when request fails
-     * Return false to prevent local callback execution (Opción 2)
+     * Called when the request fails.
+     * Return false to prevent local onError execution (Opción 2).
      */
     onError?: (error: any, context?: any) => void | Promise<void> | boolean | Promise<boolean>;
     /**
-     * Called when request finishes (success or error)
-     * Return false to prevent local callback execution (Opción 2)
+     * Called when the request finishes (success or error).
+     * Return false to prevent local onFinish execution (Opción 2).
      */
     onFinish?: (context: FinishContext<any>) => void | Promise<void> | boolean | Promise<boolean>;
 }
+/**
+ * Global callbacks configuration.
+ * Accepts a single rule (backward-compatible) or an array of rules.
+ * Each rule can independently target URLs and HTTP methods.
+ * Provided via Nuxt plugin: $getGlobalApiCallbacks
+ *
+ * @example Single rule (backward-compatible)
+ * getGlobalApiCallbacks: () => ({ onError: (e) => console.error(e) })
+ *
+ * @example Multiple rules with method/pattern targeting
+ * getGlobalApiCallbacks: () => [
+ *   { onRequest: (ctx) => console.log(ctx.url) },
+ *   { methods: ['DELETE'], onSuccess: () => toast.success('Deleted!') },
+ *   { patterns: ['/api/private/**'], onRequest: () => ({ headers: { Authorization: '...' } }) },
+ * ]
+ */
+export type GlobalCallbacksConfig = GlobalCallbacksRule | GlobalCallbacksRule[];
 /**
  * Type for skipGlobalCallbacks option (Opción 1)
  * - true: skip all global callbacks
@@ -124,6 +147,28 @@ export interface ApiRequestOptions<T = any> {
      * Useful for manual cache control or sharing cache between components.
      */
     cacheKey?: string;
+    /**
+     * Enable pagination for this request.
+     * When true, the composable injects page/perPage params and exposes `pagination` state + helpers.
+     * Uses global pagination config by default (set via plugins/api-pagination.ts).
+     * @example
+     * const { data, pagination, goToPage, nextPage, prevPage, setPerPage } = useGetPets(params, { paginated: true })
+     */
+    paginated?: boolean;
+    /**
+     * Initial page number. Defaults to global config default (usually 1).
+     */
+    initialPage?: number;
+    /**
+     * Initial page size. Defaults to global config default (usually 20).
+     */
+    initialPerPage?: number;
+    /**
+     * Per-request pagination config override.
+     * Takes priority over the global pagination config set in plugins/api-pagination.ts.
+     * Useful when one specific endpoint has a different pagination convention.
+     */
+    paginationConfig?: import('./pagination.js').PaginationConfig;
     /** Base URL prepended to every request URL. Overrides runtimeConfig.public.apiBaseUrl. */
     baseURL?: string;
     /** HTTP method (GET, POST, PUT, PATCH, DELETE, etc.) */
@@ -154,52 +199,47 @@ export declare function applyPick<T>(data: T, paths: ReadonlyArray<string>): any
  */
 export declare function getGlobalHeaders(): Record<string, string>;
 /**
- * Helper function to get global callbacks from user configuration
+ * Helper function to get global callback rules from user configuration.
+ * Always returns a normalized array — wraps legacy single-object config automatically for
+ * full backward compatibility.
  * Uses Nuxt plugin provide: plugins/api-callbacks.ts with $getGlobalApiCallbacks
  */
-export declare function getGlobalCallbacks(): GlobalCallbacksConfig;
+export declare function getGlobalCallbacks(): GlobalCallbacksRule[];
 /**
  * Helper function to get the global base URL from runtimeConfig.public.apiBaseUrl
  * Returns the configured URL or undefined if not set or not in a Nuxt context.
  */
 export declare function getGlobalBaseUrl(): string | undefined;
 /**
- * Check if a global callback should be applied to a specific request
- * Implements Opción 1 (skipGlobalCallbacks) and Opción 3 (pattern matching)
+ * Check if a global rule should be applied to a specific request.
+ * Implements Opción 1 (skipGlobalCallbacks), URL pattern matching, and HTTP method matching.
  */
-export declare function shouldApplyGlobalCallback(url: string, callbackName: 'onRequest' | 'onSuccess' | 'onError' | 'onFinish', patterns?: string[], skipConfig?: SkipGlobalCallbacks): boolean;
+export declare function shouldApplyGlobalCallback(url: string, method: string, callbackName: 'onRequest' | 'onSuccess' | 'onError' | 'onFinish', rule: GlobalCallbacksRule, skipConfig?: SkipGlobalCallbacks): boolean;
 /**
- * Merge local and global callbacks with proper execution order
+ * Merge local and global callback rules with proper execution order.
+ * Global rules are iterated in definition order. Any rule returning false suppresses the local callback.
  * Implements all 3 options:
- * - Opción 1: skipGlobalCallbacks to disable global callbacks
- * - Opción 2: global callbacks can return false to prevent local execution
- * - Opción 3: pattern matching to apply callbacks only to matching URLs
+ * - Opción 1: skipGlobalCallbacks to disable all global rules per request
+ * - Opción 2: a rule callback can return false to prevent local callback execution
+ * - Opción 3: per-rule URL pattern matching and HTTP method filtering
  */
-export declare function mergeCallbacks(url: string, localCallbacks: {
+export declare function mergeCallbacks(url: string, method: string, localCallbacks: {
     onRequest?: Function;
     onSuccess?: Function;
     onError?: Function;
     onFinish?: Function;
 }, skipConfig?: SkipGlobalCallbacks): {
     /**
-     * Merged onRequest callback
-     * Executes global first, then local
-     * Global can return modifications or false to cancel local
-     */
-    onRequest: (ctx: RequestContext) => Promise<any>;
-    /**
-     * Merged onSuccess callback
-     * Executes global first, then local (if global doesn't return false)
+     * Merged onRequest: runs all applicable global rules collecting and deep-merging
+     * modifications (headers and query are merged; body is last-write-wins).
+     * Local onRequest runs after all rules unless any returns false, and its
+     * modifications take highest priority.
      */
+    onRequest: (ctx: RequestContext) => Promise<ModifiedRequestContext | undefined>;
+    /** Merged onSuccess: global rules first in order, then local (unless suppressed). */
     onSuccess: (data: any, context?: any) => Promise<void>;
-    /**
-     * Merged onError callback
-     * Executes global first, then local (if global doesn't return false)
-     */
+    /** Merged onError: global rules first in order, then local (unless suppressed). */
     onError: (error: any, context?: any) => Promise<void>;
-    /**
-     * Merged onFinish callback
-     * Executes global first, then local (if global doesn't return false)
-     */
+    /** Merged onFinish: global rules first in order, then local (unless suppressed). */
     onFinish: (context: any) => Promise<void>;
 };

package/dist/generators/shared/runtime/apiHelpers.js

@@ -101,7 +101,9 @@ export function getGlobalHeaders() {
     return headers;
 }
 /**
- * Helper function to get global callbacks from user configuration
+ * Helper function to get global callback rules from user configuration.
+ * Always returns a normalized array — wraps legacy single-object config automatically for
+ * full backward compatibility.
  * Uses Nuxt plugin provide: plugins/api-callbacks.ts with $getGlobalApiCallbacks
  */
 export function getGlobalCallbacks() {
@@ -110,16 +112,17 @@ export function getGlobalCallbacks() {
         // @ts-ignore - $getGlobalApiCallbacks may or may not exist (user-defined)
         if (nuxtApp.$getGlobalApiCallbacks) {
             // @ts-ignore
-            const callbacks = nuxtApp.$getGlobalApiCallbacks();
-            if (callbacks && typeof callbacks === 'object') {
-                return callbacks;
+            const config = nuxtApp.$getGlobalApiCallbacks();
+            if (config && typeof config === 'object') {
+                // Normalize: wrap single-rule object in array for backward compatibility
+                return Array.isArray(config) ? config : [config];
             }
         }
     }
     catch (e) {
         // useNuxtApp not available or plugin not configured, that's OK
     }
-    return {};
+    return [];
 }
 /**
  * Helper function to get the global base URL from runtimeConfig.public.apiBaseUrl
@@ -137,144 +140,134 @@ export function getGlobalBaseUrl() {
     }
 }
 /**
- * Check if a global callback should be applied to a specific request
- * Implements Opción 1 (skipGlobalCallbacks) and Opción 3 (pattern matching)
+ * Check if a global rule should be applied to a specific request.
+ * Implements Opción 1 (skipGlobalCallbacks), URL pattern matching, and HTTP method matching.
  */
-export function shouldApplyGlobalCallback(url, callbackName, patterns, skipConfig) {
+export function shouldApplyGlobalCallback(url, method, callbackName, rule, skipConfig) {
     // Opción 1: Check if callback is skipped via skipGlobalCallbacks
-    if (skipConfig === true) {
-        return false; // Skip all global callbacks
-    }
-    if (Array.isArray(skipConfig) && skipConfig.includes(callbackName)) {
-        return false; // Skip this specific callback
-    }
-    // Opción 3: Check pattern matching
-    if (patterns && patterns.length > 0) {
-        return patterns.some((pattern) => {
-            // Convert glob pattern to regex
-            // ** matches any characters including /
-            // * matches any characters except /
+    if (skipConfig === true)
+        return false;
+    if (Array.isArray(skipConfig) && skipConfig.includes(callbackName))
+        return false;
+    // URL pattern matching — if patterns defined, URL must match at least one
+    if (rule.patterns && rule.patterns.length > 0) {
+        const matchesUrl = rule.patterns.some((pattern) => {
+            // Convert glob pattern to regex: ** = any path, * = single segment
             const regexPattern = pattern
                 .replace(/\*\*/g, '@@DOUBLE_STAR@@')
                 .replace(/\*/g, '[^/]*')
                 .replace(/@@DOUBLE_STAR@@/g, '.*');
-            const regex = new RegExp('^' + regexPattern + '$');
-            return regex.test(url);
+            return new RegExp('^' + regexPattern + '$').test(url);
         });
+        if (!matchesUrl)
+            return false;
+    }
+    // Method matching — if methods defined, request method must match at least one
+    if (rule.methods && rule.methods.length > 0) {
+        if (!rule.methods.map((m) => m.toUpperCase()).includes(method.toUpperCase()))
+            return false;
     }
-    // By default, apply global callback
     return true;
 }
 /**
- * Merge local and global callbacks with proper execution order
+ * Merge local and global callback rules with proper execution order.
+ * Global rules are iterated in definition order. Any rule returning false suppresses the local callback.
  * Implements all 3 options:
- * - Opción 1: skipGlobalCallbacks to disable global callbacks
- * - Opción 2: global callbacks can return false to prevent local execution
- * - Opción 3: pattern matching to apply callbacks only to matching URLs
+ * - Opción 1: skipGlobalCallbacks to disable all global rules per request
+ * - Opción 2: a rule callback can return false to prevent local callback execution
+ * - Opción 3: per-rule URL pattern matching and HTTP method filtering
  */
-export function mergeCallbacks(url, localCallbacks, skipConfig) {
-    const global = getGlobalCallbacks();
+export function mergeCallbacks(url, method, localCallbacks, skipConfig) {
+    const rules = getGlobalCallbacks();
+    /**
+     * Iterate all applicable global rules for onSuccess, onError, or onFinish.
+     * Returns true if the local callback should still execute.
+     */
+    async function runGlobalRules(callbackName, ...args) {
+        let continueLocal = true;
+        for (const rule of rules) {
+            const cb = rule[callbackName];
+            if (!cb || !shouldApplyGlobalCallback(url, method, callbackName, rule, skipConfig))
+                continue;
+            try {
+                const result = await cb(...args);
+                // Opción 2: returning false from any rule suppresses the local callback
+                if (result === false)
+                    continueLocal = false;
+            }
+            catch (error) {
+                console.error(`Error in global ${callbackName} callback:`, error);
+            }
+        }
+        return continueLocal;
+    }
     return {
         /**
-         * Merged onRequest callback
-         * Executes global first, then local
-         * Global can return modifications or false to cancel local
+         * Merged onRequest: runs all applicable global rules collecting and deep-merging
+         * modifications (headers and query are merged; body is last-write-wins).
+         * Local onRequest runs after all rules unless any returns false, and its
+         * modifications take highest priority.
          */
         onRequest: async (ctx) => {
-            // Execute global onRequest
-            if (shouldApplyGlobalCallback(url, 'onRequest', global.patterns, skipConfig) &&
-                global.onRequest) {
+            let mergedMods;
+            let continueLocal = true;
+            for (const rule of rules) {
+                if (!rule.onRequest || !shouldApplyGlobalCallback(url, method, 'onRequest', rule, skipConfig))
+                    continue;
                 try {
-                    const result = await global.onRequest(ctx);
-                    // Opción 2: If global returns false, don't execute local
+                    const result = await rule.onRequest(ctx);
                     if (result === false) {
-                        return;
+                        continueLocal = false;
                     }
-                    // If global returns modified context, use it
-                    if (result && typeof result === 'object' && !('then' in result)) {
-                        return result;
+                    else if (result && typeof result === 'object') {
+                        const mod = result;
+                        // Deep-merge headers and query; body is last-write-wins
+                        mergedMods = {
+                            ...(mergedMods ?? {}),
+                            ...mod,
+                            headers: { ...(mergedMods?.headers ?? {}), ...(mod.headers ?? {}) },
+                            query: { ...(mergedMods?.query ?? {}), ...(mod.query ?? {}) },
+                        };
                     }
                 }
                 catch (error) {
                     console.error('Error in global onRequest callback:', error);
                 }
             }
-            // Execute local onRequest
-            if (localCallbacks.onRequest) {
-                return await localCallbacks.onRequest(ctx);
+            // Execute local onRequest — its modifications take highest priority
+            if (continueLocal && localCallbacks.onRequest) {
+                const localResult = await localCallbacks.onRequest(ctx);
+                if (localResult && typeof localResult === 'object') {
+                    const localMod = localResult;
+                    return mergedMods
+                        ? {
+                            ...mergedMods,
+                            ...localMod,
+                            headers: { ...(mergedMods.headers ?? {}), ...(localMod.headers ?? {}) },
+                            query: { ...(mergedMods.query ?? {}), ...(localMod.query ?? {}) },
+                        }
+                        : localMod;
+                }
             }
+            return mergedMods;
         },
-        /**
-         * Merged onSuccess callback
-         * Executes global first, then local (if global doesn't return false)
-         */
+        /** Merged onSuccess: global rules first in order, then local (unless suppressed). */
         onSuccess: async (data, context) => {
-            let continueLocal = true;
-            // Execute global onSuccess
-            if (shouldApplyGlobalCallback(url, 'onSuccess', global.patterns, skipConfig) &&
-                global.onSuccess) {
-                try {
-                    const result = await global.onSuccess(data, context);
-                    // Opción 2: If global returns false, don't execute local
-                    if (result === false) {
-                        continueLocal = false;
-                    }
-                }
-                catch (error) {
-                    console.error('Error in global onSuccess callback:', error);
-                }
-            }
-            // Execute local onSuccess (if not cancelled)
+            const continueLocal = await runGlobalRules('onSuccess', data, context);
             if (continueLocal && localCallbacks.onSuccess) {
                 await localCallbacks.onSuccess(data, context);
             }
         },
-        /**
-         * Merged onError callback
-         * Executes global first, then local (if global doesn't return false)
-         */
+        /** Merged onError: global rules first in order, then local (unless suppressed). */
         onError: async (error, context) => {
-            let continueLocal = true;
-            // Execute global onError
-            if (shouldApplyGlobalCallback(url, 'onError', global.patterns, skipConfig) &&
-                global.onError) {
-                try {
-                    const result = await global.onError(error, context);
-                    // Opción 2: If global returns false, don't execute local
-                    if (result === false) {
-                        continueLocal = false;
-                    }
-                }
-                catch (error) {
-                    console.error('Error in global onError callback:', error);
-                }
-            }
-            // Execute local onError (if not cancelled)
+            const continueLocal = await runGlobalRules('onError', error, context);
             if (continueLocal && localCallbacks.onError) {
                 await localCallbacks.onError(error, context);
             }
         },
-        /**
-         * Merged onFinish callback
-         * Executes global first, then local (if global doesn't return false)
-         */
+        /** Merged onFinish: global rules first in order, then local (unless suppressed). */
         onFinish: async (context) => {
-            let continueLocal = true;
-            // Execute global onFinish
-            if (shouldApplyGlobalCallback(url, 'onFinish', global.patterns, skipConfig) &&
-                global.onFinish) {
-                try {
-                    const result = await global.onFinish(context);
-                    // Opción 2: If global returns false, don't execute local
-                    if (result === false) {
-                        continueLocal = false;
-                    }
-                }
-                catch (error) {
-                    console.error('Error in global onFinish callback:', error);
-                }
-            }
-            // Execute local onFinish (if not cancelled)
+            const continueLocal = await runGlobalRules('onFinish', context);
             if (continueLocal && localCallbacks.onFinish) {
                 await localCallbacks.onFinish(context);
             }