@intentius/chant-lexicon-terraform 0.124.52 → 0.124.55

package/dist/compose/state-merge.js

@@ -0,0 +1,135 @@
+/**
+ * The working state of a composed run (chant#4442, epic #4419): each
+ * member's pulled state moved under `module.<m>` in one state the composed
+ * root plans and applies against, and, once the apply is done or has failed,
+ * split back into one state per member by module address.
+ *
+ * Lifted from terragucci's `packages/terragucci/src/compose.ts` at c493e0e
+ * (`mergeStates`, `splitState`) and `migrate.ts` (`derivedLineage`), with
+ * chant's {@link Composition} in place of terragucci's: members are
+ * components, and a member's directory is `Composition.dirs`. Pulling and
+ * writing the states is `../state` (#4437).
+ *
+ * The lineage and serial rules are terragucci's: a split state keeps its
+ * pulled lineage and takes the pulled serial plus one; a member with no
+ * state yet gets a lineage derived from the composed run and its root, and
+ * serial 1. The working state itself has serial 1 and a lineage derived from
+ * the members in order.
+ */
+import { createHash } from "node:crypto";
+import { rootTexts } from "./hcl.js";
+import { inModule, stripModule } from "./module-address.js";
+/** What the derived lineages are derived from, beside the roots. */
+export const COMPOSE_LINEAGE = "chant terraform.compose";
+/** A lineage in the form Terraform writes (a version 4 UUID), derived from `parts`, so the same parts always give the same lineage. */
+export function derivedLineage(...parts) {
+    const h = createHash("sha256").update(parts.join("\n")).digest("hex");
+    return `${h.slice(0, 8)}-${h.slice(8, 12)}-4${h.slice(13, 16)}-8${h.slice(17, 20)}-${h.slice(20, 32)}`;
+}
+/** Whether a root's own files configure the provider of type `type` (a `provider "<type>"` block): its resources then name the module's configuration. */
+function ownsProvider(dir, binary, type) {
+    if (!dir)
+        return false;
+    return rootTexts(dir, binary).some((t) => (t.json ? new RegExp(`"provider"\\s*:\\s*\\{[^]*"${type}"`).test(t.text) : new RegExp(`\\bprovider\\s+"${type}"\\s*\\{`).test(t.text)));
+}
+function versionAbove(a, b) {
+    const pa = a.split(/[.-]/).map((x) => Number.parseInt(x, 10) || 0);
+    const pb = b.split(/[.-]/).map((x) => Number.parseInt(x, 10) || 0);
+    for (let i = 0; i < Math.max(pa.length, pb.length); i++)
+        if ((pa[i] ?? 0) !== (pb[i] ?? 0))
+            return (pa[i] ?? 0) > (pb[i] ?? 0);
+    return false;
+}
+/**
+ * The working state: each member's resources with `module.<m>` in front of
+ * their module, each output as `<m>__<name>` (the composed root's outputs, so
+ * an output that does not change plans no change), check results left out.
+ * A resource whose root configures its provider itself names the module's
+ * provider configuration. `pulled` is by member; a member with no state
+ * (null or absent) adds nothing. The highest `terraform_version` pulled wins.
+ */
+export function mergeStates(c, pulled) {
+    const resources = [];
+    const outputs = {};
+    let tfVersion;
+    for (const member of c.order) {
+        const s = pulled.get(member);
+        if (!s)
+            continue;
+        const m = c.modules.get(member);
+        if (s.terraform_version && (!tfVersion || versionAbove(s.terraform_version, tfVersion)))
+            tfVersion = s.terraform_version;
+        for (const res of s.resources) {
+            const provider = typeof res.provider === "string" ? res.provider : undefined;
+            const type = provider?.match(/provider\["([^"]+)"\]/)?.[1]?.split("/").pop();
+            const own = provider && type && !provider.startsWith("module.") && ownsProvider(c.dirs.get(member), c.binary, type);
+            resources.push({
+                ...structuredClone(res),
+                module: res.module ? `module.${m}.${res.module}` : `module.${m}`,
+                ...(provider ? { provider: own || provider.startsWith("module.") ? `module.${m}.${provider}` : provider } : {}),
+            });
+        }
+        for (const [k, v] of Object.entries(s.outputs ?? {}))
+            outputs[`${m}__${k}`] = structuredClone(v);
+    }
+    return { version: 4, terraform_version: tfVersion ?? "1.0.0", serial: 1, lineage: derivedLineage(COMPOSE_LINEAGE, ...c.order), outputs, resources, check_results: null };
+}
+/** JSON with every object's keys sorted, so two objects that differ only in key order print the same. */
+function stable(v) {
+    if (Array.isArray(v))
+        return `[${v.map(stable).join(",")}]`;
+    if (v && typeof v === "object") {
+        return `{${Object.keys(v)
+            .filter((k) => v[k] !== undefined)
+            .sort()
+            .map((k) => `${JSON.stringify(k)}:${stable(v[k])}`)
+            .join(",")}}`;
+    }
+    return JSON.stringify(v) ?? "null";
+}
+/**
+ * A state's resources and outputs in one order, for comparing two states.
+ * Keys are sorted too: a split resource in a nested module carries `module`
+ * after its other keys, where `state pull` prints it first.
+ */
+const canonical = (s) => JSON.stringify({
+    resources: [...s.resources].map(stable).sort(),
+    outputs: stable(s.outputs ?? {}),
+});
+/**
+ * One member's state out of the working state: its resources with the module
+ * taken off, its outputs from `<m>__*`, its pulled lineage and its pulled
+ * serial plus one (a member with no state yet gets a lineage of its own,
+ * derived from its root, and serial 1). `same` when it holds what was pulled.
+ */
+export function splitState(working, c, member, pulled) {
+    const m = c.modules.get(member);
+    const resources = [];
+    for (const res of working.resources) {
+        if (!inModule(res.module, m))
+            continue;
+        const module = res.module === `module.${m}` ? undefined : stripModule(res.module);
+        const { module: _m, ...rest } = structuredClone(res);
+        const provider = typeof rest.provider === "string" && inModule(rest.provider, m) ? stripModule(rest.provider) : rest.provider;
+        resources.push({ ...rest, ...(module ? { module } : {}), ...(provider !== undefined ? { provider } : {}) });
+    }
+    const outputs = {};
+    for (const [k, v] of Object.entries(working.outputs ?? {}))
+        if (k.startsWith(`${m}__`))
+            outputs[k.slice(m.length + 2)] = v;
+    const state = {
+        version: 4,
+        terraform_version: working.terraform_version,
+        serial: (pulled?.serial ?? 0) + 1,
+        lineage: pulled?.lineage || derivedLineage(COMPOSE_LINEAGE, c.roots?.get(member) ?? member),
+        outputs,
+        resources,
+        check_results: null,
+    };
+    const same = pulled ? canonical(state) === canonical(pulled) : resources.length === 0 && Object.keys(outputs).length === 0;
+    return { state, same };
+}
+/** Every member's split state, by member, in apply order. */
+export function splitStates(working, c, pulled) {
+    return new Map(c.order.map((member) => [member, splitState(working, c, member, pulled.get(member) ?? null)]));
+}

package/dist/compose.d.ts

@@ -0,0 +1,179 @@
+/**
+ * Which roots a change composes, in what order, and why the others fall back
+ * (chant#4438, epic #4419). Pure functions over a project's config, its
+ * components and its roots' files: nothing here runs a binary.
+ *
+ * A composed run plans the `terraform-apply` components a change reaches,
+ * and the ones they read, as one plan of a composed root of `module` calls,
+ * and applies it as one apply, so a value one root creates reaches the roots
+ * that read it inside that apply. Writing the composed root is #4441;
+ * splitting its state is #4442; running it is #4444.
+ *
+ * Lifted from terragucci's `packages/terragucci/src/compose.ts` at c493e0e
+ * (`Composition`, `composeSet`, `readOrder`, `moduleNames`, `compositionFor`,
+ * `fallbackOf`, `fallbackLine`), with chant's inputs in place of terragucci's:
+ *
+ * - The roots are `terraform.roots`, each deployed by a component whose step
+ *   is `{ kind: "terraform-apply", root }`. A member is a component.
+ * - A read between members is a `stackOutput()` in the step's `vars`, a
+ *   `terraform_remote_state` block whose address is another member's
+ *   backend, or a `terraform_estate_outputs` block naming another member's
+ *   estate.
+ * - `waves.after` is the component's `dependsOn`; `oidc.roles` is the apply
+ *   identity the caller resolves per member (`ci.identity.cloud`, #4296);
+ *   `TF_CLI_ARGS*` is read from the environment as before.
+ *
+ * Unlike terragucci, part of a change can compose (#4419 ruling 1): each
+ * member that cannot is left out with its own reason, and the rest compose
+ * when two or more remain. A component of another kind, or a root left out,
+ * on a dependency path between two members splits them (ruling 2), and only
+ * a component whose deploy is that one step joins (ruling 3).
+ *
+ * Off unless `terraform.compose.enabled` is set: {@link compositionIfEnabled}
+ * is the entry point, and calls nothing when it is not.
+ */
+import type { PipelineCloudIdentity } from "@intentius/chant/ci-identity";
+import type { GroupFallback } from "@intentius/chant/components/capability";
+import { type DriverComponent } from "@intentius/chant/components/driver";
+import type { TerraformConfig } from "./config.js";
+export { blankComments, lockedProviders, blockBody, hclAttr, rootState, liveEstate, estateOutputReads } from "./compose/hcl.js";
+/** `terraform.compose.max` when unset. */
+export declare const DEFAULT_COMPOSE_MAX = 10;
+/** The step kind a member's deploy is. */
+export declare const COMPOSE_STEP_KIND = "terraform-apply";
+/**
+ * Why a member, or the whole change, applies in waves. `steps` and `split`
+ * are the kinds core's own group pass uses for the same reasons (ws-107);
+ * `off` is what the capability answers core's `groupFallback` with when
+ * `terraform.compose` is not enabled. `plan-failed` is kept for a reader of
+ * terragucci's reports: under core, a group plan that throws makes every
+ * member plan-failed instead (ws-107).
+ */
+export type ComposeFallbackKind = "off" | "too-many-roots" | "one-root" | "binary" | "identity" | "workspace" | "backend" | "provider-lock" | "cli-args" | "read" | "order-only" | "import" | "path" | "plan-failed" | "targets" | "steps" | "same-root" | "split";
+/** A fallback, in the shape of core's `GroupFallback` (ws-107) with the member it leaves out. */
+export interface ComposeFallback extends GroupFallback {
+    kind: ComposeFallbackKind;
+    /** The member left out. Absent when the reason is the whole change's. */
+    member?: string;
+    /** One line, no trailing period. */
+    reason: string;
+}
+/** One read of a member by another member. */
+export type ComposedRead = 
+/** A `stackOutput()` in the step's `vars`: `variable` is the top-level var it is in, `output` the upstream output. */
+{
+    via: "vars";
+    upstream: string;
+    variable: string;
+    output: string;
+}
+/** A `terraform_remote_state` block, by label. */
+ | {
+    via: "remote-state";
+    upstream: string;
+    name: string;
+}
+/** A choudoufu `terraform_estate_outputs` block, by label. */
+ | {
+    via: "estate-outputs";
+    upstream: string;
+    name: string;
+};
+/** What `terraform.compose` comes to for one change. */
+export interface Composition {
+    /** The `terraform-apply` components the change reaches plus those they read, followed upstream, sorted. */
+    candidates: string[];
+    /** The candidates that compose, sorted. Empty when {@link fallback} is set. */
+    members: string[];
+    /** The members, each after every member it reads. */
+    order: string[];
+    /** `terraform.compose.max`. */
+    max: number;
+    /** Each candidate's key in `terraform.roots`. */
+    roots: Map<string, string>;
+    /** Each candidate's root directory, absolute. */
+    dirs: Map<string, string>;
+    /** `terraform.binary`, which says which of each root's files are read (chant#4457). Unset is `terraform`. */
+    binary?: string;
+    /** Each member's module name in the composed root: a valid HCL identifier, stable across runs. */
+    modules: Map<string, string>;
+    /** Each member's reads of another member, sorted. */
+    reads: Map<string, ComposedRead[]>;
+    /** Every member runs choudoufu against a `live` estate: one choudoufu run over estates, no state to pull, split or write back. */
+    estate?: boolean;
+    /** Each candidate left out and why, in member order. Those plan wave by wave as without the setting. */
+    fallbacks: ComposeFallback[];
+    /** Why nothing composes. */
+    fallback?: ComposeFallback;
+}
+/** The binary a member runs, before anything is installed. */
+export interface ExpectedBinary {
+    name: string;
+    version?: string;
+}
+export interface CompositionInput {
+    /** The directory `chant.config.*` was loaded from; a root's `dir` resolves against it. */
+    projectRoot: string;
+    /** The config's `terraform` namespace. */
+    terraform: TerraformConfig;
+    /** Every component of the project, of every kind. */
+    components: readonly DriverComponent[];
+    /** The components the change reaches; undefined when every component plans. */
+    selected?: ReadonlySet<string>;
+    /** The environment the run has: `TF_CLI_ARGS*` is read from it. */
+    env: NodeJS.ProcessEnv;
+    /**
+     * The apply identity a member runs under, as one comparable string
+     * ({@link identityKey} of `resolveTargetCloudIdentity` for its root, #4296).
+     * Members with different strings do not compose. Unset: one identity.
+     */
+    identity?: (member: string) => string | undefined;
+    /** The targets each member is given (`--target`, #4300). */
+    targets?: Readonly<Record<string, readonly string[]>>;
+    /** Each member's binary. Default: `terraform.binary`, at no stated version. */
+    binary?: (member: string) => ExpectedBinary;
+}
+/** A member's identity as {@link CompositionInput.identity} compares it: its apply trade, or `""` for none. */
+export declare function identityKey(identity: PipelineCloudIdentity | undefined): string;
+/**
+ * The module name of each root: its name with every character a name cannot
+ * hold as `_` (`envs/prod-app` is `envs_prod_app`), `root` for an empty one,
+ * `r_` before a leading digit, and `_2`, `_3` on a clash, given in name order.
+ */
+export declare function moduleNames(roots: readonly string[]): Map<string, string>;
+/** The members of `set`, each after every member of the set it reads; members that read none of each other in name order. */
+export declare function readOrder(set: readonly string[], deps: ReadonlyMap<string, ReadonlySet<string>>): string[];
+/** The members a composed run covers: those of `all` the change reaches and every one of `all` they read, followed upstream. */
+export declare function composeSet(all: readonly string[], selected: ReadonlySet<string> | undefined, deps: ReadonlyMap<string, ReadonlySet<string>>): string[];
+/**
+ * Each component's `terraform_remote_state` and `terraform_estate_outputs`
+ * reads of another component of `input` that deploys a root, as the
+ * composition finds them (#4447): what `terraform-apply`'s `groupReads`
+ * reports to core. Components with no such read are left out.
+ */
+export declare function rootHclReads(input: Pick<CompositionInput, "projectRoot" | "terraform" | "components"> & Partial<Pick<CompositionInput, "env">>): Map<string, ComposedRead[]>;
+/**
+ * The `off` fallback when `terraform.compose` is not enabled, else undefined:
+ * what `terraform-apply`'s `groupFallback` answers first (ws-107).
+ */
+export declare function composeOff(terraform: TerraformConfig): ComposeFallback | undefined;
+/**
+ * The composition when `terraform.compose.enabled` is set, else undefined
+ * without reading anything. The only caller of {@link compositionFor} a run
+ * should use.
+ */
+export declare function compositionIfEnabled(input: CompositionInput): Composition | undefined;
+/**
+ * What `terraform.compose` comes to for a change: the members, their order,
+ * modules and reads, each candidate left out with its reason, or why nothing
+ * composes. Per-member checks run first (root, steps, targets, binary,
+ * backend, identity, provider lock, reads, imports and paths, order, split);
+ * a member left out gets the first that applies to it. `cli-args`,
+ * `too-many-roots` and `one-root` then judge what is left as a whole.
+ */
+export declare function compositionFor(input: CompositionInput): Composition;
+/** The composition with its plan failed: nothing composes, and each member plans wave by wave. */
+export declare function withPlanFailed(c: Composition, message: string): Composition;
+/** The one line a note, a log and the report say for a fallback: the whole change's, or one member's. */
+export declare function fallbackLine(f: ComposeFallback): string;
+//# sourceMappingURL=compose.d.ts.map

package/dist/compose.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compose.d.ts","sourceRoot":"","sources":["../src/compose.ts"],"names":[],"mappings":"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"}