@intentius/chant 0.124.57 → 0.124.59
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/ci-product-words.d.ts +47 -2
- package/dist/ci-product-words.d.ts.map +1 -1
- package/dist/ci-product-words.js +59 -1
- package/dist/ci-product.d.ts +26 -2
- package/dist/ci-product.d.ts.map +1 -1
- package/dist/ci-product.js +25 -2
- package/dist/cli/commands/init.d.ts +2 -0
- package/dist/cli/commands/init.d.ts.map +1 -1
- package/dist/cli/commands/init.js +1 -1
- package/dist/cli/handlers/build.d.ts.map +1 -1
- package/dist/cli/handlers/build.js +5 -1
- package/dist/cli/handlers/init.d.ts.map +1 -1
- package/dist/cli/handlers/init.js +16 -0
- package/dist/cli/handlers/lifecycle-drift.d.ts +2 -1
- package/dist/cli/handlers/lifecycle-drift.d.ts.map +1 -1
- package/dist/cli/handlers/lifecycle-drift.js +4 -2
- package/dist/cli/handlers/lock.d.ts.map +1 -1
- package/dist/cli/handlers/lock.js +45 -2
- package/dist/cli/handlers/serve.d.ts.map +1 -1
- package/dist/cli/handlers/serve.js +9 -0
- package/dist/cli/main.d.ts.map +1 -1
- package/dist/cli/main.js +11 -3
- package/dist/cli/mcp/product-tools.d.ts +40 -7
- package/dist/cli/mcp/product-tools.d.ts.map +1 -1
- package/dist/cli/mcp/product-tools.js +58 -15
- package/dist/cli/mcp/read-only.d.ts +2 -1
- package/dist/cli/mcp/read-only.d.ts.map +1 -1
- package/dist/cli/mcp/read-only.js +2 -1
- package/dist/cli/mcp/server.d.ts +11 -0
- package/dist/cli/mcp/server.d.ts.map +1 -1
- package/dist/cli/mcp/server.js +15 -3
- package/dist/cli/mcp-config.d.ts +4 -1
- package/dist/cli/mcp-config.d.ts.map +1 -1
- package/dist/cli/mcp-config.js +6 -2
- package/dist/cli/parse-args.d.ts.map +1 -1
- package/dist/cli/parse-args.js +27 -0
- package/dist/cli/registry.d.ts +14 -0
- package/dist/cli/registry.d.ts.map +1 -1
- package/dist/components/pr-pipeline.d.ts +56 -0
- package/dist/components/pr-pipeline.d.ts.map +1 -1
- package/dist/components/pr-pipeline.js +55 -2
- package/dist/components/product-pipeline.d.ts +18 -1
- package/dist/components/product-pipeline.d.ts.map +1 -1
- package/dist/components/product-pipeline.js +8 -2
- package/dist/drift-record.d.ts +5 -0
- package/dist/drift-record.d.ts.map +1 -1
- package/dist/e2e-harness/driver.d.ts.map +1 -1
- package/dist/e2e-harness/driver.js +97 -0
- package/dist/e2e-harness/forgejo.d.ts +5 -1
- package/dist/e2e-harness/forgejo.d.ts.map +1 -1
- package/dist/e2e-harness/forgejo.js +35 -0
- package/dist/e2e-harness/index.d.ts +7 -0
- package/dist/e2e-harness/index.d.ts.map +1 -1
- package/dist/e2e-harness/index.js +10 -1
- package/dist/e2e-harness/ports.d.ts +31 -0
- package/dist/e2e-harness/ports.d.ts.map +1 -1
- package/dist/e2e-harness/scenario.d.ts.map +1 -1
- package/dist/e2e-harness/scenario.js +9 -5
- package/dist/e2e-harness/schemas/e2e-scenario.schema.json +43 -3
- package/dist/e2e-harness/schemas/index.d.ts +22 -1
- package/dist/e2e-harness/schemas/index.d.ts.map +1 -1
- package/dist/e2e-harness/schemas/index.js +1 -1
- package/dist/e2e-harness/steps.d.ts.map +1 -1
- package/dist/e2e-harness/steps.js +4 -0
- package/dist/lifecycle/lock-beat.d.ts +27 -0
- package/dist/lifecycle/lock-beat.d.ts.map +1 -0
- package/dist/lifecycle/lock-beat.js +84 -0
- package/dist/lifecycle/resource-lock.d.ts +54 -1
- package/dist/lifecycle/resource-lock.d.ts.map +1 -1
- package/dist/lifecycle/resource-lock.js +128 -7
- package/dist/mcp/types.d.ts +9 -0
- package/dist/mcp/types.d.ts.map +1 -1
- package/dist/op/activities/activity-contracts.d.ts +4 -4
- package/dist/op/index.d.ts +1 -1
- package/dist/op/index.d.ts.map +1 -1
- package/dist/op/index.js +1 -1
- package/dist/op/op-waves-notify.d.ts.map +1 -1
- package/dist/op/op-waves-notify.js +11 -0
- package/dist/op/op-waves-run.d.ts +28 -1
- package/dist/op/op-waves-run.d.ts.map +1 -1
- package/dist/op/op-waves-run.js +92 -7
- package/dist/op/op-waves.d.ts +12 -1
- package/dist/op/op-waves.d.ts.map +1 -1
- package/dist/op/op-waves.js +9 -2
- package/dist/release-floors.d.ts +1 -1
- package/dist/release-floors.js +1 -1
- package/dist/template-request/index.d.ts +9 -0
- package/dist/template-request/index.d.ts.map +1 -0
- package/dist/template-request/index.js +8 -0
- package/dist/template-request/request-body.d.ts +21 -0
- package/dist/template-request/request-body.d.ts.map +1 -0
- package/dist/template-request/request-body.js +86 -0
- package/dist/template-request/template-request.d.ts +100 -0
- package/dist/template-request/template-request.d.ts.map +1 -0
- package/dist/template-request/template-request.js +149 -0
- package/dist/template-request/template-request.schema.json +100 -0
- package/dist/template-request/template-spec.d.ts +83 -0
- package/dist/template-request/template-spec.d.ts.map +1 -0
- package/dist/template-request/template-spec.js +146 -0
- package/dist/template-request/template.schema.json +114 -0
- package/dist/template-request/validate.d.ts +4 -0
- package/dist/template-request/validate.d.ts.map +1 -0
- package/dist/template-request/validate.js +21 -0
- package/dist/wave-runtime.mjs +298 -298
- package/dist/workspace/drift-cli.d.ts +13 -1
- package/dist/workspace/drift-cli.d.ts.map +1 -1
- package/dist/workspace/drift-cli.js +19 -3
- package/package.json +8 -1
- package/src/ci-product-words.test.ts +23 -0
- package/src/ci-product-words.ts +68 -3
- package/src/ci-product.ts +31 -1
- package/src/cli/commands/init.ts +3 -1
- package/src/cli/handlers/build.ts +5 -1
- package/src/cli/handlers/init.ts +18 -0
- package/src/cli/handlers/lifecycle-drift.test.ts +52 -0
- package/src/cli/handlers/lifecycle-drift.ts +4 -2
- package/src/cli/handlers/lock.ts +41 -2
- package/src/cli/handlers/serve.ts +9 -0
- package/src/cli/main.ts +11 -3
- package/src/cli/mcp/product-tools.test.ts +56 -1
- package/src/cli/mcp/product-tools.ts +66 -15
- package/src/cli/mcp/read-only.ts +2 -1
- package/src/cli/mcp/server.ts +20 -5
- package/src/cli/mcp-config.test.ts +52 -2
- package/src/cli/mcp-config.ts +6 -3
- package/src/cli/parse-args.ts +19 -0
- package/src/cli/registry.ts +14 -0
- package/src/components/pr-pipeline.ts +87 -2
- package/src/components/product-actions.test.ts +76 -0
- package/src/components/product-pipeline.ts +21 -2
- package/src/drift-record.ts +5 -0
- package/src/e2e-harness/driver.test.ts +163 -0
- package/src/e2e-harness/driver.ts +86 -1
- package/src/e2e-harness/forgejo.ts +42 -1
- package/src/e2e-harness/index.ts +11 -1
- package/src/e2e-harness/ports.ts +33 -0
- package/src/e2e-harness/scenario.ts +8 -6
- package/src/e2e-harness/schemas/README.md +11 -2
- package/src/e2e-harness/schemas/e2e-scenario.schema.json +43 -3
- package/src/e2e-harness/schemas/index.ts +5 -1
- package/src/e2e-harness/schemas.test.ts +44 -1
- package/src/e2e-harness/steps.ts +4 -0
- package/src/lifecycle/lock-beat.ts +99 -0
- package/src/lifecycle/resource-lock-liveness.test.ts +289 -0
- package/src/lifecycle/resource-lock.ts +143 -8
- package/src/mcp/types.ts +9 -0
- package/src/op/index.ts +1 -0
- package/src/op/op-waves-notify.ts +11 -0
- package/src/op/op-waves-preview.test.ts +167 -0
- package/src/op/op-waves-run.ts +116 -8
- package/src/op/op-waves.ts +20 -3
- package/src/release-floors.ts +1 -1
- package/src/template-request/__fixtures__/request-body.md +41 -0
- package/src/template-request/index.ts +8 -0
- package/src/template-request/request-body.ts +91 -0
- package/src/template-request/template-request.schema.json +100 -0
- package/src/template-request/template-request.test.ts +315 -0
- package/src/template-request/template-request.ts +234 -0
- package/src/template-request/template-spec.ts +176 -0
- package/src/template-request/template.schema.json +114 -0
- package/src/template-request/validate.ts +28 -0
- package/src/workspace/drift-cli.test.ts +35 -1
- package/src/workspace/drift-cli.ts +21 -3
|
@@ -0,0 +1,315 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* template-request/v1 and template.yml/v1 (#4651): the schemas, one test per
|
|
3
|
+
* refusal code, the branch, and the pull request body's golden and
|
|
4
|
+
* round trip.
|
|
5
|
+
*/
|
|
6
|
+
import { describe, expect, test } from "vitest";
|
|
7
|
+
import Ajv2020 from "ajv/dist/2020";
|
|
8
|
+
import requestSchema from "./template-request.schema.json";
|
|
9
|
+
import templateSchema from "./template.schema.json";
|
|
10
|
+
import pkg from "../../package.json";
|
|
11
|
+
import { buildReleaseCatalog } from "../lifecycle/release-catalog";
|
|
12
|
+
import type { ReleaseRecord } from "../lifecycle/release-ledger";
|
|
13
|
+
import { resolveProductWords } from "../ci-product-words";
|
|
14
|
+
import {
|
|
15
|
+
checkTemplateRequest,
|
|
16
|
+
inputKindProblem,
|
|
17
|
+
isAppOutputRef,
|
|
18
|
+
makeTemplateRequest,
|
|
19
|
+
parseRequestBody,
|
|
20
|
+
parseTemplateSpec,
|
|
21
|
+
requestBody,
|
|
22
|
+
requestBranch,
|
|
23
|
+
TEMPLATE_INPUT_KINDS,
|
|
24
|
+
TEMPLATE_REQUEST_FLOOR,
|
|
25
|
+
TEMPLATE_REQUEST_SCHEMA_ID,
|
|
26
|
+
TEMPLATE_SPEC_SCHEMA_ID,
|
|
27
|
+
TemplateSpecError,
|
|
28
|
+
templateName,
|
|
29
|
+
templateSpecProblems,
|
|
30
|
+
validateTemplateRequest,
|
|
31
|
+
type TemplateRequest,
|
|
32
|
+
type TemplateRequestRefusalCode,
|
|
33
|
+
} from "./index";
|
|
34
|
+
|
|
35
|
+
const rec = (over: Partial<ReleaseRecord>): ReleaseRecord => ({
|
|
36
|
+
version: 1,
|
|
37
|
+
component: "acme/bucket/aws",
|
|
38
|
+
env: "registry",
|
|
39
|
+
digest: "sha256:aaa",
|
|
40
|
+
gitSha: "1111111111111111111111111111111111111111",
|
|
41
|
+
runId: "run-1",
|
|
42
|
+
timestamp: "2026-10-01T00:00:00.000Z",
|
|
43
|
+
actor: "ci",
|
|
44
|
+
...over,
|
|
45
|
+
});
|
|
46
|
+
|
|
47
|
+
const catalog = buildReleaseCatalog(
|
|
48
|
+
{
|
|
49
|
+
releases: [
|
|
50
|
+
rec({ releaseVersion: "1.0.0", digest: "sha256:v1", timestamp: "2026-10-01T00:00:00.000Z" }),
|
|
51
|
+
rec({ releaseVersion: "1.1.0", digest: "sha256:v11", timestamp: "2026-10-05T00:00:00.000Z" }),
|
|
52
|
+
rec({ releaseVersion: "1.2.0", digest: "sha256:v12", timestamp: "2026-10-09T00:00:00.000Z" }),
|
|
53
|
+
rec({ releaseVersion: "2.0.0", digest: "sha256:v2", timestamp: "2026-10-10T00:00:00.000Z" }),
|
|
54
|
+
],
|
|
55
|
+
statuses: [{ component: "acme/bucket/aws", digest: "sha256:v11", status: "yanked", reason: "leaks", replacement: "1.2.0", actor: "ops", timestamp: "2026-10-06T00:00:00.000Z" }],
|
|
56
|
+
attestations: [
|
|
57
|
+
{ component: "acme/bucket/aws", digest: "sha256:v1", state: "signed" },
|
|
58
|
+
{ component: "acme/bucket/aws", digest: "sha256:v11", state: "signed" },
|
|
59
|
+
{ component: "acme/bucket/aws", digest: "sha256:v2", state: "verified" },
|
|
60
|
+
],
|
|
61
|
+
},
|
|
62
|
+
{ generatedAt: "2026-10-27T00:00:00.000Z", chant: "0.0.0-test" },
|
|
63
|
+
);
|
|
64
|
+
|
|
65
|
+
const TEMPLATE_YML = `contract: 1
|
|
66
|
+
description: An object store bucket for one app.
|
|
67
|
+
inputs:
|
|
68
|
+
- name: bucket_name
|
|
69
|
+
kind: string
|
|
70
|
+
label: Bucket name
|
|
71
|
+
- name: versioning
|
|
72
|
+
kind: bool
|
|
73
|
+
default: true
|
|
74
|
+
- name: retention_days
|
|
75
|
+
kind: number
|
|
76
|
+
default: 30
|
|
77
|
+
- name: tags
|
|
78
|
+
kind: map
|
|
79
|
+
of: string
|
|
80
|
+
default: {}
|
|
81
|
+
- name: readers
|
|
82
|
+
kind: list
|
|
83
|
+
of: string
|
|
84
|
+
required: false
|
|
85
|
+
- name: kms_key
|
|
86
|
+
kind: string
|
|
87
|
+
sensitive: true
|
|
88
|
+
`;
|
|
89
|
+
|
|
90
|
+
const spec = parseTemplateSpec(TEMPLATE_YML);
|
|
91
|
+
|
|
92
|
+
const base = (over: Partial<TemplateRequest> = {}): TemplateRequest =>
|
|
93
|
+
({
|
|
94
|
+
...makeTemplateRequest({
|
|
95
|
+
kind: "app",
|
|
96
|
+
template: "acme/bucket/aws",
|
|
97
|
+
version: "1.0.0",
|
|
98
|
+
app: "orders",
|
|
99
|
+
inputs: { bucket_name: "orders-data", tags: { team: "payments" } },
|
|
100
|
+
requestedBy: "alice",
|
|
101
|
+
via: "form",
|
|
102
|
+
}),
|
|
103
|
+
...over,
|
|
104
|
+
}) as TemplateRequest;
|
|
105
|
+
|
|
106
|
+
describe("schemas", () => {
|
|
107
|
+
test("both are valid draft 2020-12 documents under template-request/v1", () => {
|
|
108
|
+
const ajv = new Ajv2020({ strict: true, allErrors: true });
|
|
109
|
+
expect(ajv.validateSchema(requestSchema)).toBe(true);
|
|
110
|
+
expect(ajv.validateSchema(templateSchema)).toBe(true);
|
|
111
|
+
expect(requestSchema.$id).toBe(TEMPLATE_REQUEST_SCHEMA_ID);
|
|
112
|
+
expect(TEMPLATE_REQUEST_SCHEMA_ID.endsWith("template-request/v1/template-request.schema.json")).toBe(true);
|
|
113
|
+
expect(TEMPLATE_SPEC_SCHEMA_ID.endsWith("template-request/v1/template.schema.json")).toBe(true);
|
|
114
|
+
expect(Object.keys(requestSchema.properties).sort()).toEqual(["$schema", "addon", "app", "claimedBy", "contract", "inputs", "kind", "requestedBy", "template", "version", "via"]);
|
|
115
|
+
});
|
|
116
|
+
|
|
117
|
+
test("the input kinds are the schema's, and each is documented there", () => {
|
|
118
|
+
expect(templateSchema.$defs.kind.enum).toEqual([...TEMPLATE_INPUT_KINDS]);
|
|
119
|
+
for (const k of TEMPLATE_INPUT_KINDS) expect(templateSchema.$defs.kind.description).toContain(`${k}:`);
|
|
120
|
+
});
|
|
121
|
+
|
|
122
|
+
test("the floor is the next release", () => {
|
|
123
|
+
expect(TEMPLATE_REQUEST_FLOOR).toBe("0.124.58");
|
|
124
|
+
});
|
|
125
|
+
|
|
126
|
+
test("the package exports ./template-request and its schemas", () => {
|
|
127
|
+
const exports = pkg.exports as Record<string, unknown>;
|
|
128
|
+
expect(exports["./template-request"]).toMatchObject({ development: "./src/template-request/index.ts", import: "./dist/template-request/index.js" });
|
|
129
|
+
expect(exports["./template-request/*.schema.json"]).toBe("./src/template-request/*.schema.json");
|
|
130
|
+
});
|
|
131
|
+
});
|
|
132
|
+
|
|
133
|
+
describe("template.yml", () => {
|
|
134
|
+
test("parses, with required read from the default", () => {
|
|
135
|
+
expect(spec.inputs.map((i) => i.name)).toEqual(["bucket_name", "versioning", "retention_days", "tags", "readers", "kms_key"]);
|
|
136
|
+
});
|
|
137
|
+
|
|
138
|
+
test("refuses a repeated name, a default of the wrong kind, a required input with a default, and `of` on a scalar", () => {
|
|
139
|
+
const doc = {
|
|
140
|
+
contract: 1,
|
|
141
|
+
description: "x",
|
|
142
|
+
inputs: [
|
|
143
|
+
{ name: "a", kind: "number", default: "3" },
|
|
144
|
+
{ name: "a", kind: "string" },
|
|
145
|
+
{ name: "b", kind: "bool", default: false, required: true },
|
|
146
|
+
],
|
|
147
|
+
};
|
|
148
|
+
const problems = templateSpecProblems(doc);
|
|
149
|
+
expect(problems).toEqual([
|
|
150
|
+
'/inputs/0 (a) default is string, and the input is a number',
|
|
151
|
+
'/inputs/1 (a) repeats the name "a"',
|
|
152
|
+
"/inputs/2 (b) is required and has a default; an input with a default is optional",
|
|
153
|
+
]);
|
|
154
|
+
expect(templateSpecProblems({ contract: 1, description: "x", inputs: [{ name: "c", kind: "string", of: "string" }] }).length).toBeGreaterThan(0);
|
|
155
|
+
expect(templateSpecProblems({ contract: 1, description: "x", inputs: [{ name: "c", kind: "tuple" }] }).length).toBeGreaterThan(0);
|
|
156
|
+
expect(() => parseTemplateSpec("contract: 1\n")).toThrow(TemplateSpecError);
|
|
157
|
+
expect(() => parseTemplateSpec("a: [\n")).toThrow(/not YAML/);
|
|
158
|
+
});
|
|
159
|
+
|
|
160
|
+
test("kind checks", () => {
|
|
161
|
+
expect(inputKindProblem({ kind: "number" }, Number.NaN)).toBeDefined();
|
|
162
|
+
expect(inputKindProblem({ kind: "list", of: "number" }, [1, "2"])).toBe("is a list whose element 1 is string, and the input is a list of number");
|
|
163
|
+
expect(inputKindProblem({ kind: "list" }, [1, "2"])).toBeUndefined();
|
|
164
|
+
expect(inputKindProblem({ kind: "map", of: "bool" }, { a: true, b: 1 })).toBe('is a map whose "b" is number, and the input is a map of bool');
|
|
165
|
+
expect(inputKindProblem({ kind: "object" }, [])).toBe("is list, and the input is a object");
|
|
166
|
+
expect(inputKindProblem({ kind: "string" }, null)).toBe("is null, and the input is a string");
|
|
167
|
+
});
|
|
168
|
+
});
|
|
169
|
+
|
|
170
|
+
describe("checkTemplateRequest", () => {
|
|
171
|
+
test("accepts a request the catalog and template allow", () => {
|
|
172
|
+
expect(checkTemplateRequest(base(), catalog, spec)).toEqual({ ok: true, request: base() });
|
|
173
|
+
});
|
|
174
|
+
|
|
175
|
+
const cases: Array<[TemplateRequestRefusalCode, unknown, string, RegExp]> = [
|
|
176
|
+
["unknown-version", base({ version: "9.9.9" }), "version", /version "9\.9\.9" of acme\/bucket\/aws is not in the catalog/],
|
|
177
|
+
["not-active", base({ version: "1.1.0" }), "version", /version 1\.1\.0 of acme\/bucket\/aws is yanked; use 1\.2\.0/],
|
|
178
|
+
["unsigned", base({ version: "1.2.0" }), "version", /version 1\.2\.0 of acme\/bucket\/aws is unsigned, and requests need signed/],
|
|
179
|
+
["unknown-input", base({ inputs: { bucket_name: "b", colour: "red" } }), "inputs.colour", /inputs\.colour: .* has no input "colour"/],
|
|
180
|
+
["missing-input", base({ inputs: {} }), "inputs.bucket_name", /inputs\.bucket_name is required/],
|
|
181
|
+
["sensitive-input", base({ inputs: { bucket_name: "b", kms_key: "k" } }), "inputs.kms_key", /inputs\.kms_key is sensitive/],
|
|
182
|
+
["input-type", base({ inputs: { bucket_name: "b", retention_days: "30" } }), "inputs.retention_days", /inputs\.retention_days is string, and the input is a number/],
|
|
183
|
+
["bad-name", base({ app: "Orders" }), "app", /app "Orders" is not a name/],
|
|
184
|
+
];
|
|
185
|
+
test.each(cases)("%s", (code, request, field, reason) => {
|
|
186
|
+
const out = checkTemplateRequest(request, catalog, spec);
|
|
187
|
+
expect(out.ok).toBe(false);
|
|
188
|
+
if (out.ok) return;
|
|
189
|
+
expect(out.refusals).toHaveLength(1);
|
|
190
|
+
expect(out.refusals[0]).toMatchObject({ code, field });
|
|
191
|
+
expect(out.refusals[0]!.reason).toMatch(reason);
|
|
192
|
+
expect(out.refusals[0]!.reason).toContain(field);
|
|
193
|
+
});
|
|
194
|
+
|
|
195
|
+
test("bad-name covers the add-on, and a deprecated version is not active either", () => {
|
|
196
|
+
const addon = checkTemplateRequest(base({ kind: "addon", addon: "9cache" }), catalog, spec);
|
|
197
|
+
expect(addon.ok ? [] : addon.refusals.map((r) => [r.code, r.field])).toEqual([["bad-name", "addon"]]);
|
|
198
|
+
const deprecated = buildReleaseCatalog(
|
|
199
|
+
{ releases: [rec({ releaseVersion: "1.0.0" })], statuses: [{ component: "acme/bucket/aws", digest: "sha256:aaa", status: "deprecated", actor: "ops", timestamp: "2026-10-02T00:00:00.000Z" }], attestations: [{ component: "acme/bucket/aws", digest: "sha256:aaa", state: "signed" }] },
|
|
200
|
+
{ generatedAt: "2026-10-27T00:00:00.000Z", chant: "0.0.0-test" },
|
|
201
|
+
);
|
|
202
|
+
const out = checkTemplateRequest(base(), deprecated, spec);
|
|
203
|
+
expect(out.ok ? [] : out.refusals.map((r) => r.code)).toEqual(["not-active"]);
|
|
204
|
+
});
|
|
205
|
+
|
|
206
|
+
test("a template the catalog does not list is unknown-version; `component` names it", () => {
|
|
207
|
+
const out = checkTemplateRequest(base({ template: "acme/queue/aws" }), catalog, spec);
|
|
208
|
+
expect(out.ok ? [] : out.refusals.map((r) => r.code)).toEqual(["unknown-version"]);
|
|
209
|
+
expect(checkTemplateRequest(base({ template: "registry.example/acme/bucket/aws" }), catalog, spec, { component: "acme/bucket/aws" }).ok).toBe(true);
|
|
210
|
+
});
|
|
211
|
+
|
|
212
|
+
test("require: unsigned accepts any attestation, verified refuses signed", () => {
|
|
213
|
+
expect(checkTemplateRequest(base({ version: "1.2.0" }), catalog, spec, { require: "unsigned" }).ok).toBe(true);
|
|
214
|
+
const out = checkTemplateRequest(base(), catalog, spec, { require: "verified" });
|
|
215
|
+
expect(out.ok ? [] : out.refusals.map((r) => r.code)).toEqual(["unsigned"]);
|
|
216
|
+
expect(checkTemplateRequest(base({ version: "2.0.0" }), catalog, spec, { require: "verified" }).ok).toBe(true);
|
|
217
|
+
});
|
|
218
|
+
|
|
219
|
+
test("an add-on's app.<output> is accepted for any kind; an app request checks it as a string", () => {
|
|
220
|
+
const refs = { bucket_name: "app.bucket_id", retention_days: "app.retention", readers: "app.reader_arns", tags: "app.tags" };
|
|
221
|
+
const addon = base({ kind: "addon", addon: "cache", inputs: refs });
|
|
222
|
+
expect(checkTemplateRequest(addon, catalog, spec)).toEqual({ ok: true, request: addon });
|
|
223
|
+
const app = checkTemplateRequest(base({ inputs: refs }), catalog, spec);
|
|
224
|
+
expect(app.ok ? [] : app.refusals.map((r) => [r.code, r.field])).toEqual([
|
|
225
|
+
["input-type", "inputs.retention_days"],
|
|
226
|
+
["input-type", "inputs.readers"],
|
|
227
|
+
["input-type", "inputs.tags"],
|
|
228
|
+
]);
|
|
229
|
+
for (const r of app.ok ? [] : app.refusals) expect(r.reason).toMatch(/reads as an app output, and only an add-on request can name one/);
|
|
230
|
+
const notRef = checkTemplateRequest(base({ kind: "addon", addon: "cache", inputs: { bucket_name: "b", retention_days: "app.9x" } }), catalog, spec);
|
|
231
|
+
expect(notRef.ok ? [] : notRef.refusals.map((r) => [r.code, r.reason.includes("app output")])).toEqual([["input-type", false]]);
|
|
232
|
+
});
|
|
233
|
+
|
|
234
|
+
test("isAppOutputRef", () => {
|
|
235
|
+
expect(["app.private_subnets", "app.x", "app._a-b"].every(isAppOutputRef)).toBe(true);
|
|
236
|
+
expect(["app.", "app.9x", "app.a.b", "module.app.x", " app.x", 3, null, ["app.x"]].some(isAppOutputRef)).toBe(false);
|
|
237
|
+
});
|
|
238
|
+
|
|
239
|
+
test("a document the schema refuses is invalid", () => {
|
|
240
|
+
const { via: _via, ...noVia } = base();
|
|
241
|
+
const out = checkTemplateRequest(noVia, catalog, spec);
|
|
242
|
+
expect(out.ok ? [] : out.refusals.map((r) => r.code)).toEqual(["invalid"]);
|
|
243
|
+
const appWithAddon = checkTemplateRequest(base({ addon: "cache" }), catalog, spec);
|
|
244
|
+
expect(appWithAddon.ok).toBe(false);
|
|
245
|
+
const addonWithout = checkTemplateRequest(base({ kind: "addon" }), catalog, spec);
|
|
246
|
+
expect(addonWithout.ok).toBe(false);
|
|
247
|
+
});
|
|
248
|
+
});
|
|
249
|
+
|
|
250
|
+
describe("requestBranch", () => {
|
|
251
|
+
test("request/<template-name>/<app>[/<addon>]", () => {
|
|
252
|
+
expect(requestBranch({ kind: "app", template: "acme/bucket/aws", app: "orders" })).toBe("request/bucket/orders");
|
|
253
|
+
expect(requestBranch({ kind: "app", template: "acme/bucket/aws", app: "orders", addon: "cache" })).toBe("request/bucket/orders/cache");
|
|
254
|
+
expect(requestBranch({ kind: "addon", template: "acme/bucket/aws", app: "orders", addon: "cache" })).toBe("request/bucket/orders/cache");
|
|
255
|
+
});
|
|
256
|
+
|
|
257
|
+
test("the template name of an address", () => {
|
|
258
|
+
expect(templateName("registry.example/acme/bucket/aws")).toBe("bucket");
|
|
259
|
+
expect(templateName("acme/bucket")).toBe("bucket");
|
|
260
|
+
expect(templateName("bucket")).toBe("bucket");
|
|
261
|
+
});
|
|
262
|
+
});
|
|
263
|
+
|
|
264
|
+
describe("requestBody", () => {
|
|
265
|
+
const words = resolveProductWords({ product: "terragucci" });
|
|
266
|
+
const request = makeTemplateRequest({
|
|
267
|
+
kind: "app",
|
|
268
|
+
template: "acme/bucket/aws",
|
|
269
|
+
version: "1.0.0",
|
|
270
|
+
app: "orders",
|
|
271
|
+
inputs: { bucket_name: "orders-data", tags: { team: "pay|ments" }, readers: ["svc-a", "svc-b"] },
|
|
272
|
+
requestedBy: "alice",
|
|
273
|
+
claimedBy: "bob",
|
|
274
|
+
via: "mcp",
|
|
275
|
+
});
|
|
276
|
+
|
|
277
|
+
test("matches the golden", async () => {
|
|
278
|
+
await expect(requestBody(request, words)).toMatchFileSnapshot("./__fixtures__/request-body.md");
|
|
279
|
+
});
|
|
280
|
+
|
|
281
|
+
test("names the template, version, every input, the requester, via, and that nothing was applied", () => {
|
|
282
|
+
const body = requestBody(request, words);
|
|
283
|
+
for (const s of ["`acme/bucket/aws`", "`1.0.0`", "`alice`", "an agent over MCP", "| `bucket_name` |", "| `readers` |", "| `tags` |", "Nothing was applied or approved."]) expect(body).toContain(s);
|
|
284
|
+
expect(requestBody(request, resolveProductWords({ product: "plywood", verbs: { plan: ["preview", "previewed"], apply: ["update", "updated"] } }))).toContain("Nothing was updated or approved.");
|
|
285
|
+
});
|
|
286
|
+
|
|
287
|
+
test("the fenced block parses back to the request", () => {
|
|
288
|
+
expect(parseRequestBody(requestBody(request, words))).toEqual(request);
|
|
289
|
+
const addon = base({ kind: "addon", addon: "cache", inputs: { note: "a ```fence``` inside" } });
|
|
290
|
+
const body = requestBody(addon, words);
|
|
291
|
+
expect(body).toContain("add-on `cache` for app `orders`");
|
|
292
|
+
expect(parseRequestBody(body)).toEqual(addon);
|
|
293
|
+
expect(parseRequestBody(body.replace(/\n/g, "\r\n"))).toEqual(addon);
|
|
294
|
+
});
|
|
295
|
+
|
|
296
|
+
test("a claimed requester gets its own row, labelled as claimed, only when set", () => {
|
|
297
|
+
const body = requestBody(request, words);
|
|
298
|
+
expect(body).toContain("| Claimed by (as given by the client; the forge does not vouch for it) | `bob` |");
|
|
299
|
+
expect(parseRequestBody(body)?.claimedBy).toBe("bob");
|
|
300
|
+
const without = base();
|
|
301
|
+
expect(without).not.toHaveProperty("claimedBy");
|
|
302
|
+
const plain = requestBody(without, words);
|
|
303
|
+
expect(plain).not.toContain("Claimed by");
|
|
304
|
+
expect(parseRequestBody(plain)).toEqual(without);
|
|
305
|
+
expect(parseRequestBody(plain)).not.toHaveProperty("claimedBy");
|
|
306
|
+
expect(validateTemplateRequest({ ...without, claimedBy: "" }).length).toBeGreaterThan(0);
|
|
307
|
+
expect(validateTemplateRequest({ ...without, claimedBy: 7 }).length).toBeGreaterThan(0);
|
|
308
|
+
});
|
|
309
|
+
|
|
310
|
+
test("a body without the block, or with a broken one, carries no request", () => {
|
|
311
|
+
expect(parseRequestBody("no request here")).toBeUndefined();
|
|
312
|
+
expect(parseRequestBody(`\`\`\`json ${TEMPLATE_REQUEST_SCHEMA_ID}\n{"x":1}\n\`\`\`\n`)).toBeUndefined();
|
|
313
|
+
expect(parseRequestBody(`\`\`\`json ${TEMPLATE_REQUEST_SCHEMA_ID}\n{not json\n\`\`\`\n`)).toBeUndefined();
|
|
314
|
+
});
|
|
315
|
+
});
|
|
@@ -0,0 +1,234 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* The template request, template-request/v1 (#4651): "an app named orders
|
|
3
|
+
* from template X at version Y with these inputs", as one JSON document.
|
|
4
|
+
* terragucci, plywood and behold all turn one into a pull request, and this
|
|
5
|
+
* module is where they agree on the document, its refusals and its branch.
|
|
6
|
+
* ./request-body.ts writes the pull request body that carries it.
|
|
7
|
+
*
|
|
8
|
+
* {@link checkTemplateRequest} reads the release catalog for the version's
|
|
9
|
+
* status and attestation, and the version's template.yml (./template-spec.ts)
|
|
10
|
+
* for its inputs. It reads no engine field: the inputs' kinds are
|
|
11
|
+
* engine-neutral.
|
|
12
|
+
*/
|
|
13
|
+
|
|
14
|
+
import schema from "./template-request.schema.json" with { type: "json" };
|
|
15
|
+
import { catalogVersion, type AttestationState, type CatalogComponent, type ReleaseCatalog } from "../lifecycle/release-catalog";
|
|
16
|
+
import { inputKindProblem, inputRequired, isAppOutputRef, type TemplateSpec } from "./template-spec";
|
|
17
|
+
import { schemaProblems } from "./validate";
|
|
18
|
+
|
|
19
|
+
/** The first chant that writes and reads template-request/v1 and template.yml/v1 (#4651). */
|
|
20
|
+
export const TEMPLATE_REQUEST_FLOOR = "0.124.58";
|
|
21
|
+
|
|
22
|
+
/** The request document's `$schema`. */
|
|
23
|
+
export const TEMPLATE_REQUEST_SCHEMA_ID: string = schema.$id;
|
|
24
|
+
|
|
25
|
+
/** The request's contract version. */
|
|
26
|
+
export const TEMPLATE_REQUEST_CONTRACT = 1;
|
|
27
|
+
|
|
28
|
+
/** An app or add-on name: a lowercase letter, then up to 39 lowercase letters, digits and -. */
|
|
29
|
+
export const REQUEST_NAME_PATTERN = /^[a-z][a-z0-9-]{0,39}$/;
|
|
30
|
+
|
|
31
|
+
/** Where a request came from. */
|
|
32
|
+
export type TemplateRequestVia = "form" | "mcp" | "cli";
|
|
33
|
+
|
|
34
|
+
/** A template request. */
|
|
35
|
+
export interface TemplateRequest {
|
|
36
|
+
$schema: string;
|
|
37
|
+
contract: 1;
|
|
38
|
+
kind: "app" | "addon";
|
|
39
|
+
/** The template's address, such as `acme/bucket/aws`. */
|
|
40
|
+
template: string;
|
|
41
|
+
/** The version in the catalog, or a digest for a release that names none. */
|
|
42
|
+
version: string;
|
|
43
|
+
app: string;
|
|
44
|
+
/** For kind `addon`: the add-on's name. */
|
|
45
|
+
addon?: string;
|
|
46
|
+
/** The values given, by input name. */
|
|
47
|
+
inputs: Record<string, unknown>;
|
|
48
|
+
/** Who asked, as the forge vouches for it: the login of the run's actor. */
|
|
49
|
+
requestedBy: string;
|
|
50
|
+
/**
|
|
51
|
+
* The person the client says filled the form or asked the agent, when it
|
|
52
|
+
* names one. The forge does not vouch for it; it is shown as claimed.
|
|
53
|
+
*/
|
|
54
|
+
claimedBy?: string;
|
|
55
|
+
via: TemplateRequestVia;
|
|
56
|
+
}
|
|
57
|
+
|
|
58
|
+
/** The fields a caller gives {@link makeTemplateRequest}; `$schema` and `contract` are filled in. */
|
|
59
|
+
export type TemplateRequestInput = Omit<TemplateRequest, "$schema" | "contract">;
|
|
60
|
+
|
|
61
|
+
/**
|
|
62
|
+
* Why a request is refused. `invalid` is a document the schema refuses for
|
|
63
|
+
* a reason no other code names (a missing field, a `via` it does not know).
|
|
64
|
+
*/
|
|
65
|
+
export type TemplateRequestRefusalCode =
|
|
66
|
+
| "unknown-version"
|
|
67
|
+
| "not-active"
|
|
68
|
+
| "unsigned"
|
|
69
|
+
| "unknown-input"
|
|
70
|
+
| "missing-input"
|
|
71
|
+
| "sensitive-input"
|
|
72
|
+
| "input-type"
|
|
73
|
+
| "bad-name"
|
|
74
|
+
| "invalid";
|
|
75
|
+
|
|
76
|
+
/** Every refusal code, in the order {@link checkTemplateRequest} checks them. */
|
|
77
|
+
export const TEMPLATE_REQUEST_REFUSAL_CODES: readonly TemplateRequestRefusalCode[] = [
|
|
78
|
+
"bad-name",
|
|
79
|
+
"invalid",
|
|
80
|
+
"unknown-version",
|
|
81
|
+
"not-active",
|
|
82
|
+
"unsigned",
|
|
83
|
+
"unknown-input",
|
|
84
|
+
"sensitive-input",
|
|
85
|
+
"input-type",
|
|
86
|
+
"missing-input",
|
|
87
|
+
];
|
|
88
|
+
|
|
89
|
+
/** One refusal: its code, the request field it is about, and a sentence naming that field. */
|
|
90
|
+
export interface TemplateRequestRefusal {
|
|
91
|
+
code: TemplateRequestRefusalCode;
|
|
92
|
+
/** `app`, `addon`, `version`, `inputs.<name>`, or the schema path for `invalid`. */
|
|
93
|
+
field: string;
|
|
94
|
+
reason: string;
|
|
95
|
+
}
|
|
96
|
+
|
|
97
|
+
export type TemplateRequestCheck = { ok: true; request: TemplateRequest } | { ok: false; refusals: TemplateRequestRefusal[] };
|
|
98
|
+
|
|
99
|
+
export interface CheckTemplateRequestOptions {
|
|
100
|
+
/**
|
|
101
|
+
* The catalog component the template is. Absent: the component named
|
|
102
|
+
* `request.template`. A product that lists components by path looks the
|
|
103
|
+
* address up itself and passes the name here.
|
|
104
|
+
*/
|
|
105
|
+
component?: string;
|
|
106
|
+
/** The lowest attestation a version may have. Default `signed`; `unsigned` accepts any. */
|
|
107
|
+
require?: AttestationState;
|
|
108
|
+
}
|
|
109
|
+
|
|
110
|
+
const ATTESTATION_RANK: Record<AttestationState, number> = { unsigned: 0, signed: 1, verified: 2 };
|
|
111
|
+
|
|
112
|
+
/** Fill `$schema` and `contract` into a request. */
|
|
113
|
+
export function makeTemplateRequest(input: TemplateRequestInput): TemplateRequest {
|
|
114
|
+
const { kind, template, version, app, addon, inputs, requestedBy, claimedBy, via } = input;
|
|
115
|
+
return {
|
|
116
|
+
$schema: TEMPLATE_REQUEST_SCHEMA_ID,
|
|
117
|
+
contract: TEMPLATE_REQUEST_CONTRACT,
|
|
118
|
+
kind,
|
|
119
|
+
template,
|
|
120
|
+
version,
|
|
121
|
+
app,
|
|
122
|
+
...(addon !== undefined ? { addon } : {}),
|
|
123
|
+
inputs,
|
|
124
|
+
requestedBy,
|
|
125
|
+
...(claimedBy !== undefined ? { claimedBy } : {}),
|
|
126
|
+
via,
|
|
127
|
+
};
|
|
128
|
+
}
|
|
129
|
+
|
|
130
|
+
/** The schema problems of a request document, one line each; empty when it is valid. */
|
|
131
|
+
export function validateTemplateRequest(doc: unknown): string[] {
|
|
132
|
+
return schemaProblems(TEMPLATE_REQUEST_SCHEMA_ID, doc);
|
|
133
|
+
}
|
|
134
|
+
|
|
135
|
+
const isRecord = (v: unknown): v is Record<string, unknown> => typeof v === "object" && v !== null && !Array.isArray(v);
|
|
136
|
+
|
|
137
|
+
/**
|
|
138
|
+
* Check a request against the catalog and the version's template.yml.
|
|
139
|
+
* Returns every refusal, each with its code and a reason naming the field.
|
|
140
|
+
* A bad name or a document the schema refuses stops the check there, and so
|
|
141
|
+
* does a version the catalog does not list; past that, the version's status
|
|
142
|
+
* and attestation and each input are all checked.
|
|
143
|
+
*/
|
|
144
|
+
export function checkTemplateRequest(
|
|
145
|
+
request: unknown,
|
|
146
|
+
catalog: ReleaseCatalog,
|
|
147
|
+
templateSpec: TemplateSpec,
|
|
148
|
+
options: CheckTemplateRequestOptions = {},
|
|
149
|
+
): TemplateRequestCheck {
|
|
150
|
+
const refused = (refusals: TemplateRequestRefusal[]): TemplateRequestCheck => ({ ok: false, refusals });
|
|
151
|
+
|
|
152
|
+
// Names first, so a bad one reads as bad-name and not as a schema pattern.
|
|
153
|
+
const names: TemplateRequestRefusal[] = [];
|
|
154
|
+
const probe: Record<string, unknown> = isRecord(request) ? { ...request } : {};
|
|
155
|
+
for (const field of ["app", "addon"] as const) {
|
|
156
|
+
const v = probe[field];
|
|
157
|
+
if (typeof v !== "string" || REQUEST_NAME_PATTERN.test(v)) continue;
|
|
158
|
+
names.push({
|
|
159
|
+
code: "bad-name",
|
|
160
|
+
field,
|
|
161
|
+
reason: `${field} ${JSON.stringify(v)} is not a name: a lowercase letter, then up to 39 lowercase letters, digits and -`,
|
|
162
|
+
});
|
|
163
|
+
probe[field] = "x";
|
|
164
|
+
}
|
|
165
|
+
if (names.length > 0) return refused(names);
|
|
166
|
+
|
|
167
|
+
const problems = validateTemplateRequest(isRecord(request) ? probe : request);
|
|
168
|
+
if (problems.length > 0) {
|
|
169
|
+
return refused(problems.map((p) => ({ code: "invalid", field: p.split(" ")[0]!, reason: `the request ${p}` })));
|
|
170
|
+
}
|
|
171
|
+
const req = request as TemplateRequest;
|
|
172
|
+
|
|
173
|
+
const componentName = options.component ?? req.template;
|
|
174
|
+
const component: CatalogComponent | undefined = catalog.components.find((c) => c.name === componentName);
|
|
175
|
+
if (!component) {
|
|
176
|
+
return refused([{ code: "unknown-version", field: "version", reason: `version ${JSON.stringify(req.version)}: the catalog lists no template ${JSON.stringify(componentName)}` }]);
|
|
177
|
+
}
|
|
178
|
+
const version = catalogVersion(catalog, component.name, req.version);
|
|
179
|
+
if (!version) {
|
|
180
|
+
const listed = component.versions.map((v) => v.version ?? v.digest).join(", ") || "none";
|
|
181
|
+
return refused([{ code: "unknown-version", field: "version", reason: `version ${JSON.stringify(req.version)} of ${req.template} is not in the catalog (it lists ${listed})` }]);
|
|
182
|
+
}
|
|
183
|
+
|
|
184
|
+
const refusals: TemplateRequestRefusal[] = [];
|
|
185
|
+
if (version.status.state !== "active") {
|
|
186
|
+
const instead = version.status.replacement ? `; use ${version.status.replacement}` : "";
|
|
187
|
+
refusals.push({ code: "not-active", field: "version", reason: `version ${req.version} of ${req.template} is ${version.status.state}${instead}` });
|
|
188
|
+
}
|
|
189
|
+
const require = options.require ?? "signed";
|
|
190
|
+
if (ATTESTATION_RANK[version.attestation.state] < ATTESTATION_RANK[require]) {
|
|
191
|
+
refusals.push({ code: "unsigned", field: "version", reason: `version ${req.version} of ${req.template} is ${version.attestation.state}, and requests need ${require}` });
|
|
192
|
+
}
|
|
193
|
+
|
|
194
|
+
const byName = new Map(templateSpec.inputs.map((i) => [i.name, i]));
|
|
195
|
+
for (const [name, value] of Object.entries(req.inputs)) {
|
|
196
|
+
const field = `inputs.${name}`;
|
|
197
|
+
const input = byName.get(name);
|
|
198
|
+
if (!input) {
|
|
199
|
+
refusals.push({ code: "unknown-input", field, reason: `${field}: ${req.template} ${req.version} has no input ${JSON.stringify(name)}` });
|
|
200
|
+
continue;
|
|
201
|
+
}
|
|
202
|
+
if (input.sensitive) {
|
|
203
|
+
refusals.push({ code: "sensitive-input", field, reason: `${field} is sensitive, and a request is written into a pull request; the app reads it from its secret store` });
|
|
204
|
+
continue;
|
|
205
|
+
}
|
|
206
|
+
// An add-on's `app.<output>` names the app module's output; the renderer resolves it.
|
|
207
|
+
if (req.addon !== undefined && isAppOutputRef(value)) continue;
|
|
208
|
+
const p = inputKindProblem(input, value);
|
|
209
|
+
if (!p) continue;
|
|
210
|
+
const why = isAppOutputRef(value) ? `; ${JSON.stringify(value)} reads as an app output, and only an add-on request can name one` : "";
|
|
211
|
+
refusals.push({ code: "input-type", field, reason: `${field} ${p}${why}` });
|
|
212
|
+
}
|
|
213
|
+
for (const input of templateSpec.inputs) {
|
|
214
|
+
if (input.sensitive || !inputRequired(input) || input.name in req.inputs) continue;
|
|
215
|
+
refusals.push({ code: "missing-input", field: `inputs.${input.name}`, reason: `inputs.${input.name} is required by ${req.template} ${req.version} and the request gives none` });
|
|
216
|
+
}
|
|
217
|
+
|
|
218
|
+
return refusals.length > 0 ? refused(refusals) : { ok: true, request: req };
|
|
219
|
+
}
|
|
220
|
+
|
|
221
|
+
/**
|
|
222
|
+
* A template's name as a branch uses it: the second-to-last segment of an
|
|
223
|
+
* address with three or more (`acme/bucket/aws` is `bucket`), else the last.
|
|
224
|
+
*/
|
|
225
|
+
export function templateName(template: string): string {
|
|
226
|
+
const parts = template.split("/").filter(Boolean);
|
|
227
|
+
return (parts.length >= 3 ? parts[parts.length - 2] : parts[parts.length - 1]) ?? template;
|
|
228
|
+
}
|
|
229
|
+
|
|
230
|
+
/** The request's branch: `request/<template-name>/<app>`, and `/<addon>` after it for an add-on. */
|
|
231
|
+
export function requestBranch(request: Pick<TemplateRequest, "template" | "app"> & Partial<Pick<TemplateRequest, "kind" | "addon">>): string {
|
|
232
|
+
const base = `request/${templateName(request.template)}/${request.app}`;
|
|
233
|
+
return request.addon !== undefined ? `${base}/${request.addon}` : base;
|
|
234
|
+
}
|