mate-academy · silcki · Jul 9, 2024 · Jul 9, 2024
diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json
@@ -18,7 +18,7 @@
   "devDependencies": {
     "@faker-js/faker": "^8.4.1",
     "@mate-academy/eslint-config": "latest",
-    "@mate-academy/scripts": "^1.7.3",
+    "@mate-academy/scripts": "^1.8.1",
     "axios": "^1.6.7",
     "eslint": "^7.32.0",
     "eslint-plugin-jest": "^22.4.1",

diff --git a/public/index.html b/public/index.html
@@ -0,0 +1,34 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8">
+    <title>Compression App</title>
+  </head>
+  <body>
+    <form id="compressionForm" enctype="multipart/form-data" method="post" action="/compress">
+      <div>
+        <label for="file">
+          Select a file:
+          <input type="file" id="file" name="file" required>
+        </label>
+      </div>
+
+
+      <div>
+        <label for="compressionType">
+          Select compression type:
+          <select id="compressionType" name="compressionType" required>
+            <option value="gzip">GZIP</option>
+            <option value="deflate">Deflate</option>
+            <option value="br">Brotli</option>
+          </select>
+        </label>
+      </div>
+
+
+      <div>
+        <button type="submit">Compress</button>
+      </div>
+    </form>
+  </body>
+</html>
diff --git a/src/controllers/AbstractController.js b/src/controllers/AbstractController.js
@@ -0,0 +1,10 @@
+'use strict';
+
+class AbstractController {
+  constructor(request, response) {
+    this.request = request;
+    this.response = response;
+  }
+}
+
+module.exports = AbstractController;
diff --git a/src/controllers/CompressController.js b/src/controllers/CompressController.js
@@ -0,0 +1,73 @@
+'use strict';
+
+const fs = require('fs');
+const zlib = require('zlib');
+const { pipeline } = require('stream');
+const formidable = require('formidable');
+
+const AbstractController = require('./AbstractController');
+
+class CompressController extends AbstractController {
+  index() {
+    const form = new formidable.IncomingForm();
+
+    form.uploadDir = '/tmp';
+    form.keepExtensions = true;
+
+    // eslint-disable-next-line max-len
+    form.parse(
+      this.request,
+      (err, { compressionType: fields }, { file: files }) => {
+        if (err || !fields || !files) {
+          this.response.writeHead(400, { 'Content-Type': 'text/plain' });
+          this.response.end('Error uploading file');
+
+          return;
+        }
+
+        const [compressionType] = fields;
+        const [file] = files;
+
+        if (!['gzip', 'deflate', 'br'].includes(compressionType)) {
+          this.response.statusCode = 400;
+          this.response.end('Compression type not supported');
+
+          return;
+        }
+
+        const fileStream = fs.createReadStream(file.filepath);
+        let gzipStream;
+
+        switch (compressionType) {
+          case 'deflate':
+            gzipStream = zlib.createDeflate();
+            break;
+          case 'br':
+            gzipStream = zlib.createBrotliCompress();
+            break;
+          default:
+            gzipStream = zlib.createGzip();
+        }
+
+        pipeline(fileStream, gzipStream, this.response, () => {
+          this.response.statusCode = 500;
+          this.response.end('Server Error');
+        });
+
+        this.response.on('close', () => {
+          fileStream.destroy();
+        });
+
+        this.response.on('error', () => fileStream.destroy());
+        this.response.statusCode = 200;
+
+        this.response.setHeader(
+          'Content-Disposition',
+          `attachment; filename=${file.originalFilename}.${compressionType}`,
+        );
+      },
+    );
+  }
+}
+
+module.exports = CompressController;
diff --git a/src/controllers/IndexController.js b/src/controllers/IndexController.js
@@ -0,0 +1,23 @@
+'use strict';
+
+const fs = require('fs');
+const AbstractController = require('./AbstractController');
+
+class IndexController extends AbstractController {
+  index() {
+    fs.readFile(`./public/index.html`, (err, data) => {
+      if (!err) {
+        this.response.statusCode = 200;
+        this.response.setHeader('Content-Type', 'text/html; charset=utf-8');
+        this.response.end(data);
+
+        return;
+      }
+
+      this.response.statusCode = 404;
+      this.response.end('File not found');
+    });
+  }
+}
+
+module.exports = IndexController;
diff --git a/src/controllers/index.js b/src/controllers/index.js
@@ -0,0 +1,7 @@
+const IndexController = require('./IndexController');
+const CompressController = require('./CompressController');
+
+module.exports = {
+  IndexController,
+  CompressController,
+};
diff --git a/src/createServer.js b/src/createServer.js
@@ -1,8 +1,25 @@
 'use strict';
 
+const http = require('http');
+
+const RouteResolver = require('./router/RouteResolver');
+const NotFoundException = require('./exceptions/NotFoundException');
+
 function createServer() {
-  /* Write your code here */
-  // Return instance of http.Server class
+  return http.createServer((req, res) => {
+    try {
+      const routeResolver = new RouteResolver(req, res);
+
+      const controller = routeResolver.resolve();
+
+      controller.index();
+    } catch (error) {
+      if (error instanceof NotFoundException) {
+        res.statusCode = error.statusCode;
+        res.end(error.message);
+      }
+    }
+  });
 }
 
 module.exports = {

diff --git a/src/exceptions/NotFoundException.js b/src/exceptions/NotFoundException.js
@@ -0,0 +1,12 @@
+'use strict';
+
+class NotFoundException extends Error {
+  constructor(message, statusCode = 404) {
+    super(message);
+    this.name = this.constructor.name;
+    this.statusCode = statusCode;
+    Error.captureStackTrace(this, this.constructor);
+  }
+}
+
+module.exports = NotFoundException;
diff --git a/src/router/RouteResolver.js b/src/router/RouteResolver.js
@@ -0,0 +1,48 @@
+'use strict';
+
+const NotFoundException = require('../exceptions/NotFoundException');
+const { IndexController, CompressController } = require('../controllers');
+
+class RouteResolver {
+  constructor(request, response) {
+    this.request = request;
+    this.response = response;
+
+    this.routes = [
+      {
+        path: ['/', '/index.html'],
+        method: 'GET',
+        controller: IndexController,
+        code: 404,
+      },
+      {
+        path: ['/compress'],
+        method: 'POST',
+        controller: CompressController,
+        code: 400,
+      },
+    ];
+
+    const protocol = this.request.socket.encrypted ? 'https' : 'http';
+    const hostName = `${protocol}://${this.request.headers.host}${this.request.url}`;
+
+    this.parsedUrl = new URL(hostName);
+  }
+  resolve() {
+    for (const route of this.routes) {
+      if (route.path.includes(this.parsedUrl.pathname)) {
+        if (route.method !== this.request.method) {
+          throw new NotFoundException('Wrong method', route.code);
+        }
+
+        const ControllerName = route.controller;
+
+        return new ControllerName(this.request, this.response);
+      }
+    }
+
+    throw new NotFoundException('Route Not Found');
+  }
+}
+
+module.exports = RouteResolver;