Node.js basics

.gitignore

@@ -0,0 +1 @@
+node_modules

src/cli/args.js

@@ -1,5 +1,24 @@
+import { argv } from "process";
+
 const parseArgs = () => {
-  // Write your code here
+  const args = argv.slice(2);
+  const argsObj = {};
+
+  for (let i = 0; i < args.length; i += 2) {
+    argsObj[args[i].slice(2)] = args[i + 1];
+  }
+
+  let msg = "";
+  const argsKeys = Object.keys(argsObj);
+  for (let i = 0; i < argsKeys.length; i++) {
+    if (i + 1 === argsKeys.length) {
+      msg += `${argsKeys[i]} is ${argsObj[argsKeys[i]]}`;
+      break;
+    }
+    msg += `${argsKeys[i]} is ${argsObj[argsKeys[i]]}, `;
+  }
+
+  console.log(msg);
 };
 
 parseArgs();

src/cli/env.js

@@ -1,5 +1,20 @@
+import { env } from "process";
+
 const parseEnv = () => {
-  // Write your code here
+  const variables = Object.keys(env).filter((value) =>
+    value.startsWith("RSS_")
+  );
+
+  let msg = "";
+  for (let i = 0; i < variables.length; i++) {
+    if (i + 1 === variables.length) {
+      msg += `${variables[i]}=${env[variables[i]]}`;
+      break;
+    }
+    msg += `${variables[i]}=${env[variables[i]]}; `;
+  }
+
+  console.log(msg);
 };
 
 parseEnv();

src/cp/cp.js

@@ -1,6 +1,14 @@
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { fork } from "node:child_process";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
 const spawnChildProcess = async (args) => {
-  // Write your code here
+  const filesDir = join(__dirname, "files");
+  const scriptFilePath = join(filesDir, "script.js");
+
+  fork(scriptFilePath, args);
 };
 
-// Put your arguments in function call to test this functionality
-spawnChildProcess( /* [someArgument1, someArgument2, ...] */);
+spawnChildProcess(["mem, wow, kek"]);

src/fs/copy.js

@@ -1,5 +1,23 @@
+import { cp } from "fs/promises";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
 const copy = async () => {
-  // Write your code here
+  const srcDir = join(__dirname, "files");
+  const destDir = join(__dirname, "files_copy");
+  try {
+    await cp(srcDir, destDir, {
+      recursive: true,
+      errorOnExist: true,
+      force: false,
+    });
+  } catch (error) {
+    if (error.code === "ENOENT" || error.code === "ERR_FS_CP_EEXIST") {
+      throw new Error("FS operation failed");
+    }
+  }
 };
 
 await copy();

src/fs/create.js

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

src/fs/delete.js

@@ -1,5 +1,20 @@
+import { rm } from "fs/promises";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
 const remove = async () => {
-  // Write your code here
+  const filesDir = join(__dirname, "files");
+  const targetFilePath = join(filesDir, "fileToRemove.txt");
+
+  try {
+    await rm(targetFilePath);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new Error("FS operation failed");
+    }
+  }
 };
 
 await remove();

src/fs/list.js

@@ -1,5 +1,20 @@
+import { readdir } from "fs/promises";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
 const list = async () => {
-  // Write your code here
+  const filesDir = join(__dirname, "files");
+
+  try {
+    const files = await readdir(filesDir);
+    console.log(files);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new Error("FS operation failed");
+    }
+  }
 };
 
 await list();

src/fs/read.js

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

src/fs/rename.js

@@ -1,5 +1,30 @@
+import { access, rename as renameFn } from "fs/promises";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
 const rename = async () => {
-  // Write your code here
+  const filesDir = join(__dirname, "files");
+  const srcFilePath = join(filesDir, "wrongFilename.txt");
+  const targetFilePath = join(filesDir, "properFilename.md");
+
+  try {
+    await access(targetFilePath);
+    throw new Error("FS operation faile");
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+
+  try {
+    await renameFn(srcFilePath, targetFilePath);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new Error("FS operation failed");
+    }
+  }
 };
 
 await rename();

src/hash/calcHash.js

@@ -1,5 +1,24 @@
+import { createHash } from "crypto";
+import { createReadStream } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
 const calculateHash = async () => {
-  // Write your code here
+  const filesDir = join(__dirname, "files");
+  const srcFilePath = join(filesDir, "fileToCalculateHashFor.txt");
+
+  const stream = createReadStream(srcFilePath);
+
+  return new Promise((resolve) => {
+    const hash = createHash("sha256");
+    stream.on("data", (data) => hash.update(data, "utf-8"));
+    stream.on("end", () => {
+      console.log(hash.digest("hex"));
+      resolve();
+    });
+  });
 };
 
 await calculateHash();

src/modules/esm.mjs

@@ -0,0 +1,39 @@
+import { createServer as createServerHttp } from "node:http";
+import { release, version } from "node:os";
+import { fileURLToPath } from "url";
+import path from "node:path";
+import { dirname } from "path";
+
+import "./files/c.cjs";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+const random = Math.random();
+
+const jsonPath = random > 0.5 ? "./files/a.json" : "./files/b.json";
+const unknownObject = (
+  await import(path.join(__dirname, jsonPath), { 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 ${__filename}`);
+console.log(`Path to current directory is ${__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 { unknownObject, myServer };

src/streams/read.js

@@ -1,5 +1,23 @@
+import { createReadStream } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { stdout } from "process";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
 const read = async () => {
-  // Write your code here
+  const filesDir = join(__dirname, "files");
+  const srcFilePath = join(filesDir, "fileToRead.txt");
+
+  const readStream = createReadStream(srcFilePath);
+
+  return new Promise((resolve) => {
+    readStream.on("data", (data) => stdout.write(data));
+    readStream.on("end", () => {
+      stdout.write("\n");
+      resolve();
+    });
+  });
 };
 
 await read();

src/streams/transform.js

@@ -1,5 +1,17 @@
+import { stdin, stdout } from "process";
+import { Transform } from "stream";
+import { pipeline } from "stream/promises";
+
 const transform = async () => {
-  // Write your code here
+  const transformStream = new Transform({
+    transform(data, _, cb) {
+      const result = data.toString().split("").reverse().join("");
+
+      cb(null, result + "\n");
+    },
+  });
+
+  await pipeline(stdin, transformStream, stdout);
 };
 
 await transform();

src/streams/write.js

@@ -1,5 +1,16 @@
+import { createWriteStream } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { stdin } from "process";
+import { pipeline } from "stream/promises";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
 const write = async () => {
-  // Write your code here
+  const filesDir = join(__dirname, "files");
+  const targetFilePath = join(filesDir, "fileToWrite.txt");
+
+  await pipeline(stdin, createWriteStream(targetFilePath));
 };
 
 await write();