@nmtjs/type 0.5.3 → 0.6.0

package/src/parse.ts

@@ -0,0 +1,217 @@
+// --------------------------------------------------------------------------
+// Iterators
+// --------------------------------------------------------------------------
+
+/** Returns true if this value is an async iterator */
+export function IsAsyncIterator(value) {
+  return IsObject(value) && Symbol.asyncIterator in value
+}
+/** Returns true if this value is an iterator */
+export function IsIterator(value) {
+  return IsObject(value) && Symbol.iterator in value
+}
+// --------------------------------------------------------------------------
+// Object Instances
+// --------------------------------------------------------------------------
+/** Returns true if this value is not an instance of a class */
+export function IsStandardObject(value) {
+  return (
+    IsObject(value) &&
+    (Object.getPrototypeOf(value) === Object.prototype ||
+      Object.getPrototypeOf(value) === null)
+  )
+}
+/** Returns true if this value is an instance of a class */
+export function IsInstanceObject(value) {
+  return (
+    IsObject(value) &&
+    !IsArray(value) &&
+    IsFunction(value.constructor) &&
+    value.constructor.name !== 'Object'
+  )
+}
+// --------------------------------------------------------------------------
+// JavaScript
+// --------------------------------------------------------------------------
+/** Returns true if this value is a Promise */
+export function IsPromise(value) {
+  return value instanceof Promise
+}
+/** Returns true if this value is a Date */
+export function IsDate(value) {
+  return value instanceof Date && Number.isFinite(value.getTime())
+}
+/** Returns true if this value is an instance of Map<K, T> */
+export function IsMap(value) {
+  return value instanceof globalThis.Map
+}
+/** Returns true if this value is an instance of Set<T> */
+export function IsSet(value) {
+  return value instanceof globalThis.Set
+}
+/** Returns true if this value is RegExp */
+export function IsRegExp(value) {
+  return value instanceof globalThis.RegExp
+}
+/** Returns true if this value is a typed array */
+export function IsTypedArray(value) {
+  return ArrayBuffer.isView(value)
+}
+/** Returns true if the value is a Int8Array */
+export function IsInt8Array(value) {
+  return value instanceof globalThis.Int8Array
+}
+/** Returns true if the value is a Uint8Array */
+export function IsUint8Array(value) {
+  return value instanceof globalThis.Uint8Array
+}
+/** Returns true if the value is a Uint8ClampedArray */
+export function IsUint8ClampedArray(value) {
+  return value instanceof globalThis.Uint8ClampedArray
+}
+/** Returns true if the value is a Int16Array */
+export function IsInt16Array(value) {
+  return value instanceof globalThis.Int16Array
+}
+/** Returns true if the value is a Uint16Array */
+export function IsUint16Array(value) {
+  return value instanceof globalThis.Uint16Array
+}
+/** Returns true if the value is a Int32Array */
+export function IsInt32Array(value) {
+  return value instanceof globalThis.Int32Array
+}
+/** Returns true if the value is a Uint32Array */
+export function IsUint32Array(value) {
+  return value instanceof globalThis.Uint32Array
+}
+/** Returns true if the value is a Float32Array */
+export function IsFloat32Array(value) {
+  return value instanceof globalThis.Float32Array
+}
+/** Returns true if the value is a Float64Array */
+export function IsFloat64Array(value) {
+  return value instanceof globalThis.Float64Array
+}
+/** Returns true if the value is a BigInt64Array */
+export function IsBigInt64Array(value) {
+  return value instanceof globalThis.BigInt64Array
+}
+/** Returns true if the value is a BigUint64Array */
+export function IsBigUint64Array(value) {
+  return value instanceof globalThis.BigUint64Array
+}
+// --------------------------------------------------------------------------
+// PropertyKey
+// --------------------------------------------------------------------------
+/** Returns true if this value has this property key */
+export function HasPropertyKey(value, key) {
+  return key in value
+}
+// --------------------------------------------------------------------------
+// Standard
+// --------------------------------------------------------------------------
+/** Returns true of this value is an object type */
+export function IsObject(value) {
+  return value !== null && typeof value === 'object'
+}
+/** Returns true if this value is an array, but not a typed array */
+export function IsArray(value) {
+  return Array.isArray(value) && !ArrayBuffer.isView(value)
+}
+/** Returns true if this value is an undefined */
+export function IsUndefined(value) {
+  return value === undefined
+}
+/** Returns true if this value is an null */
+export function IsNull(value) {
+  return value === null
+}
+/** Returns true if this value is an boolean */
+export function IsBoolean(value) {
+  return typeof value === 'boolean'
+}
+/** Returns true if this value is an number */
+export function IsNumber(value) {
+  return typeof value === 'number'
+}
+/** Returns true if this value is an integer */
+export function IsInteger(value) {
+  return Number.isInteger(value)
+}
+/** Returns true if this value is bigint */
+export function IsBigInt(value) {
+  return typeof value === 'bigint'
+}
+/** Returns true if this value is string */
+export function IsString(value) {
+  return typeof value === 'string'
+}
+/** Returns true if this value is a function */
+export function IsFunction(value) {
+  return typeof value === 'function'
+}
+/** Returns true if this value is a symbol */
+export function IsSymbol(value) {
+  return typeof value === 'symbol'
+}
+/** Returns true if this value is a value type such as number, string, boolean */
+export function IsValueType(value) {
+  // prettier-ignore
+  return (
+    IsBigInt(value) ||
+    IsBoolean(value) ||
+    IsNull(value) ||
+    IsNumber(value) ||
+    IsString(value) ||
+    IsSymbol(value) ||
+    IsUndefined(value)
+  )
+}
+
+// ------------------------------------------------------------------
+// Clonable
+// ------------------------------------------------------------------
+function FromObject(value, exclude) {
+  const Acc = {}
+  for (const key of Object.getOwnPropertyNames(value)) {
+    Acc[key] = Clone(value[key], exclude)
+  }
+  for (const key of Object.getOwnPropertySymbols(value)) {
+    Acc[key] = Clone(value[key], exclude)
+  }
+  return Acc
+}
+function FromArray(value, exclude) {
+  return value.map((element) => Clone(element, exclude))
+}
+function FromTypedArray(value) {
+  return value.slice()
+}
+function FromMap(value, exclude) {
+  return new Map(Clone([...value.entries()], exclude))
+}
+function FromSet(value, exclude) {
+  return new Set(Clone([...value.entries()], exclude))
+}
+function FromDate(value) {
+  return new Date(value.toISOString())
+}
+function FromValue(value) {
+  return value
+}
+// ------------------------------------------------------------------
+// Clone
+// ------------------------------------------------------------------
+/** Returns a clone of the given value */
+export function Clone(value, exclude?: Set<any>) {
+  if (IsArray(value)) return FromArray(value, exclude)
+  if (IsDate(value)) return FromDate(value)
+  if (IsTypedArray(value)) return FromTypedArray(value)
+  if (IsMap(value)) return FromMap(value, exclude)
+  if (IsSet(value)) return FromSet(value, exclude)
+  if (IsObject(value)) return FromObject(value, exclude)
+  if (IsValueType(value)) return FromValue(value)
+  if (exclude?.has(value.constructor)) return value
+  throw new Error('Cannot clone value')
+}

package/src/runtime.ts

@@ -0,0 +1,137 @@
+import type { ClassConstructor } from '@nmtjs/common'
+import type { TSchema } from '@sinclair/typebox'
+import type { ValueErrorIterator } from '@sinclair/typebox/compiler'
+import {
+  TransformDecode,
+  TransformEncode,
+  Value,
+} from '@sinclair/typebox/value'
+import { register } from './formats.ts'
+import type {
+  StaticInputEncode,
+  StaticOutputDecode,
+  StaticOutputEncode,
+} from './inference.ts'
+import { Clone } from './parse.ts'
+import { IsDiscriminatedUnion } from './schemas/discriminated-union.ts'
+import type { BaseType } from './types/base.ts'
+
+// register ajv formats
+register()
+
+export type CloneOptions = {
+  clone?: boolean
+  exclude?: Set<any>
+}
+
+export type ValidationError = {
+  path: string
+  message: string
+  value: unknown
+}
+
+// TODO: this one is very slow
+export function _applyDefaults(schema: TSchema, value: any) {
+  return Value.Default(schema, value)
+}
+
+// TODO: this one is very slow
+// Clone -> Clean -> Convert
+export function _parse(
+  schema: TSchema,
+  value: any,
+  cloneOptions?: CloneOptions,
+) {
+  if (cloneOptions?.clone !== false) {
+    value = Clone(value, cloneOptions?.exclude)
+  }
+  return Value.Clean(schema, Value.Convert(schema, value))
+}
+
+export function _traversErrors(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(..._traversErrors(nestedError))
+    }
+  }
+
+  return result
+}
+
+export function applyDefaults(type: BaseType, value: unknown) {
+  return _applyDefaults(type.schema, value)
+}
+
+export function parse(
+  type: BaseType,
+  value: unknown,
+  cloneOptions?: CloneOptions,
+) {
+  return _parse(type.schema, value, cloneOptions)
+}
+
+export function errors(type: BaseType, value: unknown): ValidationError[] {
+  return _traversErrors(Value.Errors(type.schema, value))
+}
+
+export function check<T extends BaseType>(
+  type: T,
+  value: unknown,
+): value is StaticInputEncode<T['schema']> {
+  return Value.Check(type.schema, value)
+}
+
+export function decode<T extends BaseType>(
+  type: T,
+  value: unknown,
+): StaticOutputDecode<T['schema']> {
+  return TransformDecode(type.schema, [], value)
+}
+
+export function encode<T extends BaseType>(
+  type: T,
+  value: unknown,
+): StaticOutputEncode<T['schema']> {
+  return TransformEncode(type.schema, [], value)
+}

package/src/schemas/default.ts

@@ -0,0 +1,12 @@
+import type { TSchema } from '@sinclair/typebox'
+
+export type TDefault<Type extends TSchema, Default = unknown> = Type & {
+  default: Default
+}
+
+export function Default<Type extends TSchema, const Default>(
+  type: Type,
+  default_: Default,
+): TDefault<Type, Default> {
+  return { ...type, default: default_ } as never
+}

package/src/schemas/discriminated-union.ts

@@ -25,7 +25,7 @@ export function IsDiscriminatedUnion(
   )
 }
 
-type DiscriminatedUnionProperties<K extends string = string> = {
+export type DiscriminatedUnionProperties<K extends string = string> = {
   [OK in K]: TLiteral<any>
 } & {
   [OK in TPropertyKey]: any

package/src/schemas/nullable.ts

@@ -1,9 +1,7 @@
 import {
   type SchemaOptions,
   type TNull,
-  type TOptional,
   type TSchema,
-  type TUndefined,
   type TUnion,
   Type,
 } from '@sinclair/typebox/type'
@@ -20,7 +18,3 @@ export const Nullable = <T extends TSchema>(
     ...options,
   })
 }
-
-export type TOptionalUndefined<T extends TSchema> = TOptional<
-  TUnion<[T, TUndefined]>
->

package/src/temporal.ts

@@ -1,4 +1,3 @@
-import { Temporal } from 'temporal-polyfill'
 import {
   DurationType,
   PlainDateTimeType,

package/src/types/any.ts

@@ -1,9 +1,7 @@
 import { type TAny, Type } from '@sinclair/typebox'
-import { BaseType, type ConstantType } from './base.ts'
-
-export class AnyType extends BaseType<TAny> {
-  declare _: ConstantType<this['schema']>
+import { BaseType } from './base.ts'
 
+export class AnyType extends BaseType<TAny, {}, any> {
   static factory() {
     return new AnyType(Type.Any())
   }

package/src/types/array.ts

@@ -10,19 +10,8 @@ export class ArrayType<T extends BaseType = BaseType> extends BaseType<
   TArray<T['schema']>,
   { element: T; options: ArrayOptions }
 > {
-  declare _: {
-    encoded: {
-      input: TArray<T['_']['encoded']['input']>
-      output: TArray<T['_']['encoded']['output']>
-    }
-    decoded: {
-      input: TArray<T['_']['decoded']['input']>
-      output: TArray<T['_']['decoded']['output']>
-    }
-  }
-
   static factory<T extends BaseType>(element: T, options: ArrayOptions = {}) {
-    return new ArrayType<T>(Type.Array(element.final, options))
+    return new ArrayType<T>(Type.Array(element.schema, options))
   }
 
   min(value: number) {

package/src/types/base.ts

@@ -1,16 +1,6 @@
-import {
-  Optional,
-  type SchemaOptions,
-  type StaticDecode,
-  type StaticEncode,
-  type TSchema,
-} from '@sinclair/typebox'
-import {
-  Nullable,
-  type TNullable,
-  type TOptionalUndefined,
-} from '../schemas/nullable.ts'
-import type { Merge } from '../utils.ts'
+import { Optional, type TOptional, type TSchema } from '@sinclair/typebox'
+import { Default, type TDefault } from '../schemas/default.ts'
+import { Nullable, type TNullable } from '../schemas/nullable.ts'
 
 export type TypeProps = Record<string, any>
 
@@ -28,85 +18,42 @@ export type DefaultTypeParams = {
   encode?: TypeParams['encode']
 }
 
-export type BaseTypeAny<T extends TSchema = TSchema> = BaseType<T, any, any>
-
-type ResolveNullable<
-  T extends TSchema,
-  P extends TypeParams,
-> = P['nullable'] extends true
-  ? T extends TNullable<infer S>
-    ? TNullable<S>
-    : TNullable<T>
-  : T
-
-type ResolveOptional<
-  T extends TSchema,
-  P extends TypeParams,
-> = P['optional'] extends true
-  ? T extends TOptionalUndefined<infer S>
-    ? TOptionalUndefined<S>
-    : TOptionalUndefined<T>
-  : T
-
-type ResolveDefault<
-  T extends TSchema,
-  P extends TypeParams,
-> = P['hasDefault'] extends true
-  ? T extends TOptionalUndefined<infer U>
-    ? U
-    : T
-  : T
+export type BaseTypeAny<T extends TSchema = TSchema> = BaseType<
+  T,
+  TypeProps,
+  any
+>
 
 export abstract class BaseType<
   Schema extends TSchema = TSchema,
   Props extends TypeProps = TypeProps,
-  Params extends TypeParams = DefaultTypeParams,
+  ValueType = unknown,
 > {
-  abstract _: {
-    encoded: {
-      input: TSchema
-      output: TSchema
-    }
-    decoded: {
-      input: TSchema
-      output: TSchema
-    }
-  }
-
   readonly schema: Schema
-  readonly final: TSchema
   readonly props: Props
-  readonly params: Params
+  readonly params: TypeParams
 
   constructor(
     schema: Schema,
     props: Props = {} as Props,
-    params: Params = {} as Params,
+    params: TypeParams = {} as TypeParams,
   ) {
     const { hasDefault = false, nullable = false, optional = false } = params
     this.schema = schema
-    this.final = schema
-
-    if (nullable)
-      this.final = Nullable({
-        ...this.final,
-        default: this.final.default ?? null,
-      }) as any
-    if (optional || hasDefault) this.final = Optional(this.final) as any
 
     this.props = props
     this.params = {
       hasDefault,
       nullable,
       optional,
-    } as Params
+    } as TypeParams
   }
 
-  optional(): OptionalType<this> {
+  optional(): OptionalType<BaseType<Schema, Props>, ValueType> {
     return OptionalType.factory(this) as any
   }
 
-  nullable(): NullableType<this> {
+  nullable(): NullableType<BaseType<Schema, Props>, ValueType> {
     return NullableType.factory(this) as any
   }
 
@@ -114,16 +61,14 @@ export abstract class BaseType<
     return this.nullable().optional()
   }
 
-  default(
-    value: StaticDecode<this['_']['decoded']['output']>,
-  ): DefaultType<this> {
+  default(value: ValueType): DefaultType<BaseType<Schema, Props>, ValueType> {
     return DefaultType.factory(
       this,
       this.params.encode?.(value) ?? value,
     ) as any
   }
 
-  description(description: string): this {
+  description(description: string): BaseType<Schema, Props, ValueType> {
     const ThisConstructor = this.constructor as any
     return new ThisConstructor(
       {
@@ -135,7 +80,7 @@ export abstract class BaseType<
     ) as any
   }
 
-  examples(...examples: any[]): this {
+  examples(...examples: ValueType[]): BaseType<Schema, Props, ValueType> {
     const ThisConstructor = this.constructor as any
     return new ThisConstructor(
       {
@@ -148,89 +93,45 @@ export abstract class BaseType<
   }
 }
 
-export type ConstantType<T extends TSchema> = {
-  encoded: {
-    input: T
-    output: T
-  }
-  decoded: {
-    input: T
-    output: T
-  }
-}
-
-export type Static<
-  T extends BaseTypeAny,
-  P extends TypeProps,
-  Params extends Merge<T['params'], P> = Merge<T['params'], P>,
-> = {
-  encoded: {
-    input: ResolveOptional<
-      ResolveNullable<T['_']['encoded']['input'], Params>,
-      Params
-    >
-    output: ResolveDefault<
-      ResolveOptional<
-        ResolveNullable<T['_']['encoded']['output'], Params>,
-        Params
-      >,
-      Params
-    >
-  }
-  decoded: {
-    input: ResolveOptional<
-      ResolveNullable<T['_']['decoded']['input'], Params>,
-      Params
-    >
-    output: ResolveDefault<
-      ResolveOptional<
-        ResolveNullable<T['_']['decoded']['output'], Params>,
-        Params
-      >,
-      Params
-    >
-  }
-}
-
 export class OptionalType<
-  Type extends BaseTypeAny<any>,
-  Params extends TypeParams = DefaultTypeParams,
-> extends BaseType<Type['schema'], { inner: Type }, Params> {
-  _!: Static<Type, Params>
-
-  static factory<T extends BaseTypeAny<any>>(type: T) {
-    return new OptionalType<T, Merge<T['params'], { optional: true }>>(
-      type.schema,
-      { inner: type },
-      { ...type.params, optional: true } as any,
-    )
+  Type extends BaseTypeAny = BaseTypeAny,
+  ValueType = unknown,
+> extends BaseType<TOptional<Type['schema']>, { inner: Type }, ValueType> {
+  static factory<T extends BaseTypeAny>(type: T) {
+    return new OptionalType<T>(Optional(type.schema) as any, { inner: type }, {
+      ...type.params,
+      optional: true,
+    } as any)
   }
 }
 
 export class NullableType<
-  Type extends BaseTypeAny<any>,
-  Params extends TypeParams = DefaultTypeParams,
-> extends BaseType<Type['schema'], { inner: Type }, Params> {
-  _!: Static<Type, Params>
-
+  Type extends BaseTypeAny<any> = BaseTypeAny<any>,
+  ValueType = unknown,
+> extends BaseType<
+  TNullable<Type['schema']>,
+  { inner: Type },
+  ValueType | null
+> {
   static factory<T extends BaseTypeAny<any>>(type: T) {
-    return new NullableType<T, Merge<T['params'], { nullable: true }>>(
-      type.schema,
-      { inner: type },
-      { ...type.params, nullable: true } as any,
-    )
+    return new NullableType<T>(Nullable(type.schema), { inner: type }, {
+      ...type.params,
+      nullable: true,
+    } as any)
   }
 }
 
 export class DefaultType<
-  Type extends BaseTypeAny<any>,
-  Params extends TypeParams = DefaultTypeParams,
-> extends BaseType<Type['schema'], { inner: Type }, Params> {
-  _!: Static<Type, Params>
-
+  Type extends BaseTypeAny = BaseTypeAny,
+  ValueType = unknown,
+> extends BaseType<
+  TDefault<TOptional<Type['schema']>>,
+  { inner: Type },
+  ValueType
+> {
   static factory<T extends BaseTypeAny<any>>(type: T, defaultValue: any) {
-    return new DefaultType<T, Merge<T['params'], { hasDefault: true }>>(
-      { ...type.schema, default: defaultValue },
+    return new DefaultType<T>(
+      Default(Optional(type.schema), defaultValue) as any,
       { inner: type },
       { ...type.params, hasDefault: true } as any,
     )