@nmtjs/type 0.1.0

package/src/types/base.ts

@@ -0,0 +1,158 @@
+import {
+  type StaticDecode,
+  type StaticEncode,
+  type TAny,
+  type TOptional,
+  type TSchema,
+  Type,
+} from '@sinclair/typebox'
+import { Nullable, type TNullable } from '../schemas/nullable.ts'
+
+export const typeSchema: unique symbol = Symbol()
+export type typeSchema = typeof typeSchema
+
+export const typeOptions: unique symbol = Symbol()
+export type typeOptions = typeof typeOptions
+
+export const typeOptional: unique symbol = Symbol()
+export type typeOptional = typeof typeOptional
+
+export const typeNullable: unique symbol = Symbol()
+export type typeNullable = typeof typeNullable
+
+export const staticType: unique symbol = Symbol()
+export type staticType = typeof staticType
+
+export const typeFinalSchema: unique symbol = Symbol()
+export type typeFinalSchema = typeof typeFinalSchema
+
+type ResolveNullable<T extends TSchema, Is extends boolean> = Is extends true
+  ? T | TNullable<T>
+  : T
+
+type ResolveOptional<T extends TSchema, Is extends boolean> = Is extends true
+  ? T | TOptional<T>
+  : T
+
+type Resolve<
+  Schema extends TSchema,
+  IsNullable extends boolean,
+  IsOptional extends boolean,
+> = ResolveOptional<ResolveNullable<Schema, IsNullable>, IsOptional>
+
+export abstract class BaseType<
+  Schema extends TSchema = any,
+  IsNullable extends boolean = boolean,
+  IsOptional extends boolean = boolean,
+  Final extends Resolve<Schema, IsNullable, IsOptional> = Resolve<
+    Schema,
+    IsNullable,
+    IsOptional
+  >,
+> {
+  [typeSchema]: Schema;
+  [typeNullable]: IsNullable;
+  [typeOptional]: IsOptional;
+
+  [staticType]!: {
+    final: Final
+    isOptional: IsOptional
+    isNullable: IsNullable
+    encoded: StaticEncode<Final>
+    decoded: StaticDecode<Final>
+  }
+
+  constructor(
+    schema: Schema,
+    nullable: IsNullable = false as IsNullable,
+    optional: IsOptional = false as IsOptional,
+  ) {
+    this[typeSchema] = schema
+    this[typeNullable] = nullable
+    this[typeOptional] = optional
+  }
+
+  get [typeFinalSchema](): Final {
+    let schema: TSchema = this._schema
+    if (this._isNullable) {
+      schema = Nullable(schema)
+    }
+    if (this._isOptional) {
+      schema = Type.Optional(schema)
+    }
+    return schema as Final
+  }
+
+  protected get _schema() {
+    return this[typeSchema]
+  }
+
+  protected get _isNullable(): IsNullable {
+    return this[typeNullable]
+  }
+
+  protected get _isOptional(): IsOptional {
+    return this[typeOptional]
+  }
+
+  protected get _isNullableOptional(): [IsNullable, IsOptional] {
+    return [this._isNullable, this._isOptional]
+  }
+
+  protected _contructSelf<T extends any[]>(...args: T) {
+    return args
+  }
+
+  protected _nullable() {
+    return this._contructSelf(this._schema, true as const, this[typeOptional])
+  }
+
+  protected _optional() {
+    return this._contructSelf(this._schema, this[typeNullable], true as const)
+  }
+
+  protected _nullish() {
+    return this._contructSelf(this._schema, true as const, true as const)
+  }
+
+  abstract nullable(): BaseType<Schema, true, IsOptional>
+  abstract optional(): BaseType<Schema, IsNullable, true>
+  abstract nullish(): BaseType<Schema, true, true>
+
+  default(value: StaticDecode<Schema>): this {
+    return this._contructSelf(
+      {
+        ...this._schema,
+        default: value,
+      },
+      this[typeNullable],
+      this[typeOptional],
+    ) as unknown as this
+  }
+
+  description(description: string): this {
+    return this._contructSelf(
+      {
+        ...this._schema,
+        description,
+      },
+      this[typeNullable],
+      this[typeOptional],
+    ) as unknown as this
+  }
+
+  examples(...examples: StaticDecode<Schema>[]): this {
+    return this._contructSelf(
+      {
+        ...this._schema,
+        examples,
+      },
+      this[typeNullable],
+      this[typeOptional],
+    ) as unknown as this
+  }
+}
+
+export function getTypeSchema<T extends BaseType>(type: T): T[typeFinalSchema] {
+  return type[typeFinalSchema]
+}

package/src/types/boolean.ts

@@ -0,0 +1,27 @@
+import { type TBoolean, Type } from '@sinclair/typebox'
+import { BaseType } from './base.ts'
+
+export class BooleanType<
+  N extends boolean = false,
+  O extends boolean = false,
+> extends BaseType<TBoolean, N, O> {
+  constructor(
+    schema: TBoolean = Type.Boolean(),
+    nullable: N = false as N,
+    optional: O = false as O,
+  ) {
+    super(schema, nullable, optional)
+  }
+
+  nullable() {
+    return new BooleanType(...this._nullable())
+  }
+
+  optional() {
+    return new BooleanType(...this._optional())
+  }
+
+  nullish() {
+    return new BooleanType(...this._nullish())
+  }
+}

package/src/types/custom.ts

@@ -0,0 +1,36 @@
+import { type TAny, type TTransform, Type } from '@sinclair/typebox'
+import { BaseType } from './base.ts'
+
+export class CustomType<
+  T,
+  N extends boolean = false,
+  O extends boolean = false,
+> extends BaseType<TTransform<TAny, T>, N, O> {
+  constructor(
+    protected readonly decode: (value: any) => T,
+    protected readonly encode: (value: T) => any,
+    nullable: N = false as N,
+    optional: O = false as O,
+  ) {
+    super(
+      Type.Optional(Type.Transform(Type.Any()).Decode(decode).Encode(encode)),
+      nullable,
+      optional,
+    )
+  }
+
+  nullable() {
+    const [_, ...args] = this._nullable()
+    return new CustomType(this.decode, this.encode, ...args)
+  }
+
+  optional() {
+    const [_, ...args] = this._optional()
+    return new CustomType(this.decode, this.encode, ...args)
+  }
+
+  nullish() {
+    const [_, ...args] = this._nullish()
+    return new CustomType(this.decode, this.encode, ...args)
+  }
+}

package/src/types/datetime.ts

@@ -0,0 +1,60 @@
+import { type TString, type TTransform, Type } from '@sinclair/typebox'
+import { BaseType } from './base.ts'
+
+export class DateType<
+  N extends boolean = false,
+  O extends boolean = false,
+> extends BaseType<TTransform<TString, Date>, N, O> {
+  constructor(
+    schema: TTransform<TString, Date> = Type.Transform(
+      Type.String({ format: 'date' }),
+    )
+      .Decode((value) => new Date(value))
+      .Encode((value) => value.toJSON()),
+    nullable: N = false as N,
+    optional: O = false as O,
+  ) {
+    super(schema, nullable, optional)
+  }
+
+  nullable() {
+    return new DateType(...this._nullable())
+  }
+
+  optional() {
+    return new DateType(...this._optional())
+  }
+
+  nullish() {
+    return new DateType(...this._nullish())
+  }
+}
+
+export class DateTimeType<
+  N extends boolean = false,
+  O extends boolean = false,
+> extends BaseType<TTransform<TString, Date>, N, O> {
+  constructor(
+    schema: TTransform<TString, Date> = Type.Transform(
+      Type.String({ format: 'date-time' }),
+    )
+      .Decode((value) => new Date(value))
+      .Encode((value) => value.toJSON()),
+    nullable: N = false as N,
+    optional: O = false as O,
+  ) {
+    super(schema, nullable, optional)
+  }
+
+  nullable() {
+    return new DateTimeType(...this._nullable())
+  }
+
+  optional() {
+    return new DateTimeType(...this._optional())
+  }
+
+  nullish() {
+    return new DateTimeType(...this._nullish())
+  }
+}

package/src/types/enum.ts

@@ -0,0 +1,62 @@
+import type { TNativeEnum } from '../schemas/native-enum.ts'
+import { NativeEnum } from '../schemas/native-enum.ts'
+import { type TUnionEnum, UnionEnum } from '../schemas/union-enum.ts'
+import { BaseType } from './base.ts'
+
+export class NativeEnumType<
+  T extends { [K in string]: K } = { [K in string]: K },
+  N extends boolean = false,
+  O extends boolean = false,
+> extends BaseType<TNativeEnum<T>, N, O> {
+  constructor(
+    readonly values: T,
+    nullable: N = false as N,
+    optional: O = false as O,
+  ) {
+    super(NativeEnum(values), nullable, optional)
+  }
+
+  nullable() {
+    const [_, ...args] = this._nullable()
+    return new NativeEnumType(this.values, ...args)
+  }
+
+  optional() {
+    const [_, ...args] = this._optional()
+    return new NativeEnumType(this.values, ...args)
+  }
+
+  nullish() {
+    const [_, ...args] = this._nullish()
+    return new NativeEnumType(this.values, ...args)
+  }
+}
+
+export class EnumType<
+  T extends (string | number)[],
+  N extends boolean = false,
+  O extends boolean = false,
+> extends BaseType<TUnionEnum<T>, N, O> {
+  constructor(
+    readonly values: [...T],
+    nullable: N = false as N,
+    optional: O = false as O,
+  ) {
+    super(UnionEnum(values), nullable, optional)
+  }
+
+  nullable() {
+    const [_, ...args] = this._nullable()
+    return new EnumType(this.values, ...args)
+  }
+
+  optional() {
+    const [_, ...args] = this._optional()
+    return new EnumType(this.values, ...args)
+  }
+
+  nullish() {
+    const [_, ...args] = this._nullish()
+    return new EnumType(this.values, ...args)
+  }
+}

package/src/types/literal.ts

@@ -0,0 +1,31 @@
+import { type TLiteral, type TLiteralValue, Type } from '@sinclair/typebox'
+import { BaseType } from './base.ts'
+
+export class LiteralType<
+  T extends TLiteralValue = TLiteralValue,
+  N extends boolean = false,
+  O extends boolean = false,
+> extends BaseType<TLiteral<T>, N, O> {
+  constructor(
+    readonly value: T,
+    nullable: N = false as N,
+    optional: O = false as O,
+  ) {
+    super(Type.Literal(value), nullable, optional)
+  }
+
+  nullable() {
+    const [_, ...args] = this._nullable()
+    return new LiteralType(this.value, ...args)
+  }
+
+  optional() {
+    const [_, ...args] = this._optional()
+    return new LiteralType(this.value, ...args)
+  }
+
+  nullish() {
+    const [_, ...args] = this._nullish()
+    return new LiteralType(this.value, ...args)
+  }
+}

package/src/types/never.ts

@@ -0,0 +1,30 @@
+import { type TNever, Type } from '@sinclair/typebox'
+import { BaseType } from './base.ts'
+
+export class NeverType<
+  N extends boolean = false,
+  O extends boolean = false,
+> extends BaseType<TNever, N, O> {
+  constructor(
+    schema = Type.Never(),
+    nullable: N = false as N,
+    optional: O = false as O,
+  ) {
+    super(schema, nullable, optional)
+  }
+
+  // @ts-expect-error
+  nullable() {
+    throw new Error('NeverType cannot be nullable')
+  }
+
+  // @ts-expect-error
+  optional() {
+    throw new Error('NeverType cannot be optional')
+  }
+
+  // @ts-expect-error
+  nullish() {
+    throw new Error('NeverType cannot be nullish')
+  }
+}

package/src/types/number.ts

@@ -0,0 +1,124 @@
+import { type TInteger, type TNumber, Type } from '@sinclair/typebox'
+import { BaseType } from './base.ts'
+
+export class NumberType<
+  N extends boolean = false,
+  O extends boolean = false,
+> extends BaseType<TNumber, N, O> {
+  constructor(
+    schema: TNumber = Type.Number(),
+    nullable: N = false as N,
+    optional: O = false as O,
+  ) {
+    super(schema, nullable, optional)
+  }
+
+  positive() {
+    return new NumberType(
+      Type.Number({ ...this._schema, minimum: 0, exclusiveMinimum: 0 }),
+      ...this._isNullableOptional,
+    )
+  }
+
+  negative() {
+    return new NumberType(
+      Type.Number({ ...this._schema, maximum: 0, exclusiveMaximum: 0 }),
+      ...this._isNullableOptional,
+    )
+  }
+
+  max(value: number, exclusive?: true) {
+    return new NumberType(
+      Type.Number({
+        ...this._schema,
+        maximum: value,
+        ...(exclusive ? {} : { exclusiveMaximum: value }),
+      }),
+      ...this._isNullableOptional,
+    )
+  }
+
+  min(value: number, exclusive?: true) {
+    return new NumberType(
+      Type.Number({
+        ...this._schema,
+        minimum: value,
+        ...(exclusive ? {} : { exclusiveMinimum: value }),
+      }),
+      ...this._isNullableOptional,
+    )
+  }
+
+  nullable() {
+    return new NumberType(...this._nullable())
+  }
+
+  optional() {
+    return new NumberType(...this._optional())
+  }
+
+  nullish() {
+    return new NumberType(...this._nullish())
+  }
+}
+
+export class IntegerType<
+  N extends boolean = false,
+  O extends boolean = false,
+> extends BaseType<TInteger, N, O> {
+  constructor(
+    schema: TInteger = Type.Integer(),
+    nullable: N = false as N,
+    optional: O = false as O,
+  ) {
+    super(schema, nullable, optional)
+  }
+
+  positive() {
+    return new IntegerType(
+      Type.Integer({ ...this._schema, minimum: 0, exclusiveMinimum: 0 }),
+      ...this._isNullableOptional,
+    )
+  }
+
+  negative() {
+    return new IntegerType(
+      Type.Integer({ ...this._schema, maximum: 0, exclusiveMaximum: 0 }),
+      ...this._isNullableOptional,
+    )
+  }
+
+  max(value: number, exclusive?: true) {
+    return new IntegerType(
+      Type.Integer({
+        ...this._schema,
+        maximum: value,
+        ...(exclusive ? {} : { exclusiveMaximum: value }),
+      }),
+      ...this._isNullableOptional,
+    )
+  }
+
+  min(value: number, exclusive?: true) {
+    return new IntegerType(
+      Type.Integer({
+        ...this._schema,
+        minimum: value,
+        ...(exclusive ? {} : { exclusiveMinimum: value }),
+      }),
+      ...this._isNullableOptional,
+    )
+  }
+
+  nullable() {
+    return new IntegerType(...this._nullable())
+  }
+
+  optional() {
+    return new IntegerType(...this._optional())
+  }
+
+  nullish() {
+    return new IntegerType(...this._nullish())
+  }
+}

package/src/types/object.ts

@@ -0,0 +1,83 @@
+import { type TObject, Type } from '@sinclair/typebox'
+import type { UnionToTupleString } from '../utils.ts'
+import { BaseType, typeFinalSchema } from './base.ts'
+import { EnumType } from './enum.ts'
+
+export class ObjectType<
+  T extends Record<string, BaseType> = Record<string, BaseType>,
+  N extends boolean = false,
+  O extends boolean = false,
+> extends BaseType<TObject<{ [K in keyof T]: T[K][typeFinalSchema] }>, N, O> {
+  constructor(
+    readonly properties: T = {} as T,
+    nullable: N = false as N,
+    optional: O = false as O,
+  ) {
+    const schemaProperties = Object.fromEntries(
+      Object.entries(properties).map(([key, value]) => [
+        key,
+        value[typeFinalSchema],
+      ]),
+    )
+    super(
+      Type.Object(
+        schemaProperties as { [K in keyof T]: T[K][typeFinalSchema] },
+      ),
+      nullable,
+      optional,
+    )
+  }
+
+  nullable() {
+    const [_, ...args] = this._nullable()
+    return new ObjectType(this.properties, ...args)
+  }
+
+  optional() {
+    const [_, ...args] = this._optional()
+    return new ObjectType(this.properties, ...args)
+  }
+
+  nullish() {
+    const [_, ...args] = this._nullish()
+    return new ObjectType(this.properties, ...args)
+  }
+
+  pick<P extends { [K in keyof T]?: true }>(pick: P) {
+    const properties = Object.fromEntries(
+      Object.entries(this.properties).filter(([key]) => pick[key]),
+    )
+    return new ObjectType(
+      properties as Pick<T, Extract<keyof P, keyof T>>,
+      ...this._isNullableOptional,
+    )
+  }
+
+  omit<P extends { [K in keyof T]?: true }>(omit: P) {
+    const properties = Object.fromEntries(
+      Object.entries(this.properties).filter(([key]) => !omit[key]),
+    )
+    return new ObjectType(
+      properties as Omit<T, Extract<keyof P, keyof T>>,
+      ...this._isNullableOptional,
+    )
+  }
+
+  extend<P extends Record<string, BaseType>>(properties: P) {
+    return new ObjectType(
+      { ...this.properties, ...properties },
+      ...this._isNullableOptional,
+    )
+  }
+
+  merge<T extends ObjectType>(object: T) {
+    return new ObjectType(
+      { ...this.properties, ...object.properties },
+      ...this._isNullableOptional,
+    )
+  }
+
+  keyof(): EnumType<UnionToTupleString<keyof T>> {
+    return new EnumType(Object.keys(this.properties) as any)
+  }
+}

package/src/types/string.ts

@@ -0,0 +1,87 @@
+import { type TString, Type } from '@sinclair/typebox'
+import { BaseType } from './base.ts'
+
+export class StringType<
+  N extends boolean = false,
+  O extends boolean = false,
+> extends BaseType<TString, N, O> {
+  constructor(
+    schema = Type.String(),
+    nullable: N = false as N,
+    optional: O = false as O,
+  ) {
+    super(schema, nullable, optional)
+  }
+
+  nullable() {
+    return new StringType(...this._nullable())
+  }
+
+  optional() {
+    return new StringType(...this._optional())
+  }
+
+  nullish() {
+    return new StringType(...this._nullish())
+  }
+
+  format(format: TString['format']) {
+    return new StringType(
+      {
+        ...this._schema,
+        format,
+      },
+      ...this._isNullableOptional,
+    )
+  }
+
+  max(value: number) {
+    return new StringType(
+      {
+        ...this._schema,
+        maxLength: value,
+      },
+      ...this._isNullableOptional,
+    )
+  }
+
+  min(value: number) {
+    return new StringType(
+      {
+        ...this._schema,
+        minLength: value,
+      },
+      ...this._isNullableOptional,
+    )
+  }
+
+  pattern(pattern: string) {
+    return new StringType(
+      {
+        ...this._schema,
+        pattern,
+      },
+      ...this._isNullableOptional,
+    )
+  }
+
+  email() {
+    return this.format('email')
+  }
+
+  url() {
+    return this.format('uri')
+  }
+
+  ipv4() {
+    return this.format('ipv4')
+  }
+
+  ipv6() {
+    return this.format('ipv6')
+  }
+
+  uuid() {
+    return this.format('uuid')
+  }
+}