tapimo 0.11.0 → 0.13.0

package/src/apps/management/routes/faucet.ts

@@ -15,54 +15,81 @@ const userRateLimit = { limit: 3, period: 'minute' } satisfies RateLimit.Limit
 
 /** OpenAPI schemas owned by the sandbox faucet. */
 export namespace schema {
-  const Token = Schema.describe(
-    z.object({
-      address: Schema.TokenAddress.check(z.describe('The test token contract that minted funds.')),
-      currency: z
-        .string()
-        .check(z.describe('The token’s currency label.'), z.meta({ examples: ['USD'] })),
-      decimals: z
-        .number()
-        .check(
-          z.int(),
-          z.nonnegative(),
-          z.describe('The decimal places used by the token.'),
-          z.meta({ examples: [6] }),
+  const Token = OpenApi.component(
+    Schema.describe(
+      z.object({
+        address: Schema.TokenAddress.check(
+          z.describe('The test token contract that minted funds.'),
         ),
-      name: z
-        .string()
-        .check(z.describe('The token’s human-readable name.'), z.meta({ examples: ['Test USD'] })),
-      symbol: z.string().check(z.describe('The token’s symbol.'), z.meta({ examples: ['TUSD'] })),
-    }),
-    'A test token minted by the faucet.',
+        currency: z
+          .string()
+          .check(z.describe('The token’s currency label.'), z.meta({ examples: ['USD'] })),
+        decimals: z
+          .number()
+          .check(
+            z.int(),
+            z.nonnegative(),
+            z.describe('The decimal places used by the token.'),
+            z.meta({ examples: [6] }),
+          ),
+        name: z
+          .string()
+          .check(
+            z.describe('The token’s human-readable name.'),
+            z.meta({ examples: ['Test USD'] }),
+          ),
+        symbol: z.string().check(z.describe('The token’s symbol.'), z.meta({ examples: ['TUSD'] })),
+      }),
+      'A test token minted by the faucet.',
+    ),
+    'FaucetToken',
   )
 
-  const FundedToken = Schema.describe(
-    z.object({
-      amount: Schema.TokenAmount.check(z.describe('Amount minted by the faucet.')),
-      token: Token,
-      transactionHash: Schema.Hash.check(z.describe('The transaction that minted this token.')),
-    }),
-    'One token amount minted by the faucet.',
+  const FundedToken = OpenApi.component(
+    Schema.describe(
+      z.object({
+        amount: Schema.TokenAmount.check(
+          z.describe('Amount minted by the faucet.'),
+          z.meta({
+            examples: [
+              { baseUnits: '1000000000', currency: 'USD', decimals: 6, formatted: '1000' },
+            ],
+          }),
+        ),
+        token: Token,
+        transactionHash: Schema.Hash.check(z.describe('The transaction that minted this token.')),
+      }),
+      'One token amount minted by the faucet.',
+    ),
+    'FaucetFundedToken',
   )
 
   /** Faucet request body. */
-  export const FundBody = Schema.describe(
-    z.object({ address: Schema.Address }),
-    'A Tempo testnet account to fund.',
+  export const FundBody = OpenApi.component(
+    Schema.describe(z.object({ address: Schema.Address }), 'A Tempo testnet account to fund.'),
+    'FundTestnetAccountRequest',
   )
 
   /** Faucet response. */
-  export const FundResponse = Schema.describe(
-    z.object({
-      tokens: z
-        .array(FundedToken)
-        .check(z.describe('The configured test tokens minted to the account.')),
-      transactionHashes: z
-        .array(Schema.Hash)
-        .check(z.describe('Transactions that minted the configured test tokens.')),
-    }),
-    'Test tokens minted while funding the account.',
+  export const FundResponse = OpenApi.component(
+    Schema.describe(
+      z.object({
+        tokens: z
+          .array(FundedToken)
+          .check(
+            z.describe('The configured test tokens minted to the account.'),
+            z.meta({ examples: [[]] }),
+          ),
+        transactionHashes: z
+          .array(Schema.Hash)
+          .check(
+            z.describe('Transactions that minted the configured test tokens.'),
+            z.meta({ examples: [[]] }),
+          ),
+      }),
+      'Test tokens minted while funding the account.',
+    ),
+    'FundTestnetAccountResponse',
   )
 
   /** Faucet path parameters. */
@@ -103,10 +130,17 @@ export function faucet() {
       responses: OpenApi.responses({
         errors: {
           400: {
-            codes: ['api_key_malformed', 'body_invalid', 'param_invalid'],
+            codes: ['body_invalid', 'param_invalid'],
             description: 'The path or account address is invalid.',
           },
-          404: 'No accessible organization was found.',
+          404: {
+            codes: ['organization_not_found'],
+            description: 'No accessible organization was found.',
+          },
+          429: {
+            codes: ['rate_limit_exceeded'],
+            description: 'The user or account faucet limit was exceeded.',
+          },
         },
         success: {
           description: 'The account was funded.',

package/src/apps/management/routes/invitations.test.ts

@@ -70,6 +70,222 @@ async function session(app: ReturnType<typeof createApp>) {
   return { cookie: cookie!, userId: id }
 }
 
+test('publishes generator-ready OpenAPI contracts', async () => {
+  const spec = await (await createApp().request('/openapi.json')).json()
+  const collection = spec.paths['/v1/orgs/{orgId}/invitations']
+  const detail = spec.paths['/v1/orgs/{orgId}/invitations/{invitationId}']
+  const mine = spec.paths['/v1/invitations']
+  const accept = spec.paths['/v1/invitations/{invitationId}/accept'].post
+  const decline = spec.paths['/v1/invitations/{invitationId}/decline'].post
+
+  expect({
+    invitationList: spec.components.schemas.InvitationList.properties.data.examples,
+    myInvitation: spec.components.schemas.MyInvitation.description,
+    myInvitationList: spec.components.schemas.MyInvitationList.properties.data.examples,
+  }).toEqual({
+    invitationList: [[]],
+    myInvitation:
+      "One pending invitation addressed to the caller, with the inviting organization's name.",
+    myInvitationList: [[]],
+  })
+
+  expect({
+    components: [
+      'AcceptInvitationResponse',
+      'CreateInvitationRequest',
+      'DeclineInvitationResponse',
+      'Invitation',
+      'InvitationList',
+      'MyInvitation',
+      'MyInvitationList',
+      'RevokeInvitationResponse',
+    ].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,
+    },
+    formats: {
+      createdAt: spec.components.schemas.Invitation.properties.createdAt.format,
+      email: spec.components.schemas.Invitation.properties.email.format,
+      expiresAt: spec.components.schemas.Invitation.properties.expiresAt.format,
+    },
+    list: {
+      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,
+    },
+    recipientActions: {
+      accept: {
+        errors: {
+          400: accept.responses[400].content['application/json'].schema,
+          403: accept.responses[403].content['application/json'].schema,
+          404: accept.responses[404].content['application/json'].schema,
+        },
+        operationId: accept.operationId,
+        response: accept.responses[200].content['application/json'].schema,
+      },
+      decline: {
+        errors: {
+          400: decline.responses[400].content['application/json'].schema,
+          403: decline.responses[403].content['application/json'].schema,
+          404: decline.responses[404].content['application/json'].schema,
+        },
+        operationId: decline.operationId,
+        response: decline.responses[200].content['application/json'].schema,
+      },
+      list: {
+        errors: {
+          400: mine.get.responses[400].content['application/json'].schema,
+          403: mine.get.responses[403].content['application/json'].schema,
+        },
+        operationId: mine.get.operationId,
+        response: mine.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,
+    },
+  }).toMatchInlineSnapshot(`
+    {
+      "components": [
+        "AcceptInvitationResponse",
+        "CreateInvitationRequest",
+        "DeclineInvitationResponse",
+        "Invitation",
+        "InvitationList",
+        "MyInvitation",
+        "MyInvitationList",
+        "RevokeInvitationResponse",
+      ],
+      "create": {
+        "errors": {
+          "400": {
+            "$ref": "#/components/schemas/ApiKeyMalformedOrBodyInvalidOrParamInvalidError",
+          },
+          "403": {
+            "$ref": "#/components/schemas/ForbiddenError",
+          },
+          "404": {
+            "$ref": "#/components/schemas/OrganizationNotFoundError",
+          },
+        },
+        "operationId": "createInvitation",
+        "request": {
+          "$ref": "#/components/schemas/CreateInvitationRequest",
+        },
+        "response": {
+          "$ref": "#/components/schemas/Invitation",
+        },
+      },
+      "formats": {
+        "createdAt": "date-time",
+        "email": "email",
+        "expiresAt": "date-time",
+      },
+      "list": {
+        "errors": {
+          "400": {
+            "$ref": "#/components/schemas/ApiKeyMalformedOrParamInvalidError",
+          },
+          "403": {
+            "$ref": "#/components/schemas/ForbiddenError",
+          },
+          "404": {
+            "$ref": "#/components/schemas/OrganizationNotFoundError",
+          },
+        },
+        "operationId": "listInvitations",
+        "response": {
+          "$ref": "#/components/schemas/InvitationList",
+        },
+      },
+      "recipientActions": {
+        "accept": {
+          "errors": {
+            "400": {
+              "$ref": "#/components/schemas/ApiKeyMalformedOrParamInvalidError",
+            },
+            "403": {
+              "$ref": "#/components/schemas/ForbiddenError",
+            },
+            "404": {
+              "$ref": "#/components/schemas/InvitationNotFoundError",
+            },
+          },
+          "operationId": "acceptInvitation",
+          "response": {
+            "$ref": "#/components/schemas/AcceptInvitationResponse",
+          },
+        },
+        "decline": {
+          "errors": {
+            "400": {
+              "$ref": "#/components/schemas/ApiKeyMalformedOrParamInvalidError",
+            },
+            "403": {
+              "$ref": "#/components/schemas/ForbiddenError",
+            },
+            "404": {
+              "$ref": "#/components/schemas/InvitationNotFoundError",
+            },
+          },
+          "operationId": "declineInvitation",
+          "response": {
+            "$ref": "#/components/schemas/DeclineInvitationResponse",
+          },
+        },
+        "list": {
+          "errors": {
+            "400": {
+              "$ref": "#/components/schemas/ApiKeyMalformedError",
+            },
+            "403": {
+              "$ref": "#/components/schemas/ForbiddenError",
+            },
+          },
+          "operationId": "listMyInvitations",
+          "response": {
+            "$ref": "#/components/schemas/MyInvitationList",
+          },
+        },
+      },
+      "revoke": {
+        "errors": {
+          "400": {
+            "$ref": "#/components/schemas/ApiKeyMalformedOrParamInvalidError",
+          },
+          "403": {
+            "$ref": "#/components/schemas/ForbiddenError",
+          },
+          "404": {
+            "$ref": "#/components/schemas/InvitationNotFoundOrOrganizationNotFoundError",
+          },
+        },
+        "operationId": "revokeInvitation",
+        "response": {
+          "$ref": "#/components/schemas/RevokeInvitationResponse",
+        },
+      },
+    }
+  `)
+})
+
 describe('invitations', () => {
   test('lets management keys manage organization invitations', async () => {
     const db = TestApp.database()