viem 0.0.1-alpha.25 → 0.0.1-alpha.26

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

@@ -1,97 +0,0 @@
-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

@@ -1,73 +0,0 @@
-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

@@ -1,231 +0,0 @@
-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

@@ -1,61 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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)
-      }
-    })()
-  })
-}