@sanity/workflow-cli 0.5.1

package/dist/lib/operation-args.js

@@ -0,0 +1,48 @@
+/**
+ * The synthetic actor a CLI write is attributed to when the operator
+ * doesn't name a real user. The engine resolves a real actor from
+ * `/users/me`, which a token-only CLI can't reach; until the CLI hooks
+ * into Sanity auth proper, writes act as this system identity.
+ */
+const SYSTEM_ACTOR = { kind: 'system', id: 'workflow-cli' };
+/**
+ * The write-verb arguments every engine operation shares: tag scope,
+ * workflow resource, and the CLI's pinned actor ({@link SYSTEM_ACTOR}).
+ * Spread by both the instance verbs ({@link buildOperationArgs}) and the
+ * definition verbs (e.g. `definition delete`).
+ */
+export function baseEngineArgs(config) {
+    return {
+        tag: config.tag,
+        workflowResource: config.workflowResource,
+        access: { actor: SYSTEM_ACTOR },
+    };
+}
+/**
+ * Resolve the actor a write is attributed to. With a named user the fire
+ * is pinned to it (plus any roles, so role-gated action filters pass);
+ * without one the {@link SYSTEM_ACTOR} fallback applies. Roles without a
+ * named user throw — they'd silently attach to nothing otherwise.
+ */
+export function resolveActor(as, roles) {
+    if (as === undefined) {
+        if (roles.length > 0) {
+            throw new Error('--as-role requires --as <userId>');
+        }
+        return SYSTEM_ACTOR;
+    }
+    return { kind: 'user', id: as, ...(roles.length > 0 ? { roles } : {}) };
+}
+/**
+ * {@link baseEngineArgs} plus the instance-operation fields (everything
+ * but the client and the verb-specific fields). The `reason` is spread
+ * conditionally because the engine's optional field rejects an explicit
+ * `undefined` under `exactOptionalPropertyTypes`.
+ */
+export function buildOperationArgs(config, instanceId, reason) {
+    return {
+        ...baseEngineArgs(config),
+        instanceId,
+        ...(reason !== undefined ? { reason } : {}),
+    };
+}

package/dist/lib/ops-report.d.ts

@@ -0,0 +1,30 @@
+import type { Ora } from 'ora';
+/** A single engine primitive that ran during a write commit — the
+ *  reportable subset of the engine's `OpAppliedSummary`. */
+export interface RanOp {
+    opType: string;
+    target?: {
+        scope: string;
+        state: string;
+    };
+}
+/**
+ * The "ops applied" block shared by write-verb reports (move-stage,
+ * fire-action): a blank separator, a header, and one line per primitive
+ * that ran. Empty when nothing ran, so callers append it unconditionally.
+ */
+export declare function opsAppliedLines(ranOps: RanOp[] | undefined): string[];
+/** The spinner message + ops block a write verb prints once its engine
+ *  call returns. {@link opsAppliedLines} builds `opsLines`. */
+export interface WriteReport {
+    fired: boolean;
+    message: string;
+    opsLines: string[];
+}
+/**
+ * Emit a write-verb report through its spinner: warn and bail when the
+ * requested intent didn't fire, otherwise succeed and print the ops block.
+ * Shared by every write command so the fired / not-fired branches stay
+ * consistent.
+ */
+export declare function emitWriteReport(spinner: Ora, report: WriteReport, log: (line: string) => void): void;

package/dist/lib/ops-report.js

@@ -0,0 +1,28 @@
+import logSymbols from 'log-symbols';
+import pc from 'picocolors';
+/**
+ * The "ops applied" block shared by write-verb reports (move-stage,
+ * fire-action): a blank separator, a header, and one line per primitive
+ * that ran. Empty when nothing ran, so callers append it unconditionally.
+ */
+export function opsAppliedLines(ranOps) {
+    const details = (ranOps ?? []).map((op) => {
+        const target = op.target ? pc.dim(` → ${op.target.scope}.${op.target.state}`) : '';
+        return `  ${logSymbols.info} ${op.opType}${target}`;
+    });
+    return details.length > 0 ? ['', pc.dim('ops applied:'), ...details] : [];
+}
+/**
+ * Emit a write-verb report through its spinner: warn and bail when the
+ * requested intent didn't fire, otherwise succeed and print the ops block.
+ * Shared by every write command so the fired / not-fired branches stay
+ * consistent.
+ */
+export function emitWriteReport(spinner, report, log) {
+    if (!report.fired) {
+        spinner.warn(report.message);
+        return;
+    }
+    spinner.succeed(report.message);
+    report.opsLines.forEach(log);
+}

package/dist/lib/stub.d.ts

@@ -0,0 +1,10 @@
+import { Command } from '@oclif/core';
+/**
+ * Base class for commands that aren't wired to the engine yet. Parses
+ * the subclass's args + flags, then prints a "not yet implemented"
+ * banner plus the parsed inputs so the surface is testable end-to-end,
+ * and exits non-zero — a stub must never report success to a caller.
+ */
+export declare abstract class StubCommand extends Command {
+    run(): Promise<void>;
+}

package/dist/lib/stub.js

@@ -0,0 +1,24 @@
+import { Command } from '@oclif/core';
+import boxen from 'boxen';
+import logSymbols from 'log-symbols';
+/**
+ * Base class for commands that aren't wired to the engine yet. Parses
+ * the subclass's args + flags, then prints a "not yet implemented"
+ * banner plus the parsed inputs so the surface is testable end-to-end,
+ * and exits non-zero — a stub must never report success to a caller.
+ */
+export class StubCommand extends Command {
+    async run() {
+        // `this.parse()` with no args picks up the subclass's static metadata.
+        const parsed = await this.parse(this.ctor);
+        const body = [
+            `${logSymbols.warning} not yet implemented`,
+            '',
+            `command: ${this.ctor.id ?? this.constructor.name}`,
+            `args:    ${JSON.stringify(parsed.args)}`,
+            `flags:   ${JSON.stringify(parsed.flags)}`,
+        ].join('\n');
+        this.log(boxen(body, { padding: 1, borderStyle: 'round', borderColor: 'yellow' }));
+        this.exit(1);
+    }
+}