@stacksjs/router 0.59.11 → 0.61.0

package/package.json

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

package/src/middleware.ts

@@ -1,4 +1,4 @@
-import { appPath } from '@stacksjs/path'
+import { userMiddlewarePath } from '@stacksjs/path'
 import type { MiddlewareOptions } from '@stacksjs/types'
 
 export class Middleware implements MiddlewareOptions {
@@ -30,4 +30,4 @@ async function importMiddlewares(directory: string) {
   return [directory] // fix this: return array of middlewares
 }
 
-export const middlewares = await importMiddlewares(appPath('middleware'))
+export const middlewares = await importMiddlewares(userMiddlewarePath())

package/src/request.ts

@@ -5,9 +5,18 @@ interface RequestData {
 type RouteParams = { [key: string]: string } | null
 
 export class Request {
+  private static instance: Request
   private query: RequestData = {}
   private params: RouteParams = null
 
+  // An attempt to singleston instance, might be needed at some point
+  public static getInstance(): Request {
+    if (!Request.instance) {
+      Request.instance = new Request()
+    }
+    return Request.instance
+  }
+
   public addQuery(url: URL): void {
     this.query = Object.fromEntries(url.searchParams)
   }
@@ -32,12 +41,16 @@ export class Request {
     const pattern = new RegExp(`^${routePattern.replace(/:(\w+)/g, (match, paramName) => `(?<${paramName}>\\w+)`)}$`)
     const match = pattern.exec(pathname)
 
-    if (match?.groups)
-      this.params = match?.groups
+    if (match?.groups) this.params = match.groups
   }
 
   public getParams(key: string): number | string | null {
-    return this.params ? (this.params[key] || null) : null
+    return this.params ? this.params[key] || null : null
+  }
+
+  public getParamAsInt(key: string): number | null {
+    const value = this.params ? this.params[key] || null : null
+    return value ? Number.parseInt(value) : null
   }
 }
 

package/src/router.ts

@@ -1,7 +1,7 @@
-import type { RedirectCode, Route, RouteGroupOptions, RouterInterface, StatusCode } from '@stacksjs/types'
-import { path as p, routesPath } from '@stacksjs/path'
 import { log } from '@stacksjs/logging'
+import { path as p, projectStoragePath, routesPath } from '@stacksjs/path'
 import { pascalCase } from '@stacksjs/strings'
+import type { RedirectCode, Route, RouteGroupOptions, RouterInterface, StatusCode } from '@stacksjs/types'
 
 export class Router implements RouterInterface {
   private routes: Route[] = []
@@ -9,19 +9,25 @@ export class Router implements RouterInterface {
   private groupPrefix = ''
   private path = ''
 
-  private addRoute(method: Route['method'], uri: string, callback: Route['callback'] | string | object, statusCode: StatusCode): this {
+  private addRoute(
+    method: Route['method'],
+    uri: string,
+    callback: Route['callback'] | string | object,
+    statusCode: StatusCode,
+  ): this {
     const name = uri.replace(/\//g, '.').replace(/:/g, '') // we can improve this
-    const pattern = new RegExp(`^${uri.replace(/:[a-zA-Z]+/g, (_match) => {
-      return '([a-zA-Z0-9-]+)'
-    })}$`)
+    const pattern = new RegExp(
+      `^${uri.replace(/:[a-zA-Z]+/g, (_match) => {
+        return '([a-zA-Z0-9-]+)'
+      })}$`,
+    )
 
     let routeCallback: Route['callback']
 
     if (typeof callback === 'string' || typeof callback === 'object') {
       // Convert string or object to RouteCallback
       routeCallback = () => callback
-    }
-    else {
+    } else {
       routeCallback = callback
     }
 
@@ -92,9 +98,20 @@ export class Router implements RouterInterface {
   public async action(path: Route['url']): Promise<this> {
     path = pascalCase(path) // actions are PascalCase
 
-    // removes the potential `ActionAction` suffix in case the user does not choose to use the Job suffix in their file name
-    const actionModule = await import(p.userActionsPath(`${path}Action.ts`.replace(/ActionAction/, 'Action')))
-    const callback = actionModule.default.handle
+    let callback: Route['callback']
+    try {
+      // removes the potential `ActionAction` suffix in case the user does not choose to use the Job suffix in their file name
+      const actionModule = await import(p.userActionsPath(`${path}Action.ts`.replace(/ActionAction/, 'Action')))
+      callback = actionModule.default.handle
+    } catch (error) {
+      try {
+        const actionModule = await import(p.userActionsPath(`${path}.ts`.replace(/ActionAction/, 'Action')))
+        callback = actionModule.default.handle
+      } catch (error) {
+        log.error(`Could not find action module for path: ${path}`)
+        return this
+      }
+    }
 
     path = this.prepareUri(path)
     this.addRoute('GET', path, callback, 200)
@@ -137,8 +154,7 @@ export class Router implements RouterInterface {
   }
 
   public group(options: string | RouteGroupOptions, callback?: () => void): this {
-    if (typeof options === 'string')
-      options = options.startsWith('/') ? options.slice(1) : options
+    if (typeof options === 'string') options = options.startsWith('/') ? options.slice(1) : options
 
     let cb: () => void
 
@@ -149,8 +165,7 @@ export class Router implements RouterInterface {
       options = {}
     }
 
-    if (!callback)
-      throw new Error('Missing callback function for your route group.')
+    if (!callback) throw new Error('Missing callback function for your route group.')
 
     cb = callback
 
@@ -169,8 +184,7 @@ export class Router implements RouterInterface {
     this.routes.forEach((r) => {
       r.uri = `${prefix}${r.uri}`
 
-      if (middleware.length)
-        r.middleware = middleware
+      if (middleware.length) r.middleware = middleware
 
       originalRoutes.push(r)
       return this
@@ -205,6 +219,7 @@ export class Router implements RouterInterface {
 
   public async getRoutes(): Promise<Route[]> {
     await import(routesPath('api.ts'))
+    await import(projectStoragePath('framework/orm/routes.ts'))
 
     return this.routes
   }
@@ -223,13 +238,18 @@ export class Router implements RouterInterface {
   }
 
   private prepareGroupPrefix(options: string | RouteGroupOptions): void {
-    if (this.groupPrefix !== '' && typeof options !== 'string')
-      return this.setGroupPrefix(this.groupPrefix, options)
+    if (this.groupPrefix !== '' && typeof options !== 'string') {
+      this.setGroupPrefix(this.groupPrefix, options)
+      return
+    }
 
-    if (typeof options === 'string')
-      return this.setGroupPrefix(options)
+    if (typeof options === 'string') {
+      this.setGroupPrefix(options)
+      return
+    }
 
-    return this.setGroupPrefix('', options)
+    this.setGroupPrefix('', options)
+    return
   }
 
   private async resolveCallback(callback: Route['callback']): Promise<Route['callback']> {
@@ -238,29 +258,36 @@ export class Router implements RouterInterface {
       return actionModule.default
     }
 
-    if (typeof callback === 'string')
-      return this.importCallbackFromPath(callback, this.path)
+    if (typeof callback === 'string') return await this.importCallbackFromPath(callback, this.path)
 
     // in this case, the callback ends up being a function
-    return callback
+    return await callback
   }
 
   private async importCallbackFromPath(callbackPath: string, originalPath: string): Promise<Route['callback']> {
     let modulePath = callbackPath
     let importPathFunction = p.appPath // Default import path function
 
-    if (callbackPath.startsWith('../'))
-      importPathFunction = p.routesPath
+    if (callbackPath.startsWith('../')) importPathFunction = p.routesPath
+
+    if (modulePath.includes('OrmAction')) importPathFunction = p.projectStoragePath
 
     // Remove trailing .ts if present
     modulePath = modulePath.endsWith('.ts') ? modulePath.slice(0, -3) : modulePath
-    const actionModule = await import(importPathFunction(`${modulePath}.ts`))
+
+    let actionModule = null
+
+    if (modulePath.includes('OrmAction')) {
+      actionModule = await import(importPathFunction(`/framework/orm/${modulePath}.ts`))
+    } else {
+      actionModule = await import(importPathFunction(`${modulePath}.ts`))
+    }
 
     // Use custom path from action module if available
     const newPath = actionModule.default.path ?? originalPath
     this.updatePathIfNeeded(newPath, originalPath)
 
-    return actionModule.default.handle
+    return await actionModule.default.handle()
   }
 
   private normalizePath(path: string): string {
@@ -269,11 +296,12 @@ export class Router implements RouterInterface {
 
   public prepareUri(path: string) {
     // if string starts with / then remove it because we are adding it back in the next line
-    if (path.startsWith('/'))
-      path = path.slice(1)
+    if (path.startsWith('/')) path = path.slice(1)
 
     path = `${this.apiPrefix}${this.groupPrefix}/${path}`
 
+    console.log(path)
+
     // if path ends in "/", then remove it
     // e.g. triggered when route is "/"
     return path.endsWith('/') ? path.slice(0, -1) : path
@@ -281,7 +309,7 @@ export class Router implements RouterInterface {
 
   private updatePathIfNeeded(newPath: string, originalPath: string): void {
     if (newPath !== originalPath) {
-    // Logic to update the path if needed, based on the action module's custom path
+      // Logic to update the path if needed, based on the action module's custom path
       this.path = newPath
     }
   }

package/src/server.ts

@@ -1,10 +1,10 @@
-import { URL } from 'node:url'
 import process from 'node:process'
 import { log } from '@stacksjs/logging'
-import type { MiddlewareOptions, Route, StatusCode } from '@stacksjs/types'
-import { middlewares } from './middleware'
-import { request } from './request'
+import { extname } from '@stacksjs/path'
+import type { Route, StatusCode } from '@stacksjs/types'
 import { route } from '.'
+import { middlewares } from './middleware'
+import { request as RequestParam } from './request'
 
 interface ServeOptions {
   host?: string
@@ -18,16 +18,15 @@ export async function serve(options: ServeOptions = {}) {
   const port = options.port || 3000
   const development = options.debug ? true : process.env.APP_ENV !== 'production' && process.env.APP_ENV !== 'prod'
 
-  if (options.timezone)
-    process.env.TZ = options.timezone
+  if (options.timezone) process.env.TZ = options.timezone
 
   Bun.serve({
     hostname,
     port,
     development,
 
-    fetch(req: Request) {
-      return serverResponse(req)
+    async fetch(req: Request) {
+      return await serverResponse(req)
     },
   })
 }
@@ -45,10 +44,12 @@ export async function serverResponse(req: Request) {
   // '/about' and '/about/' to be treated as the same
   const trimmedUrl = req.url.endsWith('/') && req.url.length > 1 ? req.url.slice(0, -1) : req.url
 
+  const url = new URL(trimmedUrl)
+  addRouteParamsAndQuery(url)
+
   const routesList: Route[] = await route.getRoutes()
   log.info(`Routes List: ${JSON.stringify(routesList)}`)
 
-  const url = new URL(trimmedUrl)
   log.info(`URL: ${JSON.stringify(url)}`)
 
   const foundRoute: Route | undefined = routesList.find((route: Route) => {
@@ -62,42 +63,40 @@ export async function serverResponse(req: Request) {
   // 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 }) // TODO: create a pretty 404 page
 
-  addRouteParamsAndQuery(url, foundRoute)
-  executeMiddleware(foundRoute)
+  await executeMiddleware(foundRoute)
 
-  return execute(foundRoute, req, { statusCode: foundRoute?.statusCode })
+  return await execute(foundRoute, req, { statusCode: foundRoute?.statusCode })
 }
 
-function addRouteParamsAndQuery(url: URL, route: Route): void {
-  if (!isObjectNotEmpty(url.searchParams))
-    request.addQuery(url)
+function addRouteParamsAndQuery(url: URL): void {
+  if (!isObjectNotEmpty(url.searchParams)) RequestParam.addQuery(url)
 
-  request.extractParamsFromRoute(route.uri, url.pathname)
+  // requestInstance.extractParamsFromRoute(route.uri, url.pathname)
 }
 
 function executeMiddleware(route: Route): void {
   const { middleware = null } = route
 
   if (middleware && middlewares && isObjectNotEmpty(middlewares)) {
+    // let middlewareItem: MiddlewareOptions
     if (isString(middleware)) {
-      const middlewareItem: MiddlewareOptions = middlewares.find((middlewareItem: MiddlewareOptions) => {
-        return middlewareItem.name === middleware
-      })
-
-      if (middlewareItem)
-        middlewareItem.handle() // Invoke only if it exists and is not undefined.
-    }
-    else {
-      middleware.forEach((m) => {
-        const middlewareItem: MiddlewareOptions = middlewares.find((middlewareItem: MiddlewareOptions) => {
-          return middlewareItem.name === m
-        })
-
-        if (middlewareItem)
-          middlewareItem.handle() // Again, invoke only if it exists.
+      // 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.
+    } 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.
       })
     }
   }
@@ -107,45 +106,42 @@ interface Options {
   statusCode?: StatusCode
 }
 
-function execute(route: Route, request: Request, { statusCode }: Options) {
-  if (!statusCode)
-    statusCode = 200
+async function execute(route: Route, req: Request, { statusCode }: Options) {
+  if (!statusCode) statusCode = 200
 
   if (route?.method === 'GET' && (statusCode === 301 || statusCode === 302)) {
     const callback = String(route.callback)
     const response = Response.redirect(callback, statusCode)
 
-    return noCache(response)
+    return await noCache(response)
   }
 
-  if (route?.method !== request.method)
-    return new Response('Method not allowed', { status: 405 })
+  if (route?.method !== req.method) return new Response('Method not allowed', { status: 405 })
 
-  // Check if it's a path to an HTM L file
+  // Check if it's a path to an HTML file
   if (isString(route.callback) && extname(route.callback) === '.html') {
     try {
       const fileContent = Bun.file(route.callback)
 
-      return new Response(fileContent, { headers: { 'Content-Type': 'text/html' } })
-    }
-    catch (error) {
-      return new Response('Error reading the HTML file', { status: 500 })
+      return await new Response(fileContent, {
+        headers: { 'Content-Type': 'text/html' },
+      })
+    } catch (error) {
+      return await new Response('Error reading the HTML file', { status: 500 })
     }
   }
 
-  if (isString(route.callback))
-    return new Response(route.callback)
+  if (isString(route.callback)) return await new Response(route.callback)
 
   if (isFunction(route.callback)) {
-    const result = (route.callback)()
-    return new Response(JSON.stringify(result))
+    const result = route.callback()
+    return await new Response(JSON.stringify(result))
   }
 
-  if (isObject(route.callback))
-    return new Response(JSON.stringify(route.callback))
+  if (isObject(route.callback)) return await new Response(JSON.stringify(route.callback))
 
   // If no known type matched, return a generic error.
-  return new Response('Unknown callback type.', { status: 500 })
+  return await new Response('Unknown callback type.', { status: 500 })
 }
 
 function noCache(response: Response) {

package/dist/index.d.ts

@@ -1,4 +0,0 @@
-export * from './middleware';
-export * from './request';
-export * from './server';
-export * from './router';

package/dist/middleware.d.ts

@@ -1,8 +0,0 @@
-import type { MiddlewareOptions } from '@stacksjs/types';
-export declare class Middleware implements MiddlewareOptions {
-    name: string;
-    priority: number;
-    handle: Function;
-    constructor(data: MiddlewareOptions);
-}
-export declare const middlewares: string[];

package/dist/request.d.ts

@@ -1,16 +0,0 @@
-interface RequestData {
-    [key: string]: string;
-}
-export declare class Request {
-    private query;
-    private params;
-    addQuery(url: URL): void;
-    get(element: string): string | number | undefined;
-    all(): RequestData;
-    has(element: string): boolean;
-    isEmpty(): boolean;
-    extractParamsFromRoute(routePattern: string, pathname: string): void;
-    getParams(key: string): number | string | null;
-}
-export declare const request: Request;
-export {};

package/dist/router.d.ts

@@ -1,32 +0,0 @@
-import type { RedirectCode, Route, RouteGroupOptions, RouterInterface } from '@stacksjs/types';
-export declare class Router implements RouterInterface {
-    private routes;
-    private apiPrefix;
-    private groupPrefix;
-    private path;
-    private addRoute;
-    get(path: Route['url'], callback: Route['callback']): Promise<this>;
-    email(path: Route['url']): Promise<this>;
-    health(): Promise<this>;
-    job(path: Route['url']): Promise<this>;
-    action(path: Route['url']): Promise<this>;
-    post(path: Route['url'], callback: Route['callback']): this;
-    view(path: Route['url'], callback: Route['callback']): this;
-    redirect(path: Route['url'], callback: Route['callback'], _status?: RedirectCode): this;
-    delete(path: Route['url'], callback: Route['callback']): this;
-    patch(path: Route['url'], callback: Route['callback']): this;
-    put(path: Route['url'], callback: Route['callback']): this;
-    group(options: string | RouteGroupOptions, callback?: () => void): this;
-    name(name: string): this;
-    middleware(middleware: Route['middleware']): this;
-    prefix(prefix: string): this;
-    getRoutes(): Promise<Route[]>;
-    private setGroupPrefix;
-    private prepareGroupPrefix;
-    private resolveCallback;
-    private importCallbackFromPath;
-    private normalizePath;
-    prepareUri(path: string): string;
-    private updatePathIfNeeded;
-}
-export declare const route: Router;

package/dist/server.d.ts

@@ -1,9 +0,0 @@
-interface ServeOptions {
-    host?: string;
-    port?: number;
-    debug?: boolean;
-    timezone?: string;
-}
-export declare function serve(options?: ServeOptions): Promise<void>;
-export declare function serverResponse(req: Request): Promise<Response>;
-export {};