tapimo 0.14.0 → 0.15.1

package/dist/apps/management/routes/orgs.d.ts

@@ -58,6 +58,19 @@ export declare namespace schema {
 export declare function orgs(): import("hono/hono-base").HonoBase<App.Environment, {
     "/v1/orgs": {
         $get: {
+            output: {
+                data: {
+                    createdAt: string;
+                    id: string;
+                    name: string;
+                    role?: "admin" | "member" | "owner" | undefined;
+                    updatedAt: string;
+                }[];
+            };
+            outputFormat: "json";
+            status: 200;
+            input: {};
+        } | {
             output: {
                 error: {
                     code: "api_key_malformed";
@@ -117,24 +130,26 @@ export declare function orgs(): import("hono/hono-base").HonoBase<App.Environmen
             outputFormat: "json";
             status: 502;
             input: {};
-        } | {
-            output: {
-                data: {
-                    createdAt: string;
-                    id: string;
-                    name: string;
-                    role?: "admin" | "member" | "owner" | undefined;
-                    updatedAt: string;
-                }[];
-            };
-            outputFormat: "json";
-            status: 200;
-            input: {};
         };
     };
 } & {
     "/v1/orgs": {
         $post: {
+            output: {
+                createdAt: string;
+                id: string;
+                name: string;
+                role?: "admin" | "member" | "owner" | undefined;
+                updatedAt: string;
+            };
+            outputFormat: "json";
+            status: 200;
+            input: {
+                json: {
+                    name: string;
+                };
+            };
+        } | {
             output: {
                 error: {
                     code: "api_key_malformed";
@@ -153,14 +168,14 @@ export declare function orgs(): import("hono/hono-base").HonoBase<App.Environmen
         } | {
             output: {
                 error: {
-                    code: "api_key_invalid" | "api_key_missing";
+                    code: "body_invalid";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 401;
+            status: 400;
             input: {
                 json: {
                     name: string;
@@ -169,14 +184,14 @@ export declare function orgs(): import("hono/hono-base").HonoBase<App.Environmen
         } | {
             output: {
                 error: {
-                    code: "upstream_error";
+                    code: "api_key_invalid" | "api_key_missing";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 502;
+            status: 401;
             input: {
                 json: {
                     name: string;
@@ -201,20 +216,24 @@ export declare function orgs(): import("hono/hono-base").HonoBase<App.Environmen
         } | {
             output: {
                 error: {
-                    code: "body_invalid";
+                    code: "upstream_error";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 400;
+            status: 502;
             input: {
                 json: {
                     name: string;
                 };
             };
-        } | {
+        };
+    };
+} & {
+    "/v1/orgs/:orgId{org_[A-Za-z0-9_-]+}": {
+        $get: {
             output: {
                 createdAt: string;
                 id: string;
@@ -225,15 +244,11 @@ export declare function orgs(): import("hono/hono-base").HonoBase<App.Environmen
             outputFormat: "json";
             status: 200;
             input: {
-                json: {
-                    name: string;
+                param: {
+                    orgId: string;
                 };
             };
-        };
-    };
-} & {
-    "/v1/orgs/:orgId{org_[A-Za-z0-9_-]+}": {
-        $get: {
+        } | {
             output: {
                 error: {
                     code: "api_key_malformed";
@@ -252,14 +267,14 @@ export declare function orgs(): import("hono/hono-base").HonoBase<App.Environmen
         } | {
             output: {
                 error: {
-                    code: "api_key_invalid" | "api_key_missing";
+                    code: "param_invalid";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 401;
+            status: 400;
             input: {
                 param: {
                     orgId: string;
@@ -268,14 +283,14 @@ export declare function orgs(): import("hono/hono-base").HonoBase<App.Environmen
         } | {
             output: {
                 error: {
-                    code: "api_key_forbidden" | "api_key_ip_forbidden";
+                    code: "api_key_invalid" | "api_key_missing";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 403;
+            status: 401;
             input: {
                 param: {
                     orgId: string;
@@ -284,14 +299,14 @@ export declare function orgs(): import("hono/hono-base").HonoBase<App.Environmen
         } | {
             output: {
                 error: {
-                    code: "payment_required" | "rate_limit_exceeded";
+                    code: "api_key_forbidden" | "api_key_ip_forbidden";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 429;
+            status: 403;
             input: {
                 param: {
                     orgId: string;
@@ -316,20 +331,24 @@ export declare function orgs(): import("hono/hono-base").HonoBase<App.Environmen
         } | {
             output: {
                 error: {
-                    code: "param_invalid";
+                    code: "payment_required" | "rate_limit_exceeded";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 400;
+            status: 429;
             input: {
                 param: {
                     orgId: string;
                 };
             };
-        } | {
+        };
+    };
+} & {
+    "/v1/orgs/:orgId{org_[A-Za-z0-9_-]+}": {
+        $patch: {
             output: {
                 createdAt: string;
                 id: string;
@@ -343,12 +362,12 @@ export declare function orgs(): import("hono/hono-base").HonoBase<App.Environmen
                 param: {
                     orgId: string;
                 };
+            } & {
+                json: {
+                    name: string;
+                };
             };
-        };
-    };
-} & {
-    "/v1/orgs/:orgId{org_[A-Za-z0-9_-]+}": {
-        $patch: {
+        } | {
             output: {
                 error: {
                     code: "api_key_malformed";
@@ -371,14 +390,14 @@ export declare function orgs(): import("hono/hono-base").HonoBase<App.Environmen
         } | {
             output: {
                 error: {
-                    code: "api_key_invalid" | "api_key_missing";
+                    code: "body_invalid";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 401;
+            status: 400;
             input: {
                 param: {
                     orgId: string;
@@ -391,14 +410,14 @@ export declare function orgs(): import("hono/hono-base").HonoBase<App.Environmen
         } | {
             output: {
                 error: {
-                    code: "api_key_forbidden" | "api_key_ip_forbidden";
+                    code: "param_invalid";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 403;
+            status: 400;
             input: {
                 param: {
                     orgId: string;
@@ -411,14 +430,14 @@ export declare function orgs(): import("hono/hono-base").HonoBase<App.Environmen
         } | {
             output: {
                 error: {
-                    code: "payment_required" | "rate_limit_exceeded";
+                    code: "api_key_invalid" | "api_key_missing";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 429;
+            status: 401;
             input: {
                 param: {
                     orgId: string;
@@ -431,14 +450,14 @@ export declare function orgs(): import("hono/hono-base").HonoBase<App.Environmen
         } | {
             output: {
                 error: {
-                    code: "upstream_error";
+                    code: "api_key_forbidden" | "api_key_ip_forbidden";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 502;
+            status: 403;
             input: {
                 param: {
                     orgId: string;
@@ -451,14 +470,14 @@ export declare function orgs(): import("hono/hono-base").HonoBase<App.Environmen
         } | {
             output: {
                 error: {
-                    code: "organization_not_found";
+                    code: "forbidden";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 404;
+            status: 403;
             input: {
                 param: {
                     orgId: string;
@@ -471,14 +490,14 @@ export declare function orgs(): import("hono/hono-base").HonoBase<App.Environmen
         } | {
             output: {
                 error: {
-                    code: "forbidden";
+                    code: "organization_not_found";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 403;
+            status: 404;
             input: {
                 param: {
                     orgId: string;
@@ -491,14 +510,14 @@ export declare function orgs(): import("hono/hono-base").HonoBase<App.Environmen
         } | {
             output: {
                 error: {
-                    code: "param_invalid";
+                    code: "payment_required" | "rate_limit_exceeded";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 400;
+            status: 429;
             input: {
                 param: {
                     orgId: string;
@@ -511,14 +530,14 @@ export declare function orgs(): import("hono/hono-base").HonoBase<App.Environmen
         } | {
             output: {
                 error: {
-                    code: "body_invalid";
+                    code: "upstream_error";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 400;
+            status: 502;
             input: {
                 param: {
                     orgId: string;
@@ -528,13 +547,13 @@ export declare function orgs(): import("hono/hono-base").HonoBase<App.Environmen
                     name: string;
                 };
             };
-        } | {
+        };
+    };
+} & {
+    "/v1/orgs/:orgId{org_[A-Za-z0-9_-]+}": {
+        $delete: {
             output: {
-                createdAt: string;
                 id: string;
-                name: string;
-                role?: "admin" | "member" | "owner" | undefined;
-                updatedAt: string;
             };
             outputFormat: "json";
             status: 200;
@@ -542,16 +561,8 @@ export declare function orgs(): import("hono/hono-base").HonoBase<App.Environmen
                 param: {
                     orgId: string;
                 };
-            } & {
-                json: {
-                    name: string;
-                };
             };
-        };
-    };
-} & {
-    "/v1/orgs/:orgId{org_[A-Za-z0-9_-]+}": {
-        $delete: {
+        } | {
             output: {
                 error: {
                     code: "api_key_malformed";
@@ -570,14 +581,14 @@ export declare function orgs(): import("hono/hono-base").HonoBase<App.Environmen
         } | {
             output: {
                 error: {
-                    code: "api_key_invalid" | "api_key_missing";
+                    code: "param_invalid";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 401;
+            status: 400;
             input: {
                 param: {
                     orgId: string;
@@ -586,14 +597,14 @@ export declare function orgs(): import("hono/hono-base").HonoBase<App.Environmen
         } | {
             output: {
                 error: {
-                    code: "api_key_forbidden" | "api_key_ip_forbidden";
+                    code: "api_key_invalid" | "api_key_missing";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 403;
+            status: 401;
             input: {
                 param: {
                     orgId: string;
@@ -602,14 +613,14 @@ export declare function orgs(): import("hono/hono-base").HonoBase<App.Environmen
         } | {
             output: {
                 error: {
-                    code: "payment_required" | "rate_limit_exceeded";
+                    code: "api_key_forbidden" | "api_key_ip_forbidden";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 429;
+            status: 403;
             input: {
                 param: {
                     orgId: string;
@@ -618,14 +629,14 @@ export declare function orgs(): import("hono/hono-base").HonoBase<App.Environmen
         } | {
             output: {
                 error: {
-                    code: "upstream_error";
+                    code: "forbidden";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 502;
+            status: 403;
             input: {
                 param: {
                     orgId: string;
@@ -650,14 +661,14 @@ export declare function orgs(): import("hono/hono-base").HonoBase<App.Environmen
         } | {
             output: {
                 error: {
-                    code: "forbidden";
+                    code: "sponsorships_unreported";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 403;
+            status: 409;
             input: {
                 param: {
                     orgId: string;
@@ -666,14 +677,14 @@ export declare function orgs(): import("hono/hono-base").HonoBase<App.Environmen
         } | {
             output: {
                 error: {
-                    code: "param_invalid";
+                    code: "routes_deposit_addresses_active";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 400;
+            status: 409;
             input: {
                 param: {
                     orgId: string;
@@ -682,14 +693,14 @@ export declare function orgs(): import("hono/hono-base").HonoBase<App.Environmen
         } | {
             output: {
                 error: {
-                    code: "sponsorships_unreported";
+                    code: "payment_required" | "rate_limit_exceeded";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 409;
+            status: 429;
             input: {
                 param: {
                     orgId: string;
@@ -697,10 +708,15 @@ export declare function orgs(): import("hono/hono-base").HonoBase<App.Environmen
             };
         } | {
             output: {
-                id: string;
+                error: {
+                    code: "upstream_error";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
             };
             outputFormat: "json";
-            status: 200;
+            status: 502;
             input: {
                 param: {
                     orgId: string;

package/dist/apps/management/routes/orgs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"orgs.d.ts","sourceRoot":"","sources":["../../../../src/apps/management/routes/orgs.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAG7B,OAAO,KAAK,KAAK,GAAG,MAAM,iBAAiB,CAAA;AAO3C,OAAO,KAAK,QAAQ,MAAM,+BAA+B,CAAA;AAIzD,uDAAuD;AACvD,yBAAiB,MAAM,CAAC;IAUtB,iEAAiE;IAC1D,MAAM,YAAY;;;;;;;;;;qBAqCxB,CAAA;IAED,6CAA6C;IACtC,MAAM,yBAAyB;;qBAGrC,CAAA;IAED,6CAA6C;IACtC,MAAM,yBAAyB;;qBAGrC,CAAA;IAED,mDAAmD;IAC5C,MAAM,MAAM;;qBAS0C,CAAA;IAE7D,oDAAoD;IACpD,UAAiB,kBAAkB,CAAC;QAClC,sDAAsD;QAC/C,MAAM,QAAQ;;yBAYpB,CAAA;KACF;IAED,mDAAmD;IACnD,UAAiB,iBAAiB,CAAC;QACjC,2CAA2C;QACpC,MAAM,QAAQ;;;;;;;;;;;;yBAQpB,CAAA;KACF;CACF;AAED;;GAEG;AACH,wBAAgB,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+CA8QnB"}
+{"version":3,"file":"orgs.d.ts","sourceRoot":"","sources":["../../../../src/apps/management/routes/orgs.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAG7B,OAAO,KAAK,KAAK,GAAG,MAAM,iBAAiB,CAAA;AAS3C,OAAO,KAAK,QAAQ,MAAM,+BAA+B,CAAA;AAKzD,uDAAuD;AACvD,yBAAiB,MAAM,CAAC;IAUtB,iEAAiE;IAC1D,MAAM,YAAY;;;;;;;;;;qBAqCxB,CAAA;IAED,6CAA6C;IACtC,MAAM,yBAAyB;;qBAGrC,CAAA;IAED,6CAA6C;IACtC,MAAM,yBAAyB;;qBAGrC,CAAA;IAED,mDAAmD;IAC5C,MAAM,MAAM;;qBAS0C,CAAA;IAE7D,oDAAoD;IACpD,UAAiB,kBAAkB,CAAC;QAClC,sDAAsD;QAC/C,MAAM,QAAQ;;yBAYpB,CAAA;KACF;IAED,mDAAmD;IACnD,UAAiB,iBAAiB,CAAC;QACjC,2CAA2C;QACpC,MAAM,QAAQ;;;;;;;;;;;;yBAQpB,CAAA;KACF;CACF;AAED;;GAEG;AACH,wBAAgB,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+CAgTnB"}

package/dist/apps/management/routes/orgs.js

@@ -1,13 +1,17 @@
 import { Hono } from 'hono';
+import * as pg from 'pg';
 import * as z from 'zod/mini';
 import * as ApiKeys from '../../../ApiKeys.js';
 import * as Auth from '../../../internal/Auth.js';
 import * as Db from '../../../db/Db.js';
 import * as EarlyAccess from '../../../db/tables/earlyAccess.js';
 import * as Memberships from '../../../db/tables/memberships.js';
+import * as RoutesDepositAddresses from '../../../db/tables/routesDepositAddresses.js';
+import * as RoutesIdempotency from '../../../db/tables/routesIdempotency.js';
 import * as OpenApi from '../../../internal/OpenApi.js';
 import * as Organizations from '../../../db/tables/organizations.js';
 import * as Response from '../../../internal/Response.js';
+import * as RoutesObservability from '../../../internal/routes/Observability.js';
 import * as Schema from '../../../internal/Schema.js';
 import * as ManagementError from '../Error.js';
 /** Zod schemas owned by the organizations resource. */
@@ -146,6 +150,9 @@ export function orgs() {
                             : [],
                         name: body.name,
                         userId: principal.id,
+                        ...(principal.identity.provider === 'wallet'
+                            ? { walletAddress: principal.identity.subject }
+                            : {}),
                     })),
                     role: 'owner',
                 };
@@ -250,8 +257,8 @@ export function orgs() {
                     description: 'No accessible organization was found for this id.',
                 },
                 409: {
-                    codes: ['sponsorships_unreported'],
-                    description: 'Billable sponsorships are still awaiting settlement.',
+                    codes: ['routes_deposit_addresses_active', 'sponsorships_unreported'],
+                    description: 'Billable usage is awaiting settlement, address provisioning is active, or an irrevocable subsidized address remains at its provider.',
                 },
             },
             success: {
@@ -275,22 +282,48 @@ export function orgs() {
             });
         const db = Db.get(c.get('db'));
         try {
-            if (await Organizations.hasUnreportedSponsorships(db, Auth.org(c).id))
+            if (await Organizations.hasUnreportedMeteredUsage(db, Auth.org(c).id))
                 return sponsorshipsUnreported(c);
-            const kv = c.get('kv');
-            if (kv)
-                for (const record of await ApiKeys.listByOrg(kv.store, Auth.org(c).id, {
-                    scopeCatalog: c.get('scopeCatalog'),
-                }))
-                    await ApiKeys.revoke(kv.store, record.id);
-            const deleted = await Organizations.deleteOrganization(db, Auth.org(c).id);
+            if (await RoutesIdempotency.hasUnattributedInFlightClaim(db))
+                return subsidizedDepositAddressesActive(c);
+            if (await RoutesIdempotency.hasInFlightDepositAddress(db, Auth.org(c).id))
+                return subsidizedDepositAddressesActive(c);
+            if (await RoutesDepositAddresses.hasSubsidizedRelayAddress(db, Auth.org(c).id))
+                return subsidizedDepositAddressesActive(c);
+            const deleted = await Organizations.deleteOrganization(db, Auth.org(c).id, {
+                onDepositAddressesDeactivated(transitions) {
+                    for (const transition of transitions)
+                        RoutesObservability.recordDepositAddress(c.get('metrics'), transition);
+                },
+            });
             if (!deleted)
                 return organizationNotFound(c);
+            const kv = c.get('kv');
+            if (kv)
+                try {
+                    await ApiKeys.markOwnerDeleting(kv.store, { orgId: Auth.org(c).id });
+                    for (const record of await ApiKeys.listByOrg(kv.store, Auth.org(c).id, {
+                        scopeCatalog: c.get('scopeCatalog'),
+                    }))
+                        await ApiKeys.revoke(kv.store, record.id);
+                }
+                catch (cause) {
+                    console.error('Organization API-key KV cleanup failed after deletion committed.', cause);
+                }
             return c.json(Response.validated(schema.deleteOrganization.Response, { id: Auth.org(c).id }), 200);
         }
         catch (cause) {
-            if (cause instanceof Organizations.UnreportedSponsorshipsError)
+            if (cause instanceof Organizations.UnreportedMeteredUsageError)
                 return sponsorshipsUnreported(c);
+            if (cause instanceof Organizations.IrrevocableDepositAddressError)
+                return subsidizedDepositAddressesActive(c);
+            if (cause instanceof pg.DatabaseError &&
+                cause.code === '23503' &&
+                [
+                    'organization has active route deposit address work',
+                    'route lifecycle rollout drain is active',
+                ].includes(cause.message))
+                return subsidizedDepositAddressesActive(c);
             return Response.upstream(c, cause);
         }
     });
@@ -298,7 +331,14 @@ export function orgs() {
 function sponsorshipsUnreported(c) {
     return Response.error(c, {
         code: 'sponsorships_unreported',
-        message: 'Billable sponsorships are still awaiting settlement',
+        message: 'Billable metered usage is still awaiting settlement',
+        status: 409,
+    });
+}
+function subsidizedDepositAddressesActive(c) {
+    return Response.error(c, {
+        code: 'routes_deposit_addresses_active',
+        message: 'Delete is blocked while address provisioning is active or an irrevocable subsidized Relay address exists.',
         status: 409,
     });
 }