Kurs JavaScript i TypeScript · Moduł 5: Zaawansowany JavaScript

CommonJS (require/module.exports)

13 min czytania ·
W tej lekcji11

W poprzednim ćwiczeniu poznaliśmy ES Modules - nowoczesny system modułów w JavaScript. Teraz zagłębimy się w inny, starszy, ale wciąż bardzo ważny system modułów: CommonJS. Choć nasz Park Jurajski potrzebuje najnowszych technologii do monitorowania dinozaurów w przeglądarce, jego solidne zaplecze serwerowe opiera się na Node.js, gdzie dominuje właśnie CommonJS.

Czym jest CommonJS?

CommonJS to system modułów, który został stworzony głównie z myślą o środowisku serwerowym i stał się standardem w ekosystemie Node.js. Zapewnia sposób na organizację kodu JavaScript w odrębne moduły, podobnie jak ES Modules, ale z inną składnią i logiką działania.

W przeciwieństwie do ES Modules, które zostały dodane do języka JavaScript dopiero w ES6 (2015), CommonJS istniał wcześniej i stał się de facto standardem dla Node.js. Nawet teraz, mimo oficjalnego wsparcia dla ES Modules w Node.js, CommonJS pozostaje dominującym formatem dla modułów Node.js i w ekosystemie npm.

Podstawy CommonJS

Główne koncepcje CommonJS to:

  1. Funkcja require() do importowania modułów
  2. Obiekt module.exports lub exports do eksportowania elementów

Przyjrzyjmy się, jak te elementy działają w kontekście naszego systemu Parku Jurajskiego.

Eksportowanie elementów w CommonJS

1. Eksportowanie przez przypisanie do module.exports

Najprostszy sposób eksportowania to przypisanie wartości do module.exports:

// dinosaur.js - Model dinozaura
class Dinosaur {
  constructor(name, species, diet, dangerLevel) {
    this.name = name;
    this.species = species;
    this.diet = diet;
    this.dangerLevel = dangerLevel;
    this.health = 100;
    this.isContained = true;
  }

  feed() {
    this.health = Math.min(100, this.health + 20);
    return `${this.name} został nakarmiony. Poziom zdrowia: ${this.health}%`;
  }

  checkStatus() {
    return {
      name: this.name,
      health: this.health,
      isContained: this.isContained,
      warning: this.dangerLevel > 7 ? "WYSOKI POZIOM ZAGROŻENIA" : ""
    };
  }
}

// Eksport całej klasy
module.exports = Dinosaur;

2. Eksportowanie obiektu z wieloma elementami

Możemy również eksportować wiele elementów, przypisując obiekt do module.exports:

// securityUtils.js - Narzędzia do obsługi bezpieczeństwa
const SECURITY_LEVELS = {
  GREEN: "normalny",
  YELLOW: "podwyższony",
  ORANGE: "wysoki",
  RED: "krytyczny"
};

function checkFenceStatus(sectorId) {
  // Symulacja sprawdzania statusu ogrodzenia w danym sektorze
  const status = Math.random() > 0.1 ? "active" : "failure";
  return {
    sector: sectorId,
    status,
    timestamp: new Date().toISOString()
  };
}

function triggerAlarm(sector, reason) {
  console.log(`ALARM! Sektor ${sector}: ${reason}`);
  // Logika uruchamiania alarmu
  return {
    success: true,
    alarmId: "ALR-" + Math.floor(Math.random() * 10000)
  };
}

function getSecurityStatus() {
  // Zwraca ogólny status bezpieczeństwa parku
  return {
    level: SECURITY_LEVELS.GREEN,
    activeAlarms: 0,
    lastChecked: new Date().toISOString()
  };
}

// Eksportowanie wielu elementów jako obiekt
module.exports = {
  SECURITY_LEVELS,
  checkFenceStatus,
  triggerAlarm,
  getSecurityStatus
};

3. Stopniowe dodawanie do exports

Możemy też dodawać eksporty pojedynczo, używając obiektu exports (który jest referencją do module.exports):

// parkStats.js - Statystyki Parku Jurajskiego
let totalVisitors = 0;
let revenue = 0;
const incidents = [];

// Eksport pierwszej funkcji
exports.addVisitors = function(count) {
  totalVisitors += count;
  return totalVisitors;
};

// Eksport drugiej funkcji
exports.addRevenue = function(amount) {
  revenue += amount;
  return revenue;
};

// Eksport trzeciej funkcji
exports.recordIncident = function(type, location, description) {
  const incident = {
    id: incidents.length + 1,
    type,
    location,
    description,
    timestamp: new Date().toISOString()
  };
  incidents.push(incident);
  return incident;
};

// Eksport czwartej funkcji
exports.getDailyStats = function() {
  return {
    totalVisitors,
    revenue,
    incidentCount: incidents.length
  };
};

UWAGA: Należy pamiętać, że exports jest tylko referencją do module.exports. Jeśli przypisujemy coś bezpośrednio do module.exports, tracimy tę referencję, dlatego nie możemy mieszać tych stylów w jednym pliku:

// To NIE zadziała
exports.someFunction = function() { /* ... */ };
module.exports = SomeClass; // To nadpisuje poprzedni eksport

// To zadziała
exports.someFunction = function() { /* ... */ };
exports.SomeClass = SomeClass;

// To też zadziała
module.exports.someFunction = function() { /* ... */ };
module.exports.SomeClass = SomeClass;

// I to zadziała (przypisanie całego obiektu)
module.exports = {
  someFunction: function() { /* ... */ },
  SomeClass: SomeClass
};

Importowanie modułów w CommonJS

1. Importowanie całego modułu

// app.js
const Dinosaur = require('./dinosaur.js');

// Tworzymy nowe instancje dinozaurów
const trex = new Dinosaur("Rex", "Tyrannosaurus", "carnivore", 9);
const brachi = new Dinosaur("Longneck", "Brachiosaurus", "herbivore", 4);

console.log(trex.checkStatus());
console.log(brachi.feed());

2. Importowanie i destrukturyzacja obiektu

// securityMonitor.js
const security = require('./securityUtils.js');

// Używamy importowanych funkcji i stałych z obiektu
function monitorSecurity() {
  const sectors = ["A1", "B2", "C3", "D4"];

  // Sprawdzamy każdy sektor
  sectors.forEach(sector => {
    const fenceStatus = security.checkFenceStatus(sector);

    if (fenceStatus.status === "failure") {
      const alarmResult = security.triggerAlarm(
        sector,
        "Awaria ogrodzenia elektrycznego!"
      );
      console.log(`Alarm ${alarmResult.alarmId} uruchomiony w sektorze ${sector}`);

      // Aktualizacja statusu bezpieczeństwa
      console.log("Zmiana poziomu bezpieczeństwa na:", security.SECURITY_LEVELS.RED);
    }
  });
}

setInterval(monitorSecurity, 60000); // Sprawdzanie co minutę

3. Destrukturyzacja przy imporcie

W nowszych wersjach Node.js możemy również używać destrukturyzacji bezpośrednio przy imporcie:

// dashboard.js
const { checkFenceStatus, triggerAlarm, SECURITY_LEVELS } = require('./securityUtils.js');

// Teraz możemy używać funkcji bezpośrednio
function checkAllSectors() {
  ["A1", "B2", "C3", "D4"].forEach(sector => {
    console.log(`Sprawdzanie sektora ${sector}: `, checkFenceStatus(sector));

    // Używamy zaimportowanej stałej
    if (Math.random() < 0.1) {
      console.log(`Ustawianie poziomu bezpieczeństwa: ${SECURITY_LEVELS.ORANGE}`);
    }
  });
}

Różnice między CommonJS a ES Modules

Warto zrozumieć kluczowe różnice między CommonJS a ES Modules:

CechaCommonJSES Modules
Składnia importurequire()import ... from ...
Składnia eksportumodule.exports = ... lub exports.x = ...export ... lub export default ...
ŁadowanieSynchroniczneAsynchroniczne (ładowane przed wykonaniem)
WykonanieKod wykonywany przy każdym imporcieKod wykonywany tylko raz, następnie moduł jest buforowany
Statyczna analizaNie wspiera statycznej analizy (dynamiczne ścieżki)Wspiera statyczną analizę (ścieżki są statyczne)
Wsparcie w przeglądarceNie wspierane natywnieWspierane w nowoczesnych przeglądarkach
HoistingImporty nie są hoistowaneImporty są hoistowane (można używać przed deklaracją)
Tree-shakingTrudniejszy do zaimplementowaniaŁatwiejszy dzięki statycznej analizie

Struktura projektu Node.js (backend Parku Jurajskiego)

Teraz przyjrzyjmy się, jak moglibyśmy zorganizować backend naszego systemu zarządzania Parkiem Jurajskim używając Node.js i CommonJS:

jurassic-park-backend/
├── config/
│   ├── database.js     # Konfiguracja bazy danych
│   ├── environment.js  # Zmienne środowiskowe
│   └── security.js     # Ustawienia bezpieczeństwa
├── models/
│   ├── dinosaur.js     # Model dinozaura
│   ├── employee.js     # Model pracownika
│   ├── facility.js     # Model placówki
│   └── index.js        # Agregator modeli
├── controllers/
│   ├── dinosaurController.js  # Kontroler dinozaurów
│   ├── securityController.js  # Kontroler bezpieczeństwa
│   └── employeeController.js  # Kontroler pracowników
├── routes/
│   ├── api.js          # Główny router API
│   ├── dinosaurs.js    # Trasy związane z dinozaurami
│   └── security.js     # Trasy związane z bezpieczeństwem
├── services/
│   ├── monitoringService.js   # Usługa monitorowania
│   ├── notificationService.js # Usługa powiadomień
│   └── loggingService.js      # Usługa logowania
├── utils/
│   ├── logger.js       # Narzędzie do logowania
│   └── validators.js   # Walidatory danych
├── middleware/
│   ├── auth.js         # Middleware autentykacji
│   └── errorHandler.js # Obsługa błędów
├── app.js              # Główna aplikacja
└── server.js           # Plik startowy serwera

Zobaczmy, jak wyglądałyby przykładowe implementacje tych modułów:

Plik konfiguracyjny (config/database.js)

// config/database.js
module.exports = {
  host: process.env.DB_HOST || 'localhost',
  port: process.env.DB_PORT || 27017,
  name: process.env.DB_NAME || 'jurassic_park',
  user: process.env.DB_USER || 'admin',
  password: process.env.DB_PASSWORD || 'secret',

  // Funkcja pomocnicza do tworzenia URI połączenia
  getConnectionString: function() {
    return `mongodb://${this.user}:${this.password}@${this.host}:${this.port}/${this.name}`;
  }
};

Model (models/dinosaur.js)

// models/dinosaur.js
const mongoose = require('mongoose');
const Schema = mongoose.Schema;

// Schemat dinozaura
const dinosaurSchema = new Schema({
  name: { type: String, required: true },
  species: { type: String, required: true },
  diet: { type: String, enum: ['carnivore', 'herbivore', 'omnivore'], required: true },
  dangerLevel: { type: Number, min: 1, max: 10, required: true },
  enclosureId: { type: Schema.Types.ObjectId, ref: 'Enclosure' },
  health: { type: Number, default: 100 },
  status: {
    isContained: { type: Boolean, default: true },
    lastCheck: { type: Date, default: Date.now }
  },
  createdAt: { type: Date, default: Date.now },
  updatedAt: { type: Date, default: Date.now }
});

// Metody schematu
dinosaurSchema.methods.feed = function() {
  this.health = Math.min(100, this.health + 20);
  this.updatedAt = Date.now();
  return this.save();
};

dinosaurSchema.methods.checkStatus = function() {
  return {
    name: this.name,
    health: this.health,
    isContained: this.status.isContained,
    warning: this.dangerLevel > 7 ? "WYSOKI POZIOM ZAGROŻENIA" : ""
  };
};

// Metody statyczne
dinosaurSchema.statics.findDangerous = function() {
  return this.find({ dangerLevel: { $gte: 8 } });
};

// Pre-save hook
dinosaurSchema.pre('save', function(next) {
  this.updatedAt = Date.now();
  next();
});

// Utworzenie modelu
const Dinosaur = mongoose.model('Dinosaur', dinosaurSchema);

// Eksport modelu
module.exports = Dinosaur;

Kontroler (controllers/dinosaurController.js)

// controllers/dinosaurController.js
const Dinosaur = require('../models/dinosaur');
const logger = require('../utils/logger');

// Obiekt kontrolera z wieloma metodami
const dinosaurController = {
  // Pobierz wszystkie dinozaury
  getAllDinosaurs: async (req, res) => {
    try {
      const dinosaurs = await Dinosaur.find().populate('enclosureId');
      res.json(dinosaurs);
    } catch (error) {
      logger.error('Błąd podczas pobierania dinozaurów:', error);
      res.status(500).json({ error: 'Błąd serwera' });
    }
  },

  // Pobierz dinozaura po ID
  getDinosaurById: async (req, res) => {
    try {
      const dinosaur = await Dinosaur.findById(req.params.id).populate('enclosureId');

      if (!dinosaur) {
        return res.status(404).json({ error: 'Dinozaur nie znaleziony' });
      }

      res.json(dinosaur);
    } catch (error) {
      logger.error(`Błąd podczas pobierania dinozaura ID=${req.params.id}: `, error);
      res.status(500).json({ error: 'Błąd serwera' });
    }
  },

  // Dodaj nowego dinozaura
  createDinosaur: async (req, res) => {
    try {
      const { name, species, diet, dangerLevel, enclosureId } = req.body;

      const newDinosaur = new Dinosaur({
        name,
        species,
        diet,
        dangerLevel,
        enclosureId
      });

      await newDinosaur.save();
      logger.info(`Dodano nowego dinozaura: ${name} (${species})`);

      res.status(201).json(newDinosaur);
    } catch (error) {
      logger.error('Błąd podczas tworzenia dinozaura:', error);
      res.status(400).json({ error: error.message });
    }
  },

  // Nakarm dinozaura
  feedDinosaur: async (req, res) => {
    try {
      const dinosaur = await Dinosaur.findById(req.params.id);

      if (!dinosaur) {
        return res.status(404).json({ error: 'Dinozaur nie znaleziony' });
      }

      await dinosaur.feed();
      logger.info(`Nakarmiono dinozaura: ${dinosaur.name}`);

      res.json({
        message: `${dinosaur.name} został nakarmiony. Poziom zdrowia: ${dinosaur.health}%`,
        health: dinosaur.health
      });
    } catch (error) {
      logger.error(`Błąd podczas karmienia dinozaura ID=${req.params.id}: `, error);
      res.status(500).json({ error: 'Błąd serwera' });
    }
  },

  // Znajdź niebezpieczne dinozaury
  getDangerousDinosaurs: async (req, res) => {
    try {
      const dangerousDinos = await Dinosaur.findDangerous();
      res.json(dangerousDinos);
    } catch (error) {
      logger.error('Błąd podczas pobierania niebezpiecznych dinozaurów:', error);
      res.status(500).json({ error: 'Błąd serwera' });
    }
  }
};

// Eksport całego obiektu kontrolera
module.exports = dinosaurController;

Trasy (routes/dinosaurs.js)

// routes/dinosaurs.js
const express = require('express');
const router = express.Router();
const dinosaurController = require('../controllers/dinosaurController');
const authMiddleware = require('../middleware/auth');

// Trasy związane z dinozaurami
router.get('/', dinosaurController.getAllDinosaurs);
router.get('/dangerous', dinosaurController.getDangerousDinosaurs);
router.get('/:id', dinosaurController.getDinosaurById);

// Trasy wymagające uwierzytelnienia
router.post('/', authMiddleware.verifyToken, dinosaurController.createDinosaur);
router.post('/:id/feed', authMiddleware.verifyToken, dinosaurController.feedDinosaur);

// Eksport routera
module.exports = router;

Główny plik aplikacji (app.js)

// app.js
const express = require('express');
const mongoose = require('mongoose');
const cors = require('cors');
const morgan = require('morgan');
const helmet = require('helmet');

// Importy konfiguracji i middleware
const dbConfig = require('./config/database');
const errorHandler = require('./middleware/errorHandler');
const logger = require('./utils/logger');

// Importy tras
const apiRouter = require('./routes/api');
const dinosaurRoutes = require('./routes/dinosaurs');
const securityRoutes = require('./routes/security');

// Inicjalizacja aplikacji Express
const app = express();

// Middleware
app.use(helmet()); // Bezpieczeństwo
app.use(cors()); // Obsługa Cross-Origin Resource Sharing
app.use(morgan('dev')); // Logowanie żądań HTTP
app.use(express.json()); // Parsowanie JSON
app.use(express.urlencoded({ extended: false })); // Parsowanie formularzy

// Połączenie z bazą danych
mongoose.connect(dbConfig.getConnectionString(), {
  useNewUrlParser: true,
  useUnifiedTopology: true
})
.then(() => {
  logger.info('Połączono z bazą danych MongoDB');
})
.catch(err => {
  logger.error('Błąd połączenia z bazą danych:', err);
  process.exit(1);
});

// Trasy
app.use('/api', apiRouter);
app.use('/api/dinosaurs', dinosaurRoutes);
app.use('/api/security', securityRoutes);

// Obsługa błędów 404
app.use((req, res, next) => {
  res.status(404).json({ error: 'Nie znaleziono' });
});

// Centralna obsługa błędów
app.use(errorHandler);

// Eksport aplikacji
module.exports = app;

Plik startowy serwera (server.js)

// server.js
const http = require('http');
const app = require('./app');
const logger = require('./utils/logger');

// Ustawienia portu
const port = process.env.PORT || 3000;
app.set('port', port);

// Utworzenie serwera HTTP
const server = http.createServer(app);

// Nasłuchiwanie na połączenia
server.listen(port, () => {
  logger.info(`Serwer Parku Jurajskiego uruchomiony na porcie ${port}`);
});

// Obsługa błędów serwera
server.on('error', (error) => {
  if (error.syscall !== 'listen') {
    throw error;
  }

  logger.error(`Błąd serwera: ${error}`);
  process.exit(1);
});

Circular Dependencies (Zależności cykliczne)

Jednym z wyzwań przy pracy z CommonJS (i modułami ogólnie) są zależności cykliczne, które występują, gdy moduł A importuje moduł B, a moduł B importuje moduł A:

// dinosaurUtils.js
const Dinosaur = require('./dinosaur');

function isDangerous(dino) {
  return dino.dangerLevel > 7;
}

module.exports = { isDangerous };

// dinosaur.js
const dinosaurUtils = require('./dinosaurUtils'); // Zależność cykliczna!

class Dinosaur {
  // ... implementacja klasy

  isHighRisk() {
    return dinosaurUtils.isDangerous(this);
  }
}

module.exports = Dinosaur;

CommonJS radzi sobie z zależnościami cyklicznymi, ale może to prowadzić do dziwnych zachowań, jak niekompletne obiekty. Aby uniknąć takich problemów:

  1. Przekształć strukturę kodu, aby uniknąć zależności cyklicznych
  2. Użyj wzorca dependency injection
  3. Przenieś współdzielony kod do trzeciego modułu, z którego importują oba

Transpilacja CommonJS do ES Modules i odwrotnie

W wielu projektach musimy obsługiwać zarówno CommonJS, jak i ES Modules. Na przykład frontend naszego Parku Jurajskiego może używać ES Modules, a backend CommonJS. Co zrobić, gdy chcemy współdzielić kod?

Babel do transpilacji

Możemy użyć Babel do transpilacji między formatami:

// babel.config.js dla ES Modules -> CommonJS
module.exports = {
  presets: [
    ['@babel/preset-env', {
      targets: {
        node: 'current'
      },
      modules: 'commonjs' // Konwertuj import/export na require/exports
    }]
  ]
};

Dual Package Hazard

Innym podejściem jest tworzenie pakietów obsługujących oba formaty modułów. W package.json możesz zdefiniować:

{
  "name": "jurassic-park-utils",
  "version": "1.0.0",
  "main": "dist/index.js", // CommonJS entry
  "module": "dist/index.mjs", // ES Module entry
  "exports": {
    "import": "./dist/index.mjs",
    "require": "./dist/index.js"
  }
}

Nowoczesne podejście: Node.js z ES Modules

Nowsze wersje Node.js (od 13.2.0) oficjalnie wspierają ES Modules. Możemy włączyć to wsparcie na kilka sposobów:

  1. Używając rozszerzenia .mjs dla plików z ES Modules
  2. Ustawiając "type": "module" w package.json

Jednak wiele pakietów npm nadal używa CommonJS, więc prawdopodobnie będziesz musiał pracować z oboma systemami.

Praktyczny przykład: Migracja z CommonJS do ES Modules

Załóżmy, że chcemy zmigrować część naszego backendu z CommonJS do ES Modules. Oto jak mogłaby wyglądać taka migracja:

Oryginalna wersja CommonJS (dinosaurController.js)

// controllers/dinosaurController.js (CommonJS)
const Dinosaur = require('../models/dinosaur');
const logger = require('../utils/logger');

function getAllDinosaurs(req, res) {
  // implementacja
}

function getDinosaurById(req, res) {
  // implementacja
}

module.exports = {
  getAllDinosaurs,
  getDinosaurById
};

Migracja do ES Modules (dinosaurController.mjs)

// controllers/dinosaurController.mjs (ES Modules)
import Dinosaur from '../models/dinosaur.mjs';
import logger from '../utils/logger.mjs';

export function getAllDinosaurs(req, res) {
  // implementacja
}

export function getDinosaurById(req, res) {
  // implementacja
}

// Możemy też eksportować domyślnie obiekt z funkcjami
export default {
  getAllDinosaurs,
  getDinosaurById
};

Wrapper do kompatybilności

Czasami potrzebujemy utworzyć wrapper, który pozwoli na import modułu ES Module z kodu CommonJS:

// controllers/dinosaurControllerWrapper.js (CommonJS)
// Ten plik ładuje moduł ES Module i eksportuje go jako CommonJS
const importESM = async () => {
  const controller = await import('./dinosaurController.mjs');
  return controller.default; // lub wybrane funkcje
};

// Eksportujemy funkcję, która zwraca Promise z kontrolerem
module.exports = importESM();

Podsumowanie

CommonJS to powszechnie używany system modułów w Node.js, który pozwala na organizację kodu w odrębne moduły, co jest kluczowe dla budowania skalowalnych aplikacji, takich jak backend naszego systemu zarządzania Parkiem Jurajskim.

Główne koncepcje CommonJS to:

  • Funkcja require() do importowania modułów
  • Obiekt module.exports lub exports do eksportowania elementów
  • Synchroniczne ładowanie modułów
  • Niezbędne buforowanie modułów dla wydajności

Mimo rosnącej popularności ES Modules, CommonJS pozostaje istotnym systemem modułów, szczególnie w ekosystemie Node.js. Zrozumienie różnic między CommonJS a ES Modules jest kluczowe dla efektywnego rozwoju aplikacji JavaScript, które mogą działać zarówno w przeglądarce, jak i na serwerze.

W naszym Parku Jurajskim używamy CommonJS dla backendu (monitoring, baza danych, kontrola bezpieczeństwa) i ES Modules dla frontendu (interfejs użytkownika, dashboardy, powiadomienia). Ta kombinacja zapewnia nam najlepsze z obu światów i pozwala efektywnie zarządzać systemem, który musi być niezawodny - w końcu bezpieczeństwo parku i jego gości zależy od naszego kodu!

W następnym ćwiczeniu przyjrzymy się dynamicznemu importowaniu modułów, które pozwala na jeszcze większą elastyczność w ładowaniu kodu na żądanie, co może być kluczowe w sytuacjach awaryjnych w Parku Jurajskim.

Kod do tej lekcji: main.js
// CommonJS w Parku Jurajskim - Backend Node.js
// Demonstracja systemu require/module.exports

console.log("Backend Parku Jurajskiego - CommonJS");
console.log("System zarządzania serwerem Node.js\n");

// ===========================================
// Symulacja modułów CommonJS
// ===========================================

// === dinosaur.js - Model dinozaura (CommonJS) ===
class Dinosaur {
  constructor(name, species, diet, dangerLevel) {
    this.name = name;
    this.species = species;
    this.diet = diet;
    this.dangerLevel = dangerLevel;
    this.health = 100;
    this.id = `DINO-${Math.random().toString(36).substr(2, 9).toUpperCase()}`;
  }

  feed() {
    this.health = Math.min(100, this.health + 20);
    return { success: true, message: `${this.name} nakarmiony`, health: this.health };
  }

  getDetails() {
    return {
      id: this.id,
      name: this.name,
      species: this.species,
      diet: this.diet,
      dangerLevel: this.dangerLevel,
      health: this.health
    };
  }
}

// CommonJS export - główna klasa
const DinosaurModule = Dinosaur;

// === database.js - Symulacja bazy danych (CommonJS) ===
const database = {
  dinosaurs: new Map(),
  enclosures: new Map(),
  logs: []
};

function saveDinosaur(dinosaur) {
  database.dinosaurs.set(dinosaur.id, dinosaur);
  database.logs.push({ action: 'SAVE_DINOSAUR', id: dinosaur.id, timestamp: Date.now() });
  return { success: true, id: dinosaur.id };
}

function getDinosaur(id) {
  const dino = database.dinosaurs.get(id);
  return dino || null;
}

function getAllDinosaurs() {
  return Array.from(database.dinosaurs.values());
}

function deleteDinosaur(id) {
  const deleted = database.dinosaurs.delete(id);
  if (deleted) {
    database.logs.push({ action: 'DELETE_DINOSAUR', id, timestamp: Date.now() });
  }
  return { success: deleted };
}

function getDatabaseStats() {
  return {
    dinosaurCount: database.dinosaurs.size,
    enclosureCount: database.enclosures.size,
    totalLogs: database.logs.length
  };
}

// CommonJS multiple exports
const DatabaseModule = {
  saveDinosaur,
  getDinosaur,
  getAllDinosaurs,
  deleteDinosaur,
  getDatabaseStats
};

// === config.js - Konfiguracja (CommonJS) ===
const config = {
  server: {
    port: 3000,
    host: 'localhost',
    environment: 'development'
  },
  database: {
    url: 'mongodb://localhost:27017/jurassic-park',
    maxConnections: 10
  },
  security: {
    maxDangerLevel: 10,
    alertThreshold: 7
  },
  park: {
    maxDinosaurs: 50,
    maxVisitors: 1000,
    openingHours: { start: 9, end: 18 }
  }
};

// CommonJS config export
const ConfigModule = config;

// === logger.js - System logowania (CommonJS) ===
const LOG_LEVELS = {
  INFO: 'INFO',
  WARN: 'WARN',
  ERROR: 'ERROR',
  DEBUG: 'DEBUG'
};

function formatLogMessage(level, message) {
  const timestamp = new Date().toISOString();
  return `[${timestamp}] [${level}] ${message}`;
}

function log(level, message) {
  const formatted = formatLogMessage(level, message);
  console.log(formatted);
  database.logs.push({ level, message, timestamp: Date.now() });
}

function info(message) { log(LOG_LEVELS.INFO, message); }
function warn(message) { log(LOG_LEVELS.WARN, message); }
function error(message) { log(LOG_LEVELS.ERROR, message); }
function debug(message) { log(LOG_LEVELS.DEBUG, message); }

// CommonJS logger exports
const LoggerModule = {
  LOG_LEVELS,
  log,
  info,
  warn,
  error,
  debug
};

// === api-routes.js - API endpoints (CommonJS) ===
class DinosaurAPI {
  static createDinosaur(req) {
    const { name, species, diet, dangerLevel } = req.body;

    LoggerModule.info(`Creating dinosaur: ${name}`);

    const dinosaur = new DinosaurModule(name, species, diet, dangerLevel);
    DatabaseModule.saveDinosaur(dinosaur);

    LoggerModule.info(`Dinosaur created: ${dinosaur.id}`);

    return {
      status: 201,
      data: dinosaur.getDetails()
    };
  }

  static getDinosaur(req) {
    const { id } = req.params;
    LoggerModule.debug(`Fetching dinosaur: ${id}`);

    const dinosaur = DatabaseModule.getDinosaur(id);

    if (!dinosaur) {
      LoggerModule.warn(`Dinosaur not found: ${id}`);
      return {
        status: 404,
        error: 'Dinosaur not found'
      };
    }

    return {
      status: 200,
      data: dinosaur.getDetails()
    };
  }

  static listDinosaurs() {
    LoggerModule.debug('Listing all dinosaurs');

    const dinosaurs = DatabaseModule.getAllDinosaurs();

    return {
      status: 200,
      data: dinosaurs.map(d => d.getDetails()),
      count: dinosaurs.length
    };
  }

  static deleteDinosaur(req) {
    const { id } = req.params;
    LoggerModule.info(`Deleting dinosaur: ${id}`);

    const result = DatabaseModule.deleteDinosaur(id);

    if (!result.success) {
      return {
        status: 404,
        error: 'Dinosaur not found'
      };
    }

    LoggerModule.info(`Dinosaur deleted: ${id}`);

    return {
      status: 200,
      data: { deleted: true }
    };
  }

  static getServerStats() {
    LoggerModule.debug('Fetching server stats');

    const dbStats = DatabaseModule.getDatabaseStats();

    return {
      status: 200,
      data: {
        ...dbStats,
        config: {
          maxDinosaurs: ConfigModule.park.maxDinosaurs,
          environment: ConfigModule.server.environment
        }
      }
    };
  }
}

// CommonJS API export
const APIModule = DinosaurAPI;

// ===========================================
// DEMONSTRACJA SYSTEMU COMMONJS
// ===========================================
console.log("=== INICJALIZACJA SERWERA ===\n");

LoggerModule.info('Server starting...');
LoggerModule.info(`Port: ${ConfigModule.server.port}`);
LoggerModule.info(`Environment: ${ConfigModule.server.environment}`);

console.log("\n=== TWORZENIE DINOZAURÓW (API CALLS) ===\n");

// Symulacja requestów API
const req1 = {
  body: { name: 'Rexy', species: 'T-Rex', diet: 'carnivore', dangerLevel: 9 }
};
const response1 = APIModule.createDinosaur(req1);
console.log('POST /api/dinosaurs:', JSON.stringify(response1, null, 2));

const req2 = {
  body: { name: 'Blue', species: 'Velociraptor', diet: 'carnivore', dangerLevel: 7 }
};
const response2 = APIModule.createDinosaur(req2);
console.log('\nPOST /api/dinosaurs:', JSON.stringify(response2, null, 2));

const req3 = {
  body: { name: 'Gentle Giant', species: 'Brachiosaurus', diet: 'herbivore', dangerLevel: 2 }
};
const response3 = APIModule.createDinosaur(req3);
console.log('\nPOST /api/dinosaurs:', JSON.stringify(response3, null, 2));

console.log("\n=== POBIERANIE DANYCH (API CALLS) ===\n");

// Lista wszystkich dinozaurów
const listResponse = APIModule.listDinosaurs();
console.log('GET /api/dinosaurs:', JSON.stringify(listResponse, null, 2));

console.log("\n=== STATYSTYKI SERWERA ===\n");

const statsResponse = APIModule.getServerStats();
console.log('GET /api/stats:', JSON.stringify(statsResponse, null, 2));

console.log("\n=== RÓŻNICE: CommonJS vs ES Modules ===\n");

console.log("CommonJS (Node.js):");
console.log("  - Używa: require() i module.exports");
console.log("  - Synchroniczne ładowanie");
console.log("  - Dynamiczne importy w runtime");
console.log("  - Wartość jest kopiowana\n");

console.log("ES Modules (ES6+):");
console.log("  - Używa: import i export");
console.log("  - Asynchroniczne ładowanie");
console.log("  - Statyczne importy w compile-time");
console.log("  - Wartość jest referencją (live binding)\n");

console.log("Przykład CommonJS:");
console.log("  // dinosaur.js");
console.log("  module.exports = class Dinosaur { ... };");
console.log("");
console.log("  // main.js");
console.log("  const Dinosaur = require('./dinosaur');\n");

console.log("Przykład ES Modules:");
console.log("  // dinosaur.js");
console.log("  export default class Dinosaur { ... }");
console.log("");
console.log("  // main.js");
console.log("  import Dinosaur from './dinosaur.js';\n");

LoggerModule.info('Demo completed successfully!');

console.log("\nBackend Parku Jurajskiego gotowy!");

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

Zadania praktyczne w grze

  • Układanie w poziomie

    Ułóż elementy eksportu funkcji:

  1. Ułóż w kolejnościSkładnia export

Przydatne artykuły