@di-framework/tenant-cli 0.0.0-stage → 6.0.9

package/dist/client/index.d.ts

@@ -0,0 +1,135 @@
+import type { components, operations } from './schema.js';
+export { events, type SseEvent } from './sse.js';
+type Json<Op extends keyof operations, Status extends number> = operations[Op]['responses'] extends {
+    [S in Status]: {
+        content: {
+            'application/json': infer T;
+        };
+    };
+} ? T : never;
+type Body<Op extends keyof operations> = operations[Op] extends {
+    requestBody: {
+        content: {
+            'application/json': infer T;
+        };
+    };
+} ? T : never;
+type Query<Op extends keyof operations> = operations[Op]['parameters'] extends {
+    query: infer Q;
+} ? Q : never;
+export type Env = Query<'deployments'>['env'];
+export type AuthInfo = components['schemas']['AuthInfo'];
+export type Principal = components['schemas']['Principal'];
+export type DeployBundle = Body<'deploy'>;
+export type DeployPlan = Json<'previewDeploy', 200>;
+export type Deployment = Json<'deploy', 202>;
+export type DeploymentList = Json<'deployments', 200>;
+export type DeploymentStats = Json<'deploymentStats', 200>;
+export type RollbackRequest = Body<'rollback'>;
+export type CreateServiceRequest = Body<'createService'>;
+export type Service = Json<'createService', 201>;
+export type LogEvent = Json<'logs', 200>;
+export type LogsQuery = Query<'logs'>;
+export type SecretList = Json<'secrets', 200>;
+export type ConfigList = Json<'vars', 200>;
+export type ProxyRequest = Body<'proxy'>;
+export type ProxySession = Json<'proxy', 201>;
+export type Problem = components['schemas']['Problem'];
+/** A non-2xx answer from the controller, carrying its problem details when it sent any. */
+export declare class ControllerError extends Error {
+    readonly status: number;
+    readonly problem: Partial<Problem>;
+    constructor(status: number, problem: Partial<Problem>);
+}
+export interface ClientOptions {
+    /** The controller's base URL, without a trailing slash. */
+    baseUrl: string;
+    /** Identity-server access token or tenant API key; absent only for `authInfo`. */
+    token?: string;
+    fetch?: typeof fetch;
+}
+export declare function createClient(options: ClientOptions): {
+    authInfo: () => Promise<{
+        account: string;
+        issuer: string;
+        clientId: string;
+    }>;
+    whoami: () => Promise<{
+        user: string;
+        account: string;
+        role: "developer" | "viewer";
+        via: "identity" | "api-key";
+        credentialId?: string;
+    }>;
+    logout: () => Promise<void>;
+    previewDeploy: (bundle: DeployBundle) => Promise<{
+        env: "prod" | "staging";
+        service: string;
+        changes: components["schemas"]["DeployChange"][];
+    }>;
+    deploy: (bundle: DeployBundle) => Promise<{
+        id: string;
+        service: string;
+        env: "prod" | "staging";
+        status: "pending" | "rolling" | "ready" | "failed" | "rolled-back";
+        component: components["schemas"]["ComponentReference"];
+        createdAt: string;
+        readyAt?: string;
+    }>;
+    createService: (request: CreateServiceRequest) => Promise<{
+        name: string;
+        env: "prod" | "staging";
+        type: "keyvalue" | "messaging" | "blobstore" | "postgres" | "egress";
+        className: string;
+        parameters?: {
+            storage?: string;
+            memory?: string;
+            cpu?: string;
+        };
+        deletionPolicy?: "Retain" | "Delete";
+        destinations?: string[];
+        createdAt: string;
+    }>;
+    proxy: (service: string, request: ProxyRequest) => Promise<{
+        url: string;
+        port: number;
+        expiresAt: string;
+    }>;
+    /** Yields one LogEvent per `log` event until the server sends `end` or the stream closes. */
+    logs(service: string, query: LogsQuery): AsyncGenerator<LogEvent>;
+    deployments: (query: Query<"deployments">) => Promise<{
+        items: components["schemas"]["Deployment"][];
+    }>;
+    deploymentStats: (env: Env) => Promise<{
+        env: "prod" | "staging";
+        services: number;
+        deployments: number;
+        ready: number;
+        failed: number;
+        lastDeployedAt?: string;
+    }>;
+    rollback: (request: RollbackRequest) => Promise<{
+        id: string;
+        service: string;
+        env: "prod" | "staging";
+        status: "pending" | "rolling" | "ready" | "failed" | "rolled-back";
+        component: components["schemas"]["ComponentReference"];
+        createdAt: string;
+        readyAt?: string;
+    }>;
+    secrets: (env: Env) => Promise<{
+        env: "prod" | "staging";
+        items: components["schemas"]["SecretEntry"][];
+    }>;
+    setSecret: (env: Env, name: string, value: string) => Promise<void>;
+    updateSecret: (env: Env, name: string, value: string) => Promise<void>;
+    unsetSecret: (env: Env, name: string) => Promise<void>;
+    vars: (env: Env) => Promise<{
+        env: "prod" | "staging";
+        items: components["schemas"]["ConfigEntry"][];
+    }>;
+    setVar: (env: Env, name: string, value: string) => Promise<void>;
+    updateVar: (env: Env, name: string, value: string) => Promise<void>;
+    unsetVar: (env: Env, name: string) => Promise<void>;
+};
+export type TenantClient = ReturnType<typeof createClient>;

package/dist/client/index.js

@@ -0,0 +1,131 @@
+import { events } from './sse.js';
+export { events } from './sse.js';
+/**
+ * Every path the client calls, checked against the generated `paths` at compile time: an
+ * operation that leaves the contract stops the client from building.
+ */
+const PATHS = {
+    authInfo: '/v1/auth/info',
+    whoami: '/v1/auth/whoami',
+    logout: '/v1/auth/logout',
+    previewDeploy: '/v1/deploy/preview',
+    deploy: '/v1/deploy',
+    createService: '/v1/services',
+    logs: '/v1/services/{service}/logs',
+    proxy: '/v1/services/{service}/proxy',
+    deployments: '/v1/deployments',
+    deploymentStats: '/v1/deployments/stats',
+    rollback: '/v1/deployments/rollback',
+    secrets: '/v1/secrets',
+    secret: '/v1/secrets/{name}',
+    vars: '/v1/vars',
+    var: '/v1/vars/{name}',
+};
+/** A non-2xx answer from the controller, carrying its problem details when it sent any. */
+export class ControllerError extends Error {
+    status;
+    problem;
+    constructor(status, problem) {
+        super(problem.detail ?? problem.title ?? `controller answered ${status}`);
+        this.status = status;
+        this.problem = problem;
+        this.name = 'ControllerError';
+    }
+}
+export function createClient(options) {
+    const base = options.baseUrl.replace(/\/$/, '');
+    const doFetch = options.fetch ?? fetch;
+    const url = (call) => {
+        const path = call.path.replace(/\{(\w+)\}/g, (_, key) => encodeURIComponent(call.params?.[key] ?? ''));
+        const search = new URLSearchParams();
+        for (const [key, value] of Object.entries(call.query ?? {})) {
+            if (value !== undefined)
+                search.set(key, String(value));
+        }
+        const qs = search.toString();
+        return `${base}${path}${qs ? `?${qs}` : ''}`;
+    };
+    const send = async (call) => {
+        const headers = new Headers({ accept: call.accept ?? 'application/json' });
+        if (options.token)
+            headers.set('authorization', `Bearer ${options.token}`);
+        if (call.body !== undefined)
+            headers.set('content-type', 'application/json');
+        const response = await doFetch(url(call), {
+            method: call.method,
+            headers,
+            body: call.body === undefined ? undefined : JSON.stringify(call.body),
+        });
+        if (response.ok)
+            return response;
+        let problem = {};
+        try {
+            problem = (await response.json());
+        }
+        catch {
+            // Not a problem document; the status alone carries the error.
+        }
+        throw new ControllerError(response.status, problem);
+    };
+    const json = async (call) => (await send(call)).json();
+    const empty = async (call) => {
+        await send(call);
+    };
+    return {
+        authInfo: () => json({ method: 'GET', path: PATHS.authInfo }),
+        whoami: () => json({ method: 'GET', path: PATHS.whoami }),
+        logout: () => empty({ method: 'POST', path: PATHS.logout }),
+        previewDeploy: (bundle) => json({ method: 'POST', path: PATHS.previewDeploy, body: bundle }),
+        deploy: (bundle) => json({ method: 'POST', path: PATHS.deploy, body: bundle }),
+        createService: (request) => json({ method: 'POST', path: PATHS.createService, body: request }),
+        proxy: (service, request) => json({ method: 'POST', path: PATHS.proxy, params: { service }, body: request }),
+        /** Yields one LogEvent per `log` event until the server sends `end` or the stream closes. */
+        async *logs(service, query) {
+            const response = await send({
+                method: 'GET',
+                path: PATHS.logs,
+                params: { service },
+                query,
+                accept: 'text/event-stream',
+            });
+            if (!response.body)
+                return;
+            for await (const event of events(response.body)) {
+                if (event.event === 'end')
+                    return;
+                if (event.event === undefined || event.event === 'log') {
+                    yield JSON.parse(event.data);
+                }
+            }
+        },
+        deployments: (query) => json({ method: 'GET', path: PATHS.deployments, query }),
+        deploymentStats: (env) => json({ method: 'GET', path: PATHS.deploymentStats, query: { env } }),
+        rollback: (request) => json({ method: 'POST', path: PATHS.rollback, body: request }),
+        secrets: (env) => json({ method: 'GET', path: PATHS.secrets, query: { env } }),
+        setSecret: (env, name, value) => empty({
+            method: 'PUT',
+            path: PATHS.secret,
+            params: { name },
+            query: { env },
+            body: { value },
+        }),
+        updateSecret: (env, name, value) => empty({
+            method: 'PATCH',
+            path: PATHS.secret,
+            params: { name },
+            query: { env },
+            body: { value },
+        }),
+        unsetSecret: (env, name) => empty({ method: 'DELETE', path: PATHS.secret, params: { name }, query: { env } }),
+        vars: (env) => json({ method: 'GET', path: PATHS.vars, query: { env } }),
+        setVar: (env, name, value) => empty({ method: 'PUT', path: PATHS.var, params: { name }, query: { env }, body: { value } }),
+        updateVar: (env, name, value) => empty({
+            method: 'PATCH',
+            path: PATHS.var,
+            params: { name },
+            query: { env },
+            body: { value },
+        }),
+        unsetVar: (env, name) => empty({ method: 'DELETE', path: PATHS.var, params: { name }, query: { env } }),
+    };
+}