galbe 0.1.13 → 0.3.0

package/docs/context.md

@@ -1,7 +1,7 @@
 # Context
 
 An instance of the context object is created when a new request is initiated and carrieds out along durring all the request lifecycle.
-See the [Lifecycle](lifecycle) section to get more details.
+See the [Lifecycle](https://galbe.dev/documentation/lifecycle) section to get more details.
 
 Its purpose is to carrie all the relevent information about the request and to allow sharing informations between each step of the request lifecycle.
 

package/docs/getting-started.md

@@ -137,6 +137,14 @@ A Glob Pattern or a list of Glob patterns defining the route files to be analyze
 
 A property that can be used by plugins to add plugin's specific configuration. Every key should correspond to a [Unique Plugin Identifier](plugins.md).
 
+**requestValidator.enabled**
+
+Enable or disable the _request_ schema validation (See [Request Schema definition](schemas.md#request-schema-definition)). Default value is `true`.
+
+**responseValidator.enabled**
+
+Enable or disable the _response_ schema validation (See [Request Schema definition](schemas.md#request-schema-definition)). Default value is `true`.
+
 ### Examples
 
 A common way to handle server configuration is to create new file `galbe.config.(js|ts|json)` at the root of your project directory and import it in your code. Here is an example:

package/docs/handler.md

@@ -10,7 +10,7 @@ The handler should be declared as last argument of the [Route Definition](routes
 galbe.get('foo', schema, [hook1, hook2], ctx => {})
 ```
 
-Handler are called after the last hook call, or right after the request parsing if no hook is declared. To get a better understanding of the request lifecycle, you can refer to the [Lifecycle](lifecycle.md) section.
+Handler are called after the last hook call, or right after the request parsing if no hook is declared. To get a better understanding of the request lifecycle, you can refer to the [Lifecycle](https://galbe.dev/documentation/lifecycle) section.
 
 ## Handler definition
 

package/docs/hooks.md

@@ -35,7 +35,7 @@ Hooks should be declared just before the handler method in the [Route Definition
 galbe.get('foo', [ hook1, hook2, ... ], ctx => {})
 ```
 
-Hooks are called just before the [Handler](handler.md) in the order that they have been declared in the hook list of the [Route Definition](routes.md#route-defintion). To get a better understanding of hooks execution during the request lifecycle, you can refer to the [Lifecycle](lifecycle.md) section.
+Hooks are called just before the [Handler](handler.md) in the order that they have been declared in the hook list of the [Route Definition](routes.md#route-defintion). To get a better understanding of hooks execution during the request lifecycle, you can refer to the [Lifecycle](https://galbe.dev/documentation/lifecycle) section.
 
 ### Examples
 
@@ -49,7 +49,7 @@ const hook2 = context => {
   console.log('hook2 called')
 }
 
-galbe.get('example', [hook1, hook2], ctx => {
+galbe.get('/example', [hook1, hook2], ctx => {
   console.log('handler')
 })
 ```
@@ -64,18 +64,18 @@ handler
 Nested hooks declaration:
 
 ```ts
-const hook1 = (context, next) => {
+const hook1 = async (context, next) => {
   console.log('hook1 start')
   await next()
   console.log('hook1 end')
 }
-const hook2 = context => {
+const hook2 = async (context, next) => {
   console.log('hook2 start')
   await next()
   console.log('hook2 end')
 }
 
-galbe.get('example', [hook1, hook2], ctx => {
+galbe.get('/example', [hook1, hook2], ctx => {
   console.log('handler')
 })
 ```

package/docs/plugins.md

@@ -1 +1,118 @@
 # Plugins
+
+Galbe provides a powerful plugin system that allows developers to extend and customize the behavior of the framework. The plugin capabilities are centered around the [Request Lifecycle](https://galbe.dev/documentation/lifecycle).
+
+## Definition
+
+```ts
+type GalbePlugin = {
+  name: string
+  init?: (config: any, galbe: Galbe) => MaybePromise<void>
+  onFetch?: (context: Context) => MaybePromise<Response | void>
+  onRoute?: (context: Context) => MaybePromise<Response | void>
+  beforeHandle?: (context: Context) => MaybePromise<Response | void>
+  afterHandle?: (response: Response, context: Context) => MaybePromise<Response | void>
+}
+```
+
+**name**
+
+The name should be a Unique Plugin Identifier. It should be chosen to be unique to avoid conflicts with other potential plugins. For example, Galbe's official plugins names will always start with `dev.galbe.*`.
+
+**init**
+
+This method is called right after the server starts. It takes two arguments: a `config` and a `galbe` instance. The `config` holds the configuration for the specific scope of the current plugin (See [Configuration](getting-started.md#properties) `plugin` property for more details). The `galbe` argument is the instance of the current server; you can for instance retrieve the current routes definitions with `galbe.router.routes`.
+
+**onFetch**
+
+This method is called at the beginning of an incoming request. It takes a single `context` argument representing the current request [Context](context.md).
+
+It is preemptable, meaning that any returned value will be interpreted as a response to send back to the client. Therefore, the method should only return [Response](https://developer.mozilla.org/en-US/docs/Web/API/Response) instances or nothing.
+
+**onRoute**
+
+This method is called after the router has found a matching route for the current request. Its takes a single `context` argument representing the current request [Context](context.md).
+
+It is preemptable, meaning that any returned value will be interpreted as a response to send back to the client. Therefore, the method should only return [Response](https://developer.mozilla.org/en-US/docs/Web/API/Response) instances or nothing.
+
+**beforeHandle**
+
+This method is called after the request has been validated and before the route hooks and the handler are called. It takes a single `context` argument representing the current request [Context](context.md).
+
+It is preemptable, meaning that any returned value will be interpreted as a response to send back to the client. Therefore, the method should only return [Response](https://developer.mozilla.org/en-US/docs/Web/API/Response) instances or nothing.
+
+**afterHandle**
+
+This method is called after the route handler has been called and before the response is sent. Its takes two arguments: a `response` object containing the [Response](https://developer.mozilla.org/en-US/docs/Web/API/Response) returned by the handler, and a `context` argument representing the current request [Context](context.md).
+
+It is preemptable, meaning that any returned value will be interpreted as a response to send back to the client. Therefore, the method should only return [Response](https://developer.mozilla.org/en-US/docs/Web/API/Response) instances or nothing.
+
+## Registration
+
+To register a plugin with your Galbe server, you must use the `use` method from you galbe instance.
+
+```js
+const galbe = new Galbe()
+galbe.use(plugin)
+```
+
+## Example
+
+Here is an example of a plugin implementation that handles routes tagged with `@deprecated` metadata (See [Route files](routes.md#route-files) section about metadata).
+
+```ts
+// myPlugin.ts
+
+import { Galbe, type Context, type Route } from 'galbe'
+
+class MyPlugin {
+  name = 'dev.galbe.example'
+  deprecated: Record<string, string[]> = {}
+  // Retrieve and store all route with a @deprecated flag metadata
+  init(config: any, galbe: Galbe) {
+    if (config?.enabled && galbe.meta) {
+      for (const f of galbe.meta) {
+        for (const [path, methods] of Object.entries(f.routes)) {
+          for (const [method, meta] of Object.entries(methods)) {
+            if (meta.deprecated) {
+              if (!this.deprecated?.[method]) this.deprecated[method] = []
+              this.deprecated[method].push(path)
+            }
+          }
+        }
+      }
+    }
+  }
+  // Check if the current route is deprecated; if so, flag it as such and log it
+  onRoute(context: Context) {
+    let route = context.route
+    if (this.deprecated?.[route.method]?.includes(route.path)) {
+      context.state[this.name] = { deprecated: true }
+      console.warn(`Call to deprecated route [${route.method}]${route.path}`)
+    }
+  }
+  // Add a header if the request has previously been flagged as deprecated
+  afterHandle(response: Response, context: Context) {
+    if (context.state?.[this.name]?.deprecated) {
+      response.headers.set('x-deprecated', 'true')
+    }
+  }
+}
+
+export default new MyPlugin()
+```
+
+```ts
+// index.ts
+
+import { Galbe } from 'galbe'
+import config from './galbe.config'
+import myPlugin from './myPlugin'
+
+const galbe = new Galbe(config)
+galbe.use(myPlugin)
+
+export default galbe
+```
+
+As you can see in this example, the [Context](context.md#definition) `state` property is used to persist information between plugins interceptor methods. It is a good practice to scope any information stored in the state with the plugin name, as it can also be used by other plugins and hooks to store data in the context.

package/docs/schemas.md

@@ -152,8 +152,7 @@ const schema = {
 
 <!-- prettier-ignore -->
 ```ts
-body: STByteArray | STString | STBoolean | STNumber | STInteger | STLiteral | 
-      STObject | STMulripartForm | STUrlForm
+body: STByteArray | STString | STBoolean | STNumber | STInteger | STLiteral | STObject | STArray | STMulripartForm | STUrlForm | STStream
 ```
 
 #### Json
@@ -238,3 +237,21 @@ galbe.post(
   }
 })
 ```
+
+### response
+
+<!-- prettier-ignore -->
+```ts
+response: Record<number, STByteArray | STString | STBoolean | STNumber | STInteger | STLiteral | STObject | STArray | STStream>
+```
+
+Same as for request body validation but to validate handler responses. Every schema type must be associated to a specific response status.
+
+#### Example
+
+```ts
+const response = {
+  200: $T.object({ data: $T.array($T.number()) })
+  404: $T.literal("Not found")
+}
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "galbe",
-  "version": "0.1.13",
+  "version": "0.3.0",
   "description": "Fast, lightweight and highly customizable JavaScript web framework based on Bun",
   "author": "Pierre Caillaud M (https://github.com/pierre-cm)",
   "type": "module",

package/src/index.ts

@@ -11,6 +11,7 @@ import type {
   ErrorHandler,
   GalbePlugin,
   STBody,
+  STResponse,
   STParams,
   STHeaders,
   STQuery
@@ -19,7 +20,7 @@ import type {
 import server from './server'
 import { GalbeRouter } from './router'
 import { defineRoutes } from './routes'
-import { logRoute } from './util'
+import { extractMetaRoute, logRoute } from './util'
 import { SchemaType, type STObject, type Static } from './schema'
 
 const overloadDiscriminer = <
@@ -27,17 +28,18 @@ const overloadDiscriminer = <
   H extends STHeaders,
   P extends Partial<STParams<Path>>,
   Q extends STQuery,
-  B extends STBody
+  B extends STBody,
+  R extends STResponse
 >(
   galbe: Galbe,
   method: Method,
   path: Path,
   arg2:
-    | RequestSchema<Path, H, P, Q, B>
-    | Hook<Path, RequestSchema<Path, H, P, Q, B>>[]
-    | Handler<Path, RequestSchema<Path, H, P, Q, B>>,
-  arg3?: Hook<Path, RequestSchema<Path, H, P, Q, B>>[] | Handler<Path, RequestSchema<Path, H, P, Q, B>>,
-  arg4?: Handler<Path, RequestSchema<Path, H, P, Q, B>>
+    | RequestSchema<Path, H, P, Q, B, R>
+    | Hook<Path, RequestSchema<Path, H, P, Q, B, R>>[]
+    | Handler<Path, RequestSchema<Path, H, P, Q, B, R>>,
+  arg3?: Hook<Path, RequestSchema<Path, H, P, Q, B, R>>[] | Handler<Path, RequestSchema<Path, H, P, Q, B, R>>,
+  arg4?: Handler<Path, RequestSchema<Path, H, P, Q, B, R>>
 ) => {
   const defaultSchema = {}
   if (typeof arg2 === 'function') {
@@ -57,14 +59,15 @@ const galbeMethod = <
   H extends STHeaders,
   P extends Partial<STParams<Path>>,
   Q extends STQuery,
-  B extends STBody
+  B extends STBody,
+  R extends STResponse
 >(
   _galbe: Galbe,
   method: Method,
   path: Path,
-  schema: RequestSchema<Path, H, P, Q, B> | undefined,
-  hooks: Hook<Path, RequestSchema<Path, H, P, Q, B>>[] | undefined,
-  handler: Handler<Path, RequestSchema<Path, H, P, Q, B>>
+  schema: RequestSchema<Path, H, P, Q, B, R> | undefined,
+  hooks: Hook<Path, RequestSchema<Path, H, P, Q, B, R>>[] | undefined,
+  handler: Handler<Path, RequestSchema<Path, H, P, Q, B, R>>
 ) => {
   schema = schema ?? {}
   hooks = hooks || []
@@ -92,6 +95,7 @@ const galbeMethod = <
   }
 }
 
+/** Galbe Schema Type builder. See {@link https://galbe.dev/documentation/schemas#schema-types Schema Types} */
 export const $T = new SchemaType()
 
 export { RequestError } from './types'
@@ -126,12 +130,14 @@ export class Galbe {
       prefix: this.config?.basePath || '',
       cacheEnabled: this.config?.router?.cacheEnabled
     })
+    this.config.requestValidator = config?.requestValidator ?? { enabled: true }
+    this.config.responseValidator = config?.responseValidator ?? { enabled: true }
   }
   private add(route: any) {
     this.router.add(route)
     if (Bun.env.BUN_ENV === 'development') {
       if (!this.#prepare) indexRoutes.push({ method: route.method, path: route.path })
-      else logRoute(route)
+      else logRoute(route, extractMetaRoute(route, this.meta))
     }
   }
   async use(plugin: GalbePlugin) {
@@ -144,7 +150,7 @@ export class Galbe {
     if (Bun.env.BUN_ENV === 'development') {
       this.#prepare = true
       console.log('🏗️  \x1b[1;30mConstructing routes\x1b[0m')
-      for (const r of indexRoutes) logRoute(r)
+      for (const r of indexRoutes) logRoute(r, extractMetaRoute(r, this.meta))
       await defineRoutes(this.config || {}, this)
       console.log('\n✅ \x1b[1;30mdone\x1b[0m')
       this.server = await server(this, port)
@@ -168,90 +174,96 @@ export class Galbe {
     H extends STHeaders,
     P extends Partial<STParams<Path>>,
     Q extends STQuery,
-    B extends STBody
+    B extends STBody,
+    R extends STResponse
   >(
     path: Path,
     arg2:
-      | RequestSchema<Path, H, P, Q, B>
-      | Hook<Path, RequestSchema<Path, H, P, Q, B>>[]
-      | Handler<Path, RequestSchema<Path, H, P, Q, B>>,
-    arg3?: Hook<Path, RequestSchema<Path, H, P, Q, B>>[] | Handler<Path, RequestSchema<Path, H, P, Q, B>>,
-    arg4?: Handler<Path, RequestSchema<Path, H, P, Q, B>>
+      | RequestSchema<Path, H, P, Q, B, R>
+      | Hook<Path, RequestSchema<Path, H, P, Q, B, R>>[]
+      | Handler<Path, RequestSchema<Path, H, P, Q, B, R>>,
+    arg3?: Hook<Path, RequestSchema<Path, H, P, Q, B, R>>[] | Handler<Path, RequestSchema<Path, H, P, Q, B, R>>,
+    arg4?: Handler<Path, RequestSchema<Path, H, P, Q, B, R>>
   ) => this.add(overloadDiscriminer(this, 'get', path, arg2, arg3, arg4))
   post: Endpoint = <
     Path extends string,
     H extends STHeaders,
     P extends Partial<STParams<Path>>,
     Q extends STQuery,
-    B extends STBody
+    B extends STBody,
+    R extends STResponse
   >(
     path: Path,
     arg2:
-      | RequestSchema<Path, H, P, Q, B>
-      | Hook<Path, RequestSchema<Path, H, P, Q, B>>[]
-      | Handler<Path, RequestSchema<Path, H, P, Q, B>>,
-    arg3?: Hook<Path, RequestSchema<Path, H, P, Q, B>>[] | Handler<Path, RequestSchema<Path, H, P, Q, B>>,
-    arg4?: Handler<Path, RequestSchema<Path, H, P, Q, B>>
+      | RequestSchema<Path, H, P, Q, B, R>
+      | Hook<Path, RequestSchema<Path, H, P, Q, B, R>>[]
+      | Handler<Path, RequestSchema<Path, H, P, Q, B, R>>,
+    arg3?: Hook<Path, RequestSchema<Path, H, P, Q, B, R>>[] | Handler<Path, RequestSchema<Path, H, P, Q, B, R>>,
+    arg4?: Handler<Path, RequestSchema<Path, H, P, Q, B, R>>
   ) => this.add(overloadDiscriminer(this, 'post', path, arg2, arg3, arg4))
   put: Endpoint = <
     Path extends string,
     H extends STHeaders,
     P extends Partial<STParams<Path>>,
     Q extends STQuery,
-    B extends STBody
+    B extends STBody,
+    R extends STResponse
   >(
     path: Path,
     arg2:
-      | RequestSchema<Path, H, P, Q, B>
-      | Hook<Path, RequestSchema<Path, H, P, Q, B>>[]
-      | Handler<Path, RequestSchema<Path, H, P, Q, B>>,
-    arg3?: Hook<Path, RequestSchema<Path, H, P, Q, B>>[] | Handler<Path, RequestSchema<Path, H, P, Q, B>>,
-    arg4?: Handler<Path, RequestSchema<Path, H, P, Q, B>>
+      | RequestSchema<Path, H, P, Q, B, R>
+      | Hook<Path, RequestSchema<Path, H, P, Q, B, R>>[]
+      | Handler<Path, RequestSchema<Path, H, P, Q, B, R>>,
+    arg3?: Hook<Path, RequestSchema<Path, H, P, Q, B, R>>[] | Handler<Path, RequestSchema<Path, H, P, Q, B, R>>,
+    arg4?: Handler<Path, RequestSchema<Path, H, P, Q, B, R>>
   ) => this.add(overloadDiscriminer(this, 'put', path, arg2, arg3, arg4))
   patch: Endpoint = <
     Path extends string,
     H extends STHeaders,
     P extends Partial<STParams<Path>>,
     Q extends STQuery,
-    B extends STBody
+    B extends STBody,
+    R extends STResponse
   >(
     path: Path,
     arg2:
-      | RequestSchema<Path, H, P, Q, B>
-      | Hook<Path, RequestSchema<Path, H, P, Q, B>>[]
-      | Handler<Path, RequestSchema<Path, H, P, Q, B>>,
-    arg3?: Hook<Path, RequestSchema<Path, H, P, Q, B>>[] | Handler<Path, RequestSchema<Path, H, P, Q, B>>,
-    arg4?: Handler<Path, RequestSchema<Path, H, P, Q, B>>
+      | RequestSchema<Path, H, P, Q, B, R>
+      | Hook<Path, RequestSchema<Path, H, P, Q, B, R>>[]
+      | Handler<Path, RequestSchema<Path, H, P, Q, B, R>>,
+    arg3?: Hook<Path, RequestSchema<Path, H, P, Q, B, R>>[] | Handler<Path, RequestSchema<Path, H, P, Q, B, R>>,
+    arg4?: Handler<Path, RequestSchema<Path, H, P, Q, B, R>>
   ) => this.add(overloadDiscriminer(this, 'patch', path, arg2, arg3, arg4))
   delete: Endpoint = <
     Path extends string,
     H extends STHeaders,
     P extends Partial<STParams<Path>>,
     Q extends STQuery,
-    B extends STBody
+    B extends STBody,
+    R extends STResponse
   >(
     path: Path,
     arg2:
-      | RequestSchema<Path, H, P, Q, B>
-      | Hook<Path, RequestSchema<Path, H, P, Q, B>>[]
-      | Handler<Path, RequestSchema<Path, H, P, Q, B>>,
-    arg3?: Hook<Path, RequestSchema<Path, H, P, Q, B>>[] | Handler<Path, RequestSchema<Path, H, P, Q, B>>,
-    arg4?: Handler<Path, RequestSchema<Path, H, P, Q, B>>
+      | RequestSchema<Path, H, P, Q, B, R>
+      | Hook<Path, RequestSchema<Path, H, P, Q, B, R>>[]
+      | Handler<Path, RequestSchema<Path, H, P, Q, B, R>>,
+    arg3?: Hook<Path, RequestSchema<Path, H, P, Q, B, R>>[] | Handler<Path, RequestSchema<Path, H, P, Q, B, R>>,
+    arg4?: Handler<Path, RequestSchema<Path, H, P, Q, B, R>>
   ) => this.add(overloadDiscriminer(this, 'delete', path, arg2, arg3, arg4))
   options: Endpoint = <
     Path extends string,
     H extends STHeaders,
     P extends Partial<STParams<Path>>,
     Q extends STQuery,
-    B extends STBody
+    B extends STBody,
+    R extends STResponse
   >(
     path: Path,
     arg2:
-      | RequestSchema<Path, H, P, Q, B>
-      | Hook<Path, RequestSchema<Path, H, P, Q, B>>[]
-      | Handler<Path, RequestSchema<Path, H, P, Q, B>>,
-    arg3?: Hook<Path, RequestSchema<Path, H, P, Q, B>>[] | Handler<Path, RequestSchema<Path, H, P, Q, B>>,
-    arg4?: Handler<Path, RequestSchema<Path, H, P, Q, B>>
+      | RequestSchema<Path, H, P, Q, B, R>
+      | Hook<Path, RequestSchema<Path, H, P, Q, B, R>>[]
+      | Handler<Path, RequestSchema<Path, H, P, Q, B, R>>,
+    arg3?: Hook<Path, RequestSchema<Path, H, P, Q, B, R>>[] | Handler<Path, RequestSchema<Path, H, P, Q, B, R>>,
+    arg4?: Handler<Path, RequestSchema<Path, H, P, Q, B, R>>
   ) => this.add(overloadDiscriminer(this, 'options', path, arg2, arg3, arg4))
 }
 

package/src/parser.ts

@@ -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()
@@ -594,7 +595,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,8 +630,6 @@ 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) => {
   const details = {
     status: ctx.set.status || 200,

package/src/router.ts

@@ -89,6 +89,7 @@ export class GalbeRouter {
     }
   }
   find(method: string, path: string) {
+    method = method.toUpperCase()
     const staticRoute = this.cachedRoutes.get(`[${method}]${path}`)
     if (staticRoute === null) throw new NotFoundError()
     if (staticRoute !== undefined) return staticRoute

package/src/routes.ts

@@ -1,7 +1,7 @@
 import type { GalbeConfig } from './types'
 
 import { readdir, lstat } from 'fs/promises'
-import { extname } from 'path'
+import { extname, relative } from 'path'
 import { parse } from 'acorn'
 import { simple } from 'acorn-walk'
 import { Galbe } from './index'
@@ -81,13 +81,15 @@ export const metaAnalysis = async (filePath: string): Promise<RouteMeta> => {
   })
   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
+      let galbeIdentifier = node.declaration?.params?.[0]?.name
+      if (!galbeIdentifier) return meta
+
       // @ts-ignore
       simple(node.declaration.body, {
         CallExpression(node) {
@@ -113,7 +115,10 @@ export const metaAnalysis = async (filePath: string): Promise<RouteMeta> => {
 }
 
 const importRoutes = async (filePath: string, galbe: Galbe) => {
-  const routes = (await import(filePath)).default
+  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)
 }
 
@@ -138,16 +143,14 @@ export const defineRoutes = async (options: GalbeConfig, galbe: Galbe) => {
         try {
           const metadata = await metaAnalysis(f)
           galbe.meta?.push({ file: path, ...metadata })
-          console.log(`\n\x1b\[0;36m    ${f}\x1b[0m`)
+          console.log(`\n\x1b\[0;36m    ${relative('.', f)}\x1b[0m`)
           await importRoutes(f, galbe)
-        } catch (err) {
-          // console.log(`\x1b\[0;31m    ${f}\x1b[0m`)
-          throw err
+        } catch (err: any) {
+          console.log(`\x1b\[0;31m    Error: ${err?.message}\x1b[0m`)
         }
       }
     }
     if (noRouteFound) {
-      process.stdout.write('\r\x1b[K')
       console.log(`\x1b\[38;5;245m    No route found\x1b[0m`)
       return
     }

package/src/schema.ts

@@ -63,6 +63,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