Add a type generic to typescript build for document type

[Liam-Tait]

Prerequisites

• I have written a descriptive issue title
• I have searched existing issues to ensure the feature has not already been requested

🚀 Feature Proposal

Add a generic Document to the build function, in particular when built with an build.ObjectSchema.

This can be done with in a non breaking way which defaults to the current approach.
Something like:

declare function build<Document extends object = object>(schema: build.ObjectSchema, options?: build.Options): (doc: Document) => string;

Motivation

This would add an additional layer of safety when in typescript when using the stringify function with data, ensuring all required fields are available.

For my particular use case, I am using typebox so my code would end up looking like:

const ExampleSchema = Type.Static(
  Type.Object({
    foo: Type.String(),
    bar: Type.String(),
  })
)
type Example = Static<typeof ExampleSchema>
const stringifyExample = fastJson<Example>(ExampleSchema)

Example

import fastJson from 'fast-json-stringify'

interface Example {
  foo: string
  bar: string
}

const schema = {
  title: 'Example Schema with required field',
  type: 'object',
  properties: {
    foo: { type: 'string' },
    bar: { type: 'string' }
  },
  required: ['foo', 'bar']
}

const stringify = fastJson<Example>(schema)

// This would be ok 
stringify({ foo: 'Foo', bar: 'Bar' })

// This would be error at compile time 
stringify({ foo: 'Foo' })

[DanieleFedeli]

I can pick this up.

I think it is better to infer the type from the schema, but for doing that I have to add another dependency to the project.

Quick demo:

[Liam-Tait]

I think it is better to infer the type from the schema

I don't think the implementation should tie to a specific library.
Typebox, json-schema-to-ts, and json-schema-to-typescript are all tools used with fastify and documented for json schema usage, with others supported as well as long as json schema is created by the tool

Tying the solution to one library makes it less usable for the others.
The TypeProvider concept could be used here too, but seems overlay complex to add for this case.

Adding a generic would allow usage of any typescript json schema library or manual typing

json-schema-to-ts

const exampleSchema = {
  properties: { foo: { type: 'string'} },
  required: ['foo'],
} as const

type Example = FromSchema<typeof exampleSchema>

build<Example>(exampleSchema)

typebox

const exampleSchema = Type.Static(
  Type.Object({
    foo: Type.String(),
  })
)
type Example = Static<typeof exampleSchema>

build<Example>(exampleSchema)

plain js + manual typing

const exampleSchema = {
  properties: { foo: { type: 'string'} },
  required: ['foo'],
}

interface Example {
  foo: string
}

build<Example>(exampleSchema)

zod + zod-to-json-schema

const exampleSchema = z.object({foo: z.string()});
type Example = z.infer<typeof exampleSchema>;
const jsonSchema = zodToJsonSchema(exampleSchema)
build<Example>(exampleSchema)

json-schema-to-typescript
schemas/example.json

{
  "properties": {
    "foo": { "type": "string"} 
  },
  "required": ["foo"],
}

import ExampleSchema from './schemas/example.json'
import { ExampleSchema as Example } from './types/example'
build<Example>(ExampleSchema)

[DanieleFedeli]

I agree with the fact that the user can insert manually a generic, we can provide both approaches, I am not ok with removing the automatic infer since at the very end, the user is going to input a JSONSchema so having that by default without any effort would be great and enhances the developer experience

[DanieleFedeli]

Can we close this?