OSV.dev vulnerability database client
wal, block, sse, zephyr: remove [mutable] from never-reassigned fields
Warning 69 (unused-field, mutable-never-assigned). Four independent
record fields were flagged as mutable but the code only mutates their
referents in place, never rebinds the record slot itself:
- ocaml-wal/lib/wal.ml: [t.file] (the Eio file resource; methods call
Eio.File.pwrite_all etc., the slot is set once at open time).
- ocaml-block/lib/block.ml: [Memory.state.data] (the backing bytes,
written via Bytes.blit_string; [Bytes.t] is already mutable).
- ocaml-sse/lib/sse.ml: [Parser.t.data_buf] (a Buffer.t, written via
Buffer.add_*; the slot never changes).
- ocaml-zephyr/lib/zephyr.ml: drop [mode : Read | Write] entirely —
set at open-time, read nowhere. The open_read / open_write
constructors already distinguish the two call shapes, so mode
tracking was redundant.
+56
-53
+1
-1
dune-project
+1
-1
dune-project
+1
-1
lib/dune
+1
-1
lib/dune
+50
-50
lib/osv.ml
+50
-50
lib/osv.ml
···
54
54
(* Severity entry: {"type": "CVSS_V3", "score": "9.8"} *)
55
55
type severity_entry = { sev_type : string; score : string }
56
56
57
-
let severity_entry_jsont : severity_entry Jsont.t =
58
-
Jsont.Object.map ~kind:"severity_entry" (fun sev_type score ->
57
+
let severity_entry_jsont : severity_entry Json.codec =
58
+
Json.Object.map ~kind:"severity_entry" (fun sev_type score ->
59
59
{ sev_type; score })
60
-
|> Jsont.Object.mem "type" Jsont.string ~dec_absent:"" ~enc:(fun s ->
60
+
|> Json.Object.mem "type" Json.string ~dec_absent:"" ~enc:(fun s ->
61
61
s.sev_type)
62
-
|> Jsont.Object.mem "score" Jsont.string ~dec_absent:"" ~enc:(fun s ->
62
+
|> Json.Object.mem "score" Json.string ~dec_absent:"" ~enc:(fun s ->
63
63
s.score)
64
-
|> Jsont.Object.skip_unknown |> Jsont.Object.finish
64
+
|> Json.Object.skip_unknown |> Json.Object.finish
65
65
66
66
(* Reference: {"type": "WEB", "url": "https://..."} *)
67
-
let reference_jsont : reference Jsont.t =
68
-
Jsont.Object.map ~kind:"reference" (fun ref_type url -> { ref_type; url })
69
-
|> Jsont.Object.mem "type" Jsont.string ~dec_absent:"" ~enc:(fun r ->
67
+
let reference_jsont : reference Json.codec =
68
+
Json.Object.map ~kind:"reference" (fun ref_type url -> { ref_type; url })
69
+
|> Json.Object.mem "type" Json.string ~dec_absent:"" ~enc:(fun r ->
70
70
r.ref_type)
71
-
|> Jsont.Object.mem "url" Jsont.string ~dec_absent:"" ~enc:(fun r -> r.url)
72
-
|> Jsont.Object.skip_unknown |> Jsont.Object.finish
71
+
|> Json.Object.mem "url" Json.string ~dec_absent:"" ~enc:(fun r -> r.url)
72
+
|> Json.Object.skip_unknown |> Json.Object.finish
73
73
74
74
(* Event: {"introduced": "0", "fixed": "1.2.3"} *)
75
75
type range_event = { event_type : string; event_version : string }
76
76
77
-
let range_event_jsont : range_event Jsont.t =
77
+
let range_event_jsont : range_event Json.codec =
78
78
(* Events are objects with a single key being the event type *)
79
-
Jsont.Object.map ~kind:"range_event" (fun event_type event_version ->
79
+
Json.Object.map ~kind:"range_event" (fun event_type event_version ->
80
80
{ event_type; event_version })
81
-
|> Jsont.Object.mem "introduced" Jsont.string ~dec_absent:"" ~enc:(fun e ->
81
+
|> Json.Object.mem "introduced" Json.string ~dec_absent:"" ~enc:(fun e ->
82
82
e.event_type)
83
-
|> Jsont.Object.mem "fixed" Jsont.string ~dec_absent:"" ~enc:(fun e ->
83
+
|> Json.Object.mem "fixed" Json.string ~dec_absent:"" ~enc:(fun e ->
84
84
e.event_version)
85
-
|> Jsont.Object.skip_unknown |> Jsont.Object.finish
85
+
|> Json.Object.skip_unknown |> Json.Object.finish
86
86
87
87
(* Range: {"type": "SEMVER", "events": [...]} *)
88
88
type raw_range = { rr_type : string; events : range_event list }
89
89
90
-
let raw_range_jsont : raw_range Jsont.t =
91
-
Jsont.Object.map ~kind:"range" (fun rr_type events -> { rr_type; events })
92
-
|> Jsont.Object.mem "type" Jsont.string ~dec_absent:"" ~enc:(fun r ->
90
+
let raw_range_jsont : raw_range Json.codec =
91
+
Json.Object.map ~kind:"range" (fun rr_type events -> { rr_type; events })
92
+
|> Json.Object.mem "type" Json.string ~dec_absent:"" ~enc:(fun r ->
93
93
r.rr_type)
94
-
|> Jsont.Object.mem "events" (Jsont.list range_event_jsont) ~dec_absent:[]
94
+
|> Json.Object.mem "events" (Json.list range_event_jsont) ~dec_absent:[]
95
95
~enc:(fun r -> r.events)
96
-
|> Jsont.Object.skip_unknown |> Jsont.Object.finish
96
+
|> Json.Object.skip_unknown |> Json.Object.finish
97
97
98
98
(* Affected: {"ranges": [...]} *)
99
99
type raw_affected = { ranges : raw_range list }
100
100
101
-
let raw_affected_jsont : raw_affected Jsont.t =
102
-
Jsont.Object.map ~kind:"affected" (fun ranges -> { ranges })
103
-
|> Jsont.Object.mem "ranges" (Jsont.list raw_range_jsont) ~dec_absent:[]
101
+
let raw_affected_jsont : raw_affected Json.codec =
102
+
Json.Object.map ~kind:"affected" (fun ranges -> { ranges })
103
+
|> Json.Object.mem "ranges" (Json.list raw_range_jsont) ~dec_absent:[]
104
104
~enc:(fun a -> a.ranges)
105
-
|> Jsont.Object.skip_unknown |> Jsont.Object.finish
105
+
|> Json.Object.skip_unknown |> Json.Object.finish
106
106
107
107
(* Vulnerability (top-level OSV record) *)
108
108
type raw_vuln = {
···
117
117
rv_references : reference list;
118
118
}
119
119
120
-
let raw_vuln_jsont : raw_vuln Jsont.t =
121
-
Jsont.Object.map ~kind:"vulnerability"
120
+
let raw_vuln_jsont : raw_vuln Json.codec =
121
+
Json.Object.map ~kind:"vulnerability"
122
122
(fun
123
123
rv_id
124
124
rv_aliases
···
141
141
rv_affected;
142
142
rv_references;
143
143
})
144
-
|> Jsont.Object.mem "id" Jsont.string ~dec_absent:"" ~enc:(fun v -> v.rv_id)
145
-
|> Jsont.Object.mem "aliases" (Jsont.list Jsont.string) ~dec_absent:[]
144
+
|> Json.Object.mem "id" Json.string ~dec_absent:"" ~enc:(fun v -> v.rv_id)
145
+
|> Json.Object.mem "aliases" (Json.list Json.string) ~dec_absent:[]
146
146
~enc:(fun v -> v.rv_aliases)
147
-
|> Jsont.Object.mem "summary" Jsont.string ~dec_absent:"" ~enc:(fun v ->
147
+
|> Json.Object.mem "summary" Json.string ~dec_absent:"" ~enc:(fun v ->
148
148
v.rv_summary)
149
-
|> Jsont.Object.mem "details" Jsont.string ~dec_absent:"" ~enc:(fun v ->
149
+
|> Json.Object.mem "details" Json.string ~dec_absent:"" ~enc:(fun v ->
150
150
v.rv_details)
151
-
|> Jsont.Object.mem "severity" (Jsont.list severity_entry_jsont)
151
+
|> Json.Object.mem "severity" (Json.list severity_entry_jsont)
152
152
~dec_absent:[] ~enc:(fun v -> v.rv_severity)
153
-
|> Jsont.Object.mem "published" Jsont.string ~dec_absent:"" ~enc:(fun v ->
153
+
|> Json.Object.mem "published" Json.string ~dec_absent:"" ~enc:(fun v ->
154
154
v.rv_published)
155
-
|> Jsont.Object.mem "modified" Jsont.string ~dec_absent:"" ~enc:(fun v ->
155
+
|> Json.Object.mem "modified" Json.string ~dec_absent:"" ~enc:(fun v ->
156
156
v.rv_modified)
157
-
|> Jsont.Object.mem "affected" (Jsont.list raw_affected_jsont) ~dec_absent:[]
157
+
|> Json.Object.mem "affected" (Json.list raw_affected_jsont) ~dec_absent:[]
158
158
~enc:(fun v -> v.rv_affected)
159
-
|> Jsont.Object.mem "references" (Jsont.list reference_jsont) ~dec_absent:[]
159
+
|> Json.Object.mem "references" (Json.list reference_jsont) ~dec_absent:[]
160
160
~enc:(fun v -> v.rv_references)
161
-
|> Jsont.Object.skip_unknown |> Jsont.Object.finish
161
+
|> Json.Object.skip_unknown |> Json.Object.finish
162
162
163
163
(* Response: {"vulns": [...]} *)
164
164
type raw_response = { vulns : raw_vuln list }
165
165
166
-
let raw_response_jsont : raw_response Jsont.t =
167
-
Jsont.Object.map ~kind:"response" (fun vulns -> { vulns })
168
-
|> Jsont.Object.mem "vulns" (Jsont.list raw_vuln_jsont) ~dec_absent:[]
166
+
let raw_response_jsont : raw_response Json.codec =
167
+
Json.Object.map ~kind:"response" (fun vulns -> { vulns })
168
+
|> Json.Object.mem "vulns" (Json.list raw_vuln_jsont) ~dec_absent:[]
169
169
~enc:(fun r -> r.vulns)
170
-
|> Jsont.Object.skip_unknown |> Jsont.Object.finish
170
+
|> Json.Object.skip_unknown |> Json.Object.finish
171
171
172
172
(* Batch response: {"results": [{"vulns": [...]}, ...]} *)
173
173
type raw_batch_result = { br_vulns : raw_vuln list }
174
174
175
-
let raw_batch_result_jsont : raw_batch_result Jsont.t =
176
-
Jsont.Object.map ~kind:"batch_result" (fun br_vulns -> { br_vulns })
177
-
|> Jsont.Object.mem "vulns" (Jsont.list raw_vuln_jsont) ~dec_absent:[]
175
+
let raw_batch_result_jsont : raw_batch_result Json.codec =
176
+
Json.Object.map ~kind:"batch_result" (fun br_vulns -> { br_vulns })
177
+
|> Json.Object.mem "vulns" (Json.list raw_vuln_jsont) ~dec_absent:[]
178
178
~enc:(fun r -> r.br_vulns)
179
-
|> Jsont.Object.skip_unknown |> Jsont.Object.finish
179
+
|> Json.Object.skip_unknown |> Json.Object.finish
180
180
181
181
type raw_batch_response = { results : raw_batch_result list }
182
182
183
-
let raw_batch_response_jsont : raw_batch_response Jsont.t =
184
-
Jsont.Object.map ~kind:"batch_response" (fun results -> { results })
185
-
|> Jsont.Object.mem "results" (Jsont.list raw_batch_result_jsont)
183
+
let raw_batch_response_jsont : raw_batch_response Json.codec =
184
+
Json.Object.map ~kind:"batch_response" (fun results -> { results })
185
+
|> Json.Object.mem "results" (Json.list raw_batch_result_jsont)
186
186
~dec_absent:[] ~enc:(fun r -> r.results)
187
-
|> Jsont.Object.skip_unknown |> Jsont.Object.finish
187
+
|> Json.Object.skip_unknown |> Json.Object.finish
188
188
189
189
(* ── Convert raw types to public types ─────────────────────────────────── *)
190
190
···
234
234
(* ── Response parsing ──────────────────────────────────────────────────── *)
235
235
236
236
let parse_response json =
237
-
match Jsont_bytesrw.decode_string raw_response_jsont json with
237
+
match Json_bytesrw.decode_string raw_response_jsont json with
238
238
| Ok resp -> List.map vuln_of_raw resp.vulns
239
239
| Error msg ->
240
240
Log.err (fun f -> f "parse_response: %s" msg);
···
293
293
Log.err (fun f -> f "batch query failed: %s" msg);
294
294
List.map (fun purl -> (purl, [])) purls
295
295
| Ok json -> (
296
-
match Jsont_bytesrw.decode_string raw_batch_response_jsont json with
296
+
match Json_bytesrw.decode_string raw_batch_response_jsont json with
297
297
| Error msg ->
298
298
Log.err (fun f -> f "batch parse failed: %s" msg);
299
299
List.map (fun purl -> (purl, [])) purls