@reventlessdev/reventless-core 3.0.0-alpha.317 → 3.0.0-alpha.319
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/CHANGELOG.md +26 -0
- package/package.json +5 -5
- package/tests/pii/PiiInstallTest.res +121 -0
- package/tests/pii/PiiInstallTest.res.mjs +173 -0
package/CHANGELOG.md
CHANGED
|
@@ -3,6 +3,32 @@
|
|
|
3
3
|
All notable changes to this project will be documented in this file.
|
|
4
4
|
See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
|
|
5
5
|
|
|
6
|
+
# 3.0.0-alpha.319 (2026-10-30)
|
|
7
|
+
|
|
8
|
+
### Features
|
|
9
|
+
|
|
10
|
+
* **pii:** a provider can be installed while it is built, and a deployment can require one ([3ce346f](https://github.com/ReventlessDev/reventless-core/commit/3ce346f66063af9221800278595abcfb7bf95884))
|
|
11
|
+
|
|
12
|
+
|
|
13
|
+
# 3.0.0-alpha.318 (2026-10-29)
|
|
14
|
+
|
|
15
|
+
* feat(core)!: every reader opens a sealed field, with the keys its batch prepared ([d4ac204](https://github.com/ReventlessDev/reventless-core/commit/d4ac204c307d34617d4e32c556030b44bb55b178))
|
|
16
|
+
### Features
|
|
17
|
+
|
|
18
|
+
* **aws:** every reader's Lambda fetches the keys its events name before decoding ([62b22c7](https://github.com/ReventlessDev/reventless-core/commit/62b22c74ba6e79783c67db962e43f86c273f4503))
|
|
19
|
+
|
|
20
|
+
### BREAKING CHANGES
|
|
21
|
+
|
|
22
|
+
* `Pii.provider` has `prefetch` and `openNow` in place of `open_`.
|
|
23
|
+
|
|
24
|
+
Not yet: `prepare` in the AWS entry points, the conformance scenario, the runs on
|
|
25
|
+
DynamoDB and Postgres.
|
|
26
|
+
|
|
27
|
+
Begins step PD10 of docs/plans/a-personal-field-is-marked-redacted-and-encrypted-at-the-seam.md.
|
|
28
|
+
Claude-Session: https://claude.ai/code/session_01HiQfdxVEsHwLHRoHSUcus1
|
|
29
|
+
|
|
30
|
+
|
|
31
|
+
|
|
6
32
|
# 3.0.0-alpha.317 (2026-10-29)
|
|
7
33
|
|
|
8
34
|
* feat(core)!: every reader opens a sealed field, with the keys its batch prepared ([d4ac204](https://github.com/ReventlessDev/reventless-core/commit/d4ac204c307d34617d4e32c556030b44bb55b178))
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@reventlessdev/reventless-core",
|
|
3
|
-
"version": "3.0.0-alpha.
|
|
3
|
+
"version": "3.0.0-alpha.319",
|
|
4
4
|
"description": "Core package for Reventless framework",
|
|
5
5
|
"license": "Apache-2.0",
|
|
6
6
|
"jest": {
|
|
@@ -33,17 +33,17 @@
|
|
|
33
33
|
"@reventlessdev/rescript-hash-object": "1.2.0-alpha.15",
|
|
34
34
|
"@reventlessdev/rescript-node": "2.0.0-alpha.24",
|
|
35
35
|
"@reventlessdev/rescript-jest": "1.0.0-alpha.13",
|
|
36
|
-
"@reventlessdev/rescript-ssh2": "2.0.0-alpha.25",
|
|
37
36
|
"@reventlessdev/rescript-pulumi-pulumi": "3.0.0-alpha.0",
|
|
38
|
-
"@reventlessdev/
|
|
37
|
+
"@reventlessdev/rescript-ssh2": "2.0.0-alpha.25",
|
|
38
|
+
"@reventlessdev/reventless-infra": "3.0.0-alpha.216",
|
|
39
39
|
"@reventlessdev/rescript-uuid": "2.0.0-alpha.1",
|
|
40
40
|
"@reventlessdev/reventless-interop": "3.0.0-alpha.42",
|
|
41
|
-
"@reventlessdev/reventless-spec": "3.0.0-alpha.
|
|
41
|
+
"@reventlessdev/reventless-spec": "3.0.0-alpha.187"
|
|
42
42
|
},
|
|
43
43
|
"devDependencies": {
|
|
44
44
|
"rescript": "12.3.1",
|
|
45
45
|
"sury-ppx": "11.0.0",
|
|
46
|
-
"@reventlessdev/reventless-ppx": "1.0.0-alpha.
|
|
46
|
+
"@reventlessdev/reventless-ppx": "1.0.0-alpha.109"
|
|
47
47
|
},
|
|
48
48
|
"peerDependencies": {
|
|
49
49
|
"rescript": "^12.3.1"
|
|
@@ -0,0 +1,121 @@
|
|
|
1
|
+
// A provider installed while it is still being built is waited for, a failed one
|
|
2
|
+
// refuses, and a deployment that requires encryption never stores a marked field
|
|
3
|
+
// as it is.
|
|
4
|
+
|
|
5
|
+
open JestGlobals
|
|
6
|
+
|
|
7
|
+
module Spec = {
|
|
8
|
+
@schema
|
|
9
|
+
type event =
|
|
10
|
+
| MemberNamed({
|
|
11
|
+
memberId: string,
|
|
12
|
+
name: @s.matches(Reventless.Pii.marked(~subject="memberId", S.string))
|
|
13
|
+
Reventless.Pii.t<string>,
|
|
14
|
+
})
|
|
15
|
+
| MemberLeft({memberId: string})
|
|
16
|
+
}
|
|
17
|
+
|
|
18
|
+
let sealing: Reventless.Pii.provider = {
|
|
19
|
+
...Reventless.Pii.plain,
|
|
20
|
+
name: "sealing",
|
|
21
|
+
encrypts: true,
|
|
22
|
+
seal: async (~subject, ~field as _, ~forgettable as _, _json) => Ok(
|
|
23
|
+
Reventless.Pii.wrap(`enc:v1:${subject}:fake:AAAA`),
|
|
24
|
+
),
|
|
25
|
+
}
|
|
26
|
+
|
|
27
|
+
let named = () =>
|
|
28
|
+
Dict.fromArray([("memberId", JSON.Encode.string("m-1")), ("name", JSON.Encode.string("Ada"))])
|
|
29
|
+
|
|
30
|
+
let seal = data => Reventless.Pii.sealData(Spec.eventSchema, ~eventType="MemberNamed", data)
|
|
31
|
+
|
|
32
|
+
@val external env: dict<string> = "process.env"
|
|
33
|
+
let variable = "REVENTLESS_PII_REQUIRE_ENCRYPTION"
|
|
34
|
+
|
|
35
|
+
describe("Pii.Provider.installWhen", () => {
|
|
36
|
+
afterEach(() => {
|
|
37
|
+
Reventless.Pii.Provider.install(Reventless.Pii.plain)
|
|
38
|
+
env->Dict.delete(variable)
|
|
39
|
+
})
|
|
40
|
+
|
|
41
|
+
test("a write waits for a provider still being built, then seals with it", async () => {
|
|
42
|
+
let (building, finish) = {
|
|
43
|
+
let finish = ref(_ => ())
|
|
44
|
+
let p = Promise.make((resolve, _) => finish := resolve)
|
|
45
|
+
(p, finish)
|
|
46
|
+
}
|
|
47
|
+
Reventless.Pii.Provider.installWhen(building)
|
|
48
|
+
let sealed = seal(named())
|
|
49
|
+
finish.contents(Ok(sealing))
|
|
50
|
+
switch await sealed {
|
|
51
|
+
| Ok(data) =>
|
|
52
|
+
expect(data->Dict.get("name")->Option.flatMap(Reventless.Pii.unwrap))->toEqual(
|
|
53
|
+
Some("enc:v1:m-1:fake:AAAA"),
|
|
54
|
+
)
|
|
55
|
+
| Error(e) => JsError.throwWithMessage(e->Reventless.Pii.errorMessage)
|
|
56
|
+
}
|
|
57
|
+
})
|
|
58
|
+
|
|
59
|
+
test("a failed install refuses the write with its reason", async () => {
|
|
60
|
+
Reventless.Pii.Provider.installWhen(Promise.resolve(Error("KMS is unreachable")))
|
|
61
|
+
switch await seal(named()) {
|
|
62
|
+
| Ok(_) => JsError.throwWithMessage("expected a refusal")
|
|
63
|
+
| Error(e) =>
|
|
64
|
+
expect(e->Reventless.Pii.errorMessage->String.includes("KMS is unreachable"))->toBe(true)
|
|
65
|
+
}
|
|
66
|
+
})
|
|
67
|
+
|
|
68
|
+
test("a failed install refuses a batch that needs keys", async () => {
|
|
69
|
+
Reventless.Pii.Provider.installWhen(Promise.resolve(Error("KMS is unreachable")))
|
|
70
|
+
let batch = [Reventless.Pii.wrap("enc:v1:k-1:A256GCM:AAAA")]
|
|
71
|
+
expect((await Reventless.Pii.prepare(batch))->Result.isError)->toBe(true)
|
|
72
|
+
})
|
|
73
|
+
|
|
74
|
+
test("a later install replaces one still in flight", async () => {
|
|
75
|
+
let (building, finish) = {
|
|
76
|
+
let finish = ref(_ => ())
|
|
77
|
+
let p = Promise.make((resolve, _) => finish := resolve)
|
|
78
|
+
(p, finish)
|
|
79
|
+
}
|
|
80
|
+
Reventless.Pii.Provider.installWhen(building)
|
|
81
|
+
Reventless.Pii.Provider.install(sealing)
|
|
82
|
+
finish.contents(Error("too late"))
|
|
83
|
+
await Promise.resolve()
|
|
84
|
+
expect((await seal(named()))->Result.isOk)->toBe(true)
|
|
85
|
+
expect(Reventless.Pii.Provider.get().name)->toBe("sealing")
|
|
86
|
+
})
|
|
87
|
+
|
|
88
|
+
test("a type without personal fields does not wait", async () => {
|
|
89
|
+
Reventless.Pii.Provider.installWhen(Promise.make((_, _) => ()))
|
|
90
|
+
let data = Dict.fromArray([("memberId", JSON.Encode.string("m-1"))])
|
|
91
|
+
expect(await Reventless.Pii.sealData(Spec.eventSchema, ~eventType="MemberLeft", data))->toEqual(
|
|
92
|
+
Ok(data),
|
|
93
|
+
)
|
|
94
|
+
})
|
|
95
|
+
})
|
|
96
|
+
|
|
97
|
+
describe("REVENTLESS_PII_REQUIRE_ENCRYPTION", () => {
|
|
98
|
+
afterEach(() => {
|
|
99
|
+
Reventless.Pii.Provider.install(Reventless.Pii.plain)
|
|
100
|
+
env->Dict.delete(variable)
|
|
101
|
+
})
|
|
102
|
+
|
|
103
|
+
test("refuses a marked field when no encrypting provider is installed", async () => {
|
|
104
|
+
env->Dict.set(variable, "true")
|
|
105
|
+
switch await seal(named()) {
|
|
106
|
+
| Ok(_) => JsError.throwWithMessage("expected a refusal")
|
|
107
|
+
| Error(e) =>
|
|
108
|
+
expect(e->Reventless.Pii.errorMessage->String.includes("requires an encrypting"))->toBe(true)
|
|
109
|
+
}
|
|
110
|
+
})
|
|
111
|
+
|
|
112
|
+
test("seals when an encrypting provider is installed", async () => {
|
|
113
|
+
env->Dict.set(variable, "true")
|
|
114
|
+
Reventless.Pii.Provider.install(sealing)
|
|
115
|
+
expect((await seal(named()))->Result.isOk)->toBe(true)
|
|
116
|
+
})
|
|
117
|
+
|
|
118
|
+
test("leaves a deployment that does not require it storing as it is", async () => {
|
|
119
|
+
expect(await seal(named()))->toEqual(Ok(named()))
|
|
120
|
+
})
|
|
121
|
+
})
|
|
@@ -0,0 +1,173 @@
|
|
|
1
|
+
// Generated by ReScript, PLEASE EDIT WITH CARE
|
|
2
|
+
|
|
3
|
+
import * as Sury from "sury";
|
|
4
|
+
import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
|
|
5
|
+
import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
|
|
6
|
+
import * as Stdlib_Result from "@rescript/runtime/lib/es6/Stdlib_Result.js";
|
|
7
|
+
import * as Pii$Reventless from "@reventlessdev/reventless-spec/src/components/Pii.res.mjs";
|
|
8
|
+
import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
|
|
9
|
+
|
|
10
|
+
let eventSchema = Sury.union([
|
|
11
|
+
Sury.$schema(s => ({
|
|
12
|
+
TAG: "MemberNamed",
|
|
13
|
+
memberId: s.m(Sury.string),
|
|
14
|
+
name: s.m(Pii$Reventless.marked("memberId", undefined, Sury.string))
|
|
15
|
+
})),
|
|
16
|
+
Sury.$schema(s => ({
|
|
17
|
+
TAG: "MemberLeft",
|
|
18
|
+
memberId: s.m(Sury.string)
|
|
19
|
+
}))
|
|
20
|
+
]);
|
|
21
|
+
|
|
22
|
+
let Spec = {
|
|
23
|
+
eventSchema: eventSchema
|
|
24
|
+
};
|
|
25
|
+
|
|
26
|
+
async function sealing_seal(subject, param, param$1, _json) {
|
|
27
|
+
return {
|
|
28
|
+
TAG: "Ok",
|
|
29
|
+
_0: Pii$Reventless.wrap(`enc:v1:` + subject + `:fake:AAAA`)
|
|
30
|
+
};
|
|
31
|
+
}
|
|
32
|
+
|
|
33
|
+
let sealing_prefetch = Pii$Reventless.plain.prefetch;
|
|
34
|
+
|
|
35
|
+
let sealing_openNow = Pii$Reventless.plain.openNow;
|
|
36
|
+
|
|
37
|
+
let sealing_release = Pii$Reventless.plain.release;
|
|
38
|
+
|
|
39
|
+
let sealing = {
|
|
40
|
+
name: "sealing",
|
|
41
|
+
encrypts: true,
|
|
42
|
+
seal: sealing_seal,
|
|
43
|
+
prefetch: sealing_prefetch,
|
|
44
|
+
openNow: sealing_openNow,
|
|
45
|
+
release: sealing_release
|
|
46
|
+
};
|
|
47
|
+
|
|
48
|
+
function named() {
|
|
49
|
+
return Object.fromEntries([
|
|
50
|
+
[
|
|
51
|
+
"memberId",
|
|
52
|
+
"m-1"
|
|
53
|
+
],
|
|
54
|
+
[
|
|
55
|
+
"name",
|
|
56
|
+
"Ada"
|
|
57
|
+
]
|
|
58
|
+
]);
|
|
59
|
+
}
|
|
60
|
+
|
|
61
|
+
function seal(data) {
|
|
62
|
+
return Pii$Reventless.sealData(eventSchema, "MemberNamed", data);
|
|
63
|
+
}
|
|
64
|
+
|
|
65
|
+
let variable = "REVENTLESS_PII_REQUIRE_ENCRYPTION";
|
|
66
|
+
|
|
67
|
+
globalThis.describe("Pii.Provider.installWhen", () => {
|
|
68
|
+
globalThis.afterEach(() => {
|
|
69
|
+
Pii$Reventless.Provider.install(Pii$Reventless.plain);
|
|
70
|
+
Stdlib_Dict.$$delete(process.env, variable);
|
|
71
|
+
});
|
|
72
|
+
globalThis.test("a write waits for a provider still being built, then seals with it", async () => {
|
|
73
|
+
let finish = {
|
|
74
|
+
contents: param => {}
|
|
75
|
+
};
|
|
76
|
+
let p = new Promise((resolve, param) => {
|
|
77
|
+
finish.contents = resolve;
|
|
78
|
+
});
|
|
79
|
+
Pii$Reventless.Provider.installWhen(p);
|
|
80
|
+
let sealed = seal(named());
|
|
81
|
+
finish.contents({
|
|
82
|
+
TAG: "Ok",
|
|
83
|
+
_0: sealing
|
|
84
|
+
});
|
|
85
|
+
let data = await sealed;
|
|
86
|
+
if (data.TAG !== "Ok") {
|
|
87
|
+
return Stdlib_JsError.throwWithMessage(Pii$Reventless.errorMessage(data._0));
|
|
88
|
+
}
|
|
89
|
+
globalThis.expect(Stdlib_Option.flatMap(data._0["name"], Pii$Reventless.unwrap)).toEqual("enc:v1:m-1:fake:AAAA");
|
|
90
|
+
});
|
|
91
|
+
globalThis.test("a failed install refuses the write with its reason", async () => {
|
|
92
|
+
Pii$Reventless.Provider.installWhen(Promise.resolve({
|
|
93
|
+
TAG: "Error",
|
|
94
|
+
_0: "KMS is unreachable"
|
|
95
|
+
}));
|
|
96
|
+
let e = await seal(named());
|
|
97
|
+
if (e.TAG === "Ok") {
|
|
98
|
+
return Stdlib_JsError.throwWithMessage("expected a refusal");
|
|
99
|
+
}
|
|
100
|
+
globalThis.expect(Pii$Reventless.errorMessage(e._0).includes("KMS is unreachable")).toBe(true);
|
|
101
|
+
});
|
|
102
|
+
globalThis.test("a failed install refuses a batch that needs keys", async () => {
|
|
103
|
+
Pii$Reventless.Provider.installWhen(Promise.resolve({
|
|
104
|
+
TAG: "Error",
|
|
105
|
+
_0: "KMS is unreachable"
|
|
106
|
+
}));
|
|
107
|
+
let batch = [Pii$Reventless.wrap("enc:v1:k-1:A256GCM:AAAA")];
|
|
108
|
+
globalThis.expect(Stdlib_Result.isError(await Pii$Reventless.prepare(batch))).toBe(true);
|
|
109
|
+
});
|
|
110
|
+
globalThis.test("a later install replaces one still in flight", async () => {
|
|
111
|
+
let finish = {
|
|
112
|
+
contents: param => {}
|
|
113
|
+
};
|
|
114
|
+
let p = new Promise((resolve, param) => {
|
|
115
|
+
finish.contents = resolve;
|
|
116
|
+
});
|
|
117
|
+
Pii$Reventless.Provider.installWhen(p);
|
|
118
|
+
Pii$Reventless.Provider.install(sealing);
|
|
119
|
+
finish.contents({
|
|
120
|
+
TAG: "Error",
|
|
121
|
+
_0: "too late"
|
|
122
|
+
});
|
|
123
|
+
await Promise.resolve();
|
|
124
|
+
globalThis.expect(Stdlib_Result.isOk(await seal(named()))).toBe(true);
|
|
125
|
+
globalThis.expect(Pii$Reventless.Provider.get().name).toBe("sealing");
|
|
126
|
+
});
|
|
127
|
+
globalThis.test("a type without personal fields does not wait", async () => {
|
|
128
|
+
Pii$Reventless.Provider.installWhen(new Promise((param, param$1) => {}));
|
|
129
|
+
let data = Object.fromEntries([[
|
|
130
|
+
"memberId",
|
|
131
|
+
"m-1"
|
|
132
|
+
]]);
|
|
133
|
+
globalThis.expect(await Pii$Reventless.sealData(eventSchema, "MemberLeft", data)).toEqual({
|
|
134
|
+
TAG: "Ok",
|
|
135
|
+
_0: data
|
|
136
|
+
});
|
|
137
|
+
});
|
|
138
|
+
});
|
|
139
|
+
|
|
140
|
+
globalThis.describe("REVENTLESS_PII_REQUIRE_ENCRYPTION", () => {
|
|
141
|
+
globalThis.afterEach(() => {
|
|
142
|
+
Pii$Reventless.Provider.install(Pii$Reventless.plain);
|
|
143
|
+
Stdlib_Dict.$$delete(process.env, variable);
|
|
144
|
+
});
|
|
145
|
+
globalThis.test("refuses a marked field when no encrypting provider is installed", async () => {
|
|
146
|
+
process.env[variable] = "true";
|
|
147
|
+
let e = await seal(named());
|
|
148
|
+
if (e.TAG === "Ok") {
|
|
149
|
+
return Stdlib_JsError.throwWithMessage("expected a refusal");
|
|
150
|
+
}
|
|
151
|
+
globalThis.expect(Pii$Reventless.errorMessage(e._0).includes("requires an encrypting")).toBe(true);
|
|
152
|
+
});
|
|
153
|
+
globalThis.test("seals when an encrypting provider is installed", async () => {
|
|
154
|
+
process.env[variable] = "true";
|
|
155
|
+
Pii$Reventless.Provider.install(sealing);
|
|
156
|
+
globalThis.expect(Stdlib_Result.isOk(await seal(named()))).toBe(true);
|
|
157
|
+
});
|
|
158
|
+
globalThis.test("leaves a deployment that does not require it storing as it is", async () => {
|
|
159
|
+
globalThis.expect(await seal(named())).toEqual({
|
|
160
|
+
TAG: "Ok",
|
|
161
|
+
_0: named()
|
|
162
|
+
});
|
|
163
|
+
});
|
|
164
|
+
});
|
|
165
|
+
|
|
166
|
+
export {
|
|
167
|
+
Spec,
|
|
168
|
+
sealing,
|
|
169
|
+
named,
|
|
170
|
+
seal,
|
|
171
|
+
variable,
|
|
172
|
+
}
|
|
173
|
+
/* eventSchema Not a pure module */
|