@stacksjs/router 0.61.24 → 0.62.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/router",
   "type": "module",
-  "version": "0.61.24",
+  "version": "0.62.0",
   "description": "The Stacks framework router.",
   "author": "Chris Breuer",
   "license": "MIT",
@@ -49,14 +49,14 @@
   },
   "peerDependencies": {
     "@stacksjs/config": "latest",
-    "unplugin-vue-router": "^0.9.0",
-    "vue-router": "^4.3.2"
+    "unplugin-vue-router": "^0.10.0",
+    "vue-router": "^4.4.0"
   },
   "dependencies": {
     "@stacksjs/config": "latest",
     "@stacksjs/logging": "latest",
-    "unplugin-vue-router": "^0.9.0",
-    "vue-router": "^4.3.2"
+    "unplugin-vue-router": "^0.10.0",
+    "vue-router": "^4.4.0"
   },
   "devDependencies": {
     "@stacksjs/development": "latest"

package/src/request.ts

@@ -1,15 +1,33 @@
-import type { RequestInstance, RouteParam } from "@stacksjs/types"
+import type { RequestInstance, RouteParam } from '@stacksjs/types'
+
+import type { VineType } from '@stacksjs/types'
+import { customValidate, validateField } from '@stacksjs/validation'
 
 interface RequestData {
   [key: string]: string
 }
 
+interface ValidationType {
+  rule: VineType
+  message: { [key: string]: string }
+}
+
+interface ValidationField {
+  [key: string]: string | ValidationType
+  validation: ValidationType
+}
+
+interface CustomAttributes {
+  [key: string]: ValidationField
+}
+
 type RouteParams = { [key: string]: string } | null
 
-export class Request implements RequestInstance{
+export class Request implements RequestInstance {
   private static instance: Request
   private query: RequestData = {}
   private params: RouteParams = null
+  private headers: any = {}
 
   // An attempt to singleston instance, might be needed at some point
   public static getInstance(): Request {
@@ -23,10 +41,18 @@ export class Request implements RequestInstance{
     this.query = Object.fromEntries(url.searchParams)
   }
 
+  public addBodies(params: any): void {
+    this.query = params
+  }
+
   public addParam(param: RouteParam): void {
     this.params = param
   }
 
+  public addHeaders(headerParams: Headers): void {
+    this.headers = headerParams
+  }
+
   public get(element: string): string | number | undefined {
     return this.query[element]
   }
@@ -35,6 +61,14 @@ export class Request implements RequestInstance{
     return this.query
   }
 
+  public async validate(attributes?: CustomAttributes): Promise<void> {
+    if (attributes === undefined || attributes === null) {
+      await validateField('Release', this.all())
+    } else {
+      await customValidate(attributes, this.all())
+    }
+  }
+
   public has(element: string): boolean {
     return element in this.query
   }
@@ -50,10 +84,32 @@ export class Request implements RequestInstance{
     if (match?.groups) this.params = match.groups
   }
 
+  public header(headerParam: string): string | number | boolean | null {
+    return this.headers.get(headerParam)
+  }
+
+  public getHeaders() {
+    return this.headers
+  }
+
+  public Header(headerParam: string): string | number | boolean | null {
+    return this.headers.get(headerParam)
+  }
+
   public getParam(key: string): number | string | null {
     return this.params ? this.params[key] || null : null
   }
 
+  public bearerToken(): string | null {
+    const authorizationHeader = this.headers.get('authorization')
+
+    if (authorizationHeader && authorizationHeader.startsWith('Bearer ')) {
+      return authorizationHeader.substring(7)
+    }
+
+    return null
+  }
+
   public getParams(): RouteParams {
     return this.params
   }
@@ -62,6 +118,6 @@ export class Request implements RequestInstance{
     const value = this.params ? this.params[key] || null : null
     return value ? Number.parseInt(value) : null
   }
-} 
+}
 
 export const request = new Request()

package/src/router.ts

@@ -3,10 +3,9 @@ import { log } from '@stacksjs/logging'
 import { path as p, projectStoragePath, routesPath } from '@stacksjs/path'
 import { kebabCase, pascalCase } from '@stacksjs/strings'
 import type { Job } from '@stacksjs/types'
-import { request } from '@stacksjs/router'
 import type { RedirectCode, Route, RouteGroupOptions, RouterInterface, StatusCode } from '@stacksjs/types'
 
-import { extractModelRequest } from './utils'
+import { extractDynamicRequest, extractModelRequest } from './utils'
 
 type ActionPath = string // TODO: narrow this by automating its generation
 
@@ -284,11 +283,9 @@ export class Router implements RouterInterface {
 
     let actionModule = null
 
-    if (modulePath.includes('OrmAction')) {
+    if (modulePath.includes('OrmAction'))
       actionModule = await import(importPathFunction(`/framework/orm/${modulePath}.ts`))
-    } else {
-      actionModule = await import(importPathFunction(`${modulePath}.ts`))
-    }
+    else actionModule = await import(importPathFunction(`${modulePath}.ts`))
 
     // Use custom path from action module if available
     const newPath = actionModule.default.path ?? originalPath
@@ -301,10 +298,16 @@ export class Router implements RouterInterface {
     // then validate
     // if succeeds, run the handle
     // if fails, return validation error
+    let requestInstance
+
+    if (modulePath.includes('OrmAction')) requestInstance = await extractModelRequest(modulePath)
+    else requestInstance = await extractDynamicRequest(modulePath)
 
-    const requestInstance = await extractModelRequest(modulePath)
-    
-    return await actionModule.default.handle(requestInstance)
+    try {
+      return await actionModule.default.handle(requestInstance)
+    } catch (error: any) {
+      return { status: error.status, errors: error.errors }
+    }
   }
 
   private normalizePath(path: string): string {

package/src/server.ts

@@ -1,13 +1,13 @@
 import process from 'node:process'
 import { log } from '@stacksjs/logging'
-import { extname, path } from '@stacksjs/path'
+import { getModelName } from '@stacksjs/orm'
+import { path, extname } from '@stacksjs/path'
 import { glob } from '@stacksjs/storage'
+import { camelCase, lowercase } from '@stacksjs/strings'
 import type { Model, Route, RouteParam, StatusCode } from '@stacksjs/types'
 import { route } from '.'
 import { middlewares } from './middleware'
 import { request as RequestParam } from './request'
-import { getModelName } from '@stacksjs/orm'
-import { lowercase } from '@stacksjs/strings'
 
 interface ServeOptions {
   host?: string
@@ -33,12 +33,14 @@ export async function serve(options: ServeOptions = {}) {
     development,
 
     async fetch(req: Request) {
-      return await serverResponse(req)
+      const reqBody = await req.text()
+
+      return await serverResponse(req, reqBody)
     },
   })
 }
 
-export async function serverResponse(req: Request) {
+export async function serverResponse(req: Request, body: string) {
   log.info(`Incoming Request: ${req.method} ${req.url}`)
   log.info(`Headers: ${JSON.stringify(req.headers)}`)
   log.info(`Body: ${JSON.stringify(req.body)}`)
@@ -58,6 +60,10 @@ export async function serverResponse(req: Request) {
 
   log.info(`URL: ${JSON.stringify(url)}`)
 
+  if (req.method === 'OPTIONS') {
+    return handleOptions(req)
+  }
+
   const foundRoute: Route | undefined = routesList
     .filter((route: Route) => {
       const pattern = new RegExp(`^${route.uri.replace(/\{(\w+)\}/g, '(\\w+)')}$`)
@@ -67,21 +73,45 @@ export async function serverResponse(req: Request) {
     .find((route: Route) => route.method === req.method)
 
   log.info(`Found Route: ${JSON.stringify(foundRoute)}`)
-  // if (url.pathname === '/favicon.ico')
-  //   return new Response('')
 
-  if (!foundRoute) return new Response('Pretty 404 page coming soon', { status: 404 }) // TODO: create a pretty 404 page
+  if (!foundRoute) {
+    return new Response('Pretty 404 page coming soon', {
+      status: 404,
+      headers: {
+        'Access-Control-Allow-Origin': '*',
+        'Access-Control-Allow-Headers': '*',
+        'Content-Type': 'json',
+      },
+    }) // TODO: create a pretty 404 page
+  }
 
   const routeParams = extractDynamicSegments(foundRoute.uri, url.pathname)
 
-  await addRouteQuery(url)
-  await addRouteParam(routeParams)
+  if (!body) {
+    await addRouteQuery(url)
+  } else {
+    await addBody(body)
+  }
 
-  await executeMiddleware(foundRoute)
+  await addRouteParam(routeParams)
+  await addHeaders(req.headers)
 
   return await execute(foundRoute, req, { statusCode: foundRoute?.statusCode })
 }
 
+function handleOptions(req: Request) {
+  return new Response(null, {
+    status: 204,
+    headers: {
+      'Access-Control-Allow-Origin': '*',
+      'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS',
+      'Access-Control-Allow-Headers':
+        'Content-Type, Authorization, Access-Control-Allow-Headers, Access-Control-Allow-Origin, Accept',
+      'Access-Control-Max-Age': '86400', // Cache the preflight response for a day
+    },
+  })
+}
+
 function extractDynamicSegments(routePattern: string, path: string): RouteParam {
   const regexPattern = new RegExp(`^${routePattern.replace(/\{(\w+)\}/g, '(\\w+)')}$`)
   const match = path.match(regexPattern)
@@ -103,6 +133,27 @@ function extractDynamicSegments(routePattern: string, path: string): RouteParam
 async function execute(foundRoute: Route, req: Request, { statusCode }: Options) {
   const foundCallback = await route.resolveCallback(foundRoute.callback)
 
+  const middlewarePayload = await executeMiddleware(foundRoute)
+
+  if (
+    middlewarePayload !== null &&
+    typeof middlewarePayload === 'object' &&
+    Object.keys(middlewarePayload).length > 0
+  ) {
+    const middlewareStatus = middlewarePayload.status
+
+    delete middlewarePayload.status
+
+    return await new Response(JSON.stringify(middlewarePayload), {
+      headers: {
+        'Content-Type': 'json',
+        'Access-Control-Allow-Origin': '*',
+        'Access-Control-Allow-Headers': '*',
+      },
+      status: middlewareStatus || 401,
+    })
+  }
+
   if (!statusCode) statusCode = 200
 
   if (foundRoute?.method === 'GET' && (statusCode === 301 || statusCode === 302)) {
@@ -112,7 +163,14 @@ async function execute(foundRoute: Route, req: Request, { statusCode }: Options)
     return await noCache(response)
   }
 
-  if (foundRoute?.method !== req.method) return new Response('Method not allowed', { status: 405 })
+  if (foundRoute?.method !== req.method)
+    return new Response('Method not allowed', {
+      status: 405,
+      headers: {
+        'Access-Control-Allow-Origin': '*',
+        'Access-Control-Allow-Headers': '*',
+      },
+    })
 
   // Check if it's a path to an HTML file
   if (isString(foundCallback) && extname(foundCallback) === '.html') {
@@ -120,25 +178,117 @@ async function execute(foundRoute: Route, req: Request, { statusCode }: Options)
       const fileContent = Bun.file(foundCallback)
 
       return await new Response(fileContent, {
-        headers: { 'Content-Type': 'text/html' },
+        headers: {
+          'Content-Type': 'text/html',
+          'Access-Control-Allow-Origin': '*',
+          'Access-Control-Allow-Headers': '*',
+        },
       })
     } catch (error) {
-      return await new Response('Error reading the HTML file', { status: 500 })
+      return await new Response('Error reading the HTML file', {
+        status: 500,
+        headers: {
+          'Access-Control-Allow-Origin': '*',
+          'Access-Control-Allow-Headers': '*',
+        },
+      })
     }
   }
 
-  if (isString(foundCallback)) return await new Response(foundCallback)
+  if (isString(foundCallback))
+    return await new Response(foundCallback, {
+      headers: {
+        'Content-Type': 'json',
+        'Access-Control-Allow-Origin': '*',
+        'Access-Control-Allow-Headers': '*',
+      },
+      status: 200,
+    })
 
   if (isFunction(foundCallback)) {
     const result = foundCallback()
 
-    return await new Response(JSON.stringify(result))
+    return await new Response(JSON.stringify(result), {
+      status: 200,
+      headers: {
+        'Access-Control-Allow-Origin': '*',
+        'Access-Control-Allow-Headers': '*',
+      },
+    })
   }
 
-  if (isObject(foundCallback)) return await new Response(JSON.stringify(foundCallback))
+  if (isObject(foundCallback) && foundCallback.status) {
+    if (foundCallback.status === 401) {
+      delete foundCallback.status
+
+      return await new Response(JSON.stringify(foundCallback), {
+        headers: {
+          'Content-Type': 'json',
+          'Access-Control-Allow-Origin': '*',
+          'Access-Control-Allow-Headers': '*',
+        },
+        status: 401,
+      })
+    }
+
+    if (foundCallback.status === 403) {
+      delete foundCallback.status
+      return await new Response(JSON.stringify(foundCallback), {
+        headers: {
+          'Content-Type': 'json',
+          'Access-Control-Allow-Origin': '*',
+          'Access-Control-Allow-Headers': '*',
+        },
+        status: 403,
+      })
+    }
+
+    if (foundCallback.status === 422) {
+      // biome-ignore lint/performance/noDelete: <explanation>
+      delete foundCallback.status
+
+      return await new Response(JSON.stringify(foundCallback), {
+        headers: {
+          'Content-Type': 'json',
+          'Access-Control-Allow-Origin': '*',
+          'Access-Control-Allow-Headers': '*',
+        },
+        status: 422,
+      })
+    }
+
+    if (foundCallback.status === 500) {
+      delete foundCallback.status
+      return await new Response(JSON.stringify(foundCallback), {
+        headers: {
+          'Content-Type': 'json',
+          'Access-Control-Allow-Origin': '*',
+          'Access-Control-Allow-Headers': '*',
+        },
+        status: 500,
+      })
+    }
+  }
+
+  if (isObject(foundCallback))
+    return await new Response(JSON.stringify(foundCallback), {
+      headers: {
+        'Content-Type': 'json',
+        'Access-Control-Allow-Origin': '*',
+        'Access-Control-Allow-Headers': '*',
+      },
+      status: 200,
+    })
 
   // If no known type matched, return a generic error.
-  return await new Response('Unknown callback type.', { status: 500 })
+  return await new Response('Unknown callback type.', {
+    headers: {
+      'Content-Type': 'json',
+      'Access-Control-Allow-Origin': '*',
+      'Access-Control-Allow-Headers': '*',
+    },
+    status: 500,
+  })
 }
 
 function noCache(response: Response) {
@@ -150,67 +300,108 @@ function noCache(response: Response) {
 }
 
 async function addRouteQuery(url: URL) {
-  const modelFiles = glob.sync(path.userModelsPath('*.ts'));
+  const modelFiles = glob.sync(path.userModelsPath('*.ts'))
 
   for (const modelFile of modelFiles) {
-    const model = (await import(modelFile)).default;
-    const modelName = getModelName(model, modelFile);
-    const modelNameLower = `${lowercase(modelName)}Request`;
-    const requestPath = path.projectStoragePath(`framework/requests/${modelName}Request.ts`);
-    const requestImport = await import(requestPath);
-    const requestInstance = requestImport[modelNameLower];
-
-    if (requestInstance && !isObjectNotEmpty(url.searchParams)) {
-      requestInstance.addQuery(url);
+    const model = (await import(modelFile)).default
+    const modelName = getModelName(model, modelFile)
+    const modelNameLower = `${camelCase(modelName)}Request`
+    const requestPath = path.projectStoragePath(`framework/requests/${modelName}Request.ts`)
+    const requestImport = await import(requestPath)
+    const requestInstance = requestImport[modelNameLower]
+
+    if (requestInstance) {
+      requestInstance.addQuery(url)
     }
   }
 
-  if (!isObjectNotEmpty(url.searchParams)) {
-    RequestParam.addQuery(url);
+  RequestParam.addQuery(url)
+}
+
+async function addBody(params: any) {
+  const modelFiles = glob.sync(path.userModelsPath('*.ts'))
+
+  for (const modelFile of modelFiles) {
+    const model = (await import(modelFile)).default
+    const modelName = getModelName(model, modelFile)
+    const modelNameLower = `${camelCase(modelName)}Request`
+    const requestPath = path.projectStoragePath(`framework/requests/${modelName}Request.ts`)
+    const requestImport = await import(requestPath)
+    const requestInstance = requestImport[modelNameLower]
+
+    if (requestInstance) {
+      requestInstance.addBodies(JSON.parse(params))
+    }
   }
+
+  RequestParam.addBodies(JSON.parse(params))
 }
 
 async function addRouteParam(param: RouteParam): Promise<void> {
-  const modelFiles = glob.sync(path.userModelsPath('*.ts'));
+  const modelFiles = glob.sync(path.userModelsPath('*.ts'))
 
   for (const modelFile of modelFiles) {
-    const model = (await import(modelFile)).default as Model;
-    const modelName = getModelName(model, modelFile);
-    const modelNameLower = `${lowercase(modelName)}Request`;
-    const requestPath = path.projectStoragePath(`framework/requests/${modelName}Request.ts`);
-    const requestImport = await import(requestPath);
-    const requestInstance = requestImport[modelNameLower];
+    const model = (await import(modelFile)).default as Model
+    const modelName = getModelName(model, modelFile)
+    const modelNameLower = `${lowercase(modelName)}Request`
+    const requestPath = path.projectStoragePath(`framework/requests/${modelName}Request.ts`)
+    const requestImport = await import(requestPath)
+    const requestInstance = requestImport[modelNameLower]
 
     if (requestInstance) {
-      requestInstance.addParam(param);
+      requestInstance.addParam(param)
     }
   }
 
   RequestParam.addParam(param)
 }
 
-function executeMiddleware(route: Route): void {
+async function addHeaders(headers: Headers): Promise<void> {
+  const modelFiles = glob.sync(path.userModelsPath('*.ts'))
+
+  for (const modelFile of modelFiles) {
+    const model = (await import(modelFile)).default as Model
+    const modelName = getModelName(model, modelFile)
+    const modelNameLower = `${lowercase(modelName)}Request`
+    const requestPath = path.projectStoragePath(`framework/requests/${modelName}Request.ts`)
+    const requestImport = await import(requestPath)
+    const requestInstance = requestImport[modelNameLower]
+
+    if (requestInstance) {
+      requestInstance.addHeaders(headers)
+    }
+  }
+
+  RequestParam.addHeaders(headers)
+}
+
+async function executeMiddleware(route: Route): Promise<any> {
   const { middleware = null } = route
 
   if (middleware && middlewares && isObjectNotEmpty(middlewares)) {
     // let middlewareItem: MiddlewareOptions
     if (isString(middleware)) {
-      // TODO: fix and uncomment this
-      // middlewareItem = middlewares.find((m) => {
-      //   return m.name === middleware
-      // })
-      // if (middlewareItem)
-      //   middlewareItem.handle() // Invoke only if it exists and is not undefined.
+      const middlewarePath = path.userMiddlewarePath(`${middleware}.ts`)
+
+      const middlewareInstance = (await import(middlewarePath)).default
+
+      try {
+        await middlewareInstance.handle()
+      } catch (error: any) {
+        return error
+      }
     } else {
-      // middleware.forEach((m) => {
-      middleware.forEach(() => {
-        // TODO: fix and uncomment this
-        // middlewareItem = middlewares.find((middlewareItem: MiddlewareOptions) => {
-        //   return middlewareItem.name === m
-        // })
-        // if (middlewareItem)
-        //   middlewareItem.handle() // Again, invoke only if it exists.
-      })
+      for (const middlewareElement of middleware) {
+        const middlewarePath = path.userMiddlewarePath(`${middlewareElement}.ts`)
+
+        const middlewareInstance = (await import(middlewarePath)).default
+
+        try {
+          await middlewareInstance.handle()
+        } catch (error: any) {
+          return error
+        }
+      }
     }
   }
 }