@stacksjs/router 0.58.70 → 0.58.72

package/dist/index.js

@@ -552,7 +552,7 @@ var toNamespacedPath = function(p) {
   return normalizeWindowsPath(p);
 };
 var _EXTNAME_RE = /.(\.[^./]+)$/;
-var extname = function(p) {
+var extname2 = function(p) {
   const match = _EXTNAME_RE.exec(normalizeWindowsPath(p));
   return match && match[1] || "";
 };
@@ -590,7 +590,7 @@ var basename = function(p, extension) {
 var parse = function(p) {
   const root = normalizeWindowsPath(p).split("/").shift() || "/";
   const base = basename(p);
-  const extension = extname(base);
+  const extension = extname2(base);
   return {
     root,
     dir: dirname(p),
@@ -847,7 +847,10 @@ function replPath(path2) {
 function routerPath(path2) {
   return corePath(`router/${path2 || ""}`);
 }
-function routesPath(path2) {
+function routesPath(path2, options) {
+  const absolutePath = resourcesPath(`routes/${path2 || ""}`);
+  if (options?.relative)
+    return relative(process2.cwd(), absolutePath);
   return projectPath(`routes/${path2 || ""}`);
 }
 function searchEnginePath(path2) {
@@ -1024,7 +1027,7 @@ var path2 = {
   basename,
   delimiter,
   dirname,
-  extname,
+  extname: extname2,
   format,
   isAbsolute,
   join,
@@ -1084,33 +1087,38 @@ class Request {
 }
 var request = new Request;
 // src/server.ts
-import {extname as extname2} from "path";
 import {URL} from "url";
+import process3 from "process";
+import {log} from "@stacksjs/logging";
 async function serve(options = {}) {
   const hostname = options.host || "localhost";
   const port = options.port || 3000;
+  const development = options.debug ? true : process3.env.APP_ENV !== "production" && process3.env.APP_ENV !== "prod";
+  if (options.timezone)
+    process3.env.TZ = options.timezone;
   Bun.serve({
     hostname,
     port,
+    development,
     fetch(req) {
       return serverResponse(req);
     }
   });
 }
 async function serverResponse(req) {
-  const timestamp = new Date().toISOString();
-  console.log(`${timestamp} - Incoming request: ${req.method} ${req.url}`);
-  console.log(`${timestamp} - Headers: ${JSON.stringify(req.headers)}`);
-  console.log(`${timestamp} - Body: ${JSON.stringify(req.body)}`);
-  console.log(`${timestamp} - Query: ${JSON.stringify(req.query)}`);
-  console.log(`${timestamp} - Params: ${JSON.stringify(req.params)}`);
-  console.log(`${timestamp} - Cookies: ${JSON.stringify(req.cookies)}`);
+  log.info(`Incoming Request: ${req.method} ${req.url}`);
+  log.info(`Headers: ${JSON.stringify(req.headers)}`);
+  log.info(`Body: ${JSON.stringify(req.body)}`);
+  const trimmedUrl = req.url.endsWith("/") && req.url.length > 1 ? req.url.slice(0, -1) : req.url;
   const routesList = await route.getRoutes();
-  const url = new URL(req.url);
+  log.info(`Routes List: ${JSON.stringify(routesList)}`);
+  const url = new URL(trimmedUrl);
+  log.info(`URL: ${JSON.stringify(url)}`);
   const foundRoute = routesList.find((route2) => {
     const pattern = new RegExp(`^${route2.uri.replace(/:\w+/g, "\\w+")}\$`);
     return pattern.test(url.pathname);
   });
+  log.info(`Found Route: ${JSON.stringify(foundRoute)}`);
   if (!foundRoute)
     return new Response("Pretty 404 page coming soon", { status: 404 });
   addRouteParamsAndQuery(url, foundRoute);
@@ -1152,7 +1160,7 @@ var execute = function(route2, request3, { statusCode }) {
   }
   if (route2?.method !== request3.method)
     return new Response("Method not allowed", { status: 405 });
-  if (isString(route2.callback) && extname2(route2.callback) === ".html") {
+  if (isString(route2.callback) && extname(route2.callback) === ".html") {
     try {
       const fileContent = Bun.file(route2.callback);
       return new Response(fileContent, { headers: { "Content-Type": "text/html" } });
@@ -1188,6 +1196,9 @@ var isFunction = function(val) {
 var isObject = function(val) {
   return val !== null && typeof val === "object" && !Array.isArray(val);
 };
+// src/router.ts
+import {log as log2} from "@stacksjs/logging";
+
 // /home/runner/work/stacks/stacks/storage/framework/core/strings/src/utils.ts
 var import_slugify = __toESM(require_slugify(), 1);
 // /home/runner/work/stacks/stacks/node_modules/change-case/dist/index.js
@@ -1324,6 +1335,9 @@ var pluralize = __toESM(require_pluralize(), 1);
 // src/router.ts
 class Router {
   routes = [];
+  apiPrefix = "/api";
+  groupPrefix = "";
+  path = "";
   addRoute(method, uri, callback, statusCode) {
     const name = uri.replace(/\//g, ".").replace(/:/g, "");
     const pattern = new RegExp(`^${uri.replace(/:[a-zA-Z]+/g, (_match) => {
@@ -1335,6 +1349,7 @@ class Router {
     } else {
       routeCallback = callback;
     }
+    log2.debug(`Adding route: ${method} ${uri} with name ${name}`);
     this.routes.push({
       name,
       method,
@@ -1345,34 +1360,41 @@ class Router {
       statusCode,
       paramNames: []
     });
+    return this;
   }
   async get(path5, callback) {
-    if (callback instanceof Promise) {
-      const actionModule = await callback;
-      callback = actionModule.default;
-    } else if (typeof callback === "string") {
-      const actionModule = await import(path2.userActionsPath(`${callback}.ts`));
-      path5 = actionModule.default.path ?? path5;
-      callback = actionModule.default.handle;
-    }
-    this.addRoute("GET", path5, callback, 200);
-    return this;
+    this.path = this.normalizePath(path5);
+    log2.debug(`Normalized Path: ${this.path}`);
+    callback = await this.resolveCallback(callback);
+    const uri = this.prepareUri(this.path);
+    log2.debug(`Prepared URI: ${uri}`);
+    return this.addRoute("GET", uri, callback, 200);
   }
   async health() {
     const healthModule = await import(path2.userActionsPath("HealthAction.ts"));
     const callback = healthModule.default.handle;
-    this.addRoute("GET", "/api/health", callback, 200);
+    const path5 = healthModule.default.path ?? `${this.apiPrefix}/health`;
+    this.addRoute("GET", path5, callback, 200);
     return this;
   }
   async job(path5) {
-    if (path5.includes("api/"))
-      path5 = pascalCase(path5.replace(/^api\/?|^\//, ""));
+    path5 = pascalCase(path5);
     const jobModule = await import(path2.userJobsPath(`${path5}Job.ts`.replace(/JobJob/, "Job")));
     const callback = jobModule.default.handle;
+    path5 = this.prepareUri(path5);
+    this.addRoute("GET", path5, callback, 200);
+    return this;
+  }
+  async action(path5) {
+    path5 = pascalCase(path5);
+    const actionModule = await import(path2.userActionsPath(`${path5}Action.ts`.replace(/ActionAction/, "Action")));
+    const callback = actionModule.default.handle;
+    path5 = this.prepareUri(path5);
     this.addRoute("GET", path5, callback, 200);
     return this;
   }
   post(path5, callback) {
+    path5 = this.prepareUri(path5);
     this.addRoute("POST", path5, callback, 201);
     return this;
   }
@@ -1397,16 +1419,18 @@ class Router {
     return this;
   }
   group(options, callback) {
+    if (typeof options === "string")
+      options = options.startsWith("/") ? options.slice(1) : options;
     let cb;
+    this.prepareGroupPrefix(options);
     if (typeof options === "function") {
       cb = options;
       options = {};
-    } else {
-      if (!callback)
-        throw new Error("Missing callback function for route group.");
-      cb = callback;
     }
-    const { prefix = "", middleware: middleware2 = [] } = options;
+    if (!callback)
+      throw new Error("Missing callback function for your route group.");
+    cb = callback;
+    const { prefix, middleware: middleware2 = [] } = options;
     const originalRoutes = this.routes;
     this.routes = [];
     cb();
@@ -1433,9 +1457,59 @@ class Router {
     return this;
   }
   async getRoutes() {
-    await import(projectPath("routes/api.ts"));
+    await import(routesPath("api.ts"));
     return this.routes;
   }
+  setGroupPrefix(prefix, options = {}) {
+    if (prefix !== "") {
+      prefix = `/${this.groupPrefix}/${prefix}`.replace(/\/\//g, "/");
+      this.groupPrefix = prefix;
+      return;
+    }
+    const effectiveOptions = typeof options === "object" ? options : {};
+    this.groupPrefix = effectiveOptions.prefix ?? prefix ?? "";
+  }
+  prepareGroupPrefix(options) {
+    if (this.groupPrefix !== "" && typeof options !== "string")
+      return this.setGroupPrefix(this.groupPrefix, options);
+    if (typeof options === "string")
+      return this.setGroupPrefix(options);
+    return this.setGroupPrefix("", options);
+  }
+  async resolveCallback(callback) {
+    if (callback instanceof Promise) {
+      const actionModule = await callback;
+      return actionModule.default;
+    }
+    if (typeof callback === "string")
+      return this.importCallbackFromPath(callback, this.path);
+    return callback;
+  }
+  async importCallbackFromPath(callbackPath, originalPath) {
+    let modulePath = callbackPath;
+    let importPathFunction = path2.appPath;
+    if (callbackPath.startsWith("../"))
+      importPathFunction = path2.routesPath;
+    modulePath = modulePath.endsWith(".ts") ? modulePath.slice(0, -3) : modulePath;
+    const actionModule = await import(importPathFunction(`${modulePath}.ts`));
+    const newPath = actionModule.default.path ?? originalPath;
+    this.updatePathIfNeeded(newPath, originalPath);
+    return actionModule.default.handle;
+  }
+  normalizePath(path5) {
+    return path5.endsWith("/") ? path5.slice(0, -1) : path5;
+  }
+  prepareUri(path5) {
+    if (path5.startsWith("/"))
+      path5 = path5.slice(1);
+    path5 = `${this.apiPrefix}${this.groupPrefix}/${path5}`;
+    return path5.endsWith("/") ? path5.slice(0, -1) : path5;
+  }
+  updatePathIfNeeded(newPath, originalPath) {
+    if (newPath !== originalPath) {
+      this.path = newPath;
+    }
+  }
 }
 var route = new Router;
 export {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/router",
   "type": "module",
-  "version": "0.58.70",
+  "version": "0.58.72",
   "description": "The Stacks framework router.",
   "author": "Chris Breuer",
   "license": "MIT",
@@ -54,6 +54,7 @@
   },
   "dependencies": {
     "@stacksjs/config": "latest",
+    "@stacksjs/logging": "latest",
     "unplugin-vue-router": "^0.7.0",
     "vue-router": "^4.2.5"
   },

package/src/router.ts

@@ -1,7 +1,10 @@
 import type { RedirectCode, Route, RouteGroupOptions, StatusCode } from '@stacksjs/types'
-import { path as p, projectPath } from '@stacksjs/path'
+import { path as p, routesPath } from '@stacksjs/path'
+import { log } from '@stacksjs/logging'
 import { pascalCase } from '@stacksjs/strings'
 
+type Prefix = string
+
 export interface RouterInterface {
   get: (url: Route['url'], callback: Route['callback']) => Promise<this>
   post: (url: Route['url'], callback: Route['callback']) => this
@@ -10,7 +13,7 @@ export interface RouterInterface {
   delete: (url: Route['url'], callback: Route['callback']) => this
   patch: (url: Route['url'], callback: Route['callback']) => this
   put: (url: Route['url'], callback: Route['callback']) => this
-  group: (options: RouteGroupOptions, callback: () => void) => this
+  group: (options: Prefix | RouteGroupOptions, callback: () => void) => this
   name: (name: string) => this
   middleware: (middleware: Route['middleware']) => this
   getRoutes: () => Promise<Route[]>
@@ -18,8 +21,11 @@ export interface RouterInterface {
 
 export class Router implements RouterInterface {
   private routes: Route[] = []
+  private apiPrefix = '/api'
+  private groupPrefix = ''
+  private path = ''
 
-  private addRoute(method: Route['method'], uri: string, callback: Route['callback'] | string | object, statusCode: StatusCode): void {
+  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-]+)'
@@ -35,6 +41,8 @@ export class Router implements RouterInterface {
       routeCallback = callback
     }
 
+    log.debug(`Adding route: ${method} ${uri} with name ${name}`)
+
     this.routes.push({
       name,
       method,
@@ -45,59 +53,75 @@ export class Router implements RouterInterface {
       statusCode,
       paramNames: [],
     })
+
+    return this
   }
 
   public async get(path: Route['url'], callback: Route['callback']): Promise<this> {
-    // check if callback is a string and if it is, then import that module path and use the default.handle function as the callback
-    if (callback instanceof Promise) {
-      const actionModule = await callback
-      callback = actionModule.default
-    }
+    this.path = this.normalizePath(path)
+    log.debug(`Normalized Path: ${this.path}`)
 
-    else if (typeof callback === 'string') {
-      // import the module and use the default.handle function as the callback
-      const actionModule = await import(p.userActionsPath(`${callback}.ts`))
+    callback = await this.resolveCallback(callback)
 
-      path = actionModule.default.path ?? path // in case a custom path is defined inside the Action, use that instead of the path passed by the router
-      callback = actionModule.default.handle
-    }
+    const uri = this.prepareUri(this.path)
+    log.debug(`Prepared URI: ${uri}`)
 
-    this.addRoute('GET', path, callback, 200)
-    return this
+    return this.addRoute('GET', uri, callback, 200)
   }
 
   public async health(): Promise<this> {
     const healthModule = await import(p.userActionsPath('HealthAction.ts'))
     const callback = healthModule.default.handle
 
-    this.addRoute('GET', '/api/health', callback, 200)
+    const path = healthModule.default.path ?? `${this.apiPrefix}/health`
+
+    this.addRoute('GET', path, callback, 200)
+
     return this
   }
 
   public async job(path: Route['url']): Promise<this> {
-    if (path.includes('api/')) // TODO: once the api prefix is removed from the router/api, remove this
-      path = pascalCase(path.replace(/^api\/?|^\//, ''))
+    path = pascalCase(path)
 
     // removes the potential `JobJob` suffix in case the user does not choose to use the Job suffix in their file name
     const jobModule = await import(p.userJobsPath(`${path}Job.ts`.replace(/JobJob/, 'Job')))
     const callback = jobModule.default.handle
 
+    path = this.prepareUri(path)
+    this.addRoute('GET', path, callback, 200)
+
+    return this
+  }
+
+  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
+
+    path = this.prepareUri(path)
     this.addRoute('GET', path, callback, 200)
+
     return this
   }
 
   public post(path: Route['url'], callback: Route['callback']): this {
+    path = this.prepareUri(path)
     this.addRoute('POST', path, callback, 201)
+
     return this
   }
 
   public view(path: Route['url'], callback: Route['callback']): this {
     this.addRoute('GET', path, callback, 200)
+
     return this
   }
 
   public redirect(path: Route['url'], callback: Route['callback'], _status?: RedirectCode): this {
     this.addRoute('GET', path, callback, 302)
+
     return this
   }
 
@@ -116,37 +140,41 @@ export class Router implements RouterInterface {
     return this
   }
 
-  public group(options: RouteGroupOptions | (() => void), callback?: () => void): this {
+  public group(options: string | RouteGroupOptions, callback?: () => void): this {
+    if (typeof options === 'string')
+      options = options.startsWith('/') ? options.slice(1) : options
+
     let cb: () => void
 
+    this.prepareGroupPrefix(options)
+
     if (typeof options === 'function') {
       cb = options
       options = {}
     }
-    else {
-      if (!callback)
-        throw new Error('Missing callback function for route group.')
-      cb = callback
-    }
 
-    const { prefix = '', middleware = [] } = options
+    if (!callback)
+      throw new Error('Missing callback function for your route group.')
+
+    cb = callback
+
+    const { prefix, middleware = [] } = options as RouteGroupOptions
 
-    // Save a reference to the original routes array.
+    // Save a reference to the original routes array
     const originalRoutes = this.routes
 
-    // Create a new routes array for the duration of the callback.
+    // Create a new routes array for the duration of the callback
     this.routes = []
 
-    // Execute the callback. This will add routes to the new this.routes array.
+    // Execute the callback. This will add routes to the new this.routes array
     cb()
 
-    // For each route added by the callback, adjust the URI and add to the original routes array.
+    // For each route added by the callback, adjust the URI and add to the original routes array
     this.routes.forEach((r) => {
       r.uri = `${prefix}${r.uri}`
 
       if (middleware.length)
         r.middleware = middleware
-      // Assuming you have a middleware property for each route.
 
       originalRoutes.push(r)
       return this
@@ -180,17 +208,86 @@ export class Router implements RouterInterface {
   }
 
   public async getRoutes(): Promise<Route[]> {
-    // const routeFileData = (await readTextFile(projectPath('routes/web.ts'))).data
+    await import(routesPath('api.ts'))
 
-    await import(projectPath('routes/api.ts'))
+    return this.routes
+  }
 
-    // run routes/web.ts
-    // const webRoutesPath = projectPath('routes/web.ts')
-    // await runCommand(`bun ${webRoutesPath}`)
+  private setGroupPrefix(prefix: string, options: RouteGroupOptions = {}) {
+    if (prefix !== '') {
+      prefix = `/${this.groupPrefix}/${prefix}`.replace(/\/\//g, '/') // remove double slashes in case there are any
+      this.groupPrefix = prefix
+      return
+    }
 
-    // set this.routes to a mapped array of routes that matches the pattern
+    // Ensure options is always treated as an object, even if it's undefined or a function
+    const effectiveOptions = typeof options === 'object' ? options : {}
 
-    return this.routes
+    this.groupPrefix = effectiveOptions.prefix ?? prefix ?? ''
+  }
+
+  private prepareGroupPrefix(options: string | RouteGroupOptions): void {
+    if (this.groupPrefix !== '' && typeof options !== 'string')
+      return this.setGroupPrefix(this.groupPrefix, options)
+
+    if (typeof options === 'string')
+      return this.setGroupPrefix(options)
+
+    return this.setGroupPrefix('', options)
+  }
+
+  private async resolveCallback(callback: Route['callback']): Promise<Route['callback']> {
+    if (callback instanceof Promise) {
+      const actionModule = await callback
+      return actionModule.default
+    }
+
+    if (typeof callback === 'string')
+      return this.importCallbackFromPath(callback, this.path)
+
+    // in this case, the callback ends up being a function
+    return 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
+
+    // Remove trailing .ts if present
+    modulePath = modulePath.endsWith('.ts') ? modulePath.slice(0, -3) : modulePath
+    const 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
+  }
+
+  private normalizePath(path: string): string {
+    return path.endsWith('/') ? path.slice(0, -1) : path
+  }
+
+  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)
+
+    path = `${this.apiPrefix}${this.groupPrefix}/${path}`
+
+    // if path ends in "/", then remove it
+    // e.g. triggered when route is "/"
+    return path.endsWith('/') ? path.slice(0, -1) : path
+  }
+
+  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
+      this.path = newPath
+    }
   }
 }
 

package/src/server.ts

@@ -1,5 +1,6 @@
-import { extname } from 'node:path'
 import { URL } from 'node:url'
+import process from 'node:process'
+import { log } from '@stacksjs/logging'
 import type { MiddlewareType, Route, StatusCode } from '@stacksjs/types'
 import { middlewares } from './middleware'
 import { request } from './request'
@@ -8,17 +9,22 @@ import { route } from '.'
 interface ServeOptions {
   host?: string
   port?: number
-  tunnel?: boolean
+  debug?: boolean
+  timezone?: string
 }
 
 export async function serve(options: ServeOptions = {}) {
-  // maybe make use of localUrl({ type: 'backend' }) here & options.tunnel
   const hostname = options.host || 'localhost'
   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
 
   Bun.serve({
     hostname,
     port,
+    development,
 
     fetch(req: Request) {
       return serverResponse(req)
@@ -27,24 +33,23 @@ export async function serve(options: ServeOptions = {}) {
 }
 
 export async function serverResponse(req: Request) {
-  const timestamp = new Date().toISOString()
-
-  // log the request in a structured way like Laravel does in the console
-  // eslint-disable-next-line no-console
-  console.log(`${timestamp} - Incoming request: ${req.method} ${req.url}`)
-  // eslint-disable-next-line no-console
-  console.log(`${timestamp} - Headers: ${JSON.stringify(req.headers)}`)
-  // eslint-disable-next-line no-console
-  console.log(`${timestamp} - Body: ${JSON.stringify(req.body)}`)
-  // eslint-disable-next-line no-console
-  console.log(`${timestamp} - Query: ${JSON.stringify(req.query)}`)
-  // eslint-disable-next-line no-console
-  console.log(`${timestamp} - Params: ${JSON.stringify(req.params)}`)
-  // eslint-disable-next-line no-console
-  console.log(`${timestamp} - Cookies: ${JSON.stringify(req.cookies)}`)
+  log.info(`Incoming Request: ${req.method} ${req.url}`)
+  log.info(`Headers: ${JSON.stringify(req.headers)}`)
+  log.info(`Body: ${JSON.stringify(req.body)}`)
+  // log.info(`Query: ${JSON.stringify(req.query)}`)
+  // log.info(`Params: ${JSON.stringify(req.params)}`)
+  // log.info(`Cookies: ${JSON.stringify(req.cookies)}`)
+
+  // Trim trailing slash from the URL if it's not the root '/'
+  // This automatically allows for route definitions, like
+  // '/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 routesList: Route[] = await route.getRoutes()
-  const url = new URL(req.url)
+  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) => {
     const pattern = new RegExp(`^${route.uri.replace(/:\w+/g, '\\w+')}$`)
@@ -52,6 +57,8 @@ export async function serverResponse(req: Request) {
     return pattern.test(url.pathname)
   })
 
+  log.info(`Found Route: ${JSON.stringify(foundRoute)}`)
+
   // if (url.pathname === '/favicon.ico')
   //   return new Response('')