sailfork / t3code-github / .repos/ alchemy-effect/ packages/ alchemy/ src/ State/ Export.ts

import * as Effect from "effect/Effect";
import { State, type PersistedState } from "./State.ts";
import { allStages } from "./Tree.ts";

/**
 * One resource record in a state export, addressed by the
 * `(stack, stage, fqn)` triple so a flat list spans the whole estate.
 */
export interface ExportedResource {
  /** Stack the record belongs to. */
  stack: string;
  /** Stage the record belongs to. */
  stage: string;
  /** Fully-qualified resource name (namespace path + logical ID). */
  fqn: string;
  /** The persisted record — the same value `state.get` returns. */
  state: PersistedState;
}

/**
 * A bulk read of the state store: every matching resource record in a
 * single document. Shaped as a flat list so consumers can filter
 * locally (e.g. `jq '.resources[] | select(...)'`) instead of issuing
 * one read per resource.
 */
export interface StateExport {
  resources: ExportedResource[];
}

/**
 * Optional scope narrowing for {@link exportState}.
 */
export interface ExportStateFilter {
  /** Only export this stack. Omit to export every stack in the store. */
  stack?: string;
  /** Only export this stage. Omit to export every stage. */
  stage?: string;
}

/**
 * Read every resource record in scope from the state store as one
 * document.
 *
 * Fans out over every `(stack, stage)` the store holds — see
 * {@link allStages} — with the per-resource reads bounded, so a whole
 * estate is fetched in a single pass instead of a call per resource.
 * Records that disappear between `list` and `get` (a concurrent
 * deploy/destroy) are skipped rather than failing the export.
 *
 * Results are ordered deterministically: by stack, then stage, then
 * FQN.
 */
export const exportState = Effect.fn("exportState")(function* (filter: ExportStateFilter = {}) {
  const state = yield* yield* State;
  const perStage = yield* Effect.forEach(
    yield* allStages(filter),
    ({ stack, stage }) =>
      Effect.gen(function* () {
        const fqns = [...(yield* state.list({ stack, stage }))].sort();
        const records = yield* Effect.forEach(
          fqns,
          (fqn) =>
            Effect.map(state.get({ stack, stage, fqn }), (value) =>
              value === undefined ? undefined : ({ stack, stage, fqn, state: value } as const),
            ),
          { concurrency: 16 },
        );
        return records.filter((r): r is ExportedResource => r !== undefined);
      }),
    { concurrency: "unbounded" },
  );
  return { resources: perStage.flat() } satisfies StateExport;
});