Task 1: node.js basics

src/cli/args.js

@@ -1,5 +1,19 @@
 const parseArgs = () => {
-    // Write your code here 
+    const envArguments = process.argv,
+          resultArray = [];
+    if(envArguments) {
+        envArguments.forEach((argValue, index, envArguments) => {
+            if (argValue.startsWith('--')){
+                const resultString = `${argValue.split('--')[1]} is ${envArguments[index + 1]}`;
+                resultArray.push(resultString);
+            }
+        });
+
+        console.log(resultArray.join(', '));
+    } else {
+        throw new Error('No environment arguments were found');
+    }
+
 };
 
 parseArgs();

src/cli/env.js

@@ -1,5 +1,14 @@
 const parseEnv = () => {
-    // Write your code here 
+    const envProps = Object.entries(process.env);
+    if (envProps) {
+        const resultString = envProps
+            .filter(([propName, _]) => propName.startsWith('RSS_'))
+            .map(([propName, propValue]) => `${propName}=${propValue}`)
+            .join(';');
+        console.log(resultString);
+    } else {
+        throw new Error('No environment props were found');
+    }
 };
 
 parseEnv();

src/cp/cp.js

@@ -1,6 +1,25 @@
+import { spawn } from 'child_process';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
 const spawnChildProcess = async (args) => {
-    // Write your code here
+    const __filename = fileURLToPath(import.meta.url),
+          __dirname = dirname(__filename),
+          pathToScript = './files/script.js';
+
+    const childProcess = spawn('node', [join(__dirname, pathToScript), ...args], {
+        stdio: ['pipe', 'pipe', 'inherit', 'ipc']
+    });
+
+    childProcess.stdout.pipe(process.stdout);
+    process.stdin.pipe(childProcess.stdin);
+
+    childProcess.on('error', (childprocessError) => {
+        throw childprocessError;
+    });
+
+    return childProcess;
 };
 
 // Put your arguments in function call to test this functionality
-spawnChildProcess( /* [someArgument1, someArgument2, ...] */);
+spawnChildProcess(['balerina capuchina', 'some other meme from tik-tok']);

src/fs/copy.js

@@ -1,5 +1,30 @@
+import fs from 'fs';
+
 const copy = async () => {
-    // Write your code here 
+    const sourceDirPath = './src/fs/files/',
+          targetDirPath = './src/fs/files_copy/';
+
+    fs.access(sourceDirPath, fs.constants.F_OK, (accessError) => {
+        if (accessError) {
+            throw new Error('FS operation failed');
+        }
+    });
+
+    fs.access(targetDirPath, fs.constants.F_OK, (accessError) => {
+        if (accessError) {
+            fs.cp(sourceDirPath, targetDirPath, {force: false, errorOnExist: true, recursive: true}, (copyFolderError) => {
+                if (copyFolderError) {
+                    throw copyFolderError;
+                } else {
+                    console.log('Folder "Files" is successfully copied to "Files_copy"');
+                }
+
+            });
+        } else {
+            throw new Error('FS operation failed');
+        }
+    });
+
 };
 
 await copy();

src/fs/create.js

@@ -1,5 +1,22 @@
+import fs from 'fs';
+
 const create = async () => {
-    // Write your code here 
+    const filePath = './src/fs/files/fresh.txt';
+
+    fs.access(filePath, fs.constants.F_OK, (accessError) => {
+        if (accessError) {
+            fs.writeFile(filePath, 'I am fresh and young', (creationError) => {
+                if (creationError) {
+                    throw creationError;
+                } else {
+                    console.log('File is created successfully');
+                }
+
+            });
+        } else {
+            throw new Error('FS operation failed');
+        }
+    })
 };
 
 await create();

src/fs/delete.js

@@ -1,5 +1,14 @@
+import fs from 'fs/promises';
+
 const remove = async () => {
-    // Write your code here 
+    const targetFilePath = './src/fs/files/fileToRemove.txt';
+
+    try {
+        await fs.rm(targetFilePath);
+        console.log('File "fileToRemove" is removed');
+    } catch (removeFileError) {
+        throw new Error('FS operation failed');
+    }
 };
 
 await remove();

src/fs/files/fresh.txt

@@ -0,0 +1 @@
+I am fresh and young

src/fs/files_copy/dontLookAtMe.txt

@@ -0,0 +1 @@
+What are you looking at?!

src/fs/files_copy/fileToRead.txt

@@ -0,0 +1,7 @@
+My content
+should
+be
+printed
+into
+console
+!

src/fs/files_copy/fileToRemove.txt

@@ -0,0 +1 @@
+How dare you!

src/fs/files_copy/fresh.txt

@@ -0,0 +1 @@
+I am fresh and young

src/fs/files_copy/hello.txt

@@ -0,0 +1 @@
+Hello Node.js

src/fs/files_copy/wrongFilename.txt

@@ -0,0 +1,3 @@
+# This is a file with a wrong filename
+
+Hello from **markdown**!

src/fs/list.js

@@ -1,5 +1,19 @@
+import fs from 'fs/promises';
+
 const list = async () => {
-    // Write your code here 
+    const targerDirPath = './src/fs/files';
+    try {
+        await fs.access(targerDirPath, fs.constants.F_OK);
+    } catch (accessError) {
+        throw new Error('FS operation failed');
+    }
+
+    try {
+        const listOfFiles = await fs.readdir(targerDirPath, {recursive: true});
+        console.log('Files from folder "fiiles":', listOfFiles);
+    } catch (readDirError) {
+        throw readDirError;
+    }
 };
 
 await list();

src/fs/read.js

@@ -1,5 +1,14 @@
+import fs from 'fs/promises';
+
 const read = async () => {
-    // Write your code here 
+    const targetFilePath = './src/fs/files/fileToRead.txt';
+
+    try {
+        const filesContent = await fs.readFile(targetFilePath, { encoding: 'utf8' });
+        console.log(filesContent);
+    } catch (readFileError) {
+        throw new Error('FS operation failed');
+    }
 };
 
 await read();

src/fs/rename.js

@@ -1,5 +1,28 @@
+import fs from 'fs';
+
 const rename = async () => {
-    // Write your code here 
+    const wrongFilenamePath = './src/fs/files/wrongFilename.txt',
+          correctFilenamePath = './src/fs/files/properFilename.md';
+
+    fs.access(wrongFilenamePath, fs.constants.F_OK, (accessError) => {
+            if (accessError) {
+                throw new Error('FS operation failed');
+            }
+        });
+
+    fs.access(correctFilenamePath, fs.constants.F_OK, (accessError) => {
+        if (accessError) {
+            fs.rename(wrongFilenamePath, correctFilenamePath, (renameFileError) => {
+                if (renameFileError) {
+                    throw renameFileError;
+                } else {
+                    console.log('Filename is changed to correct one');
+                }
+            });
+        } else {
+            throw new Error('FS operation failed');
+        }
+    });
 };
 
 await rename();

src/hash/calcHash.js

@@ -1,5 +1,16 @@
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { readFile } from 'fs/promises';
+import { createHash } from 'node:crypto';
+
 const calculateHash = async () => {
-    // Write your code here 
+    const __filename = fileURLToPath(import.meta.url),
+          __dirname = dirname(__filename),
+          fullPathToTargetFile = resolve(__dirname, './files/fileToCalculateHashFor.txt'),
+          fileContent = await readFile(fullPathToTargetFile, 'utf8');
+
+    const resultHash = createHash('sha256').update(fileContent).digest('hex');
+    console.log(resultHash);
 };
 
 await calculateHash();

src/modules/esm.mjs

@@ -0,0 +1,54 @@
+import { dirname, sep, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { release, version } from 'node:os';
+import { createServer as createServerHttp } from 'node:http';
+import { readFile } from 'fs/promises';
+import './files/c.cjs';
+
+const random = Math.random();
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+let unknownObject;
+
+async function loadFile(pathToFile) {
+  try {
+	const fullPathToFile = resolve(__dirname, pathToFile);
+    const fileContent = await readFile(fullPathToFile, 'utf8');
+    const json = JSON.parse(fileContent);
+    return json;
+  } catch (error) {
+    console.error('Error loading file:', error);
+    throw error;
+  }
+}
+
+console.log(`Release ${release()}`);
+console.log(`Version ${version()}`);
+console.log(`Path segment separator is "${sep}"`);
+console.log(`Path to current file is ${__filename}`);
+console.log(`Path to current directory is ${__dirname}`);
+
+const myServer = createServerHttp((_, res) => {
+  res.end('Request accepted');
+});
+
+const PORT = 3000;
+
+// Выбираем случайно JSON файл
+if (random > 0.5) {
+unknownObject = await loadFile('./files/a.json');
+} else {
+unknownObject = await loadFile('./files/b.json');
+}
+
+console.log('Loaded object:', 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/streams/files/fileToWrite.txt

@@ -0,0 +1 @@
+balerina capuchina

src/streams/read.js

@@ -1,5 +1,24 @@
+import fs  from 'fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, resolve } from 'node:path';
+
 const read = async () => {
-    // Write your code here 
+    const __filename = fileURLToPath(import.meta.url),
+          __dirname = dirname(__filename),
+          pathToFile = './files/fileToRead.txt',
+          fullPathToFile = resolve(__dirname, pathToFile);
+    const readableStream =  fs.createReadStream(fullPathToFile, 'utf8');
+
+    readableStream.pipe(process.stdout);
+
+    readableStream.on('open', () => {
+        console.log('File is opened successfully');
+    })
+
+    readableStream.on('error', (readError) => {
+        throw readError;
+    });
+
 };
 
 await read();

src/streams/transform.js

@@ -1,5 +1,28 @@
+import { Transform } from 'node:stream';
+
 const transform = async () => {
-    // Write your code here 
+    const transformStream = new Transform({
+        transform(chunk, encoding, callback) {
+            const reversedData = chunk.toString().split('').reverse().join('');
+            this.push(reversedData);
+            callback();
+        }
+    });
+
+    process.stdin.pipe(transformStream).pipe(process.stdout);
+
+    process.stdin.on('error', (writeError) => {
+        throw writeError;
+    });
+
+    process.stdout.on('error', (readError) => {
+        throw readError;
+    });
+
+    transformStream.on('error', (transformError) => {
+        throw transformError;
+    });
+
 };
 
 await transform();