NodeJs Basics

.gitignore

@@ -0,0 +1,4 @@
+.idea
+.vscode
+node_modules
+yarn-error.log

.nvmrc

@@ -0,0 +1 @@
+22.9.0

src/cli/args.js

@@ -1,5 +1,15 @@
 const parseArgs = () => {
-    // Write your code here 
+  const args = process.argv.slice(2);
+  const res = [];
+
+  for (let i = 0; i < args.length; i = i + 2) {
+    const propName = args[i].substring(2);
+    const value = args[i + 1];
+
+    res.push(`${propName} is ${value}`);
+  }
+
+  console.log(res.join(', '));
 };
 
-parseArgs();
+parseArgs();

src/cli/env.js

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

src/cp/cp.js

@@ -1,6 +1,21 @@
+import { spawn } from 'child_process';
+
+import { getPath } from "../helpers/index.js";
+
 const spawnChildProcess = async (args) => {
-    // Write your code here
+    const childPath = getPath(import.meta.url, 'files', 'script.js');
+
+    const child = spawn('node', [childPath, ...args], {
+        stdio: ['pipe', 'pipe', 'inherit']
+    })
+
+    process.stdin.pipe(child.stdin);
+    child.stdout.pipe(process.stdout);
+
+    child.on('close', (code) => {
+        console.log(`Child process exited with code ${code}`)
+    })
 };
 
 // Put your arguments in function call to test this functionality
-spawnChildProcess( /* [someArgument1, someArgument2, ...] */);
+spawnChildProcess(['arg1', 'arg2', 'arg3']);

src/fs/copy.js

@@ -1,5 +1,44 @@
+import { mkdir, readdir, copyFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+import { getPath, doesPathExist, operationFail } from '../helpers/index.js';
+
 const copy = async () => {
-    // Write your code here 
+  try {
+    const DESTINATION_FOLDER_NAME = 'files_copy';
+    const sourceFolderPath = getPath(import.meta.url, 'files');
+    const sourceFolderExist = await doesPathExist(sourceFolderPath);
+
+    if (!sourceFolderExist) {
+      operationFail();
+
+      return;
+    }
+
+    const destinationFolderPath = getPath(import.meta.url, DESTINATION_FOLDER_NAME);
+    const destinationFolderExist = await doesPathExist(destinationFolderPath);
+
+    if (destinationFolderExist) {
+      operationFail();
+
+      return;
+    }
+
+    await mkdir(destinationFolderPath);
+
+    const files = await readdir(sourceFolderPath);
+
+    await Promise.all(
+      files.map(async (file) => {
+        const sourceFilePath = join(sourceFolderPath, file);
+        const destinationFilePath = join(destinationFolderPath, file);
+
+        await copyFile(sourceFilePath, destinationFilePath);
+      })
+    );
+  } catch (err) {
+    throw err;
+  }
 };
 
 await copy();

src/fs/create.js

@@ -1,5 +1,26 @@
+import { writeFile } from 'node:fs';
+
+import { getPath, doesPathExist, operationFail } from '../helpers/index.js';
+
 const create = async () => {
-    // Write your code here 
+  const content = 'I am fresh and young';
+  const path = getPath(import.meta.url, 'files', 'fresh.txt');
+
+  const fileExist = await doesPathExist(path);
+
+  if (fileExist) {
+    operationFail();
+
+    return;
+  }
+
+  await writeFile(path, content, (err) => {
+    if (err) {
+      throw err;
+    } else {
+      console.log('File written successfully');
+    }
+  });
 };
 
-await create();
+await create();

src/fs/delete.js

@@ -1,5 +1,18 @@
+import fsPromises from 'node:fs/promises';
+
+import { getPath, doesPathExist, operationFail } from '../helpers/index.js';
+
 const remove = async () => {
-    // Write your code here 
+  const pathFile = getPath(import.meta.url, 'files', 'fileToRemove.txt');
+  const isFileExist = await doesPathExist(pathFile);
+
+  if (!isFileExist) {
+    operationFail();
+
+    return;
+  }
+
+  await fsPromises.rm(pathFile);
 };
 
-await remove();
+await remove();

src/fs/list.js

@@ -1,5 +1,30 @@
+import fsPromises from 'node:fs/promises';
+
+import { getPath, doesPathExist, operationFail } from '../helpers/index.js';
+import { join } from 'node:path';
+
 const list = async () => {
-    // Write your code here 
+  const dirPath = getPath(import.meta.url, 'files');
+  const isDirExist = await doesPathExist(dirPath);
+
+  if (!isDirExist) {
+    operationFail();
+
+    return;
+  }
+
+  const files = await fsPromises.readdir(dirPath);
+  const fileNames = [];
+
+  for (const file of files) {
+    const fileInfo = await fsPromises.stat(join(dirPath, file));
+
+    if (fileInfo.isFile()) {
+      fileNames.push(file);
+    }
+  }
+
+  console.log('files', fileNames);
 };
 
-await list();
+await list();

src/fs/read.js

@@ -1,5 +1,19 @@
+import { readFile } from 'node:fs/promises';
+
+import { getPath, doesPathExist, operationFail } from '../helpers/index.js';
+
 const read = async () => {
-    // Write your code here 
+  const filePath = getPath(import.meta.url, 'files', 'fileToRead.txt');
+  const isExist = doesPathExist(filePath);
+
+  if (!isExist) {
+    operationFail();
+
+    return;
+  }
+
+  const content = await readFile(filePath, { encoding: 'utf8' });
+  console.log(content);
 };
 
-await read();
+await read();

src/fs/rename.js

@@ -1,5 +1,27 @@
+import fs from 'node:fs/promises';
+
+import { getPath, doesPathExist, operationFail } from '../helpers/index.js';
+
 const rename = async () => {
-    // Write your code here 
+  try {
+    const NEW_FILE_NAME = 'properFilename.md';
+    const OLD_FILE_NAME = 'wrongFilename.txt';
+
+    const newFileNamePath = getPath(import.meta.url, 'files', NEW_FILE_NAME);
+    const newFileExist = await doesPathExist(newFileNamePath);
+    const oldFileNamePath = getPath(import.meta.url, 'files', OLD_FILE_NAME);
+    const oldFileExist = await doesPathExist(oldFileNamePath);
+
+    if (newFileExist || !oldFileExist) {
+      operationFail();
+
+      return;
+    }
+
+    await fs.rename(oldFileNamePath, newFileNamePath);
+  } catch (err) {
+    throw err;
+  }
 };
 
-await rename();
+await rename();

src/hash/calcHash.js

@@ -1,5 +1,30 @@
+import { createReadStream } from 'fs';
+import { createHash } from 'crypto';
+
+import { getPath } from '../helpers/index.js';
+
 const calculateHash = async () => {
-    // Write your code here 
+  const folderName = 'files';
+  const fileToCalculateHashFor = 'fileToCalculateHashFor.txt';
+  const sha256 = 'sha256';
+
+  const pathToTheFile = getPath(import.meta.url, folderName, fileToCalculateHashFor);
+
+  const hash = createHash(sha256);
+  const stream = createReadStream(pathToTheFile);
+
+  stream.on('data', (data) => {
+    hash.update(data);
+  });
+
+  stream.on('end', () => {
+    const sha256Hash = hash.digest('hex');
+    console.log(`SHA256 Hash for ${fileToCalculateHashFor}: ${sha256Hash}`);
+  });
+
+  stream.on('error', (error) => {
+    console.error(`Error reading file: ${error.message}`);
+  });
 };
 
-await calculateHash();
+await calculateHash();

src/helpers/index.js

@@ -0,0 +1,32 @@
+import { access } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export const getPath = (currentPath, folderName, fileName = '') => {
+  try {
+    const currentFile = fileURLToPath(currentPath);
+    const currentDirName = dirname(currentFile);
+
+    return join(currentDirName, folderName, fileName);
+  } catch (err) {
+    throw err;
+  }
+};
+
+export const doesPathExist = async (path) => {
+  try {
+    await access(path);
+
+    return true;
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      return false;
+    } else {
+      throw err;
+    }
+  }
+};
+
+export const operationFail = () => {
+  throw new Error('FS operation failed');
+};