@intentius/chant-lexicon-terraform 0.124.52 → 0.124.55

package/dist/compose/slice.d.ts

@@ -0,0 +1,102 @@
+/**
+ * The composed plan cut back into one plan per member (chant#4442, epic
+ * #4419): each member's part of the composed root's `show -json`, as if the
+ * member's root had planned alone, and from it the member's change-set part,
+ * planned outputs, plan shape and reads of other members, so the change set,
+ * the report, policy and behold see each component and not one composed
+ * root.
+ *
+ * Lifted from terragucci's `packages/terragucci/src/compose.ts` at c493e0e
+ * (`slicePlan`, `sliceText`, `planCounts`, `composedReportReads`). Addresses
+ * are stripped by `./module-address`, which `chant terraform report` uses
+ * too. The outputs are `<m>__<name>` in the composed root, as #4441 writes
+ * them and terragucci did.
+ */
+import type { ChangeSetPlanner, ChangeSetPart } from "@intentius/chant/change-set";
+import type { CapabilityPlan, PlannedOutputs } from "@intentius/chant/components/capability";
+import type { PlanShape } from "@intentius/chant/components/covered-round";
+import type { Composition, ComposedRead } from "../compose.js";
+type Json = Record<string, unknown>;
+/** The outputs of module `m` among a composed root's, by their own names. */
+export declare function moduleOutputs(outputs: unknown, m: string): Json;
+/** A module's part of `planned_values` or `prior_state.values`: its child module as the root module, addresses unprefixed. */
+export declare function moduleValues(values: unknown, m: string, outputs: Json): Json | undefined;
+/**
+ * One member's part of the composed plan's `show -json`, as if it had
+ * planned alone: its resource changes and drift with `module.<m>.` taken off,
+ * its outputs by their own names, its planned values, prior state and
+ * configuration as the root module. `checks` and `variables` (the composed
+ * root's) are left out.
+ */
+export declare function slicePlan(plan: unknown, m: string): unknown;
+/** A plan's counts as the binary's `Plan:` line gives them, and how many changes and destroys it holds. */
+export interface PlanCounts {
+    add: number;
+    change: number;
+    destroy: number;
+    changes: number;
+    destroys: number;
+}
+/** A plan's counts as the binary's `Plan:` line gives them. A no-op or read is not a change. */
+export declare function planCounts(plan: unknown): PlanCounts;
+/**
+ * One member's part of the composed plan's `show` text: the text before the
+ * actions, each resource block of its module with `module.<m>.` taken off,
+ * its line of counts, and its outputs by their own names.
+ */
+export declare function sliceText(text: string, m: string, counts: {
+    add: number;
+    change: number;
+    destroy: number;
+}): string;
+/** One member's read of another member's outputs, planned on the upstream's part of the composed plan. */
+export interface ComposedMemberRead {
+    /** The member read. */
+    upstream: string;
+    via: ComposedRead["via"];
+    /** The `vars` key, or the data block's label. */
+    name: string;
+    /** The outputs read, sorted. Undefined when the reader reads the whole object, so every output counts. */
+    outputs?: string[];
+    /** The outputs read that are known only once the upstream's part applies, sorted. */
+    unknown: string[];
+}
+/**
+ * Each member's reads of other members, planned on the upstream's part of
+ * the composed plan: an output read that the upstream's planned outputs
+ * ({@link terraformPlannedOutputs} of its slice) leave unknown is named
+ * unknown. A `vars` read names its output; a `terraform_remote_state` or
+ * `terraform_estate_outputs` block's outputs are read from the member's own
+ * files, as terragucci's `outputsRead` and `estateValuesRead` did.
+ */
+export declare function composedReads(c: Pick<Composition, "members" | "reads" | "dirs"> & Partial<Pick<Composition, "binary">>, outputs: ReadonlyMap<string, PlannedOutputs>): Map<string, ComposedMemberRead[]>;
+/** One member's part of a composed plan, in the form a capability's `plan` answers it. */
+export interface ComposedMemberPlan extends CapabilityPlan {
+    /** The member's root, as `terraform.roots` names it: the change set's member. */
+    member: string;
+    changeSet: ChangeSetPart;
+    outputs: PlannedOutputs;
+    /** `unknownInputs` are this member's reads of other members that the composed plan leaves unknown, as `<component>.<output>`. */
+    shape: PlanShape;
+    /** The member's part of `show -json`, as if it had planned alone. */
+    slice: unknown;
+    counts: PlanCounts;
+    /** Its reads of other members. */
+    reads: ComposedMemberRead[];
+}
+export interface ComposedMemberPlansOptions {
+    /** The binary that planned. Default `terraform`. */
+    planner?: ChangeSetPlanner;
+    /** The estate or workspace each member plans into, by component. */
+    scope?: (member: string) => string | undefined;
+}
+/**
+ * Every member's plan out of the composed plan's `show -json`, by component:
+ * {@link terraformChangeSetPart}, {@link terraformPlannedOutputs} and
+ * {@link terraformPlanShape} of its slice, so each member's part is the part
+ * a plan of its root alone gives on the same state. The member is the root's
+ * name (`Composition.roots`), as a single `terraform-apply` plan names it.
+ */
+export declare function composedMemberPlans(c: Pick<Composition, "members" | "order" | "modules" | "reads" | "dirs" | "roots"> & Partial<Pick<Composition, "binary">>, plan: unknown, options?: ComposedMemberPlansOptions): Record<string, ComposedMemberPlan>;
+export {};
+//# sourceMappingURL=slice.d.ts.map

package/dist/compose/slice.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slice.d.ts","sourceRoot":"","sources":["../../src/compose/slice.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AACnF,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,wCAAwC,CAAC;AAC7F,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2CAA2C,CAAC;AAC3E,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAQ5D,KAAK,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAGpC,6EAA6E;AAC7E,wBAAgB,aAAa,CAAC,OAAO,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAG/D;AAED,8HAA8H;AAC9H,wBAAgB,YAAY,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,GAAG,IAAI,GAAG,SAAS,CAWxF;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAiC3D;AAED,2GAA2G;AAC3G,MAAM,WAAW,UAAU;IACzB,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,gGAAgG;AAChG,wBAAgB,UAAU,CAAC,IAAI,EAAE,OAAO,GAAG,UAAU,CAepD;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAmCnH;AA0BD,0GAA0G;AAC1G,MAAM,WAAW,kBAAkB;IACjC,uBAAuB;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,YAAY,CAAC,KAAK,CAAC,CAAC;IACzB,iDAAiD;IACjD,IAAI,EAAE,MAAM,CAAC;IACb,0GAA0G;IAC1G,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,qFAAqF;IACrF,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,IAAI,CAAC,WAAW,EAAE,SAAS,GAAG,OAAO,GAAG,MAAM,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC,EAAE,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,cAAc,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,kBAAkB,EAAE,CAAC,CA2BxM;AAID,0FAA0F;AAC1F,MAAM,WAAW,kBAAmB,SAAQ,cAAc;IACxD,iFAAiF;IACjF,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,aAAa,CAAC;IACzB,OAAO,EAAE,cAAc,CAAC;IACxB,iIAAiI;IACjI,KAAK,EAAE,SAAS,CAAC;IACjB,qEAAqE;IACrE,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,UAAU,CAAC;IACnB,kCAAkC;IAClC,KAAK,EAAE,kBAAkB,EAAE,CAAC;CAC7B;AAED,MAAM,WAAW,0BAA0B;IACzC,oDAAoD;IACpD,OAAO,CAAC,EAAE,gBAAgB,CAAC;IAC3B,oEAAoE;IACpE,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;CAChD;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,IAAI,CAAC,WAAW,EAAE,SAAS,GAAG,OAAO,GAAG,SAAS,GAAG,OAAO,GAAG,MAAM,GAAG,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,GAAE,0BAA+B,GAAG,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAwB1P"}

package/dist/compose/slice.js

@@ -0,0 +1,249 @@
+/**
+ * The composed plan cut back into one plan per member (chant#4442, epic
+ * #4419): each member's part of the composed root's `show -json`, as if the
+ * member's root had planned alone, and from it the member's change-set part,
+ * planned outputs, plan shape and reads of other members, so the change set,
+ * the report, policy and behold see each component and not one composed
+ * root.
+ *
+ * Lifted from terragucci's `packages/terragucci/src/compose.ts` at c493e0e
+ * (`slicePlan`, `sliceText`, `planCounts`, `composedReportReads`). Addresses
+ * are stripped by `./module-address`, which `chant terraform report` uses
+ * too. The outputs are `<m>__<name>` in the composed root, as #4441 writes
+ * them and terragucci did.
+ */
+import { terraformChangeSetPart } from "../change-set.js";
+import { terraformPlannedOutputs } from "../components/capability-plugin.js";
+import { terraformPlanShape } from "../plan-shape.js";
+import { rootTexts } from "./hcl.js";
+import { inModule, moduleChanges, stripModule, topModule } from "./module-address.js";
+import { READ_VAR_PREFIX } from "./root.js";
+const isObj = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+/** The outputs of module `m` among a composed root's, by their own names. */
+export function moduleOutputs(outputs, m) {
+    if (!isObj(outputs))
+        return {};
+    return Object.fromEntries(Object.entries(outputs).filter(([k]) => k.startsWith(`${m}__`)).map(([k, v]) => [k.slice(m.length + 2), v]));
+}
+/** A module's part of `planned_values` or `prior_state.values`: its child module as the root module, addresses unprefixed. */
+export function moduleValues(values, m, outputs) {
+    if (!isObj(values))
+        return undefined;
+    const root = isObj(values.root_module) ? values.root_module : {};
+    const child = (Array.isArray(root.child_modules) ? root.child_modules : []).find((x) => isObj(x) && x.address === `module.${m}`);
+    const strip = (mod) => ({
+        ...mod,
+        ...(Array.isArray(mod.resources) ? { resources: mod.resources.map((x) => (isObj(x) ? { ...x, address: stripModule(String(x.address)) } : x)) } : {}),
+        ...(Array.isArray(mod.child_modules) ? { child_modules: mod.child_modules.map((x) => (isObj(x) ? strip({ ...x, address: stripModule(String(x.address)) }) : x)) } : {}),
+    });
+    const { address: _a, ...rest } = child ? strip(child) : { address: undefined };
+    return { ...values, outputs, root_module: rest };
+}
+/**
+ * One member's part of the composed plan's `show -json`, as if it had
+ * planned alone: its resource changes and drift with `module.<m>.` taken off,
+ * its outputs by their own names, its planned values, prior state and
+ * configuration as the root module. `checks` and `variables` (the composed
+ * root's) are left out.
+ */
+export function slicePlan(plan, m) {
+    if (!isObj(plan))
+        return plan;
+    const out = { ...plan };
+    if (Array.isArray(plan.resource_changes))
+        out.resource_changes = moduleChanges(plan.resource_changes, m);
+    if (Array.isArray(plan.resource_drift))
+        out.resource_drift = moduleChanges(plan.resource_drift, m);
+    if (isObj(plan.output_changes))
+        out.output_changes = moduleOutputs(plan.output_changes, m);
+    if (isObj(plan.planned_values))
+        out.planned_values = moduleValues(plan.planned_values, m, moduleOutputs(plan.planned_values.outputs, m));
+    if (isObj(plan.prior_state)) {
+        const values = isObj(plan.prior_state.values) ? plan.prior_state.values : undefined;
+        out.prior_state = { ...plan.prior_state, ...(values ? { values: moduleValues(values, m, moduleOutputs(values.outputs, m)) } : {}) };
+    }
+    if (isObj(plan.configuration)) {
+        const root = isObj(plan.configuration.root_module) ? plan.configuration.root_module : {};
+        const call = isObj(root.module_calls) && isObj(root.module_calls[m]) ? root.module_calls[m] : undefined;
+        const pc = isObj(plan.configuration.provider_config) ? plan.configuration.provider_config : {};
+        out.configuration = {
+            ...plan.configuration,
+            provider_config: Object.fromEntries(Object.entries(pc).flatMap(([k, v]) => k.startsWith(`module.${m}:`) ? [[k.slice(`module.${m}:`.length), isObj(v) ? { ...v, module_address: undefined } : v]] : k.includes(":") ? [] : [[k, v]])),
+            root_module: isObj(call?.module) ? call.module : {},
+        };
+    }
+    if (Array.isArray(plan.relevant_attributes)) {
+        out.relevant_attributes = plan.relevant_attributes
+            .filter((x) => isObj(x) && inModule(String(x.resource), m) && String(x.resource) !== `module.${m}`)
+            .map((x) => ({ ...x, resource: stripModule(String(x.resource)) }));
+    }
+    delete out.checks;
+    delete out.variables;
+    return out;
+}
+/** A plan's counts as the binary's `Plan:` line gives them. A no-op or read is not a change. */
+export function planCounts(plan) {
+    const rc = isObj(plan) && Array.isArray(plan.resource_changes) ? plan.resource_changes : [];
+    let add = 0;
+    let change = 0;
+    let destroy = 0;
+    let changes = 0;
+    for (const r of rc) {
+        const a = isObj(r) && isObj(r.change) && Array.isArray(r.change.actions) ? r.change.actions : [];
+        if (a.every((x) => x === "no-op" || x === "read"))
+            continue;
+        changes++;
+        if (a.includes("create"))
+            add++;
+        if (a.includes("delete"))
+            destroy++;
+        if (a.includes("update"))
+            change++;
+    }
+    return { add, change, destroy, changes, destroys: destroy };
+}
+/**
+ * One member's part of the composed plan's `show` text: the text before the
+ * actions, each resource block of its module with `module.<m>.` taken off,
+ * its line of counts, and its outputs by their own names.
+ */
+export function sliceText(text, m, counts) {
+    const lines = text.split("\n");
+    const head = [];
+    const blocks = [];
+    const outs = [];
+    let i = 0;
+    for (; i < lines.length && !/^\s{2}# /.test(lines[i]); i++) {
+        if (/^(Plan:|No changes\.|Changes to Outputs:)/.test(lines[i]))
+            break;
+        head.push(lines[i]);
+    }
+    let cur;
+    for (; i < lines.length; i++) {
+        const l = lines[i];
+        if (/^\s{2}# /.test(l)) {
+            cur = [l];
+            blocks.push(cur);
+        }
+        else if (/^(Plan:|Changes to Outputs:|─|Note:|Saved the plan)/.test(l)) {
+            cur = undefined;
+            if (l.startsWith("Changes to Outputs:")) {
+                for (i++; i < lines.length && /^\s/.test(lines[i]); i++)
+                    if (new RegExp(`^\\s+[-+~] ${m}__`).test(lines[i]))
+                        outs.push(lines[i].replace(`${m}__`, ""));
+                i--;
+            }
+        }
+        else if (cur)
+            cur.push(l);
+    }
+    const mine = blocks
+        .filter((b) => topModule(b[0].replace(/^\s{2}# /, "")) === m)
+        .map((b) => [b[0].replace(`module.${m}.`, ""), ...b.slice(1)].join("\n").trimEnd());
+    const parts = [head.join("\n").trimEnd()];
+    if (mine.length === 0 && outs.length === 0)
+        parts.push("No changes. Its part of the composed run matches the configuration.");
+    else {
+        if (mine.length)
+            parts.push(mine.join("\n\n"));
+        parts.push(`Plan: ${counts.add} to add, ${counts.change} to change, ${counts.destroy} to destroy.`);
+        if (outs.length)
+            parts.push(`Changes to Outputs:\n${outs.join("\n")}`);
+    }
+    return parts.filter((p) => p !== "").join("\n\n") + "\n";
+}
+// ── reads between members ─────────────────────────────────────────────────
+const escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+/**
+ * The names a root's files read off `data.<type>.<name>.<field>`, or
+ * undefined when they read the whole object. While the root is composed
+ * (./root.ts) a `terraform_remote_state` read is `var.chant_read_<name>`,
+ * which counts the same.
+ */
+function fieldsRead(dir, binary, type, name, field) {
+    const ref = type === "terraform_remote_state" ? `(?:data\\.${type}\\.|var\\.${READ_VAR_PREFIX})` : `data\\.${type}\\.`;
+    const re = new RegExp(`\\b${ref}${escapeRe(name)}(?![\\w-])(\\.${field}(?:\\.([A-Za-z_][\\w-]*)|\\[\\s*"([^"]+)"\\s*\\])?)?`, "g");
+    const read = new Set();
+    for (const t of dir ? rootTexts(dir, binary) : []) {
+        for (const hit of t.text.matchAll(re)) {
+            const out = hit[2] ?? hit[3];
+            if (!out)
+                return undefined;
+            read.add(out);
+        }
+    }
+    return read;
+}
+/**
+ * Each member's reads of other members, planned on the upstream's part of
+ * the composed plan: an output read that the upstream's planned outputs
+ * ({@link terraformPlannedOutputs} of its slice) leave unknown is named
+ * unknown. A `vars` read names its output; a `terraform_remote_state` or
+ * `terraform_estate_outputs` block's outputs are read from the member's own
+ * files, as terragucci's `outputsRead` and `estateValuesRead` did.
+ */
+export function composedReads(c, outputs) {
+    const out = new Map();
+    for (const member of c.members) {
+        const reads = [];
+        // Several `vars` reads of one upstream through one variable are one read.
+        const byKey = new Map();
+        for (const r of c.reads.get(member) ?? []) {
+            const planned = outputs.get(r.upstream);
+            if (!planned)
+                continue;
+            if (r.via === "vars") {
+                const key = `vars\u0000${r.upstream}\u0000${r.variable}`;
+                const had = byKey.get(key);
+                if (had)
+                    had.outputs.add(r.output);
+                else
+                    byKey.set(key, { r, outputs: new Set([r.output]) });
+            }
+            else {
+                const read = r.via === "remote-state" ? fieldsRead(c.dirs.get(member), c.binary, "terraform_remote_state", r.name, "outputs") : fieldsRead(c.dirs.get(member), c.binary, "terraform_estate_outputs", r.name, "values");
+                byKey.set(`${r.via}\u0000${r.upstream}\u0000${r.name}`, { r, ...(read ? { outputs: read } : {}) });
+            }
+        }
+        for (const { r, outputs: read } of byKey.values()) {
+            const planned = outputs.get(r.upstream);
+            const unknown = [...new Set(planned.unknown)].filter((o) => read === undefined || read.has(o)).sort();
+            reads.push({ upstream: r.upstream, via: r.via, name: r.via === "vars" ? r.variable : r.name, ...(read ? { outputs: [...read].sort() } : {}), unknown });
+        }
+        if (reads.length)
+            out.set(member, reads);
+    }
+    return out;
+}
+/**
+ * Every member's plan out of the composed plan's `show -json`, by component:
+ * {@link terraformChangeSetPart}, {@link terraformPlannedOutputs} and
+ * {@link terraformPlanShape} of its slice, so each member's part is the part
+ * a plan of its root alone gives on the same state. The member is the root's
+ * name (`Composition.roots`), as a single `terraform-apply` plan names it.
+ */
+export function composedMemberPlans(c, plan, options = {}) {
+    const slices = new Map(c.order.map((member) => [member, slicePlan(plan, c.modules.get(member))]));
+    const outputs = new Map(c.order.map((member) => [member, terraformPlannedOutputs(slices.get(member))]));
+    const reads = composedReads(c, outputs);
+    const result = {};
+    for (const member of c.order) {
+        const slice = slices.get(member);
+        const root = c.roots.get(member) ?? member;
+        const scope = options.scope?.(member);
+        const changeSet = terraformChangeSetPart({ member: root, plan: slice, ...(options.planner ? { planner: options.planner } : {}), ...(scope ? { scope } : {}) });
+        const mine = reads.get(member) ?? [];
+        const unknownInputs = [...new Set(mine.flatMap((r) => r.unknown.map((o) => `${r.upstream}.${o}`)))].sort();
+        result[member] = {
+            member: root,
+            planDigest: changeSet.member.planDigest ?? "",
+            changeSet,
+            outputs: outputs.get(member),
+            shape: terraformPlanShape(slice, root, { unknownInputs }),
+            slice,
+            counts: planCounts(slice),
+            reads: mine,
+        };
+    }
+    return result;
+}

package/dist/compose/state-address.d.ts

@@ -0,0 +1,28 @@
+/** Where one state is: its bucket, when the backend names one, and its key. */
+export interface StateKey {
+    bucket?: string;
+    key: string;
+}
+/** An address, or why the code does not say it. */
+export type Addressed = StateKey | {
+    unresolved: string;
+};
+/**
+ * One attribute as the code writes it: the string, `null` when it is written
+ * but is not a plain string (an expression, or a string with a template in
+ * it), undefined when it is not written.
+ */
+export type Attr = (name: string) => string | null | undefined;
+/** The types this module gives an address of their own. */
+export declare const ADDRESSED_TYPES: readonly ["local", "pg", "http", "consul", "kubernetes", "remote"];
+/** A plain string with no template in it, else null. */
+export declare function literal(v: unknown): string | null | undefined;
+/** The host and database of a Postgres connection string, in URL or `key=value` form. */
+export declare function pgDatabase(conn: string): string | undefined;
+/**
+ * The address of a state of backend `type`, from its attributes. `dir` is the
+ * directory the binary runs in for the block (the root's, relative to the
+ * repo), which a local path is resolved against.
+ */
+export declare function stateAddress(type: string, get: Attr, dir: string): Addressed;
+//# sourceMappingURL=state-address.d.ts.map

package/dist/compose/state-address.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-address.d.ts","sourceRoot":"","sources":["../../src/compose/state-address.ts"],"names":[],"mappings":"AA+BA,+EAA+E;AAC/E,MAAM,WAAW,QAAQ;IACvB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,GAAG,EAAE,MAAM,CAAC;CACb;AAED,mDAAmD;AACnD,MAAM,MAAM,SAAS,GAAG,QAAQ,GAAG;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC;AAE1D;;;;GAIG;AACH,MAAM,MAAM,IAAI,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;AAE/D,2DAA2D;AAC3D,eAAO,MAAM,eAAe,YAAI,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,EAAE,QAAQ,CAAU,CAAC;AAIlG,wDAAwD;AACxD,wBAAgB,OAAO,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,CAG7D;AAaD,yFAAyF;AACzF,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAgB3D;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,GAAG,SAAS,CA+D5E"}

package/dist/compose/state-address.js

@@ -0,0 +1,154 @@
+/**
+ * Lifted from terragucci's `packages/terragucci/src/state-address.ts` at c493e0e
+ * (chant#4438), unchanged but for this note.
+ *
+ * Where a state is, for each backend type, as a root's code names it: in the
+ * root's own backend block (or `cloud` block), and in a
+ * `terraform_remote_state` block that reads it. Two roots line up when the
+ * address one's backend names is the address the other's read names.
+ *
+ * s3, gcs, azurerm and any type not named here keep the address they always
+ * had: the bucket, when one is named, and the key (or `prefix`). The others
+ * get a key of their own, prefixed with the type so that no two types share
+ * one:
+ *
+ * - `local:<path>`: the state file, resolved against the root's directory and
+ *   written relative to the repo.
+ * - `pg:<host>/<database>/<schema>.<table>`: from `conn_str`, credentials left out.
+ * - `http:<address>`: the URL, credentials left out.
+ * - `consul:<address>/<path>`.
+ * - `kubernetes:<namespace>/<secret_suffix>`.
+ * - `remote:<hostname>/<organization>/<workspace>`: a `remote` backend or a `cloud` block.
+ *
+ * An address is unresolved when a part of it is not a plain string in the
+ * code: an expression such as `var.env`, or a value the backend takes from
+ * the environment or a `-backend-config` file (`PG_CONN_STR`,
+ * `TF_HTTP_ADDRESS`, `CONSUL_HTTP_ADDR`, `KUBE_NAMESPACE`,
+ * `TF_CLOUD_ORGANIZATION`, a workspace picked by tags or `TF_WORKSPACE`).
+ * Nothing can line it up with another root, so it is named instead.
+ */
+import { posix, sep } from "node:path";
+/** The types this module gives an address of their own. */
+export const ADDRESSED_TYPES = ["local", "pg", "http", "consul", "kubernetes", "remote"];
+const unresolved = (why) => ({ unresolved: why });
+/** A plain string with no template in it, else null. */
+export function literal(v) {
+    if (v === undefined)
+        return undefined;
+    return typeof v === "string" && !/\$\{|%\{/.test(v) ? v : null;
+}
+/** `scheme://user:pass@Host:port/path?q` as `host:port/path`, credentials and query left out. */
+function urlAddress(raw, keepScheme) {
+    try {
+        const u = new URL(raw.includes("://") ? raw : `http://${raw}`);
+        const path = u.pathname.replace(/\/+$/, "");
+        return `${keepScheme ? `${u.protocol}//` : ""}${u.host.toLowerCase()}${path}`;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** The host and database of a Postgres connection string, in URL or `key=value` form. */
+export function pgDatabase(conn) {
+    if (/^postgres(ql)?:\/\//i.test(conn)) {
+        try {
+            const u = new URL(conn);
+            const db = u.pathname.replace(/^\/+/, "") || u.searchParams.get("dbname");
+            const host = u.host.toLowerCase() || u.searchParams.get("host");
+            return host && db ? `${host}/${db}` : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    const kv = new Map([...conn.matchAll(/(\w+)\s*=\s*('(?:[^'\\]|\\.)*'|\S+)/g)].map((m) => [m[1], m[2].replace(/^'|'$/g, "")]));
+    const host = kv.get("host")?.toLowerCase();
+    const db = kv.get("dbname");
+    if (!host || !db)
+        return undefined;
+    return `${host}${kv.get("port") ? `:${kv.get("port")}` : ""}/${db}`;
+}
+/**
+ * The address of a state of backend `type`, from its attributes. `dir` is the
+ * directory the binary runs in for the block (the root's, relative to the
+ * repo), which a local path is resolved against.
+ */
+export function stateAddress(type, get, dir) {
+    const missing = (name, from) => unresolved(get(name) === null ? `its ${type} ${name} is an expression, not a plain string` : `its ${type} backend names no ${name} in the code (${from ? `${from} or ` : ""}a -backend-config file supplies it)`);
+    switch (type) {
+        case "local": {
+            const path = get("path");
+            if (path === null)
+                return missing("path");
+            const p = (path ?? "terraform.tfstate").split(sep).join(posix.sep);
+            // Relative to the repo, `/` between parts; a path outside the repo keeps its `..`, an absolute one stays as it is.
+            return { key: `local:${posix.isAbsolute(p) ? posix.normalize(p) : posix.normalize(posix.join(dir.split(sep).join(posix.sep) || ".", p))}` };
+        }
+        case "pg": {
+            const conn = get("conn_str");
+            if (!conn)
+                return missing("conn_str", "PG_CONN_STR");
+            const db = pgDatabase(conn);
+            if (!db)
+                return unresolved("its pg conn_str names no host and database");
+            const schema = get("schema_name");
+            const table = get("table_name");
+            if (schema === null)
+                return missing("schema_name");
+            if (table === null)
+                return missing("table_name");
+            return { key: `pg:${db}/${schema ?? "terraform_remote_state"}.${table ?? "states"}` };
+        }
+        case "http": {
+            const address = get("address");
+            if (!address)
+                return missing("address", "TF_HTTP_ADDRESS");
+            const url = urlAddress(address, true);
+            return url ? { key: `http:${url}` } : unresolved(`its http address is not a URL`);
+        }
+        case "consul": {
+            const address = get("address");
+            const path = get("path");
+            if (!path)
+                return missing("path");
+            if (!address)
+                return missing("address", "CONSUL_HTTP_ADDR");
+            const host = urlAddress(address, false);
+            return host ? { key: `consul:${host}/${path.replace(/^\/+/, "")}` } : unresolved("its consul address is not a host");
+        }
+        case "kubernetes": {
+            const suffix = get("secret_suffix");
+            const namespace = get("namespace");
+            if (!suffix)
+                return missing("secret_suffix");
+            if (!namespace)
+                return missing("namespace", "KUBE_NAMESPACE");
+            return { key: `kubernetes:${namespace}/${suffix}` };
+        }
+        case "remote":
+        case "cloud": {
+            const host = get("hostname");
+            const org = get("organization");
+            const name = get("name");
+            if (host === null)
+                return missing("hostname");
+            if (!org)
+                return missing("organization", type === "cloud" ? "TF_CLOUD_ORGANIZATION" : undefined);
+            if (name === null)
+                return unresolved(`its ${type} workspace name is an expression, not a plain string`);
+            if (name === undefined)
+                return unresolved(`its ${type} workspaces block names no workspace by name (one picked by tags, prefix or TF_WORKSPACE cannot be read from the code)`);
+            return { key: `remote:${(host ?? "app.terraform.io").toLowerCase()}/${org}/${name}` };
+        }
+    }
+    // s3, gcs, azurerm, and the types not named above: the bucket and key, as before.
+    const k = get("key");
+    const p = get("prefix");
+    const key = k || p;
+    if (!key)
+        return missing(k === null ? "key" : p === null ? "prefix" : type === "gcs" ? "prefix" : "key");
+    const bucket = get("bucket");
+    if (bucket === null)
+        return missing("bucket");
+    return { ...(bucket ? { bucket } : {}), key };
+}

package/dist/compose/state-merge.d.ts

@@ -0,0 +1,52 @@
+/**
+ * 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 type { Composition } from "../compose.js";
+import type { StateFile } from "../state/exec.js";
+/** What the derived lineages are derived from, beside the roots. */
+export declare 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 declare function derivedLineage(...parts: string[]): string;
+/** The members whose state the working state holds, in apply order. */
+type StateComposition = Pick<Composition, "order" | "modules" | "dirs"> & Partial<Pick<Composition, "roots" | "binary">>;
+/**
+ * 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 declare function mergeStates(c: StateComposition, pulled: ReadonlyMap<string, StateFile | null>): StateFile;
+/** One member's state out of the working state, and whether it holds what was pulled. */
+export interface SplitState {
+    state: StateFile;
+    /** It holds what was pulled (for a member with no state: nothing), so there is nothing to write. */
+    same: boolean;
+}
+/**
+ * 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 declare function splitState(working: StateFile, c: StateComposition, member: string, pulled: StateFile | null): SplitState;
+/** Every member's split state, by member, in apply order. */
+export declare function splitStates(working: StateFile, c: StateComposition, pulled: ReadonlyMap<string, StateFile | null>): Map<string, SplitState>;
+export {};
+//# sourceMappingURL=state-merge.d.ts.map

package/dist/compose/state-merge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-merge.d.ts","sourceRoot":"","sources":["../../src/compose/state-merge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAC9C,OAAO,KAAK,EAAE,SAAS,EAAiB,MAAM,eAAe,CAAC;AAI9D,oEAAoE;AACpE,eAAO,MAAM,eAAe,4BAA4B,CAAC;AAEzD,uIAAuI;AACvI,wBAAgB,cAAc,CAAC,GAAG,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,CAGzD;AAeD,uEAAuE;AACvE,KAAK,gBAAgB,GAAG,IAAI,CAAC,WAAW,EAAE,OAAO,GAAG,SAAS,GAAG,MAAM,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,WAAW,EAAE,OAAO,GAAG,QAAQ,CAAC,CAAC,CAAC;AAEzH;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,gBAAgB,EAAE,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAAC,GAAG,SAAS,CAsBzG;AA0BD,yFAAyF;AACzF,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,SAAS,CAAC;IACjB,oGAAoG;IACpG,IAAI,EAAE,OAAO,CAAC;CACf;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,SAAS,EAAE,CAAC,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,GAAG,IAAI,GAAG,UAAU,CAuBxH;AAED,6DAA6D;AAC7D,wBAAgB,WAAW,CAAC,OAAO,EAAE,SAAS,EAAE,CAAC,EAAE,gBAAgB,EAAE,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAE3I"}