@gieo/express 1.0.3 → 1.0.5

package/dist/index.js

@@ -169,4 +169,6 @@ var ExpressPlus = /** @class */ (function () {
     };
     return ExpressPlus;
 }());
+// ✅ Export cho cả ES Module và CommonJS
 exports.default = ExpressPlus;
+module.exports = ExpressPlus;

package/dist/test.js

@@ -35,42 +35,73 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 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;
+    var _a, op, numbers, values, 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",
-                            })];
+                _a = _b.sent(), op = _a.op, numbers = __rest(_a, ["op"]);
+                values = Object.values(numbers)
+                    .map(Number)
+                    .filter(function (v) { return !isNaN(v); });
+                if (values.length < 2) {
+                    return [2 /*return*/, res.status(400).json({
+                            statusCode: 400,
+                            success: false,
+                            message: "Need at least two numeric values",
+                        })];
                 }
-                return [2 /*return*/, res.status(200).json({
-                        statusCode: 200,
-                        success: true,
-                        result: result,
-                    })];
+                try {
+                    switch (op) {
+                        case "sum":
+                            result = utils_1.sum.apply(void 0, values);
+                            break;
+                        case "sub":
+                            result = utils_1.sub.apply(void 0, values);
+                            break;
+                        case "mul":
+                            result = utils_1.mul.apply(void 0, values);
+                            break;
+                        case "div":
+                            result = utils_1.div.apply(void 0, values);
+                            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,
+                        })];
+                }
+                catch (err) {
+                    return [2 /*return*/, res.status(500).json({
+                            statusCode: 500,
+                            success: false,
+                            message: err.message,
+                        })];
+                }
+                return [2 /*return*/];
         }
     });
 }); });

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@gieo/express",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "",
-  "main": "./dist/index.js",
+  "main": "./dist/test.js",
   "keywords": [],
   "author": "",
   "license": "ISC",

package/src/index.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const http_1 = require("http");
+const url_1 = require("url");
+class ExpressPlus {
+    constructor() {
+        this.routes = {
+            GET: [],
+            POST: [],
+            PUT: [],
+            PATCH: [],
+            DELETE: [],
+        };
+        this.middlewares = [];
+    }
+    addRoute(method, path, handler) {
+        this.routes[method].push({ path, handler });
+    }
+    use(middleware) {
+        this.middlewares.push(middleware);
+    }
+    get(path, handler) {
+        this.addRoute("GET", path, handler);
+    }
+    post(path, handler) {
+        this.addRoute("POST", path, handler);
+    }
+    put(path, handler) {
+        this.addRoute("PUT", path, handler);
+    }
+    patch(path, handler) {
+        this.addRoute("PATCH", path, handler);
+    }
+    delete(path, handler) {
+        this.addRoute("DELETE", path, handler);
+    }
+    listen(port, callback) {
+        const server = (0, http_1.createServer)((req, res) => {
+            const method = req.method;
+            const parsedUrl = (0, url_1.parse)(req.url || "", true);
+            const pathname = parsedUrl.pathname || "/";
+            const route = this.routes[method].find((r) => r.path === pathname);
+            const extendedReq = req;
+            const extendedRes = res;
+            extendedReq.query = parsedUrl.query;
+            extendedReq.getBody = async () => {
+                if (extendedReq.body)
+                    return extendedReq.body;
+                const chunks = [];
+                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) {
+                extendedRes.statusCode = code;
+                return extendedRes;
+            };
+            extendedRes.json = function (data) {
+                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);
+    }
+}
+exports.default = ExpressPlus;

package/src/index.ts

@@ -23,7 +23,7 @@ interface Route {
   handler: Handler;
 }
 
-export default class ExpressPlus {
+class ExpressPlus {
   private routes: Record<Method, Route[]> = {
     GET: [],
     POST: [],
@@ -132,3 +132,5 @@ export default class ExpressPlus {
     server.listen(port, callback);
   }
 }
+
+export default ExpressPlus;

package/src/test.js

@@ -0,0 +1,106 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = __importDefault(require("./index"));
+const utils_1 = require("@gieo/utils");
+const app = new index_1.default();
+app.post("/calc", async (req, res) => {
+    const { op, ...numbers } = await req.getBody();
+    // Lấy tất cả giá trị số từ body
+    const values = Object.values(numbers)
+        .map(Number)
+        .filter((v) => !isNaN(v));
+    if (values.length < 2) {
+        return res.status(400).json({
+            statusCode: 400,
+            success: false,
+            message: "Need at least two numeric values",
+        });
+    }
+    let result;
+    try {
+        switch (op) {
+            case "sum":
+                result = (0, utils_1.sum)(...values);
+                break;
+            case "sub":
+                result = (0, utils_1.sub)(...values);
+                break;
+            case "mul":
+                result = (0, utils_1.mul)(...values);
+                break;
+            case "div":
+                result = (0, utils_1.div)(...values);
+                break;
+            default:
+                return res.status(400).json({
+                    statusCode: 400,
+                    success: false,
+                    message: "Invalid operator",
+                });
+        }
+        return res.status(200).json({
+            statusCode: 200,
+            success: true,
+            result,
+        });
+    }
+    catch (err) {
+        return res.status(500).json({
+            statusCode: 500,
+            success: false,
+            message: err.message,
+        });
+    }
+});
+// 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) => 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.",
+        });
+    }
+    try {
+        const result = op(a, b);
+        res.status(200).json({ success: true, status: 200, result });
+    }
+    catch (err) {
+        res
+            .status(500)
+            .json({ success: false, status: 500, result: err.message });
+    }
+};
+// 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", 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 = (0, utils_1.div)(a, b);
+    res.status(200).json({ success: true, status: 200, result });
+});
+app.listen(3000, () => {
+    console.log("✅ Server is running at http://localhost:3000");
+});

package/src/test.ts

@@ -3,35 +3,56 @@ import { sum, sub, mul, div } from "@gieo/utils";
 const app = new ExpressPlus();
 
 app.post("/calc", async (req, res) => {
-  const { a, b, op } = await req.getBody();
+  const { op, ...numbers } = 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",
-      });
+  // Lấy tất cả giá trị số từ body
+  const values = Object.values(numbers)
+    .map(Number)
+    .filter((v) => !isNaN(v));
+
+  if (values.length < 2) {
+    return res.status(400).json({
+      statusCode: 400,
+      success: false,
+      message: "Need at least two numeric values",
+    });
   }
 
-  return res.status(200).json({
-    statusCode: 200,
-    success: true,
-    result,
-  });
+  let result: number;
+  try {
+    switch (op) {
+      case "sum":
+        result = sum(...values);
+        break;
+      case "sub":
+        result = sub(...values);
+        break;
+      case "mul":
+        result = mul(...values);
+        break;
+      case "div":
+        result = div(...values);
+        break;
+      default:
+        return res.status(400).json({
+          statusCode: 400,
+          success: false,
+          message: "Invalid operator",
+        });
+    }
+
+    return res.status(200).json({
+      statusCode: 200,
+      success: true,
+      result,
+    });
+  } catch (err: any) {
+    return res.status(500).json({
+      statusCode: 500,
+      success: false,
+      message: err.message,
+    });
+  }
 });
 
 // Các route cơ bản

package/tsconfig.json

@@ -1,6 +1,8 @@
 {
-    "compilerOptions": {
-        "baseUrl": ".",
-        "outDir":"./dist",
-    }
+  "compilerOptions": {
+    "module": "CommonJS",
+    "target": "ES2020",
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+  }
 }