viem 0.0.1-cjs.10 → 0.0.1-sushi.26

package/src/utils/promise/withCache.test.ts

@@ -0,0 +1,97 @@
+import { beforeEach, describe, expect, test, vi } from 'vitest'
+
+import { wait } from '../wait'
+
+import { getCache, withCache } from './withCache'
+
+beforeEach(() => getCache('foo').clear())
+
+test('caches responses', async () => {
+  const fn = vi.fn().mockResolvedValue('bar')
+
+  let data = await withCache(fn, { cacheKey: 'foo' })
+  expect(data).toBe('bar')
+
+  data = await withCache(fn, { cacheKey: 'foo' })
+  expect(data).toBe('bar')
+
+  expect(fn).toBeCalledTimes(1)
+})
+
+describe('args: maxAge', () => {
+  test('invalidates when maxAge = 0', async () => {
+    const fn = vi.fn().mockResolvedValue('bar')
+
+    let data = await withCache(fn, { cacheKey: 'foo' })
+    expect(data).toBe('bar')
+    data = await withCache(fn, { cacheKey: 'foo', maxAge: 0 })
+    expect(data).toBe('bar')
+    expect(fn).toBeCalledTimes(2)
+  })
+
+  test('invalidates when expired', async () => {
+    const fn = vi.fn().mockResolvedValue('bar')
+
+    let data = await withCache(fn, { cacheKey: 'foo' })
+    expect(data).toBe('bar')
+    data = await withCache(fn, { cacheKey: 'foo' })
+    expect(data).toBe('bar')
+    expect(fn).toBeCalledTimes(1)
+
+    await wait(150)
+    data = await withCache(fn, { cacheKey: 'foo', maxAge: 100 })
+    expect(data).toBe('bar')
+    expect(fn).toBeCalledTimes(2)
+  })
+})
+
+describe('args: cacheKey', () => {
+  test('different cacheKeys', async () => {
+    const fn = vi.fn().mockResolvedValue('bar')
+
+    let data = await withCache(fn, { cacheKey: 'foo' })
+    expect(data).toBe('bar')
+    data = await withCache(fn, { cacheKey: 'baz' })
+    expect(data).toBe('bar')
+    expect(fn).toBeCalledTimes(2)
+  })
+})
+
+describe('behavior: caches promises (deduping)', () => {
+  test('basic', async () => {
+    const fn = vi.fn()
+    await Promise.all(
+      Array.from({ length: 10 }, () =>
+        withCache(async () => fn(), { cacheKey: 'foo' }),
+      ),
+    )
+    expect(fn).toBeCalledTimes(1)
+  })
+
+  test('different cacheKeys', async () => {
+    const fn = vi.fn().mockResolvedValue('bar')
+    await Promise.all([
+      ...Array.from({ length: 10 }, () =>
+        withCache(() => fn(), { cacheKey: 'foo' }),
+      ),
+      ...Array.from({ length: 10 }, () =>
+        withCache(() => fn(), { cacheKey: 'bar' }),
+      ),
+    ])
+    expect(fn).toBeCalledTimes(2)
+  })
+})
+
+test('behavior: programmatic removal', async () => {
+  const fn = vi.fn().mockResolvedValue('bar')
+
+  let data = await withCache(fn, { cacheKey: 'foo' })
+  expect(data).toBe('bar')
+
+  getCache('foo').clear()
+
+  data = await withCache(fn, { cacheKey: 'foo' })
+  expect(data).toBe('bar')
+
+  expect(fn).toBeCalledTimes(2)
+})

package/src/utils/promise/withCache.ts

@@ -0,0 +1,73 @@
+export const promiseCache = new Map()
+export const responseCache = new Map()
+
+export function getCache<TData>(cacheKey: string) {
+  const buildCache = <TData>(cacheKey: string, cache: Map<string, TData>) => ({
+    clear: () => cache.delete(cacheKey),
+    get: () => cache.get(cacheKey),
+    set: (data: TData) => cache.set(cacheKey, data),
+  })
+
+  const promise = buildCache<Promise<TData>>(cacheKey, promiseCache)
+  const response = buildCache<{ created: Date; data: TData }>(
+    cacheKey,
+    responseCache,
+  )
+
+  return {
+    clear: () => {
+      promise.clear()
+      response.clear()
+    },
+    promise,
+    response,
+  }
+}
+
+export type WithCacheArgs = {
+  /** The key to cache the data against. */
+  cacheKey: string
+  /** The maximum age (in ms) of the cached value. Default: Infinity (no expiry) */
+  maxAge?: number
+}
+
+/**
+ * @description Returns the result of a given promise, and caches the result for
+ * subsequent invocations against a provided cache key.
+ */
+export async function withCache<TData>(
+  fn: () => Promise<TData>,
+  { cacheKey, maxAge = Infinity }: WithCacheArgs,
+) {
+  const cache = getCache<TData>(cacheKey)
+
+  // If a response exists in the cache, and it's not expired, return it
+  // and do not invoke the promise.
+  // If the max age is 0, the cache is disabled.
+  const response = cache.response.get()
+  if (response && maxAge > 0) {
+    const age = new Date().getTime() - response.created.getTime()
+    if (age < maxAge) return response.data
+  }
+
+  let promise = cache.promise.get()
+  if (!promise) {
+    promise = fn()
+
+    // Store the promise in the cache so that subsequent invocations
+    // will wait for the same promise to resolve (deduping).
+    cache.promise.set(promise)
+  }
+
+  const data = await promise
+
+  // Clear the promise cache so that subsequent invocations will
+  // invoke the promise again.
+  cache.promise.clear()
+
+  // Store the response in the cache so that subsequent invocations
+  // will return the same response.
+  cache.response.set({ created: new Date(), data })
+
+  return data
+}

package/src/utils/promise/withRetry.test.ts

@@ -0,0 +1,231 @@
+import { expect, test } from 'vitest'
+
+import { createHttpServer } from '../../_test'
+import { withRetry } from './withRetry'
+
+test('shouldRetryOnResponse: retries, and then errors', async () => {
+  let retryTimes = -1
+
+  const server = await createHttpServer((req, res) => {
+    res.writeHead(500)
+    res.end()
+  })
+
+  const res = await withRetry(
+    async () => {
+      retryTimes++
+      const response = await fetch(server.url)
+      return response
+    },
+    {
+      retryCount: 3,
+      shouldRetryOnResponse: ({ data }) => data?.status === 500,
+    },
+  )
+
+  expect(res).toBeDefined()
+  expect(retryTimes).toBe(3)
+
+  server.close()
+})
+
+test('shouldRetryOnResponse: retries, and then succeeds', async () => {
+  let retryTimes = -1
+
+  const server = await createHttpServer((req, res) => {
+    if (retryTimes === 2) {
+      res.writeHead(200)
+    } else {
+      res.writeHead(500)
+    }
+    res.end()
+  })
+
+  const res = await withRetry(
+    async () => {
+      retryTimes++
+      const response = await fetch(server.url)
+      return response
+    },
+    {
+      retryCount: 3,
+      shouldRetryOnResponse: ({ data }) => data?.status === 500,
+    },
+  )
+
+  expect(res).toBeDefined()
+  expect(retryTimes).toBe(2)
+
+  server.close()
+})
+
+test('shouldRetryOnResponse (async): retries, and then errors', async () => {
+  let retryTimes = -1
+
+  const server = await createHttpServer((req, res) => {
+    res.writeHead(200, { 'Content-Type': 'application/json' })
+    res.end(JSON.stringify({ error: 'wagmi' }))
+  })
+
+  const res = await withRetry(
+    async () => {
+      retryTimes++
+      const response = await fetch(server.url)
+      return response
+    },
+    {
+      retryCount: 3,
+      shouldRetryOnResponse: async ({ data }) => (await data.json()).error,
+    },
+  )
+
+  expect(await res.json()).toMatchInlineSnapshot(`
+    {
+      "error": "wagmi",
+    }
+  `)
+  expect(retryTimes).toBe(3)
+
+  server.close()
+})
+
+test('shouldRetryOnResponse (async): retries, and then succeeds', async () => {
+  let retryTimes = -1
+
+  const server = await createHttpServer((req, res) => {
+    res.writeHead(200, { 'Content-Type': 'application/json' })
+    if (retryTimes === 2) {
+      res.end(JSON.stringify({ message: 'wagmi' }))
+    } else {
+      res.end(JSON.stringify({ error: 'wagmi' }))
+    }
+  })
+
+  const res = await withRetry(
+    async () => {
+      retryTimes++
+      const response = await fetch(server.url)
+      return response
+    },
+    {
+      retryCount: 3,
+      shouldRetryOnResponse: async ({ data }) => (await data.json()).error,
+    },
+  )
+
+  expect(res).toBeDefined()
+  expect(retryTimes).toBe(2)
+
+  server.close()
+})
+
+test('shouldRetryOnError: retries, and then errors', async () => {
+  let retryTimes = -1
+  await expect(
+    withRetry(
+      async () => {
+        retryTimes++
+        throw new Error('test')
+      },
+      { shouldRetryOnError: ({ error }) => error.message === 'test' },
+    ),
+  ).rejects.toThrowError('test')
+  expect(retryTimes).toBe(2)
+})
+
+test('shouldRetryOnError: retries, and then succeeds', async () => {
+  let retryTimes = -1
+  const res = await withRetry(
+    async () => {
+      retryTimes++
+      if (retryTimes === 2) return 'success'
+      throw new Error('test')
+    },
+    {
+      retryCount: 3,
+      shouldRetryOnError: ({ error }) => error.message === 'test',
+    },
+  )
+  expect(res).toBe('success')
+  expect(retryTimes).toBe(2)
+})
+
+test.skip('delay: custom delay', async () => {
+  let timestamps: Date[] = []
+
+  const server = await createHttpServer((req, res) => {
+    res.writeHead(500)
+    res.end()
+  })
+
+  await withRetry(
+    async () => {
+      timestamps.push(new Date())
+      const response = await fetch(server.url)
+      return response
+    },
+    {
+      delay: 1000,
+      retryCount: 3,
+      shouldRetryOnResponse: ({ data }) => data?.status === 500,
+    },
+  )
+
+  expect(
+    Math.floor((timestamps[1].getTime() - timestamps[0].getTime()) / 1000) *
+      1000,
+  ).toBe(1000)
+  expect(
+    Math.floor((timestamps[2].getTime() - timestamps[1].getTime()) / 1000) *
+      1000,
+  ).toBe(1000)
+  expect(
+    Math.floor((timestamps[3].getTime() - timestamps[2].getTime()) / 1000) *
+      1000,
+  ).toBe(1000)
+
+  server.close()
+})
+
+test.skip('delay: custom delay fn', async () => {
+  let timestamps: Date[] = []
+
+  const server = await createHttpServer((req, res) => {
+    res.writeHead(500, {
+      'Retry-After': 1,
+    })
+    res.end()
+  })
+
+  await withRetry(
+    async () => {
+      timestamps.push(new Date())
+      const response = await fetch(server.url)
+      return response
+    },
+    {
+      delay: ({ data }) => {
+        const retryAfter = data?.headers.get('Retry-After')
+        if (retryAfter?.match(/\d/)) return parseInt(retryAfter) * 1000
+        return 100
+      },
+      retryCount: 3,
+      shouldRetryOnResponse: ({ data }) => data?.status === 500,
+    },
+  )
+
+  expect(
+    Math.floor((timestamps[1].getTime() - timestamps[0].getTime()) / 1000) *
+      1000,
+  ).toBe(1000)
+  expect(
+    Math.floor((timestamps[2].getTime() - timestamps[1].getTime()) / 1000) *
+      1000,
+  ).toBe(1000)
+  expect(
+    Math.floor((timestamps[3].getTime() - timestamps[2].getTime()) / 1000) *
+      1000,
+  ).toBe(1000)
+
+  server.close()
+})

package/src/utils/promise/withRetry.ts

@@ -0,0 +1,61 @@
+import { wait } from '../wait'
+
+export function withRetry<TData>(
+  fn: () => Promise<TData>,
+  {
+    delay: delay_ = 100,
+    retryCount = 2,
+    shouldRetryOnResponse = () => false,
+    shouldRetryOnError = () => false,
+  }: {
+    // The delay (in ms) between retries.
+    delay?: ((config: { count: number; data?: TData }) => number) | number
+    // The max number of times to retry.
+    retryCount?: number
+    // Whether or not to retry on a successful response.
+    shouldRetryOnResponse?: ({
+      count,
+      data,
+    }: {
+      count: number
+      data: TData
+    }) => Promise<boolean> | boolean
+    // Whether or not to retry when an error is thrown.
+    shouldRetryOnError?: ({
+      count,
+      error,
+    }: {
+      count: number
+      error: Error
+    }) => Promise<boolean> | boolean
+  } = {},
+) {
+  return new Promise<TData>((resolve, reject) => {
+    const attemptRetry = async ({ count = 0 } = {}) => {
+      const retry = async ({ data }: { data?: TData } = {}) => {
+        const delay =
+          typeof delay_ === 'function' ? delay_({ count, data }) : delay_
+        if (delay) await wait(delay)
+        attemptRetry({ count: count + 1 })
+      }
+
+      try {
+        const data = await fn()
+        if (
+          count < retryCount &&
+          (await shouldRetryOnResponse({ count, data }))
+        )
+          return retry({ data })
+        resolve(data)
+      } catch (err) {
+        if (
+          count < retryCount &&
+          (await shouldRetryOnError({ count, error: err as Error }))
+        )
+          return retry()
+        reject(err)
+      }
+    }
+    attemptRetry()
+  })
+}

package/src/utils/promise/withTimeout.test.ts

@@ -0,0 +1,37 @@
+import { expect, test } from 'vitest'
+
+import { createHttpServer } from '../../_test'
+import { wait } from '../wait'
+import { withTimeout } from './withTimeout'
+
+test('times out correctly', async () => {
+  await expect(() =>
+    withTimeout(
+      async () => {
+        await wait(2000)
+      },
+      { errorInstance: new Error('timed out'), timeout: 500 },
+    ),
+  ).rejects.toThrowError('timed out')
+})
+
+test('times out correctly w/ signal', async () => {
+  const server = await createHttpServer((req, res) =>
+    setTimeout(() => res.end('wagmi'), 5000),
+  )
+
+  await expect(() =>
+    withTimeout(
+      async ({ signal }) => {
+        await fetch(server.url, { signal })
+      },
+      {
+        errorInstance: new Error('timed out'),
+        timeout: 500,
+        signal: true,
+      },
+    ),
+  ).rejects.toThrowError('timed out')
+
+  server.close()
+})

package/src/utils/promise/withTimeout.ts

@@ -0,0 +1,39 @@
+export function withTimeout<TData>(
+  fn: ({ signal }: { signal?: AbortController['signal'] }) => Promise<TData>,
+  {
+    errorInstance,
+    timeout,
+    signal,
+  }: {
+    // The error instance to throw when the timeout is reached.
+    errorInstance: Error
+    // The timeout (in ms).
+    timeout: number
+    // Whether or not the timeout should use an abort signal.
+    signal?: boolean
+  },
+): Promise<TData> {
+  return new Promise((resolve, reject) => {
+    ;(async () => {
+      let timeoutId!: NodeJS.Timeout
+      try {
+        const controller = new AbortController()
+        if (timeout > 0) {
+          timeoutId = setTimeout(() => {
+            if (signal) {
+              controller.abort()
+            } else {
+              reject(errorInstance)
+            }
+          }, timeout)
+        }
+        resolve(await fn({ signal: controller?.signal }))
+      } catch (err) {
+        if ((err as Error).name === 'AbortError') reject(errorInstance)
+        reject(err)
+      } finally {
+        clearTimeout(timeoutId)
+      }
+    })()
+  })
+}