Skip to main content

harn_hostlib/
schemas.rs

1//! Embedded JSON Schemas for every hostlib host method.
2//!
3//! Schemas live at `schemas/<module>/<method>.{request,response}.json` and
4//! are baked into the crate at compile time via `include_str!`. They're the
5//! source of truth for `burin-code`'s schema-drift tests: the schema files
6//! ship with the crate (see the `include` field in `Cargo.toml`), and
7//! consumers fetch them through this module.
8//!
9//! Schemas use JSON Schema draft 2020-12.
10
11/// Direction of a schema (request body vs. response body).
12#[derive(Clone, Copy, Debug, PartialEq, Eq)]
13pub enum SchemaKind {
14    /// Schema for the *input* of a host method.
15    Request,
16    /// Schema for the *output* of a host method.
17    Response,
18}
19
20/// One `(module, method, kind, schema_text)` tuple for every shipped schema.
21///
22/// Embedders use this catalog to:
23/// - assert that every registered builtin has a matching schema (drift test);
24/// - export the schemas to consumers like burin-code;
25/// - validate live request/response payloads in tests.
26pub const SCHEMAS: &[(&str, &str, SchemaKind, &str)] = &[
27    // ast/
28    (
29        "ast",
30        "parse_file",
31        SchemaKind::Request,
32        include_str!("../schemas/ast/parse_file.request.json"),
33    ),
34    (
35        "ast",
36        "parse_file",
37        SchemaKind::Response,
38        include_str!("../schemas/ast/parse_file.response.json"),
39    ),
40    (
41        "ast",
42        "symbols",
43        SchemaKind::Request,
44        include_str!("../schemas/ast/symbols.request.json"),
45    ),
46    (
47        "ast",
48        "symbols",
49        SchemaKind::Response,
50        include_str!("../schemas/ast/symbols.response.json"),
51    ),
52    (
53        "ast",
54        "outline",
55        SchemaKind::Request,
56        include_str!("../schemas/ast/outline.request.json"),
57    ),
58    (
59        "ast",
60        "outline",
61        SchemaKind::Response,
62        include_str!("../schemas/ast/outline.response.json"),
63    ),
64    // code_index/
65    (
66        "code_index",
67        "query",
68        SchemaKind::Request,
69        include_str!("../schemas/code_index/query.request.json"),
70    ),
71    (
72        "code_index",
73        "query",
74        SchemaKind::Response,
75        include_str!("../schemas/code_index/query.response.json"),
76    ),
77    (
78        "code_index",
79        "rebuild",
80        SchemaKind::Request,
81        include_str!("../schemas/code_index/rebuild.request.json"),
82    ),
83    (
84        "code_index",
85        "rebuild",
86        SchemaKind::Response,
87        include_str!("../schemas/code_index/rebuild.response.json"),
88    ),
89    (
90        "code_index",
91        "stats",
92        SchemaKind::Request,
93        include_str!("../schemas/code_index/stats.request.json"),
94    ),
95    (
96        "code_index",
97        "stats",
98        SchemaKind::Response,
99        include_str!("../schemas/code_index/stats.response.json"),
100    ),
101    (
102        "code_index",
103        "imports_for",
104        SchemaKind::Request,
105        include_str!("../schemas/code_index/imports_for.request.json"),
106    ),
107    (
108        "code_index",
109        "imports_for",
110        SchemaKind::Response,
111        include_str!("../schemas/code_index/imports_for.response.json"),
112    ),
113    (
114        "code_index",
115        "importers_of",
116        SchemaKind::Request,
117        include_str!("../schemas/code_index/importers_of.request.json"),
118    ),
119    (
120        "code_index",
121        "importers_of",
122        SchemaKind::Response,
123        include_str!("../schemas/code_index/importers_of.response.json"),
124    ),
125    // scanner/
126    (
127        "scanner",
128        "scan_project",
129        SchemaKind::Request,
130        include_str!("../schemas/scanner/scan_project.request.json"),
131    ),
132    (
133        "scanner",
134        "scan_project",
135        SchemaKind::Response,
136        include_str!("../schemas/scanner/scan_project.response.json"),
137    ),
138    (
139        "scanner",
140        "scan_incremental",
141        SchemaKind::Request,
142        include_str!("../schemas/scanner/scan_incremental.request.json"),
143    ),
144    (
145        "scanner",
146        "scan_incremental",
147        SchemaKind::Response,
148        include_str!("../schemas/scanner/scan_incremental.response.json"),
149    ),
150    // fs_watch/
151    (
152        "fs_watch",
153        "subscribe",
154        SchemaKind::Request,
155        include_str!("../schemas/fs_watch/subscribe.request.json"),
156    ),
157    (
158        "fs_watch",
159        "subscribe",
160        SchemaKind::Response,
161        include_str!("../schemas/fs_watch/subscribe.response.json"),
162    ),
163    (
164        "fs_watch",
165        "unsubscribe",
166        SchemaKind::Request,
167        include_str!("../schemas/fs_watch/unsubscribe.request.json"),
168    ),
169    (
170        "fs_watch",
171        "unsubscribe",
172        SchemaKind::Response,
173        include_str!("../schemas/fs_watch/unsubscribe.response.json"),
174    ),
175    // tools/
176    (
177        "tools",
178        "search",
179        SchemaKind::Request,
180        include_str!("../schemas/tools/search.request.json"),
181    ),
182    (
183        "tools",
184        "search",
185        SchemaKind::Response,
186        include_str!("../schemas/tools/search.response.json"),
187    ),
188    (
189        "tools",
190        "read_file",
191        SchemaKind::Request,
192        include_str!("../schemas/tools/read_file.request.json"),
193    ),
194    (
195        "tools",
196        "read_file",
197        SchemaKind::Response,
198        include_str!("../schemas/tools/read_file.response.json"),
199    ),
200    (
201        "tools",
202        "write_file",
203        SchemaKind::Request,
204        include_str!("../schemas/tools/write_file.request.json"),
205    ),
206    (
207        "tools",
208        "write_file",
209        SchemaKind::Response,
210        include_str!("../schemas/tools/write_file.response.json"),
211    ),
212    (
213        "tools",
214        "delete_file",
215        SchemaKind::Request,
216        include_str!("../schemas/tools/delete_file.request.json"),
217    ),
218    (
219        "tools",
220        "delete_file",
221        SchemaKind::Response,
222        include_str!("../schemas/tools/delete_file.response.json"),
223    ),
224    (
225        "tools",
226        "list_directory",
227        SchemaKind::Request,
228        include_str!("../schemas/tools/list_directory.request.json"),
229    ),
230    (
231        "tools",
232        "list_directory",
233        SchemaKind::Response,
234        include_str!("../schemas/tools/list_directory.response.json"),
235    ),
236    (
237        "tools",
238        "get_file_outline",
239        SchemaKind::Request,
240        include_str!("../schemas/tools/get_file_outline.request.json"),
241    ),
242    (
243        "tools",
244        "get_file_outline",
245        SchemaKind::Response,
246        include_str!("../schemas/tools/get_file_outline.response.json"),
247    ),
248    (
249        "tools",
250        "git",
251        SchemaKind::Request,
252        include_str!("../schemas/tools/git.request.json"),
253    ),
254    (
255        "tools",
256        "git",
257        SchemaKind::Response,
258        include_str!("../schemas/tools/git.response.json"),
259    ),
260    (
261        "tools",
262        "run_command",
263        SchemaKind::Request,
264        include_str!("../schemas/tools/run_command.request.json"),
265    ),
266    (
267        "tools",
268        "run_command",
269        SchemaKind::Response,
270        include_str!("../schemas/tools/run_command.response.json"),
271    ),
272    (
273        "tools",
274        "run_test",
275        SchemaKind::Request,
276        include_str!("../schemas/tools/run_test.request.json"),
277    ),
278    (
279        "tools",
280        "run_test",
281        SchemaKind::Response,
282        include_str!("../schemas/tools/run_test.response.json"),
283    ),
284    (
285        "tools",
286        "run_build_command",
287        SchemaKind::Request,
288        include_str!("../schemas/tools/run_build_command.request.json"),
289    ),
290    (
291        "tools",
292        "run_build_command",
293        SchemaKind::Response,
294        include_str!("../schemas/tools/run_build_command.response.json"),
295    ),
296    (
297        "tools",
298        "inspect_test_results",
299        SchemaKind::Request,
300        include_str!("../schemas/tools/inspect_test_results.request.json"),
301    ),
302    (
303        "tools",
304        "inspect_test_results",
305        SchemaKind::Response,
306        include_str!("../schemas/tools/inspect_test_results.response.json"),
307    ),
308    (
309        "tools",
310        "manage_packages",
311        SchemaKind::Request,
312        include_str!("../schemas/tools/manage_packages.request.json"),
313    ),
314    (
315        "tools",
316        "manage_packages",
317        SchemaKind::Response,
318        include_str!("../schemas/tools/manage_packages.response.json"),
319    ),
320    (
321        "tools",
322        "enable",
323        SchemaKind::Request,
324        include_str!("../schemas/tools/enable.request.json"),
325    ),
326    (
327        "tools",
328        "enable",
329        SchemaKind::Response,
330        include_str!("../schemas/tools/enable.response.json"),
331    ),
332];
333
334/// Look up a single schema as raw JSON text.
335pub fn lookup(module: &str, method: &str, kind: SchemaKind) -> Option<&'static str> {
336    SCHEMAS
337        .iter()
338        .find(|(m, mt, k, _)| *m == module && *mt == method && *k == kind)
339        .map(|(_, _, _, body)| *body)
340}