@stacksjs/router 0.61.17 → 0.61.19

package/dist/index.js

@@ -30,6 +30,9 @@ class Request {
   addQuery(url) {
     this.query = Object.fromEntries(url.searchParams);
   }
+  addParam(param) {
+    this.params = param;
+  }
   get(element) {
     return this.query[element];
   }
@@ -48,15 +51,18 @@ class Request {
     if (match?.groups)
       this.params = match.groups;
   }
-  getParams(key) {
+  getParam(key) {
     return this.params ? this.params[key] || null : null;
   }
+  getParams() {
+    return this.params;
+  }
   getParamAsInt(key) {
     const value = this.params ? this.params[key] || null : null;
     return value ? Number.parseInt(value) : null;
   }
 }
-var request = new Request;
+var request2 = new Request;
 // src/server.ts
 import process from "process";
 import {log} from "@stacksjs/logging";
@@ -82,47 +88,50 @@ async function serverResponse(req) {
   log.info(`Body: ${JSON.stringify(req.body)}`);
   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 = await route.getRoutes();
   log.info(`Routes List: ${JSON.stringify(routesList)}`);
   log.info(`URL: ${JSON.stringify(url)}`);
-  const foundRoute = routesList.find((route2) => {
-    const pattern = new RegExp(`^${route2.uri.replace(/:\w+/g, "\\w+")}\$`);
+  const foundRoute = routesList.filter((route2) => {
+    const pattern = new RegExp(`^${route2.uri.replace(/\{(\w+)\}/g, "(\\w+)")}\$`);
     return pattern.test(url.pathname);
-  });
+  }).find((route2) => route2.method === req.method);
   log.info(`Found Route: ${JSON.stringify(foundRoute)}`);
   if (!foundRoute)
     return new Response("Pretty 404 page coming soon", { status: 404 });
+  const routeParams = extractDynamicSegments(foundRoute.uri, url.pathname);
+  addRouteQuery(url);
+  addRouteParam(routeParams);
   await executeMiddleware(foundRoute);
   return await execute(foundRoute, req, { statusCode: foundRoute?.statusCode });
 }
-var addRouteParamsAndQuery = function(url) {
-  if (!isObjectNotEmpty(url.searchParams))
-    request.addQuery(url);
-};
-var executeMiddleware = function(route2) {
-  const { middleware: middleware2 = null } = route2;
-  if (middleware2 && middlewares && isObjectNotEmpty(middlewares)) {
-    if (isString(middleware2)) {
-    } else {
-      middleware2.forEach(() => {
-      });
-    }
-  }
+var extractDynamicSegments = function(routePattern, path3) {
+  const regexPattern = new RegExp(`^${routePattern.replace(/\{(\w+)\}/g, "(\\w+)")}\$`);
+  const match = path3.match(regexPattern);
+  if (!match) {
+    return null;
+  }
+  const dynamicSegmentNames = [...routePattern.matchAll(/\{(\w+)\}/g)].map((m) => m[1]);
+  const dynamicSegmentValues = match.slice(1);
+  const dynamicSegments = {};
+  dynamicSegmentNames.forEach((name, index) => {
+    dynamicSegments[name] = dynamicSegmentValues[index];
+  });
+  return dynamicSegments;
 };
-async function execute(route2, req, { statusCode }) {
+async function execute(foundRoute, req, { statusCode }) {
+  const foundCallback = await route.resolveCallback(foundRoute.callback);
   if (!statusCode)
     statusCode = 200;
-  if (route2?.method === "GET" && (statusCode === 301 || statusCode === 302)) {
-    const callback = String(route2.callback);
+  if (foundRoute?.method === "GET" && (statusCode === 301 || statusCode === 302)) {
+    const callback = String(foundCallback);
     const response = Response.redirect(callback, statusCode);
     return await noCache(response);
   }
-  if (route2?.method !== req.method)
+  if (foundRoute?.method !== req.method)
     return new Response("Method not allowed", { status: 405 });
-  if (isString(route2.callback) && extname(route2.callback) === ".html") {
+  if (isString(foundCallback) && extname(foundCallback) === ".html") {
     try {
-      const fileContent = Bun.file(route2.callback);
+      const fileContent = Bun.file(foundCallback);
       return await new Response(fileContent, {
         headers: { "Content-Type": "text/html" }
       });
@@ -130,14 +139,14 @@ async function execute(route2, req, { statusCode }) {
       return await new Response("Error reading the HTML file", { status: 500 });
     }
   }
-  if (isString(route2.callback))
-    return await new Response(route2.callback);
-  if (isFunction(route2.callback)) {
-    const result = route2.callback();
+  if (isString(foundCallback))
+    return await new Response(foundCallback);
+  if (isFunction(foundCallback)) {
+    const result = foundCallback();
     return await new Response(JSON.stringify(result));
   }
-  if (isObject(route2.callback))
-    return await new Response(JSON.stringify(route2.callback));
+  if (isObject(foundCallback))
+    return await new Response(JSON.stringify(foundCallback));
   return await new Response("Unknown callback type.", { status: 500 });
 }
 var noCache = function(response) {
@@ -146,6 +155,23 @@ var noCache = function(response) {
   response.headers.set("Expires", "0");
   return response;
 };
+var addRouteQuery = function(url) {
+  if (!isObjectNotEmpty(url.searchParams))
+    request2.addQuery(url);
+};
+var addRouteParam = function(param) {
+  request2.addParam(param);
+};
+var executeMiddleware = function(route2) {
+  const { middleware: middleware2 = null } = route2;
+  if (middleware2 && middlewares && isObjectNotEmpty(middlewares)) {
+    if (isString(middleware2)) {
+    } else {
+      middleware2.forEach(() => {
+      });
+    }
+  }
+};
 var isString = function(val) {
   return typeof val === "string";
 };
@@ -156,12 +182,12 @@ var isFunction = function(val) {
   return typeof val === "function";
 };
 var isObject = function(val) {
-  return val !== null && typeof val === "object" && !Array.isArray(val);
+  return typeof val === "object";
 };
 // src/router.ts
 import {log as log2} from "@stacksjs/logging";
 import {path as p, projectStoragePath, routesPath} from "@stacksjs/path";
-import {pascalCase} from "@stacksjs/strings";
+import {kebabCase, pascalCase} from "@stacksjs/strings";
 
 class Router {
   routes = [];
@@ -173,99 +199,94 @@ class Router {
     const pattern = new RegExp(`^${uri.replace(/:[a-zA-Z]+/g, (_match) => {
       return "([a-zA-Z0-9-]+)";
     })}\$`);
-    let routeCallback;
-    if (typeof callback === "string" || typeof callback === "object") {
-      routeCallback = () => callback;
-    } else {
-      routeCallback = callback;
-    }
     log2.debug(`Adding route: ${method} ${uri} with name ${name}`);
     this.routes.push({
       name,
       method,
       url: uri,
       uri,
-      callback: routeCallback,
+      callback,
       pattern,
       statusCode,
       paramNames: []
     });
     return this;
   }
-  async get(path4, callback) {
+  get(path4, callback) {
     this.path = this.normalizePath(path4);
     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 email(path4) {
     path4 = pascalCase(path4);
-    const emailModule = await import(p.userNotificationsPath(`${path4}.ts`));
-    const callback = emailModule.default.handle;
+    const emailModule = (await import(p.userNotificationsPath(`${path4}.ts`))).default;
+    const callback = emailModule.handle;
     const uri = this.prepareUri(path4);
     this.addRoute("GET", uri, callback, 200);
     return this;
   }
   async health() {
-    const healthModule = await import(p.userActionsPath("HealthAction.ts"));
-    const callback = healthModule.default.handle;
-    const path4 = healthModule.default.path ?? `${this.apiPrefix}/health`;
+    const healthModule = (await import(p.userActionsPath("HealthAction.ts"))).default;
+    const callback = healthModule.handle;
+    const path4 = healthModule.path ?? `${this.apiPrefix}/health`;
     this.addRoute("GET", path4, callback, 200);
     return this;
   }
   async job(path4) {
     path4 = pascalCase(path4);
-    const jobModule = await import(p.userJobsPath(`${path4}Job.ts`.replace(/JobJob/, "Job")));
-    const callback = jobModule.default.handle;
-    path4 = this.prepareUri(path4);
-    this.addRoute("GET", path4, callback, 200);
-    return this;
+    const job = (await import(p.userJobsPath(`${path4}.ts`))).default;
+    return this.addRoute("GET", this.prepareUri(path4), job.handle, 200);
   }
   async action(path4) {
+    if (path4?.endsWith(".ts")) {
+      const action = (await import(p.userActionsPath(path4))).default;
+      path4 = action.path ?? kebabCase(path4);
+      return this.addRoute(action.method ?? "GET", path4, action.handle, 200);
+    }
     path4 = pascalCase(path4);
-    let callback;
+    const userActionsPath = p.userActionsPath(`${path4}.ts`);
     try {
-      const actionModule = await import(p.userActionsPath(`${path4}Action.ts`.replace(/ActionAction/, "Action")));
-      callback = actionModule.default.handle;
+      const action = (await import(userActionsPath)).default;
+      return this.addRoute(action.method ?? "GET", this.prepareUri(path4), action.handle, 200);
     } catch (error) {
       try {
-        const actionModule = await import(p.userActionsPath(`${path4}.ts`.replace(/ActionAction/, "Action")));
-        callback = actionModule.default.handle;
+        const action = (await import(p.userActionsPath(`${path4}.ts`))).default;
+        return this.addRoute(action.method ?? "GET", this.prepareUri(path4), action.handle, 200);
       } catch (error2) {
-        log2.error(`Could not find action module for path: ${path4}`);
+        log2.error(`Could not find Action for path: ${path4}`);
         return this;
       }
     }
-    path4 = this.prepareUri(path4);
-    this.addRoute("GET", path4, callback, 200);
-    return this;
   }
   post(path4, callback) {
-    path4 = this.prepareUri(path4);
-    this.addRoute("POST", path4, callback, 201);
-    return this;
+    this.path = this.normalizePath(path4);
+    const uri = this.prepareUri(this.path);
+    return this.addRoute("POST", uri, callback, 201);
   }
   view(path4, callback) {
-    this.addRoute("GET", path4, callback, 200);
-    return this;
+    this.path = this.normalizePath(path4);
+    const uri = this.prepareUri(this.path);
+    return this.addRoute("GET", uri, callback, 200);
   }
   redirect(path4, callback, _status) {
-    this.addRoute("GET", path4, callback, 302);
-    return this;
+    return this.addRoute("GET", path4, callback, 302);
   }
   delete(path4, callback) {
-    this.addRoute("DELETE", path4, callback, 204);
-    return this;
+    return this.addRoute("DELETE", this.prepareUri(path4), callback, 204);
   }
   patch(path4, callback) {
-    this.addRoute("PATCH", path4, callback, 202);
-    return this;
+    this.path = this.normalizePath(path4);
+    log2.debug(`Normalized Path: ${this.path}`);
+    const uri = this.prepareUri(this.path);
+    log2.debug(`Prepared URI: ${uri}`);
+    return this.addRoute("PATCH", uri, callback, 202);
   }
   put(path4, callback) {
-    this.addRoute("PUT", path4, callback, 202);
-    return this;
+    this.path = this.normalizePath(path4);
+    const uri = this.prepareUri(this.path);
+    return this.addRoute("PUT", uri, callback, 202);
   }
   group(options, callback) {
     if (typeof options === "string")
@@ -338,7 +359,7 @@ class Router {
     }
     if (typeof callback === "string")
       return await this.importCallbackFromPath(callback, this.path);
-    return await callback;
+    return callback;
   }
   async importCallbackFromPath(callbackPath, originalPath) {
     let modulePath = callbackPath;
@@ -356,7 +377,9 @@ class Router {
     }
     const newPath = actionModule.default.path ?? originalPath;
     this.updatePathIfNeeded(newPath, originalPath);
-    return await actionModule.default.handle();
+    if (condition)
+      return await actionModule.default.handle();
+    return await actionModule.default.handle(request);
   }
   normalizePath(path4) {
     return path4.endsWith("/") ? path4.slice(0, -1) : path4;
@@ -365,7 +388,6 @@ class Router {
     if (path4.startsWith("/"))
       path4 = path4.slice(1);
     path4 = `${this.apiPrefix}${this.groupPrefix}/${path4}`;
-    console.log(path4);
     return path4.endsWith("/") ? path4.slice(0, -1) : path4;
   }
   updatePathIfNeeded(newPath, originalPath) {
@@ -375,12 +397,19 @@ class Router {
   }
 }
 var route = new Router;
+// src/utils.ts
+async function listRoutes() {
+  const routeLists = await route.getRoutes();
+  console.table(routeLists);
+  return ok("Successfully listed routes!");
+}
 export {
   serverResponse,
   serve,
   route,
-  request,
+  request2 as request,
   middlewares,
+  listRoutes,
   Router,
   Request,
   Middleware

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/router",
   "type": "module",
-  "version": "0.61.17",
+  "version": "0.61.19",
   "description": "The Stacks framework router.",
   "author": "Chris Breuer",
   "license": "MIT",
@@ -49,13 +49,13 @@
   },
   "peerDependencies": {
     "@stacksjs/config": "latest",
-    "unplugin-vue-router": "^0.8.7",
+    "unplugin-vue-router": "^0.8.8",
     "vue-router": "^4.3.2"
   },
   "dependencies": {
     "@stacksjs/config": "latest",
     "@stacksjs/logging": "latest",
-    "unplugin-vue-router": "^0.8.7",
+    "unplugin-vue-router": "^0.8.8",
     "vue-router": "^4.3.2"
   },
   "devDependencies": {

package/src/index.ts

@@ -2,3 +2,4 @@ export * from './middleware'
 export * from './request'
 export * from './server'
 export * from './router'
+export * from './utils'

package/src/request.ts

@@ -1,3 +1,5 @@
+import type { RouteParam } from '@stacksjs/types'
+
 interface RequestData {
   [key: string]: string
 }
@@ -21,6 +23,10 @@ export class Request {
     this.query = Object.fromEntries(url.searchParams)
   }
 
+  public addParam(param: RouteParam): void {
+    this.params = param
+  }
+
   public get(element: string): string | number | undefined {
     return this.query[element]
   }
@@ -44,10 +50,14 @@ export class Request {
     if (match?.groups) this.params = match.groups
   }
 
-  public getParams(key: string): number | string | null {
+  public getParam(key: string): number | string | null {
     return this.params ? this.params[key] || null : null
   }
 
+  public getParams(): RouteParams {
+    return this.params
+  }
+
   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,8 +1,12 @@
+import type { Action } from '@stacksjs/actions'
 import { log } from '@stacksjs/logging'
 import { path as p, projectStoragePath, routesPath } from '@stacksjs/path'
-import { pascalCase } from '@stacksjs/strings'
+import { kebabCase, pascalCase } from '@stacksjs/strings'
+import type { Job } from '@stacksjs/types'
 import type { RedirectCode, Route, RouteGroupOptions, RouterInterface, StatusCode } from '@stacksjs/types'
 
+type ActionPath = string // TODO: narrow this by automating its generation
+
 export class Router implements RouterInterface {
   private routes: Route[] = []
   private apiPrefix = '/api'
@@ -22,14 +26,14 @@ export class Router implements RouterInterface {
       })}$`,
     )
 
-    let routeCallback: Route['callback']
+    // let routeCallback: Route['callback']
 
-    if (typeof callback === 'string' || typeof callback === 'object') {
-      // Convert string or object to RouteCallback
-      routeCallback = () => callback
-    } else {
-      routeCallback = callback
-    }
+    // if (typeof callback === 'string' || typeof callback === 'object') {
+    //   // Convert string or object to RouteCallback
+    //   routeCallback = () => callback
+    // } else {
+    //   routeCallback = callback
+    // }
 
     log.debug(`Adding route: ${method} ${uri} with name ${name}`)
 
@@ -38,21 +42,20 @@ export class Router implements RouterInterface {
       method,
       url: uri,
       uri,
-      callback: routeCallback,
+      callback,
       pattern,
       statusCode,
       paramNames: [],
+      // middleware: [],
     })
 
     return this
   }
 
-  public async get(path: Route['url'], callback: Route['callback']): Promise<this> {
+  public get(path: Route['url'], callback: Route['callback']): this {
     this.path = this.normalizePath(path)
     log.debug(`Normalized Path: ${this.path}`)
 
-    callback = await this.resolveCallback(callback)
-
     const uri = this.prepareUri(this.path)
     log.debug(`Prepared URI: ${uri}`)
 
@@ -62,9 +65,8 @@ export class Router implements RouterInterface {
   public async email(path: Route['url']): Promise<this> {
     path = pascalCase(path)
 
-    const emailModule = await import(p.userNotificationsPath(`${path}.ts`))
-    const callback = emailModule.default.handle
-
+    const emailModule = (await import(p.userNotificationsPath(`${path}.ts`))).default as Action
+    const callback = emailModule.handle
     const uri = this.prepareUri(path)
     this.addRoute('GET', uri, callback, 200)
 
@@ -72,10 +74,9 @@ export class Router implements RouterInterface {
   }
 
   public async health(): Promise<this> {
-    const healthModule = await import(p.userActionsPath('HealthAction.ts'))
-    const callback = healthModule.default.handle
-
-    const path = healthModule.default.path ?? `${this.apiPrefix}/health`
+    const healthModule = (await import(p.userActionsPath('HealthAction.ts'))).default as Action
+    const callback = healthModule.handle
+    const path = healthModule.path ?? `${this.apiPrefix}/health`
 
     this.addRoute('GET', path, callback, 200)
 
@@ -86,71 +87,80 @@ export class Router implements RouterInterface {
     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
+    const job = (await import(p.userJobsPath(`${path}.ts`))).default as Job
 
-    path = this.prepareUri(path)
-    this.addRoute('GET', path, callback, 200)
-
-    return this
+    return this.addRoute('GET', this.prepareUri(path), job.handle, 200)
   }
 
-  public async action(path: Route['url']): Promise<this> {
+  public async action(path: ActionPath | Route['path']): Promise<this> {
+    // check if action is a file anywhere in ./app/Actions/**/*.ts
+    if (path?.endsWith('.ts')) {
+      // given it ends with .ts, we treat it as an Actions path
+      const action = (await import(p.userActionsPath(path))).default as Action
+      path = action.path ?? kebabCase(path as string)
+      return this.addRoute(action.method ?? 'GET', path, action.handle, 200)
+    }
+
     path = pascalCase(path) // actions are PascalCase
+    const userActionsPath = p.userActionsPath(`${path}.ts`)
 
-    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
+      const action = (await import(userActionsPath)).default as Action
+
+      return this.addRoute(action.method ?? 'GET', this.prepareUri(path), action.handle, 200)
     } catch (error) {
       try {
-        const actionModule = await import(p.userActionsPath(`${path}.ts`.replace(/ActionAction/, 'Action')))
-        callback = actionModule.default.handle
+        const action = (await import(p.userActionsPath(`${path}.ts`))).default as Action
+
+        return this.addRoute(action.method ?? 'GET', this.prepareUri(path), action.handle, 200)
       } catch (error) {
-        log.error(`Could not find action module for path: ${path}`)
+        log.error(`Could not find Action for path: ${path}`)
+
         return this
       }
     }
-
-    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)
+    this.path = this.normalizePath(path)
 
-    return this
+    const uri = this.prepareUri(this.path)
+
+    return this.addRoute('POST', uri, callback, 201)
   }
 
   public view(path: Route['url'], callback: Route['callback']): this {
-    this.addRoute('GET', path, callback, 200)
+    this.path = this.normalizePath(path)
 
-    return this
+    const uri = this.prepareUri(this.path)
+
+    return this.addRoute('GET', uri, callback, 200)
   }
 
   public redirect(path: Route['url'], callback: Route['callback'], _status?: RedirectCode): this {
-    this.addRoute('GET', path, callback, 302)
-
-    return this
+    return this.addRoute('GET', path, callback, 302)
   }
 
   public delete(path: Route['url'], callback: Route['callback']): this {
-    this.addRoute('DELETE', path, callback, 204)
-    return this
+    return this.addRoute('DELETE', this.prepareUri(path), callback, 204)
   }
 
   public patch(path: Route['url'], callback: Route['callback']): this {
-    this.addRoute('PATCH', path, callback, 202)
-    return this
+    this.path = this.normalizePath(path)
+    log.debug(`Normalized Path: ${this.path}`)
+
+    const uri = this.prepareUri(this.path)
+    log.debug(`Prepared URI: ${uri}`)
+
+    return this.addRoute('PATCH', uri, callback, 202)
   }
 
   public put(path: Route['url'], callback: Route['callback']): this {
-    this.addRoute('PUT', path, callback, 202)
-    return this
+    this.path = this.normalizePath(path)
+
+    const uri = this.prepareUri(this.path)
+
+    return this.addRoute('PUT', uri, callback, 202)
   }
 
   public group(options: string | RouteGroupOptions, callback?: () => void): this {
@@ -211,7 +221,6 @@ export class Router implements RouterInterface {
   }
 
   public prefix(prefix: string): this {
-    // @ts-expect-error - this is fine for now
     this.routes[this.routes.length - 1].prefix = prefix
 
     return this
@@ -252,7 +261,7 @@ export class Router implements RouterInterface {
     return
   }
 
-  private async resolveCallback(callback: Route['callback']): Promise<Route['callback']> {
+  public async resolveCallback(callback: Route['callback']): Promise<Route['callback']> {
     if (callback instanceof Promise) {
       const actionModule = await callback
       return actionModule.default
@@ -261,10 +270,10 @@ export class Router implements RouterInterface {
     if (typeof callback === 'string') return await this.importCallbackFromPath(callback, this.path)
 
     // in this case, the callback ends up being a function
-    return await callback
+    return callback
   }
 
-  private async importCallbackFromPath(callbackPath: string, originalPath: string): Promise<Route['callback']> {
+  public async importCallbackFromPath(callbackPath: string, originalPath: string): Promise<Route['callback']> {
     let modulePath = callbackPath
     let importPathFunction = p.appPath // Default import path function
 
@@ -287,7 +296,17 @@ export class Router implements RouterInterface {
     const newPath = actionModule.default.path ?? originalPath
     this.updatePathIfNeeded(newPath, originalPath)
 
-    return await actionModule.default.handle()
+    // we need to make sure the validation happens here
+    // to do so, we need to:
+    // find the ./app/Models/* file
+    // then check via a regex which model attributes validations to utilize by checking what's in between t
+    // then validate
+    // if succeeds, run the handle
+    // if fails, return validation error
+
+    if (condition) return await actionModule.default.handle()
+
+    return await actionModule.default.handle(request)
   }
 
   private normalizePath(path: string): string {
@@ -300,8 +319,6 @@ export class Router implements RouterInterface {
 
     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

package/src/server.ts

@@ -1,7 +1,7 @@
 import process from 'node:process'
 import { log } from '@stacksjs/logging'
 import { extname } from '@stacksjs/path'
-import type { Route, StatusCode } from '@stacksjs/types'
+import type { Route, RouteParam, StatusCode } from '@stacksjs/types'
 import { route } from '.'
 import { middlewares } from './middleware'
 import { request as RequestParam } from './request'
@@ -13,6 +13,10 @@ interface ServeOptions {
   timezone?: string
 }
 
+interface Options {
+  statusCode?: StatusCode
+}
+
 export async function serve(options: ServeOptions = {}) {
   const hostname = options.host || 'localhost'
   const port = options.port || 3000
@@ -45,83 +49,72 @@ export async function serverResponse(req: Request) {
   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)}`)
 
   log.info(`URL: ${JSON.stringify(url)}`)
 
-  const foundRoute: Route | undefined = routesList.find((route: Route) => {
-    const pattern = new RegExp(`^${route.uri.replace(/:\w+/g, '\\w+')}$`)
+  const foundRoute: Route | undefined = routesList
+    .filter((route: Route) => {
+      const pattern = new RegExp(`^${route.uri.replace(/\{(\w+)\}/g, '(\\w+)')}$`)
 
-    return pattern.test(url.pathname)
-  })
+      return pattern.test(url.pathname)
+    })
+    .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
 
+  const routeParams = extractDynamicSegments(foundRoute.uri, url.pathname)
+
+  addRouteQuery(url)
+  addRouteParam(routeParams)
+
   await executeMiddleware(foundRoute)
 
   return await execute(foundRoute, req, { statusCode: foundRoute?.statusCode })
 }
 
-function addRouteParamsAndQuery(url: URL): void {
-  if (!isObjectNotEmpty(url.searchParams)) RequestParam.addQuery(url)
+function extractDynamicSegments(routePattern: string, path: string): RouteParam {
+  const regexPattern = new RegExp(`^${routePattern.replace(/\{(\w+)\}/g, '(\\w+)')}$`)
+  const match = path.match(regexPattern)
 
-  // requestInstance.extractParamsFromRoute(route.uri, url.pathname)
-}
+  if (!match) {
+    return null
+  }
+  const dynamicSegmentNames = [...routePattern.matchAll(/\{(\w+)\}/g)].map((m) => m[1])
+  const dynamicSegmentValues = match.slice(1) // First match is the whole string, so we slice it off
 
-function executeMiddleware(route: Route): void {
-  const { middleware = null } = route
+  const dynamicSegments: { [key: string]: string } = {}
+  dynamicSegmentNames.forEach((name, index) => {
+    dynamicSegments[name] = dynamicSegmentValues[index]
+  })
 
-  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.
-    } 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.
-      })
-    }
-  }
+  return dynamicSegments
 }
 
-interface Options {
-  statusCode?: StatusCode
-}
+async function execute(foundRoute: Route, req: Request, { statusCode }: Options) {
+  const foundCallback = await route.resolveCallback(foundRoute.callback)
 
-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)
+  if (foundRoute?.method === 'GET' && (statusCode === 301 || statusCode === 302)) {
+    const callback = String(foundCallback)
     const response = Response.redirect(callback, statusCode)
 
     return await noCache(response)
   }
 
-  if (route?.method !== req.method) return new Response('Method not allowed', { status: 405 })
+  if (foundRoute?.method !== req.method) return new Response('Method not allowed', { status: 405 })
 
   // Check if it's a path to an HTML file
-  if (isString(route.callback) && extname(route.callback) === '.html') {
+  if (isString(foundCallback) && extname(foundCallback) === '.html') {
     try {
-      const fileContent = Bun.file(route.callback)
+      const fileContent = Bun.file(foundCallback)
 
       return await new Response(fileContent, {
         headers: { 'Content-Type': 'text/html' },
@@ -131,14 +124,15 @@ async function execute(route: Route, req: Request, { statusCode }: Options) {
     }
   }
 
-  if (isString(route.callback)) return await new Response(route.callback)
+  if (isString(foundCallback)) return await new Response(foundCallback)
+
+  if (isFunction(foundCallback)) {
+    const result = foundCallback()
 
-  if (isFunction(route.callback)) {
-    const result = route.callback()
     return await new Response(JSON.stringify(result))
   }
 
-  if (isObject(route.callback)) return await new Response(JSON.stringify(route.callback))
+  if (isObject(foundCallback)) return await new Response(JSON.stringify(foundCallback))
 
   // If no known type matched, return a generic error.
   return await new Response('Unknown callback type.', { status: 500 })
@@ -152,6 +146,41 @@ function noCache(response: Response) {
   return response
 }
 
+function addRouteQuery(url: URL): void {
+  if (!isObjectNotEmpty(url.searchParams)) RequestParam.addQuery(url)
+
+  // requestInstance.extractParamsFromRoute(route.uri, url.pathname)
+}
+
+function addRouteParam(param: RouteParam): void {
+  RequestParam.addParam(param)
+}
+
+function executeMiddleware(route: Route): void {
+  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.
+    } 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.
+      })
+    }
+  }
+}
 function isString(val: unknown): val is string {
   return typeof val === 'string'
 }
@@ -165,5 +194,5 @@ function isFunction(val: unknown): val is Function {
 }
 
 function isObject(val: unknown): val is object {
-  return val !== null && typeof val === 'object' && !Array.isArray(val)
+  return typeof val === 'object'
 }

package/src/utils.ts

@@ -0,0 +1,9 @@
+import { route } from './router'
+
+export async function listRoutes() {
+  const routeLists = await route.getRoutes()
+
+  console.table(routeLists)
+
+  return ok('Successfully listed routes!')
+}