@nmtjs/type 0.14.5 → 0.15.0-beta.10

package/src/types/boolean.ts

@@ -0,0 +1,12 @@
+import type { ZodMiniBoolean } from 'zod/mini'
+import { boolean as zodBoolean } from 'zod/mini'
+
+import { BaseType } from './base.ts'
+
+export class BooleanType extends BaseType<ZodMiniBoolean<boolean>> {
+  static factory() {
+    return new BooleanType({ encodeZodType: zodBoolean() })
+  }
+}
+
+export const boolean = BooleanType.factory

package/src/types/custom.ts

@@ -0,0 +1,109 @@
+import type { Async } from '@nmtjs/common'
+import type { core, ZodMiniType } from 'zod/mini'
+import {
+  any,
+  overwrite,
+  pipe,
+  refine,
+  superRefine,
+  custom as zodCustom,
+} from 'zod/mini'
+
+import type { SimpleZodType, ZodType } from './base.ts'
+import { BaseType } from './base.ts'
+
+export type CustomTransformFn<I, O> = (value: I) => O
+export abstract class TransformType<
+  Type,
+  EncodeType extends SimpleZodType = ZodMiniType<Type, Type>,
+  DecodeType extends ZodType = ZodMiniType<Type, Type>,
+> extends BaseType<
+  ZodMiniType<EncodeType['_zod']['output'], DecodeType['_zod']['input']>,
+  ZodMiniType<DecodeType['_zod']['output'], EncodeType['_zod']['input']>
+> {}
+
+export class CustomType<
+  Type,
+  EncodeType extends SimpleZodType = ZodMiniType<Type, Type>,
+  DecodeType extends ZodType = ZodMiniType<Type, Type>,
+> extends TransformType<Type, EncodeType, DecodeType> {
+  static factory<
+    Type,
+    EncodeType extends SimpleZodType = ZodMiniType<Type, Type>,
+    DecodeType extends ZodType = ZodMiniType<Type, Type>,
+  >({
+    decode,
+    encode,
+    validation,
+    error,
+    type = any() as unknown as EncodeType,
+    prototype,
+  }: {
+    decode: CustomTransformFn<
+      EncodeType['_zod']['input'],
+      DecodeType['_zod']['output']
+    >
+    encode: CustomTransformFn<
+      DecodeType['_zod']['input'],
+      EncodeType['_zod']['output']
+    >
+    validation?:
+      | ((
+          value: EncodeType['_zod']['input'] | DecodeType['_zod']['output'],
+
+          payload: core.$RefinementCtx<
+            EncodeType['_zod']['output'] | DecodeType['_zod']['output']
+          >,
+        ) => Async<void>)
+      | {
+          encode?: (
+            value: EncodeType['_zod']['input'],
+            payload: core.$RefinementCtx<EncodeType['_zod']['output']>,
+          ) => Async<void>
+          decode?: (
+            value: DecodeType['_zod']['output'],
+            payload: core.$RefinementCtx<DecodeType['_zod']['output']>,
+          ) => Async<void>
+        }
+    error?: string | core.$ZodErrorMap<core.$ZodIssueBase>
+    type?: EncodeType
+    prototype?: object
+  }): CustomType<Type, EncodeType, DecodeType> {
+    const _validation = validation
+      ? typeof validation === 'function'
+        ? { encode: validation, decode: validation }
+        : validation
+      : undefined
+
+    const instance = new CustomType<Type, EncodeType, DecodeType>({
+      encodeZodType: pipe(
+        zodCustom().check(
+          ...[
+            refine((val) => typeof val !== 'undefined', { abort: true }),
+            _validation?.encode ? superRefine(_validation.encode) : undefined,
+            overwrite(encode),
+          ].filter((v) => !!v),
+        ),
+        type,
+      ),
+      decodeZodType: pipe(
+        type,
+        // @ts-expect-error
+        zodCustom().check(
+          ...[
+            refine((val) => typeof val !== 'undefined', { abort: true }),
+            overwrite(decode),
+            _validation?.decode ? superRefine(_validation.decode) : undefined,
+          ].filter((v) => !!v),
+        ),
+      ),
+      params: { encode },
+    })
+
+    if (prototype) Object.setPrototypeOf(instance, prototype)
+
+    return instance
+  }
+}
+
+export const custom = CustomType.factory

package/src/types/date.ts

@@ -0,0 +1,23 @@
+import type { ZodMiniUnion } from 'zod/mini'
+import { iso, union } from 'zod/mini'
+
+import { CustomType, TransformType } from './custom.ts'
+
+export class DateType extends TransformType<
+  Date,
+  ZodMiniUnion<[iso.ZodMiniISODate, iso.ZodMiniISODateTime]>
+> {
+  static factory(): DateType {
+    return CustomType.factory<
+      Date,
+      ZodMiniUnion<[iso.ZodMiniISODate, iso.ZodMiniISODateTime]>
+    >({
+      decode: (value) => new Date(value),
+      encode: (value) => value.toISOString(),
+      type: union([iso.date(), iso.datetime()]),
+      prototype: DateType.prototype,
+    })
+  }
+}
+
+export const date = DateType.factory

package/src/types/enum.ts

@@ -0,0 +1,23 @@
+import type { core, ZodMiniEnum } from 'zod/mini'
+import { enum as zodEnum } from 'zod/mini'
+
+import { BaseType } from './base.ts'
+
+export class EnumType<
+  T extends core.util.EnumLike = core.util.EnumLike,
+> extends BaseType<ZodMiniEnum<T>, ZodMiniEnum<T>, { values: T }> {
+  static factory<T extends core.util.EnumLike>(values: T): EnumType<T>
+  static factory<T extends string[]>(
+    values: T,
+  ): EnumType<core.util.ToEnum<T[number]>>
+  static factory<T extends core.util.EnumLike | string[]>(values: T) {
+    return new EnumType({
+      encodeZodType: zodEnum(values as any),
+      props: { values },
+    })
+  }
+}
+
+const _enum = EnumType.factory
+
+export { _enum as enum }

package/src/types/literal.ts

@@ -0,0 +1,18 @@
+import type { ZodMiniLiteral } from 'zod/mini'
+import { literal as zodLiteral } from 'zod/mini'
+
+import type { PrimitiveValueType } from './base.ts'
+import { BaseType } from './base.ts'
+
+export class LiteralType<
+  T extends PrimitiveValueType = PrimitiveValueType,
+> extends BaseType<ZodMiniLiteral<T>, ZodMiniLiteral<T>, { value: T }> {
+  static factory<T extends PrimitiveValueType>(value: T) {
+    return new LiteralType<T>({
+      encodeZodType: zodLiteral(value),
+      props: { value },
+    })
+  }
+}
+
+export const literal = LiteralType.factory

package/src/types/never.ts

@@ -0,0 +1,12 @@
+import type { ZodMiniNever } from 'zod/mini'
+import { never as zodNever } from 'zod/mini'
+
+import { BaseType } from './base.ts'
+
+export class NeverType extends BaseType<ZodMiniNever> {
+  static factory() {
+    return new NeverType({ encodeZodType: zodNever() })
+  }
+}
+
+export const never = NeverType.factory

package/src/types/null.ts

@@ -0,0 +1,14 @@
+import type { ZodMiniNull } from 'zod/mini'
+import { null as zodNull } from 'zod/mini'
+
+import { BaseType } from './base.ts'
+
+export class NullType extends BaseType<ZodMiniNull> {
+  static factory() {
+    return new NullType({ encodeZodType: zodNull() })
+  }
+}
+
+const _null = NullType.factory
+
+export { _null as null }

package/src/types/number.ts

@@ -0,0 +1,73 @@
+import type { core, ZodMiniNumber, ZodMiniString } from 'zod/mini'
+import {
+  gt,
+  gte,
+  int,
+  lt,
+  lte,
+  regex,
+  number as zodNumber,
+  string as zodString,
+} 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>
+> {
+  static factory(...checks: Check[]) {
+    return new NumberType({
+      encodeZodType: zodNumber().check(...checks),
+      params: { checks },
+    })
+  }
+
+  positive() {
+    return NumberType.factory(...this.params.checks, gte(0))
+  }
+
+  negative() {
+    return NumberType.factory(...this.params.checks, lte(0))
+  }
+
+  lt(value: number) {
+    return NumberType.factory(...this.params.checks, lt(value))
+  }
+
+  lte(value: number) {
+    return NumberType.factory(...this.params.checks, lte(value))
+  }
+
+  gte(value: number) {
+    return NumberType.factory(...this.params.checks, gte(value))
+  }
+
+  gt(value: number) {
+    return NumberType.factory(...this.params.checks, gt(value))
+  }
+}
+
+export class IntegerType extends NumberType {
+  static factory(...checks: Check[]) {
+    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: zodString().check(regex(/^-?\d+$/)),
+      error: 'Invalid bigint format',
+    })
+  }
+}
+
+export const number = NumberType.factory
+export const integer = IntegerType.factory
+export const bigInt = BigIntType.factory

package/src/types/object.ts

@@ -0,0 +1,225 @@
+import type { core, ZodMiniObject, ZodMiniRecord } from 'zod/mini'
+import {
+  looseObject as zodLooseObject,
+  object as zodObject,
+  record as zodRecord,
+} from 'zod/mini'
+
+import type { ZodPlainType } from './_utils.ts'
+import type { BaseTypeAny, OptionalType } from './base.ts'
+import type { LiteralType } from './literal.ts'
+import type { StringType } from './string.ts'
+import { zodPlainType } from './_utils.ts'
+import { BaseType } from './base.ts'
+import { EnumType } from './enum.ts'
+
+export type ObjectTypeProps = { [k: string]: BaseTypeAny }
+
+export class ObjectType<T extends ObjectTypeProps = {}> extends BaseType<
+  ZodMiniObject<{ [K in keyof T]: T[K]['encodeZodType'] }, core.$strip>,
+  ZodMiniObject<{ [K in keyof T]: T[K]['decodeZodType'] }, core.$strip>,
+  { properties: T },
+  ZodPlainType<
+    ZodMiniObject<{ [K in keyof T]: T[K]['encodeZodType'] }, core.$strip>
+  >,
+  ZodPlainType<
+    ZodMiniObject<{ [K in keyof T]: T[K]['decodeZodType'] }, core.$strip>
+  >
+> {
+  static factory<T extends ObjectTypeProps = {}>(properties: T) {
+    const encodeProperties = {} as {
+      [K in keyof T]: T[K]['encodeZodType']
+    }
+    const decodeProperties = {} as {
+      [K in keyof T]: T[K]['decodeZodType']
+    }
+
+    for (const key in properties) {
+      encodeProperties[key] = properties[key].encodeZodType
+      decodeProperties[key] = properties[key].decodeZodType
+    }
+
+    return new ObjectType<T>({
+      encodeZodType: zodObject(encodeProperties),
+      decodeZodType: zodObject(decodeProperties),
+      props: { properties },
+    })
+  }
+}
+
+export class LooseObjectType<T extends ObjectTypeProps = {}> extends BaseType<
+  ZodMiniObject<{ [K in keyof T]: T[K]['encodeZodType'] }, core.$loose>,
+  ZodMiniObject<{ [K in keyof T]: T[K]['decodeZodType'] }, core.$loose>,
+  { properties: T },
+  ZodPlainType<
+    ZodMiniObject<{ [K in keyof T]: T[K]['encodeZodType'] }, core.$loose>
+  >,
+  ZodPlainType<
+    ZodMiniObject<{ [K in keyof T]: T[K]['decodeZodType'] }, core.$loose>
+  >
+> {
+  static factory<T extends ObjectTypeProps = {}>(properties: T) {
+    const encodeProperties = {} as {
+      [K in keyof T]: T[K]['encodeZodType']
+    }
+    const decodeProperties = {} as {
+      [K in keyof T]: T[K]['decodeZodType']
+    }
+
+    for (const key in properties) {
+      encodeProperties[key] = properties[key].encodeZodType
+      decodeProperties[key] = properties[key].decodeZodType
+    }
+
+    return new LooseObjectType<T>({
+      encodeZodType: zodLooseObject(encodeProperties),
+      decodeZodType: zodLooseObject(decodeProperties),
+      props: { properties },
+    })
+  }
+}
+
+export type ObjectLikeType<T extends ObjectTypeProps> =
+  | ObjectType<T>
+  | LooseObjectType<T>
+
+export type AnyObjectType = ObjectType<ObjectTypeProps>
+export type AnyLooseObjectType = LooseObjectType<ObjectTypeProps>
+export type AnyObjectLikeType = AnyObjectType | AnyLooseObjectType
+
+export class RecordType<
+  K extends LiteralType<string | number> | EnumType | StringType,
+  E extends BaseType,
+> extends BaseType<
+  ZodMiniRecord<K['encodeZodType'], E['encodeZodType']>,
+  ZodMiniRecord<K['decodeZodType'], E['decodeZodType']>,
+  { key: K; element: E },
+  ZodPlainType<ZodMiniRecord<K['encodeZodType'], E['encodeZodType']>>,
+  ZodPlainType<ZodMiniRecord<K['decodeZodType'], E['decodeZodType']>>
+> {
+  static factory<
+    K extends LiteralType<string | number> | EnumType | StringType,
+    E extends BaseType,
+  >(key: K, element: E) {
+    return new RecordType<K, E>({
+      encodeZodType: zodPlainType(
+        zodRecord(key.encodeZodType, element.encodeZodType),
+      ),
+      decodeZodType: zodPlainType(
+        zodRecord(key.decodeZodType, element.decodeZodType),
+      ),
+      props: { key, element },
+    })
+  }
+}
+
+export type KeyofType<T extends AnyObjectLikeType> = EnumType<
+  core.util.ToEnum<Extract<keyof T['props']['properties'], string>>
+>
+
+export function keyof<T extends AnyObjectLikeType>(type: T): KeyofType<T> {
+  return EnumType.factory(Object.keys(type.props.properties) as any)
+}
+
+export type PickObjectType<
+  T extends AnyObjectLikeType,
+  P extends { [K in keyof T['props']['properties']]?: true },
+> = ObjectType<{
+  [K in keyof P]: P[K] extends true
+    ? K extends keyof T['props']['properties']
+      ? T['props']['properties'][K]
+      : never
+    : never
+}>
+export function pick<
+  T extends AnyObjectLikeType,
+  P extends { [K in keyof T['props']['properties']]?: true },
+>(source: T, pick: P): PickObjectType<T, P> {
+  const properties = Object.fromEntries(
+    Object.entries(source.props.properties).filter(([key]) => pick[key]),
+  )
+  return ObjectType.factory(properties) as any
+}
+
+export type OmitObjectType<
+  T extends AnyObjectLikeType,
+  P extends { [K in keyof T['props']['properties']]?: true },
+> = ObjectType<{
+  [K in keyof T['props']['properties'] as K extends keyof P
+    ? never
+    : K]: T['props']['properties'][K]
+}>
+export function omit<
+  T extends AnyObjectLikeType,
+  P extends { [K in keyof T['props']['properties']]?: true },
+>(source: T, omit: P): OmitObjectType<T, P> {
+  const properties = Object.fromEntries(
+    Object.entries(source.props.properties).filter(([key]) => !omit[key]),
+  )
+  return ObjectType.factory(properties) as any
+}
+
+export type ExtendObjectType<
+  T extends AnyObjectLikeType,
+  P extends ObjectTypeProps,
+> = ObjectType<{
+  [K in keyof T['props']['properties'] | keyof P]: K extends keyof P
+    ? P[K]
+    : K extends keyof T['props']['properties']
+      ? T['props']['properties'][K]
+      : never
+}>
+
+export function extend<T extends AnyObjectLikeType, P extends ObjectTypeProps>(
+  object1: T,
+  properties: P,
+): ExtendObjectType<T, P> {
+  return ObjectType.factory({
+    ...object1.props.properties,
+    ...properties,
+  }) as any
+}
+
+export type MergeObjectTypes<
+  T1 extends AnyObjectLikeType,
+  T2 extends AnyObjectLikeType,
+> = ObjectType<{
+  [K in
+    | keyof T1['props']['properties']
+    | keyof T2['props']['properties']]: K extends keyof T2['props']['properties']
+    ? T2['props']['properties'][K]
+    : K extends keyof T1['props']['properties']
+      ? T1['props']['properties'][K]
+      : never
+}>
+
+export function merge<
+  T1 extends AnyObjectLikeType,
+  T2 extends AnyObjectLikeType,
+>(object1: T1, object2: T2): MergeObjectTypes<T1, T2> {
+  return ObjectType.factory({
+    ...object1.props.properties,
+    ...object2.props.properties,
+  }) as any
+}
+
+export type PartialObjectType<T extends AnyObjectLikeType> = ObjectType<{
+  [K in keyof T['props']['properties']]: OptionalType<
+    T['props']['properties'][K]
+  >
+}>
+export function partial<T extends AnyObjectLikeType>(
+  object: T,
+): PartialObjectType<T> {
+  const properties = {} as any
+
+  for (const [key, value] of Object.entries(object.props.properties)) {
+    properties[key] = value.optional()
+  }
+
+  return ObjectType.factory(properties)
+}
+
+export const object = ObjectType.factory
+export const looseObject = LooseObjectType.factory
+export const record = RecordType.factory

package/src/types/string.ts

@@ -0,0 +1,95 @@
+import type { core, ZodMiniString } from 'zod/mini'
+import {
+  cuid,
+  cuid2,
+  e164,
+  email,
+  emoji,
+  ipv4,
+  ipv6,
+  jwt,
+  maxLength,
+  minLength,
+  nanoid,
+  regex,
+  url,
+  uuid,
+  string as zodString,
+} from 'zod/mini'
+
+import { BaseType } from './base.ts'
+
+type Check = core.CheckFn<string> | core.$ZodCheck<string>
+
+export class StringType extends BaseType<
+  ZodMiniString<string>,
+  ZodMiniString<string>
+> {
+  static factory(...checks: Check[]) {
+    return new StringType({
+      encodeZodType: zodString().check(...checks),
+      params: { checks },
+    })
+  }
+
+  max(value: number) {
+    return StringType.factory(...this.params.checks, maxLength(value))
+  }
+
+  min(value: number) {
+    return StringType.factory(...this.params.checks, minLength(value))
+  }
+
+  pattern(pattern: string | RegExp) {
+    return StringType.factory(
+      ...this.params.checks,
+      regex(typeof pattern === 'string' ? new RegExp(pattern) : 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))
+  }
+
+  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))
+  }
+}
+
+export const string = StringType.factory