Task1

src/cli/args.js

@@ -1,5 +1,10 @@
 const parseArgs = () => {
-    // Write your code here 
+    // Write your code here
+    console.log(process.argv.slice(2)
+        .filter(value => value.startsWith('--'))
+        // map modified argument key (without '--') with argument value (find index of key and increment it to get next argv)
+        .map(value => `${value.replace('--', '')} is ${process.argv[process.argv.findIndex(value1 => value1 === value) + 1]}`)
+        .join(', '));
 };
 
 parseArgs();

src/cli/env.js

@@ -1,5 +1,9 @@
 const parseEnv = () => {
-    // Write your code here 
+    // Write your code here
+    console.log(Object.entries(process.env)
+        .filter(([key,value], index) => key.startsWith('RSS_'))
+        .map(([key,value],index) => `${key}=${value}` )
+        .join('; '));
 };
 
 parseEnv();

src/cp/cp.js

@@ -1,6 +1,20 @@
+import * as child_process from "node:child_process";
+import {fileURLToPath} from "url";
+import path from "path";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const fileName = path.join(__dirname, 'files', 'script.js');
+
 const spawnChildProcess = async (args) => {
     // Write your code here
+    let child = child_process.fork(fileName, args, {
+        stdio: ["pipe", "pipe", "pipe", "ipc"],
+    });
+
+    process.stdin.pipe(child.stdin);
+    child.stdout.pipe(process.stdout);
 };
 
 // Put your arguments in function call to test this functionality
-spawnChildProcess( /* [someArgument1, someArgument2, ...] */);
+await spawnChildProcess(['qwerty', 3]);

src/fs/copy.js

@@ -1,5 +1,27 @@
+import {existsSync} from 'node:fs';
+import {cp} from 'node:fs/promises';
+import {fileURLToPath} from 'url';
+import {dirname, join} from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const sourceDir = join(__dirname, 'files');
+const destDir = join(__dirname, 'files_copy');
+const sourceExists = existsSync(sourceDir);
+const destExists = existsSync(destDir);
+
 const copy = async () => {
     // Write your code here 
+    if(!sourceExists || destExists) {
+        throw new Error('FS operation failed');
+    }
+    cp(sourceDir, destDir, {recursive: true})
+        .then(() => {
+            console.log('Files copied successfully!');
+        })
+        .catch((error) => {
+            console.error('Error copying files:', error);
+        });    
 };
 
 await copy();

src/fs/create.js

@@ -1,5 +1,26 @@
+import {existsSync, constants, writeFileSync, access} from 'node:fs';
+import {mkdir} from 'node:fs/promises';
+import {fileURLToPath} from 'url';
+import {dirname, join} from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const fileDirname = join(__dirname, 'files');
+const filePath = join(fileDirname, 'fresh.txt');
+
 const create = async () => {
-    // Write your code here 
+    // Write your code here
+    access(filePath, constants.F_OK, async (err) => {
+        // If file exists, throw an error
+        if (!err)
+            throw new Error('FS operation failed');
+        if (!existsSync(fileDirname)) await mkdir(fileDirname, {recursive: true});
+        writeFileSync(filePath, 'I am fresh and young', (error) => {
+            if (error) throw error;
+        });
+        console.log('fresh.txt filled successfully!');
+
+    });
 };
 
 await create();

src/fs/delete.js

@@ -1,5 +1,18 @@
+import {fileURLToPath} from "url";
+import {dirname, join} from "path";
+import {existsSync, unlink} from "node:fs"
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const filePath = join(__dirname, 'files', 'fileToRemove.txt');
+
 const remove = async () => {
-    // Write your code here 
+    // Write your code here
+    if (!existsSync(filePath)) throw new Error('FS operation failed');
+    await unlink(filePath, (error) => {
+        if (error) throw error;
+        console.log('File successfully removed');
+    });
 };
 
 await remove();

src/fs/list.js

@@ -1,5 +1,18 @@
+import {fileURLToPath} from "url";
+import {dirname, join} from "path";
+import fs from "node:fs"
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const fileDirname = join(__dirname, 'files');
+
 const list = async () => {
-    // Write your code here 
+    // Write your code here
+    if(!fs.existsSync(fileDirname)) throw new Error('FS operation failed');
+    fs.readdir(fileDirname, (err, files) => {
+        if(err) throw err;
+        console.log(files);
+    })
 };
 
 await list();

src/fs/read.js

@@ -1,5 +1,20 @@
+import {fileURLToPath} from "url";
+import {dirname, join} from "path";
+import fs from "node:fs";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const fileName = join(__dirname, 'files', 'fileToRead.txt');
+
 const read = async () => {
-    // Write your code here 
+    // Write your code here
+    if (!fs.existsSync(fileName)) throw new Error('FS operation failed');
+    fs.readFile(fileName, 'utf8', (err, buffer) => {
+        if (err) throw err;
+        if (buffer) {
+            console.log(buffer);
+        }
+    })
 };
 
 await read();

src/fs/rename.js

@@ -1,5 +1,26 @@
+import fs, {existsSync} from 'node:fs'
+import {fileURLToPath} from "url";
+import {dirname, join} from "path";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const fileDirname = join(__dirname, 'files');
+const srcPath = join(fileDirname, 'wrongFilename.txt');
+const destPath = join(fileDirname, 'properFilename.md');
+const sourceExists = existsSync(srcPath);
+const destExists = existsSync(destPath);
+
 const rename = async () => {
-    // Write your code here 
+    // Write your code here
+    if(!sourceExists || destExists) {
+        throw new Error('FS operation failed');
+    }
+    await fs.rename(srcPath, destPath, (err) => {
+        if(err) {
+            throw err;
+        }
+        console.log('File renamed successfully!');
+    } )
 };
 
 await rename();

src/hash/calcHash.js

@@ -1,5 +1,19 @@
+import crypto from 'node:crypto'
+import fs from "node:fs";
+import {fileURLToPath} from "url";
+import path from "path";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const fileName = path.join(__dirname, 'files', 'fileToCalculateHashFor.txt');
+
 const calculateHash = async () => {
-    // Write your code here 
+    // Write your code here
+    const hash = crypto.createHash('sha256');
+    const input = fs.createReadStream(fileName);
+    const hashSum = input.pipe(hash);
+    hashSum.on('end', () =>process.stdout.write('\n'));
+    hashSum.setEncoding('hex').pipe(process.stdout);
 };
 
 await calculateHash();

src/modules/cjsToEsm.cjs

@@ -1,7 +1,7 @@
 const path = require('path');
 const { release, version } = require('os');
 const { createServer: createServerHttp } = require('http');
-require('./files/c');
+require('./files/c.cjs');
 
 const random = Math.random();
 

src/modules/esm.mjs

@@ -0,0 +1,43 @@
+import path from 'path';
+import {release, version} from 'os';
+import {createServer as createServerHttp} from 'http';
+import './files/c.cjs';
+import {fileURLToPath} from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const random = Math.random();
+
+let unknownObject;
+let fileName;
+
+if (random > 0.5) {
+    fileName = 'a.json';
+} else {
+    fileName = 'b.json';
+}
+// Both variants are viable https://discord.com/channels/755676888680366081/1363206860160631114/1365003228994998403
+// unknownObject = {default: JSON.parse(fs.readFileSync(path.join(__dirname, 'files', fileName), 'utf-8'))};
+unknownObject = await import(`./files/${fileName}`, { with: { type: 'json' } });
+console.log(`Release ${release()}`);
+console.log(`Version ${version()}`);
+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) => {
+    res.end('Request accepted');
+});
+
+const PORT = 3000;
+// Assign to emp object prototype to get rid of [Module prototype null] or something
+console.log(Object.assign({}, unknownObject));
+
+myServer.listen(PORT, () => {
+    console.log(`Server is listening on port ${PORT}`);
+    console.log('To terminate it, use Ctrl+C combination');
+});
+export {unknownObject, myServer};
+
+

src/modules/files/c.cjs

@@ -1 +1 @@
-console.log('Hello from c.js!');
+console.log('Hello from c.cjs!');

src/streams/read.js

@@ -1,5 +1,17 @@
+import fs from 'node:fs';
+import {fileURLToPath} from "url";
+import path from "path";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const fileName = path.join(__dirname, 'files', 'fileToRead.txt');
+
 const read = async () => {
-    // Write your code here 
+    // Write your code here
+    let fileStream = fs.createReadStream(fileName);
+    fileStream.pipe(process.stdout);
+    // Added on end event stdout write new line to ensure debug info would be written on new line + ensure to flush stdout buffer
+    fileStream.on('end', () => process.stdout.write('\n'));
 };
 
 await read();

src/streams/transform.js

@@ -1,5 +1,14 @@
+import {Transform} from 'stream';
 const transform = async () => {
-    // Write your code here 
+    // Write your code here
+    console.log("Terminal is ready for input.");
+    const dataTransformer = new Transform({
+        transform(chunk, encoding, callback) {
+            this.push(`${chunk.toString().split('').reverse().join('')}\n`);
+            callback();
+        }
+    })
+    process.stdin.pipe(dataTransformer).pipe(process.stdout);
 };
 
 await transform();

src/streams/write.js

@@ -1,5 +1,16 @@
+import {fileURLToPath} from "url";
+import path from "path";
+import fs from 'node:fs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const fileName = path.join(__dirname, 'files', 'fileToWrite.txt');
+
 const write = async () => {
-    // Write your code here 
+    // Write your code here
+    console.log("Terminal is ready for input.");
+    let fileStream = fs.createWriteStream(fileName);
+    process.stdin.pipe(fileStream);
 };
 
 await write();

src/wt/main.js

@@ -1,5 +1,27 @@
+import os from "node:os";
+import {Worker, workerData} from "node:worker_threads";
+import {fileURLToPath} from "url";
+import path from "path";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const fileName = path.join(__dirname, 'worker.js');
+
 const performCalculations = async () => {
     // Write your code here
+    let cpuCoreCount = os.cpus().length;
+    let workers = []
+    for (let i = 0; i < cpuCoreCount; i++) {
+        workers.push( new Promise((resolve) => {
+            const worker = new Worker(fileName, {workerData: (10 + i)})
+            worker.on('message', message => {
+                resolve({status: 'resolved', data: message});
+            })
+            worker.on('error', err => resolve({status: 'error', data: null}));
+        }));
+    }
+    let values = await Promise.all(workers);
+    console.log(values);
 };
 
 await performCalculations();

src/wt/worker.js

@@ -1,8 +1,13 @@
+import worker from "node:worker_threads"
 // n should be received from main thread
 const nthFibonacci = (n) => n < 2 ? n : nthFibonacci(n - 1) + nthFibonacci(n - 2);
 
 const sendResult = () => {
+    // This code is for simulation of Error behaviour
+    // let rand = Math.random()
+    // if(rand > 0.5) throw new Error('');
     // This function sends result of nthFibonacci computations to main thread
+    worker.parentPort.postMessage(nthFibonacci(worker.workerData));
 };
 
 sendResult();

src/zip/compress.js

@@ -1,5 +1,18 @@
+import {fileURLToPath} from "url";
+import path from "path";
+import zlib from "zlib";
+import fs from "node:fs";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const fileName = path.join(__dirname, 'files', 'fileToCompress.txt');
+const destName = path.join(__dirname, 'files', 'archive.gz');
+
 const compress = async () => {
-    // Write your code here 
+    // Write your code here
+    let fileStream = fs.createReadStream(fileName);
+    let destStream = fs.createWriteStream(destName);
+    fileStream.pipe(zlib.createGzip()).pipe(destStream).on("finish", () => console.log("File compressed."));
 };
 
 await compress();