galbe 0.3.0 → 0.4.1

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,43 +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) {
-    method = method.toUpperCase()
+  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,7 +1,7 @@
-import type { GalbeConfig } from './types'
+import type { GalbeConfig, Route } from './types'
 
 import { readdir, lstat } from 'fs/promises'
-import { extname, relative } from 'path'
+import { extname } from 'path'
 import { parse } from 'acorn'
 import { simple } from 'acorn-walk'
 import { Galbe } from './index'
@@ -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,20 +171,24 @@ 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) {
-      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
 
@@ -99,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)
 
@@ -114,49 +221,41 @@ export const metaAnalysis = async (filePath: string): Promise<RouteMeta> => {
   return meta
 }
 
-const importRoutes = async (filePath: string, galbe: Galbe) => {
-  const imported = await import(filePath)
-  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(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    ${relative('.', f)}\x1b[0m`)
-          await importRoutes(f, galbe)
+          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) {
-          console.log(`\x1b\[0;31m    Error: ${err?.message}\x1b[0m`)
+          if (cb) await cb({ type: 'error', error: err, filepath: f, route: undefined, meta: undefined })
         }
       }
     }
-    if (noRouteFound) {
-      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[]
@@ -172,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
@@ -190,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 =
@@ -231,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> {
@@ -251,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
@@ -323,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> {
@@ -336,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 */
@@ -386,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
+}

package/src/server.ts

@@ -1,11 +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 LOADABLE_METHODS = ['POST', 'PUT', 'PATCH']
+const METHODS = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS', 'HEAD']
+const EMPTY_BODY_METHODS = ['GET', 'OPTIONS', 'HEAD']
 
 const handleInternalError = (error: any) => {
   console.error(error)
@@ -13,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),
@@ -25,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: {} },
@@ -51,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)
@@ -72,7 +71,7 @@ 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 = LOADABLE_METHODS.includes(req.method)
+        context.body = !EMPTY_BODY_METHODS.includes(req.method)
           ? await requestBodyParser(req.body, inHeaders, schema.body)
           : null
         context.headers = inHeaders
@@ -147,10 +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, context.set.status || 200)
+          validateResponse(response, schema.response, parsedResponse.status || 200)
 
         for (const p of pluginsCb.afterHandle) {
           //@ts-ignore
@@ -180,7 +179,7 @@ export default async (galbe: Galbe, port?: number) => {
             status: error.status,
             headers: { 'Content-Type': 'application/json' }
           })
-        }
+        } else console.log(error)
         return new Response('"Internal Server Error"', {
           status: 500,
           headers: {