tapimo 0.2.0 → 0.3.0

package/dist/apps/platform/routes/scopes.js

@@ -0,0 +1,66 @@
+import { Hono } from 'hono';
+import * as z from 'zod/mini';
+import * as Auth from '../../../internal/Auth.js';
+import * as Cache from '../../../internal/Cache.js';
+import * as OpenApi from '../../../internal/OpenApi.js';
+import * as Response from '../../../internal/Response.js';
+import * as Scope from '../../../Scope.js';
+/** Zod schemas owned by the scope-catalog resource. */
+export var schema;
+(function (schema) {
+    /** Schemas for the getScopes operation. */
+    let getScopes;
+    (function (getScopes) {
+        /** A single issuable API-key scope. */
+        getScopes.Entry = z
+            .object({
+            description: z
+                .string()
+                .check(z.describe('Human-readable explanation of what the scope grants.'), z.meta({ examples: ['Read webhook subscriptions.'] })),
+            scope: z
+                .enum(Scope.catalog.map((entry) => entry.scope))
+                .check(z.describe('Scope identifier used in API-key grants and route policies.'), z.meta({ examples: ['data:read'] })),
+            selfServe: z
+                .boolean()
+                .check(z.describe('Whether a session may self-mint this scope (else super-admin-only).'), z.meta({ examples: [true] })),
+        })
+            .check(z.describe('A single issuable API-key scope.'));
+        /** Response body for the scope catalog. */
+        getScopes.Response = z
+            .object({
+            data: z.array(getScopes.Entry).check(z.describe('Issuable API-key scopes.')),
+        })
+            .check(z.describe('Response body for the scope catalog.'));
+    })(getScopes = schema.getScopes || (schema.getScopes = {}));
+})(schema || (schema = {}));
+/**
+ * Mounts the `/scopes` resource: the issuable API-key scope vocabulary, served
+ * from {@link Scope.catalog}. Public catalog data: anonymous callers are served
+ * within the public quota; the session lane lets signed-in consoles skip it.
+ */
+export function scopes() {
+    return new Hono().get('/v1/scopes', Auth.policy({ public: true, session: true }), OpenApi.describeRoute({
+        description: 'See which scopes can be granted to API keys.',
+        operationId: 'getScopes',
+        responses: OpenApi.responses({
+            success: { description: 'Issuable scope catalog.', schema: schema.getScopes.Response },
+        }),
+        summary: 'List scopes',
+        tags: ['API Keys'],
+    }), Cache.response({
+        cacheControl: Cache.policies.stable,
+        name: 'tempo-api:scopes:v1',
+        key: (c) => {
+            const url = new URL(c.req.url);
+            url.search = '';
+            return url.toString();
+        },
+    }), (c) => {
+        if (Auth.narrowAccess)
+            return Auth.accessError(c);
+        return c.json(Response.validated(schema.getScopes.Response, {
+            data: Scope.catalog.map((entry) => ({ ...entry })),
+        }), 200);
+    });
+}
+//# sourceMappingURL=scopes.js.map

package/dist/apps/platform/routes/scopes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scopes.js","sourceRoot":"","sources":["../../../../src/apps/platform/routes/scopes.ts"],"names":[],"mappings":"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"}

package/dist/apps/platform/routes/usage.d.ts

@@ -0,0 +1,588 @@
+import * as z from 'zod/mini';
+import * as Response from '../../../internal/Response.js';
+import type { Environment } from '../App.js';
+/** Zod schemas owned by the usage resource. */
+export declare namespace schema {
+    /** Schemas for the getRequestUsage operation. */
+    namespace getRequestUsage {
+        /** Usage grouped by API key. */
+        const KeyBreakdown: z.ZodMiniObject<{
+            apiKeyId: z.ZodMiniString<string>;
+            averageDurationMs: z.ZodMiniNumber<number>;
+            errors: z.ZodMiniNumber<number>;
+            requests: z.ZodMiniNumber<number>;
+        }, z.core.$strip>;
+        /** Path parameters addressing one organization's usage. */
+        const Params: z.ZodMiniObject<{
+            orgId: z.ZodMiniString<string>;
+        }, z.core.$strip>;
+        /** Query parameters for request usage. */
+        const Query: z.ZodMiniObject<{
+            environment: z.ZodMiniOptional<z.ZodMiniEnum<{
+                production: "production";
+                sandbox: "sandbox";
+            }>>;
+            from: z.ZodMiniOptional<z.ZodMiniISODateTime>;
+            interval: z.ZodMiniDefault<z.ZodMiniEnum<{
+                day: "day";
+                hour: "hour";
+            }>>;
+            projectId: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            to: z.ZodMiniOptional<z.ZodMiniISODateTime>;
+        }, z.core.$strict>;
+        /** Usage grouped by route. */
+        const RouteBreakdown: z.ZodMiniObject<{
+            averageDurationMs: z.ZodMiniNumber<number>;
+            errors: z.ZodMiniNumber<number>;
+            requests: z.ZodMiniNumber<number>;
+            route: z.ZodMiniString<string>;
+        }, z.core.$strip>;
+        /** One usage series point. */
+        const SeriesPoint: z.ZodMiniObject<{
+            errors: z.ZodMiniNumber<number>;
+            requests: z.ZodMiniNumber<number>;
+            time: z.ZodMiniString<string>;
+        }, z.core.$strip>;
+        /** Usage grouped by status code. */
+        const StatusBreakdown: z.ZodMiniObject<{
+            requests: z.ZodMiniNumber<number>;
+            status: z.ZodMiniNumber<number>;
+        }, z.core.$strip>;
+        /** Overall usage totals. */
+        const Totals: z.ZodMiniObject<{
+            averageDurationMs: z.ZodMiniNumber<number>;
+            errors: z.ZodMiniNumber<number>;
+            requests: z.ZodMiniNumber<number>;
+        }, z.core.$strip>;
+        /** Request usage. */
+        const Response: z.ZodMiniObject<{
+            byKey: z.ZodMiniArray<z.ZodMiniObject<{
+                apiKeyId: z.ZodMiniString<string>;
+                averageDurationMs: z.ZodMiniNumber<number>;
+                errors: z.ZodMiniNumber<number>;
+                requests: z.ZodMiniNumber<number>;
+            }, z.core.$strip>>;
+            byRoute: z.ZodMiniArray<z.ZodMiniObject<{
+                averageDurationMs: z.ZodMiniNumber<number>;
+                errors: z.ZodMiniNumber<number>;
+                requests: z.ZodMiniNumber<number>;
+                route: z.ZodMiniString<string>;
+            }, z.core.$strip>>;
+            byStatus: z.ZodMiniArray<z.ZodMiniObject<{
+                requests: z.ZodMiniNumber<number>;
+                status: z.ZodMiniNumber<number>;
+            }, z.core.$strip>>;
+            from: z.ZodMiniString<string>;
+            interval: z.ZodMiniEnum<{
+                day: "day";
+                hour: "hour";
+            }>;
+            series: z.ZodMiniArray<z.ZodMiniObject<{
+                errors: z.ZodMiniNumber<number>;
+                requests: z.ZodMiniNumber<number>;
+                time: z.ZodMiniString<string>;
+            }, z.core.$strip>>;
+            to: z.ZodMiniString<string>;
+            totals: z.ZodMiniObject<{
+                averageDurationMs: z.ZodMiniNumber<number>;
+                errors: z.ZodMiniNumber<number>;
+                requests: z.ZodMiniNumber<number>;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+    }
+    /** Schemas for the getSponsorshipUsage operation. */
+    namespace getSponsorshipUsage {
+        /** One time bucket of sponsorship usage. */
+        const Bucket: z.ZodMiniObject<{
+            count: z.ZodMiniNumber<number>;
+            feeTotal: z.ZodMiniObject<{
+                amount: z.ZodMiniString<string>;
+                currency: z.ZodMiniEnum<{
+                    usd: "usd";
+                }>;
+            }, z.core.$strip>;
+            timestamp: z.ZodMiniString<string>;
+        }, z.core.$strip>;
+        /** Path parameters addressing one organization's usage. */
+        const Params: z.ZodMiniObject<{
+            orgId: z.ZodMiniString<string>;
+        }, z.core.$strip>;
+        /** Query parameters scoping the sponsorship usage series. */
+        const Query: z.ZodMiniObject<{
+            environment: z.ZodMiniOptional<z.ZodMiniEnum<{
+                production: "production";
+                sandbox: "sandbox";
+            }>>;
+            from: z.ZodMiniOptional<z.ZodMiniISODateTime>;
+            interval: z.ZodMiniDefault<z.ZodMiniEnum<{
+                day: "day";
+                hour: "hour";
+                month: "month";
+                week: "week";
+            }>>;
+            projectId: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            to: z.ZodMiniOptional<z.ZodMiniISODateTime>;
+        }, z.core.$strict>;
+        /** Sponsorship usage bucketed over time. */
+        const Response: z.ZodMiniObject<{
+            data: z.ZodMiniArray<z.ZodMiniObject<{
+                count: z.ZodMiniNumber<number>;
+                feeTotal: z.ZodMiniObject<{
+                    amount: z.ZodMiniString<string>;
+                    currency: z.ZodMiniEnum<{
+                        usd: "usd";
+                    }>;
+                }, z.core.$strip>;
+                timestamp: z.ZodMiniString<string>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    }
+}
+/**
+ * Mounts the usage surface: project request usage (read from a host-supplied
+ * analytics capability) and an organization's sponsorship volume and fees
+ * over time. Session lane; reads for members.
+ */
+export declare function usage(): import("hono/hono-base").HonoBase<Environment, {
+    "/v1/orgs/:orgId{org_[A-Za-z0-9_-]+}/usage/requests": {
+        $get: {
+            output: {
+                error: {
+                    code: "api_key_malformed";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 400;
+            input: {
+                param: {
+                    orgId: string;
+                };
+            } & {
+                query?: {
+                    environment?: string | string[];
+                    from?: string | string[];
+                    interval?: string | string[];
+                    projectId?: string | string[];
+                    to?: string | string[];
+                } | undefined;
+            };
+        } | {
+            output: {
+                error: {
+                    code: "api_key_invalid" | "api_key_missing";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 401;
+            input: {
+                param: {
+                    orgId: string;
+                };
+            } & {
+                query?: {
+                    environment?: string | string[];
+                    from?: string | string[];
+                    interval?: string | string[];
+                    projectId?: string | string[];
+                    to?: string | string[];
+                } | undefined;
+            };
+        } | {
+            output: {
+                error: {
+                    code: "query_invalid";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 400;
+            input: {
+                param: {
+                    orgId: string;
+                };
+            } & {
+                query?: {
+                    environment?: string | string[];
+                    from?: string | string[];
+                    interval?: string | string[];
+                    projectId?: string | string[];
+                    to?: string | string[];
+                } | undefined;
+            };
+        } | {
+            output: {
+                error: {
+                    code: "upstream_error";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 502;
+            input: {
+                param: {
+                    orgId: string;
+                };
+            } & {
+                query?: {
+                    environment?: string | string[];
+                    from?: string | string[];
+                    interval?: string | string[];
+                    projectId?: string | string[];
+                    to?: string | string[];
+                } | undefined;
+            };
+        } | {
+            output: {
+                error: {
+                    code: "param_invalid";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 400;
+            input: {
+                param: {
+                    orgId: string;
+                };
+            } & {
+                query?: {
+                    environment?: string | string[];
+                    from?: string | string[];
+                    interval?: string | string[];
+                    projectId?: string | string[];
+                    to?: string | string[];
+                } | undefined;
+            };
+        } | {
+            output: {
+                error: {
+                    code: "forbidden";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 403;
+            input: {
+                param: {
+                    orgId: string;
+                };
+            } & {
+                query?: {
+                    environment?: string | string[];
+                    from?: string | string[];
+                    interval?: string | string[];
+                    projectId?: string | string[];
+                    to?: string | string[];
+                } | undefined;
+            };
+        } | {
+            output: {
+                error: {
+                    code: "organization_not_found";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 404;
+            input: {
+                param: {
+                    orgId: string;
+                };
+            } & {
+                query?: {
+                    environment?: string | string[];
+                    from?: string | string[];
+                    interval?: string | string[];
+                    projectId?: string | string[];
+                    to?: string | string[];
+                } | undefined;
+            };
+        } | {
+            output: {
+                error: {
+                    code: "analytics_unconfigured";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 501;
+            input: {
+                param: {
+                    orgId: string;
+                };
+            } & {
+                query?: {
+                    environment?: string | string[];
+                    from?: string | string[];
+                    interval?: string | string[];
+                    projectId?: string | string[];
+                    to?: string | string[];
+                } | undefined;
+            };
+        } | {
+            output: {
+                byKey: {
+                    apiKeyId: string;
+                    averageDurationMs: number;
+                    errors: number;
+                    requests: number;
+                }[];
+                byRoute: {
+                    averageDurationMs: number;
+                    errors: number;
+                    requests: number;
+                    route: string;
+                }[];
+                byStatus: {
+                    requests: number;
+                    status: number;
+                }[];
+                from: string;
+                interval: "day" | "hour";
+                series: {
+                    errors: number;
+                    requests: number;
+                    time: string;
+                }[];
+                to: string;
+                totals: {
+                    averageDurationMs: number;
+                    errors: number;
+                    requests: number;
+                };
+            };
+            outputFormat: "json";
+            status: 200;
+            input: {
+                param: {
+                    orgId: string;
+                };
+            } & {
+                query?: {
+                    environment?: string | string[];
+                    from?: string | string[];
+                    interval?: string | string[];
+                    projectId?: string | string[];
+                    to?: string | string[];
+                } | undefined;
+            };
+        };
+    };
+} & {
+    "/v1/orgs/:orgId{org_[A-Za-z0-9_-]+}/usage/sponsorships": {
+        $get: {
+            output: {
+                error: {
+                    code: "api_key_malformed";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 400;
+            input: {
+                param: {
+                    orgId: string;
+                };
+            } & {
+                query?: {
+                    environment?: string | string[];
+                    from?: string | string[];
+                    interval?: string | string[];
+                    projectId?: string | string[];
+                    to?: string | string[];
+                } | undefined;
+            };
+        } | {
+            output: {
+                error: {
+                    code: "api_key_invalid" | "api_key_missing";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 401;
+            input: {
+                param: {
+                    orgId: string;
+                };
+            } & {
+                query?: {
+                    environment?: string | string[];
+                    from?: string | string[];
+                    interval?: string | string[];
+                    projectId?: string | string[];
+                    to?: string | string[];
+                } | undefined;
+            };
+        } | {
+            output: {
+                error: {
+                    code: "query_invalid";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 400;
+            input: {
+                param: {
+                    orgId: string;
+                };
+            } & {
+                query?: {
+                    environment?: string | string[];
+                    from?: string | string[];
+                    interval?: string | string[];
+                    projectId?: string | string[];
+                    to?: string | string[];
+                } | undefined;
+            };
+        } | {
+            output: {
+                error: {
+                    code: "upstream_error";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 502;
+            input: {
+                param: {
+                    orgId: string;
+                };
+            } & {
+                query?: {
+                    environment?: string | string[];
+                    from?: string | string[];
+                    interval?: string | string[];
+                    projectId?: string | string[];
+                    to?: string | string[];
+                } | undefined;
+            };
+        } | {
+            output: {
+                error: {
+                    code: "param_invalid";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 400;
+            input: {
+                param: {
+                    orgId: string;
+                };
+            } & {
+                query?: {
+                    environment?: string | string[];
+                    from?: string | string[];
+                    interval?: string | string[];
+                    projectId?: string | string[];
+                    to?: string | string[];
+                } | undefined;
+            };
+        } | {
+            output: {
+                error: {
+                    code: "forbidden";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 403;
+            input: {
+                param: {
+                    orgId: string;
+                };
+            } & {
+                query?: {
+                    environment?: string | string[];
+                    from?: string | string[];
+                    interval?: string | string[];
+                    projectId?: string | string[];
+                    to?: string | string[];
+                } | undefined;
+            };
+        } | {
+            output: {
+                error: {
+                    code: "organization_not_found";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 404;
+            input: {
+                param: {
+                    orgId: string;
+                };
+            } & {
+                query?: {
+                    environment?: string | string[];
+                    from?: string | string[];
+                    interval?: string | string[];
+                    projectId?: string | string[];
+                    to?: string | string[];
+                } | undefined;
+            };
+        } | {
+            output: {
+                data: {
+                    count: number;
+                    feeTotal: {
+                        amount: string;
+                        currency: "usd";
+                    };
+                    timestamp: string;
+                }[];
+            };
+            outputFormat: "json";
+            status: 200;
+            input: {
+                param: {
+                    orgId: string;
+                };
+            } & {
+                query?: {
+                    environment?: string | string[];
+                    from?: string | string[];
+                    interval?: string | string[];
+                    projectId?: string | string[];
+                    to?: string | string[];
+                } | undefined;
+            };
+        };
+    };
+}, "/", "/v1/orgs/:orgId{org_[A-Za-z0-9_-]+}/usage/sponsorships">;
+//# sourceMappingURL=usage.d.ts.map

package/dist/apps/platform/routes/usage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usage.d.ts","sourceRoot":"","sources":["../../../../src/apps/platform/routes/usage.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAS7B,OAAO,KAAK,QAAQ,MAAM,+BAA+B,CAAA;AAIzD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAE5C,+CAA+C;AAC/C,yBAAiB,MAAM,CAAC;IACtB,iDAAiD;IACjD,UAAiB,eAAe,CAAC;QAC/B,gCAAgC;QACzB,MAAM,YAAY;;;;;yBAqBwB,CAAA;QAEjD,2DAA2D;QACpD,MAAM,MAAM;;yBASiD,CAAA;QAEpE,0CAA0C;QACnC,MAAM,KAAK;;;;;;;;;;;;0BA4ByC,CAAA;QAE3D,8BAA8B;QACvB,MAAM,cAAc;;;;;yBAqBoB,CAAA;QAE/C,8BAA8B;QACvB,MAAM,WAAW;;;;yBAeuB,CAAA;QAE/C,oCAAoC;QAC7B,MAAM,eAAe;;;yBASyB,CAAA;QAErD,4BAA4B;QACrB,MAAM,MAAM;;;;yBAe0B,CAAA;QAE7C,qBAAqB;QACd,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBA2BpB,CAAA;KACF;IAED,qDAAqD;IACrD,UAAiB,mBAAmB,CAAC;QACnC,4CAA4C;QACrC,MAAM,MAAM;;;;;;;;;yBA8BlB,CAAA;QAED,2DAA2D;QACpD,MAAM,MAAM;;yBASkD,CAAA;QAErE,6DAA6D;QACtD,MAAM,KAAK;;;;;;;;;;;;;;0BAiC4D,CAAA;QAE9E,4CAA4C;QACrC,MAAM,QAAQ;;;;;;;;;;;yBASpB,CAAA;KACF;CACF;AAED;;;;GAIG;AACH,wBAAgB,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kEA2LpB"}