@nmtjs/type 0.4.7 → 0.5.0

package/src/types/object.ts

@@ -1,229 +1,88 @@
 import {
   type ObjectOptions,
   type TObject,
-  type TRecord,
+  type TRecordOrObject,
+  type TSchema,
   Type,
 } from '@sinclair/typebox'
-import type { typeStatic } from '../constants.ts'
-import type { UnionToTupleString } from '../utils.ts'
-import { BaseType, getTypeSchema } from './base.ts'
-import { type AnyEnumType, type AnyObjectEnumType, EnumType } from './enum.ts'
-import type { AnyLiteralType } from './literal.ts'
-import type { AnyStringType } from './string.ts'
-import type { AnyUnionType } from './union.ts'
+import { BaseType, type BaseTypeAny } from './base.ts'
+import type { EnumType, ObjectEnumType } from './enum.ts'
+import type { LiteralType } from './literal.ts'
+import type { StringType } from './string.ts'
 
+export type ObjectTypeProps = { [k: string]: BaseTypeAny<any> }
 export class ObjectType<
-  T extends Record<string, BaseType>,
-  N extends boolean = false,
-  O extends boolean = false,
-  D extends boolean = false,
+  T extends ObjectTypeProps = ObjectTypeProps,
 > extends BaseType<
-  TObject<{ [K in keyof T]: T[K][typeStatic]['schema'] }>,
-  N,
-  O,
-  D
+  TObject<{ [K in keyof T]: T[K]['schema'] }>,
+  { properties: T }
 > {
-  constructor(
-    protected readonly properties: T = {} as T,
-    options: ObjectOptions = {},
-    isNullable: N = false as N,
-    isOptional: O = false as O,
-    hasDefault: D = false as D,
-  ) {
-    super(options, isNullable, isOptional, hasDefault, properties)
-  }
-
-  protected _constructSchema(
-    options: ObjectOptions,
-    properties: T,
-  ): TObject<{ [K in keyof T]: T[K][typeStatic]['schema'] }> {
-    const schemaProperties = {} as {
-      [K in keyof T]: T[K][typeStatic]['schema']
+  declare _: {
+    encoded: {
+      input: TObject<{ [K in keyof T]: T[K]['_']['encoded']['input'] }>
+      output: TObject<{ [K in keyof T]: T[K]['_']['encoded']['output'] }>
     }
-
-    for (const [key, value] of Object.entries(properties)) {
-      // @ts-expect-error
-      schemaProperties[key] = getTypeSchema(value)
+    decoded: {
+      input: TObject<{ [K in keyof T]: T[K]['_']['decoded']['input'] }>
+      output: TObject<{ [K in keyof T]: T[K]['_']['decoded']['output'] }>
     }
-    return Type.Object(schemaProperties, options)
-  }
-
-  nullable() {
-    return new ObjectType(this.properties, ...this._with({ isNullable: true }))
-  }
-
-  optional() {
-    return new ObjectType(this.properties, ...this._with({ isOptional: true }))
-  }
-
-  nullish() {
-    return new ObjectType(
-      this.properties,
-      ...this._with({ isNullable: true, isOptional: true }),
-    )
-  }
-
-  default(value: this[typeStatic]['encoded']) {
-    return new ObjectType(
-      this.properties,
-      ...this._with({ options: { default: value }, hasDefault: true }),
-    )
-  }
-
-  description(description: string) {
-    return new ObjectType(
-      this.properties,
-      ...this._with({ options: { description } }),
-    )
   }
 
-  examples(
-    ...examples: [this[typeStatic]['encoded'], ...this[typeStatic]['encoded'][]]
+  static factory<T extends ObjectTypeProps = ObjectTypeProps>(
+    properties: T,
+    options: ObjectOptions = {},
   ) {
-    return new ObjectType(
-      this.properties,
-      ...this._with({ options: { examples } }),
-    )
-  }
-
-  pick<P extends { [K in keyof T]?: true }>(pick: P) {
-    const properties = Object.fromEntries(
-      Object.entries(this.properties).filter(([key]) => pick[key]),
-    )
-    const [_, ...args] = this._with()
-    return new ObjectType(
-      properties as Pick<T, Extract<keyof P, keyof T>>,
-      {},
-      ...args,
-    )
-  }
-
-  omit<P extends { [K in keyof T]?: true }>(omit: P) {
-    const properties = Object.fromEntries(
-      Object.entries(this.properties).filter(([key]) => !omit[key]),
-    )
-    const [_, ...args] = this._with()
-    return new ObjectType(
-      properties as Omit<T, Extract<keyof P, keyof T>>,
-      {},
-      ...args,
-    )
-  }
-
-  extend<P extends Record<string, BaseType>>(properties: P) {
-    const [_, ...args] = this._with()
-    return new ObjectType({ ...this.properties, ...properties }, {}, ...args)
-  }
-
-  merge<T extends ObjectType<Record<string, BaseType>>>(object: T) {
-    const [_, ...args] = this._with()
-    return new ObjectType(
-      { ...this.properties, ...object.properties },
-      {},
-      ...args,
-    )
-  }
+    const schemaProperties = {} as {
+      [K in keyof T]: T[K]['schema']
+    }
 
-  partial() {
-    const properties: { [K in keyof T]: ReturnType<T[K]['optional']> } =
-      {} as any
-    for (const [key, value] of Object.entries(this.properties)) {
-      // @ts-expect-error
-      properties[key] = value.optional()
+    for (const key in properties) {
+      schemaProperties[key] = properties[key].schema
     }
-    const [_, ...args] = this._with()
-    return new ObjectType(properties, {}, ...args)
-  }
 
-  keyof(): EnumType<UnionToTupleString<keyof T>> {
-    return new EnumType(Object.keys(this.properties) as any)
+    return new ObjectType<T>(Type.Object(schemaProperties, options) as any, {
+      properties,
+    })
   }
 }
 
 export class RecordType<
-  K extends
-    | AnyLiteralType
-    | AnyEnumType
-    | AnyObjectEnumType
-    | AnyStringType
-    | AnyUnionType,
+  K extends LiteralType | EnumType | ObjectEnumType | StringType,
   E extends BaseType,
-  N extends boolean = false,
-  O extends boolean = false,
-  D extends boolean = false,
-> extends BaseType<
-  TRecord<K[typeStatic]['schema'], E[typeStatic]['schema']>,
-  N,
-  O,
-  D,
-  ObjectOptions
-> {
-  constructor(
-    protected readonly key: K,
-    protected readonly element: E,
-    options: ObjectOptions = {},
-    isNullable: N = false as N,
-    isOptional: O = false as O,
-    hasDefault: D = false as D,
-  ) {
-    super(options, isNullable, isOptional, hasDefault, key, element)
-  }
-
-  protected _constructSchema(options: ObjectOptions, key: K, element: E) {
-    return Type.Record(
-      getTypeSchema(key),
-      getTypeSchema(element),
-      options,
-    ) as unknown as TRecord<K[typeStatic]['schema'], E[typeStatic]['schema']>
-  }
-
-  nullable() {
-    return new RecordType(
-      this.key,
-      this.element,
-      ...this._with({ isNullable: true }),
-    )
-  }
-
-  optional() {
-    return new RecordType(
-      this.key,
-      this.element,
-      ...this._with({ isOptional: true }),
-    )
-  }
-
-  nullish() {
-    return new RecordType(
-      this.key,
-      this.element,
-      ...this._with({ isNullable: true, isOptional: true }),
-    )
-  }
-
-  default(value: this[typeStatic]['encoded']) {
-    return new RecordType(
-      this.key,
-      this.element,
-      ...this._with({ options: { default: value }, hasDefault: true }),
-    )
-  }
-
-  description(description: string) {
-    return new RecordType(
-      this.key,
-      this.element,
-      ...this._with({ options: { description } }),
-    )
+> extends BaseType<TRecordOrObject<K['schema'], E['schema']>> {
+  _!: {
+    encoded: {
+      input: TRecordOrObject<
+        K['_']['encoded']['input'],
+        E['_']['encoded']['input']
+      >
+      output: TRecordOrObject<
+        K['_']['encoded']['output'],
+        E['_']['encoded']['output']
+      >
+    }
+    decoded: {
+      input: TRecordOrObject<
+        K['_']['decoded']['input'],
+        E['_']['decoded']['input']
+      >
+      output: TRecordOrObject<
+        K['_']['decoded']['output'],
+        E['_']['decoded']['output']
+      >
+    }
   }
 
-  examples(
-    ...examples: [this[typeStatic]['encoded'], ...this[typeStatic]['encoded'][]]
-  ) {
-    return new RecordType(
-      this.key,
-      this.element,
-      ...this._with({ options: { examples } }),
+  static factory<
+    K extends
+      | LiteralType<any>
+      | EnumType<any>
+      | ObjectEnumType<any>
+      | StringType,
+    E extends BaseType,
+  >(key: K, element: E, options: ObjectOptions = {}) {
+    return new RecordType<K, E>(
+      Type.Record(key.schema, element.schema, options) as any,
     )
   }
 }

package/src/types/string.ts

@@ -1,77 +1,41 @@
 import { type StringOptions, type TString, Type } from '@sinclair/typebox'
-import { BaseType } from './base.ts'
+import { BaseType, type ConstantType, type TypeParams } from './base.ts'
 
-export type AnyStringType = StringType<boolean, boolean, boolean>
-export class StringType<
-  N extends boolean = false,
-  O extends boolean = false,
-  D extends boolean = false,
-> extends BaseType<TString, N, O, D, StringOptions> {
-  constructor(
-    options: StringOptions = {},
-    isNullable: N = false as N,
-    isOptional: O = false as O,
-    hasDefault: D = false as D,
-  ) {
-    super(options, isNullable, isOptional, hasDefault)
-  }
-
-  protected _constructSchema(options: StringOptions): TString {
-    return Type.String(options)
-  }
-
-  nullable() {
-    return new StringType(...this._with({ isNullable: true }))
-  }
-
-  optional() {
-    return new StringType(...this._with({ isOptional: true }))
-  }
-
-  nullish() {
-    return new StringType(...this._with({ isNullable: true, isOptional: true }))
-  }
+export class StringType extends BaseType<TString, { options: StringOptions }> {
+  _!: ConstantType<TString>
 
-  default(value: string) {
-    return new StringType(
-      ...this._with({ options: { default: value }, hasDefault: true }),
-    )
+  static factory(options: StringOptions = {}) {
+    return new StringType(Type.String(options), { options })
   }
 
-  description(description: string) {
-    return new StringType(...this._with({ options: { description } }))
+  max(value: number) {
+    return StringType.factory({
+      ...this.props.options,
+      maxLength: value,
+    })
   }
 
-  examples(...examples: string[]) {
-    return new StringType(...this._with({ options: { examples } }))
+  min(value: number) {
+    return StringType.factory({
+      ...this.props.options,
+      minLength: value,
+    })
   }
 
   format(format: TString['format']) {
-    return new StringType(...this._with({ options: { format } }))
-  }
-
-  max(value: number) {
-    return new StringType(
-      ...this._with({
-        options: { maxLength: value },
-      }),
-    )
-  }
-
-  min(value: number) {
-    return new StringType(
-      ...this._with({
-        options: { minLength: value },
-      }),
-    )
+    return StringType.factory({
+      ...this.props.options,
+      pattern: undefined,
+      format,
+    })
   }
 
   pattern(pattern: string) {
-    return new StringType(
-      ...this._with({
-        options: { pattern },
-      }),
-    )
+    return StringType.factory({
+      ...this.props.options,
+      format: undefined,
+      pattern,
+    })
   }
 
   email() {