@nmtjs/type 0.5.3 → 0.6.0

package/src/compiler.ts

@@ -1,42 +1,39 @@
-import type { TSchema } from '@sinclair/typebox'
+import { TypeCompiler } from '@sinclair/typebox/compiler'
+import { TransformDecode, TransformEncode } from '@sinclair/typebox/value'
+import type {
+  StaticInputEncode,
+  StaticOutputDecode,
+  StaticOutputEncode,
+} from './inference.ts'
 import {
-  TypeCompiler,
-  type ValueErrorIterator,
-} from '@sinclair/typebox/compiler'
-import {
-  TransformDecode,
-  TransformEncode,
-  Value,
-} from '@sinclair/typebox/value'
-import type { t } from './index.ts'
-import { IsDiscriminatedUnion } from './schemas/discriminated-union.ts'
+  type CloneOptions,
+  type ValidationError,
+  _applyDefaults,
+  _parse,
+  _traversErrors,
+} from './runtime.ts'
 import type { BaseType } from './types/base.ts'
 
-type ValidationError = {
-  path: string
-  message: string
-  value: unknown
-}
-
 export type Compiled<T extends BaseType = BaseType> = {
-  check: (val: unknown) => boolean
+  check: (val: unknown) => val is StaticInputEncode<T['schema']>
   errors: (val: unknown) => ValidationError[]
-  parse: (val: unknown) => unknown
+  parse: (val: unknown, cloneOptions?: CloneOptions) => unknown
+  applyDefaults: (val: unknown) => unknown
   /**
    * Requires to `check` before calling
    */
-  decode: (val: unknown) => t.infer.decoded<T>
+  decode: (val: unknown) => StaticOutputDecode<T['schema']>
   /**
    * Requires to `check` before calling
    */
-  encode: (val: unknown) => t.infer.encoded<T>
+  encode: (val: unknown) => StaticOutputEncode<T['schema']>
   /**
    * Requires to `check` before calling
    */
   decodeSafe: (
     val: unknown,
   ) =>
-    | { success: true; value: t.infer.decoded<T> }
+    | { success: true; value: StaticOutputDecode<T['schema']> }
     | { success: false; error: any }
   /**
    * Requires to `check` before calling
@@ -44,88 +41,34 @@ export type Compiled<T extends BaseType = BaseType> = {
   encodeSafe: (
     val: unknown,
   ) =>
-    | { success: true; value: t.infer.encoded<T> }
+    | { success: true; value: StaticOutputEncode<T['schema']> }
     | { success: false; error: any }
 }
 
-// FIXME: this one is very slow
-function _parse(schema: TSchema, value: any) {
-  // Clone -> Clean -> Default -> Convert
-  return Value.Convert(
-    schema,
-    Value.Default(schema, Value.Clean(schema, Value.Clone(value))),
-  )
-}
-
-function _errors(errors: ValueErrorIterator) {
-  const result: ValidationError[] = []
-
-  for (const error of errors) {
-    if (IsDiscriminatedUnion(error.schema)) {
-      const discriminator = error.schema.discriminator
-      const discriminatorValue = error.value?.[discriminator]
-      if (discriminatorValue !== undefined) {
-        const variantSchema = error.schema.anyOf.find(
-          (schema) =>
-            schema.properties[discriminator].const === discriminatorValue,
-        )
-        if (variantSchema) {
-          const propertiesSchemas: TSchema[] = []
-          for (const element in variantSchema.properties) {
-            const propertySchema = variantSchema.properties[element]
-            if (propertySchema !== variantSchema.properties[discriminator]) {
-              propertiesSchemas.push(propertySchema)
-            }
-          }
-
-          for (const iter of error.errors) {
-            for (const err of iter) {
-              if (!propertiesSchemas.includes(err.schema)) continue
-              result.push({
-                path: err.path,
-                message: err.message,
-                value: err.value,
-              })
-            }
-          }
-
-          continue
-        }
-      }
-    }
-
-    result.push({
-      path: error.path,
-      message: error.message,
-      value: error.value,
-    })
-
-    for (const nestedError of error.errors) {
-      result.push(..._errors(nestedError))
-    }
-  }
-
-  return result
-}
-
 function compileType(type: BaseType) {
-  const { final: schema } = type
+  const { schema } = type
   const compiled = TypeCompiler.Compile(schema)
-  const errors = (value) => {
-    return _errors(compiled.Errors(value))
-  }
+
+  const check = (value: unknown) => compiled.Check(value)
+  const applyDefaults = (value: unknown) => _applyDefaults(schema, value)
+  const parse = (value: unknown, cloneOptions?: CloneOptions) =>
+    _parse(schema, value, cloneOptions)
+  const errors = (value: unknown) => _traversErrors(compiled.Errors(value))
+  const decode = TransformDecode.bind(null, schema, compiled.References())
+  const encode = TransformEncode.bind(null, schema, compiled.References())
 
   return {
-    check: compiled.Check.bind(compiled),
-    parse: _parse.bind(null, schema),
+    check,
+    parse,
     errors,
-    decode: TransformDecode.bind(null, schema, compiled.References()),
-    encode: TransformEncode.bind(null, schema, compiled.References()),
+    applyDefaults,
+    decode,
+    encode,
   }
 }
 
-export function compile<T extends BaseType>(schema: T): Compiled<T> {
-  const compiled = compileType(schema)
+export function compile<T extends BaseType>(type: T): Compiled<T> {
+  const compiled = compileType(type)
 
   function decodeSafe(val: unknown) {
     try {
@@ -155,31 +98,3 @@ export function compile<T extends BaseType>(schema: T): Compiled<T> {
     encodeSafe,
   } as any
 }
-
-export namespace runtime {
-  export function parse(type: BaseType, value: any) {
-    return _parse(type.final, value)
-  }
-
-  export function errors(type: BaseType, value: any): ValidationError[] {
-    return _errors(Value.Errors(type.final, value))
-  }
-
-  export function check(type: BaseType, value: any): boolean {
-    return Value.Check(type.final, value)
-  }
-
-  export function decode<T extends BaseType>(
-    type: T,
-    value: any,
-  ): t.infer.decoded<T> {
-    return TransformDecode(type.final, [], value)
-  }
-
-  export function encode<T extends BaseType>(
-    type: T,
-    value: any,
-  ): t.infer.encoded<T> {
-    return TransformEncode(type.final, [], value)
-  }
-}

package/src/index.ts

@@ -1,16 +1,12 @@
 import type {
-  StaticDecode,
-  StaticEncode,
-  TLiteralValue,
-} from '@sinclair/typebox/type'
+  StaticInputDecode,
+  StaticInputEncode,
+  StaticOutputDecode,
+  StaticOutputEncode,
+} from './inference.ts'
 import { AnyType } from './types/any.ts'
 import { ArrayType } from './types/array.ts'
-import type {
-  BaseType,
-  BaseTypeAny,
-  OptionalType,
-  Static,
-} from './types/base.ts'
+import type { BaseTypeAny, OptionalType } from './types/base.ts'
 import { BooleanType } from './types/boolean.ts'
 import { CustomType } from './types/custom.ts'
 import { DateType } from './types/date.ts'
@@ -18,22 +14,26 @@ import { EnumType, ObjectEnumType } 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 { ObjectType, type ObjectTypeProps, RecordType } from './types/object.ts'
+import {
+  ObjectType,
+  RecordType,
+  extend,
+  keyof,
+  merge,
+  omit,
+  partial,
+  pick,
+} from './types/object.ts'
 import { StringType } from './types/string.ts'
 import {
   DiscriminatedUnionType,
   IntersactionType,
   UnionType,
 } from './types/union.ts'
-import type { UnionToTupleString } from './utils.ts'
-
-// register ajv formats
-import { register } from './formats.ts'
-register()
 
 export * from './schemas/nullable.ts'
 export { BaseType, type BaseTypeAny } from './types/base.ts'
-export { type TSchema } from '@sinclair/typebox'
+export type { TSchema } from '@sinclair/typebox'
 export {
   ArrayType,
   BooleanType,
@@ -51,20 +51,20 @@ export {
   NeverType,
 }
 
-export namespace t {
+export namespace type {
   export namespace infer {
-    export type decoded<T extends BaseTypeAny> = StaticDecode<
-      T['_']['decoded']['output']
+    export type decoded<T extends BaseTypeAny<any>> = StaticOutputDecode<
+      T['schema']
     >
-    export type encoded<T extends BaseTypeAny> = StaticEncode<
-      T['_']['encoded']['output']
+    export type encoded<T extends BaseTypeAny<any>> = StaticOutputEncode<
+      T['schema']
     >
     export namespace input {
-      export type decoded<T extends BaseTypeAny> = StaticDecode<
-        T['_']['decoded']['input']
+      export type decoded<T extends BaseTypeAny<any>> = StaticInputDecode<
+        T['schema']
       >
-      export type encoded<T extends BaseTypeAny> = StaticEncode<
-        T['_']['encoded']['input']
+      export type encoded<T extends BaseTypeAny<any>> = StaticInputEncode<
+        T['schema']
       >
     }
   }
@@ -80,103 +80,20 @@ export namespace t {
   export const arrayEnum = EnumType.factory
   export const date = DateType.factory
   export const array = ArrayType.factory
-  export const object = ObjectType.factory
   export const record = RecordType.factory
   export const any = AnyType.factory
   export const or = UnionType.factory
   export const and = IntersactionType.factory
   export const discriminatedUnion = DiscriminatedUnionType.factory
   export const custom = CustomType.factory
-
-  export const keyof = <T extends ObjectType>(
-    type: T,
-  ): EnumType<
-    UnionToTupleString<T extends ObjectType<infer Props> ? keyof Props : never>
-  > => {
-    return arrayEnum(Object.keys(type.props.properties) as any)
-  }
-
-  export const pick = <
-    T extends ObjectType,
-    P extends { [K in keyof T['props']['properties']]?: true },
-  >(
-    source: T,
-    pick: P,
-  ): ObjectType<{
-    [K in keyof T['props']['properties'] as K extends keyof P
-      ? K
-      : never]: T['props']['properties'][K]
-  }> => {
-    const properties = Object.fromEntries(
-      Object.entries(source.props.properties).filter(([key]) => pick[key]),
-    )
-    return ObjectType.factory(properties) as any
-  }
-
-  export const omit = <
-    T extends ObjectType,
-    P extends { [K in keyof T]?: 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 const extend = <T extends ObjectType, 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 const merge = <T1 extends ObjectType, T2 extends ObjectType>(
-    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 const partial = <T extends ObjectType>(
-    object: T,
-  ): ObjectType<{
-    [K in keyof T['props']['properties']]: OptionalType<
-      T['props']['properties'][K]
-    >
-  }> => {
-    const properties = {} as any
-
-    for (const [key, value] of Object.entries(object.props.properties)) {
-      properties[key] = value.optional()
-    }
-
-    return ObjectType.factory(properties, {}) as any
-  }
+  export const object = Object.assign(ObjectType.factory.bind(ObjectType), {
+    keyof,
+    partial,
+    merge,
+    omit,
+    extend,
+    pick,
+  })
 }
+
+export { type as t }

package/src/inference.ts

@@ -0,0 +1,128 @@
+import type { TProperties, TSchema } from '@sinclair/typebox'
+import type * as Types from '@sinclair/typebox'
+import type { TDefault } from './schemas/default.ts'
+
+export type StaticInputEncode<Type extends TSchema> =
+  Type extends Types.TOptional<TSchema>
+    ? Types.StaticEncode<Type> | undefined
+    : Types.StaticEncode<Type>
+
+export type StaticInputDecode<Type extends TSchema> =
+  Type extends Types.TOptional<TSchema>
+    ? Types.StaticDecode<Type> | undefined
+    : Types.StaticDecode<Type>
+
+export type StaticOutputEncode<Type extends TSchema> = Types.StaticEncode<
+  TMap<Type, StaticOutputMapping>
+>
+
+export type StaticOutputDecode<Type extends TSchema> = Types.StaticDecode<
+  TMap<Type, StaticOutputMapping>
+>
+
+interface StaticOutputMapping extends TMapping {
+  output: this['input']
+}
+
+interface TMapping {
+  input: unknown
+  output: unknown
+}
+
+type TApply<
+  Type extends TSchema,
+  Mapping extends TMapping,
+  Mapped = (Mapping & { input: Type })['output'],
+  Result = Mapped extends TSchema ? Mapped : never,
+> = Result
+
+type TFromProperties<
+  Properties extends TProperties,
+  Mapping extends TMapping,
+  Result extends TProperties = {
+    [Key in keyof Properties]: TMap<Properties[Key], Mapping>
+  },
+> = Result
+
+type TFromRest<
+  Types extends TSchema[],
+  Mapping extends TMapping,
+  Result extends TSchema[] = [],
+> = Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]]
+  ? TFromRest<Right, Mapping, [...Result, TMap<Left, Mapping>]>
+  : Result
+
+type TFromType<
+  Type extends TSchema,
+  Mapping extends TMapping,
+  Result extends TSchema = TApply<Type, Mapping>,
+> = Result
+
+type UnwrapDefault<T extends TSchema> = T extends TDefault<infer U>
+  ? U extends Types.TOptional<infer V>
+    ? V
+    : U
+  : T
+
+type TMap<
+  Type extends TSchema,
+  Mapping extends TMapping,
+  // Maps the Exterior Type
+  Exterior extends TSchema = TFromType<Type, Mapping>,
+  // Maps the Interior Parameterized Types
+  Interior extends TSchema = Exterior extends Types.TConstructor<
+    infer Parameters extends TSchema[],
+    infer ReturnType extends TSchema
+  >
+    ? Types.TConstructor<
+        TFromRest<Parameters, Mapping>,
+        TFromType<ReturnType, Mapping>
+      >
+    : Exterior extends Types.TFunction<
+          infer Parameters extends TSchema[],
+          infer ReturnType extends TSchema
+        >
+      ? Types.TFunction<
+          TFromRest<Parameters, Mapping>,
+          TFromType<ReturnType, Mapping>
+        >
+      : Exterior extends Types.TIntersect<infer Types extends TSchema[]>
+        ? Types.TIntersect<TFromRest<Types, Mapping>>
+        : Exterior extends Types.TUnion<infer Types extends TSchema[]>
+          ? Types.TUnion<TFromRest<Types, Mapping>>
+          : Exterior extends Types.TTuple<infer Types extends TSchema[]>
+            ? Types.TTuple<TFromRest<Types, Mapping>>
+            : Exterior extends Types.TArray<infer Type extends TSchema>
+              ? Types.TArray<TFromType<Type, Mapping>>
+              : Exterior extends Types.TAsyncIterator<
+                    infer Type extends TSchema
+                  >
+                ? Types.TAsyncIterator<TFromType<Type, Mapping>>
+                : Exterior extends Types.TIterator<infer Type extends TSchema>
+                  ? Types.TIterator<TFromType<Type, Mapping>>
+                  : Exterior extends Types.TPromise<infer Type extends TSchema>
+                    ? Types.TPromise<TFromType<Type, Mapping>>
+                    : Exterior extends Types.TObject<
+                          infer Properties extends TProperties
+                        >
+                      ? Types.TObject<TFromProperties<Properties, Mapping>>
+                      : Exterior extends Types.TRecord<
+                            infer Key extends TSchema,
+                            infer Value extends TSchema
+                          >
+                        ? Types.TRecordOrObject<
+                            TFromType<Key, Mapping>,
+                            TFromType<Value, Mapping>
+                          >
+                        : Exterior,
+  // Modifiers Derived from Exterior Type Mapping
+  IsOptional extends number = Exterior extends Types.TOptional<TSchema> ? 1 : 0,
+  IsReadonly extends number = Exterior extends Types.TReadonly<TSchema> ? 1 : 0,
+  Result extends TSchema = [IsReadonly, IsOptional] extends [1, 1]
+    ? Types.TReadonly<UnwrapDefault<Interior>>
+    : [IsReadonly, IsOptional] extends [0, 1]
+      ? UnwrapDefault<Interior>
+      : [IsReadonly, IsOptional] extends [1, 0]
+        ? Types.TReadonly<UnwrapDefault<Interior>>
+        : UnwrapDefault<Interior>,
+> = Result