Dev

src/cli/args.js

@@ -1,5 +1,16 @@
 const parseArgs = () => {
-  // Write your code here
+  const { argv } = process;
+  const argsIndexes = [];
+
+  argv.filter((el, index) => el.startsWith('--') && argsIndexes.push(index));
+
+  const result = argsIndexes.map(
+    (index) => `${argv[index].slice(2)} is ${argv[index + 1]}`
+  );
+
+  if (result.length) {
+    console.log(result.join(', '));
+  }
 };
 
 parseArgs();

src/cli/env.js

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

src/cp/cp.js

@@ -1,6 +1,19 @@
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { spawn } from 'child_process';
+
+const FILE_PATH = fileURLToPath(import.meta.url);
+const DIRECTORY_PATH = path.dirname(FILE_PATH);
+
 const spawnChildProcess = async (args) => {
-  // Write your code here
+  const childProcess = spawn('node', [
+    `${DIRECTORY_PATH}/files/script.js`,
+    ...args,
+  ]);
+
+  childProcess.stdout.pipe(process.stdout);
+  process.stdin.pipe(childProcess.stdin);
 };
 
-// Put your arguments in function call to test this functionality
-spawnChildProcess( /* [someArgument1, someArgument2, ...] */);
+//spawnChildProcess( /* [someArgument1, someArgument2, ...] */);
+spawnChildProcess(process.argv);

src/fs/copy.js

@@ -1,5 +1,23 @@
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { cp } from 'fs/promises';
+
+const FILE_PATH = fileURLToPath(import.meta.url);
+const FS_DIRECTORY_PATH = path.dirname(FILE_PATH);
+
 const copy = async () => {
-  // Write your code here
+  try {
+    const sourcePath = path.join(FS_DIRECTORY_PATH, 'files');
+    const targetPath = path.join(FS_DIRECTORY_PATH, 'files_copy');
+
+    await cp(sourcePath, targetPath, {
+      errorOnExist: true,
+      recursive: true,
+      force: false,
+    });
+  } catch (error) {
+    throw new Error('FS operation failed');
+  }
 };
 
 await copy();

src/fs/create.js

@@ -1,5 +1,20 @@
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { open } from 'fs/promises';
+
+const FILE_PATH = fileURLToPath(import.meta.url);
+const FS_DIRECTORY_PATH = path.dirname(FILE_PATH);
+
 const create = async () => {
-  // Write your code here
+  let file;
+
+  try {
+    const sourcePath = path.join(FS_DIRECTORY_PATH, 'files');
+    file = await open(path.join(sourcePath, 'fresh.txt'), 'wx');
+    await file.writeFile('I am fresh and young');
+  } catch (error) {
+    throw new Error('FS operation failed');
+  }
 };
 
 await create();

src/fs/delete.js

@@ -1,5 +1,28 @@
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { existsSync } from 'fs';
+import { rm } from 'fs/promises';
+
+const FILE_PATH = fileURLToPath(import.meta.url);
+const FS_DIRECTORY_PATH = path.dirname(FILE_PATH);
+
 const remove = async () => {
-  // Write your code here
+  const fileToRemove = path.join(
+    FS_DIRECTORY_PATH,
+    'files',
+    'fileToRemove.txt'
+  );
+  const isFileToRemoveExisted = existsSync(fileToRemove);
+
+  if (isFileToRemoveExisted) {
+    try {
+      await rm(fileToRemove);
+    } catch (error) {
+      throw new Error('FS operation failed');
+    }
+  } else {
+    throw new Error('FS operation failed');
+  }
 };
 
 await remove();

src/fs/list.js

@@ -1,5 +1,29 @@
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { existsSync } from 'fs';
+import { readdir } from 'fs/promises';
+
+const FILE_PATH = fileURLToPath(import.meta.url);
+const FS_DIRECTORY_PATH = path.dirname(FILE_PATH);
+
 const list = async () => {
-  // Write your code here
+  const filesDir = path.join(FS_DIRECTORY_PATH, 'files');
+
+  if (existsSync(filesDir)) {
+    try {
+      const files = await readdir(filesDir);
+
+      const fileNames = [];
+      for (const file of files) {
+        fileNames.push(file);
+      }
+      console.log(fileNames);
+    } catch (err) {
+      throw new Error('FS operation failed');
+    }
+  } else {
+    throw new Error('FS operation failed');
+  }
 };
 
 await list();

src/fs/read.js

@@ -1,5 +1,25 @@
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { existsSync } from 'fs';
+import { readFile } from 'fs/promises';
+
+const FILE_PATH = fileURLToPath(import.meta.url);
+const FS_DIRECTORY_PATH = path.dirname(FILE_PATH);
+
 const read = async () => {
-  // Write your code here
+  const sourcePath = path.join(FS_DIRECTORY_PATH, 'files', 'fileToRead.txt');
+  const isFileExisted = existsSync(sourcePath);
+
+  if (isFileExisted) {
+    try {
+      const fileContent = await readFile(sourcePath, { encoding: 'utf8' });
+      console.log(`${fileContent}`);
+    } catch (error) {
+      throw new Error('FS operation failed');
+    }
+  } else {
+    throw new Error('FS operation failed');
+  }
 };
 
 await read();

src/fs/rename.js

@@ -1,5 +1,26 @@
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { existsSync } from 'fs';
+import { rename as fsRename } from 'fs/promises';
+
+const FILE_PATH = fileURLToPath(import.meta.url);
+const FS_DIRECTORY_PATH = path.dirname(FILE_PATH);
+
 const rename = async () => {
-  // Write your code here
+  const sourcePath = path.join(FS_DIRECTORY_PATH, 'files', 'wrongFilename.txt');
+  const targetPath = path.join(FS_DIRECTORY_PATH, 'files', 'properFilename.md');
+
+  const isTargetFileExisted = existsSync(targetPath);
+
+  if (!isTargetFileExisted) {
+    try {
+      await fsRename(sourcePath, targetPath);
+    } catch (error) {
+      throw new Error('FS operation failed');
+    }
+  } else {
+    throw new Error('FS operation failed');
+  }
 };
 
 await rename();

src/hash/calcHash.js

@@ -1,5 +1,29 @@
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { createReadStream } from 'fs';
+import { createHash } from 'crypto';
+
+const FILE_PATH = fileURLToPath(import.meta.url);
+const DIRECTORY_PATH = path.dirname(FILE_PATH);
+
 const calculateHash = async () => {
-  // Write your code here
+  return new Promise((resolve, reject) => {
+    const filePath = path.join(
+      DIRECTORY_PATH,
+      'files',
+      'fileToCalculateHashFor.txt'
+    );
+
+    const hash = createHash('sha256');
+    const stream = createReadStream(filePath);
+
+    stream.on('data', (chunk) => hash.update(chunk));
+    stream.on('end', () => {
+      console.log(hash.digest('hex'));
+      resolve();
+    });
+    stream.on('error', (err) => reject(err));
+  });
 };
 
 await calculateHash();

src/modules/esm.mjs

@@ -0,0 +1,46 @@
+import path from 'path';
+import { release, version } from 'os';
+import { createServer as createServerHttp } from 'http';
+import { fileURLToPath } from 'url';
+import { readFile } from 'fs/promises';
+
+const FILE_PATH = fileURLToPath(import.meta.url);
+const DIRECTORY_PATH = path.dirname(FILE_PATH);
+
+import './files/c.mjs';
+
+const random = Math.random();
+
+const loadFile = async (fileName) => {
+  const filePath = path.join(DIRECTORY_PATH, 'files', fileName);
+  const fileDataRaw = await readFile(filePath, 'utf-8');
+  return JSON.parse(fileDataRaw);
+};
+
+const unknownObject =
+  random > 0.5 ? await loadFile('a.json') : await loadFile('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 ${FILE_PATH}`);
+console.log(`Path to current directory is ${DIRECTORY_PATH}`);
+
+const myServer = createServerHttp((_, res) => {
+  res.end('Request accepted');
+});
+
+const PORT = 3000;
+
+console.log(unknownObject);
+
+myServer.listen(PORT, (error) => {
+  if (error) {
+    return console.log('Server error', error);
+  }
+  console.log(`Server is listening on port ${PORT}`);
+  console.log('To terminate it, use Ctrl+C combination');
+});
+
+export { unknownObject, myServer };

src/modules/files/c.mjs

@@ -0,0 +1 @@
+console.log('Hello from c.mjs!');

src/streams/files/fileToRead.txt

@@ -1 +1 @@
-This file should be read using Streams API
+This file should be read using Streams API

src/streams/read.js

@@ -1,5 +1,24 @@
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { createReadStream } from 'fs';
+
+const FILE_PATH = fileURLToPath(import.meta.url);
+const DIRECTORY_PATH = path.dirname(FILE_PATH);
+
 const read = async () => {
-  // Write your code here
+  const stream = createReadStream(
+    path.join(DIRECTORY_PATH, 'files', 'fileToRead.txt')
+  );
+
+  stream.on('error', (err) => {
+    console.error('Error reading file:', err.message);
+  });
+
+  stream.on('end', () => {
+    console.log('\n--- File reading finished ---');
+  });
+
+  stream.pipe(process.stdout);
 };
 
 await read();

src/streams/transform.js

@@ -1,5 +1,13 @@
+import { stdin, stdout } from 'process';
+import { Transform } from 'stream';
+
 const transform = async () => {
-  // Write your code here
+  const result = new Transform({
+    transform(chunk, _, callBack) {
+      callBack(null, chunk.toString().split('').reverse().join(''));
+    },
+  });
+  stdin.pipe(result).pipe(stdout);
 };
 
 await transform();

src/streams/write.js

@@ -1,5 +1,16 @@
+import path from 'path';
+import { createWriteStream } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+
+const FILE_PATH = fileURLToPath(import.meta.url);
+const DIRECTORY_PATH = dirname(FILE_PATH);
+
 const write = async () => {
-  // Write your code here
+  const stream = createWriteStream(
+    path.join(DIRECTORY_PATH, 'files', 'fileToWrite.txt')
+  );
+  process.stdin.pipe(stream);
 };
 
 await write();