tapimo 0.11.0 → 0.13.0

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

@@ -18,6 +18,613 @@ function app(options: TestApp.create.Options = {}) {
 
 const verifiedTokenCount = 6
 
+describe('OpenAPI', () => {
+  test('publishes generator-ready token and balance contracts', async () => {
+    const application = TestApp.create({ auth: false })
+    const spec = await (await application.request('/openapi.json')).json()
+    const operations = {
+      balance: spec.paths['/v1/addresses/{address}/balances/{token}'].get,
+      balances: spec.paths['/v1/addresses/{address}/balances'].get,
+      holders: spec.paths['/v1/tokens/{token}/holders'].get,
+      token: spec.paths['/v1/tokens/{token}'].get,
+      tokenBySymbol: spec.paths['/v1/tokens/{symbol}'].get,
+      tokenLogo: spec.paths['/v1/tokens/{token}/logo'].get,
+      tokenTransactions: spec.paths['/v1/tokens/{token}/transactions'].get,
+      tokens: spec.paths['/v1/tokens'].get,
+    }
+    const summarizeError = (
+      response: (typeof operations)[keyof typeof operations]['responses'][number],
+    ) => {
+      const schema = response.$ref ?? response.content?.['application/json']?.schema
+      if (!schema || typeof schema === 'string' || !('$ref' in schema)) return schema
+      const name = schema.$ref.split('/').at(-1)!
+      return {
+        codes: spec.components.schemas[name].properties.error.properties.code.enum,
+        schema,
+      }
+    }
+    const summarize = (operation: (typeof operations)[keyof typeof operations]) => ({
+      errors: Object.fromEntries(
+        [400, 401, 403, 404, 429, 500, 502]
+          .filter((status) => operation.responses[status])
+          .map((status) => [status, summarizeError(operation.responses[status])]),
+      ),
+      operationId: operation.operationId,
+      response:
+        operation.responses[200].content['application/json']?.schema ??
+        Object.keys(operation.responses[200].content),
+    })
+
+    expect({
+      components: [
+        'Balance',
+        'BalanceList',
+        'BalanceListMeta',
+        'RpcTokenReference',
+        'Token',
+        'TokenHolder',
+        'TokenHolderList',
+        'TokenHolderListMeta',
+        'TokenList',
+        'TokenReference',
+        'TokenTransactionList',
+        'TokenTransactionListMeta',
+      ].filter((name) => spec.components.schemas[name]),
+      formats: {
+        tokenCreatedAt: spec.components.schemas.Token.properties.createdAt.format,
+        transferFirstAt:
+          spec.components.schemas.Token.properties.transferStats.properties.firstAt.anyOf[0].format,
+        transferLastAt:
+          spec.components.schemas.Token.properties.transferStats.properties.lastAt.anyOf[0].format,
+      },
+      models: {
+        balanceList: spec.components.schemas.BalanceList.properties.data.items,
+        balanceListMeta: spec.components.schemas.BalanceList.properties.meta,
+        balanceToken: spec.components.schemas.Balance.properties.token,
+        holderList: spec.components.schemas.TokenHolderList.properties.data.items,
+        holderListMeta: spec.components.schemas.TokenHolderList.properties.meta,
+        tokenList: spec.components.schemas.TokenList.properties.data.items,
+        tokenTransactionList: (() => {
+          const item = spec.components.schemas.TokenTransactionList.properties.data.items
+          return item.$ref ?? { description: item.description, type: item.type }
+        })(),
+        tokenTransactionListMeta: spec.components.schemas.TokenTransactionList.properties.meta,
+      },
+      operations: Object.fromEntries(
+        Object.entries(operations).map(([name, operation]) => [name, summarize(operation)]),
+      ),
+      sharedErrorCodes: {
+        authentication:
+          spec.components.schemas.AuthenticationError.properties.error.properties.code.enum,
+        forbidden: spec.components.schemas.ForbiddenError.properties.error.properties.code.enum,
+        tokenNotFound:
+          spec.components.schemas.TokenNotFoundError.properties.error.properties.code.enum,
+      },
+    }).toMatchInlineSnapshot(`
+      {
+        "components": [
+          "Balance",
+          "BalanceList",
+          "BalanceListMeta",
+          "RpcTokenReference",
+          "Token",
+          "TokenHolder",
+          "TokenHolderList",
+          "TokenHolderListMeta",
+          "TokenList",
+          "TokenReference",
+          "TokenTransactionList",
+          "TokenTransactionListMeta",
+        ],
+        "formats": {
+          "tokenCreatedAt": "date-time",
+          "transferFirstAt": "date-time",
+          "transferLastAt": "date-time",
+        },
+        "models": {
+          "balanceList": {
+            "$ref": "#/components/schemas/Balance",
+          },
+          "balanceListMeta": {
+            "$ref": "#/components/schemas/BalanceListMeta",
+          },
+          "balanceToken": {
+            "$ref": "#/components/schemas/TokenReference",
+          },
+          "holderList": {
+            "$ref": "#/components/schemas/TokenHolder",
+          },
+          "holderListMeta": {
+            "$ref": "#/components/schemas/TokenHolderListMeta",
+          },
+          "tokenList": {
+            "$ref": "#/components/schemas/Token",
+          },
+          "tokenTransactionList": "#/components/schemas/Transaction",
+          "tokenTransactionListMeta": {
+            "$ref": "#/components/schemas/TokenTransactionListMeta",
+          },
+        },
+        "operations": {
+          "balance": {
+            "errors": {
+              "400": {
+                "codes": [
+                  "address_invalid",
+                  "api_key_malformed",
+                  "chain_id_invalid",
+                  "chain_id_unsupported",
+                  "query_invalid",
+                ],
+                "schema": {
+                  "$ref": "#/components/schemas/AddressInvalidOrApiKeyMalformedOrChainIdInvalidOrChainIdUnsupportedOrQueryInvalidError",
+                },
+              },
+              "401": {
+                "codes": [
+                  "api_key_invalid",
+                  "api_key_missing",
+                  "unauthorized",
+                ],
+                "schema": {
+                  "$ref": "#/components/schemas/AuthenticationError",
+                },
+              },
+              "403": {
+                "codes": [
+                  "api_key_forbidden",
+                  "api_key_ip_forbidden",
+                  "forbidden",
+                ],
+                "schema": {
+                  "$ref": "#/components/schemas/ForbiddenError",
+                },
+              },
+              "404": {
+                "codes": [
+                  "token_not_found",
+                ],
+                "schema": {
+                  "$ref": "#/components/schemas/TokenNotFoundError",
+                },
+              },
+              "429": "#/components/responses/RateLimited",
+              "500": "#/components/responses/InternalError",
+              "502": {
+                "codes": [
+                  "upstream_error",
+                ],
+                "schema": {
+                  "$ref": "#/components/schemas/UpstreamError",
+                },
+              },
+            },
+            "operationId": "getAddressBalance",
+            "response": {
+              "$ref": "#/components/schemas/Balance",
+            },
+          },
+          "balances": {
+            "errors": {
+              "400": {
+                "codes": [
+                  "address_invalid",
+                  "api_key_malformed",
+                  "chain_id_invalid",
+                  "chain_id_unsupported",
+                  "query_invalid",
+                ],
+                "schema": {
+                  "$ref": "#/components/schemas/AddressInvalidOrApiKeyMalformedOrChainIdInvalidOrChainIdUnsupportedOrQueryInvalidError",
+                },
+              },
+              "401": {
+                "codes": [
+                  "api_key_invalid",
+                  "api_key_missing",
+                  "unauthorized",
+                ],
+                "schema": {
+                  "$ref": "#/components/schemas/AuthenticationError",
+                },
+              },
+              "403": {
+                "codes": [
+                  "api_key_forbidden",
+                  "api_key_ip_forbidden",
+                  "forbidden",
+                ],
+                "schema": {
+                  "$ref": "#/components/schemas/ForbiddenError",
+                },
+              },
+              "429": "#/components/responses/RateLimited",
+              "500": "#/components/responses/InternalError",
+              "502": {
+                "codes": [
+                  "upstream_error",
+                ],
+                "schema": {
+                  "$ref": "#/components/schemas/UpstreamError",
+                },
+              },
+            },
+            "operationId": "getAddressBalances",
+            "response": {
+              "$ref": "#/components/schemas/BalanceList",
+            },
+          },
+          "holders": {
+            "errors": {
+              "400": {
+                "codes": [
+                  "api_key_malformed",
+                  "chain_id_invalid",
+                  "chain_id_unsupported",
+                  "query_invalid",
+                  "token_invalid",
+                ],
+                "schema": {
+                  "$ref": "#/components/schemas/ApiKeyMalformedOrChainIdInvalidOrChainIdUnsupportedOrQueryInvalidOrTokenInvalidError",
+                },
+              },
+              "401": {
+                "codes": [
+                  "api_key_invalid",
+                  "api_key_missing",
+                  "unauthorized",
+                ],
+                "schema": {
+                  "$ref": "#/components/schemas/AuthenticationError",
+                },
+              },
+              "403": {
+                "codes": [
+                  "api_key_forbidden",
+                  "api_key_ip_forbidden",
+                  "forbidden",
+                ],
+                "schema": {
+                  "$ref": "#/components/schemas/ForbiddenError",
+                },
+              },
+              "429": "#/components/responses/RateLimited",
+              "500": "#/components/responses/InternalError",
+              "502": {
+                "codes": [
+                  "upstream_error",
+                ],
+                "schema": {
+                  "$ref": "#/components/schemas/UpstreamError",
+                },
+              },
+            },
+            "operationId": "getTokenHolders",
+            "response": {
+              "$ref": "#/components/schemas/TokenHolderList",
+            },
+          },
+          "token": {
+            "errors": {
+              "400": {
+                "codes": [
+                  "api_key_malformed",
+                  "chain_id_invalid",
+                  "chain_id_unsupported",
+                  "query_invalid",
+                  "token_invalid",
+                ],
+                "schema": {
+                  "$ref": "#/components/schemas/ApiKeyMalformedOrChainIdInvalidOrChainIdUnsupportedOrQueryInvalidOrTokenInvalidError",
+                },
+              },
+              "401": {
+                "codes": [
+                  "api_key_invalid",
+                  "api_key_missing",
+                  "unauthorized",
+                ],
+                "schema": {
+                  "$ref": "#/components/schemas/AuthenticationError",
+                },
+              },
+              "403": {
+                "codes": [
+                  "api_key_forbidden",
+                  "api_key_ip_forbidden",
+                  "forbidden",
+                ],
+                "schema": {
+                  "$ref": "#/components/schemas/ForbiddenError",
+                },
+              },
+              "404": {
+                "codes": [
+                  "token_not_found",
+                ],
+                "schema": {
+                  "$ref": "#/components/schemas/TokenNotFoundError",
+                },
+              },
+              "429": "#/components/responses/RateLimited",
+              "500": "#/components/responses/InternalError",
+              "502": {
+                "codes": [
+                  "upstream_error",
+                ],
+                "schema": {
+                  "$ref": "#/components/schemas/UpstreamError",
+                },
+              },
+            },
+            "operationId": "getToken",
+            "response": {
+              "$ref": "#/components/schemas/Token",
+            },
+          },
+          "tokenBySymbol": {
+            "errors": {
+              "400": {
+                "codes": [
+                  "api_key_malformed",
+                  "chain_id_invalid",
+                  "chain_id_unsupported",
+                  "query_invalid",
+                  "symbol_invalid",
+                ],
+                "schema": {
+                  "$ref": "#/components/schemas/ApiKeyMalformedOrChainIdInvalidOrChainIdUnsupportedOrQueryInvalidOrSymbolInvalidError",
+                },
+              },
+              "401": {
+                "codes": [
+                  "api_key_invalid",
+                  "api_key_missing",
+                  "unauthorized",
+                ],
+                "schema": {
+                  "$ref": "#/components/schemas/AuthenticationError",
+                },
+              },
+              "403": {
+                "codes": [
+                  "api_key_forbidden",
+                  "api_key_ip_forbidden",
+                  "forbidden",
+                ],
+                "schema": {
+                  "$ref": "#/components/schemas/ForbiddenError",
+                },
+              },
+              "404": {
+                "codes": [
+                  "token_not_found",
+                ],
+                "schema": {
+                  "$ref": "#/components/schemas/TokenNotFoundError",
+                },
+              },
+              "429": "#/components/responses/RateLimited",
+              "500": "#/components/responses/InternalError",
+              "502": {
+                "codes": [
+                  "upstream_error",
+                ],
+                "schema": {
+                  "$ref": "#/components/schemas/UpstreamError",
+                },
+              },
+            },
+            "operationId": "getTokenBySymbol",
+            "response": {
+              "$ref": "#/components/schemas/Token",
+            },
+          },
+          "tokenLogo": {
+            "errors": {
+              "400": {
+                "codes": [
+                  "api_key_malformed",
+                  "chain_id_invalid",
+                  "chain_id_unsupported",
+                  "query_invalid",
+                  "token_invalid",
+                ],
+                "schema": {
+                  "$ref": "#/components/schemas/ApiKeyMalformedOrChainIdInvalidOrChainIdUnsupportedOrQueryInvalidOrTokenInvalidError",
+                },
+              },
+              "401": {
+                "codes": [
+                  "api_key_invalid",
+                  "api_key_missing",
+                  "unauthorized",
+                ],
+                "schema": {
+                  "$ref": "#/components/schemas/AuthenticationError",
+                },
+              },
+              "403": {
+                "codes": [
+                  "api_key_forbidden",
+                  "api_key_ip_forbidden",
+                  "forbidden",
+                ],
+                "schema": {
+                  "$ref": "#/components/schemas/ForbiddenError",
+                },
+              },
+              "404": {
+                "codes": [
+                  "token_logo_not_found",
+                ],
+                "schema": {
+                  "$ref": "#/components/schemas/TokenLogoNotFoundError",
+                },
+              },
+              "429": "#/components/responses/RateLimited",
+              "500": "#/components/responses/InternalError",
+              "502": {
+                "codes": [
+                  "upstream_error",
+                ],
+                "schema": {
+                  "$ref": "#/components/schemas/UpstreamError",
+                },
+              },
+            },
+            "operationId": "getTokenLogo",
+            "response": [
+              "image/*",
+            ],
+          },
+          "tokenTransactions": {
+            "errors": {
+              "400": {
+                "codes": [
+                  "api_key_malformed",
+                  "chain_id_invalid",
+                  "chain_id_unsupported",
+                  "query_invalid",
+                  "token_invalid",
+                ],
+                "schema": {
+                  "$ref": "#/components/schemas/ApiKeyMalformedOrChainIdInvalidOrChainIdUnsupportedOrQueryInvalidOrTokenInvalidError",
+                },
+              },
+              "401": {
+                "codes": [
+                  "api_key_invalid",
+                  "api_key_missing",
+                  "unauthorized",
+                ],
+                "schema": {
+                  "$ref": "#/components/schemas/AuthenticationError",
+                },
+              },
+              "403": {
+                "codes": [
+                  "api_key_forbidden",
+                  "api_key_ip_forbidden",
+                  "forbidden",
+                ],
+                "schema": {
+                  "$ref": "#/components/schemas/ForbiddenError",
+                },
+              },
+              "429": "#/components/responses/RateLimited",
+              "500": "#/components/responses/InternalError",
+              "502": {
+                "codes": [
+                  "upstream_error",
+                ],
+                "schema": {
+                  "$ref": "#/components/schemas/UpstreamError",
+                },
+              },
+            },
+            "operationId": "getTokenTransactions",
+            "response": {
+              "$ref": "#/components/schemas/TokenTransactionList",
+            },
+          },
+          "tokens": {
+            "errors": {
+              "400": {
+                "codes": [
+                  "api_key_malformed",
+                  "chain_id_invalid",
+                  "chain_id_unsupported",
+                  "query_invalid",
+                ],
+                "schema": {
+                  "$ref": "#/components/schemas/ApiKeyMalformedOrChainIdInvalidOrChainIdUnsupportedOrQueryInvalidError",
+                },
+              },
+              "401": {
+                "codes": [
+                  "api_key_invalid",
+                  "api_key_missing",
+                  "unauthorized",
+                ],
+                "schema": {
+                  "$ref": "#/components/schemas/AuthenticationError",
+                },
+              },
+              "403": {
+                "codes": [
+                  "api_key_forbidden",
+                  "api_key_ip_forbidden",
+                  "forbidden",
+                ],
+                "schema": {
+                  "$ref": "#/components/schemas/ForbiddenError",
+                },
+              },
+              "429": "#/components/responses/RateLimited",
+              "500": "#/components/responses/InternalError",
+              "502": {
+                "codes": [
+                  "upstream_error",
+                ],
+                "schema": {
+                  "$ref": "#/components/schemas/UpstreamError",
+                },
+              },
+            },
+            "operationId": "getTokens",
+            "response": {
+              "$ref": "#/components/schemas/TokenList",
+            },
+          },
+        },
+        "sharedErrorCodes": {
+          "authentication": [
+            "api_key_invalid",
+            "api_key_missing",
+            "unauthorized",
+          ],
+          "forbidden": [
+            "api_key_forbidden",
+            "api_key_ip_forbidden",
+            "forbidden",
+          ],
+          "tokenNotFound": [
+            "token_not_found",
+          ],
+        },
+      }
+    `)
+  })
+
+  test('uses coherent token responses and canonical asset URLs', async () => {
+    const application = TestApp.create({ auth: false })
+    const spec = (await (await application.request('/openapi.json')).json()) as {
+      paths: Record<
+        string,
+        {
+          get?: {
+            operationId?: string
+            responses?: Record<string, { content?: { 'application/json'?: { example?: unknown } } }>
+          }
+        }
+      >
+    }
+
+    for (const operationId of ['getToken', 'getTokenBySymbol']) {
+      const operation = Object.values(spec.paths).find(
+        (path) => path.get?.operationId === operationId,
+      )
+      expect(operation?.get?.responses?.['200']?.content?.['application/json']?.example).toEqual(
+        Tokens.tokenExample,
+      )
+    }
+
+    const assetUrls = JSON.stringify(spec).match(/https:\/\/api\.tempo\.xyz\/assets\/[^"\\]+/g)
+    expect(new Set(assetUrls)).toEqual(new Set([Tokens.tokenExample.logoUri]))
+  })
+})
+
 describe('GET /tokens', () => {
   test.runIf(runtime.mode === 'testnet')(
     'serves a bounded positional page via `page` (indexed mode)',