@plyaz/api 1.7.2 → 1.7.4

package/dist/index.mjs

@@ -12851,10 +12851,17 @@ __name(createStatusCodeLimits, "createStatusCodeLimits");
 var cacheStrategies = {
   /**
    * No caching - always fetch fresh data
-   * Use for: Real-time data, sensitive information
+   * Use for: Real-time data, sensitive information, mutations
+   *
+   * IMPORTANT: Explicit ttl/stale of 0 prevents staleTime refetch issues.
+   * The skip:true alone doesn't prevent default staleTime from being applied.
    */
   none: {
-    skip: true
+    skip: true,
+    ttl: 0,
+    // No caching
+    stale: 0
+    // No stale refetch (prevents 60s re-trigger issue)
   },
   /**
    * Short-lived cache for frequently changing data
@@ -17239,18 +17246,19 @@ var unifiedStrategies = {
   },
   /**
    * Mutation: POST/PUT/DELETE operations (uploads, creates, updates, deletes)
-   * - NO caching (mutations should never be cached)
-   * - Standard retry for actual failures
+   * - NO caching (cache: 'none' sets skip:true, ttl:0, stale:0 - prevents staleTime refetch!)
+   * - Conservative retry (allows retry on server errors 500/502/503/504)
    * - NO polling (critical! - polling causes duplicate mutations)
    * - Realtime performance (immediate response)
    *
-   * Use this for any data-modifying operation to prevent duplicate requests.
+   * Note: The retry is safe because it only triggers on actual errors (5xx).
+   * The staleTime refetch issue was fixed by setting stale:0 in cache:'none'.
    */
   mutation: {
     cache: "none",
-    // Never cache mutations
-    retry: "standard",
-    // Standard retry for actual failures (not successes)
+    // Never cache mutations (ttl:0, stale:0 prevents refetch)
+    retry: "conservative",
+    // Retry on server errors (500/502/503/504) only
     // NO polling - this is critical! Polling would re-execute the mutation
     performance: "realtime"
     // Immediate response, no batching
@@ -21534,10 +21542,28 @@ function mergeHeadersCaseInsensitive(...headerSets) {
   return result;
 }
 __name(mergeHeadersCaseInsensitive, "mergeHeadersCaseInsensitive");
-function createOnRequestHandler(handlers, enrichedHeadersConfig, encryptionConfig, configStrategy) {
+function createOnRequestHandler(options) {
+  const {
+    handlers,
+    enrichedHeadersConfig,
+    encryptionConfig,
+    configStrategy,
+    getResolvedFetchffConfig
+  } = options;
   return async (config) => {
     const performanceFactory = getPerformanceEventFactory();
     const requestId = generateRequestId();
+    if (getResolvedFetchffConfig) {
+      const resolvedConfig = getResolvedFetchffConfig();
+      config = {
+        ...config,
+        ...resolvedConfig,
+        headers: {
+          ...resolvedConfig.headers,
+          ...config.headers
+        }
+      };
+    }
     startRequestTracking(requestId);
     UnifiedDebugger.getInstance().trackConfigChange(
       { headers: config.headers },
@@ -21706,7 +21732,8 @@ function setupUnifiedHandlers(params) {
     enrichedHeadersConfig,
     globalConfig,
     clientOptions,
-    clearTemporaryOverrides: clearTemporaryOverrides2
+    clearTemporaryOverrides: clearTemporaryOverrides2,
+    getResolvedFetchffConfig
   } = params;
   const mergedOnRequest = mergeHandlers(
     globalConfig?.onRequest,
@@ -21732,12 +21759,13 @@ function setupUnifiedHandlers(params) {
   const encryptionConfig = mergedConfig.encryption ?? globalConfig?.encryption ?? clientOptions?.encryption;
   const configStrategy = mergedConfig.configOverride?.strategy ?? clientOptions?.configOverride?.strategy ?? globalConfig?.configOverride?.strategy ?? "merge";
   return {
-    onRequest: createOnRequestHandler(
-      mergedOnRequest,
+    onRequest: createOnRequestHandler({
+      handlers: mergedOnRequest,
       enrichedHeadersConfig,
       encryptionConfig,
-      configStrategy
-    ),
+      configStrategy,
+      getResolvedFetchffConfig
+    }),
     onResponse: createOnResponseHandler(
       mergedOnResponse,
       clearTemporaryOverrides2,
@@ -22092,15 +22120,21 @@ function createUpdateConfigMethod(initialConfigState, eventManager2, client, set
     const validation = validateConfigUpdate(updates, updateOptions);
     if (!validation.valid) {
       handleInvalidConfigUpdate(validation, updates, updateOptions);
-      return;
+      return { fetchffConfig: {}, applied: false };
     }
     const result = applyConfigUpdate(configState, updates, updateOptions);
     configState = result.state;
     setConfigState(configState);
     const newConfig = getEffectiveConfig(configState);
+    let resolvedUpdates = { ...updates };
+    if (updates.unifiedStrategy) {
+      resolvedUpdates = applyUnifiedStrategyToConfig(resolvedUpdates, updates.unifiedStrategy);
+    }
+    resolvedUpdates = applyIndividualStrategies(resolvedUpdates, updates);
+    const fetchffConfig = toFetchffConfig(resolvedUpdates);
     if (client && "__config" in client) {
       const fetchffClient = client;
-      Object.assign(fetchffClient["__config"], updates);
+      Object.assign(fetchffClient["__config"], fetchffConfig);
     }
     eventManager2.updateConfig(updates, updateOptions ?? {});
     const afterEventState = captureEventState(eventManager2);
@@ -22114,11 +22148,13 @@ function createUpdateConfigMethod(initialConfigState, eventManager2, client, set
       validation,
       startTime
     });
+    return { fetchffConfig, applied: true };
   };
 }
 __name(createUpdateConfigMethod, "createUpdateConfigMethod");
-function createFetchffClient(fetchffConfig, effectiveConfig, options, unifiedHandlers) {
-  return createApiFetcher({
+function createFetchffClient(params) {
+  const { fetchffConfig, effectiveConfig, options, unifiedHandlers, getResolvedFetchffConfig } = params;
+  const rawClient = createApiFetcher({
     ...fetchffConfig,
     baseURL: effectiveConfig.baseURL ?? options.apiUrl,
     endpoints,
@@ -22127,6 +22163,26 @@ function createFetchffClient(fetchffConfig, effectiveConfig, options, unifiedHan
     onError: unifiedHandlers.onError,
     onRetry: unifiedHandlers.onRetry
   });
+  const endpointMethodNames = new Set(Object.keys(endpoints));
+  return new Proxy(rawClient, {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof value !== "function" || typeof prop !== "string") {
+        return value;
+      }
+      if (!endpointMethodNames.has(prop)) {
+        return value;
+      }
+      return /* @__PURE__ */ __name(function wrappedEndpointMethod(config) {
+        const resolvedConfig = getResolvedFetchffConfig();
+        const mergedConfig = {
+          ...resolvedConfig,
+          ...config
+        };
+        return value.call(this, mergedConfig);
+      }, "wrappedEndpointMethod");
+    }
+  });
 }
 __name(createFetchffClient, "createFetchffClient");
 function enhanceClientWithMethods(params) {
@@ -22211,14 +22267,33 @@ async function createApiClient(options = {}) {
     const effectiveConfig = getEffectiveConfig(stateContainer.current);
     const fetchffConfig = toFetchffConfig(effectiveConfig);
     let clearTemporaryOverridesFn;
+    const getResolvedFetchffConfig = /* @__PURE__ */ __name(() => {
+      const currentConfig = getEffectiveConfig(stateContainer.current);
+      let resolvedConfig2 = { ...currentConfig };
+      if (currentConfig.unifiedStrategy) {
+        resolvedConfig2 = applyUnifiedStrategyToConfig(
+          resolvedConfig2,
+          currentConfig.unifiedStrategy
+        );
+      }
+      resolvedConfig2 = applyIndividualStrategies(resolvedConfig2, currentConfig);
+      return toFetchffConfig(resolvedConfig2);
+    }, "getResolvedFetchffConfig");
     const unifiedHandlers = setupUnifiedHandlers({
       mergedConfig: effectiveConfig,
       enrichedHeadersConfig: options.enrichedHeaders,
       globalConfig,
       clientOptions: options,
-      clearTemporaryOverrides: /* @__PURE__ */ __name(() => clearTemporaryOverridesFn?.(), "clearTemporaryOverrides")
+      clearTemporaryOverrides: /* @__PURE__ */ __name(() => clearTemporaryOverridesFn?.(), "clearTemporaryOverrides"),
+      getResolvedFetchffConfig
+    });
+    const client = createFetchffClient({
+      fetchffConfig,
+      effectiveConfig,
+      options,
+      unifiedHandlers,
+      getResolvedFetchffConfig
     });
-    const client = createFetchffClient(fetchffConfig, effectiveConfig, options, unifiedHandlers);
     const clientWithEvents = setupClientEvents(client, globalConfig, options);
     const { eventManager: eventManager2 } = clientWithEvents;
     Object.defineProperty(clientWithEvents, "then", {
@@ -25625,15 +25700,18 @@ __name(fetchCampaignParticipants, "fetchCampaignParticipants");
 
 // src/api/services/campaigns/GET/useCampaign.ts
 function useCampaign(queryKey, campaignId, serviceOptions, queryOptions) {
-  return createApiQuery(fetchCampaign, {
-    // Use 'background' unified strategy for stable entity data (includes longLived cache)
-    // Using unifiedStrategy (lowest precedence) allows easy override via:
-    // - serviceOptions.apiConfig.cacheStrategy (higher precedence)
-    // - serviceOptions.apiConfig.unifiedStrategy (same precedence, user wins)
-    apiConfig: {
-      unifiedStrategy: "background"
+  return createApiQuery(
+    fetchCampaign,
+    {
+      // Use 'background' unified strategy for stable entity data (includes longLived cache)
+      // Using unifiedStrategy (lowest precedence) allows easy override via:
+      // - serviceOptions.apiConfig.cacheStrategy (higher precedence)
+      // - serviceOptions.apiConfig.unifiedStrategy (same precedence, user wins)
+      apiConfig: {
+        unifiedStrategy: "background"
+      }
     }
-  })(queryKey, campaignId, serviceOptions, queryOptions);
+  )(queryKey, campaignId, serviceOptions, queryOptions);
 }
 __name(useCampaign, "useCampaign");
 
@@ -25815,15 +25893,15 @@ __name(updateCampaign, "updateCampaign");
 function useUpdateCampaign(serviceOptions, mutationOptions) {
   const queryClient = useQueryClient();
   return createApiMutation(
-    (params, opts) => updateCampaign(params.campaignId, params.data, opts),
+    (params, opts) => updateCampaign(params.id, params.data, opts),
     {
       onSuccess: /* @__PURE__ */ __name((campaign, variables) => {
-        queryClient.setQueryData(["campaign", variables.campaignId], campaign);
+        queryClient.setQueryData(["campaign", variables.id], campaign);
         void queryClient.invalidateQueries({
           queryKey: ["campaigns"]
         });
         void queryClient.invalidateQueries({
-          queryKey: ["campaign", variables.campaignId, "stats"]
+          queryKey: ["campaign", variables.id, "stats"]
         });
       }, "onSuccess"),
       // Merge default success handler with user-provided options
@@ -26958,8 +27036,8 @@ async function uploadFile(data, options) {
   const client = options?.apiClient ?? getDefaultApiClient();
   const serviceDefaults = {
     unifiedStrategy: "mutation",
-    timeout: 6e4
-    // 60 seconds for uploads
+    timeout: 12e4
+    // 2 minutes for large uploads
   };
   const mergedConfig = mergeConfigs(serviceDefaults, options?.apiConfig ?? {});
   const updateOptions = {