galbe 0.2.0 → 0.4.1

package/src/parser.ts

@@ -1,4 +1,4 @@
-import type { MaybeArray, STBody, Context } from './index'
+import type { MaybeArray, STBody, Context, STResponse } from './index'
 import type {
   STStream,
   STUrlForm,
@@ -17,6 +17,7 @@ import { readableStreamToArrayBuffer } from 'bun'
 import { Kind, Optional, Stream } from './schema'
 import { validate } from './validator'
 import { InternalError, RequestError } from './index'
+import { isIterator } from './util'
 
 const textDecoder = new TextDecoder()
 const textEncoder = new TextEncoder()
@@ -282,6 +283,7 @@ const streamToUrlForm = async (body: ReadableStream<Uint8Array>, schema?: STUrlF
 }
 async function* $streamToMultipartForm(data: ReadableStream<Uint8Array>, boundary: string, schema?: STMultipartForm) {
   const bound = textEncoder.encode(boundary)
+  const delimiter = textEncoder.encode('\r\n\r\n')
   let rest = new Uint8Array()
   let bK: Uint8Array = new Uint8Array()
   let bV: Uint8Array = new Uint8Array()
@@ -293,6 +295,7 @@ async function* $streamToMultipartForm(data: ReadableStream<Uint8Array>, boundar
     start = 0
     for (let i = 0; i < chunk.length; i++) {
       let matchBound = true
+      let matchDelimiter = true
       for (let b = 0; b < bound.length; b++) {
         if (chunk[i + b] === bound[b]) continue
         else {
@@ -300,6 +303,15 @@ async function* $streamToMultipartForm(data: ReadableStream<Uint8Array>, boundar
           break
         }
       }
+      if (!matchBound) {
+        for (let b = 0; b < delimiter.length; b++) {
+          if (chunk[i + b] === delimiter[b]) continue
+          else {
+            matchDelimiter = false
+            break
+          }
+        }
+      }
       if (matchBound) {
         bV = new Uint8Array(rest.length + i - start)
         bV.set(rest)
@@ -323,7 +335,7 @@ async function* $streamToMultipartForm(data: ReadableStream<Uint8Array>, boundar
         start = i + bound.length
         rest = new Uint8Array()
         i = start
-      } else if (chunk[i] === 0x0d && chunk[i + 1] === 0x0a && chunk[i + 2] === 0x0d) {
+      } else if (matchDelimiter) {
         bK = new Uint8Array(rest.length + i - start)
         bK.set(rest)
         bK.set(chunk.slice(start, i), rest.length)
@@ -594,7 +606,7 @@ export const requestPathParser = (input: string, path: string) => {
 }
 
 export const parseEntry = <T extends STProps>(
-  params: { [key: string]: string | string[] },
+  params: { [key: string]: any },
   schema: T,
   options?: { name?: string; i?: boolean }
 ): Static<STObject<T>> => {
@@ -629,16 +641,24 @@ export const parseEntry = <T extends STProps>(
   return parsedParams as Static<STObject<T>>
 }
 
-const isIterator = (obj: any) => typeof obj?.next === 'function'
-
-export const responseParser = (response: any, ctx: Context) => {
+export const responseParser = (response: any, ctx: Context, schema?: STResponse) => {
   const details = {
     status: ctx.set.status || 200,
     headers: new Headers(ctx.set.headers)
   }
   if (response instanceof Response) return response
   else if (typeof response === 'string') {
-    if (!details?.headers?.has('content-type')) details?.headers?.set('content-type', 'text/plain')
+    if (!details?.headers?.has('content-type')) {
+      if (schema?.[details.status][Kind] === 'json') {
+        details?.headers?.set('content-type', 'application/json')
+        response = `"${response}"`
+      } else details?.headers?.set('content-type', 'text/plain')
+    }
+    return new Response(response, details)
+  } else if (response instanceof Uint8Array) {
+    if (!details?.headers?.has('content-type')) {
+      details?.headers?.set('content-type', 'application/octet-stream')
+    }
     return new Response(response, details)
   }
   if (response instanceof ReadableStream) {
@@ -667,7 +687,8 @@ export const responseParser = (response: any, ctx: Context) => {
   } else {
     try {
       if (!details?.headers?.has('content-type')) details?.headers?.set('content-type', 'application/json')
-      return new Response(JSON.stringify(response), details)
+      if (details.headers.get('content-type') === 'application/json') response = JSON.stringify(response)
+      return new Response(response, details)
     } catch (error) {
       console.error(error)
       throw new InternalError()

package/src/router.ts

@@ -1,39 +1,34 @@
-import type { Route, RouteNode, RouteTree } from './types'
-import { NotFoundError } from './types'
+import type { Method, Route, RouteNode } from './types'
+import { MethodNotAllowedError, NotFoundError } from './types'
 
 const ROUTE_REGEX = /^(\/(\*|:?\d+|:?\w+|:?[\w\d][\w-]+[\w\d]))*\/?$/
 
-const walkRoutes = (path: string[], node: RouteNode, alts: RouteNode[] = []): RouteNode => {
+const walk = (path: string[], node: RouteNode, alts: RouteNode[] = []): RouteNode => {
   if (path.length < 1) throw new NotFoundError()
-  if (path.length === 1 && node.route) return node
+  if (path.length === 1 && node.routes && !!Object.keys(node.routes).length) return node
 
   if (node.children?.['*']) alts.push(node.children['*'])
   if (node.param) alts.push(node.param)
 
   if (node.children && path[1] in node.children) {
     path.shift()
-    return walkRoutes(path, node.children[path[0]], alts)
+    return walk(path, node.children[path[0]], alts)
   }
   if (node.param) {
     path.shift()
     alts.pop()
-    try {
-      return walkRoutes(path, node.param, alts)
-    } catch (error) {
-      if (error instanceof NotFoundError) console.log(error)
-      else throw error
-    }
+    return walk(path, node.param, alts)
   }
   if (alts.length > 1) {
-    return walkRoutes(path, alts.pop() as RouteNode, alts)
+    return walk(path, alts.pop() as RouteNode, alts)
   }
   if (alts.length === 1) {
     let lastAlt = alts.pop() as RouteNode
     try {
-      return walkRoutes(path, lastAlt, alts)
+      return walk(path, lastAlt, alts)
     } catch (error) {
       if (error instanceof NotFoundError) {
-        if (lastAlt?.route) return lastAlt
+        if (lastAlt?.routes) return lastAlt
       } else throw error
     }
   }
@@ -42,12 +37,12 @@ const walkRoutes = (path: string[], node: RouteNode, alts: RouteNode[] = []): Ro
 }
 
 export class GalbeRouter {
-  routes: RouteTree
+  routes: RouteNode
   prefix: string
   cacheEnabled: boolean
   cachedRoutes: Map<string, Route | null>
   constructor(options?: { prefix?: string; cacheEnabled?: boolean }) {
-    this.routes = { GET: {}, POST: {}, PUT: {}, PATCH: {}, DELETE: {}, OPTIONS: {} }
+    this.routes = { routes: {} }
     let prefix = options?.prefix || ''
     if (prefix && !prefix.match(/^\//)) prefix = `/${prefix}`
     this.prefix = prefix
@@ -62,42 +57,46 @@ export class GalbeRouter {
     route.path = `${this.prefix || ''}${route.path}`
     let path = route.path.replace(/^\/$(.*)\/?$/, '$1').split('/')
     path.shift()
-    let r = this.routes[route.method.toUpperCase()]
+    let r = this.routes
     if (!path.length) {
-      r.route = route
+      r.routes[route.method] = route
     } else {
       while (path.length) {
         let p = path.shift()
         if (p === undefined) break
         if (!path.length) {
-          if (p.match(/^:/)) r.param = { route }
-          else {
+          if (p.match(/^:/)) {
+            if (!r.param) r.param = { routes: {} }
+            r.param.routes[route.method] = route
+          } else {
             if (!r.children) r.children = {}
-            r.children[p] = { ...r.children[p], route }
+            if (!(p in r.children)) r.children[p] = { routes: {} }
+            r.children[p].routes[route.method] = route
           }
         } else {
           if (p.match(/^:/)) {
-            if (!r.param) r.param = {}
+            if (!r.param) r.param = { routes: {} }
             r = r.param
           } else {
             if (!r.children) r.children = {}
-            if (!(p in r.children)) r.children[p] = {}
+            if (!(p in r.children)) r.children[p] = { routes: {} }
             r = r.children[p]
           }
         }
       }
     }
   }
-  find(method: string, path: string) {
+  find(method: Method, path: string): Route {
     const staticRoute = this.cachedRoutes.get(`[${method}]${path}`)
     if (staticRoute === null) throw new NotFoundError()
     if (staticRoute !== undefined) return staticRoute
-    let parts = path.split('/')
-    const route = walkRoutes(parts, this.routes[method]).route
-    if (!route) {
+    let parts = path === '/' ? [''] : path.split('/')
+    let r = walk(parts, this.routes)
+    if (!r || !Object.keys(r.routes).length) {
       if (this.cacheEnabled) this.cachedRoutes.set(`[${method}]${path}`, null)
       throw new NotFoundError()
-    }
+    } else if (!(method in r.routes)) throw new MethodNotAllowedError()
+    const route = r.routes[method] as Route
     if (this.cacheEnabled) this.cachedRoutes.set(`[${method}]${path}`, route)
     return route
   }

package/src/routes.ts

@@ -1,4 +1,4 @@
-import type { GalbeConfig } from './types'
+import type { GalbeConfig, Route } from './types'
 
 import { readdir, lstat } from 'fs/promises'
 import { extname } from 'path'
@@ -10,14 +10,116 @@ import { Glob } from 'bun'
 
 export const DEFAULT_ROUTE_PATTERN = 'src/**/*.route.{js,ts}'
 
-export type RouteMeta = {
+export type RouteMeta = { head?: string } & Record<string, boolean | string | string[]>
+export type RoutesMeta = {
   header: Record<string, boolean | string | string[]>
-  routes: Record<string, Record<string, Record<string, boolean | string | string[]>>>
+  routes: Record<string, Record<string, RouteMeta>>
 }
-
+export type RouteInstanciationCallback = <T extends 'add' | 'error'>(event: {
+  type: T
+  error?: T extends 'error' ? any : undefined
+  route: T extends 'add' ? Route : undefined
+  filepath?: string
+  meta: T extends 'add' ? RouteMeta : undefined
+}) => any | Promise<any>
 export type RouteFileMeta = {
   file: string
-} & RouteMeta
+} & RoutesMeta
+
+class GalbeProxy {
+  #g: Galbe
+  #cb?: RouteInstanciationCallback
+  filepath?: string
+  meta?: RoutesMeta
+  constructor(g: Galbe, cb?: RouteInstanciationCallback) {
+    this.#g = g
+    this.#cb = cb
+  }
+  async get(...args: any[]) {
+    //@ts-ignore
+    const route = this.#g.get(...args) as Route
+    if (this.#cb)
+      await this.#cb({
+        type: 'add',
+        route,
+        filepath: this.filepath || '',
+        meta: this.meta?.routes?.[route.path]?.[route.method] || {}
+      })
+    return route
+  }
+  async post(...args: any[]) {
+    //@ts-ignore
+    const route = this.#g.post(...args) as Route
+    if (this.#cb)
+      await this.#cb({
+        type: 'add',
+        route,
+        filepath: this.filepath,
+        meta: this.meta?.routes?.[route.path]?.[route.method] || {}
+      })
+    return route
+  }
+  async put(...args: any[]) {
+    //@ts-ignore
+    const route = this.#g.put(...args) as Route
+    if (this.#cb)
+      await this.#cb({
+        type: 'add',
+        route,
+        filepath: this.filepath,
+        meta: this.meta?.routes?.[route.path]?.[route.method] || {}
+      })
+    return route
+  }
+  async patch(...args: any[]) {
+    //@ts-ignore
+    const route = this.#g.patch(...args) as Route
+    if (this.#cb)
+      await this.#cb({
+        type: 'add',
+        route,
+        filepath: this.filepath,
+        meta: this.meta?.routes?.[route.path]?.[route.method] || {}
+      })
+    return route
+  }
+  async delete(...args: any[]) {
+    //@ts-ignore
+    const route = this.#g.delete(...args) as Route
+    if (this.#cb)
+      await this.#cb({
+        type: 'add',
+        route,
+        filepath: this.filepath,
+        meta: this.meta?.routes?.[route.path]?.[route.method] || {}
+      })
+    return route
+  }
+  async options(...args: any[]) {
+    //@ts-ignore
+    const route = this.#g.options(...args) as Route
+    if (this.#cb)
+      await this.#cb({
+        type: 'add',
+        route,
+        filepath: this.filepath,
+        meta: this.meta?.routes?.[route.path]?.[route.method] || {}
+      })
+    return route
+  }
+  async head(...args: any[]) {
+    //@ts-ignore
+    const route = this.#g.head(...args) as Route
+    if (this.#cb)
+      await this.#cb({
+        type: 'add',
+        route,
+        filepath: this.filepath,
+        meta: this.meta?.routes?.[route.path]?.[route.method] || {}
+      })
+    return route
+  }
+}
 
 const parseComment = (comment: string): Record<string, string | string[]> => {
   const head =
@@ -40,11 +142,11 @@ const parseComment = (comment: string): Record<string, string | string[]> => {
   }
   return refs
 }
-export const metaAnalysis = async (filePath: string): Promise<RouteMeta> => {
+export const metaAnalysis = async (filePath: string): Promise<RoutesMeta> => {
   const file = Bun.file(filePath)
   const fileExt = extname(filePath)
   let content = await file.text()
-  let meta: RouteMeta = { header: {}, routes: {} }
+  let meta: RoutesMeta = { header: {}, routes: {} }
 
   if (fileExt === '.ts') {
     //// Much faster but doesn't include comments. See https://github.com/oven-sh/bun/pull/7055
@@ -69,25 +171,31 @@ export const metaAnalysis = async (filePath: string): Promise<RouteMeta> => {
     }).code
   }
 
-  const comments: Record<number, string> = {}
+  const comments: Record<number, Record<number, string>> = {}
 
   const ast = parse(content, {
     ecmaVersion: 'latest',
     sourceType: 'module',
     locations: true,
     onComment: (isBlock, text, _start, _end, _locStart, locEnd) => {
-      if (isBlock && locEnd?.line) comments[locEnd?.line] = text
+      if (isBlock && locEnd?.line !== undefined && locEnd?.column !== undefined) {
+        if (!comments?.[locEnd.line]) comments[locEnd.line] = []
+        comments[locEnd.line][locEnd.column] = text
+      }
     }
   })
   simple(ast, {
     ExportDefaultDeclaration(node) {
-      // @ts-ignore
-      let galbeIdentifier = node.declaration.params[0].name
-
-      const headerLine = node.loc?.start.line
-      const headerCom = headerLine !== undefined && comments?.[headerLine] ? comments[headerLine] : ''
+      const headerLine = node.loc?.start.line || -1
+      const headerCol = node.loc?.start.column || -1
+      const headerCom = comments?.[headerLine]?.[headerCol - 1] ? comments[headerLine][headerCol - 1] : ''
       const headerRef = parseComment(headerCom)
       meta.header = headerRef
+
+      // @ts-ignore
+      let galbeIdentifier = node.declaration?.params?.[0]?.name
+      if (!galbeIdentifier) return meta
+
       // @ts-ignore
       simple(node.declaration.body, {
         CallExpression(node) {
@@ -97,8 +205,9 @@ export const metaAnalysis = async (filePath: string): Promise<RouteMeta> => {
             const path = node.arguments[0].value
             // @ts-ignore
             const method = node.callee.property.name
-            const line = node.loc?.start.line
-            const com = line !== undefined && comments?.[line] ? comments[line] : ''
+            const line = node.loc?.start.line || -1
+            const col = node.loc?.start.column || -1
+            const com = comments?.[line]?.[col - 1] ? comments[line][col - 1] : ''
 
             const routeRefs = parseComment(com)
 
@@ -112,48 +221,41 @@ export const metaAnalysis = async (filePath: string): Promise<RouteMeta> => {
   return meta
 }
 
-const importRoutes = async (filePath: string, galbe: Galbe) => {
-  const routes = (await import(filePath)).default
-  routes(galbe)
-}
-
-export const defineRoutes = async (options: GalbeConfig, galbe: Galbe) => {
+export const defineRoutes = async (
+  options: Pick<GalbeConfig, 'routes'>,
+  galbe: Galbe,
+  cb?: RouteInstanciationCallback
+) => {
   const routes = options?.routes === true ? DEFAULT_ROUTE_PATTERN : options?.routes
-  if (!routes) {
-    console.log(`\x1b\[38;5;245m    No route file defined\x1b[0m`)
-    return
-  }
+  const proxy = new GalbeProxy(galbe, cb)
+  if (!routes) return
   const root = process.cwd()
   if (typeof routes === 'string') {
-    let noRouteFound = true
     for await (const path of new Glob(routes).scan({ cwd: root, absolute: true, onlyFiles: false })) {
-      noRouteFound = false
       const isDir = (await lstat(path)).isDirectory()
 
       let files: string[] = []
       if (!isDir) files.push(path)
       else files = files.concat((await readdir(path)).map(f => `${path}/${f}`))
-      if (files.length === 0) console.log(`\x1b\[38;5;245m    No route found\x1b[0m`)
       for (const f of files) {
         try {
           const metadata = await metaAnalysis(f)
+          proxy.filepath = f
+          proxy.meta = metadata
           galbe.meta?.push({ file: path, ...metadata })
-          console.log(`\n\x1b\[0;36m    ${f}\x1b[0m`)
-          await importRoutes(f, galbe)
-        } catch (err) {
-          // console.log(`\x1b\[0;31m    ${f}\x1b[0m`)
-          throw err
+          const imported = await import(f)
+          if (!imported?.default) throw new Error('No default export function')
+          if (typeof imported.default !== 'function') throw new Error('Default export must be a function')
+          const routes = imported.default
+          routes(proxy)
+        } catch (err: any) {
+          if (cb) await cb({ type: 'error', error: err, filepath: f, route: undefined, meta: undefined })
         }
       }
     }
-    if (noRouteFound) {
-      process.stdout.write('\r\x1b[K')
-      console.log(`\x1b\[38;5;245m    No route found\x1b[0m`)
-      return
-    }
   } else if (Array.isArray(routes)) {
     for (const r of routes) {
-      await defineRoutes({ routes: r }, galbe)
+      await defineRoutes({ routes: r }, galbe, cb)
     }
   }
 }

package/src/schema.ts

@@ -3,6 +3,7 @@ export const Optional = Symbol.for('Galbe.SchemaType.Optional')
 export const Stream = Symbol.for('Galbe.SchemaType.Stream')
 
 export interface Options {
+  id?: string
   title?: string
   description?: string
   default?: any
@@ -38,11 +39,11 @@ export interface STSchema extends Options {
     | 'literal'
     | 'array'
     | 'object'
+    | 'json'
     | 'urlForm'
     | 'multipartForm'
     | 'any'
     | 'union'
-    | 'stream'
   [Optional]?: boolean
   [Stream]?: boolean
   params: unknown[]
@@ -63,6 +64,16 @@ export type STPropsValue =
 export type STProps = Record<string | number, STPropsValue>
 
 type Evaluate<T> = T extends infer O ? { [K in keyof O]: O[K] } : never
+
+/**
+ * Infer the static TypeScript type from a {@link https://galbe.dev/documentation/schemas#schema-types Schema Type}
+ * @example
+ * ```ts
+ * const schema = $T.object({ foo: $T.string() })
+ * type T = Static<typeof schema>
+ * //   ^? type T = { foo: string }
+ * ```
+ */
 export type Static<T extends STSchema, P extends unknown[] = unknown[]> = (T & { params: P })['static']
 
 // Utils
@@ -162,6 +173,11 @@ export interface STObject<T extends STProps = STProps> extends STSchema {
   static: ObjectStatic<T, this['params']>
   props: T
 }
+export interface STJson<T extends STBoolean | STNumber | STString | STObject = any> extends STSchema {
+  [Kind]: 'json'
+  type: 'boolean' | 'number' | 'string' | 'object' | 'unknown'
+  static: Static<T>
+}
 type ObjectStatic<T extends STProps, P extends unknown[]> = ObjectStaticProps<T, { [K in keyof T]: Static<T[K], P> }>
 type OptionalPropertyKeys<T extends STProps> = {
   [K in keyof T]: T[K] extends STOptional<STSchema> ? K : never
@@ -180,6 +196,13 @@ function _Object<T extends STProps>(properties?: T, options: Options = {}): STOb
     ? { ...options, [Kind]: 'object', props: clonedProperties, required: requiredKeys }
     : { ...options, [Kind]: 'object', props: clonedProperties }) as unknown as STObject<T>
 }
+function _Json<T extends STBoolean | STNumber | STString | STObject>(value?: T, options: Options = {}): STJson<T> {
+  if (value?.[Kind] === 'boolean') return { ..._Bool(options), [Kind]: 'json', type: 'boolean' }
+  if (value?.[Kind] === 'number') return { ..._Number(options), [Kind]: 'json', type: 'number' }
+  if (value?.[Kind] === 'string') return { ..._String(options), [Kind]: 'json', type: 'string' }
+  if (value?.[Kind] === 'object') return { ..._Object(value.props, options), [Kind]: 'json', type: 'object' }
+  throw Error('Invalid Json type definition')
+}
 
 // UrlForm
 export type STUrlFormValues =
@@ -221,7 +244,19 @@ export interface MultipartFormData<K extends string = string, V extends Static<S
 }
 export interface STMultipartForm<T extends STProps = STProps> extends STSchema {
   [Kind]: 'multipartForm'
-  static: T extends undefined ? Record<string, any> : ObjectStatic<T, this['params']>
+  static: T extends undefined
+    ? {
+        [k: string]: {
+          headers: { type?: string; name: string; filename?: string }
+          content: Static<STMultipartFormValues>
+        }
+      }
+    : {
+        [K in keyof T]: {
+          headers: { type?: string; name: K; filename?: string }
+          content: Static<T[K]>
+        }
+      }
   props: T
 }
 function _MultipartForm<T extends STProps>(properties?: T, options: Options = {}): STMultipartForm<T> {
@@ -241,12 +276,12 @@ export interface STArray<T extends STSchema = STSchema> extends STSchema {
   static: Static<T>[]
   items: T
 }
-export function _Array<T extends STSchema>(schema?: T, options: ArrayOptions = {}): STArray<T | STAny> {
+export function _Array<T extends STSchema>(schema?: T, options: ArrayOptions = {}): STArray<T> {
   return {
     ...options,
     [Kind]: 'array',
     items: schema ?? _Any()
-  } as unknown as T extends undefined ? STArray<STAny> : STArray<T>
+  } as unknown as STArray<T>
 }
 
 // Union
@@ -313,9 +348,12 @@ export class SchemaType {
   public object<T extends STProps>(properties?: T, options: Options = {}): STObject<T> {
     return _Object(properties, options)
   }
-  /** Alias for Object Schema Type */
-  public json<T extends STProps>(properties?: T, options: Options = {}): STObject<T> {
-    return _Object(properties, options)
+  /** Creates a JSON Schema Type */
+  public json<T extends STString | STBoolean | STNumber | STObject<STProps>>(
+    value: T,
+    options: Options = {}
+  ): STJson<T> {
+    return _Json(value, options)
   }
   /** Creates an UrlForm Schema Type */
   public urlForm<T extends STUrlFormProps>(properties?: T, options: Options = {}): STUrlForm<T> {
@@ -326,7 +364,7 @@ export class SchemaType {
     return _MultipartForm(properties, options)
   }
   /** Crates an Array Schema Type */
-  public array<T extends STSchema>(schema?: T, options: Options = {}): STArray<T | STAny> {
+  public array<T extends STSchema>(schema?: T, options: Options = {}): STArray<T> {
     return _Array(schema, options)
   }
   /** Crates an Union Schema Type */
@@ -376,3 +414,36 @@ export class SchemaType {
     return _Stream(schema)
   }
 }
+
+export const schemaToTypeStr = (schema: STSchema): string => {
+  let type = 'unknown'
+  let kind = schema[Kind]
+
+  if (kind === 'boolean') type = 'boolean'
+  else if (kind === 'byteArray') type = 'Uint8Array'
+  else if (kind === 'number') type = 'number'
+  else if (kind === 'integer') type = 'number'
+  else if (kind === 'string') type = 'string'
+  else if (kind === 'any') type = 'any'
+  else if (kind === 'literal') {
+    let value = (schema as STLiteral).value
+    if (typeof value === 'string') type = `'${value}'`
+    else type = String(value)
+  } else if (kind === 'array') {
+    type = `Array<${schemaToTypeStr((schema as STArray).items)}>`
+  } else if (kind === 'object') {
+    let props = (schema as STObject).props
+    type = `{${Object.entries(props)
+      .map(([k, v]) => `${typeof k === 'string' ? `'${k}'` : k}:${schemaToTypeStr(v)}`)
+      .join(';')}}`
+  } else if (kind === 'json') {
+    type = `Json<${schemaToTypeStr({ ...schema, [Kind]: schema.type })}>`
+  } else if (kind === 'union') {
+    let anyOf = (schema as STUnion).anyOf
+    type = anyOf.map(s => schemaToTypeStr(s)).join('|')
+  }
+
+  if (schema[Optional]) type = `${type}|undefined`
+
+  return type
+}