Node js basics assignment

.gitignore

@@ -0,0 +1,3 @@
+node_modules/
+.idea/
+package-lock.json

package.json

@@ -39,5 +39,14 @@
   "bugs": {
     "url": "https://github.com/AlreadyBored/node-nodejs-basics/issues"
   },
-  "homepage": "https://github.com/AlreadyBored/node-nodejs-basics#readme"
+  "homepage": "https://github.com/AlreadyBored/node-nodejs-basics#readme",
+  "dependencies": {
+    "crypto": "^1.0.1",
+    "fs": "^0.0.1-security",
+    "http": "^0.0.1-security",
+    "os": "^0.1.2",
+    "path": "^0.12.7",
+    "stream": "^0.0.2",
+    "zlib": "^1.0.5"
+  }
 }

src/cli/args.js

@@ -1,5 +1,11 @@
 const parseArgs = () => {
-    // Write your code here 
-};
+    const result = [];
+    const agrsResult = process.argv;
+    agrsResult.splice(0,2);
+    for (let i = 0; i < agrsResult.length; i += 2) {
+        result.push(`${agrsResult[i]} is ${agrsResult[i + 1]}`)
+    }
+    console.log(result.join(', '))
+}
 
 parseArgs();

src/cli/env.js

@@ -1,5 +1,10 @@
 const parseEnv = () => {
-    // Write your code here 
+    const rssKeys = Object.keys(process.env).filter((key) => key.match(/^RSS_/gm));
+    const result = [];
+    for (let rssKey of rssKeys) {
+        result.push(`${rssKey}=${process.env[rssKey]}`);
+    }
+    console.log(result.join('; '));
 };
 
 parseEnv();

src/cp/cp.js

@@ -1,6 +1,9 @@
+import cp from 'child_process';
+
 const spawnChildProcess = async (args) => {
-    // Write your code here
+    const child = cp.spawn('node', ['src/cp/files/script.js', ...args], {stdio: 'inherit'});
+    child.on('error', (err) => console.log(err));
 };
 
 // Put your arguments in function call to test this functionality
-spawnChildProcess( /* [someArgument1, someArgument2, ...] */);
+spawnChildProcess(['--example', '--example2']);

src/fs/copy.js

@@ -1,5 +1,12 @@
+import * as fs from 'fs';
+
+const errorMessage = 'FS operation failed';
+
 const copy = async () => {
-    // Write your code here 
+    await fs.promises.access('src/fs/files_copy')
+        .then(() => console.log(errorMessage))
+        .catch(async() => await fs.promises.cp('src/fs/files', 'src/fs/files_copy', { errorOnExist: true, recursive: true}))
+        .catch(() => console.log(errorMessage))
 };
 
 await copy();

src/fs/create.js

@@ -1,5 +1,9 @@
+import * as fs from 'fs';
+
 const create = async () => {
-    // Write your code here 
+    await fs.promises.writeFile('src/fs/files/fresh.txt', 'I am fresh and young', {flag: 'ax'}).catch((err) => {
+        console.log('FS operation failed');
+    });
 };
 
 await create();

src/fs/delete.js

@@ -1,5 +1,9 @@
+import * as fs from 'fs';
+
+const errorMessage = 'FS operation failed';
+
 const remove = async () => {
-    // Write your code here 
+    await fs.promises.rm('src/fs/files/fileToRemove.txt').catch(() => console.log(errorMessage));
 };
 
 await remove();

src/fs/list.js

@@ -1,5 +1,13 @@
+import * as fs from 'fs';
+
+const errorMessage = 'FS operation failed';
+
 const list = async () => {
-    // Write your code here 
+    await fs.promises.readdir('src/fs/files').then((files) => {
+        for (let file of files) {
+            console.log(file);
+        }
+    }).catch(() => console.log(errorMessage));
 };
 
 await list();

src/fs/read.js

@@ -1,5 +1,11 @@
-const read = async () => {
-    // Write your code here 
+import * as fs from 'fs';
+
+const errorMessage = 'FS operation failed';
+
+const read = async () => {0
+    await fs.promises.readFile('src/fs/files/fileToRead.txt', {encoding: 'utf8'})
+        .then((data) => console.log(data))
+        .catch(() => console.log(errorMessage));
 };
 
 await read();

src/fs/rename.js

@@ -1,5 +1,13 @@
+import * as fs from 'fs';
+
+const errorMessage = 'FS operation failed';
+
 const rename = async () => {
-    // Write your code here 
+    await fs.promises.access('src/fs/files/wrongFilename.txt').then(async () => {
+        return await fs.promises.access('src/fs/files/properFilename.md')
+        .then(() => console.log(errorMessage))
+        .catch(async () => await fs.promises.rename('src/fs/files/wrongFilename.txt', 'src/fs/files/properFilename.md'))
+    }).catch(() => console.log(errorMessage));
 };
 
 await rename();

src/hash/calcHash.js

@@ -1,5 +1,17 @@
+import { createHash } from "crypto";
+import * as fs from 'fs';
+
+
 const calculateHash = async () => {
-    // Write your code here 
+    const hash = createHash("sha256");
+    const readStream = fs.createReadStream('src/hash/files/fileToCalculateHashFor.txt');
+    readStream.on('data', (chunk) => {
+        hash.update(chunk);
+    });
+    readStream.on('end', () => {
+        console.log(hash.digest("hex"));
+    })
+
 };
 
 await calculateHash();

src/modules/cjsToEsm.cjs → src/modules/esm.mjs

@@ -1,16 +1,22 @@
-const path = require('path');
-const { release, version } = require('os');
-const { createServer: createServerHttp } = require('http');
-require('./files/c');
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { release, version } from 'os';
+import { createServer as createServerHttp } from 'http';
+import('./files/c.js');
+import aFile from "./files/a.json" assert { type: "json" };
+import bFile from "./files/b.json" assert { type: "json" };
+
 
 const random = Math.random();
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
 
-let unknownObject;
+export let unknownObject;
 
 if (random > 0.5) {
-    unknownObject = require('./files/a.json');
+    unknownObject = aFile;
 } else {
-    unknownObject = require('./files/b.json');
+    unknownObject = bFile;
 }
 
 console.log(`Release ${release()}`);
@@ -20,7 +26,7 @@ console.log(`Path segment separator is "${path.sep}"`);
 console.log(`Path to current file is ${__filename}`);
 console.log(`Path to current directory is ${__dirname}`);
 
-const myServer = createServerHttp((_, res) => {
+export const myServer = createServerHttp((_, res) => {
     res.end('Request accepted');
 });
 
@@ -32,9 +38,3 @@ myServer.listen(PORT, () => {
     console.log(`Server is listening on port ${PORT}`);
     console.log('To terminate it, use Ctrl+C combination');
 });
-
-module.exports = {
-    unknownObject,
-    myServer,
-};
-

src/streams/read.js

@@ -1,5 +1,10 @@
+import * as fs from 'fs';
+
 const read = async () => {
-    // Write your code here 
+    const readableStream = fs.createReadStream('src/streams/files/fileToRead.txt');
+    readableStream.on('data', (chunk) => {
+        process.stdout.write(chunk.toString());
+    })
 };
 
 await read();

src/streams/transform.js

@@ -1,5 +1,14 @@
+import { Transform } from "stream";
+
 const transform = async () => {
-    // Write your code here 
+
+    const reverse = new Transform({
+        transform(chunk, encoding, callback) {
+          callback(null,  chunk.toString().split('').reverse().join(''));
+        },
+    });
+
+    process.stdin.pipe(reverse).pipe(process.stdout);
 };
 
 await transform();

src/streams/write.js

@@ -1,5 +1,11 @@
+import * as fs from 'fs';
+
 const write = async () => {
-    // Write your code here 
+    const writableStream = fs.createWriteStream('src/streams/files/fileToWrite.txt');
+
+    process.stdin.on('data', data => { 
+        writableStream.write(data.toString());
+      });
 };
 
 await write();

src/wt/main.js

@@ -1,5 +1,41 @@
+import os from 'os';
+import { Worker } from 'worker_threads';
+import path from 'path';
+
+const numberOfWorkers = os.cpus().length;
+const fullPath = path.resolve('src/wt/worker.js');
+
+function createPromise(workerData) {
+    return new Promise((resolve, reject) => {
+        const worker = new Worker(fullPath, { workerData });
+        worker.on('message', resolve);
+        worker.on('error', reject);
+    });
+}
+
 const performCalculations = async () => {
-    // Write your code here
+    const array = [];
+
+    for (let i = 0; i < numberOfWorkers; i++) {
+        array.push(createPromise(10 + i));
+    }
+
+    await Promise.allSettled(array).then((results) => {
+        const consoleResponse = results.map((result) => {
+            if (result.status === 'fulfilled') {
+                return {
+                    status: 'resolved',
+                    data: result.value
+                };
+            } else if (result.status === 'rejected') {
+                return {
+                    status: 'error',
+                    data: null
+                };
+            }
+        });
+        console.log(consoleResponse);
+    });
 };
 
 await performCalculations();

src/wt/worker.js

@@ -1,8 +1,10 @@
+import { workerData, parentPort } from 'worker_threads';
+
 // n should be received from main thread
 const nthFibonacci = (n) => n < 2 ? n : nthFibonacci(n - 1) + nthFibonacci(n - 2);
 
 const sendResult = () => {
-    // This function sends result of nthFibonacci computations to main thread
+    parentPort.postMessage(nthFibonacci(workerData));
 };
 
 sendResult();

src/zip/compress.js

@@ -1,5 +1,12 @@
+import {createGzip} from 'zlib';
+import * as fs from 'fs';
+
 const compress = async () => {
-    // Write your code here 
+    const gzip = createGzip();
+    const readableStream = fs.createReadStream('src/zip/files/fileToCompress.txt');
+    const writableStream = fs.createWriteStream('src/zip/files/archive.gz');
+
+    readableStream.pipe(gzip).pipe(writableStream);
 };
 
 await compress();

src/zip/decompress.js

@@ -1,5 +1,12 @@
+import {createGunzip} from 'zlib';
+import * as fs from 'fs';
+
 const decompress = async () => {
-    // Write your code here 
+    const gunzip = createGunzip();
+    const readableStream = fs.createReadStream('src/zip/files/archive.gz');
+    const writableStream = fs.createWriteStream('src/zip/files/fileToCompress.txt');
+
+    readableStream.pipe(gunzip).pipe(writableStream);
 };
 
 await decompress();