galbe 0.4.1 → 0.5.0

package/docs/plugins.md

@@ -17,7 +17,7 @@ type GalbePlugin = {
 
 **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.*`.
+The name should be a Unique Plugin Identifier. It should be chosen to be unique to avoid conflicts with other potential plugins. Ideally, it will have the form of `com.example.myplugin`.
 
 **init**
 
@@ -62,44 +62,44 @@ Here is an example of a plugin implementation that handles routes tagged with `@
 
 ```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)
-            }
-          }
-        }
+import type { GalbePlugin } from 'galbe'
+import { walkMetaRoutes } from 'galbe/utils'
+
+const PLUGIN_ID = 'dev.galbe.deprecated'
+
+export default () => {
+  let deprecateds = new Set<string>()
+  return {
+    name: PLUGIN_ID,
+    // Init the plugin, check for deprecated metadata tags
+    init(_config, galbe) {
+      if (galbe.meta) {
+        walkMetaRoutes(galbe.meta, (method, path, meta) => {
+          if (meta.deprecated) deprecateds.add(JSON.stringify({ method, path }))
+        })
+      }
+    },
+    // Check if the current route is deprecated; if so, flag it as such and log it
+    onRoute(context) {
+      let r = context.route
+      if (!r) return
+      if (deprecateds.has(JSON.stringify({ method: r.method, path: r.path }))) {
+        context.state[PLUGIN_ID] = { deprecated: true }
+        console.warn(`Call to deprecated route "${r.method} ${r.path}"`)
+      }
+    },
+    // Add a header to the response if the route has been flagged as deprecated
+    afterHandle(response, context) {
+      let r = context.route
+      if (!r) return
+      console.log('yooo', r.method, r.path)
+      if (deprecateds.has(JSON.stringify({ method: r.method, path: r.path }))) {
+        console.log('OK...')
+        response.headers.set('x-deprecated', 'true')
       }
     }
-  }
-  // 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')
-    }
-  }
+  } as GalbePlugin
 }
-
-export default new MyPlugin()
 ```
 
 ```ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "galbe",
-  "version": "0.4.1",
+  "version": "0.5.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/routes.ts

@@ -1,4 +1,4 @@
-import type { GalbeConfig, Route } from './types'
+import type { GalbeConfig, Method, Route } from './types'
 
 import { readdir, lstat } from 'fs/promises'
 import { extname } from 'path'
@@ -13,7 +13,7 @@ export const DEFAULT_ROUTE_PATTERN = 'src/**/*.route.{js,ts}'
 export type RouteMeta = { head?: string } & Record<string, boolean | string | string[]>
 export type RoutesMeta = {
   header: Record<string, boolean | string | string[]>
-  routes: Record<string, Record<string, RouteMeta>>
+  routes: Record<string, Partial<Record<Method, RouteMeta>>>
 }
 export type RouteInstanciationCallback = <T extends 'add' | 'error'>(event: {
   type: T
@@ -204,7 +204,7 @@ export const metaAnalysis = async (filePath: string): Promise<RoutesMeta> => {
             // @ts-ignore
             const path = node.arguments[0].value
             // @ts-ignore
-            const method = node.callee.property.name
+            const method = node.callee.property.name as Method
             const line = node.loc?.start.line || -1
             const col = node.loc?.start.column || -1
             const com = comments?.[line]?.[col - 1] ? comments[line][col - 1] : ''

package/src/util.ts

@@ -1,5 +1,5 @@
-import type { Route, RouteNode } from '.'
-import type { RouteMeta } from './routes'
+import type { Method, Route, RouteNode } from '.'
+import type { RouteFileMeta, RouteMeta } from './routes'
 
 const METHOD_COLOR: Record<string, string> = {
   get: '\x1b[32m',
@@ -24,12 +24,31 @@ export const logRoute = (
   )
 }
 
+/**
+ * Walk over the routes tree. A callback is called for each route with Route infos.
+ */
 export const walkRoutes = (node: RouteNode, cb: (route: Route) => void) => {
   if (node?.routes) Object.values(node.routes).forEach(r => cb(r))
   for (let c of Object.values(node?.children || {})) walkRoutes(c, cb)
   if (node?.param) walkRoutes(node.param, cb)
 }
 
+/**
+ * Walk over the routes metadata tree. A callback is called for each route metadata with RouteMeta infos.
+ */
+export const walkMetaRoutes = (
+  meta: RouteFileMeta[],
+  cb: (method: Method, path: string, routeMeta: RouteMeta) => void
+) => {
+  for (const f of meta) {
+    for (const [path, methods] of Object.entries(f.routes)) {
+      for (const [method, meta] of Object.entries(methods)) {
+        cb(method as Method, path, meta)
+      }
+    }
+  }
+}
+
 export const isIterator = (obj: any) => typeof obj?.next === 'function'
 
 export const HttpStatus = {