Supporting $ref in FromSchema

[jrabausch]

Hello there! First of all, thanks for this great library!

I found from-schema.ts which is perfect for my needs, as I have to parse multiple smaller JSON schemas and eventually compose them into new TypeBox models. Would it be possible to support $refs and definitions? How would you go about that?

Thanks in advance!

[sinclairzx81]

@jrabausch Hi,

Would it be possible to support $refs and definitions? How would you go about that?

TypeBox has support for $ref and $defs schematics via Type.Module. However be mindful that Modules are very constrained and may not be suitable for all cases. Below is how you might approach creating definition schematics (using FromSchema (which I've just pushed an update for to handle $ref, so be sure to grab the latest prototype))

Additional Information on Modules Here

import { Type, Static } from '@sinclair/typebox'
import { FromSchema } from './prototypes' // from prototypes

// Modules act as containers for multiple types. TypeBox 
// uses modules to enable remote referential computations 
// on types (which is very complex), but where the schema 
// representation for computation is expressed as `$defs` 
// and `$ref` schematics.
const Module = Type.Module({
  // dependencies
  A: FromSchema({ type: 'boolean' } as const),
  B: FromSchema({ type: 'string' } as const),
  C: FromSchema({ type: 'number' } as const),
  // dependant
  T: FromSchema({
    type: 'object',
    required: ['a', 'b', 'c'],
    properties: {
      a: { $ref: 'A' },
      b: { $ref: 'B' },
      c: { $ref: 'C' }
    }
  } as const)
})

const T = Module.Import('T')

// where T is:
//
// const T = {
//   '$defs': {
//     A: { type: 'boolean', '$id': 'A' },
//     B: { type: 'string', '$id': 'B' },
//     C: { type: 'number', '$id': 'C' },
//     T: {
//       type: 'object',
//       required: [ 'a', 'b', 'c' ],
//       properties: { 
//          a: { '$ref': 'A' }, 
//          b: { '$ref': 'B' }, 
//          c: { '$ref': 'C' } 
//       },
//       '$id': 'T'
//     }
//   },
//   '$ref': 'T' // entry
// }

type T = Static<typeof T>

// type T = {
//   a: boolean;
//   b: string;
//   c: number;
// }

---

I'm not sure if the above would be exactly ideal for your use case (combining FromSchema with Module is somewhat arcane, but possible). Users who need $defs schematics often opt to manually construct them which may prove easier to manage and offer the most flexibility. As noted in the comment, the Module type is more orientated towards computed referential types than it is pure $defs representation. The layout of the definitions is fixed (by design) and may not be suitable for all cases.

If you can provide a bit more insight into what you need, or how you need to layout the definitions, I may be able to provide some additional help.

Let me know
S

[jrabausch]

Hi @sinclairzx81 this is perfect!
Thank you for the fast and detailed response.

Our primary use case is to convert multiple JSON schemas into the TypeBox representation, combine / modify them and then generate the TypeScript types to be used in Monaco editor. Something like:

const ReturnType = Type.Object({
 field1: FromSchema(output1Schema),
 field2: FromSchema(output2Schema)
 // ...
});
// GenerateTypes is my modified version of ModelToTypeScript.GenerateType
const tsTypes = GenerateTypes(ReturnType);

The crucial part for us is, to be able to parse JSON schemas with (recursive) refs.
I also have to think about a way to handle refs like #/$defs/schema for the TypeScript types.

Greetings