Issues/Ergonomics around Type.Ref, Type.Recursive and TypeCompiler

[kade-robertson]

Hello!

I'm running into some issues attempting to (and potentially misusing) this package to define a schema to validate GeoJSON. The general idea of my project is to define the structure with Typebox as a source-of-truth, and then (try) to use codegen to produce validators for other options: https://github.com/kade-robertson/rfc7946

The trouble I'm running into is around some of the ergonomics issues I've run into with Type.Ref. You'll note in the master branch that all of my types (in the definitions package) are defined with $ids, but do not use Type.Ref to be referenced later. Adding the $id property was required to have codegen via typebox-codegen to work for Zod, which was the first example I wanted to try out. This main branch works reasonably well for those two packages.

However, the JSON schema generated is unusable, seemingly due to some of the tuple definitions ending up with duplicate IDs in the output (I think, it's not immediately clear) -- at the very least, it's JSON schema that ajv can't resolve (see PR: kade-robertson/rfc7946#1).

It seemed the most logical to me that this could be resolved with references, so I set up those changes and got the JSON schema output to be much more reasonable, functional enough to actually get ajv working (though with an admittedly awkward process to register all of the dependencies for the main FeatureCollection schema). However, this broke Typebox -- both Value and TypeCompiler could no longer resolve the type. I went through old issues on this repo and saw mention of Type.Deref, which I got working with some similar ugliness to how ajv worked, but TypeCompiler still failed to work with the dereferenced type, with an error showing up on the recursive type: kade-robertson/rfc7946#2

So, this leads to a couple of questions:

1. Am I doing something terribly wrong with my original type definitions? (very possible)
2. If I'm not, and the second PR I linked is how you'd be expected to make these definitions -- is there any way around the awkwardness of requiring Type.Deref? Should I be exporting Deref'd versions of every type?

---

As an aside, you'll note that repo has a small benchmark in it just to validate the setup. I very well could have set it up wrong, but I seem to be running into performance issues where Typebox is significantly slower than ajv, even with TypeCompiler being used. The repo isn't in a state where any branch has all benchmarks working, but the results on master look like:

┌─────────┬───────────────────────────────────────────────┬──────────┬────────────────────┬──────────┬─────────┐
│ (index) │ Task Name                                     │ ops/sec  │ Average Time (ns)  │ Margin   │ Samples │
├─────────┼───────────────────────────────────────────────┼──────────┼────────────────────┼──────────┼─────────┤
│ 0       │ 'Grocery_Stores.geojson (Typebox)'            │ '4,221'  │ 236893.03837044202 │ '±0.31%' │ 4222    │
│ 1       │ 'Grocery_Stores.geojson (Typebox (compiled))' │ '18,011' │ 55520.06367976767  │ '±0.22%' │ 18012   │
│ 2       │ 'Grocery_Stores.geojson (Zod)'                │ '2,578'  │ 387873.7049243867  │ '±0.31%' │ 2579    │
└─────────┴───────────────────────────────────────────────┴──────────┴────────────────────┴──────────┴─────────┘

whereas on the second PR that gets ajv working:

┌─────────┬────────────────────────────────────┬───────────┬────────────────────┬──────────┬─────────┐
│ (index) │ Task Name                          │ ops/sec   │ Average Time (ns)  │ Margin   │ Samples │
├─────────┼────────────────────────────────────┼───────────┼────────────────────┼──────────┼─────────┤
│ 0       │ 'Grocery_Stores.geojson (Ajv)'     │ '188,601' │ 5302.1763183851035 │ '±0.28%' │ 188602  │
│ 1       │ 'Grocery_Stores.geojson (Typebox)' │ '4,711'   │ 212254.0925297136  │ '±0.19%' │ 4712    │
│ 2       │ 'Grocery_Stores.geojson (Zod)'     │ '2,594'   │ 385492.28786127013 │ '±0.35%' │ 2595    │
└─────────┴────────────────────────────────────┴───────────┴────────────────────┴──────────┴─────────┘

None of them are performing in a way that's concerning to me (though at some point I will sort out a larger, more varied dataset), it's moreso just the disparity between ajv and typebox here doesn't line up with some of the benchmarks in the README.