Node.js basics

src/cli/args.js

@@ -1,5 +1,8 @@
 const parseArgs = () => {
-  // Write your code here
+  const str = process.argv.slice(2).map((val, i) => ((i % 2) ? `is ${val},`  : val))
+    .join(' ').toString();
+
+  console.log(str.slice(0, -1));
 };
 
 parseArgs();

src/cli/env.js

@@ -1,5 +1,10 @@
 const parseEnv = () => {
-  // Write your code here
+  const prefix = 'RSS_';
+  const keys = Object.entries(process.env).reduce((map, [key, value]) => {
+    if (key.indexOf(prefix) === 0) map[key] = value;
+    return map;
+  }, {})
+  console.log(keys);
 };
 
 parseEnv();

src/cp/cp.js

@@ -1,6 +1,27 @@
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+const filePath = 'src/cp/files/script.js';
+const spawn = require('child_process').spawn;
+
 const spawnChildProcess = async (args) => {
-  // Write your code here
+  const child = spawn(`node`, [filePath, ...args], {
+    stdio: ['pipe', 'pipe', 'inherit'],
+  });
+
+  process.stdin.pipe(child.stdin);
+  child.stdout.pipe(process.stdout);
+
+  return new Promise((res, rej) => {
+    child.stdout.on('data', (data) => {
+      res(`data: ${data}`);
+    });
+
+    child.on('exit', (code) => {
+      rej(`on exit ${code}`);
+    });
+  });
 };
 
 // Put your arguments in function call to test this functionality
-spawnChildProcess( /* [someArgument1, someArgument2, ...] */);
+spawnChildProcess([1, 2, 3]);

src/fs/copy.js

@@ -1,5 +1,24 @@
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+const fs = require('fs/promises');
+
+const folderName = 'src/fs/files';
+const copyFolderName = 'src/fs/files_copy';
+const errorMessage = 'FS operation failed';
+
 const copy = async () => {
-  // Write your code here
+  try {
+    const files = await fs.readdir(folderName);
+    await fs.mkdir(copyFolderName);
+    files.forEach(f => {
+      if(f.includes('.')) {
+        fs.copyFile(`${folderName}/${f}`, `${copyFolderName}/${f}`);
+      }
+    });
+  } catch(e) {
+    throw new Error(errorMessage);
+  }
 };
 
 await copy();

src/fs/create.js

@@ -1,5 +1,21 @@
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+const fs = require('fs/promises');
+
+const filePath = 'src/fs/files/fresh.txt';
+const content = 'I am fresh and young';
+const errorMessage = 'FS operation failed';
+
 const create = async () => {
-  // Write your code here
+  try {
+    await fs.open(filePath);
+  } catch(e) {
+    await fs.writeFile(filePath, content);
+    return;
+  }
+
+  throw new Error(errorMessage);
 };
 
 await create();

src/fs/delete.js

@@ -1,5 +1,17 @@
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+const fs = require('fs/promises');
+
+const fileToRemove = 'src/fs/files/fileToRemove.txt'
+const errorMessage = 'FS operation failed';
+
 const remove = async () => {
-  // Write your code here
+  try {
+    await fs.rm(fileToRemove);
+  } catch(e) {
+    throw new Error(errorMessage);
+  }
 };
 
-await remove();
+await remove();

src/fs/list.js

@@ -1,5 +1,18 @@
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+const fs = require('fs/promises');
+
+const folderName = 'src/fs/files';
+
 const list = async () => {
-  // Write your code here
+  try {
+    await fs.access(folderName);
+    const files = await fs.readdir(folderName);
+    files.forEach(f => { console.log(f) });
+  } catch(e) {
+    throw new Error(errorMessage);
+  }
 };
 
-await list();
+await list();

src/fs/read.js

@@ -1,5 +1,19 @@
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+const fs = require('fs/promises');
+
+const fileToRead = 'src/fs/files/fileToRead.txt';
+const errorMessage = 'FS operation failed';
+
 const read = async () => {
-  // Write your code here
+  try {
+    await fs.access(fileToRead);
+    const files = await fs.readFile(fileToRead, 'utf8');
+    console.log(files);
+  } catch(e) {
+    throw new Error(errorMessage);
+  }
 };
 
-await read();
+await read();

src/fs/rename.js

@@ -1,5 +1,18 @@
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+const fs = require('fs/promises');
+
+const oldFileName = 'src/fs/files/wrongFilename.txt'
+const newFileName = 'src/fs/files/properFilename.md';
+const errorMessage = 'FS operation failed';
+
 const rename = async () => {
-  // Write your code here
+  try {
+    await fs.rename(oldFileName, newFileName);
+  } catch(e) {
+    throw new Error(errorMessage);
+  }
 };
 
-await rename();
+await rename();

src/hash/calcHash.js

@@ -1,5 +1,18 @@
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+
+const fs = require('fs');
+const crypto = require('crypto');
+const stream = require('stream/promises');
+const filePath = 'src/hash/files/fileToCalculateHashFor.txt';
+
 const calculateHash = async () => {
-  // Write your code here
+  const fd = fs.createReadStream(filePath);
+  const hash = crypto.createHash('sha256');
+  await stream.pipeline(fd, hash);
+
+  console.log(hash.digest('hex'));
 };
 
 await calculateHash();

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

@@ -1,12 +1,17 @@
-const path = require('node:path');
-const { release, version } = require('node:os');
-const { createServer: createServerHttp } = require('node:http');
+import path from 'path';
+import { release, version } from 'os';
+import { createServer as createServerHttp } from 'http';
+import './files/c.cjs';
+import { fileURLToPath } from 'url';
 
-require('./files/c.cjs');
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
 
 const random = Math.random();
 
-const unknownObject = random > 0.5 ? require('./files/a.json') : require('./files/b.json');
+const unknownObject = random > 0.5
+  ? await import('./files/a.json', { with: { type: "json" } })
+  : await import('./files/b.json', { with: { type: "json" } });
 
 console.log(`Release ${release()}`);
 console.log(`Version ${version()}`);
@@ -28,7 +33,8 @@ myServer.listen(PORT, () => {
   console.log('To terminate it, use Ctrl+C combination');
 });
 
-module.exports = {
-  unknownObject,
-  myServer,
+export {
+      unknownObject,
+      myServer,
 };
+

src/streams/read.js

@@ -1,5 +1,12 @@
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+
+const fs = require('fs');
+const filePath = 'src/streams/files/fileToRead.txt';
+
 const read = async () => {
-  // Write your code here
+  fs.createReadStream(filePath, 'utf-8').pipe(process.stdout);
 };
 
-await read();
+await read();

src/streams/transform.js

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

src/streams/write.js

@@ -1,5 +1,13 @@
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+
+const fs = require('fs');
+const filePath = 'src/streams/files/fileToWrite.txt';
+
 const write = async () => {
-  // Write your code here
+  const file = fs.createWriteStream(filePath);
+  process.stdin.pipe(file);
 };
 
 await write();

src/wt/main.js

@@ -1,5 +1,40 @@
+import { createRequire } from 'module';
+import os from 'os';
+
+const require = createRequire(import.meta.url);
+const { Worker } = require('worker_threads');
+const cpuCount = os.cpus().length;
+
 const performCalculations = async () => {
-  // Write your code here
+  let promisesArr = [];
+  let startingCount = 10;
+
+  console.log(cpuCount)
+
+  Array.from({ length: cpuCount }).forEach(_ => {
+    const worker = new Worker('./worker.js');
+    const promise = new Promise((res, rej) => {
+      worker.on('message', (data) => {
+        res({
+          status: 'resolved',
+          data,
+        });
+      });
+
+      worker.on('error', () => {
+        rej({
+          status: 'error',
+          data: null,
+        });
+      });
+    });
+
+    promisesArr.push(promise);
+
+    worker.postMessage(startingCount++);
+  });
+
+  return Promise.allSettled(promisesArr).then((res) => console.log(res));
 };
 
 await performCalculations();

src/wt/worker.js

@@ -1,8 +1,13 @@
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+const { workerData, parentPort } = require('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
+export const sendResult = (res) => {
+  parentPort.postMessage(res);
 };
 
-sendResult();
+sendResult(nthFibonacci(workerData));

src/zip/compress.js

@@ -1,5 +1,18 @@
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+const fs = require('fs');
+const zlib = require('zlib');
+
+const filePath = 'src/zip/files/fileToCompress.txt';
+const compressedFilePath = 'src/zip/files/archive.gz';
+
+const fileToCompress = fs.createReadStream(filePath);
+const destination = fs.createWriteStream(compressedFilePath);
+
 const compress = async () => {
-  // Write your code here
+  const compress = zlib.createGzip();
+  await fileToCompress.pipe(compress).pipe(destination);
 };
 
 await compress();

src/zip/decompress.js

@@ -1,5 +1,18 @@
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+const fs = require('fs');
+const zlib = require('zlib');
+
+const compressedFilePath = 'src/zip/files/archive.gz';
+const filePath = 'src/zip/files/fileToCompress.txt';
+
+const fileToDecompress = fs.createReadStream(compressedFilePath);
+const destination = fs.createWriteStream(filePath);
+
 const decompress = async () => {
-  // Write your code here
+  const decompress = zlib.createGunzip();
+  await fileToDecompress.pipe(decompress).pipe(destination);
 };
 
-await decompress();
+await decompress();