nodejs-basics-Hryhorii-Havryliuk

src/cli/args.js

@@ -1,5 +1,16 @@
 const parseArgs = () => {
-  // Write your code here
+  const args = process.argv.slice(2);
+
+  const output = args.reduce((acc, curr, index, array) => {
+    if (curr.startsWith('--')) {
+      const key = curr.slice(2);
+      const value = array[index + 1];
+      acc.push(`${key} is ${value}`);
+    }
+    return acc;
+  }, []);
+
+  console.log(output.join(', '));
 };
 
 parseArgs();

src/cli/env.js

@@ -1,5 +1,10 @@
 const parseEnv = () => {
-  // Write your code here
+  const rssVars = Object.entries(process.env)
+    .filter(([key]) => key.startsWith('RSS_'));
+
+  const output = rssVars.map(([key, value]) => `${key}=${value}`).join('; ');
+
+  console.log(output);
 };
 
 parseEnv();

src/cp/cp.js

@@ -1,6 +1,29 @@
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
 const spawnChildProcess = async (args) => {
-  // Write your code here
+  const scriptPath = path.join(__dirname, 'files', 'script.js');
+
+  const child = spawn(
+    process.execPath,
+    [scriptPath, ...args],
+    {
+      stdio: ['pipe', 'pipe', 'inherit'],
+    }
+  );
+
+  process.stdin.pipe(child.stdin);
+
+  child.stdout.pipe(process.stdout);
+
+  child.on('exit', (code) => console.log(`Child process exited with code ${code}`));
+
+  child.on('error', (err) => console.error('Child process error:', err));
 };
 
 // Put your arguments in function call to test this functionality
-spawnChildProcess( /* [someArgument1, someArgument2, ...] */);
+spawnChildProcess(['hello', 'world']);

src/fs/copy.js

@@ -1,5 +1,36 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
 const copy = async () => {
-  // Write your code here
+  const srcDir = path.join(__dirname, 'files');
+  const destDir = path.join(__dirname, 'files_copy');
+
+  try {
+
+    await fs.access(srcDir);
+
+    try {
+
+      await fs.access(destDir);
+
+      throw new Error('FS operation failed');
+
+    } catch (err) {
+
+      if (err.code !== 'ENOENT') {
+        throw new Error('FS operation failed');
+      }
+    }
+
+    await fs.cp(srcDir, destDir, { recursive: true });
+
+  } catch (err) {
+    throw new Error('FS operation failed');
+  }
 };
 
 await copy();

src/fs/create.js

@@ -1,5 +1,36 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
 const create = async () => {
-  // Write your code here
+
+  const dirPath = path.join(__dirname, 'files');
+  const filePath = path.join(dirPath, 'fresh.txt');
+
+  try {
+
+    await fs.access(dirPath);
+
+    try {
+
+      await fs.access(filePath);
+
+      throw new Error('FS operation failed');
+
+    } catch (err) {
+
+      if (err.code === 'ENOENT') {
+        await fs.writeFile(filePath, 'I am fresh and young', 'utf8');
+      } else {
+        throw new Error('FS operation failed');
+      }
+    }
+  } catch (err) {
+    throw new Error('FS operation failed');
+  }
 };
 
 await create();

src/fs/delete.js

@@ -1,5 +1,19 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
 const remove = async () => {
-  // Write your code here
+  const filePath = path.join(__dirname, 'files', 'fileToRemove.txt');
+
+  try {
+    await fs.access(filePath);
+    await fs.rm(filePath);
+  } catch (err) {
+    throw new Error('FS operation failed');
+  }
 };
 
 await remove();

src/fs/list.js

@@ -1,5 +1,22 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
 const list = async () => {
-  // Write your code here
+  const dirPath = path.join(__dirname, 'files');
+
+  try {
+    await fs.access(dirPath);
+
+    const files = await fs.readdir(dirPath);
+
+    console.log(files);
+  } catch (err) {
+    throw new Error('FS operation failed');
+  }
 };
 
 await list();

src/fs/read.js

@@ -1,5 +1,23 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
 const read = async () => {
-  // Write your code here
+  const filePath = path.join(__dirname, 'files', 'fileToRead.txt');
+
+  try {
+
+    await fs.access(filePath);
+
+    const content = await fs.readFile(filePath, 'utf8');
+
+    console.log(content);
+  } catch (err) {
+    throw new Error('FS operation failed');
+  }
 };
 
 await read();

src/fs/rename.js

@@ -1,5 +1,31 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
 const rename = async () => {
-  // Write your code here
+  const dirPath = path.join(__dirname, 'files');
+  const oldPath = path.join(dirPath, 'wrongFilename.txt');
+  const newPath = path.join(dirPath, 'properFilename.md');
+
+  try {
+    await fs.access(oldPath);
+
+    try {
+      await fs.access(newPath);
+      throw new Error('FS operation failed');
+    } catch (err) {
+      if (err.code !== 'ENOENT') {
+        throw new Error('FS operation failed');
+      }
+    }
+
+    await fs.rename(oldPath, newPath);
+  } catch (err) {
+    throw new Error('FS operation failed');
+  }
 };
 
 await rename();

src/hash/calcHash.js

@@ -1,5 +1,27 @@
+import { createReadStream } from 'node:fs';
+import { createHash } from 'node:crypto';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
 const calculateHash = async () => {
-  // Write your code here
+  const filePath = path.join(__dirname, 'files', 'fileToCalculateHashFor.txt');
+
+  try {
+    const hash = createHash('sha256');
+    const stream = createReadStream(filePath);
+
+    stream.on('data', chunk => hash.update(chunk));
+    stream.on('end', () => console.log(hash.digest('hex')));
+
+    stream.on('error', () => { 
+      throw new Error('FS operation failed'); 
+    });
+  } catch (err) {
+    throw new Error('FS operation failed');
+  }
 };
 
 await calculateHash();

src/modules/esm.mjs

@@ -0,0 +1,38 @@
+import path from 'node:path';
+import { release, version } from 'node:os';
+import { createServer as createServerHttp } from 'node:http';
+import { readFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+
+import './files/c.cjs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const random = Math.random();
+
+const jsonFilePath = random > 0.5
+  ? path.join(__dirname, 'files', 'a.json')
+  : path.join(__dirname, 'files', 'b.json');
+
+const unknownData = JSON.parse(await readFile(jsonFilePath, 'utf8'));
+
+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}`);
+console.log(unknownData);
+
+const myServer = createServerHttp((_, res) => {
+  res.end('Request accepted');
+});
+
+const PORT = 3000;
+
+myServer.listen(PORT, () => {
+  console.log(`Server is listening on port ${PORT}`);
+  console.log('To terminate it, use Ctrl+C combination');
+});
+
+export { unknownData as unknownObject, myServer };

src/streams/read.js

@@ -1,5 +1,35 @@
+import { createReadStream } from 'node:fs';
+import { access } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
 const read = async () => {
-  // Write your code here
+  const filePath = path.join(__dirname, 'files', 'fileToRead.txt');
+
+  try {
+    await access(filePath);
+
+    const stream = createReadStream(filePath, 'utf8');
+
+    stream.on('error', () => {
+      throw new Error('FS operation failed');
+    });
+
+    stream.on('data', chunk => {
+      process.stdout.write(chunk);
+    });
+
+    stream.on('end', () => {
+      process.stdout.write('\n');
+    });
+
+  } catch (err) {
+    throw new Error('FS operation failed');
+  }
 };
 
+
 await read();

src/streams/transform.js

@@ -1,5 +1,17 @@
+import { Transform } from 'node:stream';
+
 const transform = async () => {
-  // Write your code here
+  const transform = new Transform({
+    transform(chunk, encoding, callback) {
+      const reversed = chunk.toString().split('').reverse().join('');
+      this.push(reversed);
+      callback();
+    }
+  });
+
+  console.log('Type something. Press Ctrl+Enter (on Windows) to finish.');
+
+  process.stdin.pipe(transform).pipe(process.stdout);
 };
 
 await transform();