Node.js Fundamentals and Environment Setup

// package.json
{
  "name": "nodejs-fundamentals",
  "version": "1.0.0",
  "description": "Learning Node.js fundamentals",
  "main": "index.js",
  "scripts": {
    "start": "node index.js",
    "dev": "nodemon index.js",
    "test": "jest"
  },
  "keywords": ["nodejs", "javascript", "backend"],
  "author": "Your Name",
  "license": "MIT",
  "dependencies": {
    "express": "^4.18.2"
  },
  "devDependencies": {
    "nodemon": "^3.0.1",
    "jest": "^29.6.2"
  }
}

// index.js - Basic Node.js concepts demonstration
const http = require('http');
const fs = require('fs').promises;
const path = require('path');

class NodeJSFundamentals {
  constructor() {
    this.server = null;
    this.port = process.env.PORT || 3000;
  }

  // Demonstrate event-driven programming
  createEventEmitter() {
    const EventEmitter = require('events');
    const myEmitter = new EventEmitter();

    myEmitter.on('userAction', (action, timestamp) => {
      console.log(`User performed: ${action} at ${timestamp}`);
    });

    myEmitter.on('error', (error) => {
      console.error('Error occurred:', error.message);
    });

    // Emit events
    myEmitter.emit('userAction', 'login', new Date().toISOString());
    myEmitter.emit('userAction', 'logout', new Date().toISOString());

    return myEmitter;
  }

  // Demonstrate async/await with file operations
  async demonstrateAsyncOperations() {
    try {
      console.log('=== Async Operations Demo ===');
      
      // Create a temporary file
      const tempContent = 'Hello from Node.js!';
      const tempFile = path.join(__dirname, 'temp.txt');
      
      await fs.writeFile(tempFile, tempContent, 'utf8');
      console.log('File created successfully');
      
      // Read the file
      const readContent = await fs.readFile(tempFile, 'utf8');
      console.log('File content:', readContent);
      
      // Delete the file
      await fs.unlink(tempFile);
      console.log('File deleted successfully');
      
    } catch (error) {
      console.error('Error in async operations:', error.message);
    }
  }

  // Demonstrate streams
  demonstrateStreams() {
    console.log('\n=== Streams Demo ===');
    
    const { Readable, Writable, Transform } = require('stream');
    
    // Create a readable stream
    const readable = new Readable({
      read() {}
    });
    
    // Create a transform stream
    const transform = new Transform({
      transform(chunk, encoding, callback) {
        const transformed = chunk.toString().toUpperCase();
        callback(null, transformed);
      }
    });
    
    // Create a writable stream
    const writable = new Writable({
      write(chunk, encoding, callback) {
        console.log('Received:', chunk.toString());
        callback();
      }
    });
    
    // Pipe the streams together
    readable.pipe(transform).pipe(writable);
    
    // Push data to readable stream
    readable.push('hello world');
    readable.push('node.js is awesome');
    readable.push(null); // End the stream
  }

  // Demonstrate Buffer operations
  demonstrateBuffers() {
    console.log('\n=== Buffer Demo ===');
    
    // Create buffers
    const buffer1 = Buffer.from('Hello');
    const buffer2 = Buffer.from(' World');
    
    // Concatenate buffers
    const combined = Buffer.concat([buffer1, buffer2]);
    console.log('Combined buffer:', combined.toString());
    
    // Buffer to JSON
    const bufferInfo = {
      length: combined.length,
      content: combined.toString(),
      hex: combined.toString('hex'),
      base64: combined.toString('base64')
    };
    
    console.log('Buffer information:', bufferInfo);
  }

  // Create a basic HTTP server
  createServer() {
    this.server = http.createServer((req, res) => {
      const { method, url } = req;
      
      console.log(`${method} ${url}`);
      
      // Set CORS headers
      res.setHeader('Access-Control-Allow-Origin', '*');
      res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
      res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
      
      if (method === 'OPTIONS') {
        res.writeHead(200);
        res.end();
        return;
      }
      
      // Handle different routes
      if (method === 'GET' && url === '/') {
        res.writeHead(200, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({
          message: 'Welcome to Node.js Fundamentals!',
          timestamp: new Date().toISOString(),
          features: ['Event-driven', 'Non-blocking I/O', 'Streams', 'Buffers']
        }));
      } else if (method === 'GET' && url === '/health') {
        res.writeHead(200, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({
          status: 'healthy',
          uptime: process.uptime(),
          memory: process.memoryUsage()
        }));
      } else {
        res.writeHead(404, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({ error: 'Not Found' }));
      }
    });
    
    this.server.listen(this.port, () => {
      console.log(`🚀 Server running at http://localhost:${this.port}`);
      console.log('Available endpoints:');
      console.log('  GET / - Welcome message');
      console.log('  GET /health - Health check');
    });
    
    return this.server;
  }

  // Demonstrate process management
  demonstrateProcessManagement() {
    console.log('\n=== Process Management Demo ===');
    
    console.log('Process ID:', process.pid);
    console.log('Node.js version:', process.version);
    console.log('Platform:', process.platform);
    console.log('Architecture:', process.arch);
    console.log('Current working directory:', process.cwd());
    console.log('Environment variables:', Object.keys(process.env).length);
    
    // Handle process signals
    process.on('SIGINT', () => {
      console.log('\n🛑 Received SIGINT, shutting down gracefully...');
      if (this.server) {
        this.server.close(() => {
          console.log('Server closed');
          process.exit(0);
        });
      } else {
        process.exit(0);
      }
    });
    
    process.on('SIGTERM', () => {
      console.log('\n🛑 Received SIGTERM, shutting down gracefully...');
      if (this.server) {
        this.server.close(() => {
          console.log('Server closed');
          process.exit(0);
        });
      } else {
        process.exit(0);
      }
    });
  }

  async run() {
    console.log('🎯 Node.js Fundamentals Demonstration\n');
    
    // Run all demonstrations
    this.createEventEmitter();
    await this.demonstrateAsyncOperations();
    this.demonstrateStreams();
    this.demonstrateBuffers();
    this.createServer();
    this.demonstrateProcessManagement();
    
    console.log('\n✅ All demonstrations completed!');
    console.log('Press Ctrl+C to stop the server');
  }
}

// Run the demonstration
if (require.main === module) {
  const demo = new NodeJSFundamentals();
  demo.run().catch(console.error);
}

module.exports = NodeJSFundamentals;