galbe 0.1.0

package/src/router.ts

@@ -0,0 +1,100 @@
+import type { Route, RouteNode, RouteTree } from './types'
+import { NotFoundError } from './types'
+
+const ROUTE_REGEX = /^(\/(\*|:?\d+|:?\w+|:?[\w\d][\w-]+[\w\d]))*\/?$/
+
+const walkRoutes = (path: string[], node: RouteNode, alts: RouteNode[] = []): RouteNode => {
+  if (path.length < 1) throw new NotFoundError()
+  if (path.length === 1 && node.route) 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)
+  }
+  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
+    }
+  }
+  if (alts.length > 1) {
+    return walkRoutes(path, alts.pop() as RouteNode, alts)
+  }
+  if (alts.length === 1) {
+    let lastAlt = alts.pop() as RouteNode
+    try {
+      return walkRoutes(path, lastAlt, alts)
+    } catch (error) {
+      if (error instanceof NotFoundError) {
+        if (lastAlt?.route) return lastAlt
+      } else throw error
+    }
+  }
+
+  throw new NotFoundError()
+}
+
+export class GalbeRouter {
+  routes: RouteTree
+  prefix: string
+  staticRoutes: Map<string, Route>
+  constructor(prefix?: string) {
+    this.routes = { GET: {}, POST: {}, PUT: {}, PATCH: {}, DELETE: {}, OPTIONS: {} }
+    prefix = prefix || ''
+    if (prefix && !prefix.match(/^\//)) prefix = `/${prefix}`
+    this.prefix = prefix
+    this.staticRoutes = new Map()
+  }
+  add(route: Route) {
+    route.path = route?.path?.[0] === '/' ? route.path : `/${route.path}`
+    if (!route.path.match(ROUTE_REGEX)) throw new SyntaxError(`${route.path} is not a valid route path.`)
+    const isStatic = !route.path.match(/(:[\w\d-]+|\*)/)
+    if (isStatic) this.staticRoutes.set(`[${route.method.toUpperCase()}]${route.path}`, route)
+    route.path = `${this.prefix || ''}${route.path}`
+    let path = route.path.replace(/^\/$(.*)\/?$/, '$1').split('/')
+    path.shift()
+    let r = this.routes[route.method.toUpperCase()]
+    if (!path.length) {
+      r.route = route
+    } else {
+      while (path.length) {
+        let p = path.shift()
+        if (p === undefined) break
+        if (!path.length) {
+          if (p.match(/^:/)) r.param = { route }
+          else {
+            if (!r.children) r.children = {}
+            r.children[p] = { ...r.children[p], route }
+          }
+        } else {
+          if (p.match(/^:/)) {
+            if (!r.param) r.param = {}
+            r = r.param
+          } else {
+            if (!r.children) r.children = {}
+            if (!(p in r.children)) r.children[p] = {}
+            r = r.children[p]
+          }
+        }
+      }
+    }
+  }
+  find(method: string, path: string) {
+    const staticRoute = this.staticRoutes.get(`[${method}]${path}`)
+    if (staticRoute !== undefined) return staticRoute
+    let parts = path
+      .replace(/\/+/g, '/')
+      .replace(/^\/$(.*)\/?$/, '$1')
+      .split('/')
+    const route = walkRoutes(parts, this.routes[method]).route
+    if (!route) throw new NotFoundError()
+    return route
+  }
+}

package/src/routes.ts

@@ -0,0 +1,157 @@
+import type { GalbeConfig } from './types'
+
+import { readdir, lstat } from 'fs/promises'
+import { extname } from 'path'
+import { parse } from 'acorn'
+import { simple } from 'acorn-walk'
+import { Galbe } from './index'
+import { transformSync } from '@swc/core'
+import { Glob } from 'bun'
+
+export type RouteMeta = {
+  header: Record<string, boolean | string | string[]>
+  routes: Record<string, Record<string, Record<string, boolean | string | string[]>>>
+}
+
+export type RouteFileMeta = {
+  file: string
+} & RouteMeta
+
+const parseComment = (comment: string): Record<string, string | string[]> => {
+  const head =
+    comment
+      .match(/^([^@]*)/)?.[1]
+      .replace(/^ *\* */gm, '')
+      .trim() || ''
+  const refs = {
+    ...(head ? { head } : {}),
+    ...[...comment.matchAll(new RegExp(`^\\s*\\*\\s*@([a-zA-Z_][0-9a-zA-Z_]*)(?:$|\\s+([^\\n]*)\\s*$)`, 'gm'))].reduce(
+      (acc, n) => {
+        return {
+          ...acc,
+          [n[1]]:
+            n[1] in acc ? [...(typeof acc[n[1]] === 'string' ? [acc[n[1]]] : acc[n[1]]), n[2] ?? true] : n[2] ?? true
+        }
+      },
+      {} as Record<string, any>
+    )
+  }
+  return refs
+}
+export const metaAnalysis = async (filePath: string): Promise<RouteMeta> => {
+  const file = Bun.file(filePath)
+  const fileExt = extname(filePath)
+  let content = await file.text()
+  let meta: RouteMeta = { header: {}, routes: {} }
+
+  if (fileExt === '.ts') {
+    //// Much faster but doesn't include comments. See https://github.com/oven-sh/bun/pull/7055
+    // content = new Bun.Transpiler({
+    //   loader: 'ts',
+    //   target: 'bun',
+    //   tsconfig: {
+    //     compilerOptions: {
+    //       // @ts-ignore https://github.com/oven-sh/bun/pull/7055
+    //       removeComments: false
+    //     }
+    //   }
+    // }).transformSync(content)
+    content = transformSync(content, {
+      jsc: {
+        parser: {
+          syntax: 'typescript'
+        },
+        preserveAllComments: true,
+        target: 'esnext'
+      }
+    }).code
+  }
+
+  const comments: 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
+    }
+  })
+  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 headerRef = parseComment(headerCom)
+      meta.header = headerRef
+      // @ts-ignore
+      simple(node.declaration.body, {
+        CallExpression(node) {
+          // @ts-ignore
+          if (node?.callee?.object?.name === galbeIdentifier) {
+            // @ts-ignore
+            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 routeRefs = parseComment(com)
+
+            if (!(path in meta.routes)) meta.routes[path] = {}
+            if (!(method in meta.routes[path])) meta.routes[path][method] = routeRefs
+          }
+        }
+      })
+    }
+  })
+  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) => {
+  const routes = options?.routes
+  if (!routes) {
+    console.log(`\x1b\[38;5;245m    No route file defined\x1b[0m`)
+    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)
+          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
+        }
+      }
+    }
+    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)
+    }
+  }
+}

package/src/server.ts

@@ -0,0 +1,174 @@
+import type { Context, Route } from './types'
+
+import { NotFoundError, RequestError } from './types'
+import { parseEntry, requestBodyParser, requestPathParser, responseParser } from './parser'
+import { Galbe } from './index'
+
+const handleInternalError = (error: any) => {
+  console.error(error)
+  return new RequestError({ status: 500, error: 'Internal Server Error' })
+}
+
+const setupPluginCallbacks = (galbe: Galbe) => ({
+  init: galbe.plugins.reduce((l: { name: string; cb: Function }[], p) => {
+    if (p.init) l.push({ name: p.name, cb: p.init })
+    return l
+  }, []),
+  onFetch: galbe.plugins.reduce((l: Function[], p) => {
+    if (p.onFetch) l.push(p.onFetch)
+    return l
+  }, []),
+  onRoute: galbe.plugins.reduce((l: Function[], p) => {
+    if (p.onRoute) l.push(p.onRoute)
+    return l
+  }, []),
+  beforeHandle: galbe.plugins.reduce((l: Function[], p) => {
+    if (p.beforeHandle) l.push(p.beforeHandle)
+    return l
+  }, []),
+  afterHandle: galbe.plugins.reduce((l: Function[], p) => {
+    if (p.afterHandle) l.push(p.afterHandle)
+    return l
+  }, [])
+})
+
+export default async (galbe: Galbe, port?: number) => {
+  const router = galbe.router
+  if (galbe?.config?.basePath && galbe?.config?.basePath[0] !== '/')
+    galbe.config.basePath = `/${galbe?.config?.basePath}`
+  let pluginsCb = setupPluginCallbacks(galbe)
+  for (const { name, cb } of pluginsCb.init) await cb(galbe?.config?.plugin?.[name], galbe)
+
+  return Bun.serve({
+    port: port || galbe.config?.port || 3000,
+    async fetch(req) {
+      const context: Context = {
+        request: req,
+        set: { headers: {} },
+        headers: {},
+        params: {},
+        query: {},
+        body: {},
+        state: {}
+      }
+      for (const cb of pluginsCb.onFetch) {
+        const r = await cb(req)
+        if (r) return r
+      }
+      const url = new URL(req.url)
+      let route: Route
+      let response: any = ''
+      try {
+        // find route
+        if (!url.pathname.match(new RegExp(`^${galbe.config?.basePath || ''}`))) throw new NotFoundError()
+        try {
+          route = router.find(req.method, url.pathname)
+        } catch (error) {
+          if (error instanceof RequestError) throw error
+          else throw handleInternalError(error)
+        }
+
+        for (const cb of pluginsCb.onRoute) {
+          const r = await cb(route)
+          if (r) return r
+        }
+
+        // parse request
+        const schema = route.schema
+        let inHeaders = Object.fromEntries(req.headers.entries())
+        let inQuery = Object.fromEntries(url.searchParams.entries())
+        let inParams = requestPathParser(url.pathname, route.path)
+
+        context.body = await requestBodyParser(req.body, inHeaders, schema.body)
+        context.headers = { ...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, error: errors.reduce((acc, c) => ({ ...acc, ...c.error }), {}) })
+        }
+
+        for (const cb of pluginsCb.beforeHandle) {
+          const r = await cb(context)
+          if (r) return r
+        }
+
+        // call chain
+        let handlerCalled = false
+        const handlerWrapper = async (context: Context) => {
+          handlerCalled = true
+          return route.handler(context)
+        }
+        const callChain = route.hooks.map((hook, idx) => ({
+          call: async () => {
+            let nextCalled = false
+            let next = async () => {
+              await callChain[idx + 1].call()
+            }
+            await hook(context, next)
+            if (!nextCalled && !handlerCalled) await next()
+          }
+        }))
+        callChain.push({
+          call: async () => {
+            response = await handlerWrapper(context)
+            context.set.status = response instanceof Response ? response.status : 200
+          }
+        })
+        if (callChain.length > 1) await callChain[0].call()
+        else response = await handlerWrapper(context)
+        const parsedResponse = responseParser(response, context)
+
+        for (const cb of pluginsCb.afterHandle) {
+          const r = await cb(parsedResponse)
+          if (r) return r
+        }
+
+        return parsedResponse
+      } catch (error) {
+        context.set.status = error instanceof RequestError ? error.status : 500
+        if (galbe.errorHandler) return galbe.errorHandler(error, context)
+        if (error instanceof RequestError) {
+          return new Response(JSON.stringify(error.error), {
+            status: error.status,
+            headers: { 'Content-Type': 'application/json' }
+          })
+        }
+        return new Response('Internal Server Error', { status: 500 })
+      }
+    },
+    error(error) {
+      console.error(error)
+      return new Response('Internal Server Error', {
+        status: 500,
+        headers: {
+          'Content-Type': 'text/plain'
+        }
+      })
+    }
+  })
+}

package/src/types.ts

@@ -0,0 +1,279 @@
+import type {
+  TSchema,
+  TBoolean,
+  TNumber,
+  TInteger,
+  TString,
+  TLiteral,
+  TArray,
+  TObject,
+  TProperties,
+  TUnion,
+  Static,
+  OptionalPropertyKeys,
+  ReadonlyOptionalPropertyKeys,
+  ReadonlyPropertyKeys,
+  RequiredPropertyKeys,
+  TAny
+} from '@sinclair/typebox'
+
+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 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 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
+    }
+  : 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
+
+export type Method = 'get' | 'post' | 'put' | 'delete' | 'patch' | 'options'
+type MaybePromise<T> = T | Promise<T>
+
+/**
+ * #### GalbeConfig
+ * Instanciate a Galbe web server
+ *
+ * ---
+ * @example
+ * ```typescript
+ * import { Galbe } from 'galbe'
+ * const config : GalbeConfig = {
+ *   port: 8080,
+ *   basePath: "/v1",
+ *   routes: "src/**­/*.route.ts"
+ * }
+ *
+ * export default new Galbe(config)
+ * ```
+ */
+export type GalbeConfig = {
+  port?: number
+  basePath?: string
+  routes?: string | string[]
+  plugin?: Record<string, any>
+}
+/**
+ * #### Schema
+ * Define a request Schema with constraint upon
+ *
+ * ---
+ * @example
+ * ```typescript
+ * import { T, Schema } from 'galbe'
+ * const MyRequestSchema = {
+ *   params: {
+ *    id: T.Number(),
+ *   },
+ *   body: T.Object({
+ *     name: T.String()
+ *     age: T.Optional(T.Number({minimum: 0})),
+ *   })
+ * }
+ * ```
+ */
+export type Schema<
+  H extends TProperties = TProperties,
+  P extends TProperties = TProperties,
+  Q extends TProperties = TProperties,
+  B extends TBody = TBody
+> = {
+  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>>>
+  body: Static<Exclude<S['body'], undefined>>
+  request: Request
+  state: Record<string, any>
+  set: {
+    headers: {
+      [header: string]: string
+    }
+    status?: number
+    redirect?: string
+  }
+}
+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 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>>
+  ): 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>>
+  ): 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>>
+  ): void
+  <H extends TProperties, P extends TProperties, Q extends TProperties, B extends TBody = TObject>(
+    path: string,
+    handler: Handler<Schema<H, P, Q, B>>
+  ): void
+}
+
+export class RequestError {
+  status: number
+  error: any
+  constructor(options: { status?: number; error?: any }) {
+    this.status = options.status ?? 500
+    this.error = options.error ?? 'Internal server error'
+  }
+}
+
+export type ErrorHandler = (error: any, context: Context) => any
+
+export type RouteNode = {
+  route?: Route
+  param?: RouteNode
+  children?: Record<string, RouteNode>
+}
+
+export type Route<
+  H extends TProperties = TProperties,
+  P extends TProperties = TProperties,
+  Q extends TProperties = TProperties,
+  B extends TBody = TBody
+> = {
+  method: Method
+  path: string
+  schema: Schema<H, P, Q, B>
+  context: Context<Schema<H, P, Q, B>>
+  hooks: Hook[]
+  handler: Handler<Schema<H, P, Q, B>>
+}
+
+export type RouteTree = {
+  [key: string]: RouteNode
+}
+
+export class NotFoundError extends RequestError {
+  constructor(message?: string) {
+    super({ status: 404, error: message ?? 'Not found' })
+  }
+}
+
+/**
+ * #### GalbePlugin
+ * Define a plugin for a Galbe server
+ *
+ * ---
+ * @example
+ * ```typescript
+ * import { GalbePlugin } from 'galbe'
+ * const MyPlugin : GalbePlugin = {
+ *   name: 'com.example.plugin.name',
+ *   init: (config, galbe) => {
+ *     console.log('Plugin initialization')
+ *   },
+ *   onRoute: (route) => {
+ *     if(route.path === '/myPlugin') {
+ *       return new Response('Hello Mom!')
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export type GalbePlugin = {
+  name: string
+  init?: (config: any, galbe: Galbe) => MaybePromise<void>
+  onFetch?: (request: Request) => MaybePromise<Response | void>
+  onRoute?: (route: Route) => MaybePromise<Response | void>
+  beforeHandle?: (context: Context) => MaybePromise<Response | void>
+  afterHandle?: (response: Response) => MaybePromise<Response | void>
+}