Node.js Basics

src/cli/args.js

@@ -1,5 +1,13 @@
+import { argv } from "node:process";
+
 const parseArgs = () => {
   // Write your code here
+  const justArguments = argv.slice(2);
+  const result = [];
+  for (let i = 0; i < justArguments.length; i += 2) {
+    result.push(`${justArguments[i].slice(2)} is ${justArguments[i + 1]}`);
+  }
+  console.log(result.join(", "));
 };
 
 parseArgs();

src/cli/env.js

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

src/cp/cp.js

@@ -1,6 +1,17 @@
+import { spawn } from "node:child_process";
+import { URL, fileURLToPath } from "node:url";
 const spawnChildProcess = async (args) => {
   // Write your code here
+  const scriptURL = new URL("./files/script.js", import.meta.url);
+  const scriptPath = fileURLToPath(scriptURL);
+  const child = spawn("node", [scriptPath, ...args], {
+    stdio: ["pipe", "pipe", "inherit"],
+  });
+
+  process.stdin.pipe(child.stdin);
+
+  child.stdout.pipe(process.stdout);
 };
 
 // Put your arguments in function call to test this functionality
-spawnChildProcess( /* [someArgument1, someArgument2, ...] */);
+spawnChildProcess(["someArgument1", "someArgument2", "other argument"]);

src/fs/copy.js

@@ -1,5 +1,29 @@
+import { cp } from "node:fs/promises";
+import { URL, fileURLToPath } from "node:url";
 const copy = async () => {
   // Write your code here
+  const srcURL = new URL("./files/", import.meta.url);
+  const src = fileURLToPath(srcURL);
+  const destURL = new URL("./files_copy", import.meta.url);
+  const dest = fileURLToPath(destURL);
+  const errorMessage = "FS operation failed";
+  try {
+    try {
+      await cp(src, dest, {
+        errorOnExist: true,
+        recursive: true,
+        force: false,
+      });
+    } catch (e) {
+      throw new Error(errorMessage);
+    }
+  } catch (e) {
+    if (e instanceof Error && e.message === errorMessage) {
+      console.log(e.message);
+    } else {
+      console.log(e);
+    }
+  }
 };
 
 await copy();

src/fs/create.js

@@ -1,5 +1,26 @@
+import { writeFile, access } from "node:fs/promises";
+import { URL, fileURLToPath } from "node:url";
+
 const create = async () => {
   // Write your code here
+  const content = "I am fresh and young";
+  const fileURL = new URL("./files/fresh.txt", import.meta.url);
+  const file = fileURLToPath(fileURL);
+  const errorMessage = "FS operation failed";
+  try {
+    await access(file);
+    throw new Error(errorMessage);
+  } catch (e) {
+    if (e instanceof Error && e.message === errorMessage) {
+      console.log(e.message);
+    } else {
+      try {
+        await writeFile(file, content);
+      } catch (e) {
+        console.log(e);
+      }
+    }
+  }
 };
 
 await create();

src/fs/delete.js

@@ -1,5 +1,35 @@
+import { unlink, access } from "node:fs/promises";
+import { URL, fileURLToPath } from "node:url";
+
 const remove = async () => {
   // Write your code here
+  const fileURL = new URL("./files/fileToRemove.txt", import.meta.url);
+  const filePath = fileURLToPath(fileURL);
+  const errorMessage = "FS operation failed";
+  try {
+    //check if file exists
+    try {
+      await access(filePath);
+    } catch (e) {
+      throw new Error(errorMessage);
+    }
+
+    //after ensuring in file existence try to delete it
+    //and handle if there is any error
+    try {
+      await unlink(filePath);
+      console.log("File deleted successfully");
+    } catch (e) {
+      console.log(e);
+    }
+  } catch (e) {
+    //handle both of custom thrown error and uknown one
+    if (e instanceof Error && e.message === errorMessage) {
+      console.log(e.message);
+    } else {
+      console.log(e);
+    }
+  }
 };
 
 await remove();

src/fs/files/fresh.txt

@@ -0,0 +1 @@
+I am fresh and young

src/fs/files/wrongFilename.txt → src/fs/files/properFilename.md

@@ -1,3 +1,3 @@
 # This is a file with a wrong filename
 
-Hello from **markdown**!
+Hello from **markdown**!

src/fs/list.js

@@ -1,5 +1,26 @@
+import { readdir, access } from "node:fs/promises";
+import { URL, fileURLToPath } from "node:url";
+
 const list = async () => {
   // Write your code here
+  const directoryURL = new URL("./files/", import.meta.url);
+  const directory = fileURLToPath(directoryURL);
+  const errorMessage = "FS operation failed";
+  try {
+    try {
+      await access(directory);
+    } catch (e) {
+      throw new Error(errorMessage);
+    }
+    const fileNames = await readdir(directory);
+    console.log(fileNames);
+  } catch (e) {
+    if (e instanceof Error && e.message === errorMessage) {
+      console.log(e.message);
+    } else {
+      console.log(e);
+    }
+  }
 };
 
 await list();

src/fs/read.js

@@ -1,5 +1,26 @@
+import { readFile, access } from "node:fs/promises";
+import { URL, fileURLToPath } from "node:url";
+
 const read = async () => {
   // Write your code here
+  const fileURL = new URL("./files/fileToRead.txt", import.meta.url);
+  const file = fileURLToPath(fileURL);
+  const errorMessage = "FS operation failed";
+  try {
+    try {
+      await access(file);
+    } catch (e) {
+      throw new Error(errorMessage);
+    }
+    const contents = await readFile(file, { encoding: "utf8" });
+    console.log(contents);
+  } catch (e) {
+    if (e instanceof Error && e.message === errorMessage) {
+      console.log(e.message);
+    } else {
+      console.log(e);
+    }
+  }
 };
 
 await read();

src/fs/rename.js

@@ -1,5 +1,32 @@
+import { rename as renamePromise, access } from "node:fs/promises";
+import { URL, fileURLToPath } from "node:url";
+
 const rename = async () => {
   // Write your code here
+  const oldPathURL = new URL("./files/wrongFilename.txt", import.meta.url);
+  const newPathURL = new URL("./files/properFilename.md", import.meta.url);
+  const oldPath = fileURLToPath(oldPathURL);
+  const newPath = fileURLToPath(newPathURL);
+  const errorMessage = "FS operation failed";
+  try {
+    try {
+      await access(oldPath);
+    } catch (e) {
+      throw new Error(errorMessage);
+    }
+    await access(newPath);
+    throw new Error(errorMessage);
+  } catch (e) {
+    if (e instanceof Error && e.message === errorMessage) {
+      console.log(e.message);
+    } else {
+      try {
+        await renamePromise(oldPath, newPath);
+      } catch (e) {
+        console.log(e);
+      }
+    }
+  }
 };
 
 await rename();

src/hash/calcHash.js

@@ -1,5 +1,26 @@
+import { createHash } from "node:crypto";
+import { createReadStream } from "node:fs";
+import { URL, fileURLToPath } from "node:url";
+
 const calculateHash = async () => {
   // Write your code here
+  const fileUrl = new URL(
+    "./files/fileToCalculateHashFor.txt",
+    import.meta.url,
+  );
+  const filePath = fileURLToPath(fileUrl);
+
+  const hash = createHash("sha256");
+
+  hash.on("readable", () => {
+    const data = hash.read();
+    if (data) {
+      console.log(data.toString("hex"));
+    }
+  });
+
+  const fileStream = createReadStream(filePath);
+  fileStream.pipe(hash);
 };
 
 await calculateHash();

src/modules/esm.mjs

@@ -0,0 +1,38 @@
+import { sep } from "node:path";
+import { release, version } from "node:os";
+import { createServer as createServerHttp } from "node:http";
+import { fileURLToPath } from "node:url";
+import { dirname } from "node:path";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const random = Math.random();
+
+const unknownObject = await (
+  random > 0.5
+    ? import("./files/a.json", { with: { type: "json" } })
+    : import("./files/b.json", { with: { type: "json" } })
+).then((module) => module.default);
+
+console.log(`Release ${release()}`);
+console.log(`Version ${version()}`);
+console.log(`Path segment separator is "${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/files/fileToWrite.txt

@@ -0,0 +1 @@
+Very well

src/streams/read.js

@@ -1,5 +1,13 @@
+import { createReadStream } from "node:fs";
+import { URL, fileURLToPath } from "node:url";
 const read = async () => {
   // Write your code here
+  const fileURL = new URL("./files/fileToRead.txt", import.meta.url);
+  const filePath = fileURLToPath(fileURL);
+
+  const readableStream = createReadStream(filePath, { encoding: "utf-8" });
+
+  readableStream.pipe(process.stdout);
 };
 
 await read();

src/streams/transform.js

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

src/streams/write.js

@@ -1,5 +1,13 @@
+import { createWriteStream } from "node:fs";
+import { URL, fileURLToPath } from "node:url";
 const write = async () => {
   // Write your code here
+  const fileURL = new URL("./files/fileToWrite.txt", import.meta.url);
+  const filePath = fileURLToPath(fileURL);
+
+  const writableStream = createWriteStream(filePath, { encoding: "utf-8" });
+
+  process.stdin.pipe(writableStream);
 };
 
 await write();