galbe 0.2.0 → 0.4.1

package/src/server.ts

@@ -1,8 +1,12 @@
-import type { Context, Route } from './types'
+import type { Context, Method, Route } from './types'
 
 import { InternalError, RequestError } from './types'
 import { parseEntry, requestBodyParser, requestPathParser, responseParser } from './parser'
 import { Galbe } from './index'
+import { validateResponse } from './validator'
+
+const METHODS = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS', 'HEAD']
+const EMPTY_BODY_METHODS = ['GET', 'OPTIONS', 'HEAD']
 
 const handleInternalError = (error: any) => {
   console.error(error)
@@ -10,7 +14,6 @@ const handleInternalError = (error: any) => {
 }
 
 const setupPluginCallbacks = (galbe: Galbe) => ({
-  init: galbe.plugins.filter(p => p.init),
   onFetch: galbe.plugins.filter(p => p.onFetch),
   onRoute: galbe.plugins.filter(p => p.onRoute),
   beforeHandle: galbe.plugins.filter(p => p.beforeHandle),
@@ -22,12 +25,11 @@ export default async (galbe: Galbe, port?: number) => {
   if (galbe?.config?.basePath && galbe?.config?.basePath[0] !== '/')
     galbe.config.basePath = `/${galbe?.config?.basePath}`
   let pluginsCb = setupPluginCallbacks(galbe)
-  //@ts-ignore
-  for (const p of pluginsCb.init) await p.init(galbe?.config?.plugin?.[p.name], galbe)
 
   return Bun.serve({
     port: port || galbe.config?.port || 3000,
     async fetch(req) {
+      if (!METHODS.includes(req.method)) return new Response('', { status: 501 })
       const context: Context = {
         request: req,
         set: { headers: {} },
@@ -48,7 +50,7 @@ export default async (galbe: Galbe, port?: number) => {
       try {
         // find route
         try {
-          route = router.find(req.method, url.pathname)
+          route = router.find(req.method.toLowerCase() as Method, url.pathname)
         } catch (error) {
           if (error instanceof RequestError) throw error
           else throw handleInternalError(error)
@@ -69,37 +71,41 @@ export default async (galbe: Galbe, port?: number) => {
         for (let [k, v] of url.searchParams) inQuery[k] = v
         let inParams = requestPathParser(url.pathname, route.path)
 
-        context.body = await requestBodyParser(req.body, inHeaders, schema.body)
+        context.body = !EMPTY_BODY_METHODS.includes(req.method)
+          ? await requestBodyParser(req.body, inHeaders, schema.body)
+          : null
         context.headers = inHeaders
         context.query = inQuery
         context.params = inParams
 
         // request validation
-        let errors: RequestError[] = []
-        try {
-          if (schema?.headers)
-            context.headers = {
-              ...context.headers,
-              ...parseEntry(context.headers, schema.headers, { name: 'headers', i: true })
-            }
-        } catch (error) {
-          if (error instanceof RequestError) errors.push(error)
-          else throw handleInternalError(error)
-        }
-        try {
-          if (schema?.query) context.query = parseEntry(context.query, schema.query, { name: 'query' })
-        } catch (error) {
-          if (error instanceof RequestError) errors.push(error)
-          else throw handleInternalError(error)
-        }
-        try {
-          if (schema?.params) context.params = parseEntry(context.params, schema.params, { name: 'params' })
-        } catch (error) {
-          if (error instanceof RequestError) errors.push(error)
-          else throw handleInternalError(error)
-        }
-        if (errors.length) {
-          throw new RequestError({ status: 400, payload: errors.reduce((acc, c) => ({ ...acc, ...c.payload }), {}) })
+        if (galbe.config?.requestValidator?.enabled) {
+          let errors: RequestError[] = []
+          try {
+            if (schema?.headers)
+              context.headers = {
+                ...context.headers,
+                ...parseEntry(context.headers, schema.headers, { name: 'headers', i: true })
+              }
+          } catch (error) {
+            if (error instanceof RequestError) errors.push(error)
+            else throw handleInternalError(error)
+          }
+          try {
+            if (schema?.query) context.query = parseEntry(context.query, schema.query, { name: 'query' })
+          } catch (error) {
+            if (error instanceof RequestError) errors.push(error)
+            else throw handleInternalError(error)
+          }
+          try {
+            if (schema?.params) context.params = parseEntry(context.params, schema.params, { name: 'params' })
+          } catch (error) {
+            if (error instanceof RequestError) errors.push(error)
+            else throw handleInternalError(error)
+          }
+          if (errors.length) {
+            throw new RequestError({ status: 400, payload: errors.reduce((acc, c) => ({ ...acc, ...c.payload }), {}) })
+          }
         }
 
         for (const p of pluginsCb.beforeHandle) {
@@ -140,7 +146,10 @@ export default async (galbe: Galbe, port?: number) => {
           if (r) response = r
         } else response = await handlerWrapper(context)
 
-        const parsedResponse = responseParser(response, context)
+        const parsedResponse = responseParser(response, context, schema.response)
+
+        if (galbe.config?.responseValidator?.enabled && schema.response)
+          validateResponse(response, schema.response, parsedResponse.status || 200)
 
         for (const p of pluginsCb.afterHandle) {
           //@ts-ignore
@@ -154,12 +163,23 @@ export default async (galbe: Galbe, port?: number) => {
         let customError
         if (galbe.errorHandler) customError = responseParser(galbe.errorHandler(error, context), context)
         if (customError) return customError
-        if (error instanceof RequestError) {
-          return new Response(JSON.stringify(error.payload), {
+        if (error instanceof InternalError) {
+          console.log(`Internal Error`, error?.payload || '')
+          return new Response('Internal Server Error', {
             status: error.status,
             headers: { 'Content-Type': 'application/json' }
           })
-        }
+        } else if (error instanceof RequestError) {
+          let payload = ''
+          if (typeof error.payload === 'string') payload = error.payload
+          try {
+            payload = JSON.stringify(error.payload)
+          } catch (err) {}
+          return new Response(payload, {
+            status: error.status,
+            headers: { 'Content-Type': 'application/json' }
+          })
+        } else console.log(error)
         return new Response('"Internal Server Error"', {
           status: 500,
           headers: {

package/src/types.ts

@@ -1,13 +1,17 @@
 import type { ServeOptions, TLSServeOptions } from 'bun'
 import type {
+  STAny,
   STArray,
   STBoolean,
   STByteArray,
   STInteger,
+  STJson,
   STLiteral,
   STMultipartForm,
   STNumber,
   STObject,
+  STOptional,
+  STSchema,
   STStream,
   STString,
   STUnion,
@@ -22,15 +26,35 @@ export type STBody =
   | STBoolean
   | STNumber
   | STInteger
+  | STLiteral
   | STObject
   | STArray
   | STUrlForm
   | STMultipartForm
   | STUnion
   | STStream
+  | undefined
+
+export type STResponseValue =
+  | STByteArray
+  | STString
+  | STBoolean
+  | STNumber
+  | STInteger
+  | STLiteral
+  | STObject
+  | STJson
+  | STArray
+  | STUnion
+  | STStream
+  | STAny
+export type STResponse = Record<number, STResponseValue>
+
 export type MaybeArray<T> = T | T[]
+export type MaybeSTArray<T extends STSchema> = T | STArray<T>
+export type MaybeSTUnion<T extends STSchema> = T | STUnion<[T, ...T[]]>
 
-export type Method = 'get' | 'post' | 'put' | 'delete' | 'patch' | 'options'
+export type Method = 'get' | 'post' | 'put' | 'delete' | 'patch' | 'options' | 'head'
 type MaybePromise<T> = T | Promise<T>
 
 export type ExtractParams<T extends string> = T extends `/:${infer P}/${infer Rest}`
@@ -41,13 +65,16 @@ export type ExtractParams<T extends string> = T extends `/:${infer P}/${infer Re
   ? P
   : never
 
-type STHeadersValue = STString | STBoolean | STNumber | STInteger | STLiteral | STUnion
+type STHeadersPrimaryValue = STString | STBoolean | STNumber | STInteger | STLiteral
+type STHeadersValue = MaybeSTUnion<STHeadersPrimaryValue>
 export type STHeaders = Record<string, STHeadersValue>
 
-type STParamsValue = STString | STBoolean | STNumber | STInteger | STLiteral | STUnion
+type STParamsPrimaryValue = STString | STBoolean | STNumber | STInteger | STLiteral
+type STParamsValue = MaybeSTUnion<STParamsPrimaryValue>
 export type STParams<Path extends string = string> = Record<ExtractParams<Path>, STParamsValue>
 
-type STQueryValue = STString | STBoolean | STNumber | STInteger | STLiteral | STUnion
+type STQueryPrimaryValue = STString | STBoolean | STNumber | STInteger | STLiteral
+type STQueryValue = MaybeSTArray<MaybeSTUnion<STQueryPrimaryValue>>
 export type STQuery = Record<string, STQueryValue>
 
 /**
@@ -74,6 +101,8 @@ export type GalbeConfig = {
   routes?: boolean | string | string[]
   router?: { cacheEnabled: boolean }
   plugin?: Record<string, any>
+  requestValidator?: { enabled: boolean }
+  responseValidator?: { enabled: boolean }
 }
 /**
  * #### Schema
@@ -95,16 +124,19 @@ export type GalbeConfig = {
  * ```
  */
 export type RequestSchema<
+  M extends Method = Method,
   Path extends string = string,
-  H extends STHeaders = {},
-  P extends Partial<STParams<Path>> = {},
-  Q extends STQuery = {},
-  B extends STBody = STBody
+  H extends STHeaders = STHeaders,
+  P extends Partial<STParams<Path>> = Partial<STParams<Path>>,
+  Q extends STQuery = STQuery,
+  B extends STBody = STBody,
+  R extends STResponse = STResponse
 > = {
   headers?: H
   params?: P
   query?: Q
   body?: B
+  response?: R
 }
 
 type OmitNotDefined<S extends RequestSchema> = {
@@ -115,14 +147,18 @@ type OmitNotDefined<S extends RequestSchema> = {
     : //@ts-ignore
       never]: Static<STObject<Exclude<S['params'], undefined>>>[K]
 }
-
-export type Context<Path extends string = string, S extends RequestSchema = RequestSchema> = {
+type StaticBody<T extends STSchema> = T extends STOptional<STSchema> ? Static<T> | null : Static<T>
+export type Context<
+  M extends Method = Method,
+  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>>
+  body: M extends 'get' | 'options' | 'head' ? null : StaticBody<Exclude<S['body'], undefined>>
   request: Request
   route?: Route
   state: Record<string, any>
@@ -134,57 +170,63 @@ export type Context<Path extends string = string, S extends RequestSchema = Requ
   }
 }
 export type Next = () => void | Promise<void>
-export type Hook<Path extends string = string, S extends RequestSchema = RequestSchema> = (
-  ctx: Context<Path, S>,
+export type Hook<M extends Method = Method, Path extends string = string, S extends RequestSchema = RequestSchema> = (
+  ctx: Context<M, 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 = {
+export type Handler<
+  M extends Method = Method,
+  Path extends string = string,
+  S extends RequestSchema = RequestSchema
+> = (ctx: Context<M, Path, S>) => any
+export type Endpoint<M extends Method> = {
   <
     Path extends string,
-    H extends STHeaders,
     P extends Partial<STParams<Path>>,
-    Q extends STQuery,
-    B extends STBody = any
+    H extends STHeaders = any,
+    Q extends STQuery = any,
+    B extends STBody = any,
+    R extends STResponse = STResponse
   >(
     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>>
+    schema: RequestSchema<M, Path, H, P, Q, B, R>,
+    hooks: Hook<M, Path, RequestSchema<M, Path, H, P, Q, B, R>>[],
+    handler: Handler<M, Path, RequestSchema<M, Path, H, P, Q, B, R>>
   ): void
   <
     Path extends string,
-    H extends STHeaders,
     P extends Partial<STParams<Path>>,
-    Q extends STQuery,
-    B extends STBody = any
+    H extends STHeaders = any,
+    Q extends STQuery = any,
+    B extends STBody = any,
+    R extends STResponse = STResponse
   >(
     path: Path,
-    schema: RequestSchema<Path, H, P, Q, B>,
-    handler: Handler<Path, RequestSchema<Path, H, P, Q, B>>
+    schema: RequestSchema<M, Path, H, P, Q, B, R>,
+    handler: Handler<M, Path, RequestSchema<M, Path, H, P, Q, B, R>>
   ): void
   <
     Path extends string,
-    H extends STHeaders,
     P extends Partial<STParams<Path>>,
-    Q extends STQuery,
-    B extends STBody = any
+    H extends STHeaders = any,
+    Q extends STQuery = any,
+    B extends STBody = any,
+    R extends STResponse = STResponse
   >(
     path: Path,
-    hooks: Hook<Path, RequestSchema<Path, H, P, Q, B>>[],
-    handler: Handler<Path, RequestSchema<Path, H, P, Q, B>>
+    hooks: Hook<M, Path, RequestSchema<M, Path, H, P, Q, B, R>>[],
+    handler: Handler<M, Path, RequestSchema<M, Path, H, P, Q, B, R>>
   ): void
   <
     Path extends string,
-    H extends STHeaders,
     P extends Partial<STParams<Path>>,
-    Q extends STQuery,
-    B extends STBody = any
+    H extends STHeaders = any,
+    Q extends STQuery = any,
+    B extends STBody = any,
+    R extends STResponse = STResponse
   >(
     path: Path,
-    handler: Handler<Path, RequestSchema<Path, H, P, Q, B>>
+    handler: Handler<M, Path, RequestSchema<M, Path, H, P, Q, B, R>>
   ): void
 }
 
@@ -193,52 +235,56 @@ export class RequestError {
   payload: any
   constructor(options: { status?: number; payload?: any }) {
     this.status = options.status ?? 500
-    this.payload = options.payload ?? 'Internal server error'
+    this.payload = options.payload
   }
 }
 
 export type ErrorHandler = (error: any, context: Context) => any
 
 export type RouteNode = {
-  route?: Route
+  routes: { [K in Method]?: Route }
   param?: RouteNode
   children?: Record<string, RouteNode>
 }
 
 export type Route<
+  M extends Method = Method,
   Path extends string = string,
-  H extends STHeaders = {},
   P extends Partial<STParams<Path>> = {},
-  Q extends STQuery = {},
-  B extends STBody = STBody
+  H extends STHeaders = STHeaders,
+  Q extends STQuery = STQuery,
+  B extends STBody = STBody,
+  R extends STResponse = STResponse
 > = {
-  method: Method
+  method: M
   path: Path
-  schema: RequestSchema<Path, H, P, Q, B>
-  context: Context<Path, RequestSchema<Path, H, P, Q, B>>
+  schema: RequestSchema<M, Path, H, P, Q, B, R>
+  context: Context<M, Path, RequestSchema<M, Path, H, P, Q, B, R>>
   hooks: Hook[]
-  handler: Handler<Path, RequestSchema<Path, H, P, Q, B>>
-}
-
-export type RouteTree = {
-  [key: string]: RouteNode
+  handler: Handler<M, Path, RequestSchema<M, Path, H, P, Q, B, R>>
 }
 
 export class NotFoundError extends RequestError {
-  constructor(message?: string) {
+  constructor(message?: any) {
     super({ status: 404, payload: message ?? 'Not found' })
   }
 }
 
+export class MethodNotAllowedError extends RequestError {
+  constructor(message?: any) {
+    super({ status: 405, payload: message ?? 'Method not allowed' })
+  }
+}
+
 export class InternalError extends RequestError {
-  constructor(message?: string) {
+  constructor(message?: any) {
     super({ status: 500, payload: message ?? 'Internal Server Error' })
   }
 }
 
 /**
  * #### GalbePlugin
- * Define a plugin for a Galbe server
+ * Define a plugin for a Galbe application
  *
  * ---
  * @example
@@ -264,4 +310,14 @@ export type GalbePlugin = {
   onRoute?: (context: Context) => MaybePromise<Response | void>
   beforeHandle?: (context: Context) => MaybePromise<Response | void>
   afterHandle?: (response: Response, context: Context) => MaybePromise<Response | void>
+  cli?: (commands: GalbeCLICommand[]) => MaybePromise<GalbeCLICommand[] | void>
+}
+
+export type GalbeCLICommand = {
+  name: string
+  description?: string
+  route: Route
+  arguments?: { name: string; type: string; description: string }[]
+  options?: { name: string; short: string; type: string; description: string; default: any }[]
+  action?: (props: any) => MaybePromise<void>
 }

package/src/util.ts

@@ -1,12 +1,94 @@
+import type { Route, RouteNode } from '.'
+import type { RouteMeta } from './routes'
+
 const METHOD_COLOR: Record<string, string> = {
   get: '\x1b[32m',
   post: '\x1b[34m',
   put: '\x1b[36m',
   patch: '\x1b[33m',
   delete: '\x1b[31m',
-  options: ''
+  options: '',
+  head: ''
 }
-export const logRoute = (r: { method: string; path: string }) => {
+
+export const logRoute = (
+  r: { method: string; path: string },
+  meta?: RouteMeta,
+  format?: { maxPathLength?: number }
+) => {
   let color = METHOD_COLOR?.[r.method] || ''
-  console.log(`    [${color}${`${r.method.toUpperCase()}\x1b[0m]`.padEnd(12, ' ')} ${r.path}`)
+  console.log(
+    `    [${color}${`${r.method.toUpperCase()}\x1b[0m]`.padEnd(12, ' ')} ${r.path
+      .padEnd(format?.maxPathLength ?? r.path.length, ' ')
+      .replaceAll(/:([^\/]+)/g, '\x1b[0;33m:$1\x1b[0m')}${meta?.head ? `  ${meta.head}` : ''}`
+  )
+}
+
+export const walkRoutes = (node: RouteNode, cb: (route: Route) => void) => {
+  if (node?.routes) Object.values(node.routes).forEach(r => cb(r))
+  for (let c of Object.values(node?.children || {})) walkRoutes(c, cb)
+  if (node?.param) walkRoutes(node.param, cb)
+}
+
+export const isIterator = (obj: any) => typeof obj?.next === 'function'
+
+export const HttpStatus = {
+  100: 'Continue',
+  101: 'Switching Protocols',
+  102: 'Processing',
+  103: 'Early Hints',
+  200: 'OK',
+  201: 'Created',
+  202: 'Accepted',
+  203: 'Non Authoritative Information',
+  204: 'No Content',
+  205: 'Reset Content',
+  206: 'Partial Content',
+  207: 'Multi-Status',
+  300: 'Multiple Choices',
+  301: 'Moved Permanently',
+  302: 'Moved Temporarily',
+  303: 'See Other',
+  304: 'Not Modified',
+  305: 'Use Proxy',
+  307: 'Temporary Redirect',
+  308: 'Permanent Redirect',
+  400: 'Bad Request',
+  401: 'Unauthorized',
+  402: 'Payment Required',
+  403: 'Forbidden',
+  404: 'Not Found',
+  405: 'Method Not Allowed',
+  406: 'Not Acceptable',
+  407: 'Proxy Authentication Required',
+  408: 'Request Timeout',
+  409: 'Conflict',
+  410: 'Gone',
+  411: 'Length Required',
+  412: 'Precondition Failed',
+  413: 'Request Entity Too Large',
+  414: 'Request-URI Too Long',
+  415: 'Unsupported Media Type',
+  416: 'Requested Range Not Satisfiable',
+  417: 'Expectation Failed',
+  418: "I'm a teapot",
+  419: 'Insufficient Space on Resource',
+  420: 'Method Failure',
+  421: 'Misdirected Request',
+  422: 'Unprocessable Entity',
+  423: 'Locked',
+  424: 'Failed Dependency',
+  426: 'Upgrade Required',
+  428: 'Precondition Required',
+  429: 'Too Many Requests',
+  431: 'Request Header Fields Too Large',
+  451: 'Unavailable For Legal Reasons',
+  500: 'Internal Server Error',
+  501: 'Not Implemented',
+  502: 'Bad Gateway',
+  503: 'Service Unavailable',
+  504: 'Gateway Timeout',
+  505: 'HTTP Version Not Supported',
+  507: 'Insufficient Storage',
+  511: 'Network Authentication Required'
 }

package/src/validator.ts

@@ -1,5 +1,7 @@
+import { InternalError, type STResponse } from './index'
 import type { STSchema, STProps, STUnion } from './schema'
-import { Kind, Optional } from './schema'
+import { Kind, Optional, Stream } from './schema'
+import { isIterator } from './util'
 
 export const validate = (elt: any, schema: STSchema, parse = false): any => {
   type ValidationError = string | string[] | { [key: string]: ValidationError }
@@ -7,7 +9,10 @@ export const validate = (elt: any, schema: STSchema, parse = false): any => {
   const iElt = elt
 
   if (schema[Kind] === 'boolean') {
-    if (parse && typeof elt === 'string') elt = elt === 'true' ? true : elt === 'false' ? false : null
+    if (typeof elt === 'string') {
+      if (parse) elt = elt === 'true' ? true : elt === 'false' ? false : null
+      else throw `Expected boolean, got string.`
+    }
     if (elt !== true && elt !== false) throw `${iElt} is not a valid boolean. Should be 'true' or 'false'`
   } else if (schema[Kind] === 'integer') {
     if (parse && typeof elt === 'string') elt = Number(elt)
@@ -45,6 +50,8 @@ export const validate = (elt: any, schema: STSchema, parse = false): any => {
       }
     })
     if (Object.keys(err).length) errors.push(err)
+  } else if (schema[Kind] === 'json') {
+    elt = validate(elt, { ...schema, [Kind]: schema.type }, parse)
   } else if (schema[Kind] === 'array') {
     if (parse && typeof elt === 'string') {
       try {
@@ -84,6 +91,22 @@ export const validate = (elt: any, schema: STSchema, parse = false): any => {
   return elt
 }
 
+export const validateResponse = (response: any, schema: STResponse, status: number) => {
+  if (!(status in schema)) return
+  const s = schema[status]
+  if (response instanceof ReadableStream) {
+    if (!s[Stream]) throw new InternalError(`Expected ${s[Kind]} response, but got ReadableStream`)
+  } else if (isIterator(response)) {
+    if (!s[Stream]) throw new InternalError(`Expected ${s[Kind]} response, but got Iterator`)
+  } else {
+    try {
+      validate(response, s)
+    } catch (error) {
+      throw new InternalError({ ResponseValidationError: error })
+    }
+  }
+}
+
 const schemaValidation = (value: any, schema: STSchema) => {
   const errors = []
   if (schema[Kind] === 'integer' || schema[Kind] === 'number') {
@@ -92,9 +115,8 @@ const schemaValidation = (value: any, schema: STSchema) => {
     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.min) errors.push(`${value} is less than ${schema.min}`)
-    if (schema.maximum !== undefined)
+    if (schema.min !== undefined) if ((value as number) < schema.min) errors.push(`${value} is less than ${schema.min}`)
+    if (schema.max !== undefined)
       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)

package/test/parser.test.ts

@@ -10,6 +10,7 @@ import {
   isAsyncIterator
 } from './test.utils'
 import { Galbe, $T } from '../src'
+import { schemaToTypeStr } from '../src/schema'
 
 const port = 7357
 
@@ -1195,4 +1196,37 @@ describe('parser', () => {
       expect(body).toEqual(expected.body)
     }
   })
+
+  test('schema to type', async () => {
+    let type = schemaToTypeStr(
+      $T.object({
+        boolean: $T.boolean(),
+        byteArray: $T.byteArray(),
+        number: $T.number(),
+        integer: $T.integer(),
+        string: $T.string(),
+        any: $T.any(),
+        literal: $T.literal('literal'),
+        array: $T.array($T.string()),
+        object: $T.object({
+          foo: $T.string()
+        }),
+        union: $T.union([$T.number(), $T.string()])
+      })
+    )
+    expect(type).toBe(
+      `{` +
+        `'boolean':boolean;` +
+        `'byteArray':Uint8Array;` +
+        `'number':number;` +
+        `'integer':number;` +
+        `'string':string;` +
+        `'any':any;` +
+        `'literal':'literal';` +
+        `'array':Array<string>;` +
+        `'object':{'foo':string};` +
+        `'union':number|string` +
+        `}`
+    )
+  })
 })