@nmtjs/type 0.2.0 → 0.3.0

package/src/types/custom.ts

@@ -1,53 +1,90 @@
-import { type TTransform, type TUnsafe, Type } from '@sinclair/typebox'
+import {
+  type SchemaOptions,
+  type TTransform,
+  type TUnsafe,
+  Type,
+} from '@sinclair/typebox'
 import { BaseType } from './base.ts'
 
+type CustomDecode<T> = (value: any) => T
+type CustomEncode<T> = (value: T) => any
+
 export class CustomType<
   T,
   S = T,
   N extends boolean = false,
   O extends boolean = false,
-> extends BaseType<TTransform<TUnsafe<S>, T>, N, O> {
+  D extends boolean = false,
+> extends BaseType<TTransform<TUnsafe<S>, T>, N, O, D> {
   constructor(
-    protected readonly decode: (value: any) => T,
-    protected readonly encode: (value: T) => any,
-    nullable: N = false as N,
-    optional: O = false as O,
+    protected readonly decode: CustomDecode<T>,
+    protected readonly encode: CustomEncode<T>,
+    options: SchemaOptions = {},
+    isNullable: N = false as N,
+    isOptional: O = false as O,
+    hasDefault: D = false as D,
   ) {
-    super(
-      Type.Optional(
-        Type.Transform(Type.Any() as unknown as TUnsafe<S>)
-          .Decode(decode)
-          .Encode(encode),
-      ),
-      nullable,
-      optional,
-    )
+    super(options, isNullable, isOptional, hasDefault, decode, encode)
+  }
+
+  protected _constructSchema(
+    options: SchemaOptions,
+    decode: CustomDecode<T>,
+    encode: CustomEncode<T>,
+  ): TTransform<TUnsafe<S>, T> {
+    return Type.Transform(Type.Any(options) as unknown as TUnsafe<S>)
+      .Decode(decode)
+      .Encode(encode)
   }
 
   nullable() {
-    const [_, ...args] = this._nullable()
-    return new CustomType<T, S, (typeof args)[0], (typeof args)[1]>(
+    return new CustomType<T, S, true, O, D>(
       this.decode,
       this.encode,
-      ...args,
+      ...this._with({ isNullable: true }),
     )
   }
 
   optional() {
-    const [_, ...args] = this._optional()
-    return new CustomType<T, S, (typeof args)[0], (typeof args)[1]>(
+    return new CustomType<T, S, N, true, D>(
       this.decode,
       this.encode,
-      ...args,
+      ...this._with({ isOptional: true }),
     )
   }
 
   nullish() {
-    const [_, ...args] = this._nullish()
-    return new CustomType<T, S, (typeof args)[0], (typeof args)[1]>(
+    return new CustomType<T, S, true, true, D>(
+      this.decode,
+      this.encode,
+      ...this._with({ isNullable: true, isOptional: true }),
+    )
+  }
+
+  default(value: T) {
+    return new CustomType<T, S, N, O, true>(
+      this.decode,
+      this.encode,
+      ...this._with({
+        options: { default: this.encode(value) },
+        hasDefault: true,
+      }),
+    )
+  }
+
+  description(description: string) {
+    return new CustomType<T, S, N, O, D>(
+      this.decode,
+      this.encode,
+      ...this._with({ options: { description } }),
+    )
+  }
+
+  examples(...examples: [T, ...T[]]) {
+    return new CustomType<T, S, N, O, D>(
       this.decode,
       this.encode,
-      ...args,
+      ...this._with({ options: { examples: examples.map(this.encode) } }),
     )
   }
 }

package/src/types/datetime.ts

@@ -1,60 +1,65 @@
-import { type TString, type TTransform, Type } from '@sinclair/typebox'
+import {
+  type SchemaOptions,
+  type StringOptions,
+  type TString,
+  type TTransform,
+  Type,
+} from '@sinclair/typebox'
 import { BaseType } from './base.ts'
 
+const decode = (value: any): Date => new Date(value)
+const encode = (value: Date): any => value.toISOString()
+
 export class DateType<
   N extends boolean = false,
   O extends boolean = false,
-> extends BaseType<TTransform<TString, Date>, N, O> {
+  D extends boolean = false,
+> extends BaseType<TTransform<TString, Date>, N, O, D, StringOptions> {
   constructor(
-    schema: TTransform<TString, Date> = Type.Transform(
-      Type.String({ format: 'date' }),
-    )
-      .Decode((value) => new Date(value))
-      .Encode((value) => value.toJSON()),
-    nullable: N = false as N,
-    optional: O = false as O,
+    options: SchemaOptions = {},
+    isNullable: N = false as N,
+    isOptional: O = false as O,
+    hasDefault: D = false as D,
   ) {
-    super(schema, nullable, optional)
+    super(options, isNullable, isOptional, hasDefault)
+  }
+
+  protected _constructSchema(
+    options: StringOptions,
+  ): TTransform<TString, Date> {
+    return Type.Transform(Type.String({ ...options, format: 'date-time' }))
+      .Decode(decode)
+      .Encode(encode)
   }
 
   nullable() {
-    return new DateType(...this._nullable())
+    return new DateType(...this._with({ isNullable: true }))
   }
 
   optional() {
-    return new DateType(...this._optional())
+    return new DateType(...this._with({ isOptional: true }))
   }
 
   nullish() {
-    return new DateType(...this._nullish())
+    return new DateType(...this._with({ isNullable: true, isOptional: true }))
   }
-}
 
-export class DateTimeType<
-  N extends boolean = false,
-  O extends boolean = false,
-> extends BaseType<TTransform<TString, Date>, N, O> {
-  constructor(
-    schema: TTransform<TString, Date> = Type.Transform(
-      Type.String({ format: 'date-time' }),
+  default(value: Date) {
+    return new DateType(
+      ...this._with({
+        options: { default: encode(value) },
+        hasDefault: true,
+      }),
     )
-      .Decode((value) => new Date(value))
-      .Encode((value) => value.toJSON()),
-    nullable: N = false as N,
-    optional: O = false as O,
-  ) {
-    super(schema, nullable, optional)
   }
 
-  nullable() {
-    return new DateTimeType(...this._nullable())
+  description(value: string) {
+    return new DateType(...this._with({ options: { description: value } }))
   }
 
-  optional() {
-    return new DateTimeType(...this._optional())
-  }
-
-  nullish() {
-    return new DateTimeType(...this._nullish())
+  examples(...values: [Date, ...Date[]]) {
+    return new DateType(
+      ...this._with({ options: { examples: values.map(encode) } }),
+    )
   }
 }

package/src/types/enum.ts

@@ -1,3 +1,4 @@
+import type { SchemaOptions } from '@sinclair/typebox'
 import type { TNativeEnum } from '../schemas/native-enum.ts'
 import { NativeEnum } from '../schemas/native-enum.ts'
 import { type TUnionEnum, UnionEnum } from '../schemas/union-enum.ts'
@@ -7,28 +8,56 @@ export class NativeEnumType<
   T extends { [K in string]: K } = { [K in string]: K },
   N extends boolean = false,
   O extends boolean = false,
-> extends BaseType<TNativeEnum<T>, N, O> {
+  D extends boolean = false,
+> extends BaseType<TNativeEnum<T>, N, O, D> {
   constructor(
     readonly values: T,
-    nullable: N = false as N,
-    optional: O = false as O,
+    options: SchemaOptions = {},
+    isNullable: N = false as N,
+    isOptional: O = false as O,
+    hasDefault: D = false as D,
   ) {
-    super(NativeEnum(values), nullable, optional)
+    super(options, isNullable, isOptional, hasDefault)
+  }
+
+  protected _constructSchema(options: SchemaOptions): TNativeEnum<T> {
+    return NativeEnum(this.values, options)
   }
 
   nullable() {
-    const [_, ...args] = this._nullable()
-    return new NativeEnumType(this.values, ...args)
+    return new NativeEnumType(this.values, ...this._with({ isNullable: true }))
   }
 
   optional() {
-    const [_, ...args] = this._optional()
-    return new NativeEnumType(this.values, ...args)
+    return new NativeEnumType(this.values, ...this._with({ isOptional: true }))
   }
 
   nullish() {
-    const [_, ...args] = this._nullish()
-    return new NativeEnumType(this.values, ...args)
+    return new NativeEnumType(
+      this.values,
+      ...this._with({ isNullable: true, isOptional: true }),
+    )
+  }
+
+  default(value: keyof T) {
+    return new NativeEnumType(
+      this.values,
+      ...this._with({ options: { default: value }, hasDefault: true }),
+    )
+  }
+
+  description(description: string) {
+    return new NativeEnumType(
+      this.values,
+      ...this._with({ options: { description } }),
+    )
+  }
+
+  examples(...examples: (keyof T)[]) {
+    return new NativeEnumType(
+      this.values,
+      ...this._with({ options: { examples } }),
+    )
   }
 }
 
@@ -36,27 +65,55 @@ export class EnumType<
   T extends (string | number)[],
   N extends boolean = false,
   O extends boolean = false,
-> extends BaseType<TUnionEnum<T>, N, O> {
+  D extends boolean = false,
+> extends BaseType<TUnionEnum<T>, N, O, D> {
   constructor(
-    readonly values: [...T],
-    nullable: N = false as N,
-    optional: O = false as O,
+    protected readonly values: [...T],
+    options: SchemaOptions = {},
+    isNullable: N = false as N,
+    isOptional: O = false as O,
+    hasDefault: D = false as D,
   ) {
-    super(UnionEnum(values), nullable, optional)
+    super(options, isNullable, isOptional, hasDefault, values)
+  }
+
+  protected _constructSchema(
+    options: SchemaOptions,
+    values: [...T],
+  ): TUnionEnum<T> {
+    return UnionEnum(values, options)
   }
 
   nullable() {
-    const [_, ...args] = this._nullable()
-    return new EnumType(this.values, ...args)
+    return new EnumType(this.values, ...this._with({ isNullable: true }))
   }
 
   optional() {
-    const [_, ...args] = this._optional()
-    return new EnumType(this.values, ...args)
+    return new EnumType(this.values, ...this._with({ isOptional: true }))
   }
 
   nullish() {
-    const [_, ...args] = this._nullish()
-    return new EnumType(this.values, ...args)
+    return new EnumType(
+      this.values,
+      ...this._with({ isNullable: true, isOptional: true }),
+    )
+  }
+
+  default(value: T[number]) {
+    return new EnumType(
+      this.values,
+      ...this._with({ options: { default: value }, hasDefault: true }),
+    )
+  }
+
+  description(description: string) {
+    return new EnumType(
+      this.values,
+      ...this._with({ options: { description } }),
+    )
+  }
+
+  examples(...examples: [T[number], ...T[number][]]) {
+    return new EnumType(this.values, ...this._with({ options: { examples } }))
   }
 }

package/src/types/literal.ts

@@ -1,31 +1,61 @@
-import { type TLiteral, type TLiteralValue, Type } from '@sinclair/typebox'
+import {
+  type SchemaOptions,
+  type TLiteral,
+  type TLiteralValue,
+  Type,
+} from '@sinclair/typebox'
 import { BaseType } from './base.ts'
 
 export class LiteralType<
   T extends TLiteralValue = TLiteralValue,
   N extends boolean = false,
   O extends boolean = false,
-> extends BaseType<TLiteral<T>, N, O> {
+  D extends boolean = false,
+> extends BaseType<TLiteral<T>, N, O, D> {
   constructor(
-    readonly value: T,
-    nullable: N = false as N,
-    optional: O = false as O,
+    protected readonly value: T,
+    options: SchemaOptions = {},
+    isNullable: N = false as N,
+    isOptional: O = false as O,
+    hasDefault: D = false as D,
   ) {
-    super(Type.Literal(value), nullable, optional)
+    super(options, isNullable, isOptional, hasDefault, value)
+  }
+
+  protected _constructSchema(options: SchemaOptions, value: T): TLiteral<T> {
+    return Type.Literal(value, options)
   }
 
   nullable() {
-    const [_, ...args] = this._nullable()
-    return new LiteralType(this.value, ...args)
+    return new LiteralType(this.value, this.options, true, this.isOptional)
   }
 
   optional() {
-    const [_, ...args] = this._optional()
-    return new LiteralType(this.value, ...args)
+    return new LiteralType(this.value, ...this._with({ isOptional: true }))
   }
 
   nullish() {
-    const [_, ...args] = this._nullish()
-    return new LiteralType(this.value, ...args)
+    return new LiteralType(
+      this.value,
+      ...this._with({ isNullable: true, isOptional: true }),
+    )
+  }
+
+  default(value: T = this.value) {
+    return new LiteralType(
+      this.value,
+      ...this._with({ options: { default: value }, hasDefault: true }),
+    )
+  }
+
+  description(description: string) {
+    return new LiteralType(
+      this.value,
+      ...this._with({ options: { description } }),
+    )
+  }
+
+  examples(...examples: [T, ...T[]]) {
+    return new LiteralType(this.value, ...this._with({ options: { examples } }))
   }
 }

package/src/types/never.ts

@@ -1,27 +1,40 @@
-import { type TNever, Type } from '@sinclair/typebox'
+import { type SchemaOptions, type TNever, Type } from '@sinclair/typebox'
 import { BaseType } from './base.ts'
 
 export class NeverType<
   N extends boolean = false,
   O extends boolean = false,
-> extends BaseType<TNever, N, O> {
-  constructor(
-    schema = Type.Never(),
-    nullable: N = false as N,
-    optional: O = false as O,
-  ) {
-    super(schema, nullable, optional)
+  D extends boolean = false,
+> extends BaseType<TNever, N, O, D> {
+  constructor(options: SchemaOptions = {}) {
+    super(options, false as N, false as O, false as D)
   }
 
-  nullable(): NeverType<true, O> {
+  protected _constructSchema(options: SchemaOptions): TNever {
+    return Type.Never(options)
+  }
+
+  nullable(): NeverType<true, O, D> {
     throw new Error('NeverType cannot be nullable')
   }
 
-  optional(): NeverType<N, true> {
+  optional(): NeverType<N, true, D> {
     throw new Error('NeverType cannot be optional')
   }
 
-  nullish(): NeverType<true, true> {
+  nullish(): NeverType<true, true, D> {
     throw new Error('NeverType cannot be nullish')
   }
+
+  default(): NeverType<N, O, true> {
+    throw new Error('NeverType cannot have a default value')
+  }
+
+  description(description: string): NeverType<N, O, D> {
+    return new NeverType({ ...this.options, description })
+  }
+
+  examples(): NeverType<N, O, D> {
+    throw new Error('NeverType cannot have examples')
+  }
 }