<!-- The problem of the shared global scope -->
<script src="catalog.js"></script>   <!-- defines: var catalog = [...] -->
<script src="reports.js"></script>   <!-- also defines: var catalog = {} -->
<!-- The second overwrites the first. Nobody warns you. Everything breaks. -->

// src/utils/format.js
// PRIVATE: nobody outside this file can see this constant.
const CURRENCY_SYMBOL = 'EUR';

// PRIVATE: an internal helper function.
function splitCents(cents) {
  return { euros: Math.floor(cents / 100), remainder: cents % 100 };
}

// PUBLIC: only this leaves the module.
function formatPrice(cents) {
  const { euros, remainder } = splitCents(cents);
  return `${euros}.${String(remainder).padStart(2, '0')} ${CURRENCY_SYMBOL}`;
}

module.exports = { formatPrice };

// Another file
const { formatPrice } = require('./utils/format.js');

console.log(formatPrice(2500));    // 25.00 EUR
console.log(CURRENCY_SYMBOL);      // ReferenceError: does not exist here
console.log(splitCents);           // ReferenceError: does not exist here

// An object with several things (the most common case)
module.exports = { formatPrice, formatDate };

// A single function
module.exports = function calculateOccupancy(session) { /* ... */ };

// A single class
module.exports = class Event { /* ... */ };

// An array of data
module.exports = [ { id: 'evt-001' }, { id: 'evt-002' } ];

// A primitive value (rare, but legal)
module.exports = 3000;

// Import the whole object
const format = require('./utils/format.js');
console.log(format.formatPrice(2500));

// Destructure only what you need (preferred: you can see at a glance
// what this file uses)
const { formatPrice } = require('./utils/format.js');

// Rename while destructuring, to avoid collisions
const { formatPrice: price } = require('./utils/format.js');

// What Node does, conceptually, before running your code:
const module = { exports: {} };
let exports = module.exports;   // <-- Both point at the SAME object

// src/utils/format.js
exports.formatPrice = formatPrice;   // Works
exports.formatDate = formatDate;     // Works

// Equivalent:
module.exports.formatPrice = formatPrice;

// WRONG: this exports nothing.
exports = { formatPrice, formatDate };

// src/lab/broken-exports.js
exports = { hello: () => 'hello' };
console.log('Inside the module, exports:', exports);              // { hello: [Function] }
console.log('Inside the module, module.exports:', module.exports); // {}

// src/lab/test-exports.js
const loaded = require('./broken-exports.js');
console.log(loaded);          // {}   <- empty
console.log(loaded.hello);    // undefined

const catalog = [];
module.exports = { catalog };

(function (exports, require, module, __filename, __dirname) {
  // ---- Your code goes here, untouched ----
  const catalog = [];
  module.exports = { catalog };
  // ----------------------------------------
});

// src/lab/wrapper.js
console.log(require('node:module').wrapper);

[
  '(function (exports, require, module, __filename, __dirname) { ',
  '\n});'
]

// src/lab/module-variables.js
console.log('__filename:', __filename);
console.log('__dirname :', __dirname);
console.log('module.id :', module.id);        // '.' if it is the entry point
console.log('this === module.exports:', this === module.exports);   // true
console.log('Is the entry point:', require.main === module);

const path = require('node:path');

// WRONG: it depends on where you run node from.
const dataPath = './data/events.json';

// RIGHT: always correct, wherever you run it from.
const dataPath = path.join(__dirname, '..', 'data', 'events.json');

// src/reports/occupancy.js

function generateOccupancyReport(catalog) {
  // ... report logic ...
}

// Only if it is run directly with "node src/reports/occupancy.js"
if (require.main === module) {
  const { catalog } = require('../catalog-data.js');
  console.log(generateOccupancyReport(catalog));
}

module.exports = { generateOccupancyReport };

require('./domain/event')
// 1. ./domain/event            (as is)
// 2. ./domain/event.js         <-- normally here
// 3. ./domain/event.json
// 4. ./domain/event.node       (binary C++ addon)

require('./domain')
// 1-4. The above with "domain"...
// 5. ./domain/package.json     -> reads its "main" field
// 6. ./domain/index.js         <-- the usual pattern
// 7. ./domain/index.json

From /home/joan/escena-viva/src/server/routes.js, require('express') looks in:

/home/joan/escena-viva/src/server/node_modules/express
/home/joan/escena-viva/src/node_modules/express
/home/joan/escena-viva/node_modules/express          <-- normally here
/home/joan/node_modules/express
/home/node_modules/express
/node_modules/express

console.log(module.paths);

// Returns the array directly, with no JSON.parse.
const catalog = require('./data/events.json');
console.log(catalog.length);   // 3

// src/lab/counter.js
console.log('>> the counter.js module is being EVALUATED');

let count = 0;

function increment() {
  count++;
  return count;
}

function value() {
  return count;
}

module.exports = { increment, value };

// src/lab/use-counter.js
console.log('--- First require ---');
const first = require('./counter.js');

console.log('--- Second require ---');
const second = require('./counter.js');

console.log('--- Third require ---');
const third = require('./counter.js');

console.log('');
console.log('Are they the same object?', first === second, second === third);

first.increment();
first.increment();
second.increment();

console.log('Value seen from "first":', first.value());
console.log('Value seen from "third":', third.value());

--- First require ---
>> the counter.js module is being EVALUATED
--- Second require ---
--- Third require ---

Are they the same object? true true
Value seen from "first": 3
Value seen from "third": 3

// src/data/connection.js
// The database connection pool: one single pool in the whole process.

const pool = createConnectionPool({ max: 20 });

module.exports = { pool };

// DANGER: the configuration is mutable and global.
// src/config.js
module.exports = { ticketLimitPerOrder: 10 };

// In another file, somebody does:
const config = require('./config.js');
config.ticketLimitPerOrder = 999;   // Changes it for the WHOLE application

module.exports = Object.freeze({ ticketLimitPerOrder: 10 });

// Instead of exporting an instance (a forced singleton)...
module.exports = { manager: new SalesManager(catalog) };

// ...export the class and let each caller create its own.
module.exports = { SalesManager };

// Paths of every loaded module
console.log(Object.keys(require.cache));

// Force a module to be re-evaluated on the next require
delete require.cache[require.resolve('./counter.js')];

const fresh = require('./counter.js');   // Re-evaluated: count = 0

// src/lab/circular-a.js
console.log('A: starts being evaluated');

const b = require('./circular-b.js');
console.log('A: b is', b);

module.exports = { name: 'module A' };
console.log('A: finishes being evaluated');

// src/lab/circular-b.js
console.log('B: starts being evaluated');

const a = require('./circular-a.js');
console.log('B: a is', a);          // <-- here comes the surprise

module.exports = { name: 'module B' };
console.log('B: finishes being evaluated');

node src/lab/circular-a.js

A: starts being evaluated
B: starts being evaluated
B: a is {}          <-- an EMPTY object, not { name: 'module A' }
B: finishes being evaluated
A: b is { name: 'module B' }
A: finishes being evaluated

// In circular-b.js
const { createEvent } = require('./circular-a.js');
createEvent();   // TypeError: createEvent is not a function

BEFORE                               AFTER
escena-viva/                         escena-viva/
├── data/                            ├── data/
│   └── events.json                  │   └── events.json
└── src/                             └── src/
    ├── catalog.js   <- embedded         ├── catalog.js       <- presentation only
    │                    data            ├── catalog-data.js  <- data only
    └── catalog-data.js  <- no           ├── domain/
                        module.exports   │   ├── session.js
                                         │   ├── event.js
                                         │   ├── sales-manager.js
                                         │   └── index.js
                                         └── utils/
                                             └── format.js

// src/utils/format.js
// Escena Viva presentation utilities.
// No dependencies: it is the most basic module in the project.

// Turns 2500 (cents) into the string '25.00 EUR'.
function formatPrice(cents) {
  const euros = Math.floor(cents / 100);
  const remainder = String(cents % 100).padStart(2, '0');
  return `${euros}.${remainder} EUR`;
}

// Turns '2026-10-03T20:00:00' into '03/10/2026 20:00'.
function formatDate(isoDate) {
  const date = new Date(isoDate);
  const day = String(date.getDate()).padStart(2, '0');
  const month = String(date.getMonth() + 1).padStart(2, '0');
  const year = date.getFullYear();
  const hour = String(date.getHours()).padStart(2, '0');
  const minute = String(date.getMinutes()).padStart(2, '0');
  return `${day}/${month}/${year} ${hour}:${minute}`;
}

// Generates a ticket code: EV-2026-000123
function generateTicketCode(year, sequence) {
  return `EV-${year}-${String(sequence).padStart(6, '0')}`;
}

module.exports = { formatPrice, formatDate, generateTicketCode };

// src/domain/session.js
// A session is a specific showing of an event, with its date, capacity and price.

const { formatPrice, formatDate } = require('../utils/format.js');

class Session {
  // Private field: the only way to modify it is through sell().
  #sold = 0;

  constructor({ id, dateTime, capacity, sold = 0, priceCents }) {
    this.id = id;
    this.dateTime = dateTime;
    this.capacity = capacity;
    this.priceCents = priceCents;
    this.#sold = sold;
  }

  get sold() {
    return this.#sold;
  }

  get available() {
    return this.capacity - this.#sold;
  }

  get occupancy() {
    return Math.round((this.#sold / this.capacity) * 100);
  }

  get soldOut() {
    return this.available === 0;
  }

  get priceEuros() {
    return (this.priceCents / 100).toFixed(2);
  }

  // Revenue in cents, an integer.
  get revenueCents() {
    return this.#sold * this.priceCents;
  }

  sell(quantity = 1) {
    if (!Number.isInteger(quantity) || quantity < 1) {
      const error = new Error('The quantity must be a positive integer');
      error.code = 'INVALID_QUANTITY';
      throw error;
    }
    if (quantity > this.available) {
      const error = new Error(`Insufficient capacity in ${this.id}: ${this.available} left`);
      error.code = 'INSUFFICIENT_CAPACITY';
      throw error;
    }

    this.#sold += quantity;
    return this.#sold;
  }

  // A single-row line for the console listing.
  describe() {
    return (
      `${formatDate(this.dateTime)}  ${formatPrice(this.priceCents)}  ` +
      `${this.available}/${this.capacity} available  (${this.occupancy}% occupied)` +
      (this.soldOut ? '  [SOLD OUT]' : '')
    );
  }

  // JSON.stringify automatically calls toJSON if it exists.
  // Without this, the private #sold field would not appear in the serialization.
  toJSON() {
    return {
      id: this.id,
      dateTime: this.dateTime,
      capacity: this.capacity,
      sold: this.#sold,
      priceCents: this.priceCents
    };
  }
}

module.exports = { Session };

// src/domain/event.js
// An event is a scheduled show, with one or more sessions.

const { Session } = require('./session.js');

class Event {
  #sessions = [];

  constructor({ id, title, venue, organizer, category, durationMinutes, status = 'published', sessions = [] }) {
    this.id = id;
    this.title = title;
    this.venue = venue;
    this.organizer = organizer;
    this.category = category;
    this.durationMinutes = durationMinutes;
    this.status = status;

    // We turn the plain objects into Session instances.
    // If they already are, we leave them as they are.
    this.#sessions = sessions.map((s) => (s instanceof Session ? s : new Session(s)));
  }

  get sessions() {
    // Defensive copy: nobody outside can add or remove sessions.
    return [...this.#sessions];
  }

  get sessionCount() {
    return this.#sessions.length;
  }

  get totalCapacity() {
    return this.#sessions.reduce((total, s) => total + s.capacity, 0);
  }

  get ticketsSold() {
    return this.#sessions.reduce((total, s) => total + s.sold, 0);
  }

  get totalAvailableTickets() {
    return this.totalCapacity - this.ticketsSold;
  }

  get occupancy() {
    if (this.totalCapacity === 0) return 0;
    return Math.round((this.ticketsSold / this.totalCapacity) * 100);
  }

  get revenueCents() {
    return this.#sessions.reduce((total, s) => total + s.revenueCents, 0);
  }

  get soldOut() {
    return this.#sessions.every((s) => s.soldOut);
  }

  findSession(sessionId) {
    return this.#sessions.find((s) => s.id === sessionId);
  }

  availableTickets(sessionId) {
    const session = this.findSession(sessionId);
    return session ? session.available : 0;
  }

  reserve(sessionId, quantity = 1) {
    const session = this.findSession(sessionId);

    if (!session) {
      const error = new Error(`Session ${sessionId} does not exist in ${this.id}`);
      error.code = 'SESSION_NOT_FOUND';
      throw error;
    }

    // We delegate to Session: it is the one that knows how to validate its own capacity.
    return session.sell(quantity);
  }

  toString() {
    return `${this.title} (${this.venue}) - ${this.occupancy}% occupied`;
  }

  toJSON() {
    return {
      id: this.id,
      title: this.title,
      venue: this.venue,
      organizer: this.organizer,
      category: this.category,
      durationMinutes: this.durationMinutes,
      status: this.status,
      sessions: this.#sessions.map((s) => s.toJSON())
    };
  }

  static fromJSON(object) {
    return new Event(object);
  }
}

module.exports = { Event };

// src/domain/index.js
// The domain facade: a single entry point for the whole model.
// It lets you write require('./domain') instead of three separate requires.

const { Session } = require('./session.js');
const { Event } = require('./event.js');
const { SalesManager, LOW_CAPACITY_THRESHOLD } = require('./sales-manager.js');

module.exports = { Session, Event, SalesManager, LOW_CAPACITY_THRESHOLD };

// Without a facade: three lines, and the importer must know the internal structure.
const { Session } = require('./domain/session.js');
const { Event } = require('./domain/event.js');
const { SalesManager } = require('./domain/sales-manager.js');

// With a facade: one line, and the internal structure can change without breaking anything.
const { Session, Event, SalesManager } = require('./domain');

// src/catalog-data.js
// The data source for the Escena Viva catalog.
// Until module 3 the data is embedded here; afterwards it will be read
// from data/events.json with fs, and this file will be the only one that changes.

const catalog = [
  {
    id: 'evt-001',
    title: 'Concierto de Otono',
    venue: 'Teatro Almendra',
    organizer: 'org-almendra',
    category: 'concert',
    durationMinutes: 95,
    status: 'published',
    sessions: [
      { id: 'ses-001-1', dateTime: '2026-10-03T20:00:00', capacity: 420, sold: 180, priceCents: 2500 },
      { id: 'ses-001-2', dateTime: '2026-10-04T19:00:00', capacity: 420, sold: 96,  priceCents: 2200 }
    ]
  },
  {
    id: 'evt-002',
    title: 'Noche de Monologos',
    venue: 'Sala Boveda',
    organizer: 'org-boveda',
    category: 'comedy',
    durationMinutes: 80,
    status: 'published',
    sessions: [
      { id: 'ses-002-1', dateTime: '2026-10-10T21:30:00', capacity: 120, sold: 118, priceCents: 1800 },
      { id: 'ses-002-2', dateTime: '2026-10-11T21:30:00', capacity: 120, sold: 45,  priceCents: 1800 },
      { id: 'ses-002-3', dateTime: '2026-10-17T21:30:00', capacity: 120, sold: 12,  priceCents: 1500 }
    ]
  },
  {
    id: 'evt-003',
    title: 'Festival de Jazz de Primavera',
    venue: 'Auditorio Ribera',
    organizer: 'org-ribera',
    category: 'festival',
    durationMinutes: 240,
    status: 'published',
    sessions: [
      { id: 'ses-003-1', dateTime: '2027-04-17T19:00:00', capacity: 900, sold: 640, priceCents: 3800 },
      { id: 'ses-003-2', dateTime: '2027-04-18T19:00:00', capacity: 900, sold: 720, priceCents: 4200 }
    ]
  }
];

// Returns a deep copy so nobody modifies the source by accident.
// structuredClone is native in Node since version 17.
function getCatalog() {
  return structuredClone(catalog);
}

function getEventById(id) {
  const event = catalog.find((e) => e.id === id);
  return event ? structuredClone(event) : undefined;
}

module.exports = { getCatalog, getEventById };

// src/catalog.js
// Entry point of Escena Viva's console catalog.
// Usage:
//   node src/catalog.js
//   node src/catalog.js --venue="Teatro Almendra"
//   node src/catalog.js --table
//   node src/catalog.js --max=2000

const { getCatalog } = require('./catalog-data.js');
const { Event } = require('./domain');
const { formatPrice } = require('./utils/format.js');

// --- Reading arguments ---

function readOptions(args) {
  const options = { venue: null, table: false, maxPriceCents: Infinity };

  for (const arg of args) {
    if (arg === '--table') {
      options.table = true;
    } else if (arg.startsWith('--venue=')) {
      options.venue = arg.slice('--venue='.length);
    } else if (arg.startsWith('--max=')) {
      options.maxPriceCents = Number(arg.slice('--max='.length));
    }
  }

  return options;
}

// --- Presentation ---

function showDetail(events) {
  console.log('');
  console.log('==========================================');
  console.log('   ESCENA VIVA - EVENT CATALOG');
  console.log('==========================================');

  for (const event of events) {
    console.log('');
    console.log(`${event.title}  [${event.id}]`);
    console.log(`  Venue     : ${event.venue}`);
    console.log(`  Category  : ${event.category}`);
    console.log(`  Duration  : ${event.durationMinutes} min`);
    console.log(`  Sessions  : ${event.sessionCount}`);
    console.log(`  Available : ${event.totalAvailableTickets} tickets`);
    console.log(`  Occupancy : ${event.occupancy}%`);

    for (const session of event.sessions) {
      // The session knows how to describe itself: catalog.js computes nothing.
      console.log(`    - ${session.describe()}`);
    }
  }

  console.log('');
}

function showTable(events) {
  const rows = events.flatMap((event) =>
    event.sessions.map((session) => ({
      event: event.id,
      title: event.title,
      venue: event.venue,
      session: session.id,
      price: formatPrice(session.priceCents),
      available: session.available,
      occupancy: `${session.occupancy}%`
    }))
  );

  console.table(rows);
}

// --- Main program ---

function main() {
  const options = readOptions(process.argv.slice(2));

  // The plain data is turned into domain objects.
  let events = getCatalog().map((data) => Event.fromJSON(data));

  if (options.venue) {
    events = events.filter((event) => event.venue === options.venue);
  }

  if (options.maxPriceCents < Infinity) {
    events = events.filter((event) =>
      event.sessions.some((s) => s.priceCents <= options.maxPriceCents)
    );
  }

  if (events.length === 0) {
    // Diagnostics on stderr, per the project convention.
    console.error('There are no events matching the given criteria.');
    process.exitCode = 1;
    return;
  }

  if (options.table) {
    showTable(events);
  } else {
    showDetail(events);
  }

  const totalCapacity = events.reduce((t, e) => t + e.totalCapacity, 0);
  const sold = events.reduce((t, e) => t + e.ticketsSold, 0);
  const revenue = events.reduce((t, e) => t + e.revenueCents, 0);

  console.error(
    `${events.length} events | capacity ${totalCapacity} | sold ${sold} | ` +
    `available ${totalCapacity - sold} | revenue ${formatPrice(revenue)}`
  );
}

// It only runs if this file is the main program.
if (require.main === module) {
  main();
}

module.exports = { readOptions, main };

node src/catalog.js --table

┌─────────┬───────────┬─────────────────────────────────┬────────────────────┬─────────────┬─────────────┬───────────┬───────────┐
│ (index) │ event     │ title                           │ venue              │ session     │ price       │ available │ occupancy │
├─────────┼───────────┼─────────────────────────────────┼────────────────────┼─────────────┼─────────────┼───────────┼───────────┤
│ 0       │ 'evt-001' │ 'Concierto de Otono'            │ 'Teatro Almendra'  │ 'ses-001-1' │ '25.00 EUR' │ 240       │ '43%'     │
│ 1       │ 'evt-001' │ 'Concierto de Otono'            │ 'Teatro Almendra'  │ 'ses-001-2' │ '22.00 EUR' │ 324       │ '23%'     │
│ 2       │ 'evt-002' │ 'Noche de Monologos'            │ 'Sala Boveda'      │ 'ses-002-1' │ '18.00 EUR' │ 2         │ '98%'     │
│ 3       │ 'evt-002' │ 'Noche de Monologos'            │ 'Sala Boveda'      │ 'ses-002-2' │ '18.00 EUR' │ 75        │ '38%'     │
│ 4       │ 'evt-002' │ 'Noche de Monologos'            │ 'Sala Boveda'      │ 'ses-002-3' │ '15.00 EUR' │ 108       │ '10%'     │
│ 5       │ 'evt-003' │ 'Festival de Jazz de Primavera' │ 'Auditorio Ribera' │ 'ses-003-1' │ '38.00 EUR' │ 260       │ '71%'     │
│ 6       │ 'evt-003' │ 'Festival de Jazz de Primavera' │ 'Auditorio Ribera' │ 'ses-003-2' │ '42.00 EUR' │ 180       │ '80%'     │
└─────────┴───────────┴─────────────────────────────────┴────────────────────┴─────────────┴─────────────┴───────────┴───────────┘
3 events | capacity 3000 | sold 1811 | available 1189 | revenue 62298.00 EUR

// WRONG: exposes internal details nobody outside needs.
module.exports = {
  formatPrice,
  splitCents,            // Internal helper
  CURRENCY_SYMBOL,       // Internal constant
  formatCache            // Internal state
};

// RIGHT: only what is part of the contract.
module.exports = { formatPrice };

// WRONG: requiring this module opens a connection, reads a file
// and prints to the console. Without anyone asking for it.
const connection = connectToDatabase();
const data = fs.readFileSync('data/events.json');
console.log('Catalog module loaded');

module.exports = { connection, data };

// RIGHT: the module defines capabilities. Whoever wants them invokes them.
function connect(options) { /* ... */ }
function loadData(path) { /* ... */ }

module.exports = { connect, loadData };

// At the top of the file, grouped and ordered:
const path = require('node:path');           // 1. Node core
const express = require('express');          // 2. External packages
const { Event } = require('./domain');       // 3. Your own modules

// WRONG: the dependency is only discovered at run time.
if (process.env.MODE === 'production') {
  logger = require('./production-logger.js');
}

// Less flexible: it forces a singleton and complicates testing.
module.exports = { manager: new SalesManager(catalog) };

// More flexible: each caller creates its own, when and how it wants.
module.exports = { SalesManager };

// src/utils/helpers.js
const fs = require('fs');

console.log('Loading helpers...');

const catalog = JSON.parse(fs.readFileSync('./data/events.json', 'utf8'));

var CONFIG = { limit: 10 };

function formatPrice(c) {
  return (c / 100).toFixed(2) + ' EUR';
}

function _round(n) {
  return Math.round(n);
}

exports = { formatPrice, _round, CONFIG, catalog };

// src/utils/format.js
// Formatting only. No dependencies, no side effects.

function formatPrice(cents) {
  const euros = Math.floor(cents / 100);
  const remainder = String(cents % 100).padStart(2, '0');
  return `${euros}.${remainder} EUR`;
}

module.exports = { formatPrice };

// src/config.js
// Application configuration. Frozen so that nobody can modify it.

module.exports = Object.freeze({
  ticketLimitPerOrder: 10,
  lowCapacityThreshold: 0.10
});

// src/catalog-data.js
// Data access. The read happens when it is REQUESTED, not on load.

const fs = require('node:fs');
const path = require('node:path');

// A path relative TO THE FILE, not to the working directory.
const DATA_PATH = path.join(__dirname, '..', 'data', 'events.json');

function getCatalog() {
  const content = fs.readFileSync(DATA_PATH, 'utf8');
  return JSON.parse(content);
}

module.exports = { getCatalog };

// src/reports/occupancy.js
// Escena Viva occupancy reports.
// It receives the events as an argument: it knows nothing about their origin.

const { formatPrice } = require('../utils/format.js');

// Aggregated summary by venue.
function summarizeByVenue(events) {
  const byVenue = new Map();

  for (const event of events) {
    const accumulated = byVenue.get(event.venue) ?? {
      venue: event.venue, events: 0, sessions: 0,
      capacity: 0, sold: 0, revenueCents: 0
    };

    accumulated.events += 1;
    accumulated.sessions += event.sessionCount;
    accumulated.capacity += event.totalCapacity;
    accumulated.sold += event.ticketsSold;
    accumulated.revenueCents += event.revenueCents;

    byVenue.set(event.venue, accumulated);
  }

  return [...byVenue.values()].map((a) => ({
    venue: a.venue,
    events: a.events,
    sessions: a.sessions,
    capacity: a.capacity,
    sold: a.sold,
    available: a.capacity - a.sold,
    occupancy: `${Math.round((a.sold / a.capacity) * 100)}%`,
    revenueEuros: formatPrice(a.revenueCents)
  }));
}

// Sessions below the occupancy threshold.
function sessionsAtRisk(events, thresholdPercent = 20) {
  return events.flatMap((event) =>
    event.sessions
      .filter((session) => session.occupancy < thresholdPercent)
      .map((session) => ({
        event: event.id,
        title: event.title,
        session: session.id,
        available: session.available,
        occupancy: `${session.occupancy}%`
      }))
  );
}

// Sessions with no tickets available.
function soldOutSessions(events) {
  return events.flatMap((event) =>
    event.sessions
      .filter((session) => session.soldOut)
      .map((session) => ({
        event: event.id,
        title: event.title,
        session: session.id,
        capacity: session.capacity,
        revenueEuros: formatPrice(session.revenueCents)
      }))
  );
}

// --- Direct run: only if this file IS the main program ---
if (require.main === module) {
  const { getCatalog } = require('../catalog-data.js');
  const { Event } = require('../domain');

  const events = getCatalog().map((data) => Event.fromJSON(data));
  const threshold = Number(process.argv[2]) || 20;

  console.log('OCCUPANCY BY VENUE');
  console.table(summarizeByVenue(events));

  console.log('');
  console.log(`SESSIONS AT RISK (below ${threshold}%)`);
  const atRisk = sessionsAtRisk(events, threshold);
  if (atRisk.length === 0) {
    console.log('  None.');
  } else {
    console.table(atRisk);
    process.exitCode = 1;
  }

  console.log('');
  console.log('SOLD-OUT SESSIONS');
  const soldOut = soldOutSessions(events);
  if (soldOut.length === 0) {
    console.log('  None.');
  } else {
    console.table(soldOut);
  }
}

module.exports = { summarizeByVenue, sessionsAtRisk, soldOutSessions };

node src/reports/occupancy.js

OCCUPANCY BY VENUE
┌─────────┬────────────────────┬────────┬──────────┬──────────┬──────┬───────────┬───────────┬────────────────┐
│ (index) │ venue              │ events │ sessions │ capacity │ sold │ available │ occupancy │ revenueEuros   │
├─────────┼────────────────────┼────────┼──────────┼──────────┼──────┼───────────┼───────────┼────────────────┤
│ 0       │ 'Teatro Almendra'  │ 1      │ 2        │ 840      │ 276  │ 564       │ '33%'     │ '6612.00 EUR'  │
│ 1       │ 'Sala Boveda'      │ 1      │ 3        │ 360      │ 175  │ 185       │ '49%'     │ '3114.00 EUR'  │
│ 2       │ 'Auditorio Ribera' │ 1      │ 2        │ 1800     │ 1360 │ 440       │ '76%'     │ '52572.00 EUR' │
└─────────┴────────────────────┴────────┴──────────┴──────────┴──────┴───────────┴───────────┴────────────────┘

SESSIONS AT RISK (below 20%)
┌─────────┬───────────┬──────────────────────┬─────────────┬───────────┬───────────┐
│ (index) │ event     │ title                │ session     │ available │ occupancy │
├─────────┼───────────┼──────────────────────┼─────────────┼───────────┼───────────┤
│ 0       │ 'evt-002' │ 'Noche de Monologos' │ 'ses-002-3' │ 108       │ '10%'     │
└─────────┴───────────┴──────────────────────┴─────────────┴───────────┴───────────┘

SOLD-OUT SESSIONS
  None.

// src/lab/test-reports.js
const { soldOutSessions } = require('../reports/occupancy.js');
const { getCatalog } = require('../catalog-data.js');
const { Event } = require('../domain');

const events = getCatalog().map((d) => Event.fromJSON(d));
console.log(`Sold out: ${soldOutSessions(events).length}`);

node src/lab/test-reports.js
# Sold out: 0

// src/lab/sales-log.js
console.error('>> sales-log.js EVALUATING (this must be seen only once)');

const sales = [];

function record(sale) {
  sales.push({ ...sale, recordedAt: new Date().toISOString() });
  return sales.length;
}

function total() {
  return sales.reduce((t, s) => t + s.amountCents, 0);
}

function list() {
  return [...sales];
}

module.exports = { record, total, list };

// src/lab/box-office-a.js
const log = require('./sales-log.js');

function sellFromBoxOfficeA() {
  log.record({ sessionId: 'ses-001-1', quantity: 2, amountCents: 5000 });
}

module.exports = { sellFromBoxOfficeA };

// src/lab/box-office-b.js
const log = require('./sales-log.js');

function sellFromBoxOfficeB() {
  log.record({ sessionId: 'ses-002-2', quantity: 3, amountCents: 5400 });
}

module.exports = { sellFromBoxOfficeB };

// src/lab/demonstrate-cache.js
console.error(`Modules in the cache at the start: ${Object.keys(require.cache).length}`);

const log = require('./sales-log.js');
const { sellFromBoxOfficeA } = require('./box-office-a.js');
const { sellFromBoxOfficeB } = require('./box-office-b.js');

console.error(`Modules in the cache after the requires: ${Object.keys(require.cache).length}`);
console.error('');

// Sales from three different points in the program.
log.record({ sessionId: 'ses-003-1', quantity: 1, amountCents: 3800 });
sellFromBoxOfficeA();
sellFromBoxOfficeB();

console.log('--- Shared state ---');
console.log(`Sales recorded: ${log.list().length}`);
console.log(`Total: ${(log.total() / 100).toFixed(2)} EUR`);

// Identity check.
const otherReference = require('./sales-log.js');
console.log(`Same object? ${log === otherReference}`);
console.log(`Total seen from the other reference: ${(otherReference.total() / 100).toFixed(2)} EUR`);

// --- Clearing the cache ---
console.log('');
console.log('--- After clearing the cache ---');

const path = require.resolve('./sales-log.js');
delete require.cache[path];

const newLog = require('./sales-log.js');   // Re-evaluated
console.log(`Same object as before? ${log === newLog}`);
console.log(`Sales in the new instance: ${newLog.list().length}`);
console.log(`Sales in the old instance: ${log.list().length}`);

console.error('');
console.error(`Modules in the cache at the end: ${Object.keys(require.cache).length}`);

Modules in the cache at the start: 1
>> sales-log.js EVALUATING (this must be seen only once)
Modules in the cache after the requires: 4

--- Shared state ---
Sales recorded: 3
Total: 142.00 EUR
Same object? true
Total seen from the other reference: 142.00 EUR

--- After clearing the cache ---
>> sales-log.js EVALUATING (this must be seen only once)
Same object as before? false
Sales in the new instance: 0
Sales in the old instance: 3

Modules in the cache at the end: 4

// src/lab/circular-order.js
console.error('order.js: starts');

const { Ticket } = require('./circular-ticket.js');
console.error('order.js: Ticket is', typeof Ticket);

class Order {
  constructor(id, sessionId, quantity) {
    this.id = id;
    this.tickets = [];
    for (let i = 0; i < quantity; i++) {
      this.tickets.push(new Ticket(`EV-2026-00000${i + 1}`, sessionId, this));
    }
  }
}

module.exports = { Order };
console.error('order.js: finishes');

// src/lab/circular-ticket.js
console.error('ticket.js: starts');

const { Order } = require('./circular-order.js');
console.error('ticket.js: Order is', typeof Order);   // <-- undefined

class Ticket {
  constructor(code, sessionId, order) {
    this.code = code;
    this.sessionId = sessionId;
    this.order = order;
    this.status = 'valid';
  }

  // Uses Order to validate: it will fail if Order is undefined.
  belongsToValidOrder() {
    return this.order instanceof Order;
  }
}

module.exports = { Ticket };
console.error('ticket.js: finishes');

node src/lab/circular-order.js

order.js: starts
ticket.js: starts
ticket.js: Order is undefined     <-- the symptom
ticket.js: finishes
order.js: Ticket is function
order.js: finishes

// src/domain/ticket.js
// Ticket does NOT need to know the Order class: its identifier is enough.

class Ticket {
  constructor({ code, sessionId, orderId, status = 'valid' }) {
    this.code = code;
    this.sessionId = sessionId;
    this.orderId = orderId;        // Only the id, not the object
    this.status = status;
  }

  use() {
    if (this.status !== 'valid') {
      const error = new Error(`Ticket ${this.code} is ${this.status}`);
      error.code = 'INVALID_TICKET';
      throw error;
    }
    this.status = 'used';
    return this;
  }

  cancel() {
    this.status = 'cancelled';
    return this;
  }
}

module.exports = { Ticket };

// src/domain/order.js
// Order knows Ticket. Ticket does not know Order. No cycle.

const { Ticket } = require('./ticket.js');
const { generateTicketCode } = require('../utils/format.js');

class Order {
  #tickets = [];

  constructor({ id, userId, sessionId, quantity, priceCents, status = 'pending' }) {
    this.id = id;
    this.userId = userId;
    this.sessionId = sessionId;
    this.quantity = quantity;
    this.totalCents = quantity * priceCents;
    this.status = status;
  }

  get tickets() {
    return [...this.#tickets];
  }

  issue(year, startSequence) {
    if (this.status !== 'paid') {
      const error = new Error(`Tickets cannot be issued for a ${this.status} order`);
      error.code = 'INVALID_STATE';
      throw error;
    }

    for (let i = 0; i < this.quantity; i++) {
      this.#tickets.push(new Ticket({
        code: generateTicketCode(year, startSequence + i),
        sessionId: this.sessionId,
        orderId: this.id
      }));
    }

    this.status = 'issued';
    return this.tickets;
  }
}

module.exports = { Order };