@nmtjs/type 0.6.5 → 0.7.1

package/src/types/date.ts

@@ -1,22 +1,18 @@
-import { type TString, Type } from '@sinclair/typebox'
+import { iso, union, type ZodMiniUnion } from '@zod/mini'
 import { CustomType, TransformType } from './custom.ts'
 
-const decode = (value: any): Date => new Date(value)
-const encode = (value: Date): any => value.toISOString()
-
-export class DateType extends TransformType<Date> {
+export class DateType extends TransformType<
+  Date,
+  ZodMiniUnion<[iso.ZodMiniISODate, iso.ZodMiniISODateTime]>
+> {
   static factory() {
-    return CustomType.factory<Date, TString>(
-      decode,
-      encode,
-      Type.Union([
-        Type.String({
-          format: 'date',
-        }),
-        Type.String({
-          format: 'date-time',
-        }),
-      ]) as unknown as TString,
-    )
+    return CustomType.factory<
+      Date,
+      ZodMiniUnion<Array<iso.ZodMiniISODate | iso.ZodMiniISODateTime>>
+    >({
+      decode: (value: string): Date => new Date(value),
+      encode: (value: Date): string => value.toISOString(),
+      type: union([iso.datetime(), iso.date()]),
+    })
   }
 }

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,70 @@
 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,
+  regex,
+  string,
+  type ZodMiniNumber,
+  type ZodMiniString,
+} from '@zod/mini'
 import { BaseType } from './base.ts'
+import { CustomType, TransformType } from './custom.ts'
+
+type Check = core.CheckFn<number> | core.$ZodCheck<number>
 
 export class NumberType extends BaseType<
-  TNumber,
-  { options: NumberOptions },
-  number
+  ZodMiniNumber<number>,
+  ZodMiniNumber<number>
 > {
-  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),
+      params: { 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.params.checks, gte(0))
   }
 
   negative() {
-    return this.max(0, true)
+    return NumberType.factory(...this.params.checks, lte(0))
   }
 
-  max(value: number, exclusive?: true) {
-    return IntegerType.factory({
-      ...this.props.options,
-      maximum: value,
-      ...(!exclusive ? {} : { exclusiveMaximum: value }),
-    })
+  lt(value: number) {
+    return NumberType.factory(...this.params.checks, lt(value))
   }
 
-  min(value: number, exclusive?: true) {
-    return IntegerType.factory({
-      ...this.props.options,
-      minimum: value,
-      ...(!exclusive ? {} : { exclusiveMinimum: value }),
-    })
+  lte(value: number) {
+    return NumberType.factory(...this.params.checks, lte(value))
   }
-}
 
-// 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}` },
-    )
+  gte(value: number) {
+    return NumberType.factory(...this.params.checks, gte(value))
   }
 
-  positive() {
-    return this.min(0n, true)
-  }
-
-  negative() {
-    return this.max(0n, true)
+  gt(value: number) {
+    return NumberType.factory(...this.params.checks, gt(value))
   }
+}
 
-  max(value: bigint, exclusive?: true) {
-    return BigIntType.factory({
-      ...this.props.options,
-      maximum: value,
-      ...(!exclusive ? {} : { exclusiveMaximum: value }),
-    })
+export class IntegerType extends NumberType {
+  static factory(...checks: Check[]) {
+    return NumberType.factory(...checks, int())
   }
+}
 
-  min(value: bigint, exclusive?: true) {
-    return BigIntType.factory({
-      ...this.props.options,
-      minimum: value,
-      ...(!exclusive ? {} : { exclusiveMinimum: value }),
+export class BigIntType extends TransformType<bigint, ZodMiniString<string>> {
+  static factory() {
+    return CustomType.factory<bigint, ZodMiniString<string>>({
+      decode: (value) => BigInt(value),
+      encode: (value) => value.toString(),
+      type: string().check(regex(/^-?\d+$/)),
+      error: 'Invalid bigint format',
     })
   }
 }

package/src/types/object.ts

@@ -1,64 +1,74 @@
 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,
+  strictObject,
+  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 +149,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 +157,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,94 @@
-import { type StringOptions, type TString, Type } from '@sinclair/typebox'
-import type { StaticOutputDecode } from '../inference.ts'
+import {
+  type core,
+  cuid,
+  cuid2,
+  e164,
+  email,
+  emoji,
+  ipv4,
+  ipv6,
+  jwt,
+  maxLength,
+  minLength,
+  nanoid,
+  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>
 > {
-  static factory(options: StringOptions = {}) {
-    return new StringType(Type.String(options), { options })
+  static factory(...checks: Check[]) {
+    return new StringType({
+      encodedZodType: string().check(...checks),
+      params: { checks },
+    })
   }
 
   max(value: number) {
-    return StringType.factory({
-      ...this.props.options,
-      maxLength: value,
-    })
+    return StringType.factory(...this.params.checks, maxLength(value))
   }
 
   min(value: number) {
-    return StringType.factory({
-      ...this.props.options,
-      minLength: value,
-    })
+    return StringType.factory(...this.params.checks, minLength(value))
   }
 
-  format(format: TString['format']) {
-    return StringType.factory({
-      ...this.props.options,
-      pattern: undefined,
-      format,
-    })
+  pattern(pattern: string | RegExp) {
+    return StringType.factory(
+      ...this.params.checks,
+      regex(typeof pattern === 'string' ? new RegExp(pattern) : pattern),
+    )
   }
 
-  pattern(pattern: string) {
-    return StringType.factory({
-      ...this.props.options,
-      format: undefined,
-      pattern,
-    })
+  email(options?: core.$ZodEmailParams) {
+    return StringType.factory(...this.params.checks, email(options))
+  }
+
+  url(options?: core.$ZodURLParams) {
+    return StringType.factory(...this.params.checks, url(options))
+  }
+
+  ipv4(options?: core.$ZodIPv4Params) {
+    return StringType.factory(...this.params.checks, ipv4(options))
+  }
+
+  ipv6(options?: core.$ZodIPv6Params) {
+    return StringType.factory(...this.params.checks, ipv6(options))
+  }
+
+  uuid(options?: core.$ZodUUIDParams) {
+    return StringType.factory(...this.params.checks, uuid(options))
+  }
+
+  emoji(options?: core.$ZodEmojiParams) {
+    return StringType.factory(...this.params.checks, emoji(options))
   }
 
-  email() {
-    return this.format('email')
+  nanoid(options?: core.$ZodNanoIDParams) {
+    return StringType.factory(...this.params.checks, nanoid(options))
   }
 
-  url() {
-    return this.format('uri')
+  cuid(options?: core.$ZodCUIDParams) {
+    return StringType.factory(...this.params.checks, cuid(options))
   }
 
-  ipv4() {
-    return this.format('ipv4')
+  cuid2(options?: core.$ZodCUID2Params) {
+    return StringType.factory(...this.params.checks, cuid2(options))
   }
 
-  ipv6() {
-    return this.format('ipv6')
+  e164(options?: core.$ZodE164Params) {
+    return StringType.factory(...this.params.checks, e164(options))
   }
 
-  uuid() {
-    return this.format('uuid')
+  jwt(options?: core.$ZodJWTParams) {
+    return StringType.factory(...this.params.checks, jwt(options))
   }
 }