Why is Nullable not a first class Type?

[lifeiscontent]

just curious, I see there's docs using Type.Unsafe but I don't understand why its not a part of TypeBox directly.

[sinclairzx81]

@lifeiscontent Hi,

The main reason TypeBox doesn't implement the nullable keyword is that it is not part of the Json Schema specification. I believe this keyword originated in the Swagger / OpenAPI specification (either in error or convenience to schema authors), but was never formally recognized by the Json Schema specification. TypeBox doesn't implement it for this reason.

As of OpenAPI 3.1 and onwards, they do advertise that they are aligned to the Json Schema Draft 2020-12 and have since deprecated nullable. Below is an excerpt from their 3.1 release announcement.

https://www.openapis.org/blog/2021/02/18/openapi-specification-3-1-released

The OpenAPI Initiative, the consortium of forward-looking industry experts focused on creating, evolving and promoting the OpenAPI Specification (OAS), a vendor-neutral, open description format for HTTP (including RESTful) APIs, announced today that the OpenAPI Specification 3.1.0 has been released. This new version now supports 100% compatibility with the latest draft (2020-12) of JSON Schema.

As for constructing nullable, the recommendation in TypeBox is to use Union (as is the case for TypeScript)

type T = string | null

const T = Type.Union([Type.String(), Type.Null()])

The Unsafe implementation should only really be used as a fallback if you are working with older versions of OpenAPI.

Hope this helps!
S

[sinclairzx81]

@lifeiscontent Heya,

Will close out this one as there isn't anything to action here. but happy to discuss more if you have any follow up questions.

As mentioned, the Nullable<T> type isn't planned due to not being spec compliant (in the OpenAPI case) and is not a core type as it is composition of T | null (as is the case for TypeScript). The project might introduce the NonNullable<T> type at some point as built in TS utility types are in scope.

https://www.typescriptlang.org/docs/handbook/utility-types.html#nonnullabletype

Cheers
S

[lifeiscontent]

@sinclairzx81 sorry, I guess I'm wondering why typebox doesn't implement Type.Nullable as

function Nullable<T extends TSchema>(T: T) { return Type.Union([T, Type.Null()]) }

[sinclairzx81]

@lifeiscontent Ah, my mistake. Usually when I'm asked about Nullable<T> it's often related to generating OpenAPI schematics :)

I guess I'm wondering why typebox doesn't implement Type.Nullable as

Mostly because there isn't a equivalent Nullable<T> type in TypeScript (also that the interpretation as to what Nullable means may vary (as in the case for OpenAPI), but also in TypeScript (where it can also mean undefined)).

A general goal of TypeBox is to emulate the TypeScript type system as closely as possible such that types written in one system can be translated to the other. Adding types above and beyond TypeScript may cause ambiguity when approaching domains like code translation....for example, should the code at the link below generate a TB Type.Nullable or the users TS implementation of it?

https://sinclairzx81.github.io/typebox-workbench/?share=dHlwZSBOdWxsYWJsZTxUPiA9IFQgfCBudWxsCgp0eXBlIFQgPSBOdWxsYWJsZTxzdHJpbmc%2B

Increasing alignment is a ongoing long term goal of the TypeBox project.

---

These are the main reasons why it's not implemented. However if TypeScript was to implement a Nullable utility type, TypeBox would implement it also to keep alignment.

Hope this brings some insight :)
Cheers
S