@gieo/express 1.0.0 → 1.0.2

package/dist/index.js

@@ -1,4 +1,47 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 var http_1 = require("http");
 var url_1 = require("url");
@@ -11,10 +54,14 @@ var ExpressPlus = /** @class */ (function () {
             PATCH: [],
             DELETE: [],
         };
+        this.middlewares = [];
     }
     ExpressPlus.prototype.addRoute = function (method, path, handler) {
         this.routes[method].push({ path: path, handler: handler });
     };
+    ExpressPlus.prototype.use = function (middleware) {
+        this.middlewares.push(middleware);
+    };
     ExpressPlus.prototype.get = function (path, handler) {
         this.addRoute("GET", path, handler);
     };
@@ -37,14 +84,86 @@ var ExpressPlus = /** @class */ (function () {
             var parsedUrl = (0, url_1.parse)(req.url || "", true);
             var pathname = parsedUrl.pathname || "/";
             var route = _this.routes[method].find(function (r) { return r.path === pathname; });
-            if (route) {
-                req.query = parsedUrl.query;
-                route.handler(req, res);
-            }
-            else {
-                res.statusCode = 404;
-                res.end("Not Found");
-            }
+            var extendedReq = req;
+            var extendedRes = res;
+            extendedReq.query = parsedUrl.query;
+            extendedReq.getBody = function () { return __awaiter(_this, void 0, void 0, function () {
+                var chunks, _a, extendedReq_1, extendedReq_1_1, chunk, e_1_1, raw;
+                var _b, e_1, _c, _d;
+                return __generator(this, function (_e) {
+                    switch (_e.label) {
+                        case 0:
+                            if (extendedReq.body)
+                                return [2 /*return*/, extendedReq.body];
+                            chunks = [];
+                            _e.label = 1;
+                        case 1:
+                            _e.trys.push([1, 6, 7, 12]);
+                            _a = true, extendedReq_1 = __asyncValues(extendedReq);
+                            _e.label = 2;
+                        case 2: return [4 /*yield*/, extendedReq_1.next()];
+                        case 3:
+                            if (!(extendedReq_1_1 = _e.sent(), _b = extendedReq_1_1.done, !_b)) return [3 /*break*/, 5];
+                            _d = extendedReq_1_1.value;
+                            _a = false;
+                            chunk = _d;
+                            chunks.push(chunk);
+                            _e.label = 4;
+                        case 4:
+                            _a = true;
+                            return [3 /*break*/, 2];
+                        case 5: return [3 /*break*/, 12];
+                        case 6:
+                            e_1_1 = _e.sent();
+                            e_1 = { error: e_1_1 };
+                            return [3 /*break*/, 12];
+                        case 7:
+                            _e.trys.push([7, , 10, 11]);
+                            if (!(!_a && !_b && (_c = extendedReq_1.return))) return [3 /*break*/, 9];
+                            return [4 /*yield*/, _c.call(extendedReq_1)];
+                        case 8:
+                            _e.sent();
+                            _e.label = 9;
+                        case 9: return [3 /*break*/, 11];
+                        case 10:
+                            if (e_1) throw e_1.error;
+                            return [7 /*endfinally*/];
+                        case 11: return [7 /*endfinally*/];
+                        case 12:
+                            raw = Buffer.concat(chunks).toString();
+                            extendedReq.bodyRaw = raw;
+                            try {
+                                extendedReq.body = JSON.parse(raw);
+                            }
+                            catch (_f) {
+                                extendedReq.body = {};
+                            }
+                            return [2 /*return*/, extendedReq.body];
+                    }
+                });
+            }); };
+            extendedRes.status = function (code) {
+                extendedRes.statusCode = code;
+                return extendedRes;
+            };
+            extendedRes.json = function (data) {
+                extendedRes.setHeader("Content-Type", "application/json");
+                extendedRes.end(JSON.stringify(data));
+            };
+            var i = 0;
+            var next = function () {
+                var middleware = _this.middlewares[i++];
+                if (middleware) {
+                    middleware(extendedReq, extendedRes, next);
+                }
+                else if (route) {
+                    route.handler(extendedReq, extendedRes);
+                }
+                else {
+                    extendedRes.status(404).end("Not Found");
+                }
+            };
+            next();
         });
         server.listen(port, callback);
     };

package/dist/test.js

@@ -1,32 +1,151 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 var index_1 = require("./index");
+var utils_1 = require("@gieo/utils");
 var app = new index_1.default();
+app.post("/calc", function (req, res) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, a, b, op, result;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0: return [4 /*yield*/, req.getBody()];
+            case 1:
+                _a = _b.sent(), a = _a.a, b = _a.b, op = _a.op;
+                switch (op) {
+                    case "sum":
+                        result = (0, utils_1.sum)(a, b);
+                        break;
+                    case "sub":
+                        result = (0, utils_1.sub)(a, b);
+                        break;
+                    case "mul":
+                        result = (0, utils_1.mul)(a, b);
+                        break;
+                    case "div":
+                        result = (0, utils_1.div)(a, b);
+                        break;
+                    default:
+                        return [2 /*return*/, res.status(400).json({
+                                statusCode: 400,
+                                success: false,
+                                message: "Invalid operator",
+                            })];
+                }
+                return [2 /*return*/, res.status(200).json({
+                        statusCode: 200,
+                        success: true,
+                        result: result,
+                    })];
+        }
+    });
+}); });
+// Các route cơ bản
 app.get("/", function (req, res) {
-    res.end("Hello, World!");
+    return res.status(200).json({ success: true, status: 200, result: "GET / OK" });
 });
-app.get("/hello", function (req, res) {
-    var name = req.query.name || "Guest";
-    res.end("Hello, ".concat(name, "!"));
+app.put("/", function (req, res) {
+    return res.status(200).json({ success: true, status: 200, result: "PUT / OK" });
 });
-app.post("/data", function (req, res) {
-    var body = "";
-    req.on("data", function (chunk) {
-        body += chunk.toString();
-    });
-    req.on("end", function () {
-        res.end("Received data: ".concat(body));
-    });
+app.post("/", function (req, res) {
+    return res.status(200).json({ success: true, status: 200, result: "POST / OK" });
 });
-app.put("/update", function (req, res) {
-    res.end("Update successful");
+app.patch("/", function (req, res) {
+    return res.status(200).json({ success: true, status: 200, result: "PATCH / OK" });
 });
-app.patch("/modify", function (req, res) {
-    res.end("Modify successful");
-});
-app.delete("/delete", function (req, res) {
-    res.end("Delete successful");
+app.delete("/", function (req, res) {
+    return res.status(200).json({ success: true, status: 200, result: "DELETE / OK" });
 });
+var mathRoute = function (op) { return function (req, res) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, a, b, result;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0: return [4 /*yield*/, req.getBody()];
+            case 1:
+                _a = _b.sent(), a = _a.a, b = _a.b;
+                if (typeof a !== "number" || typeof b !== "number") {
+                    return [2 /*return*/, res.status(400).json({
+                            success: false,
+                            status: 400,
+                            result: "Invalid input. 'a' and 'b' must be numbers.",
+                        })];
+                }
+                try {
+                    result = op(a, b);
+                    res.status(200).json({ success: true, status: 200, result: result });
+                }
+                catch (err) {
+                    res
+                        .status(500)
+                        .json({ success: false, status: 500, result: err.message });
+                }
+                return [2 /*return*/];
+        }
+    });
+}); }; };
+// Math operations
+app.post("/sum", mathRoute(utils_1.sum));
+app.post("/sub", mathRoute(utils_1.sub));
+app.post("/mul", mathRoute(utils_1.mul));
+app.post("/div", function (req, res) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, a, b, result;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0: return [4 /*yield*/, req.getBody()];
+            case 1:
+                _a = _b.sent(), a = _a.a, b = _a.b;
+                if (typeof a !== "number" || typeof b !== "number") {
+                    return [2 /*return*/, res.status(400).json({
+                            success: false,
+                            status: 400,
+                            result: "Invalid input. 'a' and 'b' must be numbers.",
+                        })];
+                }
+                if (b === 0) {
+                    return [2 /*return*/, res
+                            .status(400)
+                            .json({ success: false, status: 400, result: "Cannot divide by zero" })];
+                }
+                result = (0, utils_1.div)(a, b);
+                res.status(200).json({ success: true, status: 200, result: result });
+                return [2 /*return*/];
+        }
+    });
+}); });
 app.listen(3000, function () {
-    console.log("Server is running on http://localhost:3000");
+    console.log("✅ Server is running at http://localhost:3000");
 });

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@gieo/express",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "",
   "main": "index.js",
   "keywords": [],
   "author": "",
   "license": "ISC",
   "devDependencies": {
+    "@gieo/utils": "^1.0.5",
     "@types/node": "^24.2.0",
     "jiti": "^2.5.1",
     "typescript": "^5.9.2"

package/src/index.ts

@@ -1,11 +1,22 @@
 import { createServer, IncomingMessage, ServerResponse } from "http";
 import { parse } from "url";
 
+// Mở rộng Request
+interface ExtendedRequest extends IncomingMessage {
+  query?: Record<string, string | string[]>;
+  bodyRaw?: string;
+  body?: any;
+  getBody: () => Promise<any>;
+}
+
+// Mở rộng Response
+interface ExtendedResponse extends ServerResponse {
+  status: (code: number) => ExtendedResponse;
+  json: (data: any) => void;
+}
+
 type Method = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
-type Handler = (
-  req: IncomingMessage & { query?: any },
-  res: ServerResponse
-) => void;
+type Handler = (req: ExtendedRequest, res: ExtendedResponse) => void;
 
 interface Route {
   path: string;
@@ -21,10 +32,26 @@ export default class ExpressPlus {
     DELETE: [],
   };
 
+  private middlewares: ((
+    req: ExtendedRequest,
+    res: ExtendedResponse,
+    next: () => void
+  ) => void)[] = [];
+
   private addRoute(method: Method, path: string, handler: Handler): void {
     this.routes[method].push({ path, handler });
   }
 
+  use(
+    middleware: (
+      req: ExtendedRequest,
+      res: ExtendedResponse,
+      next: () => void
+    ) => void
+  ): void {
+    this.middlewares.push(middleware);
+  }
+
   get(path: string, handler: Handler): void {
     this.addRoute("GET", path, handler);
   }
@@ -53,13 +80,53 @@ export default class ExpressPlus {
 
       const route = this.routes[method].find((r) => r.path === pathname);
 
-      if (route) {
-        (req as any).query = parsedUrl.query;
-        route.handler(req as any, res);
-      } else {
-        res.statusCode = 404;
-        res.end("Not Found");
-      }
+      const extendedReq = req as ExtendedRequest;
+      const extendedRes = res as ExtendedResponse;
+
+      extendedReq.query = parsedUrl.query;
+      extendedReq.getBody = async () => {
+        if (extendedReq.body) return extendedReq.body;
+
+        const chunks: Buffer[] = [];
+        for await (const chunk of extendedReq) {
+          chunks.push(chunk);
+        }
+
+        const raw = Buffer.concat(chunks).toString();
+        extendedReq.bodyRaw = raw;
+
+        try {
+          extendedReq.body = JSON.parse(raw);
+        } catch {
+          extendedReq.body = {};
+        }
+
+        return extendedReq.body;
+      };
+
+      extendedRes.status = function (code: number) {
+        extendedRes.statusCode = code;
+        return extendedRes;
+      };
+
+      extendedRes.json = function (data: any) {
+        extendedRes.setHeader("Content-Type", "application/json");
+        extendedRes.end(JSON.stringify(data));
+      };
+
+      let i = 0;
+      const next = () => {
+        const middleware = this.middlewares[i++];
+        if (middleware) {
+          middleware(extendedReq, extendedRes, next);
+        } else if (route) {
+          route.handler(extendedReq, extendedRes);
+        } else {
+          extendedRes.status(404).end("Not Found");
+        }
+      };
+
+      next();
     });
 
     server.listen(port, callback);

package/src/test.ts

@@ -1,31 +1,98 @@
 import ExpressPlus from "./index";
+import { sum, sub, mul, div } from "@gieo/utils";
 const app = new ExpressPlus();
 
-app.get("/", (req, res) => {
-  res.end("Hello, World!");
-});
-app.get("/hello", (req, res) => {
-  const name = req.query.name || "Guest";
-  res.end(`Hello, ${name}!`);
-});
-app.post("/data", (req, res) => {
-  let body = "";
-  req.on("data", (chunk) => {
-    body += chunk.toString();
-  });
-  req.on("end", () => {
-    res.end(`Received data: ${body}`);
+app.post("/calc", async (req, res) => {
+  const { a, b, op } = await req.getBody();
+
+  let result: number;
+  switch (op) {
+    case "sum":
+      result = sum(a, b);
+      break;
+    case "sub":
+      result = sub(a, b);
+      break;
+    case "mul":
+      result = mul(a, b);
+      break;
+    case "div":
+      result = div(a, b);
+      break;
+    default:
+      return res.status(400).json({
+        statusCode: 400,
+        success: false,
+        message: "Invalid operator",
+      });
+  }
+
+  return res.status(200).json({
+    statusCode: 200,
+    success: true,
+    result,
   });
 });
-app.put("/update", (req, res) => {
-  res.end("Update successful");
-});
-app.patch("/modify", (req, res) => {
-  res.end("Modify successful");
-});
-app.delete("/delete", (req, res) => {
-  res.end("Delete successful");
+
+// Các route cơ bản
+app.get("/", (req, res) =>
+  res.status(200).json({ success: true, status: 200, result: "GET / OK" })
+);
+app.put("/", (req, res) =>
+  res.status(200).json({ success: true, status: 200, result: "PUT / OK" })
+);
+app.post("/", (req, res) =>
+  res.status(200).json({ success: true, status: 200, result: "POST / OK" })
+);
+app.patch("/", (req, res) =>
+  res.status(200).json({ success: true, status: 200, result: "PATCH / OK" })
+);
+app.delete("/", (req, res) =>
+  res.status(200).json({ success: true, status: 200, result: "DELETE / OK" })
+);
+
+const mathRoute =
+  (op: (a: number, b: number) => number) => async (req: any, res: any) => {
+    const { a, b } = await req.getBody();
+    if (typeof a !== "number" || typeof b !== "number") {
+      return res.status(400).json({
+        success: false,
+        status: 400,
+        result: "Invalid input. 'a' and 'b' must be numbers.",
+      });
+    }
+
+    try {
+      const result = op(a, b);
+      res.status(200).json({ success: true, status: 200, result });
+    } catch (err: any) {
+      res
+        .status(500)
+        .json({ success: false, status: 500, result: err.message });
+    }
+  };
+
+// Math operations
+app.post("/sum", mathRoute(sum));
+app.post("/sub", mathRoute(sub));
+app.post("/mul", mathRoute(mul));
+app.post("/div", async (req, res) => {
+  const { a, b } = await req.getBody();
+  if (typeof a !== "number" || typeof b !== "number") {
+    return res.status(400).json({
+      success: false,
+      status: 400,
+      result: "Invalid input. 'a' and 'b' must be numbers.",
+    });
+  }
+  if (b === 0) {
+    return res
+      .status(400)
+      .json({ success: false, status: 400, result: "Cannot divide by zero" });
+  }
+  const result = div(a, b);
+  res.status(200).json({ success: true, status: 200, result });
 });
 app.listen(3000, () => {
-  console.log("Server is running on http://localhost:3000");
+  console.log("✅ Server is running at http://localhost:3000");
 });