@nmtjs/type 0.6.4 → 0.7.0

package/src/types/enum.ts

@@ -1,27 +1,17 @@
-import { type TEnum, Type } from '@sinclair/typebox'
+import { type core, enum as enum_, type ZodMiniEnum } from '@zod/mini'
 import { BaseType } from './base.ts'
 
-export class ObjectEnumType<
-  T extends { [K in string]: K } = { [K in string]: K },
-> extends BaseType<TEnum<T>, { values: T[keyof T] }, T[keyof T]> {
-  static factory<T extends { [K in string]: K }>(values: T) {
-    return new ObjectEnumType<T>(Type.Enum(values as any), {
-      values: Object.values(values) as unknown as T[keyof T],
-    })
-  }
-}
-
 export class EnumType<
-  T extends (string | number)[] = (string | number)[],
-> extends BaseType<
-  TEnum<Record<string, T[number]>>,
-  { values: [...T] },
-  T[keyof T]
-> {
-  static factory<T extends (string | number)[]>(values: [...T]) {
-    return new EnumType<T>(
-      Type.Enum(Object.fromEntries(values.map((v) => [v, v])) as any),
-      { values },
-    )
+  T extends core.utils.EnumLike = core.utils.EnumLike,
+> extends BaseType<ZodMiniEnum<T>, ZodMiniEnum<T>, { values: T }> {
+  static factory<T extends core.utils.EnumLike>(values: T): EnumType<T>
+  static factory<T extends string[]>(
+    values: T,
+  ): EnumType<core.utils.ToEnum<T[number]>>
+  static factory<T extends core.utils.EnumLike | string[]>(values: T) {
+    return new EnumType({
+      encodedZodType: enum_(values as any),
+      props: { values },
+    })
   }
 }

package/src/types/literal.ts

@@ -1,10 +1,13 @@
-import { type TLiteral, type TLiteralValue, Type } from '@sinclair/typebox'
-import { BaseType } from './base.ts'
+import { literal, type ZodMiniLiteral } from '@zod/mini'
+import { BaseType, type PrimitiveValueType } from './base.ts'
 
 export class LiteralType<
-  T extends TLiteralValue = TLiteralValue,
-> extends BaseType<TLiteral<T>, { value: TLiteralValue }, T> {
-  static factory<T extends TLiteralValue>(value: T) {
-    return new LiteralType<T>(Type.Literal(value), { value })
+  T extends PrimitiveValueType = PrimitiveValueType,
+> extends BaseType<ZodMiniLiteral<T>, ZodMiniLiteral<T>, { value: T }> {
+  static factory<T extends PrimitiveValueType>(value: T) {
+    return new LiteralType<T>({
+      encodedZodType: literal(value),
+      props: { value },
+    })
   }
 }

package/src/types/never.ts

@@ -1,8 +1,10 @@
-import { type TNever, Type } from '@sinclair/typebox'
+import { never, type ZodMiniNever } from '@zod/mini'
 import { BaseType } from './base.ts'
 
-export class NeverType extends BaseType<TNever, {}, never> {
+export class NeverType extends BaseType<ZodMiniNever> {
   static factory() {
-    return new NeverType(Type.Never())
+    return new NeverType({
+      encodedZodType: never(),
+    })
   }
 }

package/src/types/number.ts

@@ -1,117 +1,55 @@
 import {
-  type BigIntOptions,
-  type IntegerOptions,
-  type NumberOptions,
-  type TBigInt,
-  type TInteger,
-  type TNumber,
-  Type,
-} from '@sinclair/typebox'
+  type core,
+  gt,
+  gte,
+  int,
+  lt,
+  lte,
+  number,
+  type ZodMiniNumber,
+} from '@zod/mini'
 import { BaseType } from './base.ts'
 
+type Check = core.CheckFn<number> | core.$ZodCheck<number>
+
 export class NumberType extends BaseType<
-  TNumber,
-  { options: NumberOptions },
-  number
+  ZodMiniNumber<number>,
+  ZodMiniNumber<number>,
+  { checks: Check[] }
 > {
-  static factory(options: NumberOptions = {}) {
-    return new NumberType(Type.Number(options), { options })
-  }
-
-  positive() {
-    return this.min(0, true)
-  }
-
-  negative() {
-    return this.max(0, true)
-  }
-
-  max(value: number, exclusive?: true) {
-    return NumberType.factory({
-      ...this.props.options,
-      maximum: value,
-      ...(!exclusive ? {} : { exclusiveMaximum: value }),
+  static factory(...checks: Check[]) {
+    return new NumberType({
+      encodedZodType: number().check(...checks),
     })
   }
 
-  min(value: number, exclusive?: true) {
-    return NumberType.factory({
-      ...this.props.options,
-      minimum: value,
-      ...(!exclusive ? {} : { exclusiveMinimum: value }),
-    })
-  }
-}
-
-export class IntegerType extends BaseType<
-  TInteger,
-  { options: IntegerOptions },
-  number
-> {
-  static factory(options: IntegerOptions = {}) {
-    return new IntegerType(Type.Integer(options), { options })
-  }
-
   positive() {
-    return this.min(0, true)
+    return NumberType.factory(...this.props.checks, gte(0))
   }
 
   negative() {
-    return this.max(0, true)
-  }
-
-  max(value: number, exclusive?: true) {
-    return IntegerType.factory({
-      ...this.props.options,
-      maximum: value,
-      ...(!exclusive ? {} : { exclusiveMaximum: value }),
-    })
-  }
-
-  min(value: number, exclusive?: true) {
-    return IntegerType.factory({
-      ...this.props.options,
-      minimum: value,
-      ...(!exclusive ? {} : { exclusiveMinimum: value }),
-    })
+    return NumberType.factory(...this.props.checks, lte(0))
   }
-}
 
-// TODO: this is not json schema compatible
-export class BigIntType extends BaseType<
-  TBigInt,
-  { options: BigIntOptions },
-  bigint
-> {
-  static factory(options: BigIntOptions = {}) {
-    return new BigIntType(
-      Type.BigInt(options),
-      { options },
-      { encode: (value) => `${value}` },
-    )
+  lt(value: number) {
+    return NumberType.factory(...this.props.checks, lt(value))
   }
 
-  positive() {
-    return this.min(0n, true)
+  lte(value: number) {
+    return NumberType.factory(...this.props.checks, lte(value))
   }
 
-  negative() {
-    return this.max(0n, true)
+  gte(value: number) {
+    return NumberType.factory(...this.props.checks, gte(value))
   }
 
-  max(value: bigint, exclusive?: true) {
-    return BigIntType.factory({
-      ...this.props.options,
-      maximum: value,
-      ...(!exclusive ? {} : { exclusiveMaximum: value }),
-    })
+  gt(value: number) {
+    return NumberType.factory(...this.props.checks, gt(value))
   }
+}
 
-  min(value: bigint, exclusive?: true) {
-    return BigIntType.factory({
-      ...this.props.options,
-      minimum: value,
-      ...(!exclusive ? {} : { exclusiveMinimum: value }),
-    })
+export class IntegerType extends NumberType {
+  static factory(...checks: Check[]) {
+    return NumberType.factory(...checks, int())
   }
 }

package/src/types/object.ts

@@ -1,64 +1,73 @@
 import {
-  type ObjectOptions,
-  type TObject,
-  type TRecordOrObject,
-  type TSchema,
-  Type,
-} from '@sinclair/typebox'
-import type { StaticInputDecode } from '../inference.ts'
-import type { UnionToTupleString } from '../utils.ts'
+  type core,
+  object,
+  record,
+  type ZodMiniObject,
+  type ZodMiniRecord,
+} from '@zod/mini'
+
 import { BaseType, type BaseTypeAny, type OptionalType } from './base.ts'
-import { EnumType, type ObjectEnumType } from './enum.ts'
+import { EnumType } from './enum.ts'
 import type { LiteralType } from './literal.ts'
 import type { StringType } from './string.ts'
 
 export type ObjectTypeProps = { [k: string]: BaseTypeAny }
 export type AnyObjectType = ObjectType<ObjectTypeProps>
 export class ObjectType<T extends ObjectTypeProps = {}> extends BaseType<
-  TObject<{ [K in keyof T]: T[K]['schema'] }>,
-  { properties: T },
-  StaticInputDecode<TObject<{ [K in keyof T]: T[K]['schema'] }>>
+  ZodMiniObject<{ [K in keyof T]: T[K]['encodedZodType'] }>,
+  ZodMiniObject<{ [K in keyof T]: T[K]['decodedZodType'] }>,
+  { properties: T }
 > {
-  static factory<T extends ObjectTypeProps = {}>(
-    properties: T,
-    options: ObjectOptions = {},
-  ) {
-    const schemaProperties = {} as {
-      [K in keyof T]: T[K]['schema']
+  static factory<T extends ObjectTypeProps = {}>(properties: T) {
+    const encodeProperties = {} as {
+      [K in keyof T]: T[K]['encodedZodType']
+    }
+    const decodeProperties = {} as {
+      [K in keyof T]: T[K]['decodedZodType']
     }
 
     for (const key in properties) {
-      schemaProperties[key] = properties[key].schema
+      encodeProperties[key] = properties[key].encodedZodType
+      decodeProperties[key] = properties[key].decodedZodType
     }
 
-    return new ObjectType<T>(Type.Object(schemaProperties, options) as any, {
-      properties,
+    return new ObjectType<T>({
+      encodedZodType: object(encodeProperties),
+      decodedZodType: object(decodeProperties),
+      props: { properties },
     })
   }
 }
 
 export class RecordType<
-  K extends LiteralType | EnumType | ObjectEnumType | StringType,
+  K extends LiteralType<string | number> | EnumType | StringType,
   E extends BaseType,
-> extends BaseType<TRecordOrObject<K['schema'], E['schema']>> {
+> extends BaseType<
+  ZodMiniRecord<K['encodedZodType'], E['encodedZodType']>,
+  ZodMiniRecord<K['decodedZodType'], E['decodedZodType']>
+> {
   static factory<
-    K extends
-      | LiteralType<any>
-      | EnumType<any>
-      | ObjectEnumType<any>
-      | StringType,
+    K extends LiteralType<string | number> | EnumType | StringType,
     E extends BaseType,
-  >(key: K, element: E, options: ObjectOptions = {}) {
-    return new RecordType<K, E>(
-      Type.Record(key.schema, element.schema, options) as any,
-    )
+  >(key: K, element: E) {
+    return new RecordType<K, E>({
+      encodedZodType: record(
+        (key as any).encodedZodType,
+        element.encodedZodType,
+      ),
+      decodedZodType: record(
+        (key as any).decodedZodType,
+        element.decodedZodType,
+      ),
+      props: { key, element },
+    })
   }
 }
 
 export function keyof<T extends ObjectType>(
   type: T,
 ): EnumType<
-  UnionToTupleString<T extends ObjectType<infer Props> ? keyof Props : never>
+  core.utils.ToEnum<Extract<keyof T['props']['properties'], string>>
 > {
   return EnumType.factory(Object.keys(type.props.properties) as any)
 }
@@ -139,9 +148,7 @@ export function partial<
 >(
   object: T,
 ): ObjectType<{
-  [K in keyof P]: P[K] extends BaseType<any, any, infer T>
-    ? OptionalType<P[K], T>
-    : never
+  [K in keyof P]: OptionalType<P[K]>
 }> {
   const properties = {} as any
 
@@ -149,5 +156,5 @@ export function partial<
     properties[key] = value.optional()
   }
 
-  return ObjectType.factory(properties, {}) as any
+  return ObjectType.factory(properties)
 }

package/src/types/string.ts

@@ -1,63 +1,65 @@
-import { type StringOptions, type TString, Type } from '@sinclair/typebox'
-import type { StaticOutputDecode } from '../inference.ts'
+import {
+  type core,
+  email,
+  ipv4,
+  ipv6,
+  maxLength,
+  minLength,
+  regex,
+  string,
+  url,
+  uuid,
+  type ZodMiniString,
+} from '@zod/mini'
+
 import { BaseType } from './base.ts'
 
+type Check = core.CheckFn<string> | core.$ZodCheck<string>
+
 export class StringType extends BaseType<
-  TString,
-  { options: StringOptions },
-  string
+  ZodMiniString<string>,
+  ZodMiniString<string>,
+  { checks: Check[] }
 > {
-  static factory(options: StringOptions = {}) {
-    return new StringType(Type.String(options), { options })
+  static factory(...checks: Check[]) {
+    return new StringType({
+      encodedZodType: string().check(...checks),
+      props: { checks },
+    })
   }
 
   max(value: number) {
-    return StringType.factory({
-      ...this.props.options,
-      maxLength: value,
-    })
+    return StringType.factory(...this.props.checks, maxLength(value))
   }
 
   min(value: number) {
-    return StringType.factory({
-      ...this.props.options,
-      minLength: value,
-    })
+    return StringType.factory(...this.props.checks, minLength(value))
   }
 
-  format(format: TString['format']) {
-    return StringType.factory({
-      ...this.props.options,
-      pattern: undefined,
-      format,
-    })
-  }
-
-  pattern(pattern: string) {
-    return StringType.factory({
-      ...this.props.options,
-      format: undefined,
-      pattern,
-    })
+  pattern(pattern: string | RegExp) {
+    return StringType.factory(
+      ...this.props.checks,
+      regex(typeof pattern === 'string' ? new RegExp(pattern) : pattern),
+    )
   }
 
-  email() {
-    return this.format('email')
+  email(options?: core.$ZodEmailParams) {
+    return StringType.factory(...this.props.checks, email(options))
   }
 
-  url() {
-    return this.format('uri')
+  url(options?: core.$ZodURLParams) {
+    return StringType.factory(...this.props.checks, url(options))
   }
 
-  ipv4() {
-    return this.format('ipv4')
+  ipv4(options?: core.$ZodIPv4Params) {
+    return StringType.factory(...this.props.checks, ipv4(options))
   }
 
-  ipv6() {
-    return this.format('ipv6')
+  ipv6(options?: core.$ZodIPv6Params) {
+    return StringType.factory(...this.props.checks, ipv6(options))
   }
 
-  uuid() {
-    return this.format('uuid')
+  uuid(options?: core.$ZodUUIDParams) {
+    return StringType.factory(...this.props.checks, uuid(options))
   }
 }

package/src/types/temporal.ts

@@ -1,4 +1,9 @@
-import { type TString, Type } from '@sinclair/typebox'
+import {
+  custom,
+  string,
+  type ZodMiniCustom,
+  type ZodMiniString,
+} from '@zod/mini'
 import { Temporal } from 'temporal-polyfill'
 import { CustomType, TransformType } from './custom.ts'
 
@@ -29,102 +34,137 @@ const createTemporalTransformer = <T extends Types>(
   } as TemporalTransformer<T>
 }
 
-export class PlainDateType extends TransformType<Temporal.PlainDate, TString> {
-  static readonly transformer = createTemporalTransformer('PlainDate')
+export class PlainDateType extends TransformType<
+  Temporal.PlainDate,
+  ZodMiniString
+> {
+  static transformer = createTemporalTransformer('PlainDate')
 
   static factory() {
-    return CustomType.factory(
+    return CustomType.factory<
+      Temporal.PlainDate,
+      ZodMiniString,
+      ZodMiniCustom<Temporal.PlainDate, Temporal.PlainDate>
+    >(
       PlainDateType.transformer.decode,
       PlainDateType.transformer.encode,
-      Type.String(),
+      string(),
     )
   }
 }
 
 export class PlainDateTimeType extends TransformType<
   Temporal.PlainDateTime,
-  TString
+  ZodMiniString
 > {
-  static readonly transformer = createTemporalTransformer('PlainDateTime')
-  protected _encode = PlainDateTimeType.transformer.encode
+  static transformer = createTemporalTransformer('PlainDateTime')
 
   static factory() {
-    return CustomType.factory(
+    return CustomType.factory<
+      Temporal.PlainDateTime,
+      ZodMiniString,
+      ZodMiniCustom<Temporal.PlainDateTime, Temporal.PlainDateTime>
+    >(
       PlainDateTimeType.transformer.decode,
       PlainDateTimeType.transformer.encode,
-      Type.String(),
+      string(),
     )
   }
 }
 
 export class ZonedDateTimeType extends TransformType<
   Temporal.ZonedDateTime,
-  TString
+  ZodMiniString
 > {
-  static readonly transformer = createTemporalTransformer(
-    'ZonedDateTime',
-    (value) => Temporal.Instant.from(value).toZonedDateTimeISO('UTC'),
+  static transformer = createTemporalTransformer('ZonedDateTime', (value) =>
+    Temporal.Instant.from(value).toZonedDateTimeISO('UTC'),
   )
 
   static factory() {
-    return CustomType.factory(
+    return CustomType.factory<
+      Temporal.ZonedDateTime,
+      ZodMiniString,
+      ZodMiniCustom<Temporal.ZonedDateTime, Temporal.ZonedDateTime>
+    >(
       ZonedDateTimeType.transformer.decode,
       ZonedDateTimeType.transformer.encode,
-      Type.String(),
+      string(),
     )
   }
 }
 
-export class PlainTimeType extends TransformType<Temporal.PlainTime, TString> {
-  static readonly transformer = createTemporalTransformer('PlainTime')
+export class PlainTimeType extends TransformType<
+  Temporal.PlainTime,
+  ZodMiniString
+> {
+  static transformer = createTemporalTransformer('PlainTime')
 
   static factory() {
-    return CustomType.factory(
+    return CustomType.factory<
+      Temporal.PlainTime,
+      ZodMiniString,
+      ZodMiniCustom<Temporal.PlainTime, Temporal.PlainTime>
+    >(
       PlainTimeType.transformer.decode,
       PlainTimeType.transformer.encode,
-      Type.String(),
+      string(),
     )
   }
 }
 
-export class DurationType extends TransformType<Temporal.Duration, TString> {
-  static readonly transformer = createTemporalTransformer('Duration')
+export class DurationType extends TransformType<
+  Temporal.Duration,
+  ZodMiniString
+> {
+  static transformer = createTemporalTransformer('Duration')
 
   static factory() {
-    return CustomType.factory(
+    return CustomType.factory<
+      Temporal.Duration,
+      ZodMiniString,
+      ZodMiniCustom<Temporal.Duration, Temporal.Duration>
+    >(
       DurationType.transformer.decode,
       DurationType.transformer.encode,
-      Type.String(),
+      string(),
     )
   }
 }
 
 export class PlainYearMonthType extends TransformType<
   Temporal.PlainYearMonth,
-  TString
+  ZodMiniString
 > {
-  static readonly transformer = createTemporalTransformer('PlainYearMonth')
+  static transformer = createTemporalTransformer('PlainYearMonth')
 
   static factory() {
-    return CustomType.factory(
+    return CustomType.factory<
+      Temporal.PlainYearMonth,
+      ZodMiniString,
+      ZodMiniCustom<Temporal.PlainYearMonth, Temporal.PlainYearMonth>
+    >(
       PlainYearMonthType.transformer.decode,
       PlainYearMonthType.transformer.encode,
-      Type.String(),
+      string(),
     )
   }
 }
 
 export class PlainMonthDayType extends TransformType<
   Temporal.PlainMonthDay,
-  TString
+  ZodMiniString
 > {
-  static readonly transformer = createTemporalTransformer('PlainMonthDay')
+  static transformer = createTemporalTransformer('PlainMonthDay')
 
   static factory() {
-    return CustomType.factory(
+    return CustomType.factory<
+      Temporal.PlainMonthDay,
+      ZodMiniString,
+      ZodMiniCustom<Temporal.PlainMonthDay, Temporal.PlainMonthDay>
+    >(
       PlainMonthDayType.transformer.decode,
       PlainMonthDayType.transformer.encode,
-      Type.String(),
+      string(),
     )
   }
 }