eventsourcingdb-merkle 4.0.6 → 4.0.8
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/README.md +7 -276
- package/package.json +4 -4
package/README.md
CHANGED
|
@@ -1,10 +1,8 @@
|
|
|
1
1
|
# eventsourcingdb-merkle
|
|
2
2
|
|
|
3
|
-
Merkle tree utilities for [EventSourcingDB](https://www.
|
|
3
|
+
Merkle tree utilities for [EventSourcingDB](https://www.eventfoundation.io/products/eventsourcingdb): a command line tool that validates the chain of hashes of your events, calculates a Merkle root as their fingerprint, and generates and verifies Merkle proofs, which prove a single event to others without handing over any other event.
|
|
4
4
|
|
|
5
|
-
|
|
6
|
-
|
|
7
|
-
For more information on EventSourcingDB, see its [official documentation](https://docs.eventsourcingdb.io/).
|
|
5
|
+
The complete documentation of this tool, including reading from a running database, roots of earlier states, salted leaves, earlier versions of the tree, and the technical details, is available at **[https://www.eventfoundation.io/docs/eventsourcingdb/merkle-cli](https://www.eventfoundation.io/docs/eventsourcingdb/merkle-cli)**.
|
|
8
6
|
|
|
9
7
|
## Getting Started
|
|
10
8
|
|
|
@@ -20,293 +18,26 @@ Or use it directly with `npx` without installing:
|
|
|
20
18
|
npx eventsourcingdb-merkle [COMMAND]
|
|
21
19
|
```
|
|
22
20
|
|
|
23
|
-
|
|
24
|
-
|
|
25
|
-
Every command that reads events reads them either from a backup file, which you name with `--backup`, or from a running EventSourcingDB, which you name with `--esdb-url` and its API token with `--esdb-api-token`:
|
|
21
|
+
Validate the chain of hashes in a backup:
|
|
26
22
|
|
|
27
23
|
```shell
|
|
28
24
|
eventsourcingdb-merkle validate-chain --backup=backup.json
|
|
29
|
-
eventsourcingdb-merkle validate-chain --esdb-url=http://localhost:3000 --esdb-api-token="$ESDB_API_TOKEN"
|
|
30
|
-
```
|
|
31
|
-
|
|
32
|
-
A backup freezes the events it holds, and it can be handed on to someone who should verify it. A running database needs no backup first. Note that EventSourcingDB has no API token that only reads, so whoever reads a running database holds a token that could write as well. Passing the token from a variable, as above, keeps it out of the history of your shell.
|
|
33
|
-
|
|
34
|
-
The tool reads a running database through the client SDK of EventSourcingDB, which uses the v2 API where the server offers it, from release 1.3 on. There, a read that is cut short fails rather than passing as complete. A server before release 1.3 offers only the v1 API, where the two cannot be told apart. The SDK verifies the hash of each event itself, so where one does not match, the tool names the stored hash, but not the one the SDK calculated.
|
|
35
|
-
|
|
36
|
-
### Validating Event Chains
|
|
37
|
-
|
|
38
|
-
To ensure that a backup file has not been tampered with or corrupted, call the `validate-chain` command and name the backup file or the database, as described above. The command verifies that each event's hash is correctly calculated, that the predecessor hash of each event matches the hash of the previous event, and that the first event has a null predecessor hash as expected:
|
|
39
|
-
|
|
40
|
-
```shell
|
|
41
|
-
eventsourcingdb-merkle validate-chain --backup=backup.json
|
|
42
|
-
```
|
|
43
|
-
|
|
44
|
-
If the chain is valid, you will see a confirmation message with the total number of events:
|
|
45
|
-
|
|
46
|
-
```
|
|
47
|
-
✓ Chain is valid (8220 events)
|
|
48
|
-
```
|
|
49
|
-
|
|
50
|
-
If the chain is invalid, the command lists all errors found:
|
|
51
|
-
|
|
52
25
|
```
|
|
53
|
-
✗ Chain validation failed
|
|
54
|
-
Total events: 8220
|
|
55
|
-
Errors found: 2
|
|
56
26
|
|
|
57
|
-
|
|
58
|
-
Event 43: Predecessor hash mismatch: expected def..., got ghi...
|
|
59
|
-
```
|
|
60
|
-
|
|
61
|
-
An event whose hash names a version of the hash that the tool does not know is listed as such, rather than as a mismatch:
|
|
62
|
-
|
|
63
|
-
```
|
|
64
|
-
Event 44: Unsupported hash version: v3
|
|
65
|
-
```
|
|
66
|
-
|
|
67
|
-
Such an event cannot be verified, which is not the same as being tampered with, and a newer version of the tool may know its version.
|
|
68
|
-
|
|
69
|
-
*Note that the command will exit with a non-zero exit code if the chain is invalid, which makes it suitable for use in CI/CD pipelines.*
|
|
70
|
-
|
|
71
|
-
### Calculating the Merkle Root
|
|
72
|
-
|
|
73
|
-
To calculate the Merkle root for all events in a backup file, call the `merkle-root` command and name the backup file or the database. The Merkle root is a single hash that represents the entire event chain and can be used to verify the integrity of the backup:
|
|
27
|
+
Calculate its Merkle root:
|
|
74
28
|
|
|
75
29
|
```shell
|
|
76
30
|
eventsourcingdb-merkle merkle-root --backup=backup.json
|
|
77
31
|
```
|
|
78
32
|
|
|
79
|
-
|
|
80
|
-
|
|
81
|
-
```
|
|
82
|
-
Merkle Root: esdb:merkle:v3:6a0e4b2f9d1c...
|
|
83
|
-
Total events: 4
|
|
84
|
-
Last event ID: 3
|
|
85
|
-
```
|
|
86
|
-
|
|
87
|
-
The root covers the number of events as well, so that a proof against it can name the position of its event, as described under [Verifying Merkle Proofs](#verifying-merkle-proofs).
|
|
88
|
-
|
|
89
|
-
#### Calculating the Merkle Root of an Earlier State
|
|
90
|
-
|
|
91
|
-
A root that you published once has to be calculated again later, for instance to generate proofs against it. Since events are never changed, a newer backup, or the database itself, holds the events of an older backup, followed by those written since. Pass the last event ID that the root covered with `--last-event-id`, and the command calculates the root over the events up to it, which is the root of the older backup:
|
|
92
|
-
|
|
93
|
-
```shell
|
|
94
|
-
eventsourcingdb-merkle merkle-root --backup=backup-2025.json --last-event-id=3
|
|
95
|
-
```
|
|
96
|
-
|
|
97
|
-
So you do not have to keep the older backup to prove against its root. If the backup or the database holds no event with that ID, the command refuses rather than calculating a root over other events.
|
|
98
|
-
|
|
99
|
-
#### Salting the Leaves
|
|
100
|
-
|
|
101
|
-
A proof names the hashes next to the path from its event to the root, and the first of them belongs to a neighboring event. That hash does not reveal the event, but whoever holds the proof and has a guess about the neighbor, such as its type, its subject, its time, and its data, can calculate its hash and so check the guess. Where your events can be guessed like that, salt the leaves of the tree: a random value in front of every leaf, which only a proof of that leaf discloses, makes the other hashes in a proof tell nothing.
|
|
102
|
-
|
|
103
|
-
The tool derives the salt of every leaf from a key, so that no salt has to be kept. Generate the key once, and pass it with `--salt-key-file` whenever you calculate the root, or a proof against it:
|
|
104
|
-
|
|
105
|
-
```shell
|
|
106
|
-
eventsourcingdb-merkle generate-salt-key --output=merkle.key
|
|
107
|
-
eventsourcingdb-merkle merkle-root --backup=backup.json --salt-key-file=merkle.key
|
|
108
|
-
```
|
|
109
|
-
|
|
110
|
-
The key file holds 64 hexadecimal digits. `generate-salt-key` never overwrites a file, and it lets nobody write the key, and on Linux and macOS, only the owner of the file read it. Windows knows only whether a file is read-only, so there, who can read the key follows from the permissions of its folder. Keep the key as long as the root, and as safely as a password: a root calculated with it is calculated again with that key only, so without it, no further proof can be generated for the root, and whoever has it can calculate the salt of every leaf. A proof carries the salt of its own leaf, so verifying it needs no key.
|
|
111
|
-
|
|
112
|
-
#### Calculating a Root of an Earlier Version
|
|
113
|
-
|
|
114
|
-
Releases before 4.0 built the tree in other ways. Release 3.0 built version 2 of the tree, which has the leaves and inner nodes of version 3, but a root that does not cover the number of events, and proofs that follow the sides of their siblings, so that they do not bind the ID of their event. Releases before 3.0 built version 1, which hashes leaves and inner nodes alike, and pairs the last node of a level with itself where it has no partner, so that a list of hashes has the same root as the same list with its last hash twice. A root of version 3 starts with `esdb:merkle:v3:`, a root of version 2 with `esdb:merkle:v2:`, and a root of version 1 has no prefix. Version 1 knows no salts. To calculate a root of an earlier version again, or to prove an event against one, pass `--tree-version=1` or `--tree-version=2`:
|
|
115
|
-
|
|
116
|
-
```shell
|
|
117
|
-
eventsourcingdb-merkle merkle-root --backup=backup.json --tree-version=2
|
|
118
|
-
```
|
|
119
|
-
|
|
120
|
-
### Validating Individual Events
|
|
121
|
-
|
|
122
|
-
Sometimes you want to verify the integrity of a single event without processing the entire backup. The `validate-event-hash` command provides two ways to do this.
|
|
123
|
-
|
|
124
|
-
#### Validating an Event from a Backup File or a Database
|
|
125
|
-
|
|
126
|
-
To validate an event by its ID from a backup file or a database, call the `validate-event-hash` command with `--event-id` and the source:
|
|
127
|
-
|
|
128
|
-
```shell
|
|
129
|
-
eventsourcingdb-merkle validate-event-hash --backup=backup.json --event-id=42
|
|
130
|
-
```
|
|
131
|
-
|
|
132
|
-
If the hash is valid, you will see a confirmation message:
|
|
133
|
-
|
|
134
|
-
```
|
|
135
|
-
✓ Hash is valid
|
|
136
|
-
Event ID: 42
|
|
137
|
-
Hash: abc123...
|
|
138
|
-
```
|
|
139
|
-
|
|
140
|
-
If the hash does not match, the command shows both the stored and calculated hashes:
|
|
141
|
-
|
|
142
|
-
```
|
|
143
|
-
✗ Hash mismatch
|
|
144
|
-
Event ID: 42
|
|
145
|
-
Stored hash: abc123...
|
|
146
|
-
Calculated hash: def456...
|
|
147
|
-
```
|
|
148
|
-
|
|
149
|
-
Read from a database, the client SDK verifies the hash and keeps the hash it calculated to itself, so the command shows the stored hash only:
|
|
150
|
-
|
|
151
|
-
```
|
|
152
|
-
✗ Hash mismatch
|
|
153
|
-
Event ID: 42
|
|
154
|
-
Stored hash: abc123...
|
|
155
|
-
```
|
|
156
|
-
|
|
157
|
-
#### Validating an Event from JSON
|
|
158
|
-
|
|
159
|
-
You can also validate an event provided as a JSON string. This is useful when you receive an event from an external source and want to verify its hash without having access to the backup file. The command takes a line of a backup, a line of `read-events`, or an event on its own, with its hash:
|
|
160
|
-
|
|
161
|
-
```shell
|
|
162
|
-
eventsourcingdb-merkle validate-event-hash --event='{"specversion":"1.0","id":"0",...,"hash":"esdb:hash:v2:..."}'
|
|
163
|
-
```
|
|
164
|
-
|
|
165
|
-
If you provide a CloudEvent without a stored hash, the command simply calculates and displays the hash in every version, since nothing tells which version is meant:
|
|
166
|
-
|
|
167
|
-
```
|
|
168
|
-
Calculated hash (version 1): abc123...
|
|
169
|
-
Calculated hash (version 2): esdb:hash:v2:def456...
|
|
170
|
-
```
|
|
171
|
-
|
|
172
|
-
### Generating Merkle Proofs
|
|
173
|
-
|
|
174
|
-
A Merkle proof allows you to prove that a specific event is part of a backup without revealing the entire backup. To generate a proof for an event, call the `get-proof` command with the source and the event ID in `--event-id`:
|
|
175
|
-
|
|
176
|
-
```shell
|
|
177
|
-
eventsourcingdb-merkle get-proof --backup=backup.json --event-id=42
|
|
178
|
-
```
|
|
179
|
-
|
|
180
|
-
The command outputs the proof in a human-readable format:
|
|
181
|
-
|
|
182
|
-
```
|
|
183
|
-
Merkle Proof for Event 42
|
|
184
|
-
|
|
185
|
-
Event Hash: esdb:hash:v2:abc123...
|
|
186
|
-
Merkle Root: esdb:merkle:v3:6a0e4b2f9d1c...
|
|
187
|
-
Last Event ID: 99
|
|
188
|
-
|
|
189
|
-
Sibling Hashes (3):
|
|
190
|
-
1. def456...
|
|
191
|
-
2. ghi789...
|
|
192
|
-
3. jkl012...
|
|
193
|
-
```
|
|
194
|
-
|
|
195
|
-
A proof of version 3 names the ID of the last event that its root covers, which fixes the position of its event in the tree. A proof of version 1 or 2 names no last event ID, but the side of each sibling instead, such as `def456... (left)`.
|
|
196
|
-
|
|
197
|
-
To prove an event against the root of an earlier state, pass its last event ID with `--last-event-id`, as for `merkle-root`. An event after it is not part of that tree, so the command refuses to prove it:
|
|
198
|
-
|
|
199
|
-
```shell
|
|
200
|
-
eventsourcingdb-merkle get-proof --backup=backup.json --event-id=42 --last-event-id=1234566
|
|
201
|
-
```
|
|
202
|
-
|
|
203
|
-
To prove an event against a root whose leaves are salted, pass the same key with `--salt-key-file`, and to prove it against a root of an earlier version, pass `--tree-version`, as for `merkle-root`. A proof against a salted root carries the salt of the leaf of its event, right after the hash of the event:
|
|
204
|
-
|
|
205
|
-
```shell
|
|
206
|
-
eventsourcingdb-merkle get-proof --backup=backup.json --event-id=42 --salt-key-file=merkle.key
|
|
207
|
-
```
|
|
208
|
-
|
|
209
|
-
```
|
|
210
|
-
Merkle Proof for Event 42
|
|
211
|
-
|
|
212
|
-
Event Hash: esdb:hash:v2:abc123...
|
|
213
|
-
Salt: 9c1f0b...
|
|
214
|
-
Merkle Root: esdb:merkle:v3:5f0c3e...
|
|
215
|
-
Last Event ID: 99
|
|
216
|
-
```
|
|
217
|
-
|
|
218
|
-
#### Outputting JSON
|
|
219
|
-
|
|
220
|
-
To get the proof as JSON for programmatic use, add the `--json` flag:
|
|
221
|
-
|
|
222
|
-
```shell
|
|
223
|
-
eventsourcingdb-merkle get-proof --backup=backup.json --event-id=42 --json
|
|
224
|
-
```
|
|
225
|
-
|
|
226
|
-
The output can then be saved to a file and shared with others:
|
|
227
|
-
|
|
228
|
-
```json
|
|
229
|
-
{
|
|
230
|
-
"eventId": "42",
|
|
231
|
-
"eventHash": "esdb:hash:v2:abc123...",
|
|
232
|
-
"siblingHashes": [
|
|
233
|
-
"def456...",
|
|
234
|
-
"ghi789...",
|
|
235
|
-
"jkl012..."
|
|
236
|
-
],
|
|
237
|
-
"merkleRoot": "esdb:merkle:v3:6a0e4b2f9d1c...",
|
|
238
|
-
"lastEventId": "99"
|
|
239
|
-
}
|
|
240
|
-
```
|
|
241
|
-
|
|
242
|
-
A proof against a salted root holds its salt in `salt`, right after `eventHash`. A proof of version 1 or 2 holds no `lastEventId`, and every sibling in it is an object with its `hash` and its `position`, `left` or `right`.
|
|
243
|
-
|
|
244
|
-
### Verifying Merkle Proofs
|
|
245
|
-
|
|
246
|
-
Once you have a Merkle proof, you can verify it without needing the original backup file. This is particularly useful when you receive a proof from someone else and want to verify that the event is indeed part of the backup with the claimed Merkle root.
|
|
247
|
-
|
|
248
|
-
To verify a proof, call the `verify-proof` command and provide either a path to a JSON file containing the proof, or the proof as a JSON string:
|
|
33
|
+
Generate a proof for an event, and verify it:
|
|
249
34
|
|
|
250
35
|
```shell
|
|
36
|
+
eventsourcingdb-merkle get-proof --backup=backup.json --event-id=42 --json > proof.json
|
|
251
37
|
eventsourcingdb-merkle verify-proof proof.json
|
|
252
38
|
```
|
|
253
39
|
|
|
254
|
-
|
|
255
|
-
|
|
256
|
-
```shell
|
|
257
|
-
eventsourcingdb-merkle verify-proof '{"eventId":"42","eventHash":"...","siblingHashes":["..."],"merkleRoot":"esdb:merkle:v3:...","lastEventId":"99"}'
|
|
258
|
-
```
|
|
259
|
-
|
|
260
|
-
The command verifies proofs of every version of the tree, which it tells apart by their root, and takes the salt of a salted proof from the proof itself, so it needs neither the backup nor the key.
|
|
261
|
-
|
|
262
|
-
If the proof is valid, the command confirms this and displays the event details:
|
|
263
|
-
|
|
264
|
-
```
|
|
265
|
-
✓ Merkle proof is valid
|
|
266
|
-
Event ID: 42
|
|
267
|
-
Event Hash: esdb:hash:v2:abc123...
|
|
268
|
-
Merkle Root: esdb:merkle:v3:6a0e4b2f9d1c...
|
|
269
|
-
Last Event ID: 99
|
|
270
|
-
```
|
|
271
|
-
|
|
272
|
-
If the proof is invalid, the command indicates this with a non-zero exit code:
|
|
273
|
-
|
|
274
|
-
```
|
|
275
|
-
✗ Merkle proof is invalid
|
|
276
|
-
Event ID: 42
|
|
277
|
-
Event Hash: esdb:hash:v2:abc123...
|
|
278
|
-
Merkle Root: esdb:merkle:v3:6a0e4b2f9d1c...
|
|
279
|
-
Last Event ID: 99
|
|
280
|
-
```
|
|
281
|
-
|
|
282
|
-
A valid proof shows that the event is part of the tree with the root it names, so compare that root with the one that was published. In version 3, it also shows that the event is the one with its ID, in a tree that ends at the last event ID: its path leads to the root from the leaf at that position only, and the root covers the number of events, so neither ID can be changed without the proof becoming invalid. A proof of version 1 or 2 does not bind the ID of its event, so whoever hands it on could change it, and its ID is only as trustworthy as whoever gave you the proof.
|
|
283
|
-
|
|
284
|
-
## Understanding the Technical Details
|
|
285
|
-
|
|
286
|
-
The tool implements Merkle trees using SHA-256 hashing, following the EventSourcingDB specification for event hash calculation, which knows two versions. An event keeps the version of the hash it was written with, so the tool verifies every hash in the version it names:
|
|
287
|
-
|
|
288
|
-
- A hash of version 2, which EventSourcingDB writes from release 1.3 on, starts with `esdb:hash:v2:`. It is the SHA-256 of that prefix and of the fields `specversion`, `id`, `predecessorhash`, `time`, `source`, `subject`, `type`, `datacontenttype`, `traceparent`, `tracestate`, and `data`, each on a line of its own, with `-` for a field that the event does not have.
|
|
289
|
-
- A hash without a prefix is of version 1. It is computed by first creating a metadata string from the CloudEvents fields, then hashing the metadata and the data separately, and finally hashing the concatenation of both hashes. It covers neither `traceparent` nor `tracestate`.
|
|
290
|
-
|
|
291
|
-
In both versions, the data is hashed as it appears in the backup or in the event given with `--event`, rather than parsed and serialized again, since that would change escape sequences such as `\u003c` for `<` and the notation of numbers. Only the whitespace between its tokens is left out, which EventSourcingDB never writes, so that an event formatted afterwards, as by a viewer or by `jq` without `-c`, still verifies.
|
|
292
|
-
|
|
293
|
-
The Merkle trees of versions 2 and 3 follow [RFC 6962](https://www.rfc-editor.org/rfc/rfc6962), as the tree of [eventsourcingdb-auditing](https://github.com/thenativeweb/eventsourcingdb-auditing) does:
|
|
294
|
-
|
|
295
|
-
- The data of a leaf is the hash of its event as it is stored, prefix included, as text in UTF-8. Where the leaves are salted, its salt comes first: the HMAC-SHA256 of that text under the salt key. Since nothing marks where the salt ends, the tree takes only hashes in the form of version 1 or 2, which give the data of a leaf other lengths with a salt than without one, and refuses an event with any other hash, as `verify-proof` refuses a proof of one.
|
|
296
|
-
- The hash of a leaf is the SHA-256 of the byte `0x00` followed by its data, and the hash of an inner node is the SHA-256 of the byte `0x01` followed by the hashes of its two children, so that neither can pass for the other.
|
|
297
|
-
- The tree splits its leaves at the largest power of two smaller than their number, and never duplicates a node.
|
|
298
|
-
- The root of version 2 is the hash of the top node in hexadecimal, after the prefix `esdb:merkle:v2:`. The root of version 3 is the SHA-256 of the byte `0x02`, the number of leaves as 8 bytes, big-endian, and the hash of the top node, in hexadecimal, after the prefix `esdb:merkle:v3:`.
|
|
299
|
-
|
|
300
|
-
A proof of version 3 is verified as [RFC 9162](https://www.rfc-editor.org/rfc/rfc9162), section 2.1.3.2, verifies an inclusion proof, with the event ID as the index of its leaf and one more than the last event ID as the size of the tree, from which the side of every sibling follows. EventSourcingDB numbers its events from 0 without gaps, so the leaf at an index is the event with that ID, and the tree of version 3 refuses a source whose IDs do not run like that. Certificate Transparency, for which RFC 9162 was written, signs the size of a tree together with its root. The root of version 3 hashes it in instead, since without it, a proof could bring a size of its own, under which its path would lead to the root from the leaf at another index.
|
|
301
|
-
|
|
302
|
-
The tree of version 1 takes the stored hashes as its leaves, and hashes the concatenation of the hashes of its two children, as text, for an inner node. Where a level has an odd number of nodes, it pairs the last one with itself.
|
|
303
|
-
|
|
304
|
-
Backup files are expected to be in one of the two NDJSON formats that EventSourcingDB writes, and the tool reads every backup that a restore of EventSourcingDB takes. It checks the structure of a backup, the hashes, and the chain, but neither the values of the events nor the schemas, which a restore checks with the rules of the server:
|
|
305
|
-
|
|
306
|
-
- A backup of the v1 API, which EventSourcingDB writes on `/api/v1/backup`, holds a JSON object with a `type` and a `payload` field on each line. A line of the type `event` holds a CloudEvents-compliant event and its hash. A line of the type `schema` holds the schema of an event type, which the tool skips, since neither the hashes nor the chain cover it.
|
|
307
|
-
- A backup of the v2 API, which EventSourcingDB writes on `/api/v2/management/create-backup` from release 1.3 on, holds a JSON object with a `type` and a `data` field on each line. It begins with a line of the type `backup`, which names the version of its format, and ends with a line of the type `end`. An incremental backup follows on the last event of the backup before it. To verify one, append it to the full backup and the increments before it, in their order, as a restore takes them, for example with `cat full.ndjson increment-1.ndjson increment-2.ndjson`: across them, the chain is the ordinary chain of the events.
|
|
308
|
-
|
|
309
|
-
A backup that holds a line of the type `error` was cut short, and the tool refuses it, as it refuses a line of any type that its format does not know, a line that is not valid JSON, and a backup of the v2 API whose structure a restore would refuse, naming the line.
|
|
40
|
+
For everything else, see the **[complete documentation](https://www.eventfoundation.io/docs/eventsourcingdb/merkle-cli)**.
|
|
310
41
|
|
|
311
42
|
## Running Quality Assurance
|
|
312
43
|
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "eventsourcingdb-merkle",
|
|
3
|
-
"version": "4.0.
|
|
3
|
+
"version": "4.0.8",
|
|
4
4
|
"description": "Merkle tree utilities for EventSourcingDB backups and databases.",
|
|
5
5
|
"author": {
|
|
6
6
|
"name": "the native web GmbH",
|
|
@@ -17,12 +17,12 @@
|
|
|
17
17
|
"commands": "./dist/commands"
|
|
18
18
|
},
|
|
19
19
|
"dependencies": {
|
|
20
|
-
"@oclif/core": "5.1.
|
|
20
|
+
"@oclif/core": "5.1.11",
|
|
21
21
|
"eventsourcingdb": "2.2.3"
|
|
22
22
|
},
|
|
23
23
|
"devDependencies": {
|
|
24
|
-
"@biomejs/biome": "2.6.
|
|
25
|
-
"@types/node": "26.6.
|
|
24
|
+
"@biomejs/biome": "2.6.5",
|
|
25
|
+
"@types/node": "26.6.6",
|
|
26
26
|
"tsx": "4.23.15",
|
|
27
27
|
"typescript": "7.0.2"
|
|
28
28
|
},
|