@sinclair/typebox 0.20.2 → 0.20.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.20.2",
+  "version": "0.20.6",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "json-schema",
@@ -23,14 +23,14 @@
     "test": "hammer task spec"
   },
   "devDependencies": {
-    "@sinclair/hammer": "^0.12.1",
+    "@sinclair/hammer": "^0.15.7",
     "@types/chai": "^4.2.16",
     "@types/mocha": "^8.2.2",
     "@types/node": "^14.14.37",
     "ajv": "^8.6.2",
     "ajv-formats": "^2.0.2",
     "chai": "^4.3.4",
-    "mocha": "^8.3.2",
-    "typescript": "^4.3.5"
+    "mocha": "^9.1.2",
+    "typescript": "^4.5.2"
   }
 }

package/readme.md

@@ -38,7 +38,7 @@ type T = Static<typeof T>   // type T = string
 
 ## Overview
 
-TypeBox is a library that creates in-memory JSON Schema objects that can be statically resolved to TypeScript types. The schemas produced by this library are designed to match the static type checking rules of the TypeScript compiler. TypeBox allows one to create a unified type that can be statically checked by the TypeScript compiler and runtime asserted using standard JSON Schema validation.
+TypeBox is a library that builds in-memory JSON Schema objects that can be statically resolved to TypeScript types. The schemas produced by this library are designed to match the static type checking rules of the TypeScript compiler. TypeBox allows one to create a unified type that can be statically checked by the TypeScript compiler and runtime asserted using standard JSON Schema validation.
 
 TypeBox can be used as a simple tool to build up complex schemas or integrated into RPC or REST services to help validate JSON data received over the wire. TypeBox does not provide any JSON schema validation. Please use libraries such as AJV to validate schemas built with this library.
 
@@ -59,6 +59,7 @@ License MIT
 - [Extended Types](#Extended-Types)
 - [Strict](#Strict)
 - [Validation](#Validation)
+- [OpenAPI](#OpenAPI)
 
 <a name="Example"></a>
 
@@ -307,7 +308,7 @@ The following table outlines the TypeBox mappings between TypeScript and JSON sc
 │          Type.Number()         │                             │     y: {                       │
 │       )                        │                             │        type: 'number'          │
 │    })                          │                             │     }                          │
-│ )                              │                             │   }                            │
+│ )                              │                             │   },                           │
 │                                │                             │   required: ['x', 'y']         │
 │                                │                             │ }                              │
 │   	                         │                             │                                │
@@ -383,7 +384,7 @@ TypeBox provides modifiers that can be applied to an objects properties. This al
 
 ### Options
 
-You can pass additional JSON schema properties on the last argument of any given type. The following are some examples.
+You can pass additional JSON schema options on the last argument of any given type. The following are some examples.
 
 ```typescript
 // string must be an email
@@ -695,25 +696,25 @@ Referenced types can be added to AJV with the `ajv.addSchema(...)` function. The
 ```typescript
 //--------------------------------------------------------------------------------------------
 //
-// Common Types
+// Shared Types
 //
 //--------------------------------------------------------------------------------------------
 
-const Common = Type.Box({
+const Shared = Type.Box({
   UserId: Type.String({ format: 'uuid' }),
   Email:  Type.String({ format: 'email' })
-}, { $id: 'Common' })
+}, { $id: 'Shared' })
 
 //--------------------------------------------------------------------------------------------
 //
-// Setup AJV validator with the following options and formats
+// Setup Validator and Register Shared Types
 //
 //--------------------------------------------------------------------------------------------
 
 const ajv = addFormats(new Ajv({}), [...])
   .addKeyword('kind')
   .addKeyword('modifier')
-  .addSchema(Common) // <-- Register Common Types
+  .addSchema(Shared) // <-- Register Shared Types
 
 //--------------------------------------------------------------------------------------------
 //
@@ -722,8 +723,8 @@ const ajv = addFormats(new Ajv({}), [...])
 //--------------------------------------------------------------------------------------------
 
 const User = Type.Object({
-  userId: Type.Ref(Common, 'UserId'),
-  email:  Type.Ref(Common, 'Email'),
+  userId: Type.Ref(Shared, 'UserId'),
+  email:  Type.Ref(Shared, 'Email'),
   online: Type.Boolean()
 }, { additionalProperties: false })
 
@@ -741,4 +742,47 @@ const ok = ajv.validate(User, {
 
 ```
 
-Please refer to the official AJV [documentation](https://ajv.js.org/guide/getting-started.html) for more information on using this validator.
+Please refer to the official AJV [documentation](https://ajv.js.org/guide/getting-started.html) for additional information.
+
+### OpenAPI
+
+TypeBox can be used to create schemas for OpenAPI, however users should be aware of the various differences between the JSON Schema and OpenAPI specifications. Two common instances where OpenAPI diverges from the JSON Schema specification is OpenAPI's handling of `string enum` and `nullable`. The following shows how you can use TypeBox to construct these types.
+
+```typescript
+import { Type, Static, TNull, TLiteral, TUnion, TSchema } from '@sinclair/typebox'
+
+//--------------------------------------------------------------------------------------------
+//
+// Nullable<T>
+//
+//--------------------------------------------------------------------------------------------
+
+function Nullable<T extends TSchema>(schema: T): TUnion<[T, TNull]> {
+    return { ...schema, nullable: true } as any
+}
+
+const T = Nullable(Type.String())        // const T = {
+                                         //   type: 'string',
+                                         //   nullable: true
+                                         // }
+
+type T = Static<typeof T>                // type T = string | null
+
+//--------------------------------------------------------------------------------------------
+//
+// StringUnion<[...]>
+//
+//--------------------------------------------------------------------------------------------
+
+type IntoStringUnion<T> = {[K in keyof T]: T[K] extends string ? TLiteral<T[K]>: never }
+
+function StringUnion<T extends string[]>(values: [...T]): TUnion<IntoStringUnion<T>> {
+    return { enum: values } as any
+}
+
+const T = StringUnion(['A', 'B', 'C'])   // const T = {
+                                         //    enum: ['A', 'B', 'C']
+                                         // }
+
+type T = Static<typeof T>                // type T = 'A' | 'B' | 'C'
+```

package/typebox.d.ts

@@ -60,10 +60,6 @@ export declare type NumberOptions = {
 export declare type IntersectOptions = {
     unevaluatedProperties?: boolean;
 } & CustomOptions;
-export declare type IndexedOptions = {
-    minProperties?: number;
-    maxProperties?: number;
-} & CustomOptions;
 export declare type ObjectOptions = {
     additionalProperties?: boolean;
 } & CustomOptions;
@@ -88,8 +84,8 @@ export declare type TBox<T extends TDefinitions> = {
 export declare type TTuple<T extends TSchema[]> = {
     kind: typeof TupleKind;
     type: 'array';
-    items: [...T];
-    additionalItems: false;
+    items?: [...T];
+    additionalItems?: false;
     minItems: number;
     maxItems: number;
 } & CustomOptions;
@@ -200,24 +196,24 @@ export declare type UnionToIntersect<U> = (U extends any ? (k: U) => void : neve
 export declare type ObjectPropertyKeys<T> = T extends TObject<infer U> ? PropertyKeys<U> : never;
 export declare type PropertyKeys<T extends TProperties> = keyof T;
 export declare type ReadonlyOptionalPropertyKeys<T extends TProperties> = {
-    [K in keyof T]: T[K] extends TReadonlyOptional<infer U> ? K : never;
+    [K in keyof T]: T[K] extends TReadonlyOptional<TSchema> ? K : never;
 }[keyof T];
 export declare type ReadonlyPropertyKeys<T extends TProperties> = {
-    [K in keyof T]: T[K] extends TReadonly<infer U> ? K : never;
+    [K in keyof T]: T[K] extends TReadonly<TSchema> ? K : never;
 }[keyof T];
 export declare type OptionalPropertyKeys<T extends TProperties> = {
-    [K in keyof T]: T[K] extends TOptional<infer U> ? K : never;
+    [K in keyof T]: T[K] extends TOptional<TSchema> ? K : never;
 }[keyof T];
 export declare type RequiredPropertyKeys<T extends TProperties> = keyof Omit<T, ReadonlyOptionalPropertyKeys<T> | ReadonlyPropertyKeys<T> | OptionalPropertyKeys<T>>;
 export declare type ReduceModifiers<T extends object> = {
     [K in keyof T]: T[K];
 };
 export declare type StaticModifiers<T extends TProperties> = {
-    readonly [K in ReadonlyOptionalPropertyKeys<T>]?: Static<T[K]>;
+    readonly [K in ReadonlyOptionalPropertyKeys<T>]?: T[K] extends TReadonlyOptional<infer U> ? Static<U> : never;
 } & {
-    readonly [K in ReadonlyPropertyKeys<T>]: Static<T[K]>;
+    readonly [K in ReadonlyPropertyKeys<T>]: T[K] extends TReadonly<infer U> ? Static<U> : never;
 } & {
-    [K in OptionalPropertyKeys<T>]?: Static<T[K]>;
+    [K in OptionalPropertyKeys<T>]?: T[K] extends TOptional<infer U> ? Static<U> : never;
 } & {
     [K in RequiredPropertyKeys<T>]: Static<T[K]>;
 };
@@ -240,12 +236,8 @@ export declare type StaticRecord<K extends TRecordKey, T extends TSchema> = K ex
 } : never : never;
 export declare type StaticArray<T extends TSchema> = Array<Static<T>>;
 export declare type StaticLiteral<T extends TValue> = T;
-export declare type StaticConstructor<T extends readonly TSchema[], U extends TSchema> = new (...args: [...{
-    [K in keyof T]: Static<T[K]>;
-}]) => Static<U>;
-export declare type StaticFunction<T extends readonly TSchema[], U extends TSchema> = (...args: [...{
-    [K in keyof T]: Static<T[K]>;
-}]) => Static<U>;
+export declare type StaticConstructor<T extends readonly TSchema[], U extends TSchema> = new (...args: unknown[]) => Static<U>;
+export declare type StaticFunction<T extends readonly TSchema[], U extends TSchema> = (...args: unknown[]) => Static<U>;
 export declare type StaticPromise<T extends TSchema> = Promise<Static<T>>;
 export declare type Static<T> = T extends TKeyOf<infer U> ? StaticKeyOf<U> : T extends TIntersect<infer U> ? StaticIntersect<U> : T extends TUnion<infer U> ? StaticUnion<U> : T extends TTuple<infer U> ? StaticTuple<U> : T extends TObject<infer U> ? StaticObject<U> : T extends TRecord<infer K, infer U> ? StaticRecord<K, U> : T extends TArray<infer U> ? StaticArray<U> : T extends TEnum<infer U> ? StaticEnum<U> : T extends TLiteral<infer U> ? StaticLiteral<U> : T extends TString ? string : T extends TNumber ? number : T extends TInteger ? number : T extends TBoolean ? boolean : T extends TNull ? null : T extends TUnknown ? unknown : T extends TAny ? any : T extends TConstructor<infer U, infer R> ? StaticConstructor<U, R> : T extends TFunction<infer U, infer R> ? StaticFunction<U, R> : T extends TPromise<infer U> ? StaticPromise<U> : T extends TUndefined ? undefined : T extends TVoid ? void : never;
 export declare class TypeBuilder {

package/typebox.js

@@ -99,7 +99,9 @@ class TypeBuilder {
         const additionalItems = false;
         const minItems = items.length;
         const maxItems = items.length;
-        return { ...options, kind: exports.TupleKind, type: 'array', items, additionalItems, minItems, maxItems };
+        return (items.length > 0)
+            ? { ...options, kind: exports.TupleKind, type: 'array', items, additionalItems, minItems, maxItems }
+            : { ...options, kind: exports.TupleKind, type: 'array', minItems, maxItems };
     }
     /** `STANDARD` Creates a `object` schema with the given properties. */
     Object(properties, options = {}) {