Basics node

src/cli/args.js

@@ -1,5 +1,10 @@
 const parseArgs = () => {
-    // Write your code here 
+  // Write your code here
+  const argv = process.argv.slice(2);
+
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i].startsWith("--")) console.log(`${argv[i]} is ${argv[i + 1]}`);
+  }
 };
 
-parseArgs();
+parseArgs();

src/cli/env.js

@@ -1,5 +1,8 @@
 const parseEnv = () => {
-    // Write your code here 
+  // Write your code here
+  for (const key in process.env) {
+    if (key.startsWith("RSS_")) console.log(`${key}=${process.env[key]}`);
+  }
 };
 
-parseEnv();
+parseEnv();

src/constants.js

@@ -0,0 +1 @@
+export const ERROR_FS = "FS operation failed";

src/cp/cp.js

@@ -1,6 +1,26 @@
+import cp from "child_process";
+
 const spawnChildProcess = async (args) => {
-    // Write your code here
+  // Write your code here
+  const childp = cp.spawn("node", [
+    import.meta.dirname + "/files/script.js",
+    ...args,
+  ]);
+
+  // Pipe the stdin of the parent process to the child process
+  process.stdin.on("data", (data) => {
+    childp.stdin.write(data + "\n");
+  });
+  // or
+  // process.stdin.pipe(childp.stdin);
+
+  // Pipe the stdout of the child process to the stdout of the parent process
+  childp.stdout.on("data", (data) => {
+    process.stdout.write(data + "\n");
+  });
+  // or
+  // childp.stdout.pipe(process.stdout);
 };
 
 // Put your arguments in function call to test this functionality
-spawnChildProcess( /* [someArgument1, someArgument2, ...] */);
+spawnChildProcess(process.argv.slice(2));

src/cp/files/script.js

@@ -4,9 +4,9 @@ console.log(`Total number of arguments is ${args.length}`);
 console.log(`Arguments: ${JSON.stringify(args)}`);
 
 const echoInput = (chunk) => {
-    const chunkStringified = chunk.toString();
-    if (chunkStringified.includes('CLOSE')) process.exit(0);
-    process.stdout.write(`Received from master process: ${chunk.toString()}\n`)
+  const chunkStringified = chunk.toString();
+  if (chunkStringified.includes("CLOSE")) process.exit(0);
+  process.stdout.write(`Received from master process: ${chunk.toString()}\n`);
 };
 
-process.stdin.on('data', echoInput);
+process.stdin.on("data", echoInput);

src/fs/copy.js

@@ -1,5 +1,19 @@
+import fs from "fs";
+import { ERROR_FS } from "../constants.js";
+import { isFileExist } from "../shared.js";
+
 const copy = async () => {
-    // Write your code here 
+  // Write your code here
+  const copy = "./src/fs/files_copy";
+  const src = "./src/fs/files";
+
+  if (!(await isFileExist(src)) || (await isFileExist(copy)))
+    throw Error(ERROR_FS);
+  else {
+    fs.cp(src, copy, { recursive: true }, (err) => {
+      if (err) throw err;
+    });
+  }
 };
 
 await copy();

src/fs/create.js

@@ -1,5 +1,16 @@
+import fs from "fs";
+import { ERROR_FS } from "../constants.js";
+import { isFileExist } from "../shared.js";
+
 const create = async () => {
-    // Write your code here 
+  // Write your code here
+  const fresh = "./src/fs/files/fresh.txt";
+
+  if (!(await isFileExist(fresh)))
+    fs.appendFile(fresh, "I am fresh and young", (err) => {
+      if (err) throw err;
+    });
+  else throw Error(ERROR_FS); // file already exist
 };
 
-await create();
+await create();

src/fs/delete.js

@@ -1,5 +1,18 @@
+import fs from "fs";
+import { ERROR_FS } from "../constants.js";
+import { isFileExist } from "../shared.js";
+
 const remove = async () => {
-    // Write your code here 
+  // Write your code here
+  const fileToRemove = "./src/fs/files/fileToRemove.txt";
+
+  if (!(await isFileExist(fileToRemove)))
+    throw Error(ERROR_FS); // file doesn't exist
+  else {
+    fs.rm(fileToRemove, (err) => {
+      if (err) throw err;
+    });
+  }
 };
 
-await remove();
+await remove();

src/fs/list.js

@@ -1,5 +1,18 @@
+import fs from "fs";
+import { ERROR_FS } from "../constants.js";
+import { isFileExist } from "../shared.js";
+
 const list = async () => {
-    // Write your code here 
+  // Write your code here
+  const filesDir = "./src/fs/files";
+
+  if (!(await isFileExist(filesDir))) throw Error(ERROR_FS);
+  else {
+    fs.readdir(filesDir, (err, files) => {
+      if (err) throw err;
+      else console.log(files);
+    });
+  }
 };
 
-await list();
+await list();

src/fs/read.js

@@ -1,5 +1,20 @@
+import fs from "fs";
+import { ERROR_FS } from "../constants.js";
+import { isFileExist } from "../shared.js";
+
 const read = async () => {
-    // Write your code here 
+  // Write your code here
+  const fileToRead = "./src/fs/files/fileToRead.txt";
+
+  const readFile = (file) => {
+    fs.readFile(file, "utf8", (err, data) => {
+      if (err) throw err;
+      else console.log(data);
+    });
+  };
+
+  if (!(await isFileExist(fileToRead))) throw Error(ERROR_FS);
+  else readFile(fileToRead);
 };
 
-await read();
+await read();

src/fs/rename.js

@@ -1,5 +1,19 @@
+import fs from "fs";
+import { ERROR_FS } from "../constants.js";
+import { isFileExist } from "../shared.js";
+
 const rename = async () => {
-    // Write your code here 
+  // Write your code here
+  const oldFile = "./src/fs/files/wrongFilename.txt";
+  const newFile = "./src/fs/files/properFilename.md";
+
+  if (!(await isFileExist(oldFile)) || (await isFileExist(newFile)))
+    throw Error(ERROR_FS);
+  else {
+    fs.rename(oldFile, newFile, (err) => {
+      if (err) throw err; // newFile is a directory
+    });
+  }
 };
 
-await rename();
+await rename();

src/hash/calcHash.js

@@ -1,5 +1,16 @@
+import fs from "fs";
+import crypto from "crypto";
+
 const calculateHash = async () => {
-    // Write your code here 
+  // Write your code here
+  const file = fs.createReadStream(
+    "./src/hash/files/fileToCalculateHashFor.txt"
+  );
+  const hash = crypto.createHash("sha256");
+
+  file.pipe(hash); // Pipes the file data into the hash object
+
+  console.log(hash.digest("hex")); // transform to hex
 };
 
-await calculateHash();
+await calculateHash();

src/modules/esm.mjs

@@ -0,0 +1,36 @@
+import fs from "fs";
+import path from "node:path";
+import { release, version } from "node:os";
+import { createServer } from "node:http";
+import "./files/c.js";
+
+const parsedData = (path) =>
+  JSON.parse(fs.readFileSync(new URL(path, import.meta.url)));
+
+const random = Math.random();
+
+const unknownObject = parsedData(
+  random > 0.5 ? "./files/a.json" : "./files/b.json"
+);
+
+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 = createServer((_, 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/shared.js

@@ -0,0 +1,8 @@
+import fs from "fs";
+
+export const isFileExist = async (file) =>
+  new Promise((resolve) => {
+    fs.access(file, fs.constants.F_OK, (err) => {
+      resolve(!err); // resolves `true` if file exists, `false` if it doesn't
+    });
+  });

src/streams/files/fileToWrite.txt

@@ -0,0 +1 @@
+

src/streams/read.js

@@ -1,5 +1,13 @@
+import fs from "fs";
+
 const read = async () => {
-    // Write your code here 
+  // Write your code here
+  const stream = fs.createReadStream("src/streams/files/fileToRead.txt");
+
+  stream.on("data", (chunk) => {
+    chunk = chunk.toString();
+    process.stdout.write(chunk + "\n");
+  });
 };
 
-await read();
+await read();

src/streams/transform.js

@@ -1,5 +1,16 @@
+import { Transform } from "stream";
+
 const transform = async () => {
-    // Write your code here 
+  // Write your code here
+
+  const reverseStream = new Transform({
+    transform(chunk, encoding, callback) {
+      // Reverse the chunk and pass it to the readable side
+      callback(null, chunk.toString().split("").reverse().join(""));
+    },
+  });
+
+  process.stdin.pipe(reverseStream).pipe(process.stdout);
 };
 
-await transform();
+await transform();

src/streams/write.js

@@ -1,5 +1,15 @@
+import fs from "fs";
+
 const write = async () => {
-    // Write your code here 
+  // Write your code here
+  const stream = fs.createWriteStream("src/streams/files/fileToWrite.txt");
+
+  process.stdin.on("data", (chunk) => {
+    stream.write(chunk);
+  });
+
+  // or ?
+  // process.stdin.pipe(stream);
 };
 
-await write();
+await write();