tapimo 0.0.0 → 0.0.2

package/src/internal/Store.test.ts

@@ -0,0 +1,545 @@
+import { Store } from 'cadent'
+
+describe('from', () => {
+  const ops = {
+    async delete() {},
+    async get() {
+      return null
+    },
+    async list() {
+      return { keys: [] }
+    },
+    async put() {},
+  }
+
+  test('defaults to a state store when type is omitted', () => {
+    expect(Store.from(ops).type).toMatchInlineSnapshot(`"state"`)
+  })
+
+  test('opts into a cache store with type: cache', () => {
+    expect(Store.from({ ...ops, type: 'cache' }).type).toMatchInlineSnapshot(`"cache"`)
+  })
+})
+
+describe('increment', () => {
+  test('falls back to a get + put read-modify-write without a native counter', async () => {
+    const cells = new Map<string, string>()
+    const store = Store.from({
+      async delete(key) {
+        cells.delete(key)
+      },
+      async get(key) {
+        return cells.get(key) ?? null
+      },
+      async list() {
+        return { keys: [] }
+      },
+      async put(key, value) {
+        cells.set(key, value)
+      },
+    })
+
+    expect(await Store.increment(store, 'counter')).toMatchInlineSnapshot(`1`)
+    expect(await Store.increment(store, 'counter')).toMatchInlineSnapshot(`2`)
+    expect(cells.get('counter')).toMatchInlineSnapshot(`"2"`)
+  })
+
+  test('prefers the store-native counter when implemented', async () => {
+    const calls: { key: string; options: Store.Store.PutOptions | undefined }[] = []
+    const store = Store.from({
+      ...Store.memory(),
+      async increment(key, options) {
+        calls.push({ key, options })
+        return 7
+      },
+    })
+
+    expect(await Store.increment(store, 'counter', { ttl: 30_000 })).toMatchInlineSnapshot(`7`)
+    expect(calls).toMatchInlineSnapshot(`
+      [
+        {
+          "key": "counter",
+          "options": {
+            "ttl": 30000,
+          },
+        },
+      ]
+    `)
+  })
+})
+
+describe('memory', () => {
+  test('treats expired entries as absent', async () => {
+    const store = Store.memory()
+
+    await store.put('short', 'soon-gone', { ttl: 10 })
+    await store.put('long', 'sticks-around', { ttl: 60_000 })
+    await new Promise((resolve) => setTimeout(resolve, 25))
+
+    expect(await store.get('short')).toMatchInlineSnapshot(`null`)
+    expect(await store.list()).toMatchInlineSnapshot(`
+      {
+        "keys": [
+          {
+            "name": "long",
+          },
+        ],
+      }
+    `)
+    expect(await store.get('long')).toMatchInlineSnapshot(`"sticks-around"`)
+  })
+
+  test('reads, writes, deletes, and lists string values', async () => {
+    const store = Store.memory({
+      entries: [
+        ['other:1', 'ignored'],
+        ['secret:1', 'alpha'],
+      ],
+    })
+
+    await store.put('secret:2', 'beta')
+    await store.delete('other:1')
+
+    expect(await store.get('other:1')).toMatchInlineSnapshot(`null`)
+    expect(await store.list({ prefix: 'secret:' })).toMatchInlineSnapshot(`
+      {
+        "keys": [
+          {
+            "name": "secret:1",
+          },
+          {
+            "name": "secret:2",
+          },
+        ],
+      }
+    `)
+    expect(await store.get('missing')).toMatchInlineSnapshot(`null`)
+    expect(await store.get('secret:1')).toMatchInlineSnapshot(`"alpha"`)
+  })
+
+  test('increments counters and restarts expired ones at 1', async () => {
+    const store = Store.memory()
+
+    expect(await Store.increment(store, 'counter', { ttl: 10 })).toMatchInlineSnapshot(`1`)
+    expect(await Store.increment(store, 'counter', { ttl: 10 })).toMatchInlineSnapshot(`2`)
+    await new Promise((resolve) => setTimeout(resolve, 25))
+
+    expect(await Store.increment(store, 'counter', { ttl: 10 })).toMatchInlineSnapshot(`1`)
+  })
+})
+
+describe('cloudflareKv', () => {
+  test('adapts a Cloudflare Workers KV namespace', async () => {
+    const cells = new Map<string, string>([
+      ['other:1', 'ignored'],
+      ['secret:1', 'alpha'],
+    ])
+    const writes: unknown[] = []
+    const namespace = {
+      async delete(key) {
+        cells.delete(key)
+      },
+      async get(key) {
+        return cells.get(key) ?? null
+      },
+      async list(options = {}) {
+        return {
+          keys: Array.from(cells.keys())
+            .filter((key) => !options.prefix || key.startsWith(options.prefix))
+            .sort()
+            .map((name) => ({ name })),
+        }
+      },
+      async put(key, value, options) {
+        writes.push({ key, options, value })
+        cells.set(key, value)
+      },
+    } satisfies Store.cloudflareKv.Namespace
+    const store = Store.cloudflareKv(namespace)
+
+    await store.put('secret:2', 'beta', { ttl: 60_500 })
+    await store.delete('other:1')
+
+    expect(writes).toMatchInlineSnapshot(`
+      [
+        {
+          "key": "secret:2",
+          "options": {
+            "expirationTtl": 61,
+          },
+          "value": "beta",
+        },
+      ]
+    `)
+    expect(await store.get('other:1')).toMatchInlineSnapshot(`null`)
+    expect(await store.list({ prefix: 'secret:' })).toMatchInlineSnapshot(`
+      {
+        "keys": [
+          {
+            "name": "secret:1",
+          },
+          {
+            "name": "secret:2",
+          },
+        ],
+      }
+    `)
+    await expect(
+      store.put('short', 'nope', { ttl: 10 }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      `[RangeError: Cloudflare KV expirationTtl must be at least 60 seconds]`,
+    )
+  })
+})
+
+describe('durableObject', () => {
+  test('adapts a Durable Object namespace without caching stubs', async () => {
+    const calls: string[] = []
+    const backing = Store.memory({
+      entries: [['secret:1', 'alpha']],
+    })
+    const namespace = {
+      getByName(name) {
+        calls.push(name)
+        // The stub contract requires a native `increment` (our DO class
+        // implements it); derive one for the in-memory fake.
+        return {
+          ...backing,
+          increment: (key, options) => Store.increment(backing, key, options),
+        }
+      },
+    } satisfies Store.durableObject.Namespace
+    const store = Store.durableObject(namespace, { name: 'tempo-api' })
+
+    await store.put('secret:2', 'beta')
+    expect(await store.get('secret:1')).toMatchInlineSnapshot(`"alpha"`)
+    expect(await store.list({ prefix: 'secret:' })).toMatchInlineSnapshot(`
+      {
+        "keys": [
+          {
+            "name": "secret:1",
+          },
+          {
+            "name": "secret:2",
+          },
+        ],
+      }
+    `)
+    await store.delete('secret:1')
+
+    expect(calls).toMatchInlineSnapshot(`
+      [
+        "tempo-api",
+        "tempo-api",
+        "tempo-api",
+        "tempo-api",
+      ]
+    `)
+  })
+
+  test('shards keys across objects with a name resolver', async () => {
+    const calls: { method: string; name: string }[] = []
+    const objects = new Map<string, Store.State>()
+    const namespace = {
+      getByName(name) {
+        const backing = objects.get(name) ?? Store.memory()
+        objects.set(name, backing)
+        const stub = {
+          delete: (key) => backing.delete(key),
+          get: (key) => backing.get(key),
+          increment: (key, options) => Store.increment(backing, key, options),
+          list: (options) => backing.list(options),
+          put: (key, value, options) => backing.put(key, value, options),
+        } satisfies Store.durableObject.Stub
+        return new Proxy(stub, {
+          get(target, method: string) {
+            calls.push({ method, name })
+            return target[method as keyof Store.durableObject.Stub]
+          },
+        })
+      },
+    } satisfies Store.durableObject.Namespace
+    const store = Store.durableObject(namespace, { name: (key) => `tempo-api:${key}` })
+
+    expect(await Store.increment(store, 'ratelimit:a')).toMatchInlineSnapshot(`1`)
+    expect(await Store.increment(store, 'ratelimit:a')).toMatchInlineSnapshot(`2`)
+    expect(await Store.increment(store, 'ratelimit:b')).toMatchInlineSnapshot(`1`)
+
+    expect(calls).toMatchInlineSnapshot(`
+      [
+        {
+          "method": "increment",
+          "name": "tempo-api:ratelimit:a",
+        },
+        {
+          "method": "increment",
+          "name": "tempo-api:ratelimit:a",
+        },
+        {
+          "method": "increment",
+          "name": "tempo-api:ratelimit:b",
+        },
+      ]
+    `)
+    await expect(store.list()).rejects.toThrowErrorMatchingInlineSnapshot(
+      `[TypeError: cannot list a sharded Durable Object store]`,
+    )
+  })
+
+  test('retries a retryable stub error once on a fresh stub', async () => {
+    let stubs = 0
+    let failures = 1
+    const backing = Store.memory()
+    const namespace = {
+      getByName() {
+        stubs += 1
+        return {
+          ...backing,
+          increment: (key, options) => {
+            if (failures > 0) {
+              failures -= 1
+              throw Object.assign(new Error('Network connection lost.'), { retryable: true })
+            }
+            return Store.increment(backing, key, options)
+          },
+        }
+      },
+    } satisfies Store.durableObject.Namespace
+    const store = Store.durableObject(namespace, { name: 'tempo-api' })
+
+    expect(await Store.increment(store, 'counter')).toMatchInlineSnapshot(`1`)
+    // One stub per attempt: a stub that threw is disconnected.
+    expect(stubs).toMatchInlineSnapshot(`2`)
+  })
+
+  test('propagates a retryable stub error when the retry also fails', async () => {
+    let attempts = 0
+    const namespace = {
+      getByName() {
+        return {
+          ...Store.memory(),
+          increment: () => {
+            attempts += 1
+            throw Object.assign(new Error('Network connection lost.'), { retryable: true })
+          },
+        }
+      },
+    } satisfies Store.durableObject.Namespace
+    const store = Store.durableObject(namespace, { name: 'tempo-api' })
+
+    await expect(Store.increment(store, 'counter')).rejects.toThrowErrorMatchingInlineSnapshot(
+      `[Error: Network connection lost.]`,
+    )
+    expect(attempts).toMatchInlineSnapshot(`2`)
+  })
+
+  test('does not retry non-retryable or overloaded stub errors', async () => {
+    let attempts = 0
+    const namespaceFor = (error: Error) =>
+      ({
+        getByName() {
+          return {
+            ...Store.memory(),
+            increment: () => {
+              attempts += 1
+              throw error
+            },
+          }
+        },
+      }) satisfies Store.durableObject.Namespace
+
+    const plain = Store.durableObject(namespaceFor(new Error('boom')), { name: 'tempo-api' })
+    await expect(Store.increment(plain, 'counter')).rejects.toThrowErrorMatchingInlineSnapshot(
+      `[Error: boom]`,
+    )
+    expect(attempts).toMatchInlineSnapshot(`1`)
+
+    attempts = 0
+    const overloaded = Store.durableObject(
+      namespaceFor(
+        Object.assign(new Error('Durable Object is overloaded.'), {
+          overloaded: true,
+          retryable: true,
+        }),
+      ),
+      { name: 'tempo-api' },
+    )
+    await expect(Store.increment(overloaded, 'counter')).rejects.toThrowErrorMatchingInlineSnapshot(
+      `[Error: Durable Object is overloaded.]`,
+    )
+    expect(attempts).toMatchInlineSnapshot(`1`)
+  })
+
+  test('defers missing namespace failures until an operation is attempted', async () => {
+    const store = Store.durableObject(undefined as unknown as Store.durableObject.Namespace, {
+      name: 'tempo-api',
+    })
+
+    expect(store.type).toMatchInlineSnapshot(`"state"`)
+    await expect(store.get('key')).rejects.toThrowErrorMatchingInlineSnapshot(
+      `[TypeError: Cannot read properties of undefined (reading 'get')]`,
+    )
+  })
+
+  test('adapts Durable Object storage and lazily removes expired entries', async () => {
+    const storage = durableObjectStorage()
+    const store = Store.durableObject(storage)
+
+    await store.put('secret:1', 'alpha', { ttl: 10 })
+    await store.put('secret:2', 'beta', { ttl: 60_000 })
+    await store.put('other:1', 'ignored')
+    await new Promise((resolve) => setTimeout(resolve, 25))
+
+    expect(await store.get('secret:1')).toMatchInlineSnapshot(`null`)
+    expect(await store.get('secret:2')).toMatchInlineSnapshot(`"beta"`)
+    expect(await store.list({ prefix: 'secret:' })).toMatchInlineSnapshot(`
+      {
+        "keys": [
+          {
+            "name": "secret:2",
+          },
+        ],
+      }
+    `)
+    expect(storage.cells.has('secret:1')).toMatchInlineSnapshot(`false`)
+  })
+})
+
+describe('memoize', () => {
+  test('coalesces concurrent cache misses for the same key', async () => {
+    const store = Store.memory()
+    const pending = deferred<void>()
+    let calls = 0
+
+    const requests = [1, 2, 3].map(() =>
+      Store.memoize(
+        async () => {
+          calls += 1
+          await pending.promise
+          return { value: 'fresh' }
+        },
+        { key: 'memo:test', store, ttl: 60_000 },
+      ),
+    )
+
+    await Promise.resolve()
+    pending.resolve()
+
+    const values = await Promise.all(requests)
+
+    expect(calls).toMatchInlineSnapshot(`1`)
+    expect(JSON.parse((await store.get('memo:test')) ?? 'null')).toMatchInlineSnapshot(`
+      {
+        "value": "fresh",
+      }
+    `)
+    expect(values).toMatchInlineSnapshot(`
+      [
+        {
+          "value": "fresh",
+        },
+        {
+          "value": "fresh",
+        },
+        {
+          "value": "fresh",
+        },
+      ]
+    `)
+  })
+
+  test('returns cached JSON values until the entry expires', async () => {
+    const store = Store.memory()
+    let calls = 0
+
+    const first = await Store.memoize(async () => ({ value: ++calls }), {
+      key: 'memo:test',
+      store,
+      ttl: 10,
+    })
+    const second = await Store.memoize(async () => ({ value: ++calls }), {
+      key: 'memo:test',
+      store,
+      ttl: 10,
+    })
+
+    await new Promise((resolve) => setTimeout(resolve, 25))
+
+    const third = await Store.memoize(async () => ({ value: ++calls }), {
+      key: 'memo:test',
+      store,
+      ttl: 10,
+    })
+
+    expect(calls).toMatchInlineSnapshot(`2`)
+    expect(first).toMatchInlineSnapshot(`
+      {
+        "value": 1,
+      }
+    `)
+    expect(second).toMatchInlineSnapshot(`
+      {
+        "value": 1,
+      }
+    `)
+    expect(third).toMatchInlineSnapshot(`
+      {
+        "value": 2,
+      }
+    `)
+  })
+
+  test('refreshes corrupt cache entries', async () => {
+    const store = Store.memory({ entries: [['memo:test', 'not-json']] })
+
+    const value = await Store.memoize(async () => ({ value: 'fresh' }), {
+      key: 'memo:test',
+      store,
+      ttl: 60_000,
+    })
+
+    expect(value).toMatchInlineSnapshot(`
+      {
+        "value": "fresh",
+      }
+    `)
+    expect(JSON.parse((await store.get('memo:test')) ?? 'null')).toMatchInlineSnapshot(`
+      {
+        "value": "fresh",
+      }
+    `)
+  })
+})
+
+function deferred<value>() {
+  let reject!: (cause?: unknown) => void
+  let resolve!: (value: PromiseLike<value> | value) => void
+  const promise = new Promise<value>((resolve_, reject_) => {
+    reject = reject_
+    resolve = resolve_
+  })
+  return { promise, reject, resolve }
+}
+
+function durableObjectStorage(): Store.durableObject.Storage & { cells: Map<string, unknown> } {
+  const cells = new Map<string, unknown>()
+
+  return {
+    cells,
+    async delete(key) {
+      return cells.delete(key)
+    },
+    async get<value = unknown>(key: string) {
+      return cells.get(key) as undefined | value
+    },
+    async list<value = unknown>(options: { prefix?: string | undefined } = {}) {
+      const entries = Array.from(cells.entries()).filter(
+        ([key]) => !options.prefix || key.startsWith(options.prefix),
+      )
+      return new Map(entries) as Map<string, value>
+    },
+    async put(key, value) {
+      cells.set(key, value)
+    },
+  }
+}