@astralarium/repo-deploy-release 0.0.0-stage → 0.2.0

package/dist/src/cloudflare.js

@@ -0,0 +1,170 @@
+/** Cloudflare as `deploy-release` reaches it: reads and simple writes
+ *  through the API under wrangler's login; bundling and config-driven
+ *  writes through wrangler. */
+import { cfApi, CfApiError, deployScript, putScriptCrons, scriptCrons, scriptDeployments, scriptVersion, } from "@astralarium/repo-deploy-info";
+import { ExpectedError } from "@astralarium/repo-telemetry";
+import { abortReason, run } from "./process.js";
+import { ownWorkspaceRoot } from "./workspace.js";
+/** Statuses of a cutover past its sleep: it finishes or compensates. */
+export const RUNNING = [
+    "running",
+    "paused",
+    "waitingForPause",
+];
+/** Statuses of a cutover waiting for its time, or retrying a step. */
+export const WAITING = ["queued", "waiting"];
+/** Unix seconds, for workflow instance ids. */
+export const epoch = () => Math.floor(Date.now() / 1000);
+/** Version id at `percentage` in `deployment`. */
+export const idAt = (deployment, percentage) => deployment?.versions.find((v) => v.percentage === percentage)?.version_id;
+/** The OAuth token outlives this; refetched after it. */
+const TOKEN_REUSE_MS = 5 * 60_000;
+/** `fallback` when `promise` rejects with a 404 (an absent script or
+ *  workflow). */
+async function orAbsent(promise, fallback) {
+    try {
+        return await promise;
+    }
+    catch (e) {
+        if (e instanceof CfApiError && e.status === 404)
+            return fallback;
+        throw e;
+    }
+}
+/** The account wrangler is logged into. */
+export class Cloudflare {
+    #signal;
+    /** Workspace package whose wrangler answers account-level queries. */
+    #pkg;
+    /** Wrangler config file within each package (`--config`). */
+    #config;
+    #account;
+    #token;
+    /** `api`, bound for the `@astralarium/repo-deploy-info` ops. */
+    #api = this.api.bind(this);
+    constructor(signal, pkg, config) {
+        this.#signal = signal;
+        this.#pkg = pkg;
+        this.#config = config;
+    }
+    /** Runs wrangler in workspace package `pkg`'s directory on its config
+     *  file (`--config`): an entry path in `args` would move wrangler's
+     *  lookup to the entry's directory. */
+    wrangler(pkg, args, { redirected = false, config = this.#config, ...options } = {}) {
+        return run("pnpm", [
+            "--filter",
+            pkg,
+            "exec",
+            "wrangler",
+            ...args,
+            ...(redirected ? [] : ["--config", config]),
+        ], this.#signal, { cwd: ownWorkspaceRoot(), ...options });
+    }
+    /** Reads wrangler's JSON output of `args`. */
+    async #wranglerJson(args) {
+        const out = await this.wrangler(this.#pkg, args, {
+            capture: true,
+            quiet: true,
+        });
+        return JSON.parse(out);
+    }
+    /** The id of the one account wrangler reaches. */
+    accountId() {
+        this.#account ??= this.#wranglerJson([
+            "whoami",
+            "--json",
+        ]).then(({ accounts }) => {
+            if (accounts.length !== 1)
+                throw new ExpectedError(`wrangler reaches ${accounts.length} Cloudflare accounts; log into exactly one`);
+            return accounts[0].id;
+        });
+        return this.#account;
+    }
+    /** Wrangler's OAuth token, reused `TOKEN_REUSE_MS`; a failed read is
+     *  retried by the next call. */
+    token() {
+        if (!this.#token || Date.now() - this.#token.at > TOKEN_REUSE_MS) {
+            const value = this.#wranglerJson([
+                "auth",
+                "token",
+                "--json",
+            ]).then((t) => t.token);
+            const token = { value, at: Date.now() };
+            value.catch(() => {
+                if (this.#token === token)
+                    this.#token = undefined;
+            });
+            this.#token = token;
+        }
+        return this.#token.value;
+    }
+    /** One API call, as `CfApi`. */
+    async api(method, path, body) {
+        const signal = this.#signal;
+        const api = cfApi(await this.token(), await this.accountId(), (input, init) => fetch(input, { ...init, signal }));
+        try {
+            return await api(method, path, body);
+        }
+        catch (e) {
+            throw signal.aborted ? abortReason(signal) : e;
+        }
+    }
+    /** `script`'s deployments, newest first; none when it is absent. */
+    deployments(script) {
+        return orAbsent(scriptDeployments(this.#api, script), []);
+    }
+    /** Version of `script` at `percentage` in its latest deployment. */
+    async versionAt(script, percentage) {
+        const [latest] = await this.deployments(script);
+        return idAt(latest, percentage);
+    }
+    /** Version `id` of `script`. */
+    version(script, id) {
+        return scriptVersion(this.#api, script, id);
+    }
+    /** `script`'s recent deployable versions; none when it is absent. */
+    async versions(script) {
+        const { items } = await orAbsent(this.api("GET", `workers/scripts/${script}/versions?deployable=true`), { items: [] });
+        return items;
+    }
+    /** Names of `script`'s secrets; none when it is absent. */
+    async secretNames(script) {
+        const secrets = await orAbsent(this.api("GET", `workers/scripts/${script}/secrets`), []);
+        return secrets.map((s) => s.name);
+    }
+    /** `script`'s cron expressions. */
+    crons(script) {
+        return scriptCrons(this.#api, script);
+    }
+    /** Clears `script`'s crons. */
+    clearCrons(script) {
+        return putScriptCrons(this.#api, script, []);
+    }
+    /** Deploys `versions` of `script`. */
+    deploy(script, versions, message) {
+        return deployScript(this.#api, script, versions, message);
+    }
+    /** Ids of workflow `flow`'s instances in `status`; none while the
+     *  workflow is absent. */
+    async instances(flow, status) {
+        const instances = await orAbsent(this.api("GET", `workflows/${flow}/instances?status=${status}&per_page=100`), []);
+        return instances.map((i) => i.id);
+    }
+    /** Starts workflow `flow` as instance `id` with `params`. */
+    async trigger(flow, id, params) {
+        await this.api("POST", `workflows/${flow}/instances`, {
+            instance_id: id,
+            params,
+        });
+    }
+    /** Instance `id` of workflow `flow`. */
+    instance(flow, id) {
+        return this.api("GET", `workflows/${flow}/instances/${id}`);
+    }
+    /** Terminates instance `id` of workflow `flow`. */
+    async terminate(flow, id) {
+        await this.api("PATCH", `workflows/${flow}/instances/${id}/status`, {
+            status: "terminate",
+        });
+    }
+}

package/dist/src/commands.d.ts

@@ -0,0 +1,55 @@
+import { type BuildEnv, type ReleaseApp } from "./app.ts";
+import { type Session, type SlotSession } from "./session.ts";
+/** Flags of the commands that build. */
+interface BuildFlags {
+    /** `--build-env`: the build's `ReleaseApp.buildEnv` values. */
+    buildEnv?: BuildEnv;
+}
+/** Flags of the commands that stage: `stage`, `deploy`. */
+interface StageFlags extends BuildFlags {
+    /** `--force`: ends the idle slot's ongoing work. */
+    force: boolean;
+}
+/** Flags of the commands that schedule a cutover: `cutover`, `deploy`. */
+interface CutoverFlags {
+    /** `--at`: the cutover time. */
+    at: string | undefined;
+    /** `--exact-time`: keeps `at` unrounded. */
+    exactTime: boolean;
+}
+/** `init`: deploys the next build to blue, its web version live alone,
+ *  and names it the live build. Refuses once a slot is live. */
+export declare function runInit(s: SlotSession, { buildEnv }?: BuildFlags): Promise<void>;
+/** `stage`: deploys the next build to the idle slot at 0%. */
+export declare function runStage(s: SlotSession, flags: StageFlags): Promise<void>;
+/** `cutover`: schedules the switch to the staged build at `--at`. */
+export declare function runCutover(s: SlotSession, flags: CutoverFlags): Promise<void>;
+/** `deploy`: `stage`, then `cutover`, unattended after the token prompt.
+ *  An in-place target deploys at once (`runDeployWorkers`); its
+ *  cutover flags refuse. */
+export declare function runDeploy(session: Session, flags: StageFlags & CutoverFlags): Promise<void>;
+/** `rollback`: switches back to the previous build now, through the
+ *  cutover workflow. Previous = the newest earlier live web version on
+ *  the other slot, while that slot still holds its build. */
+export declare function runRollback(s: SlotSession): Promise<void>;
+/** `cancel`: terminates waiting cutover runs, withdrawing their updates
+ *  and one left by an ended run, and publishes the deploy state. Resolves
+ *  whether an update or a waiting run was there to cancel. */
+export declare function cancelUpdate(s: SlotSession): Promise<boolean>;
+/** `settle`: aligns the deployment to the live web version. Ends finishing
+ *  cutover runs too; the steps below redo their tail. */
+export declare function runSettle(s: SlotSession): Promise<void>;
+/** `status`: prints the deployment's facts and checks; resolves to the
+ *  exit status, 1 on any failed check. */
+export declare function runStatus(s: SlotSession): Promise<number>;
+/** `unlock`: breaks the deploy lease once the operator confirms (`yes`
+ *  skips the question). */
+export declare function runUnlock(s: Session, flags: {
+    yes: boolean;
+}): Promise<void>;
+/** `secrets`: uploads the target's secrets file to each of its scripts. */
+export declare function runSecrets(s: Session): Promise<void>;
+/** `deploy-release`'s commands against `app`'s targets; `invocation`
+ *  starts each printed command line. */
+export declare function commands(app: ReleaseApp, invocation: string): import("@stricli/core").RouteMap<import("@stricli/core").CommandContext>;
+export {};