Complete "NodeJS basics" task

.editorconfig

@@ -0,0 +1,12 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.md]
+trim_trailing_whitespace = false

.nvmrc

@@ -0,0 +1 @@
+v24.10.0

src/cli/args.js

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

src/cli/env.js

@@ -1,5 +1,8 @@
 const parseEnv = () => {
-  // Write your code here
+  const prefix = "RSS_";
+  Object.entries(process.env)
+    .filter(([key]) => key.startsWith(prefix))
+    .forEach(([key, value]) => console.log(`${key}=${value};`));
 };
 
 parseEnv();

src/fs/copy.js

@@ -1,5 +1,28 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { FS_ERROR_MESSAGE } from "./fs-helper.js";
+
 const copy = async () => {
-  // Write your code here
+  const sourceDirName = "files";
+  const destinationDirName = `${sourceDirName}_copy`;
+
+  const currentDirectory = import.meta.dirname;
+  const sourceDirPath = path.join(currentDirectory, sourceDirName);
+  const destinationDirPath = path.join(currentDirectory, destinationDirName);
+
+  try {
+    await fs.cp(sourceDirPath, destinationDirPath, {
+      recursive: true,
+      force: false,
+      errorOnExist: true,
+    });
+  } catch (error) {
+    if (error.code === "ERR_FS_CP_EEXIST") {
+      throw new Error(FS_ERROR_MESSAGE);
+    } else if (error.code === "ENOENT") {
+      throw new Error(FS_ERROR_MESSAGE);
+    }
+  }
 };
 
 await copy();

src/fs/create.js

@@ -1,5 +1,20 @@
+import fs from "node:fs/promises";
+import { FS_ERROR_MESSAGE, getFilePathInFilesDir } from "./fs-helper.js";
+
 const create = async () => {
-  // Write your code here
+  const fileName = "fresh.txt";
+  const content = "I am fresh and young";
+  const filePath = getFilePathInFilesDir(fileName);
+
+  try {
+    await fs.writeFile(filePath, content, { flag: "wx+" });
+  } catch (error) {
+    if (error.code === "EEXIST") {
+      throw new Error(FS_ERROR_MESSAGE);
+    }
+
+    throw error;
+  }
 };
 
 await create();

src/fs/delete.js

@@ -1,5 +1,13 @@
+import fs from "node:fs/promises";
+import { FS_ERROR_MESSAGE, getFilePathInFilesDir } from "./fs-helper.js";
+
 const remove = async () => {
-  // Write your code here
+  try {
+    const fileToDeletePath = getFilePathInFilesDir("fileToRemove.txt");
+    await fs.unlink(fileToDeletePath);
+  } catch {
+    throw new Error(FS_ERROR_MESSAGE);
+  }
 };
 
 await remove();

src/fs/fs-helper.js

@@ -0,0 +1,11 @@
+import path from "node:path";
+
+export const FS_ERROR_MESSAGE = "FS operation failed";
+
+export const getFilesDirPath = () => path.join(import.meta.dirname, "files")
+
+export const getFilePathInFilesDir = (fileName) => {
+  const filesDir = getFilesDirPath()
+
+  return path.join(filesDir, fileName);
+};

src/fs/list.js

@@ -1,5 +1,17 @@
+import fs from "node:fs/promises";
+import { FS_ERROR_MESSAGE, getFilesDirPath } from "./fs-helper.js";
+
 const list = async () => {
-  // Write your code here
+  const filesDirPath = getFilesDirPath();
+
+  try {
+    const dirContent = await fs.readdir(filesDirPath, {
+      recursive: true,
+    });
+    console.log(dirContent);
+  } catch {
+    throw new Error(FS_ERROR_MESSAGE);
+  }
 };
 
 await list();

src/fs/read.js

@@ -1,5 +1,14 @@
+import fs from "node:fs/promises";
+import { FS_ERROR_MESSAGE, getFilePathInFilesDir } from "./fs-helper.js";
+
 const read = async () => {
-  // Write your code here
+  try {
+    const filePath = getFilePathInFilesDir("fileToRead.txt");
+    const content = await fs.readFile(filePath, 'utf-8');
+    console.log(content);
+  } catch {
+    throw new Error(FS_ERROR_MESSAGE);
+  }
 };
 
 await read();

src/fs/rename.js

@@ -1,5 +1,28 @@
+import path from "node:path";
+import fs from "node:fs/promises";
+import { FS_ERROR_MESSAGE, getFilesDirPath } from "./fs-helper.js";
+
 const rename = async () => {
-  // Write your code here
+  const filesDirPath = getFilesDirPath();
+  const wrongFilenamePath = path.join(filesDirPath, "wrongFilename.txt");
+  const properFilenamePath = path.join(filesDirPath, "properFilename.md");
+
+  // If the destination file (`properFilename.md`) exists throw an error
+  try {
+    await fs.access(properFilenamePath);
+    throw new Error(FS_ERROR_MESSAGE);
+  } catch (e) {
+    if (e.message === FS_ERROR_MESSAGE) {
+      throw e;
+    }
+  }
+
+  // Will throw an error if the source file (`wrongFilename.txt`) does not exist
+  try {
+    await fs.rename(wrongFilenamePath, properFilenamePath);
+  } catch {
+    throw new Error(FS_ERROR_MESSAGE);
+  }
 };
 
 await rename();

src/modules/esm.mjs

@@ -0,0 +1,37 @@
+import { sep } 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
+    ? import("./files/a.json", { with: { type: "json" } })
+    : import("./files/b.json", { with: { type: "json" } });
+
+console.log(`Release ${release()}`);
+console.log(`Version ${version()}`);
+console.log(`Path segment separator is "${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,15 @@
+import { pipeline } from "node:stream/promises";
+import { createReadStream } from "node:fs";
+import path from "node:path";
+
 const read = async () => {
-  // Write your code here
+  try {
+    const filePath = path.join(import.meta.dirname, "files", "fileToRead.txt");
+    const readStream = createReadStream(filePath, { encoding: "utf-8" });
+    await pipeline(readStream, process.stdout);
+  } catch (error) {
+    console.log(error);
+  }
 };
 
 await read();

src/streams/transform.js

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

src/streams/write.js

@@ -1,5 +1,11 @@
+import { pipeline } from "node:stream/promises";
+import { createWriteStream } from "node:fs";
+import path from "node:path";
+
 const write = async () => {
-  // Write your code here
+  const filePath = path.join(import.meta.dirname, "files", "fileToWrite.txt");
+  const writeStream = createWriteStream(filePath, { encoding: "utf-8" });
+  await pipeline(process.stdin, writeStream);
 };
 
 await write();