owebjs 1.2.3 → 1.3.1

package/README.md

@@ -1,13 +1,233 @@
 # Oweb
 
-Flexible handler that built on top of Fastify
+A flexible and modern web framework built on top of Fastify, designed for creating scalable and maintainable web applications with file-based routing and hot module replacement.
+
+<p align="center">
+  <img src="https://img.shields.io/npm/v/owebjs" alt="npm version">
+  <img src="https://img.shields.io/npm/l/owebjs" alt="license">
+  <img src="https://img.shields.io/npm/dt/owebjs" alt="downloads">
+</p>
+
+## Features
+
+- **File-based Routing**: Automatically generate routes based on your file structure
+- **Hot Module Replacement (HMR)**: Update your routes without restarting the server
+- **Middleware Support**: Use hooks to add middleware functionality
+- **Error Handling**: Global and route-specific error handling
+- **TypeScript Support**: Built with TypeScript for better developer experience
+- **Plugin System**: Extend functionality with plugins
+- **uWebSockets.js Support**: Optional high-performance WebSocket server
 
 ## Installation
 
+```bash
+npm install owebjs
+```
+
+## Quick Start
+
+```javascript
+import Oweb from 'owebjs';
+
+// Create and setup the app
+const app = await new Oweb().setup();
+
+// Load routes from a directory
+await app.loadRoutes({
+    directory: 'routes',
+    hmr: {
+        enabled: true, // Enable hot module replacement
+    },
+});
+
+// Start the server
+await app.start({ port: 3000 });
+console.log('Server running at http://localhost:3000');
+```
+
+## Creating Routes
+
+Routes are automatically generated based on your file structure. Create a file in your routes directory:
+
+```javascript
+// routes/hello.js
+import { Route } from 'owebjs';
+
+export default class extends Route {
+    async handle(req, res) {
+        res.send({ message: 'Hello, World!' });
+    }
+}
+```
+
+This will create a GET route at `/hello`.
+
+### Dynamic Routes
+
+Use brackets to create dynamic route parameters:
+
+```javascript
+// routes/users/[id].js
+import { Route } from 'owebjs';
+
+export default class extends Route {
+    async handle(req, res) {
+        res.send({ userId: req.params.id });
+    }
+}
+```
+
+This will create a GET route at `/users/:id`.
+
+### HTTP Methods
+
+Specify the HTTP method in the filename:
+
+```javascript
+// routes/api/users.post.js
+import { Route } from 'owebjs';
+
+export default class extends Route {
+    async handle(req, res) {
+        // Create a new user
+        const user = req.body;
+        res.status(201).send({ id: 1, ...user });
+    }
+}
+```
+
+## Middleware (Hooks)
+
+Create hooks to add middleware functionality:
+
+```javascript
+// routes/_hooks.js
+import { Hook } from 'owebjs';
+
+export default class extends Hook {
+    handle(req, res, done) {
+        console.log(`${req.method} ${req.url}`);
+        done(); // Continue to the next hook or route handler
+    }
+}
+```
+
+Hooks are applied to all routes in the current directory and its subdirectories.
+
+## Error Handling
+
+### Global Error Handler
+
+```javascript
+app.setInternalErrorHandler((req, res, error) => {
+    console.error(error);
+    res.status(500).send({
+        error: 'Internal Server Error',
+        message: error.message,
+    });
+});
+```
+
+### Route-specific Error Handler
+
+```javascript
+import { Route } from 'owebjs';
+
+export default class extends Route {
+    async handle(req, res) {
+        throw new Error('Something went wrong');
+    }
+
+    handleError(req, res, error) {
+        res.status(500).send({
+            error: 'Route Error',
+            message: error.message,
+        });
+    }
+}
+```
+
+## Plugins
+
+Oweb supports Fastify plugins and comes with some built-in plugins:
+
+### Using Fastify Plugins
+
+```javascript
+import Oweb from 'owebjs';
+import fastifyMultipart from '@fastify/multipart';
+
+const app = await new Oweb().setup();
+
+// Register Fastify plugin
+await app.register(fastifyMultipart, {
+    limits: {
+        fileSize: 10 * 1024 * 1024, // 10MB
+    },
+});
 ```
-npm i owebjs
+
+### Using Built-in Plugins
+
+```javascript
+import { Route } from 'owebjs';
+import { ChunkUpload } from 'owebjs/dist/plugins';
+
+export default class extends Route {
+    async handle(req, res) {
+        const file = await req.file();
+        const buffer = await file.toBuffer();
+
+        await ChunkUpload(
+            {
+                buffer,
+                fileName: file.filename,
+                currentChunk: +req.query.currentChunk,
+                totalChunks: +req.query.totalChunks,
+            },
+            {
+                path: './uploads',
+                maxChunkSize: 5 * 1024 * 1024, // 5MB
+            },
+        );
+
+        return res.status(204).send();
+    }
+}
 ```
 
-## Usage
+## Advanced Configuration
 
-This package is still WIP. However, if you want to check out the usage head over to [test directory](https://github.com/owebjs/oweb/tree/main/test)
+### uWebSockets.js Support
+
+```javascript
+const app = await new Oweb({ uWebSocketsEnabled: true }).setup();
+```
+
+### Custom Route Options
+
+```javascript
+import { Route } from 'owebjs';
+
+export default class extends Route {
+    constructor() {
+        super({
+            schema: {
+                body: {
+                    type: 'object',
+                    required: ['username', 'password'],
+                    properties: {
+                        username: { type: 'string' },
+                        password: { type: 'string' },
+                    },
+                },
+            },
+        });
+    }
+
+    async handle(req, res) {
+        // Body is validated according to the schema
+        res.send({ success: true });
+    }
+}
+```

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { FastifyServerOptions, FastifyRequest, FastifyReply, FastifyListenOptions, FastifyInstance } from 'fastify';
+import { FastifyInstance, FastifyServerOptions, FastifyRequest, FastifyReply, FastifyListenOptions } from 'fastify';
 import { FastifyReply as FastifyReply$1 } from 'fastify/types/reply';
 export { FastifyReply } from 'fastify/types/reply';
 import { FastifyRequest as FastifyRequest$1 } from 'fastify/types/request';
@@ -24,6 +24,13 @@ interface OwebOptions extends FastifyServerOptions {
 }
 interface LoadRoutesOptions {
     directory: string;
+    hmr?: {
+        /**
+         * The directory to watch for changes. If not specified, it will use the routes directory.
+         */
+        directory?: string;
+        enabled: boolean;
+    };
 }
 interface _FastifyInstance extends FastifyInstance {
 }
@@ -31,17 +38,27 @@ declare class _FastifyInstance {
 }
 declare class Oweb extends _FastifyInstance {
     _options: OwebOptions;
+    private hmrDirectory;
+    routes: Map<string, any>;
     constructor(options?: OwebOptions);
     /**
      *
      * Returns a fastify instance with the Oweb prototype methods
      */
     setup(): Promise<Oweb>;
+    /**
+     * Loads routes from a directory.
+     * @param options.directory The directory to load routes from.
+     * @param options.hmr Configuration for Hot Module Replacement.
+     * @param options.hmr.enabled Whether to enable HMR. HMR is disabled if NODE_ENV is set to production.
+     * @param options.hmr.directory The directory to watch for changes. If not specified, it will use the routes directory.
+     */
+    loadRoutes({ directory, hmr }: LoadRoutesOptions): Promise<void>;
     /**
      *
-     * Loads routes from a directory
+     * Watches for changes in the routes directory
      */
-    loadRoutes({ directory }: LoadRoutesOptions): Promise<void>;
+    private watch;
     /**
      *
      * Sets the internal error handler
@@ -55,13 +72,11 @@ declare class Oweb extends _FastifyInstance {
 
 type Awaitable<T> = T | Promise<T>;
 
-declare interface Route {
-    handle(req: FastifyRequest$1, res: FastifyReply$1): Awaitable<any>;
-    handleError?(req: FastifyRequest$1, res: FastifyReply$1, err: Error): Awaitable<any>;
-}
 declare abstract class Route {
     _options: RouteShorthandOptions;
     constructor(options?: RouteShorthandOptions);
+    abstract handle(req: FastifyRequest$1, res: FastifyReply$1): Awaitable<any>;
+    handleError?(req: FastifyRequest$1, res: FastifyReply$1, err: Error): Awaitable<any>;
 }
 
 declare interface Hook {
@@ -70,4 +85,4 @@ declare interface Hook {
 declare abstract class Hook {
 }
 
-export { Awaitable, Hook, LoadRoutesOptions, Oweb, OwebOptions, Route, Oweb as default };
+export { type Awaitable, Hook, type LoadRoutesOptions, Oweb, type OwebOptions, Route, Oweb as default };

package/dist/index.js

@@ -1,10 +1,10 @@
-import "./chunk-NH24FRB3.js";
+import "./chunk-SHUYVCID.js";
 import { Oweb } from './structures/Oweb.js';
-var src_default = Oweb;
+var index_default = Oweb;
 export * from './structures/Oweb.js';
 export * from './structures/Route.js';
 export * from './structures/Hook.js';
 export * from './types.js';
 export {
-  src_default as default
+  index_default as default
 };

package/dist/plugins/ChunkUpload.js

@@ -1,26 +1,26 @@
 import {
   __name
-} from "../chunk-NH24FRB3.js";
+} from "../chunk-SHUYVCID.js";
 import fs from "node:fs";
 import nodePath from "node:path";
-var ChunkUploadStatus;
-(function(ChunkUploadStatus2) {
+var ChunkUploadStatus = /* @__PURE__ */ function(ChunkUploadStatus2) {
   ChunkUploadStatus2["Success"] = "SUCCESS";
   ChunkUploadStatus2["FileTooLarge"] = "FILE_TOO_LARGE";
   ChunkUploadStatus2["ChunkTooLarge"] = "CHUNK_TOO_LARGE";
   ChunkUploadStatus2["InvalidChunk"] = "INVALID_CHUNK";
-})(ChunkUploadStatus || (ChunkUploadStatus = {}));
+  return ChunkUploadStatus2;
+}({});
 async function ChunkUpload(file, options) {
   const { buffer, fileName, currentChunk, totalChunks } = file;
   const { path, maxChunkSize, maxFileSize } = options;
   if (typeof currentChunk !== "number" || typeof totalChunks !== "number" || currentChunk < 1 || totalChunks < 1 || currentChunk > totalChunks) {
     return {
-      status: ChunkUploadStatus.InvalidChunk
+      status: "INVALID_CHUNK"
     };
   }
   if (buffer.length > maxChunkSize) {
     return {
-      status: ChunkUploadStatus.ChunkTooLarge
+      status: "CHUNK_TOO_LARGE"
     };
   }
   const filePath = nodePath.join(path, fileName);
@@ -39,11 +39,11 @@ async function ChunkUpload(file, options) {
     if (typeof maxFileSize === "number" && fileSize > maxFileSize) {
       fs.unlinkSync(filePath);
       return {
-        status: ChunkUploadStatus.FileTooLarge
+        status: "FILE_TOO_LARGE"
       };
     }
     return {
-      status: ChunkUploadStatus.Success,
+      status: "SUCCESS",
       uploadCompleted: true
     };
   } else if (currentChunk === 1) {
@@ -52,7 +52,7 @@ async function ChunkUpload(file, options) {
     fs.appendFileSync(chunkPath, buffer);
   }
   return {
-    status: ChunkUploadStatus.Success,
+    status: "SUCCESS",
     currentChunk
   };
 }

package/dist/plugins/index.d.ts

@@ -31,4 +31,4 @@ declare enum ChunkUploadStatus {
 }
 declare function ChunkUpload(file: FileData, options: ChunkUploadOptions): Promise<ChunkUploadResult>;
 
-export { ChunkUpload, ChunkUploadOptions, ChunkUploadResult, ChunkUploadStatus, FileData };
+export { ChunkUpload, type ChunkUploadOptions, type ChunkUploadResult, ChunkUploadStatus, type FileData };

package/dist/structures/Hook.js

@@ -1,6 +1,6 @@
 import {
   __name
-} from "../chunk-NH24FRB3.js";
+} from "../chunk-SHUYVCID.js";
 class Hook {
   static {
     __name(this, "Hook");

package/dist/structures/Oweb.js

@@ -1,8 +1,10 @@
 import {
   __name
-} from "../chunk-NH24FRB3.js";
+} from "../chunk-SHUYVCID.js";
 import Fastify from "fastify";
-import { assignRoutes } from '../utils/assignRoutes.js';
+import { applyHMR, assignRoutes } from '../utils/assignRoutes.js';
+import { watchRoutes } from '../utils/watchRoutes.js';
+import { info, success, warn } from '../utils/logger.js';
 let _FastifyInstance = class _FastifyInstance2 {
   static {
     __name(this, "_FastifyInstance");
@@ -13,6 +15,8 @@ class Oweb extends _FastifyInstance {
     __name(this, "Oweb");
   }
   _options = {};
+  hmrDirectory;
+  routes = /* @__PURE__ */ new Map();
   constructor(options) {
     super();
     this._options = options ?? {};
@@ -42,8 +46,7 @@ class Oweb extends _FastifyInstance {
       done();
     });
     for (const key in Object.getOwnPropertyDescriptors(Oweb.prototype)) {
-      if (key === "constructor")
-        continue;
+      if (key === "constructor") continue;
       Object.defineProperty(fastify, key, Object.getOwnPropertyDescriptor(Oweb.prototype, key));
     }
     Object.defineProperty(fastify, "_options", {
@@ -55,12 +58,31 @@ class Oweb extends _FastifyInstance {
     return fastify;
   }
   /**
-   *
-   * Loads routes from a directory
+   * Loads routes from a directory.
+   * @param options.directory The directory to load routes from.
+   * @param options.hmr Configuration for Hot Module Replacement.
+   * @param options.hmr.enabled Whether to enable HMR. HMR is disabled if NODE_ENV is set to production.
+   * @param options.hmr.directory The directory to watch for changes. If not specified, it will use the routes directory.
    */
-  loadRoutes({ directory }) {
+  loadRoutes({ directory, hmr }) {
+    if (hmr && !hmr.directory) hmr.directory = directory;
+    if (hmr?.enabled) {
+      this.hmrDirectory = hmr.directory;
+      success(`Hot Module Replacement enabled. Watching changes in ${hmr.directory}`, "HMR");
+    } else {
+      warn('Hot Module Replacement is disabled. Use "await app.loadRoutes({ hmr: { enabled: true, directory: path } })" to enable it.', "HMR");
+    }
     return assignRoutes(this, directory);
   }
+  /**
+   *
+   * Watches for changes in the routes directory
+   */
+  watch() {
+    return watchRoutes(this.hmrDirectory, (op, path, content) => {
+      applyHMR(this, op, this.hmrDirectory, path, content);
+    });
+  }
   /**
    *
    * Sets the internal error handler
@@ -73,10 +95,17 @@ class Oweb extends _FastifyInstance {
       this.listen({
         port,
         host
-      }, (err, address) => resolve({
-        err,
-        address
-      }));
+      }, (err, address) => {
+        if (process.env.NODE_ENV !== "production") {
+          if (this.hmrDirectory) this.watch();
+        } else {
+          info("Hot Module Replacement is disabled in production mode. NODE_ENV is set to production.", "HMR");
+        }
+        resolve({
+          err,
+          address
+        });
+      });
     });
   }
 }

package/dist/structures/Route.js

@@ -1,6 +1,6 @@
 import {
   __name
-} from "../chunk-NH24FRB3.js";
+} from "../chunk-SHUYVCID.js";
 class Route {
   static {
     __name(this, "Route");
@@ -9,9 +9,6 @@ class Route {
   constructor(options) {
     this._options = options ?? {};
   }
-  handle() {
-    throw new Error("Route#handle must be implemented");
-  }
 }
 export {
   Route

package/dist/utils/assignRoutes.js

@@ -1,12 +1,71 @@
 import {
   __name
-} from "../chunk-NH24FRB3.js";
+} from "../chunk-SHUYVCID.js";
 import path from "node:path";
 import { dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { buildRoutePath, buildRouteURL } from './utils.js';
 import { walk } from './walk.js';
+import { success, warn } from './logger.js';
+import { match } from "path-to-regexp";
+import generateFunctionFromTypescript from './generateFunctionFromTypescript.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
+let routeFunctions = {};
+const temporaryRequests = {
+  get: {},
+  post: {},
+  put: {},
+  delete: {},
+  patch: {},
+  options: {}
+};
+let routesCache = [];
+const compiledRoutes = {};
+const applyHMR = /* @__PURE__ */ __name(async (oweb, op, workingDir, path2, content) => {
+  if (path2.endsWith("hooks.js") || path2.endsWith("hooks.ts")) {
+    warn(`Hot Module Replacement is not supported for hooks. Restart the server for changes to take effect.`, "HMR");
+    return;
+  }
+  if (path2.endsWith(".ts")) {
+    const start = Date.now();
+    compiledRoutes[path2] = content.length ? await generateFunctionFromTypescript(content, path2) : void 0;
+    const end = Date.now() - start;
+    success(`File ${path2} compiled in ${end}ms`, "HMR");
+  }
+  if (op === "new-file") {
+    const start = Date.now();
+    const files = await walk(workingDir);
+    const routes = await generateRoutes(files);
+    routesCache = routes;
+    const f = routes.find((x) => x.fileInfo.filePath == path2);
+    temporaryRequests[f.method.toLowerCase()][f.url] = inner(oweb, f);
+    const end = Date.now() - start;
+    success(`Route ${f.method.toUpperCase()}:${f.url} created in ${end}ms`, "HMR");
+  } else if (op === "modify-file") {
+    const start = Date.now();
+    const files = await walk(workingDir);
+    const routes = await generateRoutes(files);
+    routesCache = routes;
+    const f = routes.find((x) => x.fileInfo.filePath == path2);
+    if (f.url in temporaryRequests[f.method.toLowerCase()]) {
+      temporaryRequests[f.method.toLowerCase()][f.url] = inner(oweb, f);
+    } else {
+      routeFunctions[f.fileInfo.filePath] = inner(oweb, f);
+    }
+    const end = Date.now() - start;
+    success(`Route ${f.method.toUpperCase()}:${f.url} reloaded in ${end}ms`, "HMR");
+  } else if (op === "delete-file") {
+    const start = Date.now();
+    const f = routesCache.find((x) => x.fileInfo.filePath == path2);
+    if (f.url in temporaryRequests[f.method.toLowerCase()]) {
+      delete temporaryRequests[f.method.toLowerCase()][f.url];
+    } else {
+      delete routeFunctions[f.fileInfo.filePath];
+    }
+    const end = Date.now() - start;
+    success(`Route ${f.method.toUpperCase()}:${f.url} removed in ${end}ms`, "HMR");
+  }
+}, "applyHMR");
 const generateRoutes = /* @__PURE__ */ __name(async (files) => {
   const routes = [];
   for (const file of files) {
@@ -15,7 +74,17 @@ const generateRoutes = /* @__PURE__ */ __name(async (files) => {
     const packageURL = new URL(path.resolve(filePath), `file://${__dirname}`).pathname.replaceAll("\\", "/");
     const routePath = buildRoutePath(parsedFile);
     const route = buildRouteURL(routePath);
-    const def = await import(packageURL);
+    if (compiledRoutes[file.filePath]) {
+      routes.push({
+        url: route.url,
+        method: route.method,
+        fn: compiledRoutes[file.filePath],
+        fileInfo: file
+      });
+      continue;
+    }
+    const cacheBuster = `?t=${Date.now()}`;
+    const def = await import(packageURL + cacheBuster);
     const routeFuncs = def.default;
     routes.push({
       url: route.url,
@@ -26,57 +95,99 @@ const generateRoutes = /* @__PURE__ */ __name(async (files) => {
   }
   return routes;
 }, "generateRoutes");
-const assignRoutes = /* @__PURE__ */ __name(async (oweb, directory) => {
-  const files = await walk(directory);
-  const routes = await generateRoutes(files);
-  for (const route of routes) {
-    const routeFunc = new route.fn();
-    oweb[route.method](route.url, routeFunc._options || {}, function(req, res) {
-      const handle = /* @__PURE__ */ __name(() => {
-        if (routeFunc.handle.constructor.name == "AsyncFunction") {
-          routeFunc.handle(...arguments).catch((error) => {
-            const handleErrorArgs = [
-              ...arguments,
-              error
-            ];
-            if (routeFunc?.handleError) {
-              routeFunc.handleError(...handleErrorArgs);
-            } else {
-              oweb._options.OWEB_INTERNAL_ERROR_HANDLER(...handleErrorArgs);
-            }
-          });
-        } else {
-          try {
-            routeFunc.handle(...arguments);
-          } catch (error) {
-            const handleErrorArgs = [
-              ...arguments,
-              error
-            ];
-            if (routeFunc?.handleError) {
-              routeFunc.handleError(...handleErrorArgs);
-            } else {
-              oweb._options.OWEB_INTERNAL_ERROR_HANDLER(...handleErrorArgs);
-            }
+function inner(oweb, route) {
+  if (!route.fn) {
+    return;
+  }
+  const routeFunc = new route.fn();
+  return function(req, res) {
+    const handle = /* @__PURE__ */ __name(() => {
+      if (routeFunc.handle.constructor.name == "AsyncFunction") {
+        routeFunc.handle(req, res).catch((error) => {
+          if (routeFunc?.handleError) {
+            routeFunc.handleError(req, res, error);
+          } else {
+            oweb._options.OWEB_INTERNAL_ERROR_HANDLER(req, res, error);
           }
-        }
-      }, "handle");
-      if (route.fileInfo.hooks.length) {
-        for (let index = 0; index < route.fileInfo.hooks.length; index++) {
-          const hookFun = route.fileInfo.hooks[index];
-          new hookFun().handle(req, res, () => {
-            if (index + 1 == route.fileInfo.hooks.length) {
-              handle();
-            }
-          });
-        }
+        });
       } else {
-        handle();
+        try {
+          routeFunc.handle(req, res);
+        } catch (error) {
+          if (routeFunc?.handleError) {
+            routeFunc.handleError(req, res, error);
+          } else {
+            oweb._options.OWEB_INTERNAL_ERROR_HANDLER(req, res, error);
+          }
+        }
+      }
+    }, "handle");
+    if (route.fileInfo.hooks.length) {
+      for (let index = 0; index < route.fileInfo.hooks.length; index++) {
+        const hookFun = route.fileInfo.hooks[index];
+        hookFun.prototype.handle(req, res, () => {
+          if (index + 1 == route.fileInfo.hooks.length) {
+            handle();
+          }
+        });
       }
+    } else {
+      handle();
+    }
+  };
+}
+__name(inner, "inner");
+function assignSpecificRoute(oweb, route) {
+  if (!route.fn) return;
+  const routeFunc = new route.fn();
+  routeFunctions[route.fileInfo.filePath] = inner(oweb, route);
+  oweb[route.method](route.url, routeFunc._options || {}, function(req, res) {
+    if (routeFunctions[route.fileInfo.filePath]) {
+      return routeFunctions[route.fileInfo.filePath](req, res);
+    } else {
+      return res.status(404).send({
+        message: `Route ${req.method}:${req.url} not found`,
+        error: "Not Found",
+        statusCode: 404
+      });
+    }
+  });
+}
+__name(assignSpecificRoute, "assignSpecificRoute");
+const assignRoutes = /* @__PURE__ */ __name(async (oweb, directory) => {
+  const files = await walk(directory);
+  const routes = await generateRoutes(files);
+  routesCache = routes;
+  oweb.all("*", (req, res) => {
+    const vals = temporaryRequests[req.method.toLowerCase()];
+    const keys = Object.keys(vals);
+    if (!vals || !keys.length) {
+      return res.status(404).send({
+        message: `Route ${req.method}:${req.url} not found`,
+        error: "Not Found",
+        statusCode: 404
+      });
+    }
+    const f = keys.find((tempName) => {
+      const matcher = match(tempName);
+      return matcher(req.url);
     });
+    if (f && vals[f]) {
+      return vals[f](req, res);
+    } else {
+      return res.status(404).send({
+        message: `Route ${req.method}:${req.url} not found`,
+        error: "Not Found",
+        statusCode: 404
+      });
+    }
+  });
+  for (const route of routes) {
+    assignSpecificRoute(oweb, route);
   }
 }, "assignRoutes");
 export {
+  applyHMR,
   assignRoutes,
   generateRoutes
 };

package/dist/utils/generateFunctionFromTypescript.js

@@ -0,0 +1,45 @@
+import {
+  __name
+} from "../chunk-SHUYVCID.js";
+import { parse } from "@babel/parser";
+import traverse from "@babel/traverse";
+import generate from "@babel/generator";
+import path from "node:path";
+import babel from "@babel/core";
+import { pathToFileURL } from "node:url";
+async function generateFunctionFromTypescript(tsCode, filePath) {
+  const result = babel.transformSync(tsCode, {
+    presets: [
+      "@babel/preset-typescript"
+    ],
+    filename: filePath
+  });
+  const jsCode = result?.code ?? "";
+  const ast = parse(jsCode, {
+    sourceType: "module"
+  });
+  traverse.default(ast, {
+    ImportDeclaration(astPath) {
+      const importSourceNode = astPath.node.source;
+      let relativePath = importSourceNode.value;
+      if (relativePath.startsWith(".")) {
+        let resolvedPath = relativePath;
+        if (path.extname(relativePath) === "") {
+          resolvedPath = relativePath + ".ts";
+        }
+        const originalFileDir = path.dirname(filePath);
+        const absoluteDepPath = path.resolve(originalFileDir, resolvedPath);
+        const absoluteDepUrl = pathToFileURL(absoluteDepPath).href;
+        importSourceNode.value = absoluteDepUrl;
+      }
+    }
+  });
+  const { code: modifiedCode } = generate.default(ast);
+  const dataUrl = `data:text/javascript,${encodeURIComponent(modifiedCode)}`;
+  const module = await import(dataUrl);
+  return module.default;
+}
+__name(generateFunctionFromTypescript, "generateFunctionFromTypescript");
+export {
+  generateFunctionFromTypescript as default
+};

package/dist/utils/logger.js

@@ -0,0 +1,38 @@
+import {
+  __name
+} from "../chunk-SHUYVCID.js";
+import chalk from "chalk";
+const successText = /* @__PURE__ */ __name((message, category = "success") => {
+  return `${chalk.bgGreen(` Oweb:${category} `)} ${message}`;
+}, "successText");
+const infoText = /* @__PURE__ */ __name((message, category = "info") => {
+  return `${chalk.bgBlue(` Oweb:${category} `)} ${message}`;
+}, "infoText");
+const warnText = /* @__PURE__ */ __name((message, category = "warn") => {
+  return `${chalk.bgYellow(` Oweb:${category} `)} ${message}`;
+}, "warnText");
+const errorText = /* @__PURE__ */ __name((message, category = "error") => {
+  return `${chalk.bgRed(` Oweb:${category} `)} ${message}`;
+}, "errorText");
+const success = /* @__PURE__ */ __name((message, category) => {
+  console.log(successText(message, category));
+}, "success");
+const info = /* @__PURE__ */ __name((message, category) => {
+  console.log(infoText(message, category));
+}, "info");
+const warn = /* @__PURE__ */ __name((message, category) => {
+  console.log(warnText(message, category));
+}, "warn");
+const error = /* @__PURE__ */ __name((message, category) => {
+  console.log(errorText(message, category));
+}, "error");
+export {
+  error,
+  errorText,
+  info,
+  infoText,
+  success,
+  successText,
+  warn,
+  warnText
+};

package/dist/utils/utils.js

@@ -1,6 +1,6 @@
 import {
   __name
-} from "../chunk-NH24FRB3.js";
+} from "../chunk-SHUYVCID.js";
 const mergePaths = /* @__PURE__ */ __name((...paths) => "/" + paths.map((path) => path.replace(/^\/|\/$/g, "")).filter((path) => path !== "").join("/"), "mergePaths");
 const regBackets = /\[([^}]*)\]/g;
 const transformBrackets = /* @__PURE__ */ __name((value) => regBackets.test(value) ? value.replace(regBackets, (_, s) => `:${s}`) : value, "transformBrackets");

package/dist/utils/walk.js

@@ -1,6 +1,6 @@
 import {
   __name
-} from "../chunk-NH24FRB3.js";
+} from "../chunk-SHUYVCID.js";
 import { readdirSync, statSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import path from "node:path";

package/dist/utils/watchRoutes.js

@@ -0,0 +1,31 @@
+import {
+  __name
+} from "../chunk-SHUYVCID.js";
+import chokidar from "chokidar";
+import { readFileSync } from "fs";
+function watchRoutes(dir, onUpdate) {
+  const watcher = chokidar.watch(dir, {
+    ignored: /([/\\]\.)|(node_modules)|(dist)/,
+    persistent: true,
+    ignoreInitial: true,
+    awaitWriteFinish: {
+      stabilityThreshold: 150,
+      pollInterval: 50
+    }
+  });
+  watcher.on("add", async (filePath) => {
+    const content = readFileSync(filePath, "utf-8");
+    onUpdate("new-file", filePath, content);
+  });
+  watcher.on("change", async (filePath) => {
+    const content = readFileSync(filePath, "utf-8");
+    onUpdate("modify-file", filePath, content);
+  });
+  watcher.on("unlink", (filePath) => {
+    onUpdate("delete-file", filePath, "");
+  });
+}
+__name(watchRoutes, "watchRoutes");
+export {
+  watchRoutes
+};

package/dist/uwebsocket/request.js

@@ -1,6 +1,6 @@
 import {
   __name
-} from "../chunk-NH24FRB3.js";
+} from "../chunk-SHUYVCID.js";
 import { Readable } from "stream";
 import { forEach } from './utils/object.js';
 class HttpRequest extends Readable {

package/dist/uwebsocket/response.js

@@ -1,6 +1,6 @@
 import {
   __name
-} from "../chunk-NH24FRB3.js";
+} from "../chunk-SHUYVCID.js";
 import { Writable } from "stream";
 import { toLowerCase } from "./utils/string.js";
 import HttpResponseSocket from './responseSocket.js';
@@ -50,13 +50,11 @@ class HttpResponse extends Writable {
   }
   //@ts-ignore
   write(data) {
-    if (this.finished)
-      return;
+    if (this.finished) return;
     this.res.write(data);
   }
   writeHead(statusCode) {
-    if (this.finished)
-      return;
+    if (this.finished) return;
     this.statusCode = statusCode;
     let headers;
     if (arguments.length === 2) {
@@ -73,8 +71,7 @@ class HttpResponse extends Writable {
   }
   //@ts-ignore
   end(data) {
-    if (this.finished)
-      return;
+    if (this.finished) return;
     function doWrite(res) {
       res.res.writeStatus(`${res.statusCode} ${res.statusMessage}`);
       res.finished = true;

package/dist/uwebsocket/responseSocket.js

@@ -1,6 +1,6 @@
 import {
   __name
-} from "../chunk-NH24FRB3.js";
+} from "../chunk-SHUYVCID.js";
 class HttpResponseSocket {
   static {
     __name(this, "HttpResponseSocket");

package/dist/uwebsocket/server.js

@@ -1,6 +1,6 @@
 import {
   __name
-} from "../chunk-NH24FRB3.js";
+} from "../chunk-SHUYVCID.js";
 import { EventEmitter } from "node:events";
 const REQUEST_EVENT = "request";
 import HttpRequest from './request.js';
@@ -67,16 +67,14 @@ async function server_default({ cert_file_name, key_file_name }) {
     }
     close(cb) {
       uWS.us_listen_socket_close(uServer._socket);
-      if (!cb)
-        return;
+      if (!cb) return;
       return cb();
     }
     start(host, port, cb) {
       let args;
       const callbackFunction = /* @__PURE__ */ __name(function(socket) {
         uServer._socket = socket;
-        if (cb)
-          cb(socket);
+        if (cb) cb(socket);
       }, "callbackFunction");
       if (host && port && cb) {
         args = [
@@ -103,8 +101,7 @@ async function server_default({ cert_file_name, key_file_name }) {
         host = listenOptions.host;
         return this.start(host, port, (socket) => {
           uServer._socket = socket;
-          if (cb)
-            cb(socket);
+          if (cb) cb(socket);
         });
       } else {
         if ((!port || typeof port === "function") && !cb) {

package/dist/uwebsocket/utils/object.js

@@ -1,6 +1,6 @@
 import {
   __name
-} from "../../chunk-NH24FRB3.js";
+} from "../../chunk-SHUYVCID.js";
 const forEach = /* @__PURE__ */ __name((obj, cb) => {
   const keys = Object.keys(obj);
   for (let i = 0, length = keys.length; i < length; i++) {

package/dist/uwebsocket/utils/string.js

@@ -1,6 +1,6 @@
 import {
   __name
-} from "../../chunk-NH24FRB3.js";
+} from "../../chunk-SHUYVCID.js";
 const toString = /* @__PURE__ */ __name((str) => {
   return str + "";
 }, "toString");

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "owebjs",
-    "version": "1.2.3",
-    "description": "Flexible handler that built on top of Fastify",
+    "version": "1.3.1",
+    "description": "A flexible and modern web framework built on top of Fastify",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
     "exports": {
@@ -32,17 +32,32 @@
     "author": "owebjs",
     "license": "MIT",
     "dependencies": {
-        "fastify": "^4.23.2"
+        "@babel/core": "^7.28.0",
+        "@babel/generator": "^7.28.0",
+        "@babel/parser": "^7.28.0",
+        "@babel/preset-typescript": "^7.27.1",
+        "@babel/traverse": "^7.28.0",
+        "@babel/types": "^7.28.2",
+        "chalk": "^5.4.1",
+        "fastify": "4.23.2",
+        "path-to-regexp": "^8.2.0"
     },
     "devDependencies": {
         "@fastify/multipart": "^8.1.0",
         "@swc/core": "^1.3.85",
-        "@types/node": "^20.6.2",
+        "@types/chokidar": "^2.1.3",
+        "@types/node": "^24.1.0",
+        "chokidar": "^3.5.3",
         "prettier": "^3.0.3",
         "tslib": "^2.6.2",
-        "tsup": "^7.2.0",
+        "tsup": "^8.5.0",
         "typescript": "^5.2.2",
         "uWebSockets.js": "github:uNetworking/uWebSockets.js#v20.10.0"
     },
-    "type": "module"
+    "type": "module",
+    "pnpm": {
+        "onlyBuiltDependencies": [
+            "esbuild"
+        ]
+    }
 }