alchemy 2.0.0-beta.76 → 2.0.0-beta.77

package/src/{Sync.ts → Drift.ts}

@@ -1,7 +1,9 @@
 /** @effect-diagnostics anyUnknownInErrorContext:off */
 import * as Cause from "effect/Cause";
+import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
+import * as Ref from "effect/Ref";
 import { stripUnowned } from "./AdoptPolicy.ts";
 import {
   Artifacts,
@@ -10,7 +12,12 @@ import {
   ensureArtifactStore,
   makeScopedArtifacts,
 } from "./Artifacts.ts";
-import type { PlanStatusSession, ScopedPlanStatusSession } from "./Cli/Cli.ts";
+import {
+  noopSession,
+  Progress,
+  type PlanStatusSession,
+  type ScopedPlanStatusSession,
+} from "./Report.ts";
 import { deepEqual } from "./Diff.ts";
 import { InstanceId } from "./InstanceId.ts";
 import type { Apply, Plan } from "./Plan.ts";
@@ -27,22 +34,22 @@ import {
 import { type ResourceOp, recordResourceOp } from "./Telemetry/Metrics.ts";
 
 /**
- * The outcome of syncing a single resource.
+ * The outcome of checking or repairing drift for a single resource.
  *
  * - `unchanged` — the observed cloud state matches the persisted attributes.
  * - `drifted`   — (dry-run only) the cloud state diverged from the persisted
- *                 attributes; a non-dry-run sync would repair it.
+ *                 attributes; a non-dry-run drift would repair it.
  * - `missing`   — (dry-run only) the resource no longer exists in the cloud;
- *                 a non-dry-run sync would recreate it.
+ *                 a non-dry-run drift would recreate it.
  * - `repaired`  — drift was detected and the resource was reconciled back to
  *                 its desired (last-deployed) state.
  * - `recreated` — the resource was missing from the cloud and was reconciled
  *                 from scratch, reusing the persisted instance id so
  *                 deterministic physical names converge to the same values.
- * - `skipped`   — the resource was not synced; see `reason` (provider has no
+ * - `skipped`   — the resource was not checked; see `reason` (provider has no
  *                 `read`, or the persisted status is not stable).
  */
-export type SyncAction =
+export type DriftAction =
   | "unchanged"
   | "drifted"
   | "missing"
@@ -50,46 +57,45 @@ export type SyncAction =
   | "recreated"
   | "skipped";
 
-export interface SyncResourceResult {
+export interface DriftResourceResult {
   fqn: string;
   logicalId: string;
   resourceType: string;
-  action: SyncAction;
+  action: DriftAction;
   /** Why the resource was skipped (only set when `action === "skipped"`). */
   reason?: string;
   /**
-   * The resource's attributes after the sync: the reconciled attributes for
+   * The resource's attributes after the drift: the reconciled attributes for
    * `repaired`/`recreated`, the observed cloud attributes for `drifted`, and
    * the persisted attributes for `unchanged`. Unset for `missing`/`skipped`.
    */
   attr?: any;
 }
 
-export interface SyncResult {
-  resources: Record<string, SyncResourceResult>;
+export interface DriftResult {
+  resources: Record<string, DriftResourceResult>;
 }
 
-export interface SyncOptions {
-  /**
-   * Detect and report drift without repairing it. No provider `reconcile`
-   * runs and no state is persisted — resources report `drifted`/`missing`
-   * instead of `repaired`/`recreated`.
-   */
-  dryRun?: boolean;
+export interface DriftOptions {
   /** Optional progress session (the CLI passes one; tests usually don't). */
   session?: PlanStatusSession;
 }
 
-const noopSession: PlanStatusSession = {
-  emit: () => Effect.void,
-  done: () => Effect.void,
-};
+/** A provider lifecycle failure annotated with the resource being checked. */
+export class DriftResourceError extends Data.TaggedError("DriftResourceError")<{
+  readonly message: string;
+  readonly fqn: string;
+  readonly logicalId: string;
+  readonly resourceType: string;
+  readonly operation: ResourceOp;
+  readonly cause: unknown;
+}> {}
 
 /**
  * Reconcile state drift for every resource persisted under `stack`/`stage`.
  *
  * Unlike `deploy` (which converges the cloud to a *new* desired state
- * computed from the stack program), `sync` converges the cloud back to the
+ * computed from the stack program), `drift` converges the cloud back to the
  * *last-deployed* desired state recorded in the state store. It needs no
  * stack program — only the state store and the resource providers.
  *
@@ -107,31 +113,36 @@ const noopSession: PlanStatusSession = {
  *    deterministic physical names regenerate identically.
  * 4. **Persist** — write the fresh attributes back to the state store.
  *
- * Resources are synced concurrently and independently — persisted props are
+ * Resources are checked concurrently and independently — persisted props are
  * fully resolved values, so there are no upstream/downstream data edges to
- * order by. A failure syncing one resource does not interrupt the others;
+ * order by. A failure checking one resource does not interrupt the others;
  * all failures are aggregated into a single combined cause after every
  * resource has been attempted.
  *
- * Resources that cannot be synced are reported as `skipped` rather than
+ * Resources that cannot be checked are reported as `skipped` rather than
  * failing the run: providers without `read` (nothing to observe), and
  * resources whose persisted status is not stable (`creating`, `updating`,
  * `replacing`, `replaced`, `deleting`) — those represent an interrupted
  * deploy and must be recovered by `deploy`, which owns replacement chains
  * and dependency ordering. Action rows have no cloud state and are ignored.
  */
-export const sync = (
+const runDrift = (
   stack: { name: string; stage: string },
-  options: SyncOptions = {},
-): Effect.Effect<SyncResult, any, State> =>
+  options: DriftOptions & { readonly dryRun: boolean },
+): Effect.Effect<DriftResult, any, State> =>
   Effect.gen(function* () {
+    // Phase markers + per-resource observation progress go through the
+    // ambient Progress reporter (a no-op by default) so renderers can show the
+    // drift check as it runs.
+    const reportPlanned = yield* Progress;
+    yield* reportPlanned({ _tag: "plan.phase", phase: "loading-state" });
     const state = yield* yield* State;
     const session = options.session ?? noopSession;
     const stackName = stack.name;
     const stage = stack.stage;
-    const dryRun = options.dryRun ?? false;
+    const dryRun = options.dryRun;
 
-    const syncResource = Effect.fn("sync.resource")(function* (fqn: string) {
+    const driftResource = Effect.fn("drift.resource")(function* (fqn: string) {
       const persisted = yield* state.get({ stack: stackName, stage, fqn });
       // Action rows have no cloud state to drift.
       if (!persisted || isActionState(persisted)) {
@@ -141,8 +152,8 @@ export const sync = (
       const { logicalId, instanceId, resourceType, namespace } = old;
 
       const result = (
-        partial: Pick<SyncResourceResult, "action" | "reason" | "attr">,
-      ): SyncResourceResult => ({
+        partial: Pick<DriftResourceResult, "action" | "reason" | "attr">,
+      ): DriftResourceResult => ({
         fqn,
         logicalId,
         resourceType,
@@ -151,15 +162,22 @@ export const sync = (
 
       const scopedSession = {
         ...session,
-        note: (note: string) =>
-          session.emit({ id: logicalId, kind: "annotate", message: note }),
+        note: (note, options?) =>
+          session.emit({
+            fqn,
+            id: logicalId,
+            _tag: "apply.resource.note",
+            message: note,
+            kind: options?.kind,
+          }),
       } satisfies ScopedPlanStatusSession;
 
       const report = (
         status: "updating" | "updated" | "creating" | "created" | "skipped",
       ) =>
         session.emit({
-          kind: "status-change",
+          _tag: "apply.resource.status",
+          fqn,
           id: logicalId,
           type: resourceType,
           status,
@@ -178,7 +196,7 @@ export const sync = (
       if (old.status !== "created" && old.status !== "updated") {
         // Anything mid-flight (or with a pending replacement chain) belongs
         // to `deploy`'s recovery machinery — replacement generations and
-        // dependency ordering are not sync's to drive.
+        // dependency ordering are not drift's to drive.
         return yield* skip(
           old.status === "replaced" || old.status === "replacing"
             ? `resource has a pending replacement (status '${old.status}'); run deploy to finish it`
@@ -207,6 +225,17 @@ export const sync = (
           value: { ...value, namespace } as ResourceState,
         });
 
+      // Paired with the resource-planned completion so renderers can show
+      // which rows' cloud reads are actually in flight (the slowest part of
+      // a drift check). Emitted after the skip gates: skipped rows settle
+      // instantly and never read the cloud.
+      yield* reportPlanned({
+        _tag: "plan.resource.started",
+        fqn,
+        logicalId,
+        resourceType,
+        total: fqns.length,
+      });
       const observed = yield* provider
         .read({
           id: logicalId,
@@ -319,13 +348,43 @@ export const sync = (
     });
 
     const fqns = yield* state.list({ stack: stackName, stage });
+    yield* reportPlanned({ _tag: "plan.phase", phase: "computing-plan" });
 
-    // Sync every resource even if some fail, then surface all failures as
+    // Per-resource observation progress: each row is reported through the
+    // ambient Progress reporter as its cloud read lands (drift checks are the
+    // slowest planning path). Failed or action rows advance the count
+    // without an event, so progress stays monotonic.
+    const observedCount = yield* Ref.make(0);
+    const resourceObserved = (result: DriftResourceResult | undefined) =>
+      Ref.updateAndGet(observedCount, (count) => count + 1).pipe(
+        Effect.flatMap((completed) =>
+          result === undefined
+            ? Effect.void
+            : reportPlanned({
+                _tag: "plan.resource.completed",
+                fqn: result.fqn,
+                logicalId: result.logicalId,
+                resourceType: result.resourceType,
+                // Drift observation compares attributes, not binding rows.
+                bindings: [],
+                action:
+                  result.action === "drifted" || result.action === "repaired"
+                    ? "update"
+                    : result.action === "missing"
+                      ? "create"
+                      : "noop",
+                completed,
+                total: fqns.length,
+              }),
+        ),
+      );
+
+    // Drift every resource even if some fail, then surface all failures as
     // one combined cause (mirrors Apply's failure aggregation).
     const failures: Cause.Cause<unknown>[] = [];
     const results = yield* Effect.all(
       fqns.map((fqn) =>
-        syncResource(fqn).pipe(
+        driftResource(fqn).pipe(
           Effect.catchCause((cause) =>
             Effect.gen(function* () {
               failures.push(cause);
@@ -334,7 +393,8 @@ export const sync = (
                 .pipe(Effect.orElseSucceed(() => undefined));
               if (persisted && !isActionState(persisted)) {
                 yield* session.emit({
-                  kind: "status-change",
+                  _tag: "apply.resource.status",
+                  fqn,
                   id: persisted.logicalId,
                   type: persisted.resourceType,
                   status: "fail",
@@ -343,12 +403,13 @@ export const sync = (
               return undefined;
             }),
           ),
+          Effect.tap(resourceObserved),
         ),
       ),
       { concurrency: "unbounded" },
     );
 
-    yield* session.done();
+    yield* session.done(failures.length === 0 ? "success" : "failure");
 
     if (failures.length > 0) {
       return yield* Effect.failCause(
@@ -359,13 +420,13 @@ export const sync = (
     return {
       resources: Object.fromEntries(
         results
-          .filter((r): r is SyncResourceResult => r !== undefined)
+          .filter((r): r is DriftResourceResult => r !== undefined)
           .map((r) => [r.fqn, r]),
       ),
-    } satisfies SyncResult;
+    } satisfies DriftResult;
   }).pipe(
     ensureArtifactStore,
-    Effect.withSpan("sync", {
+    Effect.withSpan("drift", {
       attributes: {
         "alchemy.stack": stack.name,
         "alchemy.stage": stack.stage,
@@ -374,6 +435,16 @@ export const sync = (
     }),
   );
 
+/** Detect drift without reconciling resources or updating state. */
+export const detect = (stack: { name: string; stage: string }) =>
+  runDrift(stack, { dryRun: true });
+
+/** Reconcile resources back to their last-deployed desired state. */
+export const repair = (
+  stack: { name: string; stage: string },
+  options: DriftOptions = {},
+) => runDrift(stack, { ...options, dryRun: false });
+
 /**
  * Same shape as Apply's lifecycle instrumentation: scoped artifacts +
  * instance id, the resource op metrics, and a `provider.<op>` span.
@@ -388,13 +459,32 @@ const instrumentLifecycle =
   ) =>
   <A, E, R>(
     effect: Effect.Effect<A, E, R>,
-  ): Effect.Effect<A, E, Exclude<R, InstanceId | Artifacts>> =>
+  ): Effect.Effect<
+    A,
+    E | DriftResourceError,
+    Exclude<R, InstanceId | Artifacts>
+  > =>
     Effect.serviceOption(ArtifactStore).pipe(
       Effect.map(Option.getOrElse(createArtifactStore)),
       Effect.flatMap((store) =>
         effect.pipe(
           Effect.provideService(Artifacts, makeScopedArtifacts(store, fqn)),
           Effect.provideService(InstanceId, instanceId),
+          Effect.catchCause(
+            (cause): Effect.Effect<never, E | DriftResourceError> =>
+              Cause.hasInterruptsOnly(cause)
+                ? Effect.failCause(cause)
+                : Effect.fail(
+                    new DriftResourceError({
+                      message: `Resource '${fqn}' (${resourceType}) failed during ${op}`,
+                      fqn,
+                      logicalId,
+                      resourceType,
+                      operation: op,
+                      cause: Cause.squash(cause),
+                    }),
+                  ),
+          ),
         ),
       ),
       recordResourceOp(resourceType, op),
@@ -407,14 +497,18 @@ const instrumentLifecycle =
           "alchemy.resource.op": op,
         },
       }),
-    ) as Effect.Effect<A, E, Exclude<R, InstanceId | Artifacts>>;
+    ) as Effect.Effect<
+      A,
+      E | DriftResourceError,
+      Exclude<R, InstanceId | Artifacts>
+    >;
 
-export interface SyncPlan {
-  /** Per-resource detection outcome (a dry-run {@link SyncResult}). */
-  result: SyncResult;
+export interface DriftPlan {
+  /** Per-resource detection outcome (a dry-run {@link DriftResult}). */
+  result: DriftResult;
   /**
    * The detection outcome projected onto the engine's {@link Plan} shape so
-   * the CLI renders a sync exactly like a deploy plan (ink TUI when
+   * the CLI renders a drift exactly like a deploy plan (ink TUI when
    * interactive, plain logging otherwise): `drifted` → `update`, `missing` →
    * `create`, `unchanged`/`skipped` → `noop`.
    */
@@ -422,17 +516,17 @@ export interface SyncPlan {
 }
 
 /**
- * Run the drift-detection pass (a dry-run {@link sync}) and project the
+ * Run the drift-detection pass and project the
  * outcome onto a {@link Plan} for display/approval. The plan is a read-only
- * view — repair happens by calling {@link sync} (without `dryRun`), which
- * re-observes the cloud rather than trusting the detection snapshot.
+ * view — {@link repair} re-observes the cloud rather than trusting the
+ * detection snapshot.
  */
 export const plan = (stack: {
   name: string;
   stage: string;
-}): Effect.Effect<SyncPlan, any, State> =>
+}): Effect.Effect<DriftPlan, any, State> =>
   Effect.gen(function* () {
-    const result = yield* sync(stack, { dryRun: true });
+    const result = yield* detect(stack);
     const state = yield* yield* State;
 
     const resources: Plan["resources"] = {};
@@ -443,7 +537,7 @@ export const plan = (stack: {
         fqn,
       });
       if (!persisted || isActionState(persisted)) continue;
-      // Repair the row with the provider mode that created it (sync never
+      // Repair the row with the provider mode that created it (drift never
       // switches modes — a local ⇄ live switch is a plan-time replacement).
       const provider = yield* findProviderByType(
         persisted.resourceType,
@@ -458,6 +552,14 @@ export const plan = (stack: {
       resources[fqn] = {
         action,
         props: persisted.props,
+        drift:
+          r.action === "drifted" || r.action === "missing"
+            ? {
+                expected: persisted.attr,
+                actual: r.attr,
+                missing: r.action === "missing",
+              }
+            : undefined,
         state: persisted,
         provider,
         mode: persisted.providerMode,
@@ -480,7 +582,7 @@ export const plan = (stack: {
           RuntimeContext: undefined!,
           Providers: undefined,
         } as ResourceLike,
-        // Sync repairs from the persisted bindings verbatim — surface them
+        // Drift repairs from the persisted bindings verbatim — surface them
         // as noop rows so the renderer shows the binding topology without
         // implying binding changes.
         bindings: (persisted.bindings ?? []).map((binding) => ({
@@ -502,9 +604,9 @@ export const plan = (stack: {
         output: undefined,
         cycleMembers: new Set<string>(),
       },
-    } satisfies SyncPlan;
+    } satisfies DriftPlan;
   }).pipe(
-    Effect.withSpan("sync.plan", {
+    Effect.withSpan("drift.plan", {
       attributes: {
         "alchemy.stack": stack.name,
         "alchemy.stage": stack.stage,

package/src/Drizzle/Schema.ts

@@ -9,6 +9,7 @@ import { isResolved } from "../Diff.ts";
 import * as Provider from "../Provider.ts";
 import { Resource } from "../Resource.ts";
 import { exec } from "../Util/exec.ts";
+import { isNonInteractive } from "../Util/interactive.ts";
 import type { Providers } from "./Providers.ts";
 
 export type Dialect = "postgres" | "mysql" | "sqlite";
@@ -217,13 +218,10 @@ export const SchemaProvider = () =>
             extendEnv: true,
           };
 
-          const interactive =
-            !process.env.CI &&
-            process.stdin.isTTY &&
-            process.stdout.isTTY &&
-            process.stderr.isTTY;
-
-          if (interactive) {
+          // Hand the terminal to drizzle-kit only when this process may
+          // prompt at all — the same detection (TTY, CI, `--no-input`,
+          // `ALCHEMY_NO_TUI`, agent env) every other spawned command uses.
+          if (!isNonInteractive() && process.stderr.isTTY) {
             const handle = yield* ChildProcess.make(nodeExecPath, args, {
               ...commandOptions,
               stdin: "inherit",