@nmtjs/type 0.2.1 → 0.3.0

package/src/types/number.ts

@@ -1,124 +1,160 @@
-import { type TInteger, type TNumber, Type } from '@sinclair/typebox'
+import {
+  type IntegerOptions,
+  type NumberOptions,
+  type TInteger,
+  type TNumber,
+  Type,
+} from '@sinclair/typebox'
 import { BaseType } from './base.ts'
 
 export class NumberType<
   N extends boolean = false,
   O extends boolean = false,
-> extends BaseType<TNumber, N, O> {
+  D extends boolean = false,
+> extends BaseType<TNumber, N, O, D, NumberOptions> {
   constructor(
-    schema: TNumber = Type.Number(),
-    nullable: N = false as N,
-    optional: O = false as O,
+    protected readonly options: NumberOptions = {},
+    isNullable: N = false as N,
+    isOptional: O = false as O,
+    hasDefault: D = false as D,
   ) {
-    super(schema, nullable, optional)
+    super(options, isNullable, isOptional, hasDefault)
   }
 
-  positive() {
+  protected _constructSchema(options: NumberOptions): TNumber {
+    return Type.Number(options)
+  }
+
+  nullable() {
+    return new NumberType(...this._with({ isNullable: true }))
+  }
+
+  optional() {
+    return new NumberType(...this._with({ isOptional: true }))
+  }
+
+  nullish() {
+    return new NumberType(...this._with({ isNullable: true, isOptional: true }))
+  }
+
+  default(value: number) {
     return new NumberType(
-      Type.Number({ ...this._schema, minimum: 0, exclusiveMinimum: 0 }),
-      ...this._isNullableOptional,
+      ...this._with({ options: { default: value }, hasDefault: true }),
     )
   }
 
+  description(description: string) {
+    return new NumberType(...this._with({ options: { description } }))
+  }
+
+  examples(...examples: [number, ...number[]]) {
+    return new NumberType(...this._with({ options: { examples } }))
+  }
+
+  positive() {
+    return this.min(0, true)
+  }
+
   negative() {
-    return new NumberType(
-      Type.Number({ ...this._schema, maximum: 0, exclusiveMaximum: 0 }),
-      ...this._isNullableOptional,
-    )
+    return this.max(0, true)
   }
 
   max(value: number, exclusive?: true) {
     return new NumberType(
-      Type.Number({
-        ...this._schema,
-        maximum: value,
-        ...(exclusive ? {} : { exclusiveMaximum: value }),
+      ...this._with({
+        options: {
+          maximum: value,
+          ...(exclusive ? {} : { exclusiveMaximum: value }),
+        },
       }),
-      ...this._isNullableOptional,
     )
   }
 
   min(value: number, exclusive?: true) {
     return new NumberType(
-      Type.Number({
-        ...this._schema,
-        minimum: value,
-        ...(exclusive ? {} : { exclusiveMinimum: value }),
+      ...this._with({
+        options: {
+          minimum: value,
+          ...(exclusive ? {} : { exclusiveMinimum: value }),
+        },
       }),
-      ...this._isNullableOptional,
     )
   }
+}
+
+export class IntegerType<
+  N extends boolean = false,
+  O extends boolean = false,
+  D extends boolean = false,
+> extends BaseType<TInteger, N, O, D, IntegerOptions> {
+  constructor(
+    options: IntegerOptions = {},
+    isNullable: N = false as N,
+    isOptional: O = false as O,
+    hasDefault: D = false as D,
+  ) {
+    super(options, isNullable, isOptional, hasDefault)
+  }
+
+  protected _constructSchema(options: IntegerOptions): TInteger {
+    return Type.Integer(options)
+  }
 
   nullable() {
-    return new NumberType(...this._nullable())
+    return new IntegerType(...this._with({ isNullable: true }))
   }
 
   optional() {
-    return new NumberType(...this._optional())
+    return new IntegerType(...this._with({ isOptional: true }))
   }
 
   nullish() {
-    return new NumberType(...this._nullish())
+    return new IntegerType(
+      ...this._with({ isNullable: true, isOptional: true }),
+    )
   }
-}
 
-export class IntegerType<
-  N extends boolean = false,
-  O extends boolean = false,
-> extends BaseType<TInteger, N, O> {
-  constructor(
-    schema: TInteger = Type.Integer(),
-    nullable: N = false as N,
-    optional: O = false as O,
-  ) {
-    super(schema, nullable, optional)
+  default(value: number) {
+    return new IntegerType(
+      ...this._with({ options: { default: value }, hasDefault: true }),
+    )
+  }
+
+  description(description: string) {
+    return new IntegerType(...this._with({ options: { description } }))
+  }
+
+  examples(...examples: [number, ...number[]]) {
+    return new IntegerType(...this._with({ options: { examples } }))
   }
 
   positive() {
-    return new IntegerType(
-      Type.Integer({ ...this._schema, minimum: 0, exclusiveMinimum: 0 }),
-      ...this._isNullableOptional,
-    )
+    return this.min(0, true)
   }
 
   negative() {
-    return new IntegerType(
-      Type.Integer({ ...this._schema, maximum: 0, exclusiveMaximum: 0 }),
-      ...this._isNullableOptional,
-    )
+    return this.max(0, true)
   }
 
   max(value: number, exclusive?: true) {
     return new IntegerType(
-      Type.Integer({
-        ...this._schema,
-        maximum: value,
-        ...(exclusive ? {} : { exclusiveMaximum: value }),
+      ...this._with({
+        options: {
+          maximum: value,
+          ...(exclusive ? {} : { exclusiveMaximum: value }),
+        },
       }),
-      ...this._isNullableOptional,
     )
   }
 
   min(value: number, exclusive?: true) {
     return new IntegerType(
-      Type.Integer({
-        ...this._schema,
-        minimum: value,
-        ...(exclusive ? {} : { exclusiveMinimum: value }),
+      ...this._with({
+        options: {
+          minimum: value,
+          ...(exclusive ? {} : { exclusiveMinimum: value }),
+        },
       }),
-      ...this._isNullableOptional,
     )
   }
-
-  nullable() {
-    return new IntegerType(...this._nullable())
-  }
-
-  optional() {
-    return new IntegerType(...this._optional())
-  }
-
-  nullish() {
-    return new IntegerType(...this._nullish())
-  }
 }

package/src/types/object.ts

@@ -1,55 +1,97 @@
-import { type TObject, Type } from '@sinclair/typebox'
+import {
+  type ObjectOptions,
+  type StaticEncode,
+  type TObject,
+  Type,
+} from '@sinclair/typebox'
+import type { typeStatic } from '../constants.ts'
 import type { UnionToTupleString } from '../utils.ts'
-import { BaseType, typeFinalSchema } from './base.ts'
+import { BaseType, getTypeSchema } from './base.ts'
 import { EnumType } from './enum.ts'
 
 export class ObjectType<
   T extends Record<string, BaseType> = Record<string, BaseType>,
   N extends boolean = false,
   O extends boolean = false,
-> extends BaseType<TObject<{ [K in keyof T]: T[K][typeFinalSchema] }>, N, O> {
+  D extends boolean = false,
+> extends BaseType<
+  TObject<{ [K in keyof T]: T[K][typeStatic]['schema'] }>,
+  N,
+  O,
+  D
+> {
   constructor(
-    readonly properties: T = {} as T,
-    nullable: N = false as N,
-    optional: O = false as O,
+    protected readonly properties: T = {} as T,
+    options: ObjectOptions = {},
+    isNullable: N = false as N,
+    isOptional: O = false as O,
+    hasDefault: D = false as D,
   ) {
-    const schemaProperties = Object.fromEntries(
-      Object.entries(properties).map(([key, value]) => [
-        key,
-        value[typeFinalSchema],
-      ]),
-    )
-    super(
-      Type.Object(
-        schemaProperties as { [K in keyof T]: T[K][typeFinalSchema] },
-      ),
-      nullable,
-      optional,
-    )
+    super(options, isNullable, isOptional, hasDefault, properties)
+  }
+
+  protected _constructSchema(
+    options: ObjectOptions,
+    properties: T,
+  ): TObject<{ [K in keyof T]: T[K][typeStatic]['schema'] }> {
+    const schemaProperties = {} as {
+      [K in keyof T]: T[K][typeStatic]['schema']
+    }
+
+    for (const [key, value] of Object.entries(properties)) {
+      // @ts-expect-error
+      schemaProperties[key] = getTypeSchema(value)
+    }
+    return Type.Object(schemaProperties, options)
   }
 
   nullable() {
-    const [_, ...args] = this._nullable()
-    return new ObjectType(this.properties, ...args)
+    return new ObjectType(this.properties, ...this._with({ isNullable: true }))
   }
 
   optional() {
-    const [_, ...args] = this._optional()
-    return new ObjectType(this.properties, ...args)
+    return new ObjectType(this.properties, ...this._with({ isOptional: true }))
   }
 
   nullish() {
-    const [_, ...args] = this._nullish()
-    return new ObjectType(this.properties, ...args)
+    return new ObjectType(
+      this.properties,
+      ...this._with({ isNullable: true, isOptional: true }),
+    )
+  }
+
+  default(value: this[typeStatic]['encoded']) {
+    return new ObjectType(
+      this.properties,
+      ...this._with({ options: { default: value }, hasDefault: true }),
+    )
+  }
+
+  description(description: string) {
+    return new ObjectType(
+      this.properties,
+      ...this._with({ options: { description } }),
+    )
+  }
+
+  examples(
+    ...examples: [this[typeStatic]['encoded'], ...this[typeStatic]['encoded'][]]
+  ) {
+    return new ObjectType(
+      this.properties,
+      ...this._with({ options: { examples } }),
+    )
   }
 
   pick<P extends { [K in keyof T]?: true }>(pick: P) {
     const properties = Object.fromEntries(
       Object.entries(this.properties).filter(([key]) => pick[key]),
     )
+    const [_, ...args] = this._with()
     return new ObjectType(
       properties as Pick<T, Extract<keyof P, keyof T>>,
-      ...this._isNullableOptional,
+      {},
+      ...args,
     )
   }
 
@@ -57,26 +99,39 @@ export class ObjectType<
     const properties = Object.fromEntries(
       Object.entries(this.properties).filter(([key]) => !omit[key]),
     )
+    const [_, ...args] = this._with()
     return new ObjectType(
       properties as Omit<T, Extract<keyof P, keyof T>>,
-      ...this._isNullableOptional,
+      {},
+      ...args,
     )
   }
 
   extend<P extends Record<string, BaseType>>(properties: P) {
-    return new ObjectType(
-      { ...this.properties, ...properties },
-      ...this._isNullableOptional,
-    )
+    const [_, ...args] = this._with()
+    return new ObjectType({ ...this.properties, ...properties }, {}, ...args)
   }
 
   merge<T extends ObjectType>(object: T) {
+    const [_, ...args] = this._with()
     return new ObjectType(
       { ...this.properties, ...object.properties },
-      ...this._isNullableOptional,
+      {},
+      ...args,
     )
   }
 
+  partial() {
+    const properties: { [K in keyof T]: ReturnType<T[K]['optional']> } =
+      {} as any
+    for (const [key, value] of Object.entries(this.properties)) {
+      // @ts-expect-error
+      properties[key] = value.optional()
+    }
+    const [_, ...args] = this._with()
+    return new ObjectType(properties, {}, ...args)
+  }
+
   keyof(): EnumType<UnionToTupleString<keyof T>> {
     return new EnumType(Object.keys(this.properties) as any)
   }

package/src/types/string.ts

@@ -1,67 +1,75 @@
-import { type TString, Type } from '@sinclair/typebox'
+import { type StringOptions, type TString, Type } from '@sinclair/typebox'
 import { BaseType } from './base.ts'
 
 export class StringType<
   N extends boolean = false,
   O extends boolean = false,
-> extends BaseType<TString, N, O> {
+  D extends boolean = false,
+> extends BaseType<TString, N, O, D, StringOptions> {
   constructor(
-    schema = Type.String(),
-    nullable: N = false as N,
-    optional: O = false as O,
+    options: StringOptions = {},
+    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): TString {
+    return Type.String(options)
   }
 
   nullable() {
-    return new StringType(...this._nullable())
+    return new StringType(...this._with({ isNullable: true }))
   }
 
   optional() {
-    return new StringType(...this._optional())
+    return new StringType(...this._with({ isOptional: true }))
   }
 
   nullish() {
-    return new StringType(...this._nullish())
+    return new StringType(...this._with({ isNullable: true, isOptional: true }))
   }
 
-  format(format: TString['format']) {
+  default(value: string) {
     return new StringType(
-      {
-        ...this._schema,
-        format,
-      },
-      ...this._isNullableOptional,
+      ...this._with({ options: { default: value }, hasDefault: true }),
     )
   }
 
+  description(description: string) {
+    return new StringType(...this._with({ options: { description } }))
+  }
+
+  examples(...examples: string[]) {
+    return new StringType(...this._with({ options: { examples } }))
+  }
+
+  format(format: TString['format']) {
+    return new StringType(...this._with({ options: { format } }))
+  }
+
   max(value: number) {
     return new StringType(
-      {
-        ...this._schema,
-        maxLength: value,
-      },
-      ...this._isNullableOptional,
+      ...this._with({
+        options: { maxLength: value },
+      }),
     )
   }
 
   min(value: number) {
     return new StringType(
-      {
-        ...this._schema,
-        minLength: value,
-      },
-      ...this._isNullableOptional,
+      ...this._with({
+        options: { minLength: value },
+      }),
     )
   }
 
   pattern(pattern: string) {
     return new StringType(
-      {
-        ...this._schema,
-        pattern,
-      },
-      ...this._isNullableOptional,
+      ...this._with({
+        options: { pattern },
+      }),
     )
   }