Nodejs basics

src/cli/args.js

@@ -1,5 +1,14 @@
 const parseArgs = () => {
-    // Write your code here 
+  const array = process.argv.slice(2);
+
+  let value = array.reduce(function (accumulator, item, index, array) {
+    if (index % 2 === 0) {
+      accumulator.push(`${item.slice(2)} is ${array[index + 1]}`);
+    }
+    return accumulator;
+  }, []);
+  const joinedStr = value.join(", ");
+  console.log(joinedStr);
 };
 
-parseArgs();
+parseArgs();

src/cli/env.js

@@ -1,5 +1,9 @@
 const parseEnv = () => {
-    // Write your code here 
+  const filteredObject = Object.entries(process.env).filter((el) =>
+    el[0].includes("RSS_")
+  );
+  const variables = filteredObject.map(el => el.join("=")).join('; ');
+  console.log(variables)
 };
 
-parseEnv();
+parseEnv();

src/cp/cp.js

@@ -1,6 +1,12 @@
+import { spawn } from 'node:child_process';
+import path, { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const childModule = path.join(__dirname, 'files', 'script.js');
+
 const spawnChildProcess = async (args) => {
-    // Write your code here
+  const cp = spawn('node', [childModule, ...args]);
 };
 
-// Put your arguments in function call to test this functionality
-spawnChildProcess( /* [someArgument1, someArgument2, ...] */);
+spawnChildProcess([1, 'a']);

src/fs/copy.js

@@ -1,5 +1,17 @@
+import { copyFile, cp, mkdir, readdir, unlink } from 'node:fs/promises';
+import path, { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const filesFolder = path.join(__dirname, 'files');
+const filesFolderCopy = path.join(__dirname, 'files-copy');
+
 const copy = async () => {
-    // Write your code here 
+  try {
+    await cp(filesFolder, filesFolderCopy, { recursive: true, force: false, errorOnExist: true });
+  } catch {
+    throw new Error('FS operation failed');
+  }
 };
 
 await copy();

src/fs/create.js

@@ -1,5 +1,16 @@
+import { writeFile } from 'node:fs/promises';
+import path, { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pathToFile = path.join(__dirname, 'files', 'fresh.txt');
+
 const create = async () => {
-    // Write your code here 
+  try {
+    await writeFile(pathToFile, 'I am fresh and young', { flag: 'wx' });
+  } catch {
+    throw new Error('FS operation failed');
+  }
 };
 
-await create();
+await create();

src/fs/delete.js

@@ -1,5 +1,16 @@
+import { unlink } from 'node:fs/promises';
+import path, { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const filesFolder = path.join(__dirname, 'files');
+
 const remove = async () => {
-    // Write your code here 
+  try {
+    await unlink(path.join(filesFolder, 'fileToRemove.txt'));
+  } catch {
+    throw new Error('FS operation failed');
+  }
 };
 
-await remove();
+await remove();

src/fs/list.js

@@ -1,5 +1,18 @@
+import { access, constants, readdir, unlink } from 'node:fs/promises';
+import path, { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const filesFolder = path.join(__dirname, 'files');
+
 const list = async () => {
-    // Write your code here 
+  try {
+    access(filesFolder);
+    const files = await readdir(filesFolder);
+    console.log(files);
+  } catch (error) {
+    throw new Error('FS operation failed');
+  }
 };
 
-await list();
+await list();

src/fs/read.js

@@ -1,5 +1,21 @@
+import { readFile } from 'node:fs/promises';
+import path, { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const filesFolder = path.join(__dirname, 'files') 
+
 const read = async () => {
-    // Write your code here 
+
+    try {
+        const fileContent = await readFile(path.join(filesFolder, 'fileToRead.txt'),'utf8')
+        console.log(fileContent);
+    } catch (error) {
+
+        throw new Error('FS operation failed')
+    }
+
+
 };
 
 await read();

src/fs/rename.js

@@ -1,5 +1,17 @@
+import { rename as renameFile } from 'node:fs/promises';
+import path, { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const target = path.join(__dirname, 'files', 'wrongFilename.txt');
+const outputFile = path.join(__dirname, 'files', 'properFilename.md');
+
 const rename = async () => {
-    // Write your code here 
+  try {
+    await renameFile(target, outputFile);
+  } catch {
+    throw new Error('FS operation failed');
+  }
 };
 
-await rename();
+await rename();

src/hash/calcHash.js

@@ -1,5 +1,24 @@
-const calculateHash = async () => {
-    // Write your code here 
+
+import { createHash } from 'node:crypto';
+import { createReadStream } from 'node:fs';
+import path, { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const fileForHash = path.join(__dirname, 'files', 'fileToCalculateHashFor.txt')
+
+const hash = createHash('sha256');
+
+  const calculateHash = async () => {
+    const stream = createReadStream(fileForHash);
+    stream.on('readable', () => {
+      const data = stream.read();
+      if (data)
+        hash.update(data);
+      else {
+        console.log(`${hash.digest('hex')}`);
+      }
+    });
 };
 
 await calculateHash();

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

@@ -1,11 +1,18 @@
-const path = require('path');
-const { release, version } = require('os');
-const { createServer: createServerHttp } = require('http');
-require('./files/c');
+import {  createServer as createServerHttp  } from 'http';
+import { release, version } from 'os';
+import path from 'path';
+import { createRequire } from "module";
+import { fileURLToPath } from 'url';
+
+const require = createRequire(import.meta.url);
+import './files/c.js'
 
 const random = Math.random();
 
-let unknownObject;
+export let unknownObject;
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
 
 if (random > 0.5) {
     unknownObject = require('./files/a.json');
@@ -20,7 +27,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');
 });
 
@@ -33,8 +40,3 @@ myServer.listen(PORT, () => {
     console.log('To terminate it, use Ctrl+C combination');
 });
 
-module.exports = {
-    unknownObject,
-    myServer,
-};
-

src/streams/files/fileToWrite.txt

@@ -0,0 +1 @@
+dfddfdfdff defddfjDDDD F  F F  Fd 

src/streams/read.js

@@ -1,5 +1,14 @@
+import { createReadStream } from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const filesFolder = path.join(__dirname, 'files');
+const fileToRead = path.join(filesFolder, 'fileToRead.txt');
+
 const read = async () => {
-    // Write your code here 
+  const readableStream = createReadStream(fileToRead);
+  readableStream.pipe(process.stdout);
 };
 
-await read();
+await read();

src/streams/transform.js

@@ -1,5 +1,19 @@
+import { Transform, pipeline } from 'stream';
+import { stdin, stdout } from 'process';
+
+const input = stdin;
+const output = stdout;
+
 const transform = async () => {
-    // Write your code here 
+  const transformStream = new Transform({
+    transform(chunk, enc, cb) {
+      const reversed = chunk.toString().trim().split('').reverse().join('');
+      cb(null, reversed + '\n');
+    },
+  });
+  pipeline(input, transformStream, output, (err) => {
+    throw new Error('Error:', err);
+  });
 };
 
-await transform();
+await transform();

src/streams/write.js

@@ -1,5 +1,15 @@
+import { createWriteStream } from 'fs';
+import path from 'path';
+import { stdin } from 'process';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const filesFolder = path.join(__dirname, 'files');
+const fileToWrite = path.join(filesFolder, 'fileToWrite.txt');
+
 const write = async () => {
-    // Write your code here 
+  const output = createWriteStream(fileToWrite);
+  process.stdin.pipe(output);
 };
 
-await write();
+await write();

src/wt/main.js

@@ -1,5 +1,48 @@
+import { Worker, isMainThread, workerData } from 'node:worker_threads';
+import os from 'node:os';
+import path, { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const workerModule = path.join(__dirname, 'worker.js');
+const incrementalNumber = 10;
+const numberOfCores = os.availableParallelism();
+
 const performCalculations = async () => {
-    // Write your code here
+  if (isMainThread) {
+    const workers = [];
+    const output = [];
+
+    for (let i = 0; i < numberOfCores; i++) {
+      const worker = new Worker(workerModule, { workerData: i + incrementalNumber });
+      workers.push(worker);
+    }
+
+    workers.forEach((worker, i) => {
+      worker.on('message', (data) => {
+        output[i] = {
+          status: 'resolved',
+          data: data,
+        };
+
+        results.length === numberOfCores ? console.log(results) : null;
+      });
+
+      worker.on('error', (error) => {
+        output[i] = {
+          status: 'error',
+          data: null,
+        };
+      });
+    });
+
+    workers.forEach((worker) => {
+      worker.postMessage(workerData);
+    });
+  } else {
+    const data = workerData;
+    parentPort.postMessage(data);
+  }
 };
 
-await performCalculations();
+await performCalculations();

src/wt/worker.js

@@ -1,8 +1,9 @@
-// n should be received from main thread
-const nthFibonacci = (n) => n < 2 ? n : nthFibonacci(n - 1) + nthFibonacci(n - 2);
+import { parentPort, workerData } from 'node:worker_threads';
+
+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();
+sendResult();

src/zip/compress.js

@@ -1,5 +1,19 @@
+import { createReadStream, createWriteStream } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { createGzip } from "zlib";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const filesFolder = path.join(__dirname, "files");
+
 const compress = async () => {
-    // Write your code here 
+  const gzip = createGzip();
+  const fileToCompress = createReadStream(
+    path.join(filesFolder, "fileToCompress.txt")
+  );
+  const archive = createWriteStream(path.join(filesFolder, "archive.gz"));
+
+  fileToCompress.pipe(gzip).pipe(archive);
 };
 
-await compress();
+await compress();