tapimo 0.10.2 → 0.12.0

package/src/apps/data/routes/zones.test.ts

@@ -33,7 +33,19 @@ const withdrawalProcessedData = AbiParameters.from(['address', 'uint128', 'bool'
 const recipient = Schema.Address.parse('0xbe058e1c4df8a4366a387bf595b284246a93039e')
 const token = Schema.Address.parse('0x20c0000000000000000000000000000000000000')
 
+type OpenApiErrorSchema = {
+  $ref?: string
+  properties?: {
+    error?: {
+      properties?: {
+        code?: { enum?: readonly string[] }
+      }
+    }
+  }
+}
+
 type OpenApiDocument = {
+  components?: { schemas?: Record<string, OpenApiErrorSchema> }
   paths: {
     '/v1/zones/withdrawals/{senderTag}'?: {
       get?: {
@@ -63,15 +75,7 @@ type OpenApiDocument = {
           400?: {
             content?: {
               'application/json'?: {
-                schema?: {
-                  properties?: {
-                    error?: {
-                      properties?: {
-                        code?: { enum?: readonly string[] }
-                      }
-                    }
-                  }
-                }
+                schema?: OpenApiErrorSchema
               }
             }
           }
@@ -428,11 +432,13 @@ describe('GET /v1/zones/withdrawals/:senderTag', () => {
     `)
 
     const response = operation.responses?.[200]?.content?.['application/json']
+    const errorSchema = operation.responses?.[400]?.content?.['application/json']?.schema
+    const errorSchemaName = errorSchema?.$ref?.split('/').at(-1)
+    const errorSchema_resolved = errorSchemaName
+      ? document.components?.schemas?.[errorSchemaName]
+      : errorSchema
     expect(Object.keys(response?.examples ?? {}).sort()).toEqual(['empty', 'processed'])
-    expect(
-      operation.responses?.[400]?.content?.['application/json']?.schema?.properties?.error
-        ?.properties?.code?.enum,
-    ).toEqual([
+    expect(errorSchema_resolved?.properties?.error?.properties?.code?.enum).toEqual([
       'api_key_malformed',
       'chain_id_invalid',
       'chain_id_unsupported',

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

@@ -38,17 +38,221 @@ function create(options: TestApp.create.Options = {}) {
 }
 
 describe('funding OpenAPI', () => {
-  test('publishes get operation ids for funding inventory', async () => {
+  test('publishes generator-ready discovery contracts', async () => {
     const app = create({ auth: false })
     const spec = await (await app.request('/openapi.json')).json()
+    const operations = {
+      chains: spec.paths['/v1/funding/chains'].get,
+      providers: spec.paths['/v1/funding/providers'].get,
+      quotes: spec.paths['/v1/funding/quotes'].get,
+    }
+    const summarize = (operation: (typeof operations)[keyof typeof operations]) => ({
+      errors: Object.fromEntries(
+        [400, 401, 403, 429, 500, 502].map((status) => [
+          status,
+          operation.responses[status].$ref ??
+            operation.responses[status].content?.['application/json']?.schema,
+        ]),
+      ),
+      operationId: operation.operationId,
+      response: operation.responses[200].content['application/json'].schema,
+    })
 
     expect({
-      chains: spec.paths['/v1/funding/chains'].get.operationId,
-      providers: spec.paths['/v1/funding/providers'].get.operationId,
-    }).toEqual({
-      chains: 'getFundingChains',
-      providers: 'getFundingProviders',
-    })
+      components: [
+        'FundingChain',
+        'FundingChainInventory',
+        'FundingChainList',
+        'FundingProvider',
+        'FundingProviderList',
+        'FundingQuote',
+        'FundingQuoteDetails',
+        'FundingQuoteList',
+        'FundingQuoteQuality',
+        'FundingToken',
+      ].filter((name) => spec.components.schemas[name]),
+      formats: {
+        quoteExpiresAt: spec.components.schemas.FundingQuoteDetails.properties.expiresAt.format,
+        quoteSampledAt: spec.components.schemas.FundingQuoteDetails.properties.sampledAt.format,
+      },
+      models: {
+        chainInventoryToken: spec.components.schemas.FundingChainInventory.properties.tokens.items,
+        chainList: spec.components.schemas.FundingChainList.properties.data.items,
+        providerList: spec.components.schemas.FundingProviderList.properties.data.items,
+        quote: {
+          destinationChain: spec.components.schemas.FundingQuote.properties.destinationChain,
+          destinationToken: spec.components.schemas.FundingQuote.properties.destinationToken,
+          provider: spec.components.schemas.FundingQuote.properties.provider,
+          quality: spec.components.schemas.FundingQuote.properties.quality,
+          quote: spec.components.schemas.FundingQuote.properties.quote,
+          sourceChain: spec.components.schemas.FundingQuote.properties.sourceChain,
+          sourceToken: spec.components.schemas.FundingQuote.properties.sourceToken,
+        },
+        quoteList: spec.components.schemas.FundingQuoteList.properties.data.items,
+      },
+      operations: {
+        chains: summarize(operations.chains),
+        providers: summarize(operations.providers),
+        quotes: summarize(operations.quotes),
+      },
+      sharedErrorCodes: {
+        authentication:
+          spec.components.schemas.AuthenticationError.properties.error.properties.code.enum,
+        forbidden: spec.components.schemas.ForbiddenError.properties.error.properties.code.enum,
+        malformedApiKey:
+          spec.components.schemas.ApiKeyMalformedError.properties.error.properties.code.enum,
+        malformedApiKeyOrInvalidQuery:
+          spec.components.schemas.ApiKeyMalformedOrQueryInvalidError.properties.error.properties
+            .code.enum,
+        upstream: spec.components.schemas.UpstreamError.properties.error.properties.code.enum,
+      },
+    }).toMatchInlineSnapshot(`
+      {
+        "components": [
+          "FundingChain",
+          "FundingChainInventory",
+          "FundingChainList",
+          "FundingProvider",
+          "FundingProviderList",
+          "FundingQuote",
+          "FundingQuoteDetails",
+          "FundingQuoteList",
+          "FundingQuoteQuality",
+          "FundingToken",
+        ],
+        "formats": {
+          "quoteExpiresAt": "date-time",
+          "quoteSampledAt": "date-time",
+        },
+        "models": {
+          "chainInventoryToken": {
+            "$ref": "#/components/schemas/FundingToken",
+          },
+          "chainList": {
+            "$ref": "#/components/schemas/FundingChainInventory",
+          },
+          "providerList": {
+            "$ref": "#/components/schemas/FundingProvider",
+          },
+          "quote": {
+            "destinationChain": {
+              "$ref": "#/components/schemas/FundingChain",
+            },
+            "destinationToken": {
+              "$ref": "#/components/schemas/FundingToken",
+            },
+            "provider": {
+              "$ref": "#/components/schemas/FundingProvider",
+            },
+            "quality": {
+              "$ref": "#/components/schemas/FundingQuoteQuality",
+            },
+            "quote": {
+              "$ref": "#/components/schemas/FundingQuoteDetails",
+            },
+            "sourceChain": {
+              "$ref": "#/components/schemas/FundingChain",
+            },
+            "sourceToken": {
+              "$ref": "#/components/schemas/FundingToken",
+            },
+          },
+          "quoteList": {
+            "$ref": "#/components/schemas/FundingQuote",
+          },
+        },
+        "operations": {
+          "chains": {
+            "errors": {
+              "400": {
+                "$ref": "#/components/schemas/ApiKeyMalformedError",
+              },
+              "401": {
+                "$ref": "#/components/schemas/AuthenticationError",
+              },
+              "403": {
+                "$ref": "#/components/schemas/ForbiddenError",
+              },
+              "429": "#/components/responses/RateLimited",
+              "500": "#/components/responses/InternalError",
+              "502": {
+                "$ref": "#/components/schemas/UpstreamError",
+              },
+            },
+            "operationId": "getFundingChains",
+            "response": {
+              "$ref": "#/components/schemas/FundingChainList",
+            },
+          },
+          "providers": {
+            "errors": {
+              "400": {
+                "$ref": "#/components/schemas/ApiKeyMalformedError",
+              },
+              "401": {
+                "$ref": "#/components/schemas/AuthenticationError",
+              },
+              "403": {
+                "$ref": "#/components/schemas/ForbiddenError",
+              },
+              "429": "#/components/responses/RateLimited",
+              "500": "#/components/responses/InternalError",
+              "502": {
+                "$ref": "#/components/schemas/UpstreamError",
+              },
+            },
+            "operationId": "getFundingProviders",
+            "response": {
+              "$ref": "#/components/schemas/FundingProviderList",
+            },
+          },
+          "quotes": {
+            "errors": {
+              "400": {
+                "$ref": "#/components/schemas/ApiKeyMalformedOrQueryInvalidError",
+              },
+              "401": {
+                "$ref": "#/components/schemas/AuthenticationError",
+              },
+              "403": {
+                "$ref": "#/components/schemas/ForbiddenError",
+              },
+              "429": "#/components/responses/RateLimited",
+              "500": "#/components/responses/InternalError",
+              "502": {
+                "$ref": "#/components/schemas/UpstreamError",
+              },
+            },
+            "operationId": "quoteFunding",
+            "response": {
+              "$ref": "#/components/schemas/FundingQuoteList",
+            },
+          },
+        },
+        "sharedErrorCodes": {
+          "authentication": [
+            "api_key_invalid",
+            "api_key_missing",
+            "unauthorized",
+          ],
+          "forbidden": [
+            "api_key_forbidden",
+            "api_key_ip_forbidden",
+            "forbidden",
+          ],
+          "malformedApiKey": [
+            "api_key_malformed",
+          ],
+          "malformedApiKeyOrInvalidQuery": [
+            "api_key_malformed",
+            "query_invalid",
+          ],
+          "upstream": [
+            "upstream_error",
+          ],
+        },
+      }
+    `)
   })
 })
 

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

@@ -20,23 +20,29 @@ export namespace schema {
   export const Token = FundingProvider.schema.TokenRef
 
   /** Chain inventory entry returned by the funding chains endpoint. */
-  export const ChainInventory = Schema.describe(
-    z.extend(Chain, {
-      tokens: z.array(Token).check(z.describe('Stablecoins known on this source chain.')),
-    }),
-    'One source chain and its known stablecoin inventory.',
+  export const ChainInventory = OpenApi.component(
+    Schema.describe(
+      z.extend(Chain, {
+        tokens: z.array(Token).check(z.describe('Stablecoins known on this source chain.')),
+      }),
+      'One source chain and its known stablecoin inventory.',
+    ),
+    'FundingChainInventory',
   )
 
   /** Schemas for the getFundingChains operation. */
   export namespace getFundingChains {
     /** Non-paginated source-chain inventory. */
-    export const Response = Schema.describe(
-      z.object({
-        data: z
-          .array(ChainInventory)
-          .check(z.describe('Source chains and stablecoins supported by funding quotes.')),
-      }),
-      'A non-paginated list of source chains and stablecoin inventory.',
+    export const Response = OpenApi.component(
+      Schema.describe(
+        z.object({
+          data: z
+            .array(ChainInventory)
+            .check(z.describe('Source chains and stablecoins supported by funding quotes.')),
+        }),
+        'A non-paginated list of source chains and stablecoin inventory.',
+      ),
+      'FundingChainList',
     )
   }
 }
@@ -72,6 +78,7 @@ export function chains() {
       description: 'Lists supported source chains and tokens.',
       operationId: 'getFundingChains',
       responses: OpenApi.responses({
+        errors: { 400: { codes: [] } },
         success: {
           description: 'Supported source chains and stablecoins.',
           example: fundingChainsResponseExample,