Improve the retry.fetch default behavior and option structure

Author: ericallam

packages/core/src/v3/schemas/fetch.ts

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { RetryOptions } from "./messages";
 import { EventFilter } from "./eventFilter";
+import { Prettify } from "../types";
 
 export const FetchRetryHeadersStrategy = z.object({
   /** The `headers` strategy retries the request using info from the response headers. */
@@ -45,14 +46,14 @@ export const FetchRetryStrategy = z.discriminatedUnion("strategy", [
 
 export type FetchRetryStrategy = z.infer<typeof FetchRetryStrategy>;
 
-export const FetchRetryOptions = z.record(FetchRetryStrategy);
+export const FetchRetryByStatusOptions = z.record(z.string(), FetchRetryStrategy);
 
 /** An object where the key is a status code pattern and the value is a retrying strategy. Supported patterns are:
   - Specific status codes: 429
   - Ranges: 500-599
   - Wildcards: 2xx, 3xx, 4xx, 5xx 
   */
-export type FetchRetryOptions = z.infer<typeof FetchRetryOptions>;
+export type FetchRetryByStatusOptions = Prettify<z.infer<typeof FetchRetryByStatusOptions>>;
 
 export const FetchTimeoutOptions = z.object({
   /** The maximum time to wait for the request to complete. */
@@ -61,3 +62,16 @@ export const FetchTimeoutOptions = z.object({
 });
 
 export type FetchTimeoutOptions = z.infer<typeof FetchTimeoutOptions>;
+
+export const FetchRetryOptions = z.object({
+  /** The retrying strategy for specific status codes. */
+  byStatus: FetchRetryByStatusOptions.optional(),
+  /** The timeout options for the request. */
+  timeout: RetryOptions.optional(),
+  /**
+   * The retrying strategy for connection errors.
+   */
+  connectionError: RetryOptions.optional(),
+});
+
+export type FetchRetryOptions = Prettify<z.infer<typeof FetchRetryOptions>>;

packages/core/src/v3/utils/flattenAttributes.ts

@@ -32,9 +32,9 @@ export function flattenAttributes(
       for (let i = 0; i < value.length; i++) {
         if (typeof value[i] === "object" && value[i] !== null) {
           // update null check here as well
-          Object.assign(result, flattenAttributes(value[i], `${newPrefix}.${i}`));
+          Object.assign(result, flattenAttributes(value[i], `${newPrefix}.[${i}]`));
         } else {
-          result[`${newPrefix}.${i}`] = value[i];
+          result[`${newPrefix}.[${i}]`] = value[i];
         }
       }
     } else if (isRecord(value)) {
@@ -55,46 +55,54 @@ function isRecord(value: unknown): value is Record<string, unknown> {
 }
 
 export function unflattenAttributes(obj: Attributes): Record<string, unknown> {
-  if (
-    obj === null ||
-    obj === undefined ||
-    typeof obj === "string" ||
-    typeof obj === "number" ||
-    typeof obj === "boolean" ||
-    Array.isArray(obj)
-  ) {
+  if (typeof obj !== "object" || obj === null || Array.isArray(obj)) {
     return obj;
   }
 
   const result: Record<string, unknown> = {};
 
   for (const [key, value] of Object.entries(obj)) {
-    const parts = key.split(".");
-    let current = result;
+    const parts = key.split(".").reduce((acc, part) => {
+      // Splitting array indices as separate parts
+      if (detectIsArrayIndex(part)) {
+        acc.push(part);
+      } else {
+        acc.push(...part.split(/\.\[(.*?)\]/).filter(Boolean));
+      }
+      return acc;
+    }, [] as string[]);
+
+    let current: Record<string, unknown> = result;
     for (let i = 0; i < parts.length - 1; i++) {
       const part = parts[i];
-
-      // Check if part is not undefined and it's a string.
-      if (typeof part === "string") {
-        const nextPart = parts[i + 1];
-        const isArray = nextPart ? parseInt(nextPart, 10).toString() === nextPart : false;
-        if (current[part] == null) {
-          current[part] = isArray ? [] : {};
-        }
-
-        current = current[part] as Record<string, unknown>;
+      const isArray = detectIsArrayIndex(part);
+      const cleanPart = isArray ? part.substring(1, part.length - 1) : part;
+      const nextIsArray = detectIsArrayIndex(parts[i + 1]);
+      if (!current[cleanPart]) {
+        current[cleanPart] = nextIsArray ? [] : {};
       }
+      current = current[cleanPart] as Record<string, unknown>;
     }
-    // For the last element, we must ensure we also check if it is not undefined and it's a string.
     const lastPart = parts[parts.length - 1];
-    if (typeof lastPart === "string") {
-      current[lastPart] = value;
-    }
+    const cleanLastPart = detectIsArrayIndex(lastPart)
+      ? parseInt(lastPart.substring(1, lastPart.length - 1), 10)
+      : lastPart;
+    current[cleanLastPart] = value;
   }
 
   return result;
 }
 
+function detectIsArrayIndex(key: string): boolean {
+  const match = key.match(/^\[(\d+)\]$/);
+
+  if (match) {
+    return true;
+  }
+
+  return false;
+}
+
 export function primitiveValueOrflattenedAttributes(
   obj: Record<string, unknown> | Array<unknown> | string | boolean | number | undefined,
   prefix: string | undefined

packages/core/src/v3/utils/retries.ts

@@ -1,5 +1,5 @@
-import { type RetryOptions } from "../schemas";
 import { calculateResetAt as calculateResetAtInternal } from "../../retry";
+import { FetchRetryOptions, type RetryOptions } from "../schemas";
 
 export const defaultRetryOptions = {
   maxAttempts: 3,
@@ -9,6 +9,17 @@ export const defaultRetryOptions = {
   randomize: true,
 } satisfies RetryOptions;
 
+export const defaultFetchRetryOptions = {
+  byStatus: {
+    "429,408,409,5xx": {
+      strategy: "backoff",
+      ...defaultRetryOptions,
+    },
+  },
+  connectionError: defaultRetryOptions,
+  timeout: defaultRetryOptions,
+} satisfies FetchRetryOptions;
+
 /**
  *
  * @param options

packages/core/test/flattenAttributes.test.ts

@@ -0,0 +1,186 @@
+import { flattenAttributes, unflattenAttributes } from "../src/v3/utils/flattenAttributes";
+
+describe("flattenAttributes", () => {
+  it("handles null and undefined gracefully", () => {
+    expect(flattenAttributes(null)).toEqual({});
+    expect(flattenAttributes(undefined)).toEqual({});
+  });
+
+  it("flattens string attributes correctly", () => {
+    const result = flattenAttributes("testString");
+    expect(result).toEqual({ "": "testString" });
+  });
+
+  it("flattens number attributes correctly", () => {
+    const result = flattenAttributes(12345);
+    expect(result).toEqual({ "": 12345 });
+  });
+
+  it("flattens boolean attributes correctly", () => {
+    const result = flattenAttributes(true);
+    expect(result).toEqual({ "": true });
+  });
+
+  it("flattens complex objects correctly", () => {
+    const obj = {
+      level1: {
+        level2: {
+          value: "test",
+        },
+        array: [1, 2, 3],
+      },
+    };
+    const expected = {
+      "level1.level2.value": "test",
+      "level1.array.[0]": 1,
+      "level1.array.[1]": 2,
+      "level1.array.[2]": 3,
+    };
+    expect(flattenAttributes(obj)).toEqual(expected);
+  });
+
+  it("applies prefixes correctly", () => {
+    const obj = { key: "value" };
+    const expected = { "prefix.key": "value" };
+    expect(flattenAttributes(obj, "prefix")).toEqual(expected);
+  });
+
+  it("handles arrays of objects correctly", () => {
+    const obj = {
+      array: [{ key: "value" }, { key: "value" }, { key: "value" }],
+    };
+    const expected = {
+      "array.[0].key": "value",
+      "array.[1].key": "value",
+      "array.[2].key": "value",
+    };
+    expect(flattenAttributes(obj)).toEqual(expected);
+  });
+
+  it("handles arrays of objects correctly with prefixing correctly", () => {
+    const obj = {
+      array: [{ key: "value" }, { key: "value" }, { key: "value" }],
+    };
+    const expected = {
+      "prefix.array.[0].key": "value",
+      "prefix.array.[1].key": "value",
+      "prefix.array.[2].key": "value",
+    };
+    expect(flattenAttributes(obj, "prefix")).toEqual(expected);
+  });
+
+  it("handles objects of objects correctly", () => {
+    const obj = {
+      level1: {
+        level2: {
+          key: "value",
+        },
+      },
+    };
+    const expected = { "level1.level2.key": "value" };
+    expect(flattenAttributes(obj)).toEqual(expected);
+  });
+
+  it("handles objects of objects correctly with prefixing", () => {
+    const obj = {
+      level1: {
+        level2: {
+          key: "value",
+        },
+      },
+    };
+    const expected = { "prefix.level1.level2.key": "value" };
+    expect(flattenAttributes(obj, "prefix")).toEqual(expected);
+  });
+
+  it("handles retry.byStatus correctly", () => {
+    const obj = {
+      "500": {
+        strategy: "backoff",
+        maxAttempts: 2,
+        factor: 2,
+        minTimeoutInMs: 1_000,
+        maxTimeoutInMs: 30_000,
+        randomize: false,
+      },
+    };
+
+    const expected = {
+      "retry.byStatus.500.strategy": "backoff",
+      "retry.byStatus.500.maxAttempts": 2,
+      "retry.byStatus.500.factor": 2,
+      "retry.byStatus.500.minTimeoutInMs": 1_000,
+      "retry.byStatus.500.maxTimeoutInMs": 30_000,
+      "retry.byStatus.500.randomize": false,
+    };
+
+    expect(flattenAttributes(obj, "retry.byStatus")).toEqual(expected);
+  });
+});
+
+describe("unflattenAttributes", () => {
+  it("returns the original object for primitive types", () => {
+    // @ts-expect-error
+    expect(unflattenAttributes("testString")).toEqual("testString");
+    // @ts-expect-error
+    expect(unflattenAttributes(12345)).toEqual(12345);
+    // @ts-expect-error
+    expect(unflattenAttributes(true)).toEqual(true);
+  });
+
+  it("correctly reconstructs an object from flattened attributes", () => {
+    const flattened = {
+      "level1.level2.value": "test",
+      "level1.array.[0]": 1,
+      "level1.array.[1]": 2,
+      "level1.array.[2]": 3,
+    };
+    const expected = {
+      level1: {
+        level2: {
+          value: "test",
+        },
+        array: [1, 2, 3],
+      },
+    };
+    expect(unflattenAttributes(flattened)).toEqual(expected);
+  });
+
+  it("handles complex nested objects with mixed types", () => {
+    const flattened = {
+      "user.details.name": "John Doe",
+      "user.details.age": 30,
+      "user.preferences.colors.[0]": "blue",
+      "user.preferences.colors.[1]": "green",
+      "user.active": true,
+    };
+    const expected = {
+      user: {
+        details: {
+          name: "John Doe",
+          age: 30,
+        },
+        preferences: {
+          colors: ["blue", "green"],
+        },
+        active: true,
+      },
+    };
+    expect(unflattenAttributes(flattened)).toEqual(expected);
+  });
+
+  it("correctly identifies arrays vs objects", () => {
+    const flattened = {
+      "array.[0]": 1,
+      "array.[1]": 2,
+      "object.key": "value",
+    };
+    const expected = {
+      array: [1, 2],
+      object: {
+        key: "value",
+      },
+    };
+    expect(unflattenAttributes(flattened)).toEqual(expected);
+  });
+});