@nmtjs/type 0.7.0 → 0.7.2

package/src/index.ts

@@ -1,3 +1,4 @@
+import * as zod from '@zod/mini'
 import { AnyType } from './types/any.ts'
 import { ArrayType } from './types/array.ts'
 import type { BaseTypeAny } from './types/base.ts'
@@ -7,11 +8,7 @@ import { DateType } from './types/date.ts'
 import { EnumType } from './types/enum.ts'
 import { LiteralType } from './types/literal.ts'
 import { NeverType } from './types/never.ts'
-import {
-  // BigIntType,
-  IntegerType,
-  NumberType,
-} from './types/number.ts'
+import { BigIntType, IntegerType, NumberType } from './types/number.ts'
 import {
   extend,
   keyof,
@@ -29,6 +26,8 @@ import {
   UnionType,
 } from './types/union.ts'
 
+zod.config(zod.core.locales.en())
+
 export { NeemataTypeError } from './types/base.ts'
 export { BaseType, type BaseTypeAny } from './types/base.ts'
 export {
@@ -52,18 +51,18 @@ export {
 
 export namespace type {
   export namespace infer {
-    export type decoded<T extends BaseTypeAny<any>> =
-      T['decodedZodType']['_zod']['output']
-
-    export type encoded<T extends BaseTypeAny<any>> =
-      T['encodedZodType']['_zod']['output']
-
-    export namespace input {
-      export type decoded<T extends BaseTypeAny<any>> =
+    export namespace decoded {
+      export type input<T extends BaseTypeAny> =
         T['decodedZodType']['_zod']['input']
+      export type output<T extends BaseTypeAny> =
+        T['decodedZodType']['_zod']['output']
+    }
 
-      export type encoded<T extends BaseTypeAny<any>> =
+    export namespace encoded {
+      export type input<T extends BaseTypeAny> =
         T['encodedZodType']['_zod']['input']
+      export type output<T extends BaseTypeAny> =
+        T['encodedZodType']['_zod']['output']
     }
   }
 
@@ -72,7 +71,7 @@ export namespace type {
   export const string = StringType.factory
   export const number = NumberType.factory
   export const integer = IntegerType.factory
-  // export const bitint = BigIntType.factory
+  export const bitint = BigIntType.factory
   export const literal = LiteralType.factory
   export const enumeration = EnumType.factory
   export const date = DateType.factory
@@ -95,4 +94,4 @@ export namespace type {
   })
 }
 
-export { type as t }
+export { type as t, zod }

package/src/temporal.ts

@@ -8,13 +8,13 @@ import {
   ZonedDateTimeType,
 } from './types/temporal.ts'
 
-export const plainDate = PlainDateType
-export const plainDatetime = PlainDateTimeType
-export const plainTime = PlainTimeType
-export const zonedDatetime = ZonedDateTimeType
-export const duration = DurationType
-export const plainYearMonth = PlainYearMonthType
-export const plainMonthDay = PlainMonthDayType
+export const plainDate = PlainDateType.factory
+export const plainDatetime = PlainDateTimeType.factory
+export const plainTime = PlainTimeType.factory
+export const zonedDatetime = ZonedDateTimeType.factory
+export const duration = DurationType.factory
+export const plainYearMonth = PlainYearMonthType.factory
+export const plainMonthDay = PlainMonthDayType.factory
 
 export type {
   DurationType,

package/src/types/array.ts

@@ -13,28 +13,41 @@ type Check = core.CheckFn<any[]> | core.$ZodCheck<any[]>
 export class ArrayType<T extends BaseType = BaseType> extends BaseType<
   ZodMiniArray<T['encodedZodType']>,
   ZodMiniArray<T['decodedZodType']>,
-  { element: T; checks: Check[] }
+  { element: T }
 > {
   static factory<T extends BaseType>(element: T, ...checks: Check[]) {
     return new ArrayType<T>({
       encodedZodType: array(element.encodedZodType).check(...checks),
       decodedZodType: array(element.decodedZodType).check(...checks),
-      props: { element, checks },
+      params: { checks },
+      props: { element },
     })
   }
 
   min(value: number) {
     const check = minLength(value)
-    return ArrayType.factory<T>(this.props.element, ...this.props.checks, check)
+    return ArrayType.factory<T>(
+      this.props.element,
+      ...this.params.checks,
+      check,
+    )
   }
 
   max(value: number) {
     const check = maxLength(value)
-    return ArrayType.factory<T>(this.props.element, ...this.props.checks, check)
+    return ArrayType.factory<T>(
+      this.props.element,
+      ...this.params.checks,
+      check,
+    )
   }
 
   length(value: number) {
     const check = length(value)
-    return ArrayType.factory<T>(this.props.element, ...this.props.checks, check)
+    return ArrayType.factory<T>(
+      this.props.element,
+      ...this.params.checks,
+      check,
+    )
   }
 }

package/src/types/base.ts

@@ -7,6 +7,7 @@ import {
   type ZodMiniAny,
   type ZodMiniArray,
   type ZodMiniBoolean,
+  type ZodMiniCustom,
   type ZodMiniDefault,
   type ZodMiniEnum,
   type ZodMiniInterface,
@@ -26,7 +27,7 @@ import {
 
 export type PrimitiveValueType = string | number | boolean | null
 
-export type SimpleZodType =
+export type PrimitiveZodType =
   | ZodMiniNever
   | ZodMiniDefault
   | ZodMiniNullable
@@ -43,7 +44,8 @@ export type SimpleZodType =
   | ZodMiniIntersection
   | ZodMiniInterface
   | ZodMiniRecord
-  | ZodMiniPipe
+
+export type SimpleZodType = ZodMiniType
 
 export type ZodType = SimpleZodType | ZodMiniType
 
@@ -59,6 +61,7 @@ export type TypeMetadata<T = any> = {
 export type TypeParams = {
   encode?: (value: any) => any
   metadata?: TypeMetadata
+  checks: Array<core.CheckFn<any> | core.$ZodCheck<any>>
 }
 
 export type DefaultTypeParams = {
@@ -90,18 +93,18 @@ export abstract class BaseType<
     encodedZodType,
     decodedZodType = encodedZodType as unknown as DecodedZodType,
     props = {} as Props,
-    params = {} as TypeParams,
+    params = {} as Partial<TypeParams>,
   }: {
     encodedZodType: EncodedZodType
     decodedZodType?: DecodedZodType
     props?: Props
-    params?: TypeParams
+    params?: Partial<TypeParams>
   }) {
     this.encodedZodType = encodedZodType
     this.decodedZodType = decodedZodType
 
     this.props = props
-    this.params = params
+    this.params = Object.assign({ checks: [] }, params)
   }
 
   optional(): OptionalType<this> {

package/src/types/custom.ts

@@ -1,51 +1,62 @@
 import {
   any,
+  type core,
   custom,
   overwrite,
   pipe,
-  type ZodMiniAny,
-  type ZodMiniCustom,
   type ZodMiniPipe,
+  type ZodMiniType,
 } from '@zod/mini'
 import { BaseType, type SimpleZodType, type ZodType } from './base.ts'
 
-export type CustomTypeDecode<I, O> = (value: I) => O
-export type CustomTypeEncode<I, O> = (value: I) => O
-
+export type CustomTransformFn<I, O> = (value: I) => O
 export abstract class TransformType<
   Type,
-  EncodedType extends SimpleZodType = ZodMiniAny,
-  DecodedType extends ZodType = ZodMiniCustom<Type>,
-> extends BaseType<EncodedType, DecodedType> {}
+  EncodedType extends SimpleZodType = ZodMiniType<Type, Type>,
+  DecodedType extends ZodType = ZodMiniType<Type, Type>,
+> extends BaseType<
+  ZodMiniPipe<
+    ZodMiniType<DecodedType['_zod']['output'], DecodedType['_zod']['input']>,
+    EncodedType
+  >,
+  ZodMiniPipe<
+    EncodedType,
+    ZodMiniType<EncodedType['_zod']['output'], EncodedType['_zod']['input']>
+  >
+> {}
 
 export class CustomType<
   Type,
-  EncodedType extends SimpleZodType = ZodMiniAny,
-  DecodedType extends ZodType = ZodMiniCustom<Type, Type>,
-> extends BaseType<
-  ZodMiniPipe<DecodedType, EncodedType>,
-  ZodMiniPipe<EncodedType, DecodedType>
-> {
+  EncodedType extends SimpleZodType = ZodMiniType<Type, Type>,
+  DecodedType extends ZodType = ZodMiniType<Type, Type>,
+> extends TransformType<Type, EncodedType, DecodedType> {
   static factory<
     Type,
-    EncodedType extends SimpleZodType = ZodMiniAny,
-    DecodedType extends ZodType = ZodMiniCustom<Type>,
-  >(
-    decode: CustomTypeDecode<
-      EncodedType['_zod']['output'],
+    EncodedType extends SimpleZodType = ZodMiniType<Type, Type>,
+    DecodedType extends ZodType = ZodMiniType<Type, Type>,
+  >({
+    decode,
+    encode,
+    error,
+    type = any() as unknown as EncodedType,
+  }: {
+    decode: CustomTransformFn<
+      EncodedType['_zod']['input'],
       DecodedType['_zod']['output']
-    >,
-    encode: CustomTypeEncode<
-      DecodedType['_zod']['output'],
+    >
+    encode: CustomTransformFn<
+      DecodedType['_zod']['input'],
       EncodedType['_zod']['output']
-    >,
-    type: EncodedType = any() as unknown as EncodedType,
-  ) {
+    >
+    error?: string | core.$ZodErrorMap<core.$ZodIssueBase>
+    type?: EncodedType
+  }) {
     return new CustomType<Type, EncodedType, DecodedType>({
-      //@ts-expect-error
       encodedZodType: pipe(custom().check(overwrite(encode)), type),
-      //@ts-expect-error
-      decodedZodType: pipe(type, custom().check(overwrite(decode))),
+      decodedZodType: pipe(
+        type,
+        custom(undefined, { error }).check(overwrite(decode)),
+      ),
       params: { encode },
     })
   }

package/src/types/date.ts

@@ -1,15 +1,6 @@
-import {
-  date,
-  iso,
-  union,
-  type ZodMiniDate,
-  type ZodMiniUnion,
-} from '@zod/mini'
+import { iso, union, type ZodMiniUnion } from '@zod/mini'
 import { CustomType, TransformType } from './custom.ts'
 
-const decode = (value: string): Date => new Date(value)
-const encode = (value: Date): string => value.toISOString()
-
 export class DateType extends TransformType<
   Date,
   ZodMiniUnion<[iso.ZodMiniISODate, iso.ZodMiniISODateTime]>
@@ -18,6 +9,10 @@ export class DateType extends TransformType<
     return CustomType.factory<
       Date,
       ZodMiniUnion<Array<iso.ZodMiniISODate | iso.ZodMiniISODateTime>>
-    >(decode, encode, union([iso.datetime(), iso.date()]))
+    >({
+      decode: (value: string): Date => new Date(value),
+      encode: (value: Date): string => value.toISOString(),
+      type: union([iso.datetime(), iso.date()]),
+    })
   }
 }

package/src/types/number.ts

@@ -6,45 +6,49 @@ import {
   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<
   ZodMiniNumber<number>,
-  ZodMiniNumber<number>,
-  { checks: Check[] }
+  ZodMiniNumber<number>
 > {
   static factory(...checks: Check[]) {
     return new NumberType({
       encodedZodType: number().check(...checks),
+      params: { checks },
     })
   }
 
   positive() {
-    return NumberType.factory(...this.props.checks, gte(0))
+    return NumberType.factory(...this.params.checks, gte(0))
   }
 
   negative() {
-    return NumberType.factory(...this.props.checks, lte(0))
+    return NumberType.factory(...this.params.checks, lte(0))
   }
 
   lt(value: number) {
-    return NumberType.factory(...this.props.checks, lt(value))
+    return NumberType.factory(...this.params.checks, lt(value))
   }
 
   lte(value: number) {
-    return NumberType.factory(...this.props.checks, lte(value))
+    return NumberType.factory(...this.params.checks, lte(value))
   }
 
   gte(value: number) {
-    return NumberType.factory(...this.props.checks, gte(value))
+    return NumberType.factory(...this.params.checks, gte(value))
   }
 
   gt(value: number) {
-    return NumberType.factory(...this.props.checks, gt(value))
+    return NumberType.factory(...this.params.checks, gt(value))
   }
 }
 
@@ -53,3 +57,14 @@ export class IntegerType extends NumberType {
     return NumberType.factory(...checks, int())
   }
 }
+
+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

@@ -2,6 +2,7 @@ import {
   type core,
   object,
   record,
+  strictObject,
   type ZodMiniObject,
   type ZodMiniRecord,
 } from '@zod/mini'
@@ -14,8 +15,8 @@ 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<
-  ZodMiniObject<{ [K in keyof T]: T[K]['encodedZodType'] }>,
-  ZodMiniObject<{ [K in keyof T]: T[K]['decodedZodType'] }>,
+  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) {

package/src/types/string.ts

@@ -1,10 +1,16 @@
 import {
   type core,
+  cuid,
+  cuid2,
+  e164,
   email,
+  emoji,
   ipv4,
   ipv6,
+  jwt,
   maxLength,
   minLength,
+  nanoid,
   regex,
   string,
   url,
@@ -18,48 +24,71 @@ type Check = core.CheckFn<string> | core.$ZodCheck<string>
 
 export class StringType extends BaseType<
   ZodMiniString<string>,
-  ZodMiniString<string>,
-  { checks: Check[] }
+  ZodMiniString<string>
 > {
   static factory(...checks: Check[]) {
     return new StringType({
       encodedZodType: string().check(...checks),
-      props: { checks },
+      params: { checks },
     })
   }
 
   max(value: number) {
-    return StringType.factory(...this.props.checks, maxLength(value))
+    return StringType.factory(...this.params.checks, maxLength(value))
   }
 
   min(value: number) {
-    return StringType.factory(...this.props.checks, minLength(value))
+    return StringType.factory(...this.params.checks, minLength(value))
   }
 
   pattern(pattern: string | RegExp) {
     return StringType.factory(
-      ...this.props.checks,
+      ...this.params.checks,
       regex(typeof pattern === 'string' ? new RegExp(pattern) : pattern),
     )
   }
 
   email(options?: core.$ZodEmailParams) {
-    return StringType.factory(...this.props.checks, email(options))
+    return StringType.factory(...this.params.checks, email(options))
   }
 
   url(options?: core.$ZodURLParams) {
-    return StringType.factory(...this.props.checks, url(options))
+    return StringType.factory(...this.params.checks, url(options))
   }
 
   ipv4(options?: core.$ZodIPv4Params) {
-    return StringType.factory(...this.props.checks, ipv4(options))
+    return StringType.factory(...this.params.checks, ipv4(options))
   }
 
   ipv6(options?: core.$ZodIPv6Params) {
-    return StringType.factory(...this.props.checks, ipv6(options))
+    return StringType.factory(...this.params.checks, ipv6(options))
   }
 
   uuid(options?: core.$ZodUUIDParams) {
-    return StringType.factory(...this.props.checks, uuid(options))
+    return StringType.factory(...this.params.checks, uuid(options))
+  }
+
+  emoji(options?: core.$ZodEmojiParams) {
+    return StringType.factory(...this.params.checks, emoji(options))
+  }
+
+  nanoid(options?: core.$ZodNanoIDParams) {
+    return StringType.factory(...this.params.checks, nanoid(options))
+  }
+
+  cuid(options?: core.$ZodCUIDParams) {
+    return StringType.factory(...this.params.checks, cuid(options))
+  }
+
+  cuid2(options?: core.$ZodCUID2Params) {
+    return StringType.factory(...this.params.checks, cuid2(options))
+  }
+
+  e164(options?: core.$ZodE164Params) {
+    return StringType.factory(...this.params.checks, e164(options))
+  }
+
+  jwt(options?: core.$ZodJWTParams) {
+    return StringType.factory(...this.params.checks, jwt(options))
   }
 }