galbe 0.1.6 → 0.1.7

package/src/types.ts

@@ -1,117 +1,54 @@
+import type { ServeOptions, TLSServeOptions } from 'bun'
 import type {
-  TSchema,
-  TBoolean,
-  TNumber,
-  TInteger,
-  TString,
-  TLiteral,
-  TArray,
-  TObject,
-  TProperties,
-  TUnion,
-  Static,
-  OptionalPropertyKeys,
-  ReadonlyOptionalPropertyKeys,
-  ReadonlyPropertyKeys,
-  RequiredPropertyKeys,
-  TAny
-} from '@sinclair/typebox'
+  STArray,
+  STBoolean,
+  STByteArray,
+  STInteger,
+  STLiteral,
+  STMultipartForm,
+  STNumber,
+  STObject,
+  STStream,
+  STString,
+  STUnion,
+  STUrlForm,
+  Static
+} from './schema'
+import type { Galbe } from './index'
 
-import { Kind } from '@sinclair/typebox'
-import { Galbe } from './index'
-
-export const Stream = Symbol.for('Galbe.Stream')
-export type TStream<T extends TSchema = TSchema> = T & {
-  [Stream]: 'Stream'
-}
-
-export type TBody =
-  | TByteArray
-  | TString
-  | TBoolean
-  | TNumber
-  | TInteger
-  | TObject
-  | TArray
-  | TUrlForm
-  | TMultipartForm
-  | TUnion
-  | TStream
-export type TStreamable = TByteArray | TString | TUrlForm | TMultipartForm
-export type TUrlFormParam = TString | TByteArray | TBoolean | TNumber | TInteger | TLiteral | TArray | TAny | TUnion
-export type TMultipartFormParam = TByteArray | TUrlFormParam | TObject | TArray
+export type STBody =
+  | STByteArray
+  | STString
+  | STBoolean
+  | STNumber
+  | STInteger
+  | STObject
+  | STArray
+  | STUrlForm
+  | STMultipartForm
+  | STUnion
+  | STStream
 export type MaybeArray<T> = T | T[]
 
-export interface MultipartFormData<
-  K extends string | number | symbol = string,
-  V extends Static<TMultipartFormParam> = any
-> {
-  headers: { type?: string; name: K; filename?: string }
-  content: V
-}
-
-export interface TByteArray extends TSchema {
-  [Kind]: 'ByteArray'
-  static: Uint8Array
-  type: 'byteArray'
-}
-export interface TMultipartForm<T extends TMultipartProperties = TMultipartProperties> extends TSchema {
-  [Kind]: 'MultipartForm'
-  static: MultipartPropertiesReduce<T, this['params']>
-  type: 'multipartForm'
-}
-export interface TUrlForm<T extends TUrlFormProperties = TUrlFormProperties> extends TSchema {
-  [Kind]: 'UrlForm'
-  static: UrlFormPropertiesReduce<T, this['params']>
-  type: 'urlForm'
-}
+export type Method = 'get' | 'post' | 'put' | 'delete' | 'patch' | 'options'
+type MaybePromise<T> = T | Promise<T>
 
-export type TMultipartProperties<V = TMultipartFormParam> = Record<string, V>
-export type MultipartPropertiesReduce<T extends TMultipartProperties, P extends unknown[]> = MultipartPropertiesReducer<
-  T,
-  {
-    [K in keyof T]: Static<T[K], P>
-  }
->
-export type MultipartPropertiesReducer<
-  T extends TMultipartProperties,
-  R extends Record<keyof any, unknown>
-> = MultipartEvaluate<
-  Readonly<Partial<Pick<R, ReadonlyOptionalPropertyKeys<T>>>> &
-    Readonly<Pick<R, ReadonlyPropertyKeys<T>>> &
-    Partial<Pick<R, OptionalPropertyKeys<T>>> &
-    Required<Pick<R, RequiredPropertyKeys<T>>>
->
-export type MultipartEvaluate<T> = T extends infer O
-  ? {
-      [K in keyof O]: O[K] extends Static<TMultipartFormParam> ? MultipartFormData<K, O[K]> : never
-    }
+export type ExtractParams<T extends string> = T extends `/:${infer P}/${infer Rest}`
+  ? P | ExtractParams<Rest>
+  : T extends `${infer _}:${infer P}/${infer Rest}`
+  ? P | ExtractParams<Rest>
+  : T extends `${infer _}:${infer P}`
+  ? P
   : never
 
-export type TUrlFormProperties<V = TUrlFormParam> = Record<string, V>
-export type UrlFormPropertiesReduce<T extends TUrlFormProperties, P extends unknown[]> = UrlFormPropertiesReducer<
-  T,
-  {
-    [K in keyof T]: Static<T[K], P>
-  }
->
-export type UrlFormPropertiesReducer<
-  T extends TUrlFormProperties,
-  R extends Record<keyof any, unknown>
-> = UrlFormEvaluate<
-  Readonly<Partial<Pick<R, ReadonlyOptionalPropertyKeys<T>>>> &
-    Readonly<Pick<R, ReadonlyPropertyKeys<T>>> &
-    Partial<Pick<R, OptionalPropertyKeys<T>>> &
-    Required<Pick<R, RequiredPropertyKeys<T>>>
->
-export type UrlFormEvaluate<T> = T extends infer O
-  ? {
-      [K in keyof O]: O[K] extends Static<TUrlFormParam> ? O[K] : never
-    }
-  : never
+type STHeadersValue = STString | STBoolean | STNumber | STInteger | STLiteral | STUnion
+export type STHeaders = Record<string, STHeadersValue>
 
-export type Method = 'get' | 'post' | 'put' | 'delete' | 'patch' | 'options'
-type MaybePromise<T> = T | Promise<T>
+type STParamsValue = STString | STBoolean | STNumber | STInteger | STLiteral | STUnion
+export type STParams<Path extends string = string> = Record<ExtractParams<Path>, STParamsValue>
+
+type STQueryValue = STString | STBoolean | STNumber | STInteger | STLiteral | STUnion
+export type STQuery = Record<string, STQueryValue>
 
 /**
  * #### GalbeConfig
@@ -133,7 +70,8 @@ type MaybePromise<T> = T | Promise<T>
 export type GalbeConfig = {
   port?: number
   basePath?: string
-  routes?: string | string[]
+  server?: Exclude<ServeOptions, 'port'> | TLSServeOptions
+  routes?: boolean | string | string[]
   plugin?: Record<string, any>
 }
 /**
@@ -143,33 +81,46 @@ export type GalbeConfig = {
  * ---
  * @example
  * ```typescript
- * import { T, Schema } from 'galbe'
+ * import { $T } from 'galbe'
  * const MyRequestSchema = {
  *   params: {
- *    id: T.Number(),
+ *    id: $T.number(),
  *   },
- *   body: T.Object({
- *     name: T.String()
- *     age: T.Optional(T.Number({minimum: 0})),
+ *   body: $T.object({
+ *     name: $T.string()
+ *     age: $T.optional($T.number({min: 0})),
  *   })
  * }
  * ```
  */
-export type Schema<
-  H extends TProperties = TProperties,
-  P extends TProperties = TProperties,
-  Q extends TProperties = TProperties,
-  B extends TBody = TBody
+export type RequestSchema<
+  Path extends string = string,
+  H extends STHeaders = {},
+  P extends Partial<STParams<Path>> = {},
+  Q extends STQuery = {},
+  B extends STBody = STBody
 > = {
   headers?: H
   params?: P
   query?: Q
   body?: B
 }
-export type Context<S extends Schema = any> = {
-  headers: Static<TObject<Exclude<S['headers'], undefined>>>
-  params: Static<TObject<Exclude<S['params'], undefined>>>
-  query: Static<TObject<Exclude<S['query'], undefined>>>
+
+type OmitNotDefined<S extends RequestSchema> = {
+  [K in keyof Exclude<S['params'], undefined> as Exclude<S['params'], undefined>[K] extends Required<
+    Exclude<S['params'], undefined>
+  >[K]
+    ? K
+    : //@ts-ignore
+      never]: Static<STObject<Exclude<S['params'], undefined>>>[K]
+}
+
+export type Context<Path extends string = string, S extends RequestSchema = RequestSchema> = {
+  headers: Static<STObject<Exclude<S['headers'], undefined>>>
+  params: {
+    [K in ExtractParams<Path>]: K extends keyof OmitNotDefined<S> ? OmitNotDefined<S>[K] : string
+  }
+  query: Static<STObject<Exclude<S['query'], undefined>>>
   body: Static<Exclude<S['body'], undefined>>
   request: Request
   state: Record<string, any>
@@ -182,28 +133,57 @@ export type Context<S extends Schema = any> = {
   }
 }
 export type Next = () => void | Promise<void>
-export type Hook<S extends Schema = Schema> = (ctx: Context<S>, next: Next) => any | Promise<any>
-export type Handler<S extends Schema = Schema> = (ctx: Context<S>) => any
+export type Hook<Path extends string = string, S extends RequestSchema = RequestSchema> = (
+  ctx: Context<Path, S>,
+  next: Next
+) => any | Promise<any>
+export type Handler<Path extends string = string, S extends RequestSchema = RequestSchema> = (
+  ctx: Context<Path, S>
+) => any
 export type Endpoint = {
-  <H extends TProperties, P extends TProperties, Q extends TProperties, B extends TBody = TObject>(
-    path: string,
-    schema: Schema<H, P, Q, B>,
-    hooks: Hook<Schema<H, P, Q, B>>[],
-    handler: Handler<Schema<H, P, Q, B>>
+  <
+    Path extends string,
+    H extends STHeaders,
+    P extends Partial<STParams<Path>>,
+    Q extends STQuery,
+    B extends STBody = STObject
+  >(
+    path: Path,
+    schema: RequestSchema<Path, H, P, Q, B>,
+    hooks: Hook<Path, RequestSchema<Path, H, P, Q, B>>[],
+    handler: Handler<Path, RequestSchema<Path, H, P, Q, B>>
   ): void
-  <H extends TProperties, P extends TProperties, Q extends TProperties, B extends TBody = TObject>(
-    path: string,
-    schema: Schema<H, P, Q, B>,
-    handler: Handler<Schema<H, P, Q, B>>
+  <
+    Path extends string,
+    H extends STHeaders,
+    P extends Partial<STParams<Path>>,
+    Q extends STQuery,
+    B extends STBody = STObject
+  >(
+    path: Path,
+    schema: RequestSchema<Path, H, P, Q, B>,
+    handler: Handler<Path, RequestSchema<Path, H, P, Q, B>>
   ): void
-  <H extends TProperties, P extends TProperties, Q extends TProperties, B extends TBody = TObject>(
-    path: string,
-    hooks: Hook<Schema<H, P, Q, B>>[],
-    handler: Handler<Schema<H, P, Q, B>>
+  <
+    Path extends string,
+    H extends STHeaders,
+    P extends Partial<STParams<Path>>,
+    Q extends STQuery,
+    B extends STBody = STObject
+  >(
+    path: Path,
+    hooks: Hook<Path, RequestSchema<Path, H, P, Q, B>>[],
+    handler: Handler<Path, RequestSchema<Path, H, P, Q, B>>
   ): void
-  <H extends TProperties, P extends TProperties, Q extends TProperties, B extends TBody = TObject>(
-    path: string,
-    handler: Handler<Schema<H, P, Q, B>>
+  <
+    Path extends string,
+    H extends STHeaders,
+    P extends Partial<STParams<Path>>,
+    Q extends STQuery,
+    B extends STBody = STObject
+  >(
+    path: Path,
+    handler: Handler<Path, RequestSchema<Path, H, P, Q, B>>
   ): void
 }
 
@@ -225,17 +205,18 @@ export type RouteNode = {
 }
 
 export type Route<
-  H extends TProperties = TProperties,
-  P extends TProperties = TProperties,
-  Q extends TProperties = TProperties,
-  B extends TBody = TBody
+  Path extends string = string,
+  H extends STHeaders = {},
+  P extends Partial<STParams<Path>> = {},
+  Q extends STQuery = {},
+  B extends STBody = STBody
 > = {
   method: Method
-  path: string
-  schema: Schema<H, P, Q, B>
-  context: Context<Schema<H, P, Q, B>>
+  path: Path
+  schema: RequestSchema<Path, H, P, Q, B>
+  context: Context<Path, RequestSchema<Path, H, P, Q, B>>
   hooks: Hook[]
-  handler: Handler<Schema<H, P, Q, B>>
+  handler: Handler<Path, RequestSchema<Path, H, P, Q, B>>
 }
 
 export type RouteTree = {

package/src/validator.ts

@@ -1,29 +1,28 @@
-import type { TProperties, TSchema } from '@sinclair/typebox'
+import type { STSchema, STProps, STUnion } from './schema'
+import { Kind, Optional } from './schema'
 
-import { Kind, Optional } from '@sinclair/typebox'
-
-export const validate = (elt: any, schema: TSchema, parse = false): any => {
+export const validate = (elt: any, schema: STSchema, parse = false): any => {
   type ValidationError = string | string[] | { [key: string]: ValidationError }
   const errors: ValidationError[] = []
   const iElt = elt
 
-  if (schema[Kind] === 'Boolean') {
+  if (schema[Kind] === 'boolean') {
     if (parse && typeof elt === 'string') elt = elt === 'true' ? true : elt === 'false' ? false : null
     if (elt !== true && elt !== false) throw `${iElt} is not a valid boolean. Should be 'true' or 'false'`
-  } else if (schema[Kind] === 'Integer') {
+  } else if (schema[Kind] === 'integer') {
     if (parse && typeof elt === 'string') elt = Number(elt)
     if (!Number.isInteger(elt)) throw `${iElt} is not a valid integer`
     schemaValidation(elt, schema)
-  } else if (schema[Kind] === 'Number') {
+  } else if (schema[Kind] === 'number') {
     if (parse && typeof elt === 'string') elt = Number(elt)
     if (!Number.isFinite(elt)) throw `${iElt} is not a valid number`
     schemaValidation(elt, schema)
-  } else if (schema[Kind] === 'String') {
+  } else if (schema[Kind] === 'string') {
     if (!(typeof elt === 'string')) throw `${iElt} is not a valid string`
     schemaValidation(elt, schema)
-  } else if (schema[Kind] === 'Literal') {
-    if (elt !== schema.const) throw `${iElt} is not a valid value`
-  } else if (schema[Kind] === 'Object') {
+  } else if (schema[Kind] === 'literal') {
+    if (elt !== schema.value) throw `${iElt} is not a valid value`
+  } else if (schema[Kind] === 'object') {
     if (parse && typeof elt === 'string') {
       try {
         elt = JSON.parse(elt)
@@ -34,9 +33,9 @@ export const validate = (elt: any, schema: TSchema, parse = false): any => {
     if (typeof elt !== 'object') throw `${iElt} is not a valid object`
     if (Array.isArray(elt)) throw `Expected an object, not an array`
     const err: ValidationError = {}
-    Object.entries(schema.properties as TProperties).forEach(([k, s]) => {
+    Object.entries(schema.props as STProps).forEach(([k, s]) => {
       if (!(k in elt)) {
-        if (!s[Optional]) err[k] = 'Required'
+        if (!s?.[Optional]) err[k] = 'Required'
         return
       }
       try {
@@ -46,7 +45,7 @@ export const validate = (elt: any, schema: TSchema, parse = false): any => {
       }
     })
     if (Object.keys(err).length) errors.push(err)
-  } else if (schema[Kind] === 'Array') {
+  } else if (schema[Kind] === 'array') {
     if (parse && typeof elt === 'string') {
       try {
         elt = JSON.parse(elt)
@@ -56,16 +55,16 @@ export const validate = (elt: any, schema: TSchema, parse = false): any => {
     }
     if (!Array.isArray(elt)) throw 'Not a valid array'
     schemaValidation(elt, schema)
-  } else if (schema[Kind] === 'ByteArray') {
+  } else if (schema[Kind] === 'byteArray') {
     if (parse && typeof elt === 'string') elt = Uint8Array.from(elt, c => c.charCodeAt(0))
     else if (parse && Array.isArray(elt)) elt = new Uint8Array(elt)
-    if (!(elt instanceof Uint8Array)) throw 'Not a valid ByteArray'
-  } else if (schema[Kind] === 'Union') {
-    const union = Object.values(schema.anyOf)
+    if (!(elt instanceof Uint8Array)) throw 'Not a valid byteArray'
+  } else if (schema[Kind] === 'union') {
+    const union = Object.values((schema as STUnion).anyOf)
     let valid = false
     for (const u of union) {
       try {
-        elt = validate(elt, u as TSchema, parse)
+        elt = validate(elt, u as STSchema, parse)
         valid = true
         break
       } catch (err) {
@@ -73,8 +72,8 @@ export const validate = (elt: any, schema: TSchema, parse = false): any => {
       }
     }
     // @ts-ignore
-    if (!valid) throw `${elt} could not be parsed to any of: ${union.map(u => u?.const ?? u[Kind]).join(', ')}`
-  } else if (schema[Kind] === 'Any') {
+    if (!valid) throw `${elt} could not be parsed to any of: ${union.map(u => u?.value ?? u[Kind]).join(', ')}`
+  } else if (schema[Kind] === 'any') {
   } else {
     throw `Unsupported schema type ${schema[Kind]}`
   }
@@ -85,32 +84,31 @@ export const validate = (elt: any, schema: TSchema, parse = false): any => {
   return elt
 }
 
-const schemaValidation = (value: any, schema: TSchema) => {
+const schemaValidation = (value: any, schema: STSchema) => {
   const errors = []
-  if (schema[Kind] === 'Integer' || schema[Kind] === 'Number') {
-    if (schema.exclusiveMinimum !== undefined)
-      if ((value as number) <= schema.exclusiveMinimum)
-        errors.push(`${value} is less or equal to ${schema.exclusiveMinimum}`)
-    if (schema.exclusiveMaximum !== undefined)
-      if ((value as number) >= schema.exclusiveMaximum)
-        errors.push(`${value} is greater or equal to ${schema.exclusiveMaximum}`)
+  if (schema[Kind] === 'integer' || schema[Kind] === 'number') {
+    if (schema.exclusiveMin !== undefined)
+      if ((value as number) <= schema.exclusiveMin) errors.push(`${value} is less or equal to ${schema.exclusiveMin}`)
+    if (schema.exclusiveMax !== undefined)
+      if ((value as number) >= schema.exclusiveMax)
+        errors.push(`${value} is greater or equal to ${schema.exclusiveMax}`)
     if (schema.minimum !== undefined)
-      if ((value as number) < schema.minimum) errors.push(`${value} is less than ${schema.minimum}`)
+      if ((value as number) < schema.min) errors.push(`${value} is less than ${schema.min}`)
     if (schema.maximum !== undefined)
-      if ((value as number) > schema.maximum) errors.push(`${value} is greater than ${schema.maximum}`)
-  } else if (schema[Kind] === 'String') {
+      if ((value as number) > schema.max) errors.push(`${value} is greater than ${schema.max}`)
+  } else if (schema[Kind] === 'string') {
     if (schema.minLength !== undefined && (value as string).length < schema.minLength)
       errors.push(`${value} length is too small (${schema.minLength} char min)`)
     if (schema.maxLength !== undefined && (value as string).length > schema.maxLength)
       errors.push(`${value} length is too large (${schema.maxLength} char max)`)
-    if (schema.pattern !== undefined && !(value as string).match(new RegExp(schema.pattern)))
+    if (schema.pattern !== undefined && !(value as string).match(schema.pattern))
       errors.push(`${value} does not match pattern ${schema.pattern}`)
-  } else if (schema[Kind] === 'Array') {
+  } else if (schema[Kind] === 'array') {
     if (schema.minItems !== undefined && (value as any[]).length < schema.minItems)
       errors.push(`Must contain at least ${schema.minItems} item${schema.minItems > 1 ? 's' : ''}`)
     if (schema.maxItems !== undefined && (value as any[]).length > schema.maxItems)
       errors.push(`Must contain at most (${schema.maxItems} item${schema.maxItems > 1 ? 's' : ''}`)
-    if (schema.uniqueItems === true && new Set(value as any[]).size !== (value as any[]).length)
+    if (schema.unique === true && new Set(value as any[]).size !== (value as any[]).length)
       errors.push(`Has duplicate values`)
   }
   if (errors.length) throw Array.isArray(errors) && errors.length === 1 ? errors[0] : errors