@intentius/chant-lexicon-temporal 0.1.14 → 0.1.15

package/dist/integrity.json

@@ -1,7 +1,7 @@
 {
   "algorithm": "sha256",
   "artifacts": {
-    "manifest.json": "a00c2b9e855c60fed2e4a370789a4c295f495980c9fba2a007674c33d808dd23",
+    "manifest.json": "01f153ed27fa75f3ffeec4202cb7d3dcdef74712c8b196f9385e7b896c6da604",
     "meta.json": "c77a3c415993bed3865e07fa6db4fb7b9e87de0afa8d8675f64eadf50f914077",
     "types/index.d.ts": "5216f5256321f084a7c8211ef66ab599f621c74751cc3485cfc2a62502b81e2f",
     "rules/tmp001.ts": "689222211a93716a7e4432f6dd6a2a2ab54020b232049fb602893872585f9978",
@@ -11,5 +11,5 @@
     "skills/chant-temporal.md": "ff929983b33bb420c49ab61851f3799c5610256cb972d6c584792bb98b0cfb22",
     "skills/chant-temporal-ops.md": "7e83bc3e6e63af4ab14b8dc07aa00132d51991cf35b1bca29560d48934bff6dc"
   },
-  "composite": "a7fbf3d5259994cbf34d80e3d056c643729fd3bc982671842269b26e856bcd37"
+  "composite": "08737cdf11946008dd7428f19bf68924eaebf67072c3885695a00759ba743f62"
 }

package/dist/manifest.json

@@ -1,6 +1,6 @@
 {
   "name": "temporal",
-  "version": "0.1.14",
+  "version": "0.1.15",
   "chantVersion": ">=0.1.0",
   "namespace": "Temporal",
   "intrinsics": [],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intentius/chant-lexicon-temporal",
-  "version": "0.1.14",
+  "version": "0.1.15",
   "description": "Temporal lexicon for chant — server deployment, namespaces, search attributes, and schedules",
   "license": "Apache-2.0",
   "homepage": "https://intentius.io/chant",
@@ -37,6 +37,10 @@
   },
   "devDependencies": {
     "@intentius/chant": "*",
+    "@temporalio/common": "^1.17.2",
+    "@temporalio/testing": "^1.17.2",
+    "@temporalio/worker": "^1.17.2",
+    "@temporalio/workflow": "^1.17.2",
     "typescript": "^5.9.3"
   }
 }

package/src/composites/apply-op.ts

@@ -0,0 +1,139 @@
+/**
+ * ApplyOp composite — the code → cloud workflow as an Op.
+ *
+ * Compute the plan, then apply via the target's native mechanism. Authority
+ * stays with the platform (the CloudFormation stack, the Kubernetes API
+ * server, the ARM resource group) — chant never hosts a state file.
+ *
+ * Phases: build → plan → [approve] → apply. Deletes are limited to chant-owned
+ * orphans, ridden on the native prune/complete path scoped to the ownership
+ * marker, so a foreign resource is never touched.
+ *
+ * An ungated apply may run on the local Op executor; a gated apply needs
+ * Temporal for the durable approval wait (added in #125).
+ *
+ * @example
+ * ```typescript
+ * // additive, local executor
+ * export const { op } = ApplyOp({ name: "prod-apply", env: "prod", target: "kubectl" });
+ *
+ * // gated destructive apply on Temporal
+ * export const { op } = ApplyOp({
+ *   name: "prod-apply",
+ *   env: "prod",
+ *   target: "kubectl",
+ *   delete: "gated",
+ *   gate: { signalName: "approve-apply", description: "Approve prod apply with deletes" },
+ * });
+ * ```
+ *
+ * @see #112 — stateless-authoritative state model + live import
+ */
+
+import { Op, phase, activity, gate, OpResource } from "@intentius/chant/op";
+import type { ApplyTarget, DeleteMode } from "../op/activities/apply";
+
+export interface ApplyOpConfig {
+  /** Op name (kebab-case). */
+  name: string;
+  /** Environment — CFN stack name / ARM resource group / kube context env. */
+  env: string;
+  /** Native apply mechanism. Default: "kubectl". */
+  target?: ApplyTarget;
+  /** Built manifest/template path (or directory for kubectl). Default: "dist". */
+  output?: string;
+  /** Project directory to build. Default: ".". */
+  path?: string;
+  /** Delete handling. Default: "never". */
+  delete?: DeleteMode;
+  /**
+   * Approval gate before the apply. Implied when `delete: "gated"`; may also be
+   * set explicitly. Omit `signalName` to default to `approve-<name>`.
+   */
+  gate?: { signalName?: string; timeout?: string; description?: string };
+  /**
+   * Saga-style rollback on partial apply failure, run as an `onFailure` phase.
+   * Defaults on whenever the apply is destructive (`delete !== "never"`). Pass
+   * `{ command }` to supply a rollback command for targets without a native one
+   * (kubectl, ARM); `false` to disable.
+   */
+  compensate?: boolean | { command?: string };
+  /** Override the task queue. Defaults to `name`. */
+  taskQueue?: string;
+}
+
+export interface ApplyOpResources {
+  /** Op resource — generates the build→plan→[approve]→apply workflow. */
+  op: InstanceType<typeof OpResource>;
+}
+
+export function ApplyOp(config: ApplyOpConfig): ApplyOpResources {
+  const taskQueue = config.taskQueue ?? config.name;
+  const target = config.target ?? "kubectl";
+  const output = config.output ?? "dist";
+  const deleteMode = config.delete ?? "never";
+  const gated = deleteMode === "gated" || config.gate !== undefined;
+
+  const phases = [
+    phase("Build", [activity("chantBuild", { path: config.path ?? "." })]),
+    phase("Plan", [
+      {
+        kind: "activity" as const,
+        fn: "lifecycleDiff",
+        args: { env: config.env, live: true },
+        outcomeAttribute: { name: "Drift", from: "drifted" },
+      },
+    ]),
+  ];
+
+  if (gated) {
+    phases.push(
+      phase("Approve", [
+        gate(config.gate?.signalName ?? `approve-${config.name}`, {
+          ...(config.gate?.timeout ? { timeout: config.gate.timeout } : {}),
+          description:
+            config.gate?.description ?? `Approve apply to ${config.env} (delete mode: ${deleteMode})`,
+        }),
+      ]),
+    );
+  }
+
+  phases.push(
+    phase("Apply", [
+      activity("nativeApply", { target, env: config.env, output, deleteMode }, "longInfra"),
+    ]),
+  );
+
+  // Compensation defaults on for destructive applies — a partial failure should
+  // unwind rather than leave the cloud half-applied.
+  const compensateDefault = deleteMode !== "never";
+  const compensateEnabled = config.compensate === undefined ? compensateDefault : config.compensate !== false;
+  const compensateCommand =
+    typeof config.compensate === "object" ? config.compensate.command : undefined;
+
+  const op = Op({
+    name: config.name,
+    overview: `Apply declared source to the ${config.env} environment (code → cloud)`,
+    taskQueue,
+    searchAttributes: {
+      Apply: "true",
+      Env: config.env,
+    },
+    phases,
+    ...(compensateEnabled
+      ? {
+          onFailure: [
+            phase("Rollback", [
+              activity("compensateApply", {
+                target,
+                env: config.env,
+                ...(compensateCommand ? { command: compensateCommand } : {}),
+              }),
+            ]),
+          ],
+        }
+      : {}),
+  });
+
+  return { op };
+}

package/src/composites/composites.test.ts

@@ -6,6 +6,8 @@ import { describe, test, expect } from "vitest";
 import { TemporalDevStack } from "./dev-stack";
 import { TemporalCloudStack } from "./cloud-stack";
 import { WatchOp } from "./watch-op";
+import { ReconcileOp } from "./reconcile-op";
+import { ApplyOp } from "./apply-op";
 import { serializeOps } from "../op/serializer";
 import { DECLARABLE_MARKER } from "@intentius/chant/declarable";
 
@@ -165,8 +167,8 @@ describe("WatchOp: configuration", () => {
     expect(phases.map((p) => p.name)).toEqual(["Snapshot", "Diff"]);
     const snapStep = (phases[0].steps as Array<Record<string, unknown>>)[0];
     const diffStep = (phases[1].steps as Array<Record<string, unknown>>)[0];
-    expect(snapStep.fn).toBe("stateSnapshot");
-    expect(diffStep.fn).toBe("stateDiff");
+    expect(snapStep.fn).toBe("lifecycleSnapshot");
+    expect(diffStep.fn).toBe("lifecycleDiff");
     expect(snapStep.args).toEqual({ env: "prod" });
     expect(diffStep.args).toEqual({ env: "prod", live: true });
     // Drift is surfaced as a workflow search attribute via outcomeAttribute (#41)
@@ -225,9 +227,146 @@ describe("WatchOp: serialization", () => {
     expect(wf).toContain('upsertSearchAttributes({"OpName":["prod-watch"],"Watch":["true"],"Env":["prod"]});');
     expect(wf).toContain('upsertSearchAttributes({ Phase: ["Snapshot"] });');
     expect(wf).toContain('upsertSearchAttributes({ Phase: ["Diff"] });');
-    expect(wf).toContain("stateSnapshot(");
+    expect(wf).toContain("lifecycleSnapshot(");
     // Diff result captured + Drift search attribute auto-emitted
-    expect(wf).toContain("const __r0 = await stateDiff(");
+    expect(wf).toContain("const __r0 = await lifecycleDiff(");
     expect(wf).toContain('upsertSearchAttributes({ "Drift": [String(__r0?.drifted)] });');
   });
 });
+
+// ── ReconcileOp ──────────────────────────────────────────────────────
+
+describe("ReconcileOp: shape", () => {
+  test("one-shot (no schedule) returns op only", () => {
+    const result = ReconcileOp({ name: "prod-reconcile", env: "prod" });
+    expect(result.op).toBeDefined();
+    expect(result.schedule).toBeUndefined();
+    expect(getEntityType(result.op)).toBe("Temporal::Op");
+    expect((result.op as Record<symbol, unknown>)[DECLARABLE_MARKER]).toBe(true);
+  });
+
+  test("with schedule returns op + schedule", () => {
+    const result = ReconcileOp({ name: "prod-reconcile", env: "prod", schedule: "0 * * * *" });
+    expect(result.op).toBeDefined();
+    expect(result.schedule).toBeDefined();
+    expect(getEntityType(result.schedule)).toBe("Temporal::Schedule");
+  });
+});
+
+describe("ReconcileOp: configuration", () => {
+  test("phases are Snapshot → Plan → Reconcile with the right activities", () => {
+    const { op } = ReconcileOp({ name: "p", env: "prod" });
+    const phases = (getProps(op).phases as Array<Record<string, unknown>>) ?? [];
+    expect(phases.map((p) => p.name)).toEqual(["Snapshot", "Plan", "Reconcile"]);
+    const reconcileStep = (phases[2].steps as Array<Record<string, unknown>>)[0];
+    expect(reconcileStep.fn).toBe("reconcilePr");
+    expect(reconcileStep.args).toEqual({ env: "prod", mode: "pull-request", owned: false });
+  });
+
+  test("scope.owned + onDrift flow into the reconcilePr step", () => {
+    const { op } = ReconcileOp({ name: "p", env: "prod", onDrift: "issue", scope: { owned: true } });
+    const phases = getProps(op).phases as Array<Record<string, unknown>>;
+    const reconcileStep = (phases[2].steps as Array<Record<string, unknown>>)[0];
+    expect(reconcileStep.args).toEqual({ env: "prod", mode: "issue", owned: true });
+  });
+
+  test("auto-emit search attrs include Reconcile + Env", () => {
+    const { op } = ReconcileOp({ name: "p", env: "prod" });
+    expect(getProps(op).searchAttributes).toEqual({ Reconcile: "true", Env: "prod" });
+  });
+
+  test("Plan phase surfaces Drift as a search attribute", () => {
+    const { op } = ReconcileOp({ name: "p", env: "prod" });
+    const phases = getProps(op).phases as Array<Record<string, unknown>>;
+    const diffStep = (phases[1].steps as Array<Record<string, unknown>>)[0];
+    expect(diffStep.outcomeAttribute).toEqual({ name: "Drift", from: "drifted" });
+  });
+});
+
+// ── ApplyOp ──────────────────────────────────────────────────────────
+
+describe("ApplyOp: shape", () => {
+  test("returns an op (no schedule)", () => {
+    const result = ApplyOp({ name: "prod-apply", env: "prod" });
+    expect(result.op).toBeDefined();
+    expect(getEntityType(result.op)).toBe("Temporal::Op");
+    expect((result.op as Record<symbol, unknown>)[DECLARABLE_MARKER]).toBe(true);
+  });
+
+  test("ungated apply: Build → Plan → Apply (no Approve phase)", () => {
+    const { op } = ApplyOp({ name: "p", env: "prod", target: "kubectl" });
+    const phases = getProps(op).phases as Array<Record<string, unknown>>;
+    expect(phases.map((p) => p.name)).toEqual(["Build", "Plan", "Apply"]);
+    const applyStep = (phases[2].steps as Array<Record<string, unknown>>)[0];
+    expect(applyStep.fn).toBe("nativeApply");
+    expect(applyStep.args).toEqual({ target: "kubectl", env: "prod", output: "dist", deleteMode: "never" });
+  });
+});
+
+describe("ApplyOp: gating + deletes", () => {
+  test("delete: gated inserts an Approve gate phase before Apply", () => {
+    const { op } = ApplyOp({ name: "p", env: "prod", delete: "gated" });
+    const phases = getProps(op).phases as Array<Record<string, unknown>>;
+    expect(phases.map((p) => p.name)).toEqual(["Build", "Plan", "Approve", "Apply"]);
+    const gateStep = (phases[2].steps as Array<Record<string, unknown>>)[0];
+    expect(gateStep.kind).toBe("gate");
+    expect(gateStep.signalName).toBe("approve-p");
+  });
+
+  test("explicit gate config is honored", () => {
+    const { op } = ApplyOp({
+      name: "p",
+      env: "prod",
+      gate: { signalName: "go", description: "ship it" },
+    });
+    const phases = getProps(op).phases as Array<Record<string, unknown>>;
+    const gateStep = (phases[2].steps as Array<Record<string, unknown>>)[0];
+    expect(gateStep.signalName).toBe("go");
+    expect(gateStep.description).toBe("ship it");
+  });
+
+  test("deleteMode flows into the nativeApply step", () => {
+    const { op } = ApplyOp({ name: "p", env: "prod", delete: "owned-only" });
+    const phases = getProps(op).phases as Array<Record<string, unknown>>;
+    const applyStep = (phases.find((p) => p.name === "Apply")!.steps as Array<Record<string, unknown>>)[0];
+    expect((applyStep.args as Record<string, unknown>).deleteMode).toBe("owned-only");
+  });
+
+  test("auto-emit search attrs include Apply + Env", () => {
+    const { op } = ApplyOp({ name: "p", env: "prod" });
+    expect(getProps(op).searchAttributes).toEqual({ Apply: "true", Env: "prod" });
+  });
+});
+
+describe("ApplyOp: compensation (#125)", () => {
+  test("destructive apply adds an onFailure Rollback phase by default", () => {
+    const { op } = ApplyOp({ name: "p", env: "prod", delete: "owned-only" });
+    const onFailure = getProps(op).onFailure as Array<Record<string, unknown>> | undefined;
+    expect(onFailure?.map((p) => p.name)).toEqual(["Rollback"]);
+    const step = (onFailure![0].steps as Array<Record<string, unknown>>)[0];
+    expect(step.fn).toBe("compensateApply");
+    expect(step.args).toEqual({ target: "kubectl", env: "prod" });
+  });
+
+  test("additive apply has no compensation by default", () => {
+    const { op } = ApplyOp({ name: "p", env: "prod", delete: "never" });
+    expect(getProps(op).onFailure).toBeUndefined();
+  });
+
+  test("compensate: false disables rollback even when destructive", () => {
+    const { op } = ApplyOp({ name: "p", env: "prod", delete: "owned-only", compensate: false });
+    expect(getProps(op).onFailure).toBeUndefined();
+  });
+
+  test("compensate.command supplies a rollback for targets without a native one", () => {
+    const { op } = ApplyOp({
+      name: "p",
+      env: "prod",
+      target: "kubectl",
+      compensate: { command: "kubectl rollout undo deployment/web" },
+    });
+    const onFailure = getProps(op).onFailure as Array<Record<string, unknown>>;
+    const step = (onFailure[0].steps as Array<Record<string, unknown>>)[0];
+    expect((step.args as Record<string, unknown>).command).toBe("kubectl rollout undo deployment/web");
+  });
+});

package/src/composites/reconcile-op.ts

@@ -0,0 +1,112 @@
+/**
+ * ReconcileOp composite — the cloud → code workflow as an Op.
+ *
+ * Keeps source tracking reality: when live drifts from declarations, open a PR
+ * that regenerates the affected TypeScript. Mirrors the {@link WatchOp} shape.
+ *
+ * Phases: snapshot → plan → regenerate (live import) → open PR. The
+ * regenerate-and-PR step is the `reconcilePr` activity (#122), which derives
+ * the change set from `chant lifecycle plan` and opens a reviewable PR.
+ *
+ * Runs on the local Op executor for a one-shot `chant run`; on Temporal when a
+ * `schedule` is given (the cron + run history are the value, as with WatchOp).
+ *
+ * @example
+ * ```typescript
+ * // one-shot, local executor
+ * export const { op } = ReconcileOp({ name: "prod-reconcile", env: "prod" });
+ *
+ * // scheduled on Temporal
+ * export const { op, schedule } = ReconcileOp({
+ *   name: "prod-reconcile",
+ *   env: "prod",
+ *   schedule: "0 * * * *",        // hourly
+ *   scope: { owned: true },
+ * });
+ * ```
+ *
+ * @see #112 — stateless-authoritative state model + live import
+ */
+
+import { Op, phase, activity, OpResource } from "@intentius/chant/op";
+import { TemporalSchedule } from "../resources";
+import type { ReconcileMode } from "../op/activities/reconcile";
+
+function kebabToCamel(s: string): string {
+  return s.replace(/-([a-z])/g, (_, c: string) => c.toUpperCase());
+}
+
+export interface ReconcileOpConfig {
+  /** Op name (kebab-case). Used as workflow function name, task queue, schedule id base. */
+  name: string;
+  /** Environment to reconcile (e.g. "prod"). */
+  env: string;
+  /**
+   * Cron expression. When set, a TemporalSchedule fires the workflow; omit for
+   * one-shot `chant run` on the local executor.
+   */
+  schedule?: string;
+  /**
+   * What to produce on drift. Default: "pull-request".
+   * @default "pull-request"
+   */
+  onDrift?: ReconcileMode;
+  /** Restrict reconciliation to chant-owned resources. */
+  scope?: { owned?: boolean };
+  /** Override the task queue. Defaults to `name`. */
+  taskQueue?: string;
+}
+
+export interface ReconcileOpResources {
+  /** Op resource — generates the snapshot→plan→regenerate→PR workflow. */
+  op: InstanceType<typeof OpResource>;
+  /** Temporal schedule, present only when `schedule` was given. */
+  schedule?: InstanceType<typeof TemporalSchedule>;
+}
+
+export function ReconcileOp(config: ReconcileOpConfig): ReconcileOpResources {
+  const taskQueue = config.taskQueue ?? config.name;
+  const onDrift = config.onDrift ?? "pull-request";
+  const owned = config.scope?.owned ?? false;
+
+  const op = Op({
+    name: config.name,
+    overview: `Reconcile the ${config.env} environment into source (cloud → code)`,
+    taskQueue,
+    searchAttributes: {
+      Reconcile: "true",
+      Env: config.env,
+    },
+    phases: [
+      phase("Snapshot", [activity("lifecycleSnapshot", { env: config.env })]),
+      phase("Plan", [
+        {
+          kind: "activity",
+          fn: "lifecycleDiff",
+          args: { env: config.env, live: true },
+          outcomeAttribute: { name: "Drift", from: "drifted" },
+        },
+      ]),
+      phase("Reconcile", [
+        // reconcilePr derives the change set from `chant lifecycle plan`,
+        // regenerates via `chant import --from`, and opens a PR.
+        activity("reconcilePr", { env: config.env, mode: onDrift, owned }),
+      ]),
+    ],
+  });
+
+  if (!config.schedule) {
+    return { op };
+  }
+
+  const schedule = new TemporalSchedule({
+    scheduleId: `${config.name}-schedule`,
+    spec: { cronExpressions: [config.schedule] },
+    action: {
+      workflowType: kebabToCamel(config.name) + "Workflow",
+      taskQueue,
+    },
+  } as Record<string, unknown>);
+
+  return { op, schedule };
+}

package/src/composites/watch-op.ts

@@ -5,7 +5,7 @@
  * Composes existing pieces:
  *   - The Op codegen (#7) emits a workflow that runs phases sequentially
  *   - The auto-emit search-attribute behavior (#28) tags each phase
- *   - The pre-built stateSnapshot + stateDiff activities (this commit)
+ *   - The pre-built lifecycleSnapshot + lifecycleDiff activities (this commit)
  *   - TemporalSchedule fires the workflow on a cron schedule
  *
  * @example
@@ -46,7 +46,7 @@ export interface WatchOpConfig {
    */
   taskQueue?: string;
   /**
-   * Run `chant state diff --live` (queries cloud APIs) instead of the
+   * Run `chant lifecycle diff --live` (queries cloud APIs) instead of the
    * default digest-only diff. Recommended for real drift detection.
    * @default true
    */
@@ -73,14 +73,14 @@ export function WatchOp(config: WatchOpConfig): WatchOpResources {
       Env: config.env,
     },
     phases: [
-      phase("Snapshot", [activity("stateSnapshot", { env: config.env })]),
+      phase("Snapshot", [activity("lifecycleSnapshot", { env: config.env })]),
       phase("Diff", [
-        // outcomeAttribute surfaces stateDiff's `drifted` boolean as a
+        // outcomeAttribute surfaces lifecycleDiff's `drifted` boolean as a
         // workflow-level Drift search attribute, making 'show me runs that
         // detected drift' a one-filter UI query.
         {
           kind: "activity",
-          fn: "stateDiff",
+          fn: "lifecycleDiff",
           args: { env: config.env, live },
           outcomeAttribute: { name: "Drift", from: "drifted" },
         },

package/src/config.ts

@@ -69,6 +69,13 @@ export interface TemporalActivityProfile {
     maximumAttempts?: number;
     /** Cap on retry intervals (e.g. "5m"). */
     maximumInterval?: string;
+    /**
+     * Error names (`Error.name`) that fail immediately without retry. Honored
+     * in both modes: the generated worker spreads this profile into
+     * `proxyActivities`, so Temporal's RetryPolicy uses it; the local executor
+     * reads it directly to short-circuit its retry loop.
+     */
+    nonRetryableErrorTypes?: string[];
   };
 }
 
@@ -118,6 +125,24 @@ export const TEMPORAL_ACTIVITY_PROFILES = {
     heartbeatTimeout: "90s",
     retry: { maximumAttempts: 1 },
   },
+
+  /**
+   * Argo CD sync waits: poll an Application until `health=Healthy && sync=Synced`
+   * (`waitForArgoSync`). Long timeout for slow first syncs, 60s heartbeat, cheap
+   * idempotent retries — re-polling is free. A terminal-unhealthy Application
+   * fails fast via `ArgoSyncFailedError` (non-retryable).
+   */
+  argoSync: {
+    startToCloseTimeout: "30m",
+    heartbeatTimeout: "60s",
+    retry: {
+      maximumAttempts: 5,
+      initialInterval: "10s",
+      backoffCoefficient: 2,
+      maximumInterval: "1m",
+      nonRetryableErrorTypes: ["ArgoSyncFailedError"],
+    },
+  },
 } as const satisfies Record<string, TemporalActivityProfile>;
 
 export interface TemporalWorkerProfile {

package/src/index.ts

@@ -29,6 +29,10 @@ export { TemporalCloudStack } from "./composites/cloud-stack";
 export type { TemporalCloudStackConfig, TemporalCloudStackResources } from "./composites/cloud-stack";
 export { WatchOp } from "./composites/watch-op";
 export type { WatchOpConfig, WatchOpResources } from "./composites/watch-op";
+export { ReconcileOp } from "./composites/reconcile-op";
+export type { ReconcileOpConfig, ReconcileOpResources } from "./composites/reconcile-op";
+export { ApplyOp } from "./composites/apply-op";
+export type { ApplyOpConfig, ApplyOpResources } from "./composites/apply-op";
 
 // Op builders (re-exported from core for single-import convenience)
 export {
@@ -41,7 +45,7 @@ export {
   helmInstall,
   waitForStack,
   gitlabPipeline,
-  stateSnapshot,
+  lifecycleSnapshot,
   shell,
   teardown,
 } from "@intentius/chant/op";

package/src/op/activities/apply.test.ts

@@ -0,0 +1,54 @@
+import { describe, test, expect } from "vitest";
+import { applyCommand, rollbackCommand } from "./apply";
+
+describe("applyCommand (#124)", () => {
+  test("kubectl never → plain apply, no prune", () => {
+    const cmd = applyCommand("kubectl", "prod", "dist", "never");
+    expect(cmd).toContain("kubectl apply -f dist");
+    expect(cmd).not.toContain("--prune");
+  });
+
+  test("kubectl owned-only → prune scoped to the chant ownership marker", () => {
+    const cmd = applyCommand("kubectl", "prod", "dist", "owned-only");
+    expect(cmd).toContain("--prune");
+    expect(cmd).toContain("--selector app.kubernetes.io/managed-by=chant");
+  });
+
+  test("kubectl gated → same owned-scoped prune as owned-only", () => {
+    expect(applyCommand("kubectl", "prod", "dist", "gated")).toBe(
+      applyCommand("kubectl", "prod", "dist", "owned-only"),
+    );
+  });
+
+  test("cloudformation deploys to the env stack", () => {
+    const cmd = applyCommand("cloudformation", "prod", "stack.json", "owned-only");
+    expect(cmd).toContain("aws cloudformation deploy");
+    expect(cmd).toContain("--stack-name prod");
+    expect(cmd).toContain("--template-file stack.json");
+  });
+
+  test("arm uses Complete mode only when deleting", () => {
+    expect(applyCommand("arm", "rg", "t.json", "owned-only")).toContain("--mode Complete");
+    expect(applyCommand("arm", "rg", "t.json", "never")).toContain("--mode Incremental");
+  });
+
+  test("never deletes a foreign resource: prune is always marker-scoped", () => {
+    // The only delete path is the marker-scoped prune/complete — there is no
+    // unscoped delete command, so a foreign (unmarked) resource is never pruned.
+    const cmd = applyCommand("kubectl", "prod", "dist", "owned-only");
+    expect(cmd).toContain("managed-by=chant");
+  });
+});
+
+describe("rollbackCommand (#125)", () => {
+  test("cloudformation has a native rollback", () => {
+    expect(rollbackCommand("cloudformation", "prod")).toBe(
+      "aws cloudformation rollback-stack --stack-name prod",
+    );
+  });
+
+  test("kubectl / arm have no native single-command rollback", () => {
+    expect(rollbackCommand("kubectl", "prod")).toBeUndefined();
+    expect(rollbackCommand("arm", "rg")).toBeUndefined();
+  });
+});