OSV.dev vulnerability database client
osv: let open Json.Codec in cleanup
39 Json.Codec. prefixes removed. The raw_vuln record uses rv_*
prefixed field names that don't clash with Json.Codec.mem_map.
The unprefixed `vulnerability` record (with `id`) has no associated
codec body to disambiguate.
+48
-39
+48
-39
lib/osv.ml
+48
-39
lib/osv.ml
···
55
55
type severity_entry = { sev_type : string; score : string }
56
56
57
57
let severity_entry_jsont : severity_entry Json.codec =
58
-
Json.Codec.Object.map ~kind:"severity_entry" (fun sev_type score ->
58
+
let open Json.Codec in
59
+
Object.map ~kind:"severity_entry" (fun sev_type score ->
59
60
{ sev_type; score })
60
-
|> Json.Codec.Object.mem "type" Json.Codec.string ~dec_absent:""
61
+
|> Object.mem "type" string ~dec_absent:""
61
62
~enc:(fun s -> s.sev_type)
62
-
|> Json.Codec.Object.mem "score" Json.Codec.string ~dec_absent:""
63
+
|> Object.mem "score" string ~dec_absent:""
63
64
~enc:(fun s -> s.score)
64
-
|> Json.Codec.Object.skip_unknown |> Json.Codec.Object.finish
65
+
|> Object.skip_unknown |> Object.finish
65
66
66
67
(* Reference: {"type": "WEB", "url": "https://..."} *)
67
68
let reference_jsont : reference Json.codec =
68
-
Json.Codec.Object.map ~kind:"reference" (fun ref_type url ->
69
+
let open Json.Codec in
70
+
Object.map ~kind:"reference" (fun ref_type url ->
69
71
{ ref_type; url })
70
-
|> Json.Codec.Object.mem "type" Json.Codec.string ~dec_absent:""
72
+
|> Object.mem "type" string ~dec_absent:""
71
73
~enc:(fun r -> r.ref_type)
72
-
|> Json.Codec.Object.mem "url" Json.Codec.string ~dec_absent:"" ~enc:(fun r ->
74
+
|> Object.mem "url" string ~dec_absent:"" ~enc:(fun r ->
73
75
r.url)
74
-
|> Json.Codec.Object.skip_unknown |> Json.Codec.Object.finish
76
+
|> Object.skip_unknown |> Object.finish
75
77
76
78
(* Event: {"introduced": "0", "fixed": "1.2.3"} *)
77
79
type range_event = { event_type : string; event_version : string }
78
80
79
81
let range_event_jsont : range_event Json.codec =
82
+
let open Json.Codec in
80
83
(* Events are objects with a single key being the event type *)
81
-
Json.Codec.Object.map ~kind:"range_event" (fun event_type event_version ->
84
+
Object.map ~kind:"range_event" (fun event_type event_version ->
82
85
{ event_type; event_version })
83
-
|> Json.Codec.Object.mem "introduced" Json.Codec.string ~dec_absent:""
86
+
|> Object.mem "introduced" string ~dec_absent:""
84
87
~enc:(fun e -> e.event_type)
85
-
|> Json.Codec.Object.mem "fixed" Json.Codec.string ~dec_absent:""
88
+
|> Object.mem "fixed" string ~dec_absent:""
86
89
~enc:(fun e -> e.event_version)
87
-
|> Json.Codec.Object.skip_unknown |> Json.Codec.Object.finish
90
+
|> Object.skip_unknown |> Object.finish
88
91
89
92
(* Range: {"type": "SEMVER", "events": [...]} *)
90
93
type raw_range = { rr_type : string; events : range_event list }
91
94
92
95
let raw_range_jsont : raw_range Json.codec =
93
-
Json.Codec.Object.map ~kind:"range" (fun rr_type events ->
96
+
let open Json.Codec in
97
+
Object.map ~kind:"range" (fun rr_type events ->
94
98
{ rr_type; events })
95
-
|> Json.Codec.Object.mem "type" Json.Codec.string ~dec_absent:""
99
+
|> Object.mem "type" string ~dec_absent:""
96
100
~enc:(fun r -> r.rr_type)
97
-
|> Json.Codec.Object.mem "events" (Json.Codec.list range_event_jsont)
101
+
|> Object.mem "events" (list range_event_jsont)
98
102
~dec_absent:[] ~enc:(fun r -> r.events)
99
-
|> Json.Codec.Object.skip_unknown |> Json.Codec.Object.finish
103
+
|> Object.skip_unknown |> Object.finish
100
104
101
105
(* Affected: {"ranges": [...]} *)
102
106
type raw_affected = { ranges : raw_range list }
103
107
104
108
let raw_affected_jsont : raw_affected Json.codec =
105
-
Json.Codec.Object.map ~kind:"affected" (fun ranges -> { ranges })
106
-
|> Json.Codec.Object.mem "ranges" (Json.Codec.list raw_range_jsont)
109
+
let open Json.Codec in
110
+
Object.map ~kind:"affected" (fun ranges -> { ranges })
111
+
|> Object.mem "ranges" (list raw_range_jsont)
107
112
~dec_absent:[] ~enc:(fun a -> a.ranges)
108
-
|> Json.Codec.Object.skip_unknown |> Json.Codec.Object.finish
113
+
|> Object.skip_unknown |> Object.finish
109
114
110
115
(* Vulnerability (top-level OSV record) *)
111
116
type raw_vuln = {
···
121
126
}
122
127
123
128
let raw_vuln_jsont : raw_vuln Json.codec =
124
-
Json.Codec.Object.map ~kind:"vulnerability"
129
+
let open Json.Codec in
130
+
Object.map ~kind:"vulnerability"
125
131
(fun
126
132
rv_id
127
133
rv_aliases
···
144
150
rv_affected;
145
151
rv_references;
146
152
})
147
-
|> Json.Codec.Object.mem "id" Json.Codec.string ~dec_absent:"" ~enc:(fun v ->
153
+
|> Object.mem "id" string ~dec_absent:"" ~enc:(fun v ->
148
154
v.rv_id)
149
-
|> Json.Codec.Object.mem "aliases" (Json.Codec.list Json.Codec.string)
155
+
|> Object.mem "aliases" (list string)
150
156
~dec_absent:[] ~enc:(fun v -> v.rv_aliases)
151
-
|> Json.Codec.Object.mem "summary" Json.Codec.string ~dec_absent:""
157
+
|> Object.mem "summary" string ~dec_absent:""
152
158
~enc:(fun v -> v.rv_summary)
153
-
|> Json.Codec.Object.mem "details" Json.Codec.string ~dec_absent:""
159
+
|> Object.mem "details" string ~dec_absent:""
154
160
~enc:(fun v -> v.rv_details)
155
-
|> Json.Codec.Object.mem "severity" (Json.Codec.list severity_entry_jsont)
161
+
|> Object.mem "severity" (list severity_entry_jsont)
156
162
~dec_absent:[] ~enc:(fun v -> v.rv_severity)
157
-
|> Json.Codec.Object.mem "published" Json.Codec.string ~dec_absent:""
163
+
|> Object.mem "published" string ~dec_absent:""
158
164
~enc:(fun v -> v.rv_published)
159
-
|> Json.Codec.Object.mem "modified" Json.Codec.string ~dec_absent:""
165
+
|> Object.mem "modified" string ~dec_absent:""
160
166
~enc:(fun v -> v.rv_modified)
161
-
|> Json.Codec.Object.mem "affected" (Json.Codec.list raw_affected_jsont)
167
+
|> Object.mem "affected" (list raw_affected_jsont)
162
168
~dec_absent:[] ~enc:(fun v -> v.rv_affected)
163
-
|> Json.Codec.Object.mem "references" (Json.Codec.list reference_jsont)
169
+
|> Object.mem "references" (list reference_jsont)
164
170
~dec_absent:[] ~enc:(fun v -> v.rv_references)
165
-
|> Json.Codec.Object.skip_unknown |> Json.Codec.Object.finish
171
+
|> Object.skip_unknown |> Object.finish
166
172
167
173
(* Response: {"vulns": [...]} *)
168
174
type raw_response = { vulns : raw_vuln list }
169
175
170
176
let raw_response_jsont : raw_response Json.codec =
171
-
Json.Codec.Object.map ~kind:"response" (fun vulns -> { vulns })
172
-
|> Json.Codec.Object.mem "vulns" (Json.Codec.list raw_vuln_jsont)
177
+
let open Json.Codec in
178
+
Object.map ~kind:"response" (fun vulns -> { vulns })
179
+
|> Object.mem "vulns" (list raw_vuln_jsont)
173
180
~dec_absent:[] ~enc:(fun r -> r.vulns)
174
-
|> Json.Codec.Object.skip_unknown |> Json.Codec.Object.finish
181
+
|> Object.skip_unknown |> Object.finish
175
182
176
183
(* Batch response: {"results": [{"vulns": [...]}, ...]} *)
177
184
type raw_batch_result = { br_vulns : raw_vuln list }
178
185
179
186
let raw_batch_result_jsont : raw_batch_result Json.codec =
180
-
Json.Codec.Object.map ~kind:"batch_result" (fun br_vulns -> { br_vulns })
181
-
|> Json.Codec.Object.mem "vulns" (Json.Codec.list raw_vuln_jsont)
187
+
let open Json.Codec in
188
+
Object.map ~kind:"batch_result" (fun br_vulns -> { br_vulns })
189
+
|> Object.mem "vulns" (list raw_vuln_jsont)
182
190
~dec_absent:[] ~enc:(fun r -> r.br_vulns)
183
-
|> Json.Codec.Object.skip_unknown |> Json.Codec.Object.finish
191
+
|> Object.skip_unknown |> Object.finish
184
192
185
193
type raw_batch_response = { results : raw_batch_result list }
186
194
187
195
let raw_batch_response_jsont : raw_batch_response Json.codec =
188
-
Json.Codec.Object.map ~kind:"batch_response" (fun results -> { results })
189
-
|> Json.Codec.Object.mem "results" (Json.Codec.list raw_batch_result_jsont)
196
+
let open Json.Codec in
197
+
Object.map ~kind:"batch_response" (fun results -> { results })
198
+
|> Object.mem "results" (list raw_batch_result_jsont)
190
199
~dec_absent:[] ~enc:(fun r -> r.results)
191
-
|> Json.Codec.Object.skip_unknown |> Json.Codec.Object.finish
200
+
|> Object.skip_unknown |> Object.finish
192
201
193
202
(* ── Convert raw types to public types ─────────────────────────────────── *)
194
203