@conduit-client/service-retry 3.0.0 → 3.3.0

package/dist/types/v1/__tests__/composed-retry-policy.spec.d.ts

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

package/dist/types/v1/composed-retry-policy.d.ts

@@ -0,0 +1,106 @@
+import { RetryPolicy } from './retry-policy';
+import type { RetryContext } from './retry-service';
+/**
+ * Composes multiple retry policies into a single policy.
+ *
+ * This allows combining different retry strategies (e.g., throttling + CSRF)
+ * into one policy that can be used with the RetryService.
+ *
+ * ## Behavior
+ *
+ * - **shouldRetry**: Returns true if ANY policy wants to retry (OR logic)
+ * - **calculateDelay**: Uses delay from the FIRST policy that wants to retry (order matters!)
+ * - **prepareRetry**: Calls prepareRetry ONLY on policies that matched shouldRetry (runs in parallel)
+ *
+ * ## Important Notes
+ *
+ * **Policy Order Matters**: The order of policies in the array determines which delay is used
+ * when multiple policies want to retry. Place more specific or higher-priority policies first.
+ *
+ * **prepareRetry Efficiency**: Only policies that matched shouldRetry will have their
+ * prepareRetry called. This avoids unnecessary work and side effects for unrelated retry
+ * conditions. If multiple policies match, their prepareRetry hooks run in parallel.
+ *
+ * **Avoid Overlapping Conditions**: If multiple policies have overlapping retry conditions
+ * (e.g., both retry on 500 errors), the first policy's delay will always be used. Design
+ * policies with distinct, non-overlapping conditions when possible.
+ *
+ * @example
+ * ```typescript
+ * const throttling = new FetchThrottlingRetryPolicy();
+ * const csrf = new CsrfTokenRetryPolicy();
+ * const composed = new ComposedRetryPolicy([throttling, csrf]);
+ *
+ * const retryService = new RetryService(composed);
+ * ```
+ */
+export declare class ComposedRetryPolicy<T> extends RetryPolicy<T> {
+    private readonly policies;
+    constructor(policies: RetryPolicy<T>[]);
+    /**
+     * Returns true if any of the composed policies want to retry.
+     *
+     * Uses OR logic: if ANY policy returns true, this returns true.
+     * Policies are checked in order and evaluation short-circuits on the first match.
+     */
+    shouldRetry(result: T, context: RetryContext<T>): Promise<boolean>;
+    /**
+     * Returns the delay from the first policy that wants to retry.
+     *
+     * If multiple policies want to retry, only the FIRST policy's delay is used.
+     * Policy order in the constructor array determines priority.
+     * If no policy wants to retry, returns 0.
+     *
+     * @example
+     * ```typescript
+     * // If both PolicyA (1000ms) and PolicyB (5000ms) want to retry:
+     * const composed = new ComposedRetryPolicy([policyA, policyB]);
+     * composed.calculateDelay(result, context); // Returns 1000ms (PolicyA wins)
+     * ```
+     */
+    calculateDelay(result: T, context: RetryContext<T>): Promise<number>;
+    /**
+     * Calls prepareRetry on policies that both:
+     * 1. Implement the prepareRetry hook, AND
+     * 2. Returned true from shouldRetry for this result
+     *
+     * This allows only the matching policies to perform preparation work (e.g., token refresh).
+     * All matching prepareRetry calls run in parallel for efficiency.
+     *
+     * **Important**: prepareRetry only runs on policies that matched shouldRetry. This ensures
+     * you don't perform unnecessary work or side effects for unrelated retry conditions.
+     *
+     * **Note**: If multiple policies match and have prepareRetry, ensure they don't have
+     * conflicting side effects since they run in parallel.
+     *
+     * @example
+     * ```typescript
+     * // Status 401 occurs
+     * const composed = new ComposedRetryPolicy([
+     *   authPolicy,      // shouldRetry(401) → true, has prepareRetry
+     *   throttlePolicy,  // shouldRetry(401) → false, has prepareRetry
+     * ]);
+     *
+     * await composed.prepareRetry(result, context);
+     * // → Only authPolicy.prepareRetry() runs (because it matched)
+     * // → throttlePolicy.prepareRetry() does NOT run (didn't match)
+     * ```
+     */
+    prepareRetry(result: T, context: RetryContext<T>): Promise<void>;
+    /**
+     * Returns all composed policies.
+     * Useful for accessing or configuring individual policies after composition.
+     */
+    getPolicies(): RetryPolicy<T>[];
+    /**
+     * Helper to get a specific policy by type.
+     * Useful for calling policy-specific methods after composition.
+     *
+     * @example
+     * ```typescript
+     * const csrfPolicy = composedPolicy.getPolicyByType(CsrfTokenRetryPolicy);
+     * csrfPolicy?.setRequestContext(mutableRequest);
+     * ```
+     */
+    getPolicyByType<P extends RetryPolicy<T>>(policyType: new (...args: any[]) => P): P | undefined;
+}

package/dist/types/v1/index.d.ts

@@ -4,5 +4,6 @@ import type { NamedService, ServiceDescriptor } from '@conduit-client/utils';
 export type NamedRetryService = NamedService<'retry', RetryService<any>>;
 export { RetryService, type RetryContext } from './retry-service';
 export { RetryPolicy } from './retry-policy';
+export { ComposedRetryPolicy } from './composed-retry-policy';
 export type RetryServiceDescriptor = ServiceDescriptor<RetryService<any>, 'retry', '1.0'>;
 export declare function buildServiceDescriptor<T>(defaultRetryPolicy: RetryPolicy<T>): RetryServiceDescriptor;

package/dist/types/v1/retry-policy.d.ts

@@ -1,5 +1,13 @@
 import type { RetryContext } from './retry-service';
 export declare abstract class RetryPolicy<T> {
-    abstract shouldRetry(result: T, context: RetryContext<T>): boolean;
-    abstract calculateDelay(result: T, context: RetryContext<T>): number;
+    abstract shouldRetry(result: T, context: RetryContext<T>): Promise<boolean>;
+    abstract calculateDelay(result: T, context: RetryContext<T>): Promise<number>;
+    /**
+     * Optional hook called before each retry attempt.
+     * Allows policies to perform async preparation work before retrying.
+     *
+     * @param result - The result that triggered the retry
+     * @param context - Current retry context including attempt number and elapsed time
+     */
+    prepareRetry?(result: T, context: RetryContext<T>): Promise<void>;
 }

package/dist/v1/index.js

@@ -19,9 +19,12 @@ class RetryService {
       totalElapsedMs: Date.now() - startTime,
       lastResult: result
     };
-    while (policy.shouldRetry(result, context)) {
-      const delay = policy.calculateDelay(result, context);
+    while (await policy.shouldRetry(result, context)) {
+      const delay = await policy.calculateDelay(result, context);
       await this.delay(delay);
+      if (policy.prepareRetry) {
+        await policy.prepareRetry(result, context);
+      }
       attempt++;
       result = await operation();
       context = {
@@ -40,6 +43,108 @@ class RetryService {
 }
 class RetryPolicy {
 }
+class ComposedRetryPolicy extends RetryPolicy {
+  constructor(policies) {
+    super();
+    this.policies = policies;
+  }
+  /**
+   * Returns true if any of the composed policies want to retry.
+   *
+   * Uses OR logic: if ANY policy returns true, this returns true.
+   * Policies are checked in order and evaluation short-circuits on the first match.
+   */
+  async shouldRetry(result, context) {
+    for (const policy of this.policies) {
+      if (await policy.shouldRetry(result, context)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Returns the delay from the first policy that wants to retry.
+   *
+   * If multiple policies want to retry, only the FIRST policy's delay is used.
+   * Policy order in the constructor array determines priority.
+   * If no policy wants to retry, returns 0.
+   *
+   * @example
+   * ```typescript
+   * // If both PolicyA (1000ms) and PolicyB (5000ms) want to retry:
+   * const composed = new ComposedRetryPolicy([policyA, policyB]);
+   * composed.calculateDelay(result, context); // Returns 1000ms (PolicyA wins)
+   * ```
+   */
+  async calculateDelay(result, context) {
+    for (const policy of this.policies) {
+      if (await policy.shouldRetry(result, context)) {
+        return policy.calculateDelay(result, context);
+      }
+    }
+    return 0;
+  }
+  /**
+   * Calls prepareRetry on policies that both:
+   * 1. Implement the prepareRetry hook, AND
+   * 2. Returned true from shouldRetry for this result
+   *
+   * This allows only the matching policies to perform preparation work (e.g., token refresh).
+   * All matching prepareRetry calls run in parallel for efficiency.
+   *
+   * **Important**: prepareRetry only runs on policies that matched shouldRetry. This ensures
+   * you don't perform unnecessary work or side effects for unrelated retry conditions.
+   *
+   * **Note**: If multiple policies match and have prepareRetry, ensure they don't have
+   * conflicting side effects since they run in parallel.
+   *
+   * @example
+   * ```typescript
+   * // Status 401 occurs
+   * const composed = new ComposedRetryPolicy([
+   *   authPolicy,      // shouldRetry(401) → true, has prepareRetry
+   *   throttlePolicy,  // shouldRetry(401) → false, has prepareRetry
+   * ]);
+   *
+   * await composed.prepareRetry(result, context);
+   * // → Only authPolicy.prepareRetry() runs (because it matched)
+   * // → throttlePolicy.prepareRetry() does NOT run (didn't match)
+   * ```
+   */
+  async prepareRetry(result, context) {
+    const matchingPolicies = [];
+    for (const policy of this.policies) {
+      if (policy.prepareRetry !== void 0 && await policy.shouldRetry(result, context)) {
+        matchingPolicies.push(policy);
+      }
+    }
+    if (matchingPolicies.length > 0) {
+      await Promise.all(
+        matchingPolicies.map((policy) => policy.prepareRetry(result, context))
+      );
+    }
+  }
+  /**
+   * Returns all composed policies.
+   * Useful for accessing or configuring individual policies after composition.
+   */
+  getPolicies() {
+    return this.policies;
+  }
+  /**
+   * Helper to get a specific policy by type.
+   * Useful for calling policy-specific methods after composition.
+   *
+   * @example
+   * ```typescript
+   * const csrfPolicy = composedPolicy.getPolicyByType(CsrfTokenRetryPolicy);
+   * csrfPolicy?.setRequestContext(mutableRequest);
+   * ```
+   */
+  getPolicyByType(policyType) {
+    return this.policies.find((policy) => policy instanceof policyType);
+  }
+}
 function buildServiceDescriptor(defaultRetryPolicy) {
   return {
     version: "1.0",
@@ -48,6 +153,7 @@ function buildServiceDescriptor(defaultRetryPolicy) {
   };
 }
 export {
+  ComposedRetryPolicy,
   RetryPolicy,
   RetryService,
   buildServiceDescriptor

package/dist/v1/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../../src/v1/retry-service.ts","../../src/v1/retry-policy.ts","../../src/v1/index.ts"],"sourcesContent":["import type { RetryPolicy } from './retry-policy';\n\nexport interface RetryContext<T> {\n    attempt: number;\n    totalElapsedMs: number;\n    lastResult?: T;\n}\n\nexport interface IRetryService<T> {\n    applyRetry(operation: () => Promise<T>, retryPolicyOverride?: RetryPolicy<T>): Promise<T>;\n}\n\nexport class RetryService<T> implements IRetryService<T> {\n    constructor(private readonly defaultRetryPolicy: RetryPolicy<T>) {}\n\n    applyRetry(operation: () => Promise<T>, retryPolicyOverride?: RetryPolicy<T>): Promise<T> {\n        return this.retry(operation, retryPolicyOverride || this.defaultRetryPolicy);\n    }\n\n    protected async retry(operation: () => Promise<T>, policy: RetryPolicy<T>): Promise<T> {\n        const startTime = Date.now();\n\n        let attempt = 0;\n        let result: T = await operation();\n        let context: RetryContext<T> = {\n            attempt,\n            totalElapsedMs: Date.now() - startTime,\n            lastResult: result,\n        };\n\n        while (policy.shouldRetry(result, context)) {\n            const delay = policy.calculateDelay(result, context);\n            await this.delay(delay);\n\n            attempt++;\n            result = await operation();\n            context = {\n                attempt,\n                totalElapsedMs: Date.now() - startTime,\n                lastResult: result,\n            };\n        }\n\n        return result;\n    }\n\n    private delay(ms: number): Promise<void> {\n        return new Promise((resolve) => {\n            setTimeout(resolve, ms);\n        });\n    }\n}\n","import type { RetryContext } from './retry-service';\n\nexport abstract class RetryPolicy<T> {\n    abstract shouldRetry(result: T, context: RetryContext<T>): boolean;\n    abstract calculateDelay(result: T, context: RetryContext<T>): number;\n}\n","import { RetryService } from './retry-service';\nimport type { RetryPolicy } from './retry-policy';\nimport type { NamedService, ServiceDescriptor } from '@conduit-client/utils';\n\nexport type NamedRetryService = NamedService<'retry', RetryService<any>>;\nexport { RetryService, type RetryContext } from './retry-service';\nexport { RetryPolicy } from './retry-policy';\nexport type RetryServiceDescriptor = ServiceDescriptor<RetryService<any>, 'retry', '1.0'>;\n\nexport function buildServiceDescriptor<T>(\n    defaultRetryPolicy: RetryPolicy<T>\n): RetryServiceDescriptor {\n    return {\n        version: '1.0' as const,\n        service: new RetryService<T>(defaultRetryPolicy),\n        type: 'retry',\n    };\n}\n"],"names":[],"mappings":";;;;;AAYO,MAAM,aAA4C;AAAA,EACrD,YAA6B,oBAAoC;AAApC,SAAA,qBAAA;AAAA,EAAqC;AAAA,EAElE,WAAW,WAA6B,qBAAkD;AACtF,WAAO,KAAK,MAAM,WAAW,uBAAuB,KAAK,kBAAkB;AAAA,EAC/E;AAAA,EAEA,MAAgB,MAAM,WAA6B,QAAoC;AACnF,UAAM,YAAY,KAAK,IAAA;AAEvB,QAAI,UAAU;AACd,QAAI,SAAY,MAAM,UAAA;AACtB,QAAI,UAA2B;AAAA,MAC3B;AAAA,MACA,gBAAgB,KAAK,IAAA,IAAQ;AAAA,MAC7B,YAAY;AAAA,IAAA;AAGhB,WAAO,OAAO,YAAY,QAAQ,OAAO,GAAG;AACxC,YAAM,QAAQ,OAAO,eAAe,QAAQ,OAAO;AACnD,YAAM,KAAK,MAAM,KAAK;AAEtB;AACA,eAAS,MAAM,UAAA;AACf,gBAAU;AAAA,QACN;AAAA,QACA,gBAAgB,KAAK,IAAA,IAAQ;AAAA,QAC7B,YAAY;AAAA,MAAA;AAAA,IAEpB;AAEA,WAAO;AAAA,EACX;AAAA,EAEQ,MAAM,IAA2B;AACrC,WAAO,IAAI,QAAQ,CAAC,YAAY;AAC5B,iBAAW,SAAS,EAAE;AAAA,IAC1B,CAAC;AAAA,EACL;AACJ;ACjDO,MAAe,YAAe;AAGrC;ACIO,SAAS,uBACZ,oBACsB;AACtB,SAAO;AAAA,IACH,SAAS;AAAA,IACT,SAAS,IAAI,aAAgB,kBAAkB;AAAA,IAC/C,MAAM;AAAA,EAAA;AAEd;"}
+{"version":3,"file":"index.js","sources":["../../src/v1/retry-service.ts","../../src/v1/retry-policy.ts","../../src/v1/composed-retry-policy.ts","../../src/v1/index.ts"],"sourcesContent":["import type { RetryPolicy } from './retry-policy';\n\nexport interface RetryContext<T> {\n    attempt: number;\n    totalElapsedMs: number;\n    lastResult?: T;\n}\n\nexport interface IRetryService<T> {\n    applyRetry(operation: () => Promise<T>, retryPolicyOverride?: RetryPolicy<T>): Promise<T>;\n}\n\nexport class RetryService<T> implements IRetryService<T> {\n    constructor(private readonly defaultRetryPolicy: RetryPolicy<T>) {}\n\n    applyRetry(operation: () => Promise<T>, retryPolicyOverride?: RetryPolicy<T>): Promise<T> {\n        return this.retry(operation, retryPolicyOverride || this.defaultRetryPolicy);\n    }\n\n    protected async retry(operation: () => Promise<T>, policy: RetryPolicy<T>): Promise<T> {\n        const startTime = Date.now();\n\n        let attempt = 0;\n        let result: T = await operation();\n        let context: RetryContext<T> = {\n            attempt,\n            totalElapsedMs: Date.now() - startTime,\n            lastResult: result,\n        };\n\n        while (await policy.shouldRetry(result, context)) {\n            const delay = await policy.calculateDelay(result, context);\n            await this.delay(delay);\n\n            // Call prepareRetry hook if policy implements it\n            if (policy.prepareRetry) {\n                await policy.prepareRetry(result, context);\n            }\n\n            attempt++;\n            result = await operation();\n            context = {\n                attempt,\n                totalElapsedMs: Date.now() - startTime,\n                lastResult: result,\n            };\n        }\n\n        return result;\n    }\n\n    private delay(ms: number): Promise<void> {\n        return new Promise((resolve) => {\n            setTimeout(resolve, ms);\n        });\n    }\n}\n","import type { RetryContext } from './retry-service';\n\nexport abstract class RetryPolicy<T> {\n    abstract shouldRetry(result: T, context: RetryContext<T>): Promise<boolean>;\n    abstract calculateDelay(result: T, context: RetryContext<T>): Promise<number>;\n\n    /**\n     * Optional hook called before each retry attempt.\n     * Allows policies to perform async preparation work before retrying.\n     *\n     * @param result - The result that triggered the retry\n     * @param context - Current retry context including attempt number and elapsed time\n     */\n    prepareRetry?(result: T, context: RetryContext<T>): Promise<void>;\n}\n","import { RetryPolicy } from './retry-policy';\nimport type { RetryContext } from './retry-service';\n\n/**\n * Composes multiple retry policies into a single policy.\n *\n * This allows combining different retry strategies (e.g., throttling + CSRF)\n * into one policy that can be used with the RetryService.\n *\n * ## Behavior\n *\n * - **shouldRetry**: Returns true if ANY policy wants to retry (OR logic)\n * - **calculateDelay**: Uses delay from the FIRST policy that wants to retry (order matters!)\n * - **prepareRetry**: Calls prepareRetry ONLY on policies that matched shouldRetry (runs in parallel)\n *\n * ## Important Notes\n *\n * **Policy Order Matters**: The order of policies in the array determines which delay is used\n * when multiple policies want to retry. Place more specific or higher-priority policies first.\n *\n * **prepareRetry Efficiency**: Only policies that matched shouldRetry will have their\n * prepareRetry called. This avoids unnecessary work and side effects for unrelated retry\n * conditions. If multiple policies match, their prepareRetry hooks run in parallel.\n *\n * **Avoid Overlapping Conditions**: If multiple policies have overlapping retry conditions\n * (e.g., both retry on 500 errors), the first policy's delay will always be used. Design\n * policies with distinct, non-overlapping conditions when possible.\n *\n * @example\n * ```typescript\n * const throttling = new FetchThrottlingRetryPolicy();\n * const csrf = new CsrfTokenRetryPolicy();\n * const composed = new ComposedRetryPolicy([throttling, csrf]);\n *\n * const retryService = new RetryService(composed);\n * ```\n */\nexport class ComposedRetryPolicy<T> extends RetryPolicy<T> {\n    constructor(private readonly policies: RetryPolicy<T>[]) {\n        super();\n    }\n\n    /**\n     * Returns true if any of the composed policies want to retry.\n     *\n     * Uses OR logic: if ANY policy returns true, this returns true.\n     * Policies are checked in order and evaluation short-circuits on the first match.\n     */\n    async shouldRetry(result: T, context: RetryContext<T>): Promise<boolean> {\n        for (const policy of this.policies) {\n            if (await policy.shouldRetry(result, context)) {\n                return true;\n            }\n        }\n        return false;\n    }\n\n    /**\n     * Returns the delay from the first policy that wants to retry.\n     *\n     * If multiple policies want to retry, only the FIRST policy's delay is used.\n     * Policy order in the constructor array determines priority.\n     * If no policy wants to retry, returns 0.\n     *\n     * @example\n     * ```typescript\n     * // If both PolicyA (1000ms) and PolicyB (5000ms) want to retry:\n     * const composed = new ComposedRetryPolicy([policyA, policyB]);\n     * composed.calculateDelay(result, context); // Returns 1000ms (PolicyA wins)\n     * ```\n     */\n    async calculateDelay(result: T, context: RetryContext<T>): Promise<number> {\n        for (const policy of this.policies) {\n            if (await policy.shouldRetry(result, context)) {\n                return policy.calculateDelay(result, context);\n            }\n        }\n        return 0;\n    }\n\n    /**\n     * Calls prepareRetry on policies that both:\n     * 1. Implement the prepareRetry hook, AND\n     * 2. Returned true from shouldRetry for this result\n     *\n     * This allows only the matching policies to perform preparation work (e.g., token refresh).\n     * All matching prepareRetry calls run in parallel for efficiency.\n     *\n     * **Important**: prepareRetry only runs on policies that matched shouldRetry. This ensures\n     * you don't perform unnecessary work or side effects for unrelated retry conditions.\n     *\n     * **Note**: If multiple policies match and have prepareRetry, ensure they don't have\n     * conflicting side effects since they run in parallel.\n     *\n     * @example\n     * ```typescript\n     * // Status 401 occurs\n     * const composed = new ComposedRetryPolicy([\n     *   authPolicy,      // shouldRetry(401) → true, has prepareRetry\n     *   throttlePolicy,  // shouldRetry(401) → false, has prepareRetry\n     * ]);\n     *\n     * await composed.prepareRetry(result, context);\n     * // → Only authPolicy.prepareRetry() runs (because it matched)\n     * // → throttlePolicy.prepareRetry() does NOT run (didn't match)\n     * ```\n     */\n    async prepareRetry(result: T, context: RetryContext<T>): Promise<void> {\n        // Filter policies that have prepareRetry and match shouldRetry\n        const matchingPolicies: RetryPolicy<T>[] = [];\n\n        for (const policy of this.policies) {\n            if (policy.prepareRetry !== undefined && (await policy.shouldRetry(result, context))) {\n                matchingPolicies.push(policy);\n            }\n        }\n\n        // Call prepareRetry on all matching policies in parallel\n        if (matchingPolicies.length > 0) {\n            await Promise.all(\n                matchingPolicies.map((policy) => policy.prepareRetry!(result, context))\n            );\n        }\n    }\n\n    /**\n     * Returns all composed policies.\n     * Useful for accessing or configuring individual policies after composition.\n     */\n    getPolicies(): RetryPolicy<T>[] {\n        return this.policies;\n    }\n\n    /**\n     * Helper to get a specific policy by type.\n     * Useful for calling policy-specific methods after composition.\n     *\n     * @example\n     * ```typescript\n     * const csrfPolicy = composedPolicy.getPolicyByType(CsrfTokenRetryPolicy);\n     * csrfPolicy?.setRequestContext(mutableRequest);\n     * ```\n     */\n    getPolicyByType<P extends RetryPolicy<T>>(\n        policyType: new (...args: any[]) => P\n    ): P | undefined {\n        return this.policies.find((policy) => policy instanceof policyType) as P | undefined;\n    }\n}\n","import { RetryService } from './retry-service';\nimport type { RetryPolicy } from './retry-policy';\nimport type { NamedService, ServiceDescriptor } from '@conduit-client/utils';\n\nexport type NamedRetryService = NamedService<'retry', RetryService<any>>;\nexport { RetryService, type RetryContext } from './retry-service';\nexport { RetryPolicy } from './retry-policy';\nexport { ComposedRetryPolicy } from './composed-retry-policy';\nexport type RetryServiceDescriptor = ServiceDescriptor<RetryService<any>, 'retry', '1.0'>;\n\nexport function buildServiceDescriptor<T>(\n    defaultRetryPolicy: RetryPolicy<T>\n): RetryServiceDescriptor {\n    return {\n        version: '1.0' as const,\n        service: new RetryService<T>(defaultRetryPolicy),\n        type: 'retry',\n    };\n}\n"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@conduit-client/service-retry",
-    "version": "3.0.0",
+    "version": "3.3.0",
     "private": false,
     "description": "Luvio Retry Service definition",
     "type": "module",
@@ -31,7 +31,7 @@
         "watch": "npm run build --watch"
     },
     "dependencies": {
-        "@conduit-client/utils": "3.0.0"
+        "@conduit-client/utils": "3.3.0"
     },
     "volta": {
         "extends": "../../../../package.json"
@@ -39,7 +39,7 @@
     "size-limit": [
         {
             "path": "./dist/v1/index.js",
-            "limit": "900 B"
+            "limit": "1.4 kB"
         }
     ]
 }