@nmtjs/type 0.4.7 → 0.5.0

package/src/types/array.ts

@@ -1,97 +1,49 @@
-import { type ArrayOptions, type TArray, Type } from '@sinclair/typebox'
-import type { typeStatic } from '../constants.ts'
-import { BaseType, getTypeSchema } from './base.ts'
-
-export class ArrayType<
-  T extends BaseType = BaseType,
-  N extends boolean = false,
-  O extends boolean = false,
-  D extends boolean = false,
-> extends BaseType<TArray<T[typeStatic]['schema']>, N, O, D, ArrayOptions> {
-  constructor(
-    readonly element: T,
-    options: ArrayOptions = {},
-    isNullable: N = false as N,
-    isOptional: O = false as O,
-    hasDefault: D = false as D,
-  ) {
-    super(options, isNullable, isOptional, hasDefault, element)
-  }
-
-  protected _constructSchema(
-    options: ArrayOptions,
-    element: T,
-  ): TArray<T[typeStatic]['schema']> {
-    return Type.Array(getTypeSchema(element), options)
-  }
-
-  nullable() {
-    return new ArrayType(this.element, ...this._with({ isNullable: true }))
-  }
-
-  optional() {
-    return new ArrayType(this.element, ...this._with({ isOptional: true }))
-  }
-
-  nullish() {
-    return new ArrayType(
-      this.element,
-      ...this._with({ isNullable: true, isOptional: true }),
-    )
-  }
-
-  default(value: this[typeStatic]['encoded']) {
-    return new ArrayType(
-      this.element,
-      ...this._with({
-        options: { default: value },
-        hasDefault: true,
-      }),
-    )
-  }
-
-  description(description: string) {
-    return new ArrayType(
-      this.element,
-      ...this._with({ options: { description } }),
-    )
-  }
-
-  examples(
-    ...examples: [this[typeStatic]['encoded'], ...this[typeStatic]['encoded'][]]
-  ) {
-    return new ArrayType(
-      this.element,
-      ...this._with({
-        options: { example: examples[0], examples },
-      }),
-    )
+import {
+  type ArrayOptions,
+  type StaticDecode,
+  type TArray,
+  Type,
+} from '@sinclair/typebox'
+import { BaseType } from './base.ts'
+
+export class ArrayType<T extends BaseType = BaseType> extends BaseType<
+  TArray<T['schema']>,
+  { element: T; options: ArrayOptions }
+> {
+  _!: {
+    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.schema, options))
   }
 
   min(value: number) {
-    return new ArrayType(
-      this.element,
-      ...this._with({
-        options: { minItems: value },
-      }),
-    )
+    return ArrayType.factory(this.props.element, {
+      ...this.props.options,
+      minItems: value,
+    })
   }
 
   max(value: number) {
-    return new ArrayType(
-      this.element,
-      ...this._with({
-        options: { maxItems: value },
-      }),
-    )
+    return ArrayType.factory(this.props.element, {
+      ...this.props.options,
+      maxItems: value,
+    })
   }
 
   length(value: number) {
-    return new ArrayType(
-      this.element,
-      ...this._with({
-        options: { minItems: value, maxItems: value },
-      }),
-    )
+    return ArrayType.factory(this.props.element, {
+      ...this.props.options,
+      minItems: value,
+      maxItems: value,
+    })
   }
 }

package/src/types/base.ts

@@ -1,109 +1,233 @@
 import {
+  Optional,
   type SchemaOptions,
   type StaticDecode,
   type StaticEncode,
-  type TAny,
-  type TOptional,
   type TSchema,
-  Type,
 } from '@sinclair/typebox'
-import { typeSchema, typeStatic } from '../constants.ts'
-import { Nullable, type TNullable } from '../schemas/nullable.ts'
+import {
+  Nullable,
+  type TNullable,
+  type TOptionalUndefined,
+} from '../schemas/nullable.ts'
+import type { Merge } from '../utils.ts'
+
+export type TypeProps = Record<string, any>
+
+export type TypeParams = {
+  optional?: boolean
+  nullable?: boolean
+  hasDefault?: boolean
+  encode?: (value: any) => any
+}
+
+export type DefaultTypeParams = {
+  optional: false
+  nullable: false
+  hasDefault: false
+  encode?: TypeParams['encode']
+}
 
-type ResolveNullable<T extends TSchema, Is extends boolean> = Is extends true
-  ? TNullable<T>
+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, Is extends boolean> = Is extends true
-  ? TOptional<T>
+type ResolveOptional<
+  T extends TSchema,
+  P extends TypeParams,
+> = P['optional'] extends true
+  ? T extends TOptionalUndefined<infer S>
+    ? TOptionalUndefined<S>
+    : TOptionalUndefined<T>
   : T
 
-type Resolve<
-  Schema extends TSchema,
-  IsNullable extends boolean,
-  IsOptional extends boolean,
-> = ResolveOptional<ResolveNullable<Schema, IsNullable>, IsOptional>
+type ResolveDefault<
+  T extends TSchema,
+  P extends TypeParams,
+> = P['hasDefault'] extends true
+  ? T extends TOptionalUndefined<infer U>
+    ? U
+    : T
+  : T
 
 export abstract class BaseType<
   Schema extends TSchema = TSchema,
-  IsNullable extends boolean = boolean,
-  IsOptional extends boolean = boolean,
-  HasDefault extends boolean = boolean,
-  Options extends SchemaOptions = SchemaOptions,
+  Props extends TypeProps = TypeProps,
+  Params extends TypeParams = DefaultTypeParams,
 > {
-  protected abstract _constructSchema(
-    options: Options,
-    ...constructArgs: any[]
-  ): Schema
-
-  [typeStatic]!: {
-    schema: Resolve<
-      Schema,
-      IsNullable,
-      HasDefault extends true ? false : IsOptional
-    >
-    isOptional: IsOptional
-    isNullable: IsNullable
-    hasDefault: HasDefault
-    encoded: StaticEncode<Resolve<Schema, IsNullable, IsOptional>>
-    decoded: StaticDecode<
-      Resolve<Schema, IsNullable, HasDefault extends true ? false : IsOptional>
-    >
+  abstract _: {
+    encoded: {
+      input: TSchema
+      output: TSchema
+    }
+    decoded: {
+      input: TSchema
+      output: TSchema
+    }
   }
 
+  readonly schema: Schema
+  readonly final: TSchema
+  readonly props: Props
+  readonly params: Params
+
   constructor(
-    protected options: Options = {} as Options,
-    protected isNullable: IsNullable = false as IsNullable,
-    protected isOptional: IsOptional = false as IsOptional,
-    protected hasDefault: HasDefault = false as HasDefault,
-    ...contstructArgs: any[]
+    schema: Schema,
+    props: Props = {} as Props,
+    params: Params = {} as Params,
   ) {
-    let schema: TSchema = this._constructSchema(options, ...contstructArgs)
-    if (this.isNullable) {
-      schema = Nullable(schema)
-    }
-    if (this.isOptional) {
-      schema = Type.Optional(schema)
-    }
-    this[typeSchema] = schema as Schema
+    const { hasDefault = false, nullable = false, optional = false } = params
+    this.schema = schema
+    this.final = schema
+    if (nullable) this.final = Nullable(this.final) as any
+    if (optional || hasDefault) this.final = Optional(this.final) as any
+
+    this.props = props
+    this.params = {
+      hasDefault,
+      nullable,
+      optional,
+    } as Params
+  }
+
+  optional(): OptionalType<this> {
+    return OptionalType.factory(this) as any
   }
-  protected [typeSchema]: Schema
 
-  protected get _args(): [IsNullable, IsOptional, HasDefault] {
-    return [this.isNullable, this.isOptional, this.hasDefault]
+  nullable(): NullableType<this> {
+    return NullableType.factory(this) as any
   }
 
-  protected _with<
-    _IsNullable extends boolean = IsNullable,
-    _IsOptional extends boolean = IsOptional,
-    _HasDefault extends boolean = HasDefault,
-  >({
-    options = this.options as Options,
-    isNullable = this.isNullable as unknown as _IsNullable,
-    isOptional = this.isOptional as unknown as _IsOptional,
-    hasDefault = this.hasDefault as unknown as _HasDefault,
-  }: {
-    options?: Options
-    isNullable?: _IsNullable
-    isOptional?: _IsOptional
-    hasDefault?: _HasDefault
-  } = {}): [Options, _IsNullable, _IsOptional, _HasDefault] {
-    return [{ ...this.options, ...options }, isNullable, isOptional, hasDefault]
+  nullish() {
+    return this.nullable().optional()
   }
 
-  abstract optional(): BaseType<Schema, IsNullable, true, HasDefault>
-  abstract nullish(): BaseType<Schema, true, true, HasDefault>
-  abstract default(value: any): BaseType<Schema, IsNullable, IsOptional, true>
-  abstract description(
-    value: string,
-  ): BaseType<Schema, IsNullable, IsOptional, HasDefault>
-  abstract examples(
-    ...values: any[]
-  ): BaseType<Schema, IsNullable, IsOptional, HasDefault>
+  default(
+    value: StaticDecode<this['_']['decoded']['output']>,
+  ): DefaultType<this> {
+    return DefaultType.factory(
+      this,
+      this.params.encode?.(value) ?? value,
+    ) as any
+  }
+
+  description(description: string): this {
+    const ThisConstructor = this.constructor as any
+    return new ThisConstructor(
+      {
+        ...this.schema,
+        description,
+      },
+      this.props,
+      this.params,
+    ) as any
+  }
+
+  examples(...examples: any[]): this {
+    const ThisConstructor = this.constructor as any
+    return new ThisConstructor(
+      {
+        ...this.schema,
+        examples,
+      },
+      this.props,
+      this.params,
+    ) as any
+  }
 }
 
-export function getTypeSchema<T extends BaseType>(
-  type: T,
-): T[typeStatic]['schema'] {
-  return type[typeSchema]
+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,
+    )
+  }
+}
+
+export class NullableType<
+  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 NullableType<T, Merge<T['params'], { nullable: true }>>(
+      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>
+
+  static factory<T extends BaseTypeAny<any>>(type: T, defaultValue: any) {
+    return new DefaultType<T, Merge<T['params'], { hasDefault: true }>>(
+      { ...type.schema, default: defaultValue },
+      { inner: type },
+      { ...type.params, hasDefault: true } as any,
+    )
+  }
 }

package/src/types/boolean.ts

@@ -1,49 +1,15 @@
-import { type SchemaOptions, type TBoolean, Type } from '@sinclair/typebox'
-import { BaseType } from './base.ts'
-
-export class BooleanType<
-  N extends boolean = false,
-  O extends boolean = false,
-  D extends boolean = false,
-> extends BaseType<TBoolean, N, O, D> {
-  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): TBoolean {
-    return Type.Boolean(options)
-  }
-
-  nullable() {
-    return new BooleanType(...this._with({ isNullable: true }))
-  }
-
-  optional() {
-    return new BooleanType(...this._with({ isOptional: true }))
-  }
-
-  nullish() {
-    return new BooleanType(
-      ...this._with({ isNullable: true, isOptional: true }),
-    )
-  }
-
-  default(value: boolean) {
-    return new BooleanType(
-      ...this._with({ options: { default: value }, hasDefault: true }),
-    )
-  }
-
-  description(description: string) {
-    return new BooleanType(...this._with({ options: { description } }))
-  }
-
-  examples(...examples: [boolean, ...boolean[]]) {
-    return new BooleanType(...this._with({ options: { examples } }))
+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']>
+
+  static factory() {
+    return new BooleanType(Type.Boolean())
   }
 }

package/src/types/custom.ts

@@ -1,90 +1,32 @@
 import {
-  type SchemaOptions,
+  type TAny,
   type TTransform,
   type TUnsafe,
   Type,
 } from '@sinclair/typebox'
-import { BaseType } from './base.ts'
+import { BaseType, type ConstantType } from './base.ts'
 
-type CustomDecode<T> = (value: any) => T
-type CustomEncode<T> = (value: T) => any
+export type CustomTypeDecode<T> = (value: any) => T
+export type CustomTypeEncode<T> = (value: T) => any
 
-export class CustomType<
-  T,
-  S = T,
-  N extends boolean = false,
-  O extends boolean = false,
-  D extends boolean = false,
-> extends BaseType<TTransform<TUnsafe<S>, T>, N, O, D> {
-  constructor(
-    protected readonly decode: CustomDecode<T>,
-    protected readonly encode: CustomEncode<T>,
-    options: SchemaOptions = {},
-    isNullable: N = false as N,
-    isOptional: O = false as O,
-    hasDefault: D = false as D,
-  ) {
-    super(options, isNullable, isOptional, hasDefault, decode, encode)
-  }
-
-  protected _constructSchema(
-    options: SchemaOptions,
-    decode: CustomDecode<T>,
-    encode: CustomEncode<T>,
-  ): TTransform<TUnsafe<S>, T> {
-    return Type.Transform(Type.Any(options) as unknown as TUnsafe<S>)
-      .Decode(decode)
-      .Encode(encode)
-  }
-
-  nullable() {
-    return new CustomType<T, S, true, O, D>(
-      this.decode,
-      this.encode,
-      ...this._with({ isNullable: true }),
-    )
-  }
-
-  optional() {
-    return new CustomType<T, S, N, true, D>(
-      this.decode,
-      this.encode,
-      ...this._with({ isOptional: true }),
-    )
-  }
-
-  nullish() {
-    return new CustomType<T, S, true, true, D>(
-      this.decode,
-      this.encode,
-      ...this._with({ isNullable: true, isOptional: true }),
-    )
-  }
-
-  default(value: T) {
-    return new CustomType<T, S, N, O, true>(
-      this.decode,
-      this.encode,
-      ...this._with({
-        options: { default: this.encode(value) },
-        hasDefault: true,
-      }),
-    )
-  }
-
-  description(description: string) {
-    return new CustomType<T, S, N, O, D>(
-      this.decode,
-      this.encode,
-      ...this._with({ options: { description } }),
-    )
-  }
+export abstract class TransformType<T, S = TAny> extends BaseType<
+  TTransform<TUnsafe<S>, T>
+> {
+  _!: ConstantType<this['schema']>
+}
 
-  examples(...examples: [T, ...T[]]) {
-    return new CustomType<T, S, N, O, D>(
-      this.decode,
-      this.encode,
-      ...this._with({ options: { examples: examples.map(this.encode) } }),
+export class CustomType<T, S = TAny> extends TransformType<T, S> {
+  static factory<T, S = TAny>(
+    decode: CustomTypeDecode<T>,
+    encode: CustomTypeEncode<T>,
+    schema = Type.Any() as unknown as TUnsafe<S>,
+  ) {
+    return new CustomType<T, S>(
+      Type.Transform(schema as unknown as TUnsafe<S>)
+        .Decode(decode)
+        .Encode(encode),
+      {},
+      { encode } as any,
     )
   }
 }

package/src/types/date.ts

@@ -0,0 +1,10 @@
+import { CustomType, TransformType } from './custom.ts'
+
+const decode = (value: any): Date => new Date(value)
+const encode = (value: Date): any => value.toISOString()
+
+export class DateType extends TransformType<Date> {
+  static factory() {
+    return CustomType.factory<Date>(decode, encode)
+  }
+}