tapimo 0.0.1 → 0.0.2

package/src/apps/coingecko.ts

@@ -1048,7 +1048,7 @@ async function loadDexBalances(
               account: dexAccount,
               token: token as ViemAddress,
             })
-            balances.set(token, balance)
+            balances.set(token, balance.amount)
           } catch {
             failed = true
             balances.set(token, 0n)

package/src/apps/indexer.test.ts

@@ -117,7 +117,7 @@ describe('GET /indexer/query', () => {
           getClient: () => Tempo.client,
           recipient: Tempo.accounts[2].address,
         },
-        secretKey: 'secret_test_key',
+        secretKey: 'secret_test_key_0123456789abcdef',
       },
     })
     await exhaustQuota(RateLimit.memory({ store: rateLimitStore }), 'public:anonymous', {

package/src/apps/webhooks.test.ts

@@ -1119,7 +1119,7 @@ describe('MPP access (disabled for now — API-key-only)', () => {
           getClient: () => Tempo.client,
           recipient: Tempo.accounts[2].address,
         },
-        secretKey: 'secret_test_key',
+        secretKey: 'secret_test_key_0123456789abcdef',
       },
       webhook: { store: Store.memory() },
     })

package/src/internal/Auth.test.ts

@@ -555,6 +555,64 @@ describe('require', () => {
         }
       `)
     })
+
+    test('fails open when the public rate-limit store errors', async () => {
+      const error = vi.spyOn(console, 'error').mockImplementation(() => {})
+      try {
+        const app = createApp({
+          auth: {
+            apiKey: { source: TestApp.source({ keys: [{ ...key, token }] }) },
+            rateLimit: {
+              async consume() {
+                throw new Error('Network connection lost.')
+              },
+            },
+          },
+          policy: { public: { rateLimit: { perMinute: 1 } } },
+        })
+        const response = await app.request('/protected', {
+          headers: { 'x-forwarded-for': '203.0.113.10' },
+        })
+        const body = await response.json()
+
+        expect(response.status).toMatchInlineSnapshot(`200`)
+        expect(response.headers.has('ratelimit-limit')).toMatchInlineSnapshot(`false`)
+        expect(body).toMatchInlineSnapshot(`
+          {
+            "id": "203.0.113.10",
+            "type": "public",
+          }
+        `)
+        expect(error.mock.calls.length).toMatchInlineSnapshot(`1`)
+      } finally {
+        error.mockRestore()
+      }
+    })
+
+    test('fails open when the API-key rate-limit store errors', async () => {
+      const error = vi.spyOn(console, 'error').mockImplementation(() => {})
+      try {
+        const app = createApp({
+          auth: {
+            apiKey: { source: TestApp.source({ keys: [{ ...key, token }] }) },
+            rateLimit: {
+              async consume() {
+                throw new Error('Network connection lost.')
+              },
+            },
+          },
+        })
+        const response = await app.request('/protected', {
+          headers: { 'tempo-api-key': token },
+        })
+
+        expect(response.status).toMatchInlineSnapshot(`200`)
+        expect(response.headers.has('ratelimit-limit')).toMatchInlineSnapshot(`false`)
+        expect(error.mock.calls.length).toMatchInlineSnapshot(`1`)
+      } finally {
+        error.mockRestore()
+      }
+    })
   })
 
   describe('rateLimit per-scope', () => {
@@ -845,7 +903,7 @@ function createMppServer() {
       }),
     ],
     realm: 'tempo-api-test',
-    secretKey: 'secret_test_key',
+    secretKey: 'secret_test_key_0123456789abcdef',
   })
 }
 

package/src/internal/Auth.ts

@@ -796,7 +796,12 @@ function consumeRateLimit(
   options: RateLimit.Store.ConsumeOptions,
 ): Promise<RateLimit.Result | null> {
   if (!auth.rateLimit) return Promise.resolve(null)
-  return auth.rateLimit.consume(options)
+  // Fail open: a rate-limit store error (e.g. a lost Durable Object
+  // connection) degrades to unenforced quota instead of failing the request.
+  return auth.rateLimit.consume(options).catch((error) => {
+    console.error('[auth] rate-limit consume failed; failing open', error)
+    return null
+  })
 }
 
 /**

package/src/internal/Store.test.ts

@@ -286,6 +286,90 @@ describe('durableObject', () => {
     )
   })
 
+  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',

package/src/internal/Store.ts

@@ -430,29 +430,48 @@ function durableObjectStub(
 
   return from({
     async delete(key) {
-      await stub(key).delete(key)
+      await durableObjectRetry(() => stub(key).delete(key))
     },
     async get(key) {
-      return stub(key).get(key)
+      return durableObjectRetry(() => stub(key).get(key))
     },
     // Native RPC increment: the read-modify-write runs inside the object
     // (one round trip, atomic) instead of the get + put fallback (two).
     async increment(key, options) {
-      return stub(key).increment(key, options)
+      return durableObjectRetry(() => stub(key).increment(key, options))
     },
     async list(options) {
       // A sharded store scatters keys across objects, so no single object can
       // enumerate them.
       if (typeof name === 'function')
         throw new TypeError('cannot list a sharded Durable Object store')
-      return stub('').list(options)
+      return durableObjectRetry(() => stub('').list(options))
     },
     async put(key, value, options) {
-      await stub(key).put(key, value, options)
+      await durableObjectRetry(() => stub(key).put(key, value, options))
     },
   })
 }
 
+/**
+ * Runs a Durable Object stub call, retrying once when workerd marks the error
+ * retryable (transient transport failures, e.g. "Network connection lost.")
+ * and not overloaded. Callers pass a thunk so the retry resolves a fresh
+ * stub: a stub that threw is disconnected.
+ */
+async function durableObjectRetry<value>(call: () => Promise<value>): Promise<value> {
+  try {
+    return await call()
+  } catch (error) {
+    const { overloaded, retryable } = (error ?? {}) as {
+      overloaded?: boolean | undefined
+      retryable?: boolean | undefined
+    }
+    if (retryable !== true || overloaded === true) throw error
+    return call()
+  }
+}
+
 function cloudflareKvExpirationTtl(ttl: number | undefined) {
   if (ttl === undefined) return undefined
   if (ttl <= 0) return 0

package/src/internal/Viem.ts

@@ -130,7 +130,8 @@ export declare namespace getClient {
     Chain,
     undefined,
     undefined,
-    PublicActions<HttpTransport, Chain, undefined> & TempoActions<Chain, undefined>
+    // Omit core's ERC-20 `token` namespace; `tempoActions` shadows it at runtime.
+    Omit<PublicActions<HttpTransport, Chain, undefined>, 'token'> & TempoActions<Chain, undefined>
   >
 
   /** Options for getting a Tempo viem client. */