@nmtjs/type 0.4.7 → 0.5.0

package/src/compiler.ts

@@ -3,28 +3,52 @@ import {
   TypeCompiler,
   type ValueErrorIterator,
 } from '@sinclair/typebox/compiler'
-import { Value } from '@sinclair/typebox/value'
-import type { typeStatic } from './constants.ts'
-import { type BaseType, getTypeSchema } from './types/base.ts'
+import {
+  TransformDecode,
+  TransformEncode,
+  Value,
+} from '@sinclair/typebox/value'
+import type { t } from './index.ts'
+import { IsDiscriminatedUnion } from './schemas/discriminated-union.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
-  errors: (val: unknown) => ValueErrorIterator
+  errors: (val: unknown) => ValidationError[]
   parse: (val: unknown) => unknown
-  decode: (val: unknown) => T[typeStatic]['decoded']
-  encode: (val: unknown) => T[typeStatic]['encoded']
+  /**
+   * Requires to `check` before calling
+   */
+  decode: (val: unknown) => t.infer.decoded<T>
+  /**
+   * Requires to `check` before calling
+   */
+  encode: (val: unknown) => t.infer.encoded<T>
+  /**
+   * Requires to `check` before calling
+   */
   decodeSafe: (
     val: unknown,
   ) =>
-    | { success: true; value: T[typeStatic]['decoded'] }
+    | { success: true; value: t.infer.decoded<T> }
     | { success: false; error: any }
+  /**
+   * Requires to `check` before calling
+   */
   encodeSafe: (
     val: unknown,
   ) =>
-    | { success: true; value: T[typeStatic]['encoded'] }
+    | { success: true; value: t.infer.encoded<T> }
     | { success: false; error: any }
 }
 
+// FIXME: this one is very slow
 function _parse(schema: TSchema, value: any) {
   // Clone -> Clean -> Default -> Convert
   return Value.Convert(
@@ -33,70 +57,129 @@ function _parse(schema: TSchema, value: any) {
   )
 }
 
+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 schema = getTypeSchema(type)
+  const { final: schema } = type
   const compiled = TypeCompiler.Compile(schema)
+  const errors = (value) => {
+    return _errors(compiled.Errors(value))
+  }
+
   return {
     check: compiled.Check.bind(compiled),
-    errors: compiled.Errors.bind(compiled),
-    decode: compiled.Decode.bind(compiled),
-    encode: compiled.Encode.bind(compiled),
     parse: _parse.bind(null, schema),
+    errors,
+    decode: TransformDecode.bind(null, schema, compiled.References()),
+    encode: TransformEncode.bind(null, schema, compiled.References()),
   }
 }
 
 export function compile<T extends BaseType>(schema: T): Compiled<T> {
   const compiled = compileType(schema)
 
-  return {
-    ...compiled,
-    decodeSafe: (val) => {
-      try {
-        return {
-          success: true as const,
-          value: compiled.decode(val),
-        }
-      } catch (error) {
-        return { success: false as const, error }
+  function decodeSafe(val: unknown) {
+    try {
+      return {
+        success: true as const,
+        value: compiled.decode(val),
       }
-    },
-    encodeSafe: (val) => {
-      try {
-        return {
-          success: true as const,
-          value: compiled.encode(val),
-        }
-      } catch (error) {
-        return { success: false as const, error }
+    } catch (error) {
+      return { success: false as const, error }
+    }
+  }
+
+  function encodeSafe(val: unknown) {
+    try {
+      return {
+        success: true as const,
+        value: compiled.encode(val),
       }
-    },
+    } catch (error) {
+      return { success: false as const, error }
+    }
   }
+
+  return {
+    ...compiled,
+    decodeSafe,
+    encodeSafe,
+  } as any
 }
 
 export namespace runtime {
   export function parse(type: BaseType, value: any) {
-    return _parse(getTypeSchema(type), value)
+    return _parse(type.schema, value)
   }
 
-  export function errors(type: BaseType, value: any): ValueErrorIterator {
-    return Value.Errors(getTypeSchema(type), value)
+  export function errors(type: BaseType, value: any): ValidationError[] {
+    return _errors(Value.Errors(type.schema, value))
   }
 
   export function check(type: BaseType, value: any): boolean {
-    return Value.Check(getTypeSchema(type), value)
+    return Value.Check(type.schema, value)
   }
 
   export function decode<T extends BaseType>(
-    type: BaseType,
+    type: T,
     value: any,
-  ): T[typeStatic]['decoded'] {
-    return Value.Decode(getTypeSchema(type), value)
+  ): t.infer.decoded<T> {
+    return TransformDecode(type.schema, [], value)
   }
 
   export function encode<T extends BaseType>(
     type: T,
     value: any,
-  ): T[typeStatic]['encoded'] {
-    return Value.Encode(getTypeSchema(type), value)
+  ): t.infer.encoded<T> {
+    return TransformEncode(type.schema, [], value)
   }
 }

package/src/formats.ts

@@ -32,7 +32,7 @@ export const fullFormats: Record<
   'iso-date-time': getDateTime(),
   // duration: https://tools.ietf.org/html/rfc3339#appendix-A
   duration:
-    /^P(?!$)((\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?((\d+|\d\.\d+)S)?)?|(\d+W)?)$/,
+    /^P(?!$)((\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?((\d+|\d+\.\d+)S)?)?|(\d+W)?)$/,
   uri,
   'uri-reference':
     /^(?:[a-z][a-z0-9+\-.]*:)?(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'"()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?(?:\?(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i,

package/src/index.ts

@@ -1,38 +1,38 @@
-import type { TLiteralValue } from '@sinclair/typebox/type'
+import type {
+  StaticDecode,
+  StaticEncode,
+  TLiteralValue,
+} from '@sinclair/typebox/type'
+import { AnyType } from './types/any.ts'
 import { ArrayType } from './types/array.ts'
-import type { BaseType } from './types/base.ts'
+import type {
+  BaseType,
+  BaseTypeAny,
+  OptionalType,
+  Static,
+} from './types/base.ts'
 import { BooleanType } from './types/boolean.ts'
 import { CustomType } from './types/custom.ts'
-import { DateType } from './types/datetime.ts'
-import {
-  type AnyEnumType,
-  type AnyObjectEnumType,
-  EnumType,
-  ObjectEnumType,
-} from './types/enum.ts'
-import { type AnyLiteralType, LiteralType } from './types/literal.ts'
+import { DateType } from './types/date.ts'
+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, RecordType } from './types/object.ts'
-import { type AnyStringType, StringType } from './types/string.ts'
+import { ObjectType, type ObjectTypeProps, RecordType } from './types/object.ts'
+import { StringType } from './types/string.ts'
 import {
-  type AnyUnionType,
+  DiscriminatedUnionType,
   IntersactionType,
   UnionType,
 } from './types/union.ts'
-
-import type { typeStatic } from './constants.ts'
-import { AnyType } from './types/any.ts'
-import { NeverType } from './types/never.ts'
+import type { UnionToTupleString } from './utils.ts'
 
 // register ajv formats
 import { register } from './formats.ts'
 register()
 
 export * from './schemas/nullable.ts'
-export {
-  BaseType,
-  getTypeSchema,
-} from './types/base.ts'
+export { BaseType, type BaseTypeAny } from './types/base.ts'
 export { type TSchema } from '@sinclair/typebox'
 export {
   ArrayType,
@@ -53,48 +53,130 @@ export {
 
 export namespace t {
   export namespace infer {
-    export type staticType<T extends BaseType> = T[typeStatic]
-    export type decoded<T extends BaseType> = staticType<T>['decoded']
-    export type encoded<T extends BaseType> = staticType<T>['encoded']
+    export type decoded<T extends BaseTypeAny> = StaticDecode<
+      T['_']['decoded']['output']
+    >
+    export type encoded<T extends BaseTypeAny> = StaticEncode<
+      T['_']['encoded']['output']
+    >
+    export namespace input {
+      export type decoded<T extends BaseTypeAny> = StaticDecode<
+        T['_']['decoded']['input']
+      >
+      export type encoded<T extends BaseTypeAny> = StaticEncode<
+        T['_']['encoded']['input']
+      >
+    }
+  }
+
+  export const never = NeverType.factory
+  export const boolean = BooleanType.factory
+  export const string = StringType.factory
+  export const number = NumberType.factory
+  export const integer = IntegerType.factory
+  export const bitint = BigIntType.factory
+  export const literal = LiteralType.factory
+  export const objectEnum = ObjectEnumType.factory
+  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 never = () => new NeverType()
-  export const boolean = () => new BooleanType()
-  export const string = () => new StringType()
-  export const number = () => new NumberType()
-  export const integer = () => new IntegerType()
-  export const bitint = () => new BigIntType()
-  export const literal = <T extends TLiteralValue>(value: T) =>
-    new LiteralType(value)
-  export const objectEnum = <T extends { [K in string]: K }>(enumLike: T) =>
-    new ObjectEnumType(enumLike)
-  export const arrayEnum = <T extends (string | number)[]>(enumLike: [...T]) =>
-    new EnumType(enumLike)
-  export const date = () => new DateType()
-  export const array = <T extends BaseType>(element: T) =>
-    new ArrayType(element)
-  export const object = <T extends Record<string, BaseType>>(properties: T) =>
-    new ObjectType(properties)
-  export const record = <
-    K extends
-      | AnyLiteralType
-      | AnyEnumType
-      | AnyObjectEnumType
-      | AnyStringType
-      | AnyUnionType,
-    E extends BaseType,
+
+  export const pick = <
+    T extends ObjectType,
+    P extends { [K in keyof T['props']['properties']]?: true },
   >(
-    key: K,
-    value: E,
-  ) => new RecordType(key, value)
-  export const any = () => new AnyType()
-  export const or = <T extends [BaseType, BaseType, ...BaseType[]]>(
-    ...types: T
-  ) => new UnionType(types)
-  export const and = <T extends [BaseType, BaseType, ...BaseType[]]>(
-    ...types: T
-  ) => new IntersactionType(types)
-  export const custom = <T>(
-    decode: (value: any) => T,
-    encode: (value: T) => any,
-  ) => new CustomType<T>(decode, encode)
+    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
+  }
 }

package/src/schemas/discriminated-union.ts

@@ -0,0 +1,49 @@
+import {
+  KindGuard,
+  type TLiteral,
+  type TObject,
+  type TPropertyKey,
+  type TSchema,
+  type TUnion,
+  Type,
+  TypeGuard,
+  ValueGuard,
+} from '@sinclair/typebox'
+
+export function IsDiscriminatedUnion(
+  schema: TSchema,
+): schema is TDiscriminatedUnion {
+  return (
+    TypeGuard.IsUnion(schema) &&
+    'discriminator' in schema &&
+    ValueGuard.IsString(schema.discriminator) &&
+    schema.anyOf.every(
+      (variant) =>
+        KindGuard.IsObject(variant) &&
+        KindGuard.IsLiteralString(variant.properties[schema.discriminator]),
+    )
+  )
+}
+
+type DiscriminatedUnionProperties<K extends string = string> = {
+  [OK in K]: TLiteral<any>
+} & {
+  [OK in TPropertyKey]: any
+}
+
+export interface TDiscriminatedUnion<
+  K extends string = string,
+  T extends TObject<DiscriminatedUnionProperties<K>>[] = TObject<
+    DiscriminatedUnionProperties<K>
+  >[],
+> extends TUnion<T> {
+  discriminator: K
+  anyOf: T
+}
+
+export function DiscriminatedUnion<
+  K extends string,
+  T extends TObject<DiscriminatedUnionProperties<K>>[],
+>(key: K, types: T): TDiscriminatedUnion<K, T> {
+  return Type.Union(types, { discriminator: key }) as any
+}

package/src/schemas/nullable.ts

@@ -1,7 +1,9 @@
 import {
   type SchemaOptions,
   type TNull,
+  type TOptional,
   type TSchema,
+  type TUndefined,
   type TUnion,
   Type,
 } from '@sinclair/typebox/type'
@@ -11,22 +13,14 @@ export const Nullable = <T extends TSchema>(
   schema: T,
   options: SchemaOptions = {},
 ) => {
-  const {
-    default: _default,
-    description,
-    examples,
-    readOnly,
-    title,
-    writeOnly,
-  } = schema
+  const { default: _default } = schema
 
   return Type.Union([schema, Type.Null()], {
     default: _default,
-    description,
-    examples,
-    readOnly,
-    title,
-    writeOnly,
     ...options,
   })
 }
+
+export type TOptionalUndefined<T extends TSchema> = TOptional<
+  TUnion<[T, TUndefined]>
+>

package/src/temporal.ts

@@ -1,3 +1,4 @@
+import { Temporal } from 'temporal-polyfill'
 import {
   DurationType,
   PlainDateTimeType,
@@ -8,13 +9,13 @@ import {
   ZonedDateTimeType,
 } from './types/temporal.ts'
 
-export const plainDate = () => new PlainDateType()
-export const plainDatetime = () => new PlainDateTimeType()
-export const plainTime = () => new PlainTimeType()
-export const zonedDatetime = () => new ZonedDateTimeType()
-export const duration = () => new DurationType()
-export const plainYearMonth = () => new PlainYearMonthType()
-export const plainMonthDay = () => new 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 {
   DurationType,

package/src/types/any.ts

@@ -1,50 +1,10 @@
-import { type SchemaOptions, type TAny, Type } from '@sinclair/typebox'
-import { BaseType } from './base.ts'
+import { type TAny, Type } from '@sinclair/typebox'
+import { BaseType, type ConstantType } from './base.ts'
 
-export class AnyType<
-  N extends boolean = false,
-  O extends boolean = false,
-  D extends boolean = false,
-> extends BaseType<TAny, N, O, D, SchemaOptions> {
-  constructor(
-    options: SchemaOptions = {},
-    isNullable: N = false as N,
-    isOptional: O = false as O,
-    hasDefault: D = false as D,
-  ) {
-    super(options, isNullable, isOptional, hasDefault)
-  }
-
-  protected _constructSchema(options: SchemaOptions): TAny {
-    return Type.Any(options)
-  }
-
-  nullable() {
-    return new AnyType(...this._with({ isNullable: true }))
-  }
-
-  optional() {
-    return new AnyType(...this._with({ isOptional: true }))
-  }
-
-  nullish() {
-    return new AnyType(...this._with({ isNullable: true, isOptional: true }))
-  }
-
-  default(value: any) {
-    return new AnyType(
-      ...this._with({
-        options: { default: value },
-        hasDefault: true,
-      }),
-    )
-  }
-
-  description(description: string) {
-    return new AnyType(...this._with({ options: { description } }))
-  }
+export class AnyType extends BaseType<TAny> {
+  _!: ConstantType<this['schema']>
 
-  examples(...examples: [any, ...any[]]) {
-    return new AnyType(...this._with({ options: { examples } }))
+  static factory() {
+    return new AnyType(Type.Any())
   }
 }