tapimo 0.10.2 → 0.12.0

package/src/apps/funding/routes/quotes.test.ts

@@ -10,6 +10,8 @@ import * as Rhino from '../../../internal/funding/providers/rhino.js'
 
 import * as Squid from '../../../internal/funding/providers/squid.js'
 
+import * as Stargate from '../../../internal/funding/providers/stargate.js'
+
 import * as Symbiosis from '../../../internal/funding/providers/symbiosis.js'
 
 import type * as Log from '../../../internal/Log.js'
@@ -34,6 +36,10 @@ const providers = [
     integratorId: 'squid-integrator-id',
     userAddress: '0x1111111111111111111111111111111111111111',
   }),
+  Stargate.stargate({
+    apiKey: 'layerzero-api-key',
+    userAddress: '0x1111111111111111111111111111111111111111',
+  }),
   Symbiosis.symbiosis({ userAddress: '0x1111111111111111111111111111111111111111' }),
 ] as const
 
@@ -175,6 +181,27 @@ describe('GET /funding/quotes', () => {
     expect(body.data[0]?.quote.expiresAt).toBe('2026-01-01T00:01:00Z')
   })
 
+  test('returns Stargate quotes for Base USDC to Tempo USDC.e', async () => {
+    const app = create({ providers: [stargateProvider()] })
+    const response = await app.request(quoteUrl({ ...baseUsdcQuery, provider: 'stargate' }), {
+      headers: TestApp.auth.headers,
+    })
+
+    expect(response.status).toBe(200)
+    const body = await TestApp.json(response, Funding.schema.quoteFunding.Response)
+    expect(body.data[0]).toMatchObject({
+      destinationAmount: { baseUnits: '999600' },
+      destinationAmountMin: { baseUnits: '999100' },
+      id: 'base-usdc-tempo-usdce-stargate',
+      provider: { id: 'stargate', name: 'Stargate' },
+      quality: {
+        liquiditySource: 'providerQuote',
+        sourceDetail: 'stargate:value-transfer-v1:bus',
+        tier: 'liquid',
+      },
+    })
+  })
+
   test('returns non-EVM Rhino quotes with stable chain and token ids', async () => {
     const app = create({ providers: [rhinoProvider()] })
     const response = await app.request(
@@ -501,6 +528,25 @@ function rhinoProvider() {
   })
 }
 
+function stargateProvider() {
+  return withGetQuote('stargate', async (input, signal) => {
+    expect(signal.aborted).toBe(false)
+    expect(input.candidate.id).toBe('base-usdc-tempo-usdce-stargate')
+    return {
+      destinationAmountMin: '999100',
+      destinationAmount: '999600',
+      quality: {
+        estimatedSeconds: 28,
+        liquiditySource: 'providerQuote',
+        sourceDetail: 'stargate:value-transfer-v1:bus',
+        tier: 'liquid',
+      },
+      sampledAt: '2026-01-01T00:00:00Z',
+      status: 'available',
+    }
+  })
+}
+
 function withGetQuote(
   id: FundingProvider.ProviderId,
   getQuote: FundingProvider.Provider['getQuote'],

package/src/apps/funding/routes/quotes.ts

@@ -22,11 +22,14 @@ export namespace schema {
     export const Query = FundingProvider.schema.QuoteRequest
 
     /** Non-paginated list of successful funding quotes. */
-    export const Response = Schema.describe(
-      z.object({
-        data: z.array(FundingQuote).check(z.describe('Successful live funding quotes.')),
-      }),
-      'A non-paginated list of successful live funding quotes.',
+    export const Response = OpenApi.component(
+      Schema.describe(
+        z.object({
+          data: z.array(FundingQuote).check(z.describe('Successful live funding quotes.')),
+        }),
+        'A non-paginated list of successful live funding quotes.',
+      ),
+      'FundingQuoteList',
     )
   }
 }

package/src/apps/funding/routes/transfers.test.ts

@@ -39,6 +39,24 @@ function create(options: TestApp.create.Options = {}) {
   return TestApp.create({ ...options, db })
 }
 
+type JsonSchema = {
+  $ref?: string | undefined
+  additionalProperties?: boolean | undefined
+  examples?: readonly unknown[] | undefined
+  properties?: Record<string, JsonSchema> | undefined
+  required?: readonly string[] | undefined
+}
+
+type ComponentSpec = {
+  components: { schemas: Record<string, JsonSchema> }
+}
+
+function dereference(spec: ComponentSpec, schema: JsonSchema): JsonSchema {
+  if (!schema.$ref) return schema
+  const name = schema.$ref.split('/').at(-1)!
+  return spec.components.schemas[name]!
+}
+
 describe('GET /funding/transfers', () => {
   test('requires the funding:read scope', async () => {
     const app = transfersApp()
@@ -766,33 +784,23 @@ describe('funding transfers OpenAPI', () => {
 
   test('publishes human-readable deposit address route examples', async () => {
     const app = create({ auth: false })
-    type Property = { examples: string[] }
     type Operation = {
       requestBody: {
-        content: Record<
-          string,
-          {
-            schema: {
-              properties: {
-                destinationToken: Property
-                sourceChain: Property
-                sourceToken: Property
-              }
-            }
-          }
-        >
+        content: Record<string, { schema: JsonSchema }>
       }
     }
-    type Spec = { paths: Record<string, { post: Operation }> }
+    type Spec = ComponentSpec & { paths: Record<string, { post: Operation }> }
     const spec = (await (await app.request('/openapi.json')).json()) as Spec
-    const properties =
+    const properties = dereference(
+      spec,
       spec.paths['/v1/funding/deposit-addresses']!.post.requestBody.content['application/json']!
-        .schema.properties
+        .schema,
+    ).properties!
 
     expect({
-      destinationToken: properties.destinationToken.examples,
-      sourceChain: properties.sourceChain.examples,
-      sourceToken: properties.sourceToken.examples,
+      destinationToken: properties['destinationToken']!.examples,
+      sourceChain: properties['sourceChain']!.examples,
+      sourceToken: properties['sourceToken']!.examples,
     }).toMatchInlineSnapshot(`
       {
         "destinationToken": [
@@ -949,30 +957,22 @@ describe('funding transfers OpenAPI', () => {
 
   test('publishes concrete creation schemas', async () => {
     const app = create({ auth: false })
-    const spec = (await (await app.request('/openapi.json')).json()) as {
+    type Spec = ComponentSpec & {
       paths: Record<
         string,
         {
           post?: {
             requestBody: {
-              content: Record<
-                string,
-                {
-                  schema: {
-                    additionalProperties?: boolean
-                    properties: object
-                    required?: readonly string[] | undefined
-                  }
-                }
-              >
+              content: Record<string, { schema: JsonSchema }>
             }
             responses: Record<string, unknown>
           }
         }
       >
     }
+    const spec = (await (await app.request('/openapi.json')).json()) as Spec
     const creationSchema = (path: string) =>
-      spec.paths[path]!.post!.requestBody.content['application/json']!.schema
+      dereference(spec, spec.paths[path]!.post!.requestBody.content['application/json']!.schema)
     expect(
       creationSchema('/v1/funding/deposit-addresses').required?.includes('subsidize') ?? false,
     ).toMatchInlineSnapshot(`false`)
@@ -980,7 +980,7 @@ describe('funding transfers OpenAPI', () => {
       const schema = creationSchema(path)
       return {
         additionalProperties: schema.additionalProperties,
-        properties: Object.keys(schema.properties),
+        properties: Object.keys(schema.properties!),
       }
     }
 
@@ -1025,6 +1025,7 @@ describe('funding transfers OpenAPI', () => {
           "200",
           "400",
           "401",
+          "403",
           "404",
           "409",
           "429",
@@ -1047,6 +1048,7 @@ describe('funding transfers OpenAPI', () => {
         "vaultResponses": [
           "400",
           "401",
+          "403",
           "429",
           "500",
           "501",
@@ -1069,6 +1071,7 @@ describe('funding transfers OpenAPI', () => {
         "zoneResponses": [
           "400",
           "401",
+          "403",
           "429",
           "500",
           "501",

package/src/apps/management/Billing.test.ts

@@ -199,6 +199,32 @@ describe('createReporter', () => {
     await db.close()
   })
 
+  test('behavior: marks a meter event that Stripe already accepted', async () => {
+    const db = create()
+    await db.migrate()
+    await StripeCustomers.create(db, { orgId: 'org_1', stripeCustomerId: 'cus_1' })
+    const row = await finalized(db, { feeAmount: '100000', seed: '03' })
+
+    const { stripe } = stubStripe({
+      meterEvent: (params) => {
+        throw new Error(`An event already exists with identifier ${params.identifier}.`)
+      },
+      subscriptions: [{ items: ['feePayerSpend', 'apiRequests'], status: 'active' }],
+    })
+    expect(await Billing.createReporter({ db, stripe }).tick()).toStrictEqual({
+      failed: 0,
+      reported: 1,
+      skipped: 0,
+    })
+    expect((await SponsoredTransactions.get(db, row.id))?.meterReportedAt).not.toBeNull()
+    expect(await Billing.createReporter({ db, stripe }).tick()).toStrictEqual({
+      failed: 0,
+      reported: 0,
+      skipped: 0,
+    })
+    await db.close()
+  })
+
   test('behavior: canceled customers skip without meter events', async () => {
     const db = create()
     await db.migrate()

package/src/apps/management/Billing.ts

@@ -357,12 +357,18 @@ export function createReporter(options: createReporter.Options): createReporter.
             const stamp = recent && !subscription.items.feePayerSpend?.created
             // The row id makes short-window retries idempotent on Stripe's
             // side; `meter_reported_at` is the durable exactly-once guard.
-            await stripe.billing.meterEvents.create({
-              event_name: meterEventName,
-              identifier: row.id,
-              payload: { stripe_customer_id: customer.stripeCustomerId, value: row.feeAmount! },
-              ...(stamp ? { timestamp: Math.floor(finalizedAt / 1000) } : {}),
-            })
+            try {
+              await stripe.billing.meterEvents.create({
+                event_name: meterEventName,
+                identifier: row.id,
+                payload: { stripe_customer_id: customer.stripeCustomerId, value: row.feeAmount! },
+                ...(stamp ? { timestamp: Math.floor(finalizedAt / 1000) } : {}),
+              })
+            } catch (error) {
+              // Stripe may persist the event before the Worker records its ack.
+              // Its duplicate response proves this exact row was already metered.
+              if (!isDuplicateMeterEvent(error, row.id)) throw error
+            }
             reported++
           } else {
             // Deleted orgs and Stripe-deleted (canceled) customers keep their
@@ -381,6 +387,14 @@ export function createReporter(options: createReporter.Options): createReporter.
   }
 }
 
+/** Whether Stripe confirms that the exact meter event identifier already exists. */
+function isDuplicateMeterEvent(error: unknown, identifier: string): boolean {
+  return (
+    error instanceof Error &&
+    error.message === `An event already exists with identifier ${identifier}.`
+  )
+}
+
 export declare namespace createReporter {
   /** Options for {@link createReporter}. */
   type Options = {
@@ -452,7 +466,10 @@ export function createRequestUsageReporter(
             count: status.count,
             environment,
             oldestPendingAgeSeconds: status.oldestAttemptedAt
-              ? Math.max(0, Math.floor((now() - new Date(status.oldestAttemptedAt).getTime()) / 1_000))
+              ? Math.max(
+                  0,
+                  Math.floor((now() - new Date(status.oldestAttemptedAt).getTime()) / 1_000),
+                )
               : 0,
           }
         }),

package/src/apps/management/routes/api-keys.test.ts

@@ -82,6 +82,184 @@ async function fixture(app: ReturnType<typeof createApp>, cookie: string) {
   return { org, project }
 }
 
+test('publishes generator-ready OpenAPI contracts', async () => {
+  const app = createApp({ kv: { store: TestApp.kvStore() } })
+  const spec = await (await app.request('/openapi.json')).json()
+  const collection = spec.paths['/v1/orgs/{orgId}/projects/{projectId}/api-keys']
+  const detail = spec.paths['/v1/orgs/{orgId}/projects/{projectId}/api-keys/{keyId}']
+  const organization = spec.paths['/v1/orgs/{orgId}/api-keys']
+
+  expect({
+    components: [
+      'ApiKey',
+      'ApiKeyList',
+      'CreateApiKeyRequest',
+      'CreateApiKeyResponse',
+      'RevokeApiKeyResponse',
+      'UpdateApiKeyRequest',
+    ].filter((name) => spec.components.schemas[name]),
+    create: {
+      errors: {
+        400: collection.post.responses[400].content['application/json'].schema,
+        403: collection.post.responses[403].content['application/json'].schema,
+        404: collection.post.responses[404].content['application/json'].schema,
+      },
+      operationId: collection.post.operationId,
+      request: collection.post.requestBody.content['application/json'].schema,
+      response: collection.post.responses[200].content['application/json'].schema,
+    },
+    listOrganization: {
+      errors: {
+        400: organization.get.responses[400].content['application/json'].schema,
+        403: organization.get.responses[403].content['application/json'].schema,
+        404: organization.get.responses[404].content['application/json'].schema,
+      },
+      operationId: organization.get.operationId,
+      response: organization.get.responses[200].content['application/json'].schema,
+    },
+    listProject: {
+      errors: {
+        400: collection.get.responses[400].content['application/json'].schema,
+        403: collection.get.responses[403].content['application/json'].schema,
+        404: collection.get.responses[404].content['application/json'].schema,
+      },
+      operationId: collection.get.operationId,
+      response: collection.get.responses[200].content['application/json'].schema,
+    },
+    revoke: {
+      errors: {
+        400: detail.delete.responses[400].content['application/json'].schema,
+        403: detail.delete.responses[403].content['application/json'].schema,
+        404: detail.delete.responses[404].content['application/json'].schema,
+      },
+      operationId: detail.delete.operationId,
+      response: detail.delete.responses[200].content['application/json'].schema,
+    },
+    timestamps: {
+      createdAt: spec.components.schemas.ApiKey.properties.createdAt.format,
+      expiresAt: spec.components.schemas.ApiKey.properties.expiresAt.format,
+      lastUsedAt: spec.components.schemas.ApiKey.properties.lastUsedAt.format,
+    },
+    update: {
+      errors: {
+        400: detail.patch.responses[400].content['application/json'].schema,
+        403: detail.patch.responses[403].content['application/json'].schema,
+        404: detail.patch.responses[404].content['application/json'].schema,
+      },
+      operationId: detail.patch.operationId,
+      request: detail.patch.requestBody.content['application/json'].schema,
+      response: detail.patch.responses[200].content['application/json'].schema,
+    },
+  }).toMatchInlineSnapshot(`
+    {
+      "components": [
+        "ApiKey",
+        "ApiKeyList",
+        "CreateApiKeyRequest",
+        "CreateApiKeyResponse",
+        "RevokeApiKeyResponse",
+        "UpdateApiKeyRequest",
+      ],
+      "create": {
+        "errors": {
+          "400": {
+            "$ref": "#/components/schemas/ApiKeyMalformedOrBodyInvalidOrParamInvalidError",
+          },
+          "403": {
+            "$ref": "#/components/schemas/ApiKeyForbiddenOrApiKeyIpForbiddenOrForbiddenOrScopeNotIssuableError",
+          },
+          "404": {
+            "$ref": "#/components/schemas/ApiKeysNotEnabledOrOrganizationNotFoundOrProjectNotFoundError",
+          },
+        },
+        "operationId": "createApiKey",
+        "request": {
+          "$ref": "#/components/schemas/CreateApiKeyRequest",
+        },
+        "response": {
+          "$ref": "#/components/schemas/CreateApiKeyResponse",
+        },
+      },
+      "listOrganization": {
+        "errors": {
+          "400": {
+            "$ref": "#/components/schemas/ApiKeyMalformedOrParamInvalidOrQueryInvalidError",
+          },
+          "403": {
+            "$ref": "#/components/schemas/ForbiddenError",
+          },
+          "404": {
+            "$ref": "#/components/schemas/ApiKeysNotEnabledOrOrganizationNotFoundError",
+          },
+        },
+        "operationId": "listOrgApiKeys",
+        "response": {
+          "$ref": "#/components/schemas/ApiKeyList",
+        },
+      },
+      "listProject": {
+        "errors": {
+          "400": {
+            "$ref": "#/components/schemas/ApiKeyMalformedOrParamInvalidOrQueryInvalidError",
+          },
+          "403": {
+            "$ref": "#/components/schemas/ForbiddenError",
+          },
+          "404": {
+            "$ref": "#/components/schemas/ApiKeysNotEnabledOrOrganizationNotFoundOrProjectNotFoundError",
+          },
+        },
+        "operationId": "listApiKeys",
+        "response": {
+          "$ref": "#/components/schemas/ApiKeyList",
+        },
+      },
+      "revoke": {
+        "errors": {
+          "400": {
+            "$ref": "#/components/schemas/ApiKeyMalformedOrParamInvalidError",
+          },
+          "403": {
+            "$ref": "#/components/schemas/ForbiddenError",
+          },
+          "404": {
+            "$ref": "#/components/schemas/ApiKeyNotFoundOrApiKeysNotEnabledOrOrganizationNotFoundOrProjectNotFoundError",
+          },
+        },
+        "operationId": "revokeApiKey",
+        "response": {
+          "$ref": "#/components/schemas/RevokeApiKeyResponse",
+        },
+      },
+      "timestamps": {
+        "createdAt": "date-time",
+        "expiresAt": "date-time",
+        "lastUsedAt": "date-time",
+      },
+      "update": {
+        "errors": {
+          "400": {
+            "$ref": "#/components/schemas/ApiKeyMalformedOrBodyInvalidOrParamInvalidError",
+          },
+          "403": {
+            "$ref": "#/components/schemas/ForbiddenError",
+          },
+          "404": {
+            "$ref": "#/components/schemas/ApiKeyNotFoundOrApiKeysNotEnabledOrOrganizationNotFoundOrProjectNotFoundError",
+          },
+        },
+        "operationId": "updateApiKey",
+        "request": {
+          "$ref": "#/components/schemas/UpdateApiKeyRequest",
+        },
+        "response": {
+          "$ref": "#/components/schemas/ApiKey",
+        },
+      },
+    }
+  `)
+})
+
 describe('keys', () => {
   test('requires an owner to issue management write keys', async () => {
     const db = TestApp.database()