@intentius/chant-lexicon-terraform 0.124.97 → 0.124.98
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/behaviour/reference-catalog.d.ts +42 -6
- package/dist/behaviour/reference-catalog.d.ts.map +1 -1
- package/dist/behaviour/reference-catalog.js +169 -8
- package/dist/describe-resources.js +1 -1
- package/dist/hcl/evaluate.d.ts +151 -0
- package/dist/hcl/evaluate.d.ts.map +1 -0
- package/dist/hcl/evaluate.js +940 -0
- package/dist/hcl/instances.d.ts +11 -1
- package/dist/hcl/instances.d.ts.map +1 -1
- package/dist/hcl/instances.js +89 -3
- package/dist/hcl/parse.d.ts +23 -1
- package/dist/hcl/parse.d.ts.map +1 -1
- package/dist/hcl/parse.js +9 -3
- package/dist/hcl/redact.d.ts +5 -1
- package/dist/hcl/redact.d.ts.map +1 -1
- package/dist/hcl/redact.js +7 -3
- package/dist/hcl/references.d.ts +12 -1
- package/dist/hcl/references.d.ts.map +1 -1
- package/dist/hcl/references.js +33 -16
- package/dist/integrity.json +6 -6
- package/dist/lint/post-synth/tf001.d.ts +4 -1
- package/dist/lint/post-synth/tf001.d.ts.map +1 -1
- package/dist/lint/post-synth/tf001.js +20 -8
- package/dist/lint/post-synth/tf002.d.ts +11 -5
- package/dist/lint/post-synth/tf002.d.ts.map +1 -1
- package/dist/lint/post-synth/tf002.js +42 -8
- package/dist/lint/post-synth/tf006.d.ts +7 -3
- package/dist/lint/post-synth/tf006.d.ts.map +1 -1
- package/dist/lint/post-synth/tf006.js +9 -3
- package/dist/lint/post-synth/tf022.d.ts +6 -0
- package/dist/lint/post-synth/tf022.d.ts.map +1 -1
- package/dist/lint/post-synth/tf022.js +18 -1
- package/dist/lint/secret-shape.d.ts +8 -0
- package/dist/lint/secret-shape.d.ts.map +1 -1
- package/dist/lint/secret-shape.js +76 -0
- package/dist/manifest.json +1 -1
- package/dist/plugin.d.ts.map +1 -1
- package/dist/plugin.js +7 -2
- package/dist/rules/tf001.ts +21 -7
- package/dist/rules/tf002.ts +44 -7
- package/dist/rules/tf006.ts +8 -3
- package/dist/rules/tf022.ts +18 -1
- package/package.json +2 -2
- package/src/__fixtures__/resolved-arguments/build-trusted/extras.tf +28 -0
- package/src/__fixtures__/resolved-arguments/build-trusted/main.tf +22 -0
- package/src/__fixtures__/resolved-arguments/build-trusted/serviceaccounts.tf +26 -0
- package/src/__fixtures__/resolved-arguments/modules/gke-cluster/main.tf +15 -0
- package/src/__fixtures__/resolved-arguments/modules/gke-cluster/variables.tf +12 -0
- package/src/__fixtures__/resolved-arguments/modules/gke-project/main.tf +9 -0
- package/src/__fixtures__/resolved-arguments/modules/gke-project/outputs.tf +9 -0
- package/src/__fixtures__/resolved-arguments/modules/gke-project/variables.tf +7 -0
- package/src/__fixtures__/resolved-arguments/modules/workload-identity-service-account/main.tf +16 -0
- package/src/__fixtures__/resolved-arguments/modules/workload-identity-service-account/outputs.tf +4 -0
- package/src/__fixtures__/resolved-arguments/modules/workload-identity-service-account/variables.tf +21 -0
- package/src/behaviour/reference-catalog.plugin.test.ts +101 -2
- package/src/behaviour/reference-catalog.ts +162 -9
- package/src/describe-resources.ts +1 -1
- package/src/hcl/edges.test.ts +1 -1
- package/src/hcl/evaluate.test.ts +215 -0
- package/src/hcl/evaluate.ts +899 -0
- package/src/hcl/instances.ts +89 -3
- package/src/hcl/parse.test.ts +18 -0
- package/src/hcl/parse.ts +28 -3
- package/src/hcl/redact.ts +7 -3
- package/src/hcl/references.test.ts +68 -0
- package/src/hcl/references.ts +31 -15
- package/src/lint/post-synth/fixtures/TF001/negative-second-block.tf +17 -0
- package/src/lint/post-synth/fixtures/TF002/module-cycle/cdn/back/main.tf +3 -0
- package/src/lint/post-synth/fixtures/TF002/module-cycle/cdn/main.tf +3 -0
- package/src/lint/post-synth/fixtures/TF002/module-cycle/main.tf +14 -0
- package/src/lint/post-synth/fixtures/TF002/module-nested/cdn/edge/main.tf +8 -0
- package/src/lint/post-synth/fixtures/TF002/module-nested/cdn/main.tf +3 -0
- package/src/lint/post-synth/fixtures/TF002/module-nested/main.tf +14 -0
- package/src/lint/post-synth/fixtures/TF002/module-other-provider/cdn/main.tf +8 -0
- package/src/lint/post-synth/fixtures/TF002/module-other-provider/main.tf +14 -0
- package/src/lint/post-synth/fixtures/TF002/module-pinned/cdn/main.tf +12 -0
- package/src/lint/post-synth/fixtures/TF002/module-pinned/main.tf +14 -0
- package/src/lint/post-synth/fixtures/TF002/module-unpinned/cdn/main.tf +7 -0
- package/src/lint/post-synth/fixtures/TF002/module-unpinned/main.tf +14 -0
- package/src/lint/post-synth/fixtures/TF006/negative-null-default.tf +12 -0
- package/src/lint/post-synth/fixtures/TF006/positive-empty-default.tf +0 -6
- package/src/lint/post-synth/fixtures/TF007/negative-names.tf +25 -0
- package/src/lint/post-synth/fixtures/TF022/negative-secret-reference.tf +32 -0
- package/src/lint/post-synth/fixtures/TF022/positive-secret-data.tf +8 -0
- package/src/lint/post-synth/fixtures/TF024/live-backend-second-block/a-versions.tf +3 -0
- package/src/lint/post-synth/fixtures/TF024/live-backend-second-block/b-backend.tf +10 -0
- package/src/lint/post-synth/fixtures/TF024/live-cloud-second-block/a-versions.tf +3 -0
- package/src/lint/post-synth/fixtures/TF024/live-cloud-second-block/b-cloud.tf +9 -0
- package/src/lint/post-synth/fixtures/TF024/sidecar-backend-second-block/a-versions.tf +3 -0
- package/src/lint/post-synth/fixtures/TF024/sidecar-backend-second-block/b-backend.tf +6 -0
- package/src/lint/post-synth/fixtures/TF024/sidecar-backend-second-block/estate.chdf.hcl +1 -0
- package/src/lint/post-synth/module-rules.test.ts +1 -1
- package/src/lint/post-synth/post-synth.test.ts +39 -0
- package/src/lint/post-synth/single-block.test.ts +23 -2
- package/src/lint/post-synth/tf001.ts +21 -7
- package/src/lint/post-synth/tf002.test.ts +45 -1
- package/src/lint/post-synth/tf002.ts +44 -7
- package/src/lint/post-synth/tf006.ts +8 -3
- package/src/lint/post-synth/tf022.ts +18 -1
- package/src/lint/post-synth/tf024.test.ts +21 -0
- package/src/lint/secret-shape.test.ts +30 -0
- package/src/lint/secret-shape.ts +75 -0
- package/src/plugin.ts +6 -2
- package/src/redact.test.ts +8 -0
|
@@ -0,0 +1,899 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Evaluate a block's arguments from the files a plan reads, per module
|
|
3
|
+
* instance (chant #5117).
|
|
4
|
+
*
|
|
5
|
+
* The reference catalog (`../behaviour/reference-catalog.ts`) matches values
|
|
6
|
+
* written on a node. A declared block mostly holds expressions instead:
|
|
7
|
+
* `account_id = var.name`, where the variable is set by a module call from
|
|
8
|
+
* `each.key`, and `project = var.project_id`, set from another module's
|
|
9
|
+
* output. This module follows those expressions back to a literal where the
|
|
10
|
+
* source alone says what it is, so the catalog has the value to match.
|
|
11
|
+
*
|
|
12
|
+
* It resolves, in one module instance:
|
|
13
|
+
*
|
|
14
|
+
* - `var.<x>` from the call's argument (evaluated in the caller), else the
|
|
15
|
+
* variable's default; in the root module from the tfvars files
|
|
16
|
+
* `./instances.ts` reads, then the default;
|
|
17
|
+
* - `local.<x>`, `each.key`, `each.value` and `count.index`;
|
|
18
|
+
* - `module.<call>.<output>`, when the output's value resolves in the child;
|
|
19
|
+
* - `<type>.<name>.<arg>` in the same module, when the block sets `<arg>`;
|
|
20
|
+
* - `"${...}"` interpolation whose every part resolves;
|
|
21
|
+
* - `lookup(map, key, default)`, `toset()`, `length()` and `cond ? a : b`
|
|
22
|
+
* over a known bool, plus list and object constructors and index steps;
|
|
23
|
+
* - `a == b` and `a != b` over two known values (#5094), so
|
|
24
|
+
* `count = var.is_prod_cluster == "true" ? 1 : 0` picks its count.
|
|
25
|
+
*
|
|
26
|
+
* Anything else is unknown, and an unknown value carries the first
|
|
27
|
+
* reference that stopped it: a data source (`data.google_organization.org.org_id`),
|
|
28
|
+
* a function (`timestamp()`), an attribute the provider computes
|
|
29
|
+
* (`google_service_account.sa.email`), a variable nothing sets, an operator
|
|
30
|
+
* this reader does not evaluate. A reference inside a child module is named
|
|
31
|
+
* with the module path in front, as Terraform prints addresses
|
|
32
|
+
* (`module.project.data.google_organization.org.org_id`). A sensitive
|
|
33
|
+
* variable or output is unknown, so a value marked sensitive never reaches
|
|
34
|
+
* the graph. No plan, state or provider is read.
|
|
35
|
+
*
|
|
36
|
+
* Pure apart from what it is handed: the parsed entities of one root, its
|
|
37
|
+
* tfvars values, and a module path.
|
|
38
|
+
*/
|
|
39
|
+
|
|
40
|
+
import { isResourceDeclarable, type Declarable } from "@intentius/chant/declarable";
|
|
41
|
+
import {
|
|
42
|
+
LOCALS_TYPE,
|
|
43
|
+
MODULE_TYPE,
|
|
44
|
+
OUTPUT_TYPE,
|
|
45
|
+
RESOURCE_TYPE,
|
|
46
|
+
VARIABLE_TYPE,
|
|
47
|
+
scopeOfKey,
|
|
48
|
+
type BlockBody,
|
|
49
|
+
type TerraformEntity,
|
|
50
|
+
} from "./parse";
|
|
51
|
+
|
|
52
|
+
/** A value the source does not determine, and the reference that stopped it. */
|
|
53
|
+
export class Unknown {
|
|
54
|
+
constructor(readonly ref: string) {}
|
|
55
|
+
}
|
|
56
|
+
|
|
57
|
+
export const isUnknown = (v: unknown): v is Unknown => v instanceof Unknown;
|
|
58
|
+
|
|
59
|
+
/** Lists `toset()` made, so `for_each` can tell a set from a list. */
|
|
60
|
+
const SETS = new WeakSet<unknown[]>();
|
|
61
|
+
|
|
62
|
+
/** Whether a value is a set `toset()` made. */
|
|
63
|
+
export const isSetValue = (v: unknown): boolean => Array.isArray(v) && SETS.has(v);
|
|
64
|
+
|
|
65
|
+
/** The first unknown inside a value, depth first, or undefined when the value is wholly known. */
|
|
66
|
+
export function firstUnknown(v: unknown, depth = 0): Unknown | undefined {
|
|
67
|
+
if (v instanceof Unknown) return v;
|
|
68
|
+
if (depth > 32) return undefined;
|
|
69
|
+
if (Array.isArray(v)) {
|
|
70
|
+
for (const x of v) {
|
|
71
|
+
const u = firstUnknown(x, depth + 1);
|
|
72
|
+
if (u) return u;
|
|
73
|
+
}
|
|
74
|
+
} else if (typeof v === "object" && v !== null) {
|
|
75
|
+
for (const x of Object.values(v)) {
|
|
76
|
+
const u = firstUnknown(x, depth + 1);
|
|
77
|
+
if (u) return u;
|
|
78
|
+
}
|
|
79
|
+
}
|
|
80
|
+
return undefined;
|
|
81
|
+
}
|
|
82
|
+
|
|
83
|
+
// ── Expressions ──────────────────────────────────────────────────────────────
|
|
84
|
+
|
|
85
|
+
type Step = { attr: string } | { index: Expr } | { splat: true };
|
|
86
|
+
|
|
87
|
+
type Expr =
|
|
88
|
+
| { t: "lit"; v: unknown }
|
|
89
|
+
| { t: "tpl"; parts: Array<string | Expr>; text: string }
|
|
90
|
+
| { t: "ref"; root: string; steps: Step[]; text: string }
|
|
91
|
+
| { t: "post"; of: Expr; steps: Step[]; text: string }
|
|
92
|
+
| { t: "call"; name: string; args: Expr[]; text: string }
|
|
93
|
+
| { t: "cond"; c: Expr; a: Expr; b: Expr }
|
|
94
|
+
| { t: "eq"; negate: boolean; l: Expr; r: Expr }
|
|
95
|
+
| { t: "tuple"; items: Expr[] }
|
|
96
|
+
| { t: "object"; entries: Array<[Expr, Expr]> };
|
|
97
|
+
|
|
98
|
+
/** An expression this reader does not evaluate; `text` names it, cut to 80 characters. */
|
|
99
|
+
class Unsupported extends Error {
|
|
100
|
+
readonly text: string;
|
|
101
|
+
constructor(text: string) {
|
|
102
|
+
const flat = text.replace(/\s+/g, " ").trim();
|
|
103
|
+
super(flat);
|
|
104
|
+
this.text = flat.length > 80 ? `${flat.slice(0, 77)}...` : flat;
|
|
105
|
+
}
|
|
106
|
+
}
|
|
107
|
+
|
|
108
|
+
/** Index just past the `}` that closes the `{` at `open`, skipping strings. -1 when unclosed. */
|
|
109
|
+
function closeBrace(s: string, open: number): number {
|
|
110
|
+
let depth = 0;
|
|
111
|
+
for (let i = open; i < s.length; i++) {
|
|
112
|
+
const c = s[i];
|
|
113
|
+
if (c === '"') {
|
|
114
|
+
i = skipQuoted(s, i) - 1;
|
|
115
|
+
continue;
|
|
116
|
+
}
|
|
117
|
+
if (c === "{") depth++;
|
|
118
|
+
else if (c === "}" && --depth === 0) return i + 1;
|
|
119
|
+
}
|
|
120
|
+
return -1;
|
|
121
|
+
}
|
|
122
|
+
|
|
123
|
+
/** Index just past the string opened at `i`, its interpolations included. */
|
|
124
|
+
function skipQuoted(s: string, i: number): number {
|
|
125
|
+
i++;
|
|
126
|
+
while (i < s.length) {
|
|
127
|
+
const c = s[i];
|
|
128
|
+
if (c === "\\") i += 2;
|
|
129
|
+
else if (c === "$" && s[i + 1] === "$" && s[i + 2] === "{") i += 3;
|
|
130
|
+
else if (c === "$" && s[i + 1] === "{") {
|
|
131
|
+
const end = closeBrace(s, i + 1);
|
|
132
|
+
if (end === -1) return s.length;
|
|
133
|
+
i = end;
|
|
134
|
+
} else if (c === '"') return i + 1;
|
|
135
|
+
else i++;
|
|
136
|
+
}
|
|
137
|
+
return s.length;
|
|
138
|
+
}
|
|
139
|
+
|
|
140
|
+
/**
|
|
141
|
+
* A template's parts: literal text and the expressions of its `${...}`.
|
|
142
|
+
* `$${` is a literal `${`. A `%{` directive is not read.
|
|
143
|
+
*/
|
|
144
|
+
function parseTemplate(s: string, unescape: (t: string) => string): Array<string | Expr> {
|
|
145
|
+
const parts: Array<string | Expr> = [];
|
|
146
|
+
let lit = "";
|
|
147
|
+
let i = 0;
|
|
148
|
+
while (i < s.length) {
|
|
149
|
+
if (s.startsWith("$${", i)) {
|
|
150
|
+
lit += "${";
|
|
151
|
+
i += 3;
|
|
152
|
+
} else if (s.startsWith("%%{", i)) {
|
|
153
|
+
lit += "%{";
|
|
154
|
+
i += 3;
|
|
155
|
+
} else if (s.startsWith("%{", i)) {
|
|
156
|
+
throw new Unsupported(s);
|
|
157
|
+
} else if (s.startsWith("${", i)) {
|
|
158
|
+
const end = closeBrace(s, i + 1);
|
|
159
|
+
if (end === -1) throw new Unsupported(s);
|
|
160
|
+
if (lit) parts.push(unescape(lit));
|
|
161
|
+
lit = "";
|
|
162
|
+
parts.push(parseExpression(s.slice(i + 2, end - 1).replace(/^~/, "").replace(/~$/, "")));
|
|
163
|
+
i = end;
|
|
164
|
+
} else {
|
|
165
|
+
lit += s[i];
|
|
166
|
+
i++;
|
|
167
|
+
}
|
|
168
|
+
}
|
|
169
|
+
if (lit) parts.push(unescape(lit));
|
|
170
|
+
return parts;
|
|
171
|
+
}
|
|
172
|
+
|
|
173
|
+
/** The escapes of a quoted HCL string. */
|
|
174
|
+
function unescapeQuoted(t: string): string {
|
|
175
|
+
return t.replace(/\\(u[0-9a-fA-F]{4}|U[0-9a-fA-F]{8}|.)/g, (_, e: string) => {
|
|
176
|
+
if (e === "n") return "\n";
|
|
177
|
+
if (e === "t") return "\t";
|
|
178
|
+
if (e === "r") return "\r";
|
|
179
|
+
if (e[0] === "u" || e[0] === "U") return String.fromCodePoint(parseInt(e.slice(1), 16));
|
|
180
|
+
return e;
|
|
181
|
+
});
|
|
182
|
+
}
|
|
183
|
+
|
|
184
|
+
type Tok = { k: "id" | "num" | "str" | "p"; v: string; at: number; end: number };
|
|
185
|
+
|
|
186
|
+
const PUNCT = ["...", "==", "!=", "<=", ">=", "&&", "||", "=>", "(", ")", "[", "]", "{", "}", ",", ".", "?", ":", "=", "*", "!", "+", "-", "/", "%", "<", ">"];
|
|
187
|
+
|
|
188
|
+
function tokenize(s: string): Tok[] {
|
|
189
|
+
const out: Tok[] = [];
|
|
190
|
+
let i = 0;
|
|
191
|
+
while (i < s.length) {
|
|
192
|
+
const c = s[i]!;
|
|
193
|
+
if (/\s/.test(c)) {
|
|
194
|
+
i++;
|
|
195
|
+
} else if (c === "#" || s.startsWith("//", i)) {
|
|
196
|
+
while (i < s.length && s[i] !== "\n") i++;
|
|
197
|
+
} else if (s.startsWith("/*", i)) {
|
|
198
|
+
const end = s.indexOf("*/", i + 2);
|
|
199
|
+
i = end === -1 ? s.length : end + 2;
|
|
200
|
+
} else if (/[A-Za-z_]/.test(c)) {
|
|
201
|
+
const m = /^[A-Za-z_][A-Za-z0-9_-]*/.exec(s.slice(i))!;
|
|
202
|
+
out.push({ k: "id", v: m[0], at: i, end: i + m[0].length });
|
|
203
|
+
i += m[0].length;
|
|
204
|
+
} else if (/[0-9]/.test(c)) {
|
|
205
|
+
const m = /^[0-9]+(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?/.exec(s.slice(i))!;
|
|
206
|
+
out.push({ k: "num", v: m[0], at: i, end: i + m[0].length });
|
|
207
|
+
i += m[0].length;
|
|
208
|
+
} else if (c === '"') {
|
|
209
|
+
const end = skipQuoted(s, i);
|
|
210
|
+
out.push({ k: "str", v: s.slice(i + 1, end - 1), at: i, end });
|
|
211
|
+
i = end;
|
|
212
|
+
} else if (s.startsWith("<<", i)) {
|
|
213
|
+
throw new Unsupported(s.trim());
|
|
214
|
+
} else {
|
|
215
|
+
const p = PUNCT.find((x) => s.startsWith(x, i));
|
|
216
|
+
if (!p) throw new Unsupported(s.trim());
|
|
217
|
+
out.push({ k: "p", v: p, at: i, end: i + p.length });
|
|
218
|
+
i += p.length;
|
|
219
|
+
}
|
|
220
|
+
}
|
|
221
|
+
return out;
|
|
222
|
+
}
|
|
223
|
+
|
|
224
|
+
/** Parse the inside of one `${...}`. Throws {@link Unsupported} on a form this reader does not evaluate. */
|
|
225
|
+
function parseExpression(src: string): Expr {
|
|
226
|
+
const toks = tokenize(src);
|
|
227
|
+
let pos = 0;
|
|
228
|
+
const peek = (v?: string): Tok | undefined => {
|
|
229
|
+
const t = toks[pos];
|
|
230
|
+
return t && (v === undefined || (t.k === "p" && t.v === v)) ? t : undefined;
|
|
231
|
+
};
|
|
232
|
+
const expect = (v: string): Tok => {
|
|
233
|
+
const t = peek(v);
|
|
234
|
+
if (!t) throw new Unsupported(src.trim());
|
|
235
|
+
pos++;
|
|
236
|
+
return t;
|
|
237
|
+
};
|
|
238
|
+
const textFrom = (start: number): string => src.slice(toks[start]!.at, toks[pos - 1]!.end).trim();
|
|
239
|
+
|
|
240
|
+
const steps = (): Step[] => {
|
|
241
|
+
const out: Step[] = [];
|
|
242
|
+
for (;;) {
|
|
243
|
+
if (peek(".")) {
|
|
244
|
+
pos++;
|
|
245
|
+
const t = toks[pos];
|
|
246
|
+
if (t?.k === "id") out.push({ attr: t.v });
|
|
247
|
+
else if (t?.k === "num") out.push({ index: { t: "lit", v: Number(t.v) } });
|
|
248
|
+
else if (t?.k === "p" && t.v === "*") out.push({ splat: true });
|
|
249
|
+
else throw new Unsupported(src.trim());
|
|
250
|
+
pos++;
|
|
251
|
+
} else if (peek("[")) {
|
|
252
|
+
pos++;
|
|
253
|
+
if (peek("*")) {
|
|
254
|
+
pos++;
|
|
255
|
+
out.push({ splat: true });
|
|
256
|
+
} else out.push({ index: expr() });
|
|
257
|
+
expect("]");
|
|
258
|
+
} else return out;
|
|
259
|
+
}
|
|
260
|
+
};
|
|
261
|
+
|
|
262
|
+
const primary = (): Expr => {
|
|
263
|
+
const start = pos;
|
|
264
|
+
const t = toks[pos];
|
|
265
|
+
if (!t) throw new Unsupported(src.trim());
|
|
266
|
+
pos++;
|
|
267
|
+
if (t.k === "num") return { t: "lit", v: Number(t.v) };
|
|
268
|
+
if (t.k === "str") return { t: "tpl", parts: parseTemplate(t.v, unescapeQuoted), text: src.slice(t.at, t.end) };
|
|
269
|
+
if (t.k === "id") {
|
|
270
|
+
if (t.v === "true" || t.v === "false") return { t: "lit", v: t.v === "true" };
|
|
271
|
+
if (t.v === "null") return { t: "lit", v: null };
|
|
272
|
+
if (peek("(")) {
|
|
273
|
+
pos++;
|
|
274
|
+
const args: Expr[] = [];
|
|
275
|
+
while (!peek(")")) {
|
|
276
|
+
args.push(expr());
|
|
277
|
+
if (peek("...")) throw new Unsupported(src.trim());
|
|
278
|
+
if (!peek(",")) break;
|
|
279
|
+
pos++;
|
|
280
|
+
}
|
|
281
|
+
expect(")");
|
|
282
|
+
return { t: "call", name: t.v, args, text: textFrom(start) };
|
|
283
|
+
}
|
|
284
|
+
const s = steps();
|
|
285
|
+
return { t: "ref", root: t.v, steps: s, text: textFrom(start) };
|
|
286
|
+
}
|
|
287
|
+
if (t.v === "-" && toks[pos]?.k === "num") {
|
|
288
|
+
pos++;
|
|
289
|
+
return { t: "lit", v: -Number(toks[pos - 1]!.v) };
|
|
290
|
+
}
|
|
291
|
+
if (t.v === "(") {
|
|
292
|
+
const inner = expr();
|
|
293
|
+
expect(")");
|
|
294
|
+
return inner;
|
|
295
|
+
}
|
|
296
|
+
if (t.v === "[") {
|
|
297
|
+
if (toks[pos]?.k === "id" && toks[pos]!.v === "for") throw new Unsupported(src.trim());
|
|
298
|
+
const items: Expr[] = [];
|
|
299
|
+
while (!peek("]")) {
|
|
300
|
+
items.push(expr());
|
|
301
|
+
if (!peek(",")) break;
|
|
302
|
+
pos++;
|
|
303
|
+
}
|
|
304
|
+
expect("]");
|
|
305
|
+
return { t: "tuple", items };
|
|
306
|
+
}
|
|
307
|
+
if (t.v === "{") {
|
|
308
|
+
if (toks[pos]?.k === "id" && toks[pos]!.v === "for") throw new Unsupported(src.trim());
|
|
309
|
+
const entries: Array<[Expr, Expr]> = [];
|
|
310
|
+
while (!peek("}")) {
|
|
311
|
+
const k = toks[pos];
|
|
312
|
+
let key: Expr;
|
|
313
|
+
if (k?.k === "id" && (toks[pos + 1]?.v === "=" || toks[pos + 1]?.v === ":")) {
|
|
314
|
+
key = { t: "lit", v: k.v };
|
|
315
|
+
pos++;
|
|
316
|
+
} else key = expr();
|
|
317
|
+
if (peek("=") || peek(":")) pos++;
|
|
318
|
+
else throw new Unsupported(src.trim());
|
|
319
|
+
entries.push([key, expr()]);
|
|
320
|
+
if (peek(",")) pos++;
|
|
321
|
+
}
|
|
322
|
+
expect("}");
|
|
323
|
+
return { t: "object", entries };
|
|
324
|
+
}
|
|
325
|
+
throw new Unsupported(src.trim());
|
|
326
|
+
};
|
|
327
|
+
|
|
328
|
+
const postfix = (): Expr => {
|
|
329
|
+
const start = pos;
|
|
330
|
+
const p = primary();
|
|
331
|
+
if (p.t === "ref") return p;
|
|
332
|
+
const s = steps();
|
|
333
|
+
return s.length === 0 ? p : { t: "post", of: p, steps: s, text: textFrom(start) };
|
|
334
|
+
};
|
|
335
|
+
|
|
336
|
+
// `==` and `!=` (#5094) bind looser than a traversal and tighter than `? :`.
|
|
337
|
+
// Arithmetic and `&&`/`||` are not read, so an operand followed by one is unsupported.
|
|
338
|
+
const equality = (): Expr => {
|
|
339
|
+
let l = postfix();
|
|
340
|
+
while (peek("==") || peek("!=")) {
|
|
341
|
+
const negate = toks[pos]!.v === "!=";
|
|
342
|
+
pos++;
|
|
343
|
+
l = { t: "eq", negate, l, r: postfix() };
|
|
344
|
+
}
|
|
345
|
+
return l;
|
|
346
|
+
};
|
|
347
|
+
|
|
348
|
+
const expr = (): Expr => {
|
|
349
|
+
const c = equality();
|
|
350
|
+
const next = toks[pos];
|
|
351
|
+
if (next?.k === "p" && next.v === "?") {
|
|
352
|
+
pos++;
|
|
353
|
+
const a = expr();
|
|
354
|
+
expect(":");
|
|
355
|
+
const b = expr();
|
|
356
|
+
return { t: "cond", c, a, b };
|
|
357
|
+
}
|
|
358
|
+
if (next?.k === "p" && ![")", "]", "}", ",", ":", "...", "="].includes(next.v)) throw new Unsupported(src.trim());
|
|
359
|
+
return c;
|
|
360
|
+
};
|
|
361
|
+
|
|
362
|
+
const e = expr();
|
|
363
|
+
if (pos < toks.length) throw new Unsupported(src.trim());
|
|
364
|
+
return e;
|
|
365
|
+
}
|
|
366
|
+
|
|
367
|
+
const parsed = new Map<string, Expr | Unsupported>();
|
|
368
|
+
|
|
369
|
+
/** A hcl2json string as an expression: a template, or one bare `${...}` whose value is the expression's own. */
|
|
370
|
+
function parseValueString(s: string): Expr | Unsupported {
|
|
371
|
+
const hit = parsed.get(s);
|
|
372
|
+
if (hit) return hit;
|
|
373
|
+
let out: Expr | Unsupported;
|
|
374
|
+
try {
|
|
375
|
+
const parts = parseTemplate(s, (t) => t);
|
|
376
|
+
out = parts.length === 1 && typeof parts[0] !== "string" ? parts[0]! : { t: "tpl", parts, text: s };
|
|
377
|
+
} catch (err) {
|
|
378
|
+
out = err instanceof Unsupported ? err : new Unsupported(s);
|
|
379
|
+
}
|
|
380
|
+
if (parsed.size > 20_000) parsed.clear();
|
|
381
|
+
parsed.set(s, out);
|
|
382
|
+
return out;
|
|
383
|
+
}
|
|
384
|
+
|
|
385
|
+
// ── Scopes ───────────────────────────────────────────────────────────────────
|
|
386
|
+
|
|
387
|
+
/** One module instance: the entity-key scope its blocks sit in and its Terraform path. */
|
|
388
|
+
export interface ModulePlace {
|
|
389
|
+
/** The entity-key scope, `estate` or `estate/module.a/module.b`. */
|
|
390
|
+
scope: string;
|
|
391
|
+
/** The module path as Terraform prints it, `""` for the root, `module.a["x"].module.b`. */
|
|
392
|
+
path: string;
|
|
393
|
+
parent?: ModulePlace;
|
|
394
|
+
/** The call's iteration for this instance, when the call is expanded. */
|
|
395
|
+
iteration?: Iteration;
|
|
396
|
+
}
|
|
397
|
+
|
|
398
|
+
/** `each` and `count` for one instance of an expanded block or call. */
|
|
399
|
+
export interface Iteration {
|
|
400
|
+
each?: { key: unknown; value: unknown } | Unknown;
|
|
401
|
+
count?: number | Unknown;
|
|
402
|
+
}
|
|
403
|
+
|
|
404
|
+
interface Env {
|
|
405
|
+
place: ModulePlace;
|
|
406
|
+
iteration?: Iteration;
|
|
407
|
+
}
|
|
408
|
+
|
|
409
|
+
const SEGMENT_RE = /^module\.([A-Za-z_][A-Za-z0-9_-]*)(\[(?:[0-9]+|"(?:[^"\\]|\\.)*")\])?(?:\.|$)/;
|
|
410
|
+
|
|
411
|
+
/** The key text of an instance key, `[0]` or `["a"]`, as a number or a string. */
|
|
412
|
+
export function instanceKeyValue(key: string): number | string | undefined {
|
|
413
|
+
const inner = key.slice(1, -1);
|
|
414
|
+
if (/^[0-9]+$/.test(inner)) return Number(inner);
|
|
415
|
+
try {
|
|
416
|
+
const v = JSON.parse(inner) as unknown;
|
|
417
|
+
return typeof v === "string" ? v : undefined;
|
|
418
|
+
} catch {
|
|
419
|
+
return undefined;
|
|
420
|
+
}
|
|
421
|
+
}
|
|
422
|
+
|
|
423
|
+
function bodyOf(entity: Declarable | undefined): BlockBody {
|
|
424
|
+
const body = entity && isResourceDeclarable(entity) ? (entity as TerraformEntity).props.body : undefined;
|
|
425
|
+
return (typeof body === "object" && body !== null ? body : {}) as BlockBody;
|
|
426
|
+
}
|
|
427
|
+
|
|
428
|
+
const expanded = (body: BlockBody): "count" | "for_each" | undefined => ("count" in body ? "count" : "for_each" in body ? "for_each" : undefined);
|
|
429
|
+
|
|
430
|
+
/**
|
|
431
|
+
* Evaluates expressions over one root's parsed entities. Build it once per
|
|
432
|
+
* root, after the descent into local modules.
|
|
433
|
+
*/
|
|
434
|
+
export class RootEvaluator {
|
|
435
|
+
private readonly vars = new Map<string, Map<string, TerraformEntity>>();
|
|
436
|
+
private readonly locals = new Map<string, Map<string, unknown>>();
|
|
437
|
+
private readonly memo = new Map<string, unknown>();
|
|
438
|
+
private readonly places = new Map<string, ModulePlace>();
|
|
439
|
+
private readonly visiting = new Set<string>();
|
|
440
|
+
private depth = 0;
|
|
441
|
+
|
|
442
|
+
constructor(
|
|
443
|
+
private readonly entities: ReadonlyMap<string, Declarable>,
|
|
444
|
+
private readonly root: string,
|
|
445
|
+
private readonly tfvars: ReadonlyMap<string, unknown> = new Map(),
|
|
446
|
+
) {
|
|
447
|
+
for (const [key, e] of entities) {
|
|
448
|
+
if (!(key === root || key.startsWith(`${root}/`)) || !isResourceDeclarable(e)) continue;
|
|
449
|
+
const entity = e as TerraformEntity;
|
|
450
|
+
const scope = scopeOfKey(key);
|
|
451
|
+
if (entity.entityType === VARIABLE_TYPE && entity.props.address.startsWith("var.")) {
|
|
452
|
+
(this.vars.get(scope) ?? this.vars.set(scope, new Map()).get(scope)!).set(entity.props.address.slice(4), entity);
|
|
453
|
+
} else if (entity.entityType === LOCALS_TYPE) {
|
|
454
|
+
const into = this.locals.get(scope) ?? this.locals.set(scope, new Map()).get(scope)!;
|
|
455
|
+
for (const [name, value] of Object.entries(bodyOf(entity))) into.set(name, value);
|
|
456
|
+
}
|
|
457
|
+
}
|
|
458
|
+
}
|
|
459
|
+
|
|
460
|
+
/** The root module's place. */
|
|
461
|
+
rootPlace(): ModulePlace {
|
|
462
|
+
return this.placeAt(undefined, this.root, "", undefined);
|
|
463
|
+
}
|
|
464
|
+
|
|
465
|
+
private placeAt(parent: ModulePlace | undefined, scope: string, path: string, iteration: Iteration | undefined): ModulePlace {
|
|
466
|
+
const hit = this.places.get(path === "" ? `\u0000${scope}` : path);
|
|
467
|
+
if (hit && hit.scope === scope) return hit;
|
|
468
|
+
const place: ModulePlace = { scope, path, ...(parent ? { parent } : {}), ...(iteration ? { iteration } : {}) };
|
|
469
|
+
this.places.set(path === "" ? `\u0000${scope}` : path, place);
|
|
470
|
+
return place;
|
|
471
|
+
}
|
|
472
|
+
|
|
473
|
+
/**
|
|
474
|
+
* The place an instance's scope names (`module.a["x"].module.b`, as
|
|
475
|
+
* `withInstanceNodes` carries it), or undefined when a call on the way is
|
|
476
|
+
* not a module call of this root.
|
|
477
|
+
*/
|
|
478
|
+
placeOfInstanceScope(instanceScope: string): ModulePlace | undefined {
|
|
479
|
+
let place = this.rootPlace();
|
|
480
|
+
let rest = instanceScope;
|
|
481
|
+
while (rest !== "") {
|
|
482
|
+
const m = SEGMENT_RE.exec(rest);
|
|
483
|
+
if (!m) return undefined;
|
|
484
|
+
rest = rest.slice(m[0].length);
|
|
485
|
+
const next = this.childPlace(place, m[1]!, m[2] === undefined ? undefined : instanceKeyValue(m[2]));
|
|
486
|
+
if (!next || isUnknown(next)) return undefined;
|
|
487
|
+
place = next;
|
|
488
|
+
}
|
|
489
|
+
return place;
|
|
490
|
+
}
|
|
491
|
+
|
|
492
|
+
/**
|
|
493
|
+
* The place of a block-level read of an entity-key scope: every expanded
|
|
494
|
+
* call on the way has an unknown iteration, since the block stands for all
|
|
495
|
+
* of its instances.
|
|
496
|
+
*/
|
|
497
|
+
placeOfScope(scope: string): ModulePlace | undefined {
|
|
498
|
+
let place = this.rootPlace();
|
|
499
|
+
if (scope === this.root) return place;
|
|
500
|
+
if (!scope.startsWith(`${this.root}/`)) return undefined;
|
|
501
|
+
for (const segment of scope.slice(this.root.length + 1).split("/")) {
|
|
502
|
+
if (!segment.startsWith("module.")) return undefined;
|
|
503
|
+
const name = segment.slice("module.".length);
|
|
504
|
+
const callKey = `${place.scope}/module.${name}`;
|
|
505
|
+
const call = this.entities.get(callKey);
|
|
506
|
+
if (!call || (call as TerraformEntity).entityType !== MODULE_TYPE) return undefined;
|
|
507
|
+
const how = expanded(bodyOf(call));
|
|
508
|
+
const pathSeg = `module.${name}`;
|
|
509
|
+
const path = place.path ? `${place.path}.${pathSeg}` : pathSeg;
|
|
510
|
+
const iteration: Iteration | undefined = how === "for_each"
|
|
511
|
+
? { each: new Unknown(prefixed(place, "each.key")) }
|
|
512
|
+
: how === "count" ? { count: new Unknown(prefixed(place, "count.index")) } : undefined;
|
|
513
|
+
place = this.placeAt(place, `${callKey}`, `${path}${how ? "[*]" : ""}`, iteration);
|
|
514
|
+
}
|
|
515
|
+
return place;
|
|
516
|
+
}
|
|
517
|
+
|
|
518
|
+
/** A module call's instance place, or an unknown when its key is not known; undefined when there is no such call. */
|
|
519
|
+
private childPlace(place: ModulePlace, name: string, key: number | string | undefined): ModulePlace | Unknown | undefined {
|
|
520
|
+
const callKey = `${place.scope}/module.${name}`;
|
|
521
|
+
const call = this.entities.get(callKey);
|
|
522
|
+
if (!call || (call as TerraformEntity).entityType !== MODULE_TYPE) return undefined;
|
|
523
|
+
const body = bodyOf(call);
|
|
524
|
+
const how = expanded(body);
|
|
525
|
+
const seg = `module.${name}`;
|
|
526
|
+
if (!how) {
|
|
527
|
+
if (key !== undefined) return new Unknown(prefixed(place, `${seg}[${JSON.stringify(key)}]`));
|
|
528
|
+
return this.placeAt(place, callKey, place.path ? `${place.path}.${seg}` : seg, undefined);
|
|
529
|
+
}
|
|
530
|
+
if (key === undefined) return new Unknown(prefixed(place, seg));
|
|
531
|
+
const iteration = this.iterationOf(body, { place }, key);
|
|
532
|
+
const keyText = typeof key === "number" ? `[${key}]` : `[${JSON.stringify(key)}]`;
|
|
533
|
+
return this.placeAt(place, callKey, `${place.path ? `${place.path}.` : ""}${seg}${keyText}`, iteration);
|
|
534
|
+
}
|
|
535
|
+
|
|
536
|
+
/** The iteration of one instance of an expanded block, by its key. */
|
|
537
|
+
iterationOf(body: BlockBody, env: Env, key: number | string): Iteration {
|
|
538
|
+
if ("count" in body) return { count: typeof key === "number" ? key : new Unknown(prefixed(env.place, "count.index")) };
|
|
539
|
+
const all = this.value(body.for_each, { place: env.place });
|
|
540
|
+
if (isUnknown(all)) return { each: all };
|
|
541
|
+
if (Array.isArray(all)) return { each: { key, value: key } };
|
|
542
|
+
if (typeof all === "object" && all !== null && typeof key === "string" && key in all) {
|
|
543
|
+
return { each: { key, value: (all as Record<string, unknown>)[key] } };
|
|
544
|
+
}
|
|
545
|
+
return { each: new Unknown(prefixed(env.place, "each.key")) };
|
|
546
|
+
}
|
|
547
|
+
|
|
548
|
+
/** The block-level iteration of a block: unknown when it is expanded, none when it is not. */
|
|
549
|
+
blockIteration(body: BlockBody, place: ModulePlace): Iteration | undefined {
|
|
550
|
+
const how = expanded(body);
|
|
551
|
+
if (how === "for_each") return { each: new Unknown(prefixed(place, "each.key")) };
|
|
552
|
+
if (how === "count") return { count: new Unknown(prefixed(place, "count.index")) };
|
|
553
|
+
return undefined;
|
|
554
|
+
}
|
|
555
|
+
|
|
556
|
+
/**
|
|
557
|
+
* A value from a parsed body (a literal, a hcl2json `"${...}"` string, or a
|
|
558
|
+
* list or map of those) evaluated in a place. Unknown parts stay
|
|
559
|
+
* {@link Unknown}; a map keeps its known entries beside them.
|
|
560
|
+
*/
|
|
561
|
+
value(raw: unknown, env: Env): unknown {
|
|
562
|
+
if (this.depth > 64) return new Unknown("(expression too deep)");
|
|
563
|
+
this.depth++;
|
|
564
|
+
try {
|
|
565
|
+
if (typeof raw === "string") {
|
|
566
|
+
if (!raw.includes("${") && !raw.includes("%{")) return raw;
|
|
567
|
+
const expr = parseValueString(raw);
|
|
568
|
+
if (expr instanceof Unsupported) return new Unknown(prefixed(env.place, expr.text));
|
|
569
|
+
return this.expr(expr, env);
|
|
570
|
+
}
|
|
571
|
+
if (Array.isArray(raw)) return raw.map((v) => this.value(v, env));
|
|
572
|
+
if (typeof raw === "object" && raw !== null) {
|
|
573
|
+
const out: Record<string, unknown> = {};
|
|
574
|
+
for (const [k, v] of Object.entries(raw)) {
|
|
575
|
+
let key: unknown = k;
|
|
576
|
+
if (k.includes("${")) key = this.value(k, env);
|
|
577
|
+
if (typeof key !== "string") return isUnknown(key) ? key : new Unknown(prefixed(env.place, k));
|
|
578
|
+
out[key] = this.value(v, env);
|
|
579
|
+
}
|
|
580
|
+
return out;
|
|
581
|
+
}
|
|
582
|
+
return raw;
|
|
583
|
+
} finally {
|
|
584
|
+
this.depth--;
|
|
585
|
+
}
|
|
586
|
+
}
|
|
587
|
+
|
|
588
|
+
private expr(e: Expr, env: Env): unknown {
|
|
589
|
+
switch (e.t) {
|
|
590
|
+
case "lit":
|
|
591
|
+
return e.v;
|
|
592
|
+
case "tpl": {
|
|
593
|
+
let out = "";
|
|
594
|
+
for (const p of e.parts) {
|
|
595
|
+
if (typeof p === "string") {
|
|
596
|
+
out += p;
|
|
597
|
+
continue;
|
|
598
|
+
}
|
|
599
|
+
const v = this.expr(p, env);
|
|
600
|
+
if (isUnknown(v)) return v;
|
|
601
|
+
if (typeof v === "string") out += v;
|
|
602
|
+
else if (typeof v === "number" || typeof v === "boolean") out += String(v);
|
|
603
|
+
else return new Unknown(prefixed(env.place, e.text));
|
|
604
|
+
}
|
|
605
|
+
return out;
|
|
606
|
+
}
|
|
607
|
+
case "tuple":
|
|
608
|
+
return e.items.map((i) => this.expr(i, env));
|
|
609
|
+
case "object": {
|
|
610
|
+
const out: Record<string, unknown> = {};
|
|
611
|
+
for (const [k, v] of e.entries) {
|
|
612
|
+
const key = this.expr(k, env);
|
|
613
|
+
if (isUnknown(key)) return key;
|
|
614
|
+
if (typeof key !== "string" && typeof key !== "number") return new Unknown(prefixed(env.place, "(object key)"));
|
|
615
|
+
out[String(key)] = this.expr(v, env);
|
|
616
|
+
}
|
|
617
|
+
return out;
|
|
618
|
+
}
|
|
619
|
+
case "cond": {
|
|
620
|
+
const c = this.expr(e.c, env);
|
|
621
|
+
if (isUnknown(c)) return c;
|
|
622
|
+
if (typeof c !== "boolean") return new Unknown(prefixed(env.place, "(condition)"));
|
|
623
|
+
return this.expr(c ? e.a : e.b, env);
|
|
624
|
+
}
|
|
625
|
+
case "eq": {
|
|
626
|
+
const l = this.expr(e.l, env);
|
|
627
|
+
const r = this.expr(e.r, env);
|
|
628
|
+
const u = firstUnknown(l) ?? firstUnknown(r);
|
|
629
|
+
if (u) return u;
|
|
630
|
+
return sameValue(l, r) !== e.negate;
|
|
631
|
+
}
|
|
632
|
+
case "call":
|
|
633
|
+
return this.call(e, env);
|
|
634
|
+
case "post":
|
|
635
|
+
return this.steps(this.expr(e.of, env), e.steps, env, e.text);
|
|
636
|
+
case "ref":
|
|
637
|
+
return this.ref(e, env);
|
|
638
|
+
}
|
|
639
|
+
}
|
|
640
|
+
|
|
641
|
+
private call(e: Extract<Expr, { t: "call" }>, env: Env): unknown {
|
|
642
|
+
const args = () => e.args.map((a) => this.expr(a, env));
|
|
643
|
+
if (e.name === "lookup" && (e.args.length === 2 || e.args.length === 3)) {
|
|
644
|
+
const [map, key, dflt] = args();
|
|
645
|
+
if (isUnknown(map)) return map;
|
|
646
|
+
if (isUnknown(key)) return key;
|
|
647
|
+
if (typeof map !== "object" || map === null || Array.isArray(map) || typeof key !== "string") return new Unknown(prefixed(env.place, e.text));
|
|
648
|
+
if (key in map) return (map as Record<string, unknown>)[key];
|
|
649
|
+
return e.args.length === 3 ? dflt : new Unknown(prefixed(env.place, e.text));
|
|
650
|
+
}
|
|
651
|
+
if (e.name === "toset" && e.args.length === 1) {
|
|
652
|
+
const [list] = args();
|
|
653
|
+
const u = firstUnknown(list);
|
|
654
|
+
if (u) return u;
|
|
655
|
+
if (!Array.isArray(list)) return new Unknown(prefixed(env.place, e.text));
|
|
656
|
+
const set = list.every((v) => typeof v === "string") ? [...new Set(list as string[])].sort() : [...list];
|
|
657
|
+
SETS.add(set);
|
|
658
|
+
return set;
|
|
659
|
+
}
|
|
660
|
+
if (e.name === "length" && e.args.length === 1) {
|
|
661
|
+
const [v] = args();
|
|
662
|
+
if (isUnknown(v)) return v;
|
|
663
|
+
if (Array.isArray(v)) return v.length;
|
|
664
|
+
if (typeof v === "object" && v !== null) return Object.keys(v).length;
|
|
665
|
+
if (typeof v === "string") return [...v].length;
|
|
666
|
+
return new Unknown(prefixed(env.place, e.text));
|
|
667
|
+
}
|
|
668
|
+
return new Unknown(prefixed(env.place, `${e.name}()`));
|
|
669
|
+
}
|
|
670
|
+
|
|
671
|
+
/** Apply traversal steps to a value. `text` names the whole traversal when a step does not apply. */
|
|
672
|
+
private steps(v: unknown, steps: readonly Step[], env: Env, text: string): unknown {
|
|
673
|
+
let cur = v;
|
|
674
|
+
for (const s of steps) {
|
|
675
|
+
if (isUnknown(cur)) return cur;
|
|
676
|
+
if ("splat" in s) return new Unknown(prefixed(env.place, text));
|
|
677
|
+
let key: unknown;
|
|
678
|
+
if ("attr" in s) key = s.attr;
|
|
679
|
+
else {
|
|
680
|
+
key = this.expr(s.index, env);
|
|
681
|
+
if (isUnknown(key)) return key;
|
|
682
|
+
}
|
|
683
|
+
if (Array.isArray(cur) && typeof key === "number" && key >= 0 && key < cur.length) cur = cur[key];
|
|
684
|
+
else if (typeof cur === "object" && cur !== null && !Array.isArray(cur) && (typeof key === "string" || typeof key === "number") && String(key) in cur) {
|
|
685
|
+
cur = (cur as Record<string, unknown>)[String(key)];
|
|
686
|
+
} else return new Unknown(prefixed(env.place, text));
|
|
687
|
+
}
|
|
688
|
+
return cur;
|
|
689
|
+
}
|
|
690
|
+
|
|
691
|
+
private ref(e: Extract<Expr, { t: "ref" }>, env: Env): unknown {
|
|
692
|
+
const { place } = env;
|
|
693
|
+
const unknown = () => new Unknown(prefixed(place, e.text));
|
|
694
|
+
const first = e.steps[0];
|
|
695
|
+
const firstAttr = first && "attr" in first ? first.attr : undefined;
|
|
696
|
+
switch (e.root) {
|
|
697
|
+
case "var":
|
|
698
|
+
return firstAttr === undefined ? unknown() : this.steps(this.variable(place, firstAttr), e.steps.slice(1), env, e.text);
|
|
699
|
+
case "local":
|
|
700
|
+
return firstAttr === undefined ? unknown() : this.steps(this.local(place, firstAttr), e.steps.slice(1), env, e.text);
|
|
701
|
+
case "each": {
|
|
702
|
+
const each = env.iteration?.each;
|
|
703
|
+
if (!each || (firstAttr !== "key" && firstAttr !== "value")) return unknown();
|
|
704
|
+
if (isUnknown(each)) return new Unknown(prefixed(place, `each.${firstAttr}`));
|
|
705
|
+
return this.steps(firstAttr === "key" ? each.key : each.value, e.steps.slice(1), env, e.text);
|
|
706
|
+
}
|
|
707
|
+
case "count": {
|
|
708
|
+
const count = env.iteration?.count;
|
|
709
|
+
if (count === undefined || firstAttr !== "index" || e.steps.length !== 1) return unknown();
|
|
710
|
+
return isUnknown(count) ? new Unknown(prefixed(place, "count.index")) : count;
|
|
711
|
+
}
|
|
712
|
+
case "module":
|
|
713
|
+
return firstAttr === undefined ? unknown() : this.moduleOutput(e, env, firstAttr);
|
|
714
|
+
case "data":
|
|
715
|
+
case "path":
|
|
716
|
+
case "terraform":
|
|
717
|
+
case "self":
|
|
718
|
+
return unknown();
|
|
719
|
+
default:
|
|
720
|
+
return firstAttr === undefined ? unknown() : this.resourceArgument(e, env, firstAttr);
|
|
721
|
+
}
|
|
722
|
+
}
|
|
723
|
+
|
|
724
|
+
/** `module.<call>[key]?.<output>...`. */
|
|
725
|
+
private moduleOutput(e: Extract<Expr, { t: "ref" }>, env: Env, name: string): unknown {
|
|
726
|
+
let i = 1;
|
|
727
|
+
let key: number | string | undefined;
|
|
728
|
+
const idx = e.steps[1];
|
|
729
|
+
if (idx && "index" in idx) {
|
|
730
|
+
const k = this.expr(idx.index, env);
|
|
731
|
+
if (isUnknown(k)) return k;
|
|
732
|
+
if (typeof k !== "number" && typeof k !== "string") return new Unknown(prefixed(env.place, e.text));
|
|
733
|
+
key = k;
|
|
734
|
+
i = 2;
|
|
735
|
+
}
|
|
736
|
+
const child = this.childPlace(env.place, name, key);
|
|
737
|
+
if (child === undefined) return new Unknown(prefixed(env.place, e.text));
|
|
738
|
+
if (isUnknown(child)) return child;
|
|
739
|
+
const out = e.steps[i];
|
|
740
|
+
if (!out || !("attr" in out)) return new Unknown(prefixed(env.place, e.text));
|
|
741
|
+
const output = this.entities.get(`${child.scope}/output.${out.attr}`);
|
|
742
|
+
if (!output || (output as TerraformEntity).entityType !== OUTPUT_TYPE) return new Unknown(prefixed(env.place, e.text));
|
|
743
|
+
const body = bodyOf(output);
|
|
744
|
+
if (body.sensitive === true) return new Unknown(prefixed(child, `output.${out.attr}`));
|
|
745
|
+
const memoKey = `out\u0000${child.path}\u0000${child.scope}\u0000${out.attr}`;
|
|
746
|
+
const v = this.guarded(memoKey, () => this.value(body.value, { place: child }), () => new Unknown(prefixed(child, `output.${out.attr}`)));
|
|
747
|
+
return this.steps(v, e.steps.slice(i + 1), env, e.text);
|
|
748
|
+
}
|
|
749
|
+
|
|
750
|
+
/** `<type>.<name>[key]?.<arg>...` in the same module: the argument as the block sets it. */
|
|
751
|
+
private resourceArgument(e: Extract<Expr, { t: "ref" }>, env: Env, name: string): unknown {
|
|
752
|
+
const address = `${e.root}.${name}`;
|
|
753
|
+
const entity = this.entities.get(`${env.place.scope}/${address}`);
|
|
754
|
+
const unknown = () => new Unknown(prefixed(env.place, e.text));
|
|
755
|
+
if (!entity || (entity as TerraformEntity).entityType !== RESOURCE_TYPE) return unknown();
|
|
756
|
+
const body = bodyOf(entity);
|
|
757
|
+
let i = 1;
|
|
758
|
+
let iteration: Iteration | undefined;
|
|
759
|
+
const how = expanded(body);
|
|
760
|
+
if (how) {
|
|
761
|
+
const idx = e.steps[1];
|
|
762
|
+
if (!idx || !("index" in idx)) return unknown();
|
|
763
|
+
const k = this.expr(idx.index, env);
|
|
764
|
+
if (isUnknown(k)) return k;
|
|
765
|
+
if (typeof k !== "number" && typeof k !== "string") return unknown();
|
|
766
|
+
iteration = this.iterationOf(body, { place: env.place }, k);
|
|
767
|
+
i = 2;
|
|
768
|
+
}
|
|
769
|
+
const arg = e.steps[i];
|
|
770
|
+
if (!arg || !("attr" in arg) || !(arg.attr in body) || ["count", "for_each", "depends_on", "provider", "lifecycle"].includes(arg.attr)) return unknown();
|
|
771
|
+
const memoKey = `res\u0000${env.place.path}\u0000${env.place.scope}\u0000${address}\u0000${JSON.stringify(iteration ?? null, (_, v) => (isUnknown(v) ? `?${v.ref}` : v))}\u0000${arg.attr}`;
|
|
772
|
+
const v = this.guarded(memoKey, () => this.value(body[arg.attr], { place: env.place, ...(iteration ? { iteration } : {}) }), unknown);
|
|
773
|
+
return this.steps(v, e.steps.slice(i + 1), env, e.text);
|
|
774
|
+
}
|
|
775
|
+
|
|
776
|
+
/** A variable's value in a place. */
|
|
777
|
+
private variable(place: ModulePlace, name: string): unknown {
|
|
778
|
+
const decl = this.vars.get(place.scope)?.get(name);
|
|
779
|
+
const unknown = () => new Unknown(prefixed(place, `var.${name}`));
|
|
780
|
+
if (!decl) return unknown();
|
|
781
|
+
const body = bodyOf(decl);
|
|
782
|
+
if (body.sensitive === true) return unknown();
|
|
783
|
+
return this.guarded(`var\u0000${place.path}\u0000${place.scope}\u0000${name}`, () => {
|
|
784
|
+
if (place.parent === undefined) {
|
|
785
|
+
const v = this.tfvars.has(name) ? this.tfvars.get(name) : body.default;
|
|
786
|
+
return v === undefined || holdsExpression(v) ? unknown() : v;
|
|
787
|
+
}
|
|
788
|
+
const call = this.entities.get(place.scope);
|
|
789
|
+
const callBody = bodyOf(call);
|
|
790
|
+
if (name in callBody) return this.value(callBody[name], { place: place.parent, ...(place.iteration ? { iteration: place.iteration } : {}) });
|
|
791
|
+
return body.default === undefined || holdsExpression(body.default) ? unknown() : body.default;
|
|
792
|
+
}, unknown);
|
|
793
|
+
}
|
|
794
|
+
|
|
795
|
+
/** A local value in a place. */
|
|
796
|
+
private local(place: ModulePlace, name: string): unknown {
|
|
797
|
+
const scoped = this.locals.get(place.scope);
|
|
798
|
+
if (!scoped?.has(name)) return new Unknown(prefixed(place, `local.${name}`));
|
|
799
|
+
return this.guarded(`local\u0000${place.path}\u0000${place.scope}\u0000${name}`, () => this.value(scoped.get(name), { place }), () => new Unknown(prefixed(place, `local.${name}`)));
|
|
800
|
+
}
|
|
801
|
+
|
|
802
|
+
/** Memoized, and unknown on a cycle. */
|
|
803
|
+
private guarded(key: string, compute: () => unknown, onCycle: () => Unknown): unknown {
|
|
804
|
+
if (this.memo.has(key)) return this.memo.get(key);
|
|
805
|
+
if (this.visiting.has(key)) return onCycle();
|
|
806
|
+
this.visiting.add(key);
|
|
807
|
+
try {
|
|
808
|
+
const v = compute();
|
|
809
|
+
this.memo.set(key, v);
|
|
810
|
+
return v;
|
|
811
|
+
} finally {
|
|
812
|
+
this.visiting.delete(key);
|
|
813
|
+
}
|
|
814
|
+
}
|
|
815
|
+
}
|
|
816
|
+
|
|
817
|
+
/**
|
|
818
|
+
* Terraform's `==` over two known values: the same type and the same value,
|
|
819
|
+
* with no conversion, so `"1" == 1` is false. Lists compare element by
|
|
820
|
+
* element and maps key by key.
|
|
821
|
+
*/
|
|
822
|
+
function sameValue(a: unknown, b: unknown): boolean {
|
|
823
|
+
if (a === null || b === null || typeof a !== "object" || typeof b !== "object") return a === b;
|
|
824
|
+
if (Array.isArray(a) !== Array.isArray(b)) return false;
|
|
825
|
+
if (Array.isArray(a)) {
|
|
826
|
+
const bl = b as unknown[];
|
|
827
|
+
return a.length === bl.length && a.every((x, i) => sameValue(x, bl[i]));
|
|
828
|
+
}
|
|
829
|
+
const ak = Object.keys(a as object);
|
|
830
|
+
const bo = b as Record<string, unknown>;
|
|
831
|
+
return ak.length === Object.keys(bo).length && ak.every((k) => k in bo && sameValue((a as Record<string, unknown>)[k], bo[k]));
|
|
832
|
+
}
|
|
833
|
+
|
|
834
|
+
/** A reference named as Terraform prints it from the root: the module path in front. */
|
|
835
|
+
function prefixed(place: ModulePlace, ref: string): string {
|
|
836
|
+
return place.path ? `${place.path}.${ref}` : ref;
|
|
837
|
+
}
|
|
838
|
+
|
|
839
|
+
/** Whether a value still holds an expression. */
|
|
840
|
+
function holdsExpression(value: unknown): boolean {
|
|
841
|
+
if (typeof value === "string") return value.includes("${");
|
|
842
|
+
if (Array.isArray(value)) return value.some(holdsExpression);
|
|
843
|
+
if (typeof value === "object" && value !== null) return Object.entries(value).some(([k, v]) => k.includes("${") || holdsExpression(v));
|
|
844
|
+
return false;
|
|
845
|
+
}
|
|
846
|
+
|
|
847
|
+
// ── Arguments ────────────────────────────────────────────────────────────────
|
|
848
|
+
|
|
849
|
+
/**
|
|
850
|
+
* What evaluating one block's arguments gave: the arguments that held an
|
|
851
|
+
* expression and resolved, shaped like the body (a nested block keeps its
|
|
852
|
+
* place in its list), and per argument that did not, the reference that
|
|
853
|
+
* stopped it.
|
|
854
|
+
*/
|
|
855
|
+
export interface EvaluatedArguments {
|
|
856
|
+
arguments?: Record<string, unknown>;
|
|
857
|
+
stopped?: Record<string, string>;
|
|
858
|
+
}
|
|
859
|
+
|
|
860
|
+
const isBlock = (v: unknown): v is Record<string, unknown> => typeof v === "object" && v !== null && !Array.isArray(v);
|
|
861
|
+
|
|
862
|
+
/** True when a value holds an interpolation, `${...}`, anywhere in it. */
|
|
863
|
+
export function interpolated(value: unknown, depth = 0): boolean {
|
|
864
|
+
if (depth > 12) return false;
|
|
865
|
+
if (typeof value === "string") return value.includes("${");
|
|
866
|
+
if (Array.isArray(value)) return value.some((v) => interpolated(v, depth + 1));
|
|
867
|
+
if (isBlock(value)) return Object.values(value).some((v) => interpolated(v, depth + 1));
|
|
868
|
+
return false;
|
|
869
|
+
}
|
|
870
|
+
|
|
871
|
+
/**
|
|
872
|
+
* Evaluate the arguments of a block body that hold an expression, walking
|
|
873
|
+
* nested blocks and maps the way the catalog's literal view does.
|
|
874
|
+
*/
|
|
875
|
+
export function evaluateArguments(body: BlockBody, evaluate: (raw: unknown) => unknown): EvaluatedArguments {
|
|
876
|
+
const stopped: Record<string, string> = {};
|
|
877
|
+
const walk = (obj: Record<string, unknown>, path: string, depth: number): Record<string, unknown> | undefined => {
|
|
878
|
+
let out: Record<string, unknown> | undefined;
|
|
879
|
+
for (const [key, value] of Object.entries(obj)) {
|
|
880
|
+
if (depth > 12) break;
|
|
881
|
+
const at = path ? `${path}.${key}` : key;
|
|
882
|
+
if (isBlock(value)) {
|
|
883
|
+
const inner = walk(value, at, depth + 1);
|
|
884
|
+
if (inner) (out ??= {})[key] = inner;
|
|
885
|
+
} else if (Array.isArray(value) && value.length > 0 && value.every(isBlock)) {
|
|
886
|
+
const inner = value.map((b, i) => walk(b, `${at}[${i}]`, depth + 1));
|
|
887
|
+
if (inner.some((x) => x !== undefined)) (out ??= {})[key] = inner.map((x) => x ?? {});
|
|
888
|
+
} else if (interpolated(value)) {
|
|
889
|
+
const v = evaluate(value);
|
|
890
|
+
const u = firstUnknown(v);
|
|
891
|
+
if (u) stopped[at] = u.ref;
|
|
892
|
+
else (out ??= {})[key] = v;
|
|
893
|
+
}
|
|
894
|
+
}
|
|
895
|
+
return out;
|
|
896
|
+
};
|
|
897
|
+
const resolved = walk(body, "", 0);
|
|
898
|
+
return { ...(resolved ? { arguments: resolved } : {}), ...(Object.keys(stopped).length > 0 ? { stopped } : {}) };
|
|
899
|
+
}
|