First commit

Author: sombo20

restApi/.env

@@ -0,0 +1,6 @@
+#main path to static file and upload file
+PATH_PUBLIC = public
+
+#server configuration
+SERVER_PORT=5000
+SERVER_HOST=localhost

restApi/app/controllers/userController.js

@@ -0,0 +1,26 @@
+import { index, store, show, update, destroy } from "#service/userService";
+
+export async function listUsers(req,res){
+	const usersList = await index();
+	res.json(usersList);
+}
+
+export async function getUser(req,res){
+	const userInfo = await show(req.params.id);
+	userInfo ? res.json(userInfo) : res.json({msg:"User not found..."});
+}
+
+export async function deleteUser(req,res){
+	const userDelete = await destroy(req.body.id);
+	userDelete ? res.json({msg:"user deleted"}) : res.json({msg:"user don`t exist"}); 
+}
+
+export async function newUser(req,res){
+	const createUser = await store(req.body);
+	createUser ? res.json({msg:"User created"}) : res.json({msg:"user not created"});
+}
+
+export async function updateUser(req,res){
+	const userUpdate = await update(req.body.id,req.body);
+	userUpdate ? res.json({msg:"User updated"}) : res.json({msg:"User dont updated"});
+}

restApi/app/middlewares/authApi.js

@@ -0,0 +1,9 @@
+export function auth(req, res, next) {
+  const isAuth = req.headers.authorization && req.headers.authorization.includes("Bearer") ? true : false 
+  
+  if (isAuth) {
+    next();
+  } else {
+    res.json({message:"You`re almost hacked this API ,you is embryo soldier!, token Bearer required"});
+  }
+}

restApi/app/models/user.js

@@ -0,0 +1,46 @@
+const user = [
+    {
+        "id":"255261",
+        "name":"John",
+        "email":"[email protected]",
+        "country":"Canada",
+        "photo":"https://randomuser.me/api/portraits/men/77.jpg"
+    },
+    {
+        "id":"226195",
+        "name":"David",
+        "email":"[email protected]",
+        "country":"Japan",
+        "photo":"https://randomuser.me/api/portraits/men/68.jpg"
+    },
+    {
+        "id":"493672",
+        "name":"Alice",
+        "email":"[email protected]",
+        "country":"Japan",
+        "photo":"https://randomuser.me/api/portraits/women/42.jpg"
+    },
+    {
+        "id":"703642",
+        "name":"Daniel",
+        "email":"[email protected]",
+        "country":"Canada",
+        "photo":"https://randomuser.me/api/portraits/women/55.jpg"
+    },
+    {
+        "id":"775456",
+        "name":"Emily",
+        "email":"[email protected]",
+        "country":"Canada",
+        "photo":"https://randomuser.me/api/portraits/men/88.jpg"
+    },
+    {
+        "id":"989409",
+        "name":"Michael",
+        "email":"[email protected]",
+        "country":"Australia",
+        "photo":"https://randomuser.me/api/portraits/women/46.jpg"
+    }
+]
+
+export default user;

restApi/app/services/userService.js

@@ -0,0 +1,41 @@
+import  user  from "#model/user";
+
+async function index() {
+  return user;
+}
+
+async function store(data) {
+  user.push(data);
+  return data;
+}
+
+async function show(id) {
+  const item = user.find(item => item.id === id);
+  return item;
+}
+
+async function update(id, data) {
+  const indexToUpdate = user.findIndex(item => item.id === id);
+  if (indexToUpdate !== -1) {
+    user[indexToUpdate] = { ...user[indexToUpdate], ...data };
+    return user[indexToUpdate];
+  }
+  return null;
+}
+
+async function destroy(id) {
+  const indexToDelete = user.findIndex(item => item.id === id);
+  if (indexToDelete !== -1) {
+    const deletedItem = user.splice(indexToDelete, 1);
+    return deletedItem[0];
+  }
+  return null;
+}
+
+export {
+  index,
+  store,
+  show,
+  update,
+  destroy,
+};

restApi/config/headers.js

@@ -0,0 +1,5 @@
+export function configHeaders(request, response){
+
+	response.setHeader('Access-Control-Allow-Origin', '*');
+    //here add more headers...
+}

restApi/index.js

@@ -0,0 +1,2 @@
+import { runApp } from "#app"
+runApp();

restApi/lib/core/handlers.js

@@ -0,0 +1,109 @@
+// handler.js
+import parseRequestBody from "./parseRequestBody.js";
+import { routes, get, post, put, delet } from "./routes.js";
+import { logger } from "#utils/logs";
+import { handleNotFound, handleBadRequest, handleMethodNotAllowed } from "#status";
+import { renderFile } from "./renderFile.js";
+import { configHeaders } from "#config/headers";
+
+async function handleRequest(request, response) {
+  const { url, method } = request;
+
+  renderFile(request,response);
+  configHeaders(request,response);
+  
+   if (method === 'OPTIONS') {
+     response.writeHead(200, {
+      'Access-Control-Allow-Origin': '*',
+      'Access-Control-Allow-Headers': 'Authorization, Content-Type,X-Requested-With'
+    });
+    response.end();
+    return;
+  }
+
+  async function status(body){
+    response.statusCode = body;
+  }
+
+  async function log(...messages) {
+    console.log(...messages);
+  }
+
+  async function send(body) {
+    response.end(body.toString());
+  }
+
+  async function setHeader(body,value){
+     response.setHeader(body,value);
+  }
+
+  async function go(path){
+    response.writeHead(302, { Location:path});    
+    response.end();
+  }
+   
+
+
+  async function json(data) {
+    response.writeHead(200, { "Content-Type": "application/json"});
+    response.end(JSON.stringify(data));
+  }
+
+
+  const customResponse = { log, send, json, setHeader, status, go};
+
+  let routeFound = false;
+  for (const route of routes) {
+    const match = url.match(route.regexPath);
+
+    if (match) {
+      routeFound = true;
+      if (route.method === method) {
+
+         if (method === "POST" || method === "PUT" || method === "DELETE") {
+          try {
+            const body = await parseRequestBody(request);
+            request.body = body.data;
+          } catch (error) {
+            await logger.error("Error parsing request body:" + error);
+            return handleBadRequest(request, customResponse);
+          }
+        }
+
+        const param = {};
+        for (let i = 0; i < route.paramNames.length; i++) {
+          const paramName = route.paramNames[i];
+          param[paramName] = match[i + 1];
+        }
+
+        request.params = param;
+        request.cookies = "";
+        
+        await runMiddlewares(request, customResponse, route.handlers);
+        return;
+      } else if (method === "GET" && route.method === "POST" || route.method === "DELETE" || route.method === "PUT") {
+        return await handleMethodNotAllowed(request, customResponse, route.method);
+      }else if (method === "POST" || method === "DELETE" || method === "PUT" && route.method === "GET") {
+        return await handleMethodNotAllowed(request, customResponse, route.method);
+      }
+    }
+  }
+
+  if (!routeFound) {
+    await handleNotFound(request, customResponse);
+  }
+}
+
+async function runMiddlewares(request, customResponse, handlers) {
+  if (!handlers || handlers.length === 0) {
+    return;
+  }
+
+  const currentHandler = handlers[0];
+
+  await currentHandler(request, customResponse, async () => {
+    await runMiddlewares(request, customResponse, handlers.slice(1));
+  });
+}
+
+export { handleRequest, get, post, put, delet };

restApi/lib/core/parseRequestBody.js

@@ -0,0 +1,83 @@
+import Busboy from "busboy";
+import fs from 'fs';
+
+/**
+ * Parses the request body based on the content type.
+ * Supports multipart/form-data and application/json content types.
+ * @param {http.IncomingMessage} req - The request object.
+ * @returns {Promise} - A promise that resolves to the parsed data.
+ */
+
+export default async function parseRequestBody(req) {
+  return new Promise((resolve, reject) => {
+    const contentType = req.headers["content-type"];
+    let data = "";
+
+    if (contentType && contentType.startsWith("multipart/form-data")) {
+      // Parsing multipart/form-data
+      const boundaryMatch = contentType.match(/boundary=(?:"([^"]+)"|([^;]+))/i);
+      const boundary = boundaryMatch ? boundaryMatch[1] || boundaryMatch[2] : undefined;
+
+      if (!boundary) {
+        reject(new Error('Boundary not found in the content-type header.'));
+        return;
+      }
+
+      const busboy = Busboy({ headers: req.headers, boundary });
+      const formData = { fields: {}, files: {} };
+
+      busboy.on('field', (fieldname, val) => {
+        formData.fields[fieldname] = val;
+      });
+
+      busboy.on('file', (fieldname, file, filename, encoding, mimetype) => {
+        const chunks = [];
+        file.on('data', (chunk) => {
+          chunks.push(chunk);
+        });
+
+        file.on('end', () => {
+          formData.files[fieldname] = {
+            filename,
+            encoding,
+            mimetype,
+            data: Buffer.concat(chunks),
+          };
+        });
+      });
+
+      busboy.on('finish', () => {
+        const data = formData.fields ? formData.fields : {};
+        const files = formData.files ? formData.files : {};
+        resolve({ data: { data, files } });
+      });
+
+      busboy.on('error', (err) => {
+        reject(err);
+      });
+
+      req.pipe(busboy);
+    } else if (contentType && contentType.startsWith("application/json")) {
+      // Parsing application/json
+      req.on("data", (chunk) => {
+        data += chunk.toString();
+      });
+
+      req.on("end", () => {
+        try {
+          const jsonData = JSON.parse(data);
+          resolve({ data: jsonData });
+        } catch (err) {
+          reject(err);
+        }
+      });
+    } else {
+      // Unsupported content type
+      reject(new Error("Unsupported content type."));
+    }
+
+    req.on("error", (err) => {
+      reject(err);
+    });
+  });
+}

restApi/lib/core/renderFile.js

@@ -0,0 +1,55 @@
+import fs from 'fs';
+import { dirname, extname, join } from 'path';
+import { fileURLToPath } from 'url';
+
+/**
+ * Renders a file in the response based on the request URL.
+ * @param {http.IncomingMessage} request - The request object.
+ * @param {http.ServerResponse} response - The response object.
+ */
+
+export function renderFile(request, response) {
+  const currentFileUrl = import.meta.url;
+  const currentFilePath = dirname(fileURLToPath(currentFileUrl));
+  const pathPublic = process.env.PATH_PUBLIC;
+  const publicPath = join(currentFilePath, pathPublic).replace('/lib/core', '');
+
+  const filePath = join(publicPath, request.url.replace(/\.\.\//g, ''));
+
+  fs.stat(filePath, (err, stats) => {
+    if (err || !stats.isFile()) {
+      return;
+    }
+
+    const contentType = getContentType(filePath);
+    response.writeHead(200, { 'Content-Type': contentType });
+    fs.createReadStream(filePath).pipe(response);
+  });
+}
+
+/**
+ * Gets the content type based on the file extension.
+ * @param {string} filePath - The path to the file.
+ * @returns {string} - The content type.
+ */
+
+function getContentType(filePath) {
+  const ext = extname(filePath);
+  switch (ext) {
+    case '.html':
+      return 'text/html';
+    case '.js':
+      return 'text/javascript';
+    case '.css':
+      return 'text/css';
+    case '.jpeg':
+    case '.jpg':
+      return 'image/jpeg';
+    case '.png':
+      return 'image/png';
+    case '.gif':
+      return 'image/gif';
+    default:
+      return 'application/octet-stream';
+  }
+}