Node js basics

src/cli/args.js

@@ -1,5 +1,17 @@
 const parseArgs = () => {
   // Write your code here
+  let valueNameFlag = false;
+  const result = [];
+  process.argv.reduce((previous, current) => {
+    if (previous) {
+      result.push(`${previous} is ${current}`);
+      return null
+    }
+    else if (current.startsWith("--")) {
+      return current.substr(2);
+    }
+  });
+  console.log(result.join(', '));
 };
 
 parseArgs();

src/cli/env.js

@@ -1,5 +1,13 @@
 const parseEnv = () => {
   // Write your code here
+  const envVariablesKeys = Object.keys(process.env);
+  const result = []
+  envVariablesKeys.forEach((k) => {
+    if (k.startsWith("RSS_")) {
+      result.push(`${k}=${process.env[k]}`);
+    }
+  });
+  console.log(result.join("; "))
 };
 
 parseEnv();

src/cp/cp.js

@@ -1,6 +1,17 @@
+import { spawn } from "node:child_process";
+
+const filePath = "./src/cp/files/script.js";
+
 const spawnChildProcess = async (args) => {
   // Write your code here
+  const child = spawn("node", [filePath, ...args], {
+    stdio: ['pipe', 'pipe'],
+  });
+
+  process.stdin.pipe(child.stdin);
+
+  child.stdout.pipe(process.stdout);
 };
 
 // Put your arguments in function call to test this functionality
-spawnChildProcess( /* [someArgument1, someArgument2, ...] */);
+spawnChildProcess(  [true, 2, 'test3'] );

src/fs/copy.js

@@ -1,5 +1,28 @@
+import fs from "node:fs/promises";
+
+const folder = "./src/fs/files";
+
 const copy = async () => {
   // Write your code here
+  try {
+    await fs.access(folder);
+    await fs.access(`${folder}_copy`);
+    throw new Error("FS operation failed");
+  }
+  catch(error) {
+    if (error.syscall === "access") {
+      try {
+        await fs.access(folder);
+        fs.cp(folder, `${folder}_copy`, {recursive: true});
+      }
+      catch(error) {
+        throw new Error("FS operation failed");
+      }
+    }
+    else {
+      throw error;
+    }
+  }
 };
 
 await copy();

src/fs/create.js

@@ -1,5 +1,37 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+const fresh = "./src/fs/files/fresh.txt";
+const str = "I am fresh and young";
+
 const create = async () => {
   // Write your code here
+  try {
+    const stat = await fs.stat(fresh);
+    if (stat.isFile()) {
+      throw Error("FS operation failed");
+    }
+    else {
+      await fs.rmdir(fresh);
+      await fs.writeFile(fresh, str);
+    }
+  }
+  catch(error) {
+    if (error.syscall === "stat") {
+      try {
+        await fs.access(path.dirname(fresh));
+      }
+      catch(error) {
+        fs.mkdir(path.dirname(fresh));
+      }
+      finally{
+        await fs.writeFile(fresh, str);
+      }
+    }
+    else {
+      throw error;
+    }
+  }
 };
 
 await create();

src/fs/delete.js

@@ -1,5 +1,27 @@
+import fs from "node:fs/promises";
+
+const errorMessage = "FS operation failed";
+const fileName = "./src/fs/files/fileToRemove.txt";
+
 const remove = async () => {
   // Write your code here
+  try {
+    const fileStat = await fs.stat(fileName);
+    if (fileStat.isFile()) {
+      await fs.rm(fileName);
+    }
+    else {
+      throw new Error(errorMessage);
+    }
+  }
+  catch(error) {
+    if (error.syscall === "stat") {
+      throw new Error(errorMessage);
+    }
+    else {
+      throw error
+    }
+  }
 };
 
 await remove();

src/fs/list.js

@@ -1,5 +1,25 @@
+import fs from "node:fs/promises";
+
+const errorMessage = "FS operation failed";
+const directory = "./src/fs/files";
+
 const list = async () => {
   // Write your code here
+  const directoryStat = await fs.stat(directory);
+  if (directoryStat.isDirectory()) {
+    const files = await fs.readdir(directory);
+    await Promise.all(
+      files.map(async (f) => {
+        const fStat = await fs.stat(`${directory}/${f}`);
+        if (fStat.isFile()) {
+          console.log(f);
+        }
+      })
+    );
+  }
+  else {
+    throw new Error (errorMessage);
+  }
 };
 
 await list();

src/fs/read.js

@@ -1,5 +1,23 @@
+import fs from "node:fs/promises";
+
+const errorMessage = "FS operation failed";
+const filePath = "./src/fs/files/fileToRead.txt";
+
 const read = async () => {
   // Write your code here
+  try {
+    const fileStat = await fs.stat(filePath);
+    if (fileStat.isFile()) {
+      const fileContent = await fs.readFile(filePath);
+      console.log(fileContent.toString());
+    }
+    else {
+      throw new Error(errorMessage);
+    }
+  }
+  catch(error) {
+    throw new Error(errorMessage);
+  }
 };
 
 await read();

src/fs/rename.js

@@ -1,5 +1,33 @@
+import fs from "node:fs/promises";
+
+const errorMessage = "FS operation failed";
+const fileName = "./src/fs/files/wrongFilename.txt";
+const properFilename = "./src/fs/files/properFilename.md";
+
 const rename = async () => {
   // Write your code here
+  try {
+    const fileNameStat = await fs.stat(fileName);
+    if (fileNameStat.isDirectory()) {
+      throw new Error(errorMessage);
+    }
+    await fs.stat(properFilename);
+    throw new Error(errorMessage);
+  }
+  catch(error) {
+    if (error.syscall === "stat") {
+      try {
+        await fs.access(fileName);
+      }
+      catch(error) {
+        throw new Error(errorMessage);
+      }
+      await fs.rename(fileName, properFilename);
+    }
+    else {
+      throw error
+    }
+  }
 };
 
 await rename();

src/hash/calcHash.js

@@ -1,5 +1,16 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+
+const filePath = "./src/hash/files/fileToCalculateHashFor.txt";
+
 const calculateHash = async () => {
   // Write your code here
+  const hash = crypto.createHash("sha256");
+  const input = fs.createReadStream(filePath);
+  for await (const chunk of input) {
+    hash.update(chunk);
+  }
+  console.log(hash.digest('hex'));
 };
 
 await calculateHash();

src/modules/esm.mjs

@@ -0,0 +1,36 @@
+import path from 'node:path';
+import { release, version } from 'node:os';
+import { createServer as createServerHttp } from 'node:http';
+
+import './files/c.cjs';
+
+const random = Math.random();
+
+const unknownObject = (random > 0.5 /* ? a : b; */
+  ? await import ('./files/a.json', { with: { type: 'json' }})
+  : await import('./files/b.json', { with: { type: 'json' }})).default;
+
+console.log(`Release ${release()}`);
+console.log(`Version ${version()}`);
+console.log(`Path segment separator is "${path.sep}"`);
+
+console.log(`Path to current file is ${import.meta.filename}`);
+console.log(`Path to current directory is ${import.meta.dirname}`);
+
+const myServer = createServerHttp((_, res) => {
+  res.end('Request accepted');
+});
+
+const PORT = 3000;
+
+console.log(unknownObject);
+
+myServer.listen(PORT, () => {
+  console.log(`Server is listening on port ${PORT}`);
+  console.log('To terminate it, use Ctrl+C combination');
+});
+
+export default {
+  unknownObject,
+  myServer,
+};

src/streams/read.js

@@ -1,5 +1,14 @@
+import fs from "node:fs";
+
+const filePath = "./src/streams/files/fileToRead.txt";
+
 const read = async () => {
   // Write your code here
+  const input = fs.createReadStream(filePath);
+  for await (const chunk of input) {
+    process.stdout.write(chunk);
+  }
+  process.stdout.write('\n');
 };
 
 await read();

src/streams/transform.js

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

src/streams/write.js

@@ -1,5 +1,11 @@
+import fs from "node:fs";
+
+const fileToWrite = "./src/streams/files/fileToWrite.txt";
+
 const write = async () => {
   // Write your code here
+  const output = fs.createWriteStream(fileToWrite);
+  process.stdin.pipe(output);
 };
 
 await write();

src/wt/main.js

@@ -1,5 +1,31 @@
+import os from "os";
+import {
+  Worker, MessageChannel, MessagePort, isMainThread, parentPort
+} from 'node:worker_threads';
+
 const performCalculations = async () => {
   // Write your code here
+  const coresCount = os.cpus().length;
+  const values = [];
+  for (let i = 10; i < 10 + coresCount; i++) {
+    values.push(i);
+  }
+  const results = await Promise.all(values.map(async (v, index) => {
+    return new Promise((resolve) => {
+      const worker = new Worker("./src/wt/worker.js", {
+        workerData: {n: v},
+      });
+      worker.on("message", (r) => {
+        resolve({status: "resolved", data: r});
+      });
+      worker.on("error", (error) => {
+        resolve({status: "error", data: null});
+      })
+    })
+  }));
+  results.forEach((r) => {
+    console.log(`{status: ${r.status}, data: ${r.data}}`);
+  })
 };
 
 await performCalculations();