@intentius/chant-lexicon-terraform 0.124.76 → 0.124.78
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/drift-record.d.ts +24 -0
- package/dist/drift-record.d.ts.map +1 -1
- package/dist/drift-record.js +52 -0
- package/dist/drift-rows.d.ts +49 -4
- package/dist/drift-rows.d.ts.map +1 -1
- package/dist/drift-rows.js +87 -19
- package/dist/integrity.json +2 -2
- package/dist/manifest.json +1 -1
- package/dist/pr-env.d.ts +138 -0
- package/dist/pr-env.d.ts.map +1 -0
- package/dist/pr-env.js +248 -0
- package/dist/state/gitlab.d.ts +74 -0
- package/dist/state/gitlab.d.ts.map +1 -0
- package/dist/state/gitlab.js +275 -0
- package/dist/state/index.d.ts +2 -0
- package/dist/state/index.d.ts.map +1 -1
- package/dist/state/index.js +2 -0
- package/dist/state/store.d.ts +2 -1
- package/dist/state/store.d.ts.map +1 -1
- package/dist/state/versions.d.ts +39 -0
- package/dist/state/versions.d.ts.map +1 -0
- package/dist/state/versions.js +85 -0
- package/dist/state-migration.d.ts +85 -0
- package/dist/state-migration.d.ts.map +1 -0
- package/dist/state-migration.js +296 -0
- package/dist/state-ops.d.ts +54 -87
- package/dist/state-ops.d.ts.map +1 -1
- package/dist/state-ops.js +120 -77
- package/package.json +2 -2
- package/src/__fixtures__/drift-rows/refresh-plan-module.json +48 -0
- package/src/drift-record.test.ts +62 -0
- package/src/drift-record.ts +58 -0
- package/src/drift-rows.test.ts +90 -1
- package/src/drift-rows.ts +89 -18
- package/src/pr-env.test.ts +132 -0
- package/src/pr-env.ts +312 -0
- package/src/state/gitlab.test.ts +226 -0
- package/src/state/gitlab.ts +318 -0
- package/src/state/index.ts +2 -0
- package/src/state/store.ts +2 -1
- package/src/state/versions.ts +103 -0
- package/src/state-export-unlock.test.ts +230 -0
- package/src/state-migration.test.ts +236 -0
- package/src/state-migration.ts +353 -0
- package/src/state-ops.ts +132 -130
package/dist/drift-record.d.ts
CHANGED
|
@@ -11,6 +11,7 @@
|
|
|
11
11
|
* | `live-plan -json` | `ownership` | `bound[]`: in-sync, owned by its `source`. `unowned[]` and `adoptable[]`: unclaimed. `ABSENT`: pending. Any other omission: not-observed. `foreign[]`: undeclared, foreign. `controller_held[]`: runtime |
|
|
12
12
|
* | `live-ls -json` | `ownership` | `declared: false`: undeclared. A gap no live-plan row answers: not-observed |
|
|
13
13
|
* | live-plan and a plan together | `plan` | bound with a planned update or replace: drifted with paths, the live-plan ownership kept |
|
|
14
|
+
* | `show -json` of a live root's full plan | `plan` | planned create: missing. Planned delete or forget: undeclared. Update or any pair of actions: drifted with paths, declared then live. No-op: in-sync |
|
|
14
15
|
*
|
|
15
16
|
* A state read never says in-sync or drifted: `driftRecord` refuses it.
|
|
16
17
|
*
|
|
@@ -77,6 +78,29 @@ export interface TerraformPlanDriftInput extends DriftAdapterBase {
|
|
|
77
78
|
* configuration is the change set's to show and not drift.
|
|
78
79
|
*/
|
|
79
80
|
export declare function terraformPlanDriftRecords(input: TerraformPlanDriftInput): DriftRecord[];
|
|
81
|
+
export interface TerraformLivePlanDriftInput extends DriftAdapterBase {
|
|
82
|
+
/** The engine that planned the root. Default `choudoufu`, which plans a live root. */
|
|
83
|
+
engine?: "choudoufu" | "terraform" | "tofu";
|
|
84
|
+
/** `show -json <planfile>` of the root's full plan, parsed. */
|
|
85
|
+
plan: unknown;
|
|
86
|
+
}
|
|
87
|
+
/**
|
|
88
|
+
* A live root's records from its full plan, read as drift (#4812). A root
|
|
89
|
+
* under live resource markers takes no refresh-only plan, and its plan reads
|
|
90
|
+
* the live system, so what the plan would change is what moved outside the
|
|
91
|
+
* code: one record per managed instance in `resource_changes`, a planned
|
|
92
|
+
* create missing (the object no longer exists), a planned delete or forget
|
|
93
|
+
* undeclared (it exists outside the code), an update or any pair of actions
|
|
94
|
+
* drifted with the plan's paths, declared before and live after, and a
|
|
95
|
+
* no-op in-sync. A path whose declared value is known only after the apply
|
|
96
|
+
* is not a difference and is left out. `resource_drift` is not read.
|
|
97
|
+
*
|
|
98
|
+
* The rules are drift-rows' `live: true` read (`./drift-rows.ts`), so the
|
|
99
|
+
* records that are not in-sync are its rows. `choudoufuLivePlusPlanDriftRecords`
|
|
100
|
+
* is the read for a root whose `live-plan -json` was taken too: it keeps
|
|
101
|
+
* live-plan's ownership, which a plan alone does not give.
|
|
102
|
+
*/
|
|
103
|
+
export declare function terraformLivePlanDriftRecords(input: TerraformLivePlanDriftInput): DriftRecord[];
|
|
80
104
|
export interface ChoudoufuLivePlanDriftInput extends DriftAdapterBase {
|
|
81
105
|
/** `choudoufu live-plan -json`, parsed. */
|
|
82
106
|
livePlan: unknown;
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"drift-record.d.ts","sourceRoot":"","sources":["../src/drift-record.ts"],"names":[],"mappings":"AAAA
|
|
1
|
+
{"version":3,"file":"drift-record.d.ts","sourceRoot":"","sources":["../src/drift-record.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAEH,OAAO,EAGL,KAAK,gBAAgB,EAKrB,KAAK,WAAW,EACjB,MAAM,+BAA+B,CAAC;AAiEvC,MAAM,WAAW,wBAAyB,SAAQ,gBAAgB;IAChE,MAAM,CAAC,EAAE,WAAW,GAAG,MAAM,CAAC;IAC9B,yFAAyF;IACzF,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7B,8EAA8E;IAC9E,MAAM,CAAC,EAAE;QAAE,MAAM,EAAE,aAAa,GAAG,gBAAgB,GAAG,YAAY,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CACvF;AAED;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,wBAAwB,GAAG,WAAW,EAAE,CA0BzF;AAID,MAAM,WAAW,uBAAwB,SAAQ,gBAAgB;IAC/D,MAAM,CAAC,EAAE,WAAW,GAAG,MAAM,CAAC;IAC9B,iDAAiD;IACjD,IAAI,EAAE,OAAO,CAAC;CACf;AAED;;;;;;;;GAQG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,uBAAuB,GAAG,WAAW,EAAE,CA0BvF;AAED,MAAM,WAAW,2BAA4B,SAAQ,gBAAgB;IACnE,sFAAsF;IACtF,MAAM,CAAC,EAAE,WAAW,GAAG,WAAW,GAAG,MAAM,CAAC;IAC5C,+DAA+D;IAC/D,IAAI,EAAE,OAAO,CAAC;CACf;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,2BAA2B,GAAG,WAAW,EAAE,CAgC/F;AAMD,MAAM,WAAW,2BAA4B,SAAQ,gBAAgB;IACnE,2CAA2C;IAC3C,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,2BAA2B,GAAG,WAAW,EAAE,CA2F/F;AAID,MAAM,WAAW,yBAA0B,SAAQ,gBAAgB;IACjE,yCAAyC;IACzC,MAAM,EAAE,OAAO,CAAC;IAChB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;CAC7B;AAED;;;;;;;;GAQG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,yBAAyB,GAAG,WAAW,EAAE,CAmD3F;AAED,kGAAkG;AAClG,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,gBAAgB,GAAG;IAAE,QAAQ,EAAE,OAAO,CAAC;IAAC,MAAM,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,WAAW,EAAE,CAM1H;AAID,MAAM,WAAW,+BAAgC,SAAQ,gBAAgB;IACvE,2CAA2C;IAC3C,QAAQ,EAAE,OAAO,CAAC;IAClB,kEAAkE;IAClE,IAAI,EAAE,OAAO,CAAC;IACd,+DAA+D;IAC/D,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;GAOG;AACH,wBAAgB,iCAAiC,CAAC,KAAK,EAAE,+BAA+B,GAAG,WAAW,EAAE,CAqBvG"}
|
package/dist/drift-record.js
CHANGED
|
@@ -11,6 +11,7 @@
|
|
|
11
11
|
* | `live-plan -json` | `ownership` | `bound[]`: in-sync, owned by its `source`. `unowned[]` and `adoptable[]`: unclaimed. `ABSENT`: pending. Any other omission: not-observed. `foreign[]`: undeclared, foreign. `controller_held[]`: runtime |
|
|
12
12
|
* | `live-ls -json` | `ownership` | `declared: false`: undeclared. A gap no live-plan row answers: not-observed |
|
|
13
13
|
* | live-plan and a plan together | `plan` | bound with a planned update or replace: drifted with paths, the live-plan ownership kept |
|
|
14
|
+
* | `show -json` of a live root's full plan | `plan` | planned create: missing. Planned delete or forget: undeclared. Update or any pair of actions: drifted with paths, declared then live. No-op: in-sync |
|
|
14
15
|
*
|
|
15
16
|
* A state read never says in-sync or drifted: `driftRecord` refuses it.
|
|
16
17
|
*
|
|
@@ -170,6 +171,57 @@ export function terraformPlanDriftRecords(input) {
|
|
|
170
171
|
return driftRecord({ ...at, status: "in-sync" });
|
|
171
172
|
});
|
|
172
173
|
}
|
|
174
|
+
/**
|
|
175
|
+
* A live root's records from its full plan, read as drift (#4812). A root
|
|
176
|
+
* under live resource markers takes no refresh-only plan, and its plan reads
|
|
177
|
+
* the live system, so what the plan would change is what moved outside the
|
|
178
|
+
* code: one record per managed instance in `resource_changes`, a planned
|
|
179
|
+
* create missing (the object no longer exists), a planned delete or forget
|
|
180
|
+
* undeclared (it exists outside the code), an update or any pair of actions
|
|
181
|
+
* drifted with the plan's paths, declared before and live after, and a
|
|
182
|
+
* no-op in-sync. A path whose declared value is known only after the apply
|
|
183
|
+
* is not a difference and is left out. `resource_drift` is not read.
|
|
184
|
+
*
|
|
185
|
+
* The rules are drift-rows' `live: true` read (`./drift-rows.ts`), so the
|
|
186
|
+
* records that are not in-sync are its rows. `choudoufuLivePlusPlanDriftRecords`
|
|
187
|
+
* is the read for a root whose `live-plan -json` was taken too: it keeps
|
|
188
|
+
* live-plan's ownership, which a plan alone does not give.
|
|
189
|
+
*/
|
|
190
|
+
export function terraformLivePlanDriftRecords(input) {
|
|
191
|
+
const engine = input.engine ?? "choudoufu";
|
|
192
|
+
const doc = isObject(input.plan) ? input.plan : {};
|
|
193
|
+
const version = input.version ?? asString(doc.terraform_version);
|
|
194
|
+
const evidence = { tool: engine, ...(version ? { version } : {}), command: `${engine} show -json` };
|
|
195
|
+
const index = indexPlan(input.plan);
|
|
196
|
+
const types = new Map();
|
|
197
|
+
for (const entry of asArray(doc.resource_changes)) {
|
|
198
|
+
if (isObject(entry) && asString(entry.address) && asString(entry.type))
|
|
199
|
+
types.set(entry.address, entry.type);
|
|
200
|
+
}
|
|
201
|
+
const out = [];
|
|
202
|
+
for (const [address, change] of index.changes) {
|
|
203
|
+
if (isDataAddress(address))
|
|
204
|
+
continue;
|
|
205
|
+
const type = types.get(address);
|
|
206
|
+
const at = { ...common(input, engine, "plan", address), ...(type ? { resourceType: type } : {}), evidence };
|
|
207
|
+
const actions = change.actions.filter((a) => a !== "no-op" && a !== "read");
|
|
208
|
+
if (actions.length === 0) {
|
|
209
|
+
out.push(driftRecord({ ...at, status: "in-sync" }));
|
|
210
|
+
continue;
|
|
211
|
+
}
|
|
212
|
+
if (change.actions.length === 1 && actions[0] === "create") {
|
|
213
|
+
out.push(driftRecord({ ...at, status: "missing" }));
|
|
214
|
+
continue;
|
|
215
|
+
}
|
|
216
|
+
if (change.actions.length === 1 && (actions[0] === "delete" || actions[0] === "forget")) {
|
|
217
|
+
out.push(driftRecord({ ...at, status: "undeclared" }));
|
|
218
|
+
continue;
|
|
219
|
+
}
|
|
220
|
+
const attributes = change.changes.filter((c) => c.after !== KNOWN_AFTER_APPLY).map((c) => attributeOf(c, true));
|
|
221
|
+
out.push(driftRecord({ ...at, status: "drifted", ...(attributes.length > 0 ? { attributes } : {}) }));
|
|
222
|
+
}
|
|
223
|
+
return out.sort(byAddress);
|
|
224
|
+
}
|
|
173
225
|
// ── choudoufu live-plan ────────────────────────────────────────────────────────
|
|
174
226
|
const BOUND_SOURCES = ["marker", "record", "derived", "cache"];
|
|
175
227
|
/**
|
package/dist/drift-rows.d.ts
CHANGED
|
@@ -2,8 +2,8 @@
|
|
|
2
2
|
* Drift rows (#4580): one row per object a plan found drifted, by address,
|
|
3
3
|
* with its action and the object's real name, counted the way a product's
|
|
4
4
|
* drift report counts. `./drift-record.ts` answers a different question (the
|
|
5
|
-
* status of each instance the plan names), so it skips create
|
|
6
|
-
*
|
|
5
|
+
* status of each instance the plan names, redacted), so it skips create
|
|
6
|
+
* rows and carries no names.
|
|
7
7
|
*
|
|
8
8
|
* A stock root's refresh-only plan reports drift as `resource_drift`, and
|
|
9
9
|
* every entry there is one row, data blocks and creates included. A full
|
|
@@ -14,8 +14,15 @@
|
|
|
14
14
|
* Data blocks, no-op and read entries are not drift.
|
|
15
15
|
*
|
|
16
16
|
* These are terragucci's rules (packages/terragucci/src/report/drift.ts:
|
|
17
|
-
* `liveDrift`, `driftCount`, `driftNames`), so a row count here
|
|
18
|
-
* count its report gives for the same plan.
|
|
17
|
+
* `driftPlan`, `liveDrift`, `driftCount`, `driftNames`), so a row count here
|
|
18
|
+
* equals the count its report gives for the same plan.
|
|
19
|
+
*
|
|
20
|
+
* Behind every row is a whole change (#4812): the plan's entry for the
|
|
21
|
+
* object, shaped as a `resource_changes[]` entry with its actions, full
|
|
22
|
+
* before and after and their masks (`terraformPlanDriftChanges`). A drift
|
|
23
|
+
* report is a plan report over those changes: `terraformDriftPlan` puts a
|
|
24
|
+
* refresh-only plan's drift in place of its changes, and
|
|
25
|
+
* `terraformLivePlanDrift` reads a live root's full plan as drift.
|
|
19
26
|
*
|
|
20
27
|
* A row carries no attribute values. Its `name` is the first non-empty
|
|
21
28
|
* string among `name`, `id`, `bucket`, `function_name` and `arn`, read from
|
|
@@ -49,6 +56,44 @@ export interface TerraformPlanDriftRowsOptions {
|
|
|
49
56
|
*/
|
|
50
57
|
live?: boolean;
|
|
51
58
|
}
|
|
59
|
+
/**
|
|
60
|
+
* The drift a plan (`show -json`, parsed) found as whole changes (#4812),
|
|
61
|
+
* one per drifted object in the plan's order, each shaped as a
|
|
62
|
+
* `resource_changes[]` entry: `address`, `mode`, `type`, `name`,
|
|
63
|
+
* `module_address`, `index`, `deposed` and `provider_name` as the plan has
|
|
64
|
+
* them, and `change` with its actions, its full before and after, and their
|
|
65
|
+
* masks. A stock root's are its `resource_drift` entries unchanged. A live
|
|
66
|
+
* root's are its full plan's changes seen from the other side: a create
|
|
67
|
+
* there is a `delete` (the object no longer exists), a delete a `create`
|
|
68
|
+
* (an object exists outside the code), any pair of actions an `update`, the
|
|
69
|
+
* code's value before and the live one after, the sensitive masks swapped
|
|
70
|
+
* with them and an unknown value replaced by the live one.
|
|
71
|
+
*
|
|
72
|
+
* Values are not redacted: a change carries what the plan carries, masks
|
|
73
|
+
* included, for a report that renders the plan. A drift record
|
|
74
|
+
* (`./drift-record.ts`) is the redacted read.
|
|
75
|
+
*
|
|
76
|
+
* Its length is the drift count, and `terraformPlanDriftRows` is one row
|
|
77
|
+
* per entry. A malformed `resource_drift` entry that is not an object is
|
|
78
|
+
* passed on as the plan has it, and its row has the address `""`.
|
|
79
|
+
*/
|
|
80
|
+
export declare function terraformPlanDriftChanges(plan: unknown, options?: TerraformPlanDriftRowsOptions): Record<string, unknown>[];
|
|
81
|
+
/**
|
|
82
|
+
* A refresh-only plan as its drift report reads it: the drift found in place
|
|
83
|
+
* of the changes proposed, so the report is built from the same JSON as a
|
|
84
|
+
* plan's and code waiting on the default branch never shows in it.
|
|
85
|
+
* `resource_changes` becomes `terraformPlanDriftChanges(plan)`; the rest of
|
|
86
|
+
* the document is kept. Anything not an object is returned as it is.
|
|
87
|
+
*/
|
|
88
|
+
export declare function terraformDriftPlan(plan: unknown): unknown;
|
|
89
|
+
/**
|
|
90
|
+
* A full plan of a root under live resource markers, as drift: its
|
|
91
|
+
* `resource_drift` becomes `terraformPlanDriftChanges(plan, { live: true })`
|
|
92
|
+
* and the rest of the document is kept, so it reads as a refresh-only plan
|
|
93
|
+
* would (`terraformDriftPlan`, and every function here without `live`).
|
|
94
|
+
* Anything not an object is returned as it is.
|
|
95
|
+
*/
|
|
96
|
+
export declare function terraformLivePlanDrift(plan: unknown): unknown;
|
|
52
97
|
/**
|
|
53
98
|
* The drift a plan (`show -json`, parsed) found, one row per drifted object
|
|
54
99
|
* in the plan's order. Its length is the drift count.
|
package/dist/drift-rows.d.ts.map
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"drift-rows.d.ts","sourceRoot":"","sources":["../src/drift-rows.ts"],"names":[],"mappings":"AAAA
|
|
1
|
+
{"version":3,"file":"drift-rows.d.ts","sourceRoot":"","sources":["../src/drift-rows.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAMH,0BAA0B;AAC1B,MAAM,WAAW,iBAAiB;IAChC,iEAAiE;IACjE,OAAO,EAAE,MAAM,CAAC;IAChB;;;;;OAKG;IACH,MAAM,EAAE,MAAM,CAAC;IACf,mDAAmD;IACnD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,mEAAmE;IACnE,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,6BAA6B;IAC5C;;;;OAIG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AA4ED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,GAAE,6BAAkC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAG/H;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAGzD;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAG7D;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,GAAE,6BAAkC,GAAG,iBAAiB,EAAE,CAEtH;AAED,6FAA6F;AAC7F,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,GAAE,6BAAkC,GAAG,MAAM,CAE1G;AAED,8EAA8E;AAC9E,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,GAAE,6BAAkC,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAIvH"}
|
package/dist/drift-rows.js
CHANGED
|
@@ -2,8 +2,8 @@
|
|
|
2
2
|
* Drift rows (#4580): one row per object a plan found drifted, by address,
|
|
3
3
|
* with its action and the object's real name, counted the way a product's
|
|
4
4
|
* drift report counts. `./drift-record.ts` answers a different question (the
|
|
5
|
-
* status of each instance the plan names), so it skips create
|
|
6
|
-
*
|
|
5
|
+
* status of each instance the plan names, redacted), so it skips create
|
|
6
|
+
* rows and carries no names.
|
|
7
7
|
*
|
|
8
8
|
* A stock root's refresh-only plan reports drift as `resource_drift`, and
|
|
9
9
|
* every entry there is one row, data blocks and creates included. A full
|
|
@@ -14,8 +14,15 @@
|
|
|
14
14
|
* Data blocks, no-op and read entries are not drift.
|
|
15
15
|
*
|
|
16
16
|
* These are terragucci's rules (packages/terragucci/src/report/drift.ts:
|
|
17
|
-
* `liveDrift`, `driftCount`, `driftNames`), so a row count here
|
|
18
|
-
* count its report gives for the same plan.
|
|
17
|
+
* `driftPlan`, `liveDrift`, `driftCount`, `driftNames`), so a row count here
|
|
18
|
+
* equals the count its report gives for the same plan.
|
|
19
|
+
*
|
|
20
|
+
* Behind every row is a whole change (#4812): the plan's entry for the
|
|
21
|
+
* object, shaped as a `resource_changes[]` entry with its actions, full
|
|
22
|
+
* before and after and their masks (`terraformPlanDriftChanges`). A drift
|
|
23
|
+
* report is a plan report over those changes: `terraformDriftPlan` puts a
|
|
24
|
+
* refresh-only plan's drift in place of its changes, and
|
|
25
|
+
* `terraformLivePlanDrift` reads a live root's full plan as drift.
|
|
19
26
|
*
|
|
20
27
|
* A row carries no attribute values. Its `name` is the first non-empty
|
|
21
28
|
* string among `name`, `id`, `bucket`, `function_name` and `arn`, read from
|
|
@@ -54,17 +61,22 @@ function stockAction(actions) {
|
|
|
54
61
|
return "replace";
|
|
55
62
|
return "update";
|
|
56
63
|
}
|
|
57
|
-
/**
|
|
58
|
-
function
|
|
59
|
-
|
|
60
|
-
return list.map((entry) => {
|
|
64
|
+
/** One row per whole change. */
|
|
65
|
+
function rowsOf(changes) {
|
|
66
|
+
return changes.map((entry) => {
|
|
61
67
|
const ch = isObject(entry) && isObject(entry.change) ? entry.change : {};
|
|
62
68
|
const actions = Array.isArray(ch.actions) ? ch.actions.map(String) : [];
|
|
63
69
|
return rowOf(entry, stockAction(actions), [ch.after, ch.before]);
|
|
64
70
|
});
|
|
65
71
|
}
|
|
66
|
-
/**
|
|
67
|
-
|
|
72
|
+
/**
|
|
73
|
+
* A live root's full plan, its changes read as drift: each one the plan
|
|
74
|
+
* would make, seen from the other side, as terragucci's `liveDrift` builds
|
|
75
|
+
* it. The code's value is before and the live value after, the masks swap
|
|
76
|
+
* with them, and a value the plan knows only after the apply takes the live
|
|
77
|
+
* one, since it is not a difference.
|
|
78
|
+
*/
|
|
79
|
+
function liveChanges(doc) {
|
|
68
80
|
const list = Array.isArray(doc.resource_changes) ? doc.resource_changes : [];
|
|
69
81
|
const out = [];
|
|
70
82
|
for (const entry of list) {
|
|
@@ -75,24 +87,80 @@ function liveRows(doc) {
|
|
|
75
87
|
if (actions.length === 0 || actions.every((a) => a === "no-op" || a === "read"))
|
|
76
88
|
continue;
|
|
77
89
|
const action = actions.length === 1 ? (FLIP[actions[0]] ?? actions[0]) : "update";
|
|
78
|
-
const live =
|
|
79
|
-
let code =
|
|
80
|
-
// A value the plan knows only after the apply is not a difference: the live one stands for it.
|
|
90
|
+
const live = (ch.before ?? null);
|
|
91
|
+
let code = (ch.after ?? null);
|
|
81
92
|
const unknown = isObject(ch.after_unknown) ? ch.after_unknown : {};
|
|
82
|
-
if (code && live)
|
|
83
|
-
|
|
84
|
-
|
|
93
|
+
if (isObject(code) && isObject(live)) {
|
|
94
|
+
const known = live;
|
|
95
|
+
code = { ...code, ...Object.fromEntries(Object.keys(unknown).filter((k) => unknown[k] === true && k in known).map((k) => [k, known[k]])) };
|
|
96
|
+
}
|
|
97
|
+
out.push({
|
|
98
|
+
...entry,
|
|
99
|
+
change: { actions: [action], before: code, after: live, before_sensitive: ch.after_sensitive ?? false, after_sensitive: ch.before_sensitive ?? false },
|
|
100
|
+
});
|
|
85
101
|
}
|
|
86
102
|
return out;
|
|
87
103
|
}
|
|
104
|
+
/** A refresh-only plan's `resource_drift`, each entry as the plan has it. */
|
|
105
|
+
function stockChanges(doc) {
|
|
106
|
+
return (Array.isArray(doc.resource_drift) ? [...doc.resource_drift] : []);
|
|
107
|
+
}
|
|
108
|
+
/**
|
|
109
|
+
* The drift a plan (`show -json`, parsed) found as whole changes (#4812),
|
|
110
|
+
* one per drifted object in the plan's order, each shaped as a
|
|
111
|
+
* `resource_changes[]` entry: `address`, `mode`, `type`, `name`,
|
|
112
|
+
* `module_address`, `index`, `deposed` and `provider_name` as the plan has
|
|
113
|
+
* them, and `change` with its actions, its full before and after, and their
|
|
114
|
+
* masks. A stock root's are its `resource_drift` entries unchanged. A live
|
|
115
|
+
* root's are its full plan's changes seen from the other side: a create
|
|
116
|
+
* there is a `delete` (the object no longer exists), a delete a `create`
|
|
117
|
+
* (an object exists outside the code), any pair of actions an `update`, the
|
|
118
|
+
* code's value before and the live one after, the sensitive masks swapped
|
|
119
|
+
* with them and an unknown value replaced by the live one.
|
|
120
|
+
*
|
|
121
|
+
* Values are not redacted: a change carries what the plan carries, masks
|
|
122
|
+
* included, for a report that renders the plan. A drift record
|
|
123
|
+
* (`./drift-record.ts`) is the redacted read.
|
|
124
|
+
*
|
|
125
|
+
* Its length is the drift count, and `terraformPlanDriftRows` is one row
|
|
126
|
+
* per entry. A malformed `resource_drift` entry that is not an object is
|
|
127
|
+
* passed on as the plan has it, and its row has the address `""`.
|
|
128
|
+
*/
|
|
129
|
+
export function terraformPlanDriftChanges(plan, options = {}) {
|
|
130
|
+
if (!isObject(plan))
|
|
131
|
+
return [];
|
|
132
|
+
return options.live ? liveChanges(plan) : stockChanges(plan);
|
|
133
|
+
}
|
|
134
|
+
/**
|
|
135
|
+
* A refresh-only plan as its drift report reads it: the drift found in place
|
|
136
|
+
* of the changes proposed, so the report is built from the same JSON as a
|
|
137
|
+
* plan's and code waiting on the default branch never shows in it.
|
|
138
|
+
* `resource_changes` becomes `terraformPlanDriftChanges(plan)`; the rest of
|
|
139
|
+
* the document is kept. Anything not an object is returned as it is.
|
|
140
|
+
*/
|
|
141
|
+
export function terraformDriftPlan(plan) {
|
|
142
|
+
if (!isObject(plan))
|
|
143
|
+
return plan;
|
|
144
|
+
return { ...plan, resource_changes: terraformPlanDriftChanges(plan) };
|
|
145
|
+
}
|
|
146
|
+
/**
|
|
147
|
+
* A full plan of a root under live resource markers, as drift: its
|
|
148
|
+
* `resource_drift` becomes `terraformPlanDriftChanges(plan, { live: true })`
|
|
149
|
+
* and the rest of the document is kept, so it reads as a refresh-only plan
|
|
150
|
+
* would (`terraformDriftPlan`, and every function here without `live`).
|
|
151
|
+
* Anything not an object is returned as it is.
|
|
152
|
+
*/
|
|
153
|
+
export function terraformLivePlanDrift(plan) {
|
|
154
|
+
if (!isObject(plan))
|
|
155
|
+
return plan;
|
|
156
|
+
return { ...plan, resource_drift: terraformPlanDriftChanges(plan, { live: true }) };
|
|
157
|
+
}
|
|
88
158
|
/**
|
|
89
159
|
* The drift a plan (`show -json`, parsed) found, one row per drifted object
|
|
90
160
|
* in the plan's order. Its length is the drift count.
|
|
91
161
|
*/
|
|
92
162
|
export function terraformPlanDriftRows(plan, options = {}) {
|
|
93
|
-
|
|
94
|
-
return [];
|
|
95
|
-
return options.live ? liveRows(plan) : stockRows(plan);
|
|
163
|
+
return rowsOf(terraformPlanDriftChanges(plan, options));
|
|
96
164
|
}
|
|
97
165
|
/** How many objects a plan found drifted: `terraformPlanDriftRows(plan, options).length`. */
|
|
98
166
|
export function terraformPlanDriftCount(plan, options = {}) {
|
package/dist/integrity.json
CHANGED
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
{
|
|
2
2
|
"algorithm": "sha256",
|
|
3
3
|
"artifacts": {
|
|
4
|
-
"manifest.json": "
|
|
4
|
+
"manifest.json": "8ad4ee999ef6cc002b43068ba53aed3520d22ee0544e0ece887f9777542f7df7",
|
|
5
5
|
"meta.json": "ca3d163bab055381827226140568f3bef7eaac187cebd76878e0b63e9e442356",
|
|
6
6
|
"types/index.d.ts": "022927e6a7b351cc4cf52d5f973f60ccd140e5810e17b32fb8868965aa1db161",
|
|
7
7
|
"rules/plan-before-apply.ts": "7c10245b2c3335253b48ee7d8b075d89f43116bde20313a5d1031b343fef1282",
|
|
@@ -59,5 +59,5 @@
|
|
|
59
59
|
"rules/tf047.ts": "bfa86f85c4c5efff297280fc2f15104d6319fa96dfc444a31829fb7353224092",
|
|
60
60
|
"skills/chant-terraform.md": "53dd11c7b289652f92fdaf2c03766abda46d8964e31fe709e8b142ced4f19c50"
|
|
61
61
|
},
|
|
62
|
-
"composite": "
|
|
62
|
+
"composite": "dc15705fd3b8efb31bb5e9de4d327c106926808c0f59f7ffb0ce1c160e5d0ede"
|
|
63
63
|
}
|
package/dist/manifest.json
CHANGED
package/dist/pr-env.d.ts
ADDED
|
@@ -0,0 +1,138 @@
|
|
|
1
|
+
import { type PrEnvComponentPlan } from "@intentius/chant/components/pr-env-components";
|
|
2
|
+
import type { PrEnvAdapter } from "@intentius/chant/components/pr-env-run";
|
|
3
|
+
import type { LivePrEnvironment, PrEnvTeardownAdapter } from "@intentius/chant/components/pr-environment";
|
|
4
|
+
import type { BinaryExec } from "./state/exec.js";
|
|
5
|
+
/** The backends a copy can be given a key of its own on, and the attribute that holds the key. */
|
|
6
|
+
export declare const KEY_ATTRIBUTE: Readonly<Record<string, string>>;
|
|
7
|
+
/** The http backend's attributes that name the state too: its lock's, `<address>/lock` on GitLab. */
|
|
8
|
+
export declare const HTTP_LOCK_ATTRIBUTES: readonly ["lock_address", "unlock_address"];
|
|
9
|
+
/** A root no copy can be made of, or a prepared root whose key is its own. A config error: nothing planned. */
|
|
10
|
+
export declare class CopyRefusedError extends Error {
|
|
11
|
+
constructor(message: string);
|
|
12
|
+
}
|
|
13
|
+
/**
|
|
14
|
+
* A state key with the suffix: before a closing `.tfstate`, else at the end.
|
|
15
|
+
* `envs/dev/terraform.tfstate` becomes `envs/dev/terraform-pr-7.tfstate`.
|
|
16
|
+
*/
|
|
17
|
+
export declare function suffixedKey(key: string, suffix: string): string;
|
|
18
|
+
/** Whether a key or location carries a copy's suffix as {@link suffixedKey} puts it. A GitLab lock address is read without its `/lock`. */
|
|
19
|
+
export declare const carriesSuffix: (key: string, suffix: string) => boolean;
|
|
20
|
+
/** A copy's backend: the attribute and suffixed key, any other attribute it sets, and where the copy is. */
|
|
21
|
+
export interface CopyBackend {
|
|
22
|
+
type: string;
|
|
23
|
+
attribute: string;
|
|
24
|
+
key: string;
|
|
25
|
+
location: string;
|
|
26
|
+
/** Further `-backend-config` pairs: a GitLab copy's lock addresses. */
|
|
27
|
+
extra?: Record<string, string>;
|
|
28
|
+
}
|
|
29
|
+
/**
|
|
30
|
+
* A GitLab-managed state's attributes for its copy: the address and each
|
|
31
|
+
* lock address with the state name suffixed. Each is the configured one,
|
|
32
|
+
* else its `TF_HTTP_*` variable, as the binary reads it.
|
|
33
|
+
*/
|
|
34
|
+
export declare function gitlabCopy(root: string, config: Record<string, unknown>, env: NodeJS.ProcessEnv, suffix: string): {
|
|
35
|
+
key: string;
|
|
36
|
+
extra: Record<string, string>;
|
|
37
|
+
};
|
|
38
|
+
/**
|
|
39
|
+
* The `-backend-config` a root's copy is initialised with, from the backend
|
|
40
|
+
* its code declares with the job's flags over it. Throws
|
|
41
|
+
* {@link CopyRefusedError} for a root no copy can be made of: a `cloud`
|
|
42
|
+
* block, a backend with no key attribute, a block that names no key.
|
|
43
|
+
*/
|
|
44
|
+
export declare function copyBackend(dir: string, root: string, suffix: string, env?: NodeJS.ProcessEnv, binary?: string): CopyBackend;
|
|
45
|
+
/**
|
|
46
|
+
* The backend a prepared root was initialised with, checked to be its copy:
|
|
47
|
+
* its key attribute, and a GitLab state's lock addresses, carry the suffix.
|
|
48
|
+
* Throws {@link CopyRefusedError} when it does not; `hint` says how to make
|
|
49
|
+
* the product's config read the suffix.
|
|
50
|
+
*/
|
|
51
|
+
export declare function preparedCopyBackend(dir: string, root: string, suffix: string, env?: NodeJS.ProcessEnv, hint?: string): CopyBackend;
|
|
52
|
+
/** One root of a copy: where the binary runs it, and how. */
|
|
53
|
+
export interface CopyRoot {
|
|
54
|
+
/** The root's name, as the records and the report name it. */
|
|
55
|
+
root: string;
|
|
56
|
+
/** The root's directory in the checkout planned. */
|
|
57
|
+
dir: string;
|
|
58
|
+
binary: string;
|
|
59
|
+
env?: NodeJS.ProcessEnv;
|
|
60
|
+
/**
|
|
61
|
+
* Prepare a root another tool initialises (a Terragrunt unit), with the
|
|
62
|
+
* suffix set as its config reads it: where the binary then runs, and with
|
|
63
|
+
* which env. Its recorded backend must carry the suffix.
|
|
64
|
+
*/
|
|
65
|
+
prepare?: (suffix: string) => Promise<{
|
|
66
|
+
dir: string;
|
|
67
|
+
env: NodeJS.ProcessEnv;
|
|
68
|
+
}>;
|
|
69
|
+
}
|
|
70
|
+
export interface CopyPlanInput {
|
|
71
|
+
copy: CopyRoot;
|
|
72
|
+
/** The environment's suffix: `pr-<n>`. */
|
|
73
|
+
suffix: string;
|
|
74
|
+
/** Where the plan file goes. */
|
|
75
|
+
planFile: string;
|
|
76
|
+
destroy?: boolean;
|
|
77
|
+
lockTimeout?: string | false;
|
|
78
|
+
exec?: BinaryExec;
|
|
79
|
+
/** How the product's config reads the suffix, for a prepared root's refusal. */
|
|
80
|
+
hint?: string;
|
|
81
|
+
}
|
|
82
|
+
/**
|
|
83
|
+
* Plan one root's copy: init it under its suffixed key (or prepare it, then
|
|
84
|
+
* check its key), plan (a destroy with `destroy`), and read the plan's
|
|
85
|
+
* counts. A run of the binary that fails is the plan's `error`; a root no
|
|
86
|
+
* copy can be made of throws {@link CopyRefusedError}.
|
|
87
|
+
*/
|
|
88
|
+
export declare function terraformCopyPlan(input: CopyPlanInput): Promise<PrEnvComponentPlan>;
|
|
89
|
+
export interface TerraformPrEnvInput {
|
|
90
|
+
/** The roots of the copy, in apply order, from the pull request's head. */
|
|
91
|
+
roots(target: {
|
|
92
|
+
pr: number;
|
|
93
|
+
env: string;
|
|
94
|
+
head: string;
|
|
95
|
+
}): Promise<CopyRoot[]>;
|
|
96
|
+
/** A directory the plan files go in. */
|
|
97
|
+
work: string;
|
|
98
|
+
exec?: BinaryExec;
|
|
99
|
+
lockTimeout?: string | false;
|
|
100
|
+
hint?: string;
|
|
101
|
+
/** What a copy with no roots says. */
|
|
102
|
+
nothing?: string;
|
|
103
|
+
log?: (line: string) => void;
|
|
104
|
+
}
|
|
105
|
+
/**
|
|
106
|
+
* The adapter `prEnvUp` takes for a copy of Terraform roots: each root's copy
|
|
107
|
+
* planned under `-<env>` (`pr-<n>`) and applied in order. `refused` holds a
|
|
108
|
+
* {@link CopyRefusedError}, which a product raises as a config error.
|
|
109
|
+
*/
|
|
110
|
+
export declare function terraformPrEnvAdapter(input: TerraformPrEnvInput): PrEnvAdapter & {
|
|
111
|
+
refused?: Error;
|
|
112
|
+
};
|
|
113
|
+
export interface TerraformPrEnvTeardownInput {
|
|
114
|
+
/** The name outcomes are attributed to: the product's. */
|
|
115
|
+
name: string;
|
|
116
|
+
/**
|
|
117
|
+
* The roots as the commit the copy last applied from has them, with what
|
|
118
|
+
* it holds released by `done`. A root missing from `roots` fails alone.
|
|
119
|
+
*/
|
|
120
|
+
checkout(live: LivePrEnvironment): Promise<{
|
|
121
|
+
roots: CopyRoot[];
|
|
122
|
+
done?: () => void;
|
|
123
|
+
}>;
|
|
124
|
+
work: string;
|
|
125
|
+
exec?: BinaryExec;
|
|
126
|
+
lockTimeout?: string | false;
|
|
127
|
+
hint?: string;
|
|
128
|
+
log?: (line: string) => void;
|
|
129
|
+
}
|
|
130
|
+
/**
|
|
131
|
+
* The teardown `prEnvDown` and `prEnvSweep` take for a copy of Terraform
|
|
132
|
+
* roots: a root whose recorded state location carries `-<env>` is destroyed,
|
|
133
|
+
* through a planned destroy of its copy, in reverse apply order; any other
|
|
134
|
+
* is a hole, so nothing at a root's own key is destroyed. It stands in for
|
|
135
|
+
* the terraform lexicon's own teardown.
|
|
136
|
+
*/
|
|
137
|
+
export declare function terraformPrEnvTeardown(input: TerraformPrEnvTeardownInput): PrEnvTeardownAdapter;
|
|
138
|
+
//# sourceMappingURL=pr-env.d.ts.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"pr-env.d.ts","sourceRoot":"","sources":["../src/pr-env.ts"],"names":[],"mappings":"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"}
|