@nmtjs/type 0.5.2 → 0.6.0

package/src/types/boolean.ts

@@ -1,14 +1,7 @@
-import {
-  type SchemaOptions,
-  type StaticDecode,
-  type TBoolean,
-  Type,
-} from '@sinclair/typebox'
-import { BaseType, type ConstantType } from './base.ts'
-
-export class BooleanType extends BaseType<TBoolean> {
-  _!: ConstantType<this['schema']>
+import { type TBoolean, Type } from '@sinclair/typebox'
+import { BaseType } from './base.ts'
 
+export class BooleanType extends BaseType<TBoolean, {}, boolean> {
   static factory() {
     return new BooleanType(Type.Boolean())
   }

package/src/types/custom.ts

@@ -1,30 +1,31 @@
 import {
   type TAny,
+  type TSchema,
   type TTransform,
-  type TUnsafe,
   Type,
 } from '@sinclair/typebox'
-import { BaseType, type ConstantType } from './base.ts'
+import type { StaticInputDecode, StaticOutputDecode } from '../inference.ts'
+import { BaseType } from './base.ts'
 
 export type CustomTypeDecode<T> = (value: any) => T
 export type CustomTypeEncode<T> = (value: T) => any
 
-export abstract class TransformType<T, S = TAny> extends BaseType<
-  TTransform<TUnsafe<S>, T>
-> {
-  _!: ConstantType<this['schema']>
-}
+export abstract class TransformType<
+  T,
+  S extends TSchema = TAny,
+> extends BaseType<TTransform<S, T>, {}, StaticInputDecode<TTransform<S, T>>> {}
 
-export class CustomType<T, S = TAny> extends TransformType<T, S> {
-  static factory<T, S = TAny>(
+export class CustomType<T, S extends TSchema = TAny> extends TransformType<
+  T,
+  S
+> {
+  static factory<T, S extends TSchema = TAny>(
     decode: CustomTypeDecode<T>,
     encode: CustomTypeEncode<T>,
-    schema = Type.Any() as unknown as TUnsafe<S>,
+    schema: S = Type.Any() as S,
   ) {
     return new CustomType<T, S>(
-      Type.Transform(schema as unknown as TUnsafe<S>)
-        .Decode(decode)
-        .Encode(encode),
+      Type.Transform(schema).Decode(decode).Encode(encode),
       {},
       { encode } as any,
     )

package/src/types/date.ts

@@ -1,3 +1,4 @@
+import { type TString, Type } from '@sinclair/typebox'
 import { CustomType, TransformType } from './custom.ts'
 
 const decode = (value: any): Date => new Date(value)
@@ -5,6 +6,17 @@ const encode = (value: Date): any => value.toISOString()
 
 export class DateType extends TransformType<Date> {
   static factory() {
-    return CustomType.factory<Date>(decode, encode)
+    return CustomType.factory<Date, TString>(
+      decode,
+      encode,
+      Type.Union([
+        Type.String({
+          format: 'date',
+        }),
+        Type.String({
+          format: 'date-time',
+        }),
+      ]) as unknown as TString,
+    )
   }
 }

package/src/types/enum.ts

@@ -1,30 +1,27 @@
-import {
-  Enum,
-  type SchemaOptions,
-  type StaticDecode,
-  type TEnum,
-  Type,
-} from '@sinclair/typebox'
-import { BaseType, type ConstantType } from './base.ts'
+import { type TEnum, Type } from '@sinclair/typebox'
+import { BaseType } from './base.ts'
 
 export class ObjectEnumType<
   T extends { [K in string]: K } = { [K in string]: K },
-> extends BaseType<TEnum<T>> {
-  _!: ConstantType<this['schema']>
-
+> 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))
+    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]>>> {
-  _!: ConstantType<this['schema']>
-
+> 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 },
     )
   }
 }

package/src/types/literal.ts

@@ -1,12 +1,10 @@
 import { type TLiteral, type TLiteralValue, Type } from '@sinclair/typebox'
-import { BaseType, type ConstantType } from './base.ts'
+import { BaseType } from './base.ts'
 
 export class LiteralType<
   T extends TLiteralValue = TLiteralValue,
-> extends BaseType<TLiteral<T>> {
-  _!: ConstantType<this['schema']>
-
+> extends BaseType<TLiteral<T>, { value: TLiteralValue }, T> {
   static factory<T extends TLiteralValue>(value: T) {
-    return new LiteralType<T>(Type.Literal(value))
+    return new LiteralType<T>(Type.Literal(value), { value })
   }
 }

package/src/types/never.ts

@@ -1,9 +1,7 @@
 import { type TNever, Type } from '@sinclair/typebox'
-import { BaseType, type ConstantType } from './base.ts'
-
-export class NeverType extends BaseType<TNever> {
-  _!: ConstantType<this['schema']>
+import { BaseType } from './base.ts'
 
+export class NeverType extends BaseType<TNever, {}, never> {
   static factory() {
     return new NeverType(Type.Never())
   }

package/src/types/number.ts

@@ -2,23 +2,18 @@ import {
   type BigIntOptions,
   type IntegerOptions,
   type NumberOptions,
-  type Static,
-  type StaticDecode,
-  type StringOptions,
   type TBigInt,
   type TInteger,
   type TNumber,
-  type TString,
-  type TTransform,
   Type,
-  TypeBoxError,
 } from '@sinclair/typebox'
-import { BaseType, type ConstantType } from './base.ts'
-import { CustomType, TransformType } from './custom.ts'
-
-export class NumberType extends BaseType<TNumber, { options: NumberOptions }> {
-  _!: ConstantType<this['schema']>
+import { BaseType } from './base.ts'
 
+export class NumberType extends BaseType<
+  TNumber,
+  { options: NumberOptions },
+  number
+> {
   static factory(options: NumberOptions = {}) {
     return new NumberType(Type.Number(options), { options })
   }
@@ -50,10 +45,9 @@ export class NumberType extends BaseType<TNumber, { options: NumberOptions }> {
 
 export class IntegerType extends BaseType<
   TInteger,
-  { options: IntegerOptions }
+  { options: IntegerOptions },
+  number
 > {
-  _!: ConstantType<this['schema']>
-
   static factory(options: IntegerOptions = {}) {
     return new IntegerType(Type.Integer(options), { options })
   }
@@ -84,11 +78,17 @@ export class IntegerType extends BaseType<
 }
 
 // TODO: this is not json schema compatible
-export class BigIntType extends BaseType<TBigInt, { options: BigIntOptions }> {
-  _!: ConstantType<this['schema']>
-
+export class BigIntType extends BaseType<
+  TBigInt,
+  { options: BigIntOptions },
+  bigint
+> {
   static factory(options: BigIntOptions = {}) {
-    return new BigIntType(Type.BigInt(options), { options })
+    return new BigIntType(
+      Type.BigInt(options),
+      { options },
+      { encode: (value) => `${value}` },
+    )
   }
 
   positive() {

package/src/types/object.ts

@@ -5,30 +5,21 @@ import {
   type TSchema,
   Type,
 } from '@sinclair/typebox'
-import { BaseType, type BaseTypeAny } from './base.ts'
-import type { EnumType, ObjectEnumType } from './enum.ts'
+import type { StaticInputDecode } from '../inference.ts'
+import type { UnionToTupleString } from '../utils.ts'
+import { BaseType, type BaseTypeAny, type OptionalType } from './base.ts'
+import { EnumType, type ObjectEnumType } from './enum.ts'
 import type { LiteralType } from './literal.ts'
 import type { StringType } from './string.ts'
 
-export type ObjectTypeProps = { [k: string]: BaseTypeAny<any> }
-export class ObjectType<
-  T extends ObjectTypeProps = ObjectTypeProps,
-> extends BaseType<
+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 }
+  { properties: T },
+  StaticInputDecode<TObject<{ [K in keyof T]: T[K]['schema'] }>>
 > {
-  declare _: {
-    encoded: {
-      input: TObject<{ [K in keyof T]: T[K]['_']['encoded']['input'] }>
-      output: TObject<{ [K in keyof T]: T[K]['_']['encoded']['output'] }>
-    }
-    decoded: {
-      input: TObject<{ [K in keyof T]: T[K]['_']['decoded']['input'] }>
-      output: TObject<{ [K in keyof T]: T[K]['_']['decoded']['output'] }>
-    }
-  }
-
-  static factory<T extends ObjectTypeProps = ObjectTypeProps>(
+  static factory<T extends ObjectTypeProps = {}>(
     properties: T,
     options: ObjectOptions = {},
   ) {
@@ -50,29 +41,6 @@ export class RecordType<
   K extends LiteralType | EnumType | ObjectEnumType | StringType,
   E extends BaseType,
 > extends BaseType<TRecordOrObject<K['schema'], E['schema']>> {
-  _!: {
-    encoded: {
-      input: TRecordOrObject<
-        K['_']['encoded']['input'],
-        E['_']['encoded']['input']
-      >
-      output: TRecordOrObject<
-        K['_']['encoded']['output'],
-        E['_']['encoded']['output']
-      >
-    }
-    decoded: {
-      input: TRecordOrObject<
-        K['_']['decoded']['input'],
-        E['_']['decoded']['input']
-      >
-      output: TRecordOrObject<
-        K['_']['decoded']['output'],
-        E['_']['decoded']['output']
-      >
-    }
-  }
-
   static factory<
     K extends
       | LiteralType<any>
@@ -86,3 +54,100 @@ export class RecordType<
     )
   }
 }
+
+export function keyof<T extends ObjectType>(
+  type: T,
+): EnumType<
+  UnionToTupleString<T extends ObjectType<infer Props> ? keyof Props : never>
+> {
+  return EnumType.factory(Object.keys(type.props.properties) as any)
+}
+
+export function pick<
+  T extends AnyObjectType,
+  P extends { [K in keyof T['props']['properties']]?: true },
+>(
+  source: T,
+  pick: P,
+): ObjectType<{
+  [K in keyof P]: P[K] extends true
+    ? K extends keyof T['props']['properties']
+      ? T['props']['properties'][K]
+      : never
+    : never
+}> {
+  const properties = Object.fromEntries(
+    Object.entries(source.props.properties).filter(([key]) => pick[key]),
+  )
+  return ObjectType.factory(properties) as any
+}
+
+export function omit<
+  T extends AnyObjectType,
+  P extends { [K in keyof T['props']['properties']]?: true },
+>(
+  source: T,
+  omit: P,
+): ObjectType<{
+  [K in keyof T['props']['properties'] as K extends keyof P
+    ? never
+    : K]: T['props']['properties'][K]
+}> {
+  const properties = Object.fromEntries(
+    Object.entries(source.props.properties).filter(([key]) => !omit[key]),
+  )
+  return ObjectType.factory(properties) as any
+}
+
+export function extend<T extends AnyObjectType, P extends ObjectTypeProps>(
+  object1: T,
+  properties: P,
+): 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
+}> {
+  return ObjectType.factory({
+    ...object1.props.properties,
+    ...properties,
+  }) as any
+}
+
+export function merge<T1 extends AnyObjectType, T2 extends AnyObjectType>(
+  object1: T1,
+  object2: T2,
+): 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
+}> {
+  return ObjectType.factory({
+    ...object1.props.properties,
+    ...object2.props.properties,
+  }) as any
+}
+
+export function partial<
+  T extends AnyObjectType,
+  P extends T extends ObjectType<infer Props> ? Props : never,
+>(
+  object: T,
+): ObjectType<{
+  [K in keyof P]: P[K] extends BaseType<any, any, infer T>
+    ? OptionalType<P[K], T>
+    : never
+}> {
+  const properties = {} as any
+
+  for (const [key, value] of Object.entries(object.props.properties)) {
+    properties[key] = value.optional()
+  }
+
+  return ObjectType.factory(properties, {}) as any
+}

package/src/types/string.ts

@@ -1,9 +1,12 @@
 import { type StringOptions, type TString, Type } from '@sinclair/typebox'
-import { BaseType, type ConstantType, type TypeParams } from './base.ts'
-
-export class StringType extends BaseType<TString, { options: StringOptions }> {
-  _!: ConstantType<TString>
-
+import type { StaticOutputDecode } from '../inference.ts'
+import { BaseType } from './base.ts'
+
+export class StringType extends BaseType<
+  TString,
+  { options: StringOptions },
+  string
+> {
   static factory(options: StringOptions = {}) {
     return new StringType(Type.String(options), { options })
   }

package/src/types/union.ts

@@ -1,57 +1,52 @@
 import {
   type TIntersect,
+  type TObject,
+  type TSchema,
   type TUnion,
   Type,
   type UnionToTuple,
 } from '@sinclair/typebox'
+import type { StaticInputDecode } from '../inference.ts'
 import {
   DiscriminatedUnion,
+  type DiscriminatedUnionProperties,
   type TDiscriminatedUnion,
 } from '../schemas/discriminated-union.ts'
 import { BaseType, type BaseTypeAny } from './base.ts'
-import type { LiteralType } from './literal.ts'
 import type { ObjectType, ObjectTypeProps } from './object.ts'
 
 export class UnionType<
   T extends readonly BaseType[] = readonly BaseType[],
-> extends BaseType<TUnion<UnionToTuple<T[number]['schema']>>> {
-  _!: {
-    encoded: {
-      input: TUnion<UnionToTuple<T[number]['_']['encoded']['input']>>
-      output: TUnion<UnionToTuple<T[number]['_']['encoded']['output']>>
-    }
-    decoded: {
-      input: TUnion<UnionToTuple<T[number]['_']['decoded']['input']>>
-      output: TUnion<UnionToTuple<T[number]['_']['decoded']['output']>>
-    }
-  }
-
-  static factory<T extends readonly BaseType[] = readonly BaseType[]>(
-    ...types: T
-  ) {
-    return new UnionType<T>(Type.Union(types.map((t) => t.schema)) as any)
+  S extends TSchema[] = UnionToTuple<T[number]['schema']>,
+> extends BaseType<TUnion<S>, { options: T }, StaticInputDecode<TUnion<S>>> {
+  static factory<
+    T extends readonly BaseType[] = readonly BaseType[],
+    S extends TSchema[] = UnionToTuple<T[number]['schema']>,
+  >(...options: T) {
+    return new UnionType<T, S>(
+      Type.Union(options.map((t) => t.schema)) as any,
+      {
+        options,
+      },
+    )
   }
 }
 
 export class IntersactionType<
   T extends readonly BaseType[] = readonly BaseType[],
-> extends BaseType<TIntersect<UnionToTuple<T[number]['schema']>>> {
-  _!: {
-    encoded: {
-      input: TIntersect<UnionToTuple<T[number]['_']['encoded']['input']>>
-      output: TIntersect<UnionToTuple<T[number]['_']['encoded']['output']>>
-    }
-    decoded: {
-      input: TIntersect<UnionToTuple<T[number]['_']['decoded']['input']>>
-      output: TIntersect<UnionToTuple<T[number]['_']['decoded']['output']>>
-    }
-  }
-
-  static factory<T extends readonly BaseType[] = readonly BaseType[]>(
-    ...types: T
-  ) {
-    return new IntersactionType<T>(
-      Type.Intersect(types.map((t) => t.schema)) as any,
+  S extends TSchema[] = UnionToTuple<T[number]['schema']>,
+> extends BaseType<
+  TIntersect<S>,
+  { options: T },
+  StaticInputDecode<TIntersect<S>>
+> {
+  static factory<
+    T extends readonly BaseType[] = readonly BaseType[],
+    S extends TSchema[] = UnionToTuple<T[number]['schema']>,
+  >(...options: T) {
+    return new IntersactionType<T, S>(
+      Type.Intersect(options.map((t) => t.schema)) as any,
+      { options },
     )
   }
 }
@@ -61,57 +56,27 @@ export type DiscriminatedUnionOptionType<K extends string> = ObjectType<
 >
 
 export class DiscriminatedUnionType<
-  K extends string,
-  T extends readonly [
-    DiscriminatedUnionOptionType<K>,
-    ...DiscriminatedUnionOptionType<K>[],
-  ],
+  K extends string = string,
+  T extends
+    readonly DiscriminatedUnionOptionType<K>[] = DiscriminatedUnionOptionType<K>[],
+  S extends TObject<DiscriminatedUnionProperties<K>>[] = [],
 > extends BaseType<
-  TDiscriminatedUnion<
-    K,
-    //@ts-expect-error
-    UnionToTuple<T[number]['schema']>
-  >,
+  TDiscriminatedUnion<K, S>,
   {
     key: K
     options: T
-  }
+  },
+  StaticInputDecode<TDiscriminatedUnion<K, S>>
 > {
-  _!: {
-    encoded: {
-      input: TDiscriminatedUnion<
-        K,
-        //@ts-expect-error
-        UnionToTuple<T[number]['_']['encoded']['input']>
-      >
-      output: TDiscriminatedUnion<
-        K,
-        //@ts-expect-error
-        UnionToTuple<T[number]['_']['encoded']['output']>
-      >
-    }
-    decoded: {
-      input: TDiscriminatedUnion<
-        K,
-        //@ts-expect-error
-        UnionToTuple<T[number]['_']['decoded']['input']>
-      >
-      output: TDiscriminatedUnion<
-        K,
-        //@ts-expect-error
-        UnionToTuple<T[number]['_']['decoded']['output']>
-      >
-    }
-  }
-
   static factory<
     K extends string,
-    T extends readonly [
-      DiscriminatedUnionOptionType<K>,
-      ...DiscriminatedUnionOptionType<K>[],
-    ],
+    T extends readonly DiscriminatedUnionOptionType<K>[],
+    //@ts-expect-error
+    S extends TObject<DiscriminatedUnionProperties<K>>[] = UnionToTuple<
+      T[number]['schema']
+    >,
   >(key: K, ...options: T) {
-    return new DiscriminatedUnionType<K, T>(
+    return new DiscriminatedUnionType<K, T, S>(
       DiscriminatedUnion(key, options.map((t) => t.schema) as any),
       { key, options },
     )