// Node.js
const crypto = require('crypto');

const md5 = crypto.createHash('md5').update('hello').digest('hex');
console.log(md5); // '5d41402abc4b2a76b9719d911017c592'

// Node.js
const sha256 = crypto.createHash('sha256').update('hello').digest('hex');
console.log(sha256);
// '2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824'

// These two different inputs produce the same MD5 hash
// (real example from the 2004 Wang et al. paper — truncated for illustration)
// Input A: d131dd02c5e6eec4...
// Input B: d131dd02c5e6eec5...
// Both hash to: 79054025255fb1a26e4bc422aef54eb4

// HMAC-SHA256 for API signing
const hmac = crypto.createHmac('sha256', process.env.SECRET_KEY);
hmac.update(requestBody);
const signature = hmac.digest('hex');

# lerna.json
{
  "version": "independent",
  "npmClient": "pnpm",
  "useWorkspaces": true,
  "packages": ["packages/*", "apps/*"],
  "command": {
    "publish": {
      "conventionalCommits": true,
      "message": "chore(release): publish"
    }
  }
}

# Run build across all changed packages
npx lerna run build --since origin/main

# Publish all changed packages
npx lerna publish --conventional-commits

# lerna.json — enable Nx integration
{
  "version": "independent",
  "useWorkspaces": true,
  "$schema": "node_modules/lerna/schemas/lerna-schema.json",
  "useNx": true,  // Enable Nx task runner
  "npmClient": "npm"
}

// turbo.json
{
  "$schema": "https://turbo.build/schema.json",
  "tasks": {
    "build": {
      "dependsOn": ["^build"],  // ^ means "all dependencies' build first"
      "inputs": ["src/**", "package.json", "tsconfig.json"],
      "outputs": ["dist/**", ".next/**"]
    },
    "test": {
      "dependsOn": ["build"],
      "inputs": ["src/**", "tests/**"],
      "outputs": []
    },
    "lint": {
      "inputs": ["src/**", ".eslintrc*"],
      "outputs": []
    },
    "dev": {
      "persistent": true,
      "cache": false  // Never cache dev servers
    }
  }
}

# Link to Vercel remote cache
npx turbo login
npx turbo link

# Now every turbo run is potentially a cache hit from any team member's build
turbo build

# Output:
# @acme/ui:build: cache hit, replaying output...
# @acme/utils:build: cache hit, replaying output...
# @acme/web:build: >>> FULL TURBO  (all dependencies were cached)
# Tasks: 12 successful, 12 total
# Cached: 12 cached, 12 total
# Time: 847ms >>> FULL TURBO

my-monorepo/
├── apps/
│   ├── web/          # Next.js app
│   └── docs/         # Docusaurus site
├── packages/
│   ├── ui/           # Shared React components
│   ├── config/       # Shared configs (eslint, tsconfig)
│   └── utils/        # Shared utilities
├── turbo.json
└── package.json      # Workspace root with workspaces field

# nx.json
{
  "$schema": "./node_modules/nx/schemas/nx-schema.json",
  "namedInputs": {
    "default": ["{projectRoot}/**/*", "sharedGlobals"],
    "production": [
      "default",
      "!{projectRoot}/**/*.spec.ts",
      "!{projectRoot}/jest.config.ts"
    ]
  },
  "targetDefaults": {
    "build": {
      "dependsOn": ["^build"],
      "inputs": ["production", "^production"],
      "cache": true
    },
    "test": {
      "inputs": ["default", "^production", "{workspaceRoot}/jest.preset.js"],
      "cache": true
    }
  }
}

# Show what's affected by changes since main branch
npx nx affected:graph

# Run only tests for affected projects
npx nx affected --target=test --base=main

# Run specific project's build
npx nx build my-app

# Run with task runner parallelism
npx nx run-many --target=build --all --parallel=4

# Add a new React app to the monorepo
npx nx g @nx/react:app my-new-app

# Add a shared library
npx nx g @nx/react:lib ui-components --directory=shared

# Add a component to a library
npx nx g @nx/react:component Button --project=shared-ui-components

# Generate a Node.js API
npx nx g @nx/node:app my-api --framework=express

// In CI: distribute 50 test suites across 10 agents
npx nx-cloud start-ci-run --distribute-on="5 linux-medium-js"
npx nx affected --target=test
npx nx-cloud stop-all-agents

// Traditional function
const add = function(a, b) { return a + b; };

// Arrow function — same thing, shorter
const add = (a, b) => a + b;

// Single parameter — parens optional
const double = n => n * 2;

// No parameters — parens required
const getTimestamp = () => Date.now();

// Multi-line body — needs curly braces and explicit return
const processUser = (user) => {
  const fullName = `${user.first} ${user.last}`;
  return { ...user, fullName };
};

// Returning an object literal — wrap in parens
const makePoint = (x, y) => ({ x, y });

// The this binding difference
class Timer {
  constructor() {
    this.count = 0;
  }

  start() {
    // Arrow function: 'this' is the Timer instance
    setInterval(() => {
      this.count++;
      console.log(this.count);
    }, 1000);

    // Regular function would break: 'this' would be undefined (strict mode)
  }
}

const [first, second, third] = [10, 20, 30];
console.log(first); // 10

// Skip elements with commas
const [,, third] = [1, 2, 3];
console.log(third); // 3

// Default values
const [a = 0, b = 0, c = 0] = [1, 2];
console.log(c); // 0

// Swap variables without a temp
let x = 1, y = 2;
[x, y] = [y, x];
console.log(x, y); // 2 1

// Rest element
const [head, ...tail] = [1, 2, 3, 4, 5];
console.log(head); // 1
console.log(tail); // [2, 3, 4, 5]

const user = { id: 1, name: 'Alice', age: 30, role: 'admin' };

const { name, age } = user;
console.log(name); // 'Alice'

// Rename while destructuring
const { name: fullName, role: userRole } = user;
console.log(fullName); // 'Alice'

// Default values
const { name, city = 'Unknown' } = user;
console.log(city); // 'Unknown'

// Nested destructuring
const { address: { street, zip } = {} } = user;

// Rest properties
const { id, ...rest } = user;
console.log(rest); // { name: 'Alice', age: 30, role: 'admin' }

// In function parameters — very common pattern
function displayUser({ name, role, age = 0 }) {
  console.log(`${name} (${role}), age ${age}`);
}
displayUser(user);

// Destructuring API responses
async function loadUser(id) {
  const { data: { user: { name, email } } } = await fetchUser(id);
  return { name, email };
}

const name = 'World';
const greeting = `Hello, ${name}!`;

// Multi-line strings
const html = `


    ## ${user.name}
    ${user.bio}



`;

// Any expression works inside ${}
const price = 9.99;
const tax = 0.08;
const total = `Total: $${(price * (1 + tax)).toFixed(2)}`;

// Tagged templates (advanced)
function highlight(strings, ...values) {
  return strings.reduce((result, str, i) => {
    const val = values[i] !== undefined ? `<mark>${values[i]}</mark>` : '';
    return result + str + val;
  }, '');
}

const name = 'Alice';
const msg = highlight`Welcome back, ${name}! You have ${5} messages.`;
// 'Welcome back, <mark>Alice</mark>! You have <mark>5</mark> messages.'

// Rest: collect multiple arguments into an array
function sum(...numbers) {
  return numbers.reduce((total, n) => total + n, 0);
}
sum(1, 2, 3, 4, 5); // 15

// Spread: expand an array/object into individual values

// Combine arrays
const a = [1, 2, 3];
const b = [4, 5, 6];
const combined = [...a, ...b]; // [1, 2, 3, 4, 5, 6]

// Copy an array
const copy = [...a];

// Spread into function arguments
Math.max(...numbers);

// Merge objects
const defaults = { theme: 'light', lang: 'en', debug: false };
const userPrefs = { theme: 'dark', lang: 'fr' };
const config = { ...defaults, ...userPrefs };
// { theme: 'dark', lang: 'fr', debug: false }

// Add or override a property immutably
const updated = { ...user, name: 'New Name', updatedAt: new Date() };

// Clone with spread (shallow)
const clone = { ...original };

// var: function-scoped, hoisted (avoid in modern code)
var x = 1;

// let: block-scoped, reassignable
let count = 0;
count++;

// const: block-scoped, cannot be reassigned (but objects/arrays can be mutated)
const PI = 3.14159;
const user = { name: 'Alice' };
user.name = 'Bob';       // ✅ OK — mutating the object
user = { name: 'Carol' } // ❌ TypeError — reassigning the binding

// Use const by default, let when you need to reassign, never var

// math.js — named exports
export const PI = 3.14159;
export function add(a, b) { return a + b; }
export function multiply(a, b) { return a * b; }

// Rename on export
export { add as sum };

// Default export (one per file)
export default function divide(a, b) { return a / b; }

// app.js — importing
import divide from './math.js';           // default import
import { add, PI } from './math.js';      // named imports
import { add as plus } from './math.js';  // rename on import
import * as math from './math.js';        // import everything

// Re-export (barrel files)
// index.js
export { add, multiply } from './math.js';
export { default as divide } from './math.js';

class Animal {
  #name;  // private field (ES2022)

  constructor(name, sound) {
    this.#name = name;
    this.sound = sound;
  }

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

  speak() {
    return `${this.#name} says ${this.sound}`;
  }

  static create(name, sound) {
    return new Animal(name, sound);
  }
}

class Dog extends Animal {
  constructor(name) {
    super(name, 'woof');
    this.tricks = [];
  }

  learn(trick) {
    this.tricks.push(trick);
    return this;  // enable chaining
  }

  speak() {
    const base = super.speak();
    return `${base}! It knows: ${this.tricks.join(', ')}`;
  }
}

const dog = new Dog('Rex');
dog.learn('sit').learn('shake');
console.log(dog.speak());
// 'Rex says woof! It knows: sit, shake'

// Optional chaining (?.) — ES2020
const user = null;

// Without optional chaining — throws TypeError
// const city = user.address.city;

// With optional chaining — returns undefined safely
const city = user?.address?.city;

// Works with methods
const result = obj?.method?.();

// Works with arrays/bracket notation
const firstTag = post?.tags?.[0];

// Nullish coalescing (??) — ES2020
// Returns right side only when left is null or undefined (not 0 or '')
const name = user?.name ?? 'Anonymous';
const port = config.port ?? 3000;

// vs logical OR (||) which also triggers on 0, '', false
const port1 = config.port ?? 3000;  // 0 stays 0
const port2 = config.port || 3000;  // 0 becomes 3000 — bug!

// Nullish coalescing assignment (??=) — ES2021
user.preferences ??= {};   // assign only if null/undefined
user.score ||= 0;          // assign if falsy (||=)
user.count &&= user.count + 1; // assign only if truthy (&&=)

// Covered in detail in the Promises guide
// Key syntax reminder:
async function fetchData(url) {
  try {
    const response = await fetch(url);
    return await response.json();
  } catch (error) {
    console.error('Failed:', error);
    throw error;
  }
}

// Set: collection of unique values
const set = new Set([1, 2, 3, 2, 1]);
console.log(set.size); // 3
set.add(4);
set.has(2); // true
set.delete(2);
[...set]; // [1, 3, 4]

// Remove duplicates from an array
const unique = [...new Set([1, 1, 2, 3, 3])]; // [1, 2, 3]

// Map: key-value pairs with any key type
const map = new Map();
const objKey = { id: 1 };
map.set(objKey, 'some value');
map.set('name', 'Alice');
map.get(objKey); // 'some value'
map.size; // 2
map.has('name'); // true

// Iterate
for (const [key, value] of map) {
  console.log(key, value);
}

// Convert object to Map
const obj = { a: 1, b: 2, c: 3 };
const mapFromObj = new Map(Object.entries(obj));

// Convert Map back to object
const objFromMap = Object.fromEntries(map);

// Symbol: unique, immutable primitive
const sym = Symbol('description');
const sym2 = Symbol('description');
sym === sym2; // false — always unique

// Use as object keys to avoid collisions
const ID = Symbol('id');
const obj = { [ID]: 123, name: 'Alice' };
obj[ID]; // 123

// Well-known symbols
class MyArray {
  [Symbol.iterator]() { /* custom iteration */ }
}

// WeakMap: keys must be objects; entries can be garbage collected
const cache = new WeakMap();
function getResult(obj) {
  if (cache.has(obj)) return cache.get(obj);
  const result = expensiveCalc(obj);
  cache.set(obj, result);
  return result;
}

// Logical assignment (ES2021)
a ||= b;   // a = a || b
a &&= b;   // a = a && b
a ??= b;   // a = a ?? b

// Numeric separators (ES2021) — improve readability
const million = 1_000_000;
const hex     = 0xFF_EC_D0;
const bytes   = 0b1010_0001;

// Object.hasOwn() (ES2022) — safer than hasOwnProperty
Object.hasOwn(obj, 'key'); // true if own property

// Array.at() (ES2022) — supports negative indices
const arr = [1, 2, 3, 4, 5];
arr.at(-1);  // 5 (last element)
arr.at(-2);  // 4

// String.at() works the same way
'hello'.at(-1); // 'o'

// structuredClone() (ES2022) — deep clone
const original = { a: 1, b: { c: 2 } };
const deep = structuredClone(original);
deep.b.c = 99;
console.log(original.b.c); // 2 — not affected

// Error cause (ES2022)
try {
  await connectToDatabase();
} catch (err) {
  throw new Error('Failed to load user', { cause: err });
}

// Variables
const x = 1;      // block-scoped, no reassignment
let y = 2;        // block-scoped, reassignable

// Functions
const fn = (a, b) => a + b;       // arrow function
const fn = async () => {};         // async arrow
function fn(...args) {}            // rest params

// Strings
`Hello ${name}`                    // template literal

// Destructuring
const { a, b } = obj;             // object
const [x, y] = arr;               // array
function fn({ a, b = 0 } = {}) {} // default params

// Spread/Rest
{ ...obj, key: val }               // merge/add
[...arr1, ...arr2]                 // combine arrays
fn(...arr)                         // spread as args

// Modules
import def from './mod'            // default
import { a, b } from './mod'       // named
export default fn                  // default export
export { a, b }                    // named exports

// Safe access
obj?.prop?.method?.()             // optional chaining
val ?? defaultVal                  // nullish coalescing

// Collections
new Set([1,2,3])                   // unique values
new Map([[key, val]])              // any-type keys

// Callback hell — don't do this
getData(function(err, data) {
  if (err) return handleError(err);
  processData(data, function(err, result) {
    if (err) return handleError(err);
    saveResult(result, function(err, saved) {
      if (err) return handleError(err);
      notifyUser(saved, function(err) {
        if (err) return handleError(err);
        console.log('Done!');
      });
    });
  });
});

const myPromise = new Promise((resolve, reject) => {
  // Simulate async work
  setTimeout(() => {
    const success = Math.random() > 0.5;
    if (success) {
      resolve('Operation succeeded!');
    } else {
      reject(new Error('Operation failed'));
    }
  }, 1000);
});

myPromise
  .then(result => {
    console.log('Success:', result);
    return result.toUpperCase(); // return value is passed to next .then()
  })
  .then(upperResult => {
    console.log('Transformed:', upperResult);
  })
  .catch(error => {
    console.error('Error:', error.message);
  })
  .finally(() => {
    console.log('This runs regardless of success or failure');
  });

// Fetching user data then their posts
fetch('/api/users/1')
  .then(response => {
    if (!response.ok) {
      throw new Error(`HTTP error: ${response.status}`);
    }
    return response.json();
  })
  .then(user => {
    console.log('User:', user.name);
    return fetch(`/api/users/${user.id}/posts`);
  })
  .then(response => response.json())
  .then(posts => {
    console.log(`Found ${posts.length} posts`);
  })
  .catch(error => {
    console.error('Failed:', error.message);
  });

async function greet() {
  return 'Hello!';
}

// These are equivalent:
greet().then(msg => console.log(msg)); // 'Hello!'
Promise.resolve('Hello!').then(msg => console.log(msg));

async function fetchUser(id) {
  const response = await fetch(`/api/users/${id}`);
  if (!response.ok) {
    throw new Error(`HTTP error: ${response.status}`);
  }
  const user = await response.json();
  return user;
}

// Call it
fetchUser(1)
  .then(user => console.log(user.name))
  .catch(err => console.error(err.message));

// Or use await at the top level (ES modules / Node.js 14.8+)
const user = await fetchUser(1);
console.log(user.name);

async function loadUserPosts(userId) {
  const userResponse = await fetch(`/api/users/${userId}`);
  if (!userResponse.ok) throw new Error(`HTTP error: ${userResponse.status}`);

  const user = await userResponse.json();
  console.log('User:', user.name);

  const postsResponse = await fetch(`/api/users/${user.id}/posts`);
  const posts = await postsResponse.json();

  console.log(`Found ${posts.length} posts`);
  return posts;
}

async function safeFetch(url) {
  try {
    const response = await fetch(url);
    if (!response.ok) {
      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
    }
    return await response.json();
  } catch (error) {
    if (error.name === 'TypeError') {
      // Network error or invalid URL
      console.error('Network error:', error.message);
    } else {
      // HTTP error
      console.error('Request failed:', error.message);
    }
    throw error; // Re-throw so callers can handle it
  }
}

// Using the function
async function main() {
  try {
    const data = await safeFetch('/api/data');
    console.log(data);
  } catch (error) {
    // Handle at the call site
    showErrorToUser(error.message);
  }
}

async function loadDashboard(userId) {
  // All three requests run in parallel — much faster than sequential
  const [user, posts, notifications] = await Promise.all([
    fetch(`/api/users/${userId}`).then(r => r.json()),
    fetch(`/api/users/${userId}/posts`).then(r => r.json()),
    fetch(`/api/users/${userId}/notifications`).then(r => r.json()),
  ]);

  return { user, posts, notifications };
}

// Without Promise.all (sequential — 3x slower)
async function loadDashboardSlow(userId) {
  const user = await fetch(`/api/users/${userId}`).then(r => r.json());
  const posts = await fetch(`/api/users/${userId}/posts`).then(r => r.json());
  const notifications = await fetch(`/api/users/${userId}/notifications`).then(r => r.json());
  return { user, posts, notifications };
}

const results = await Promise.allSettled([
  fetch('/api/endpoint-1').then(r => r.json()),
  fetch('/api/endpoint-2').then(r => r.json()),
  fetch('/api/endpoint-that-might-fail').then(r => r.json()),
]);

results.forEach((result, index) => {
  if (result.status === 'fulfilled') {
    console.log(`Request ${index} succeeded:`, result.value);
  } else {
    console.error(`Request ${index} failed:`, result.reason.message);
  }
});

function fetchWithTimeout(url, timeoutMs) {
  const fetchPromise = fetch(url).then(r => r.json());

  const timeoutPromise = new Promise((_, reject) =>
    setTimeout(() => reject(new Error('Request timed out')), timeoutMs)
  );

  return Promise.race([fetchPromise, timeoutPromise]);
}

try {
  const data = await fetchWithTimeout('/api/slow-endpoint', 5000);
  console.log(data);
} catch (err) {
  console.error(err.message); // 'Request timed out' or fetch error
}

// Try multiple CDN mirrors, use the first that responds
const data = await Promise.any([
  fetch('https://cdn1.example.com/data.json').then(r => r.json()),
  fetch('https://cdn2.example.com/data.json').then(r => r.json()),
  fetch('https://cdn3.example.com/data.json').then(r => r.json()),
]);
console.log('Got data from fastest source:', data);

const userIds = [1, 2, 3, 4, 5];

// ❌ Sequential — each request waits for the previous
for (const id of userIds) {
  const user = await fetchUser(id); // waits 1s × 5 = 5s total
  console.log(user.name);
}

// ✅ Parallel — all requests fire at once
const users = await Promise.all(userIds.map(id => fetchUser(id))); // ~1s total
users.forEach(user => console.log(user.name));

// ❌ Bug: not awaiting — data will be a Promise, not the value
async function getData() {
  const data = fetchUser(1); // missing await!
  console.log(data); // Promise { <pending> }
  return data;
}

// ✅ Correct
async function getData() {
  const data = await fetchUser(1);
  console.log(data); // { id: 1, name: 'Alice', ... }
  return data;
}

// ❌ Swallowing errors silently
async function bad() {
  try {
    return await riskyOperation();
  } catch (err) {
    // Silent! Caller doesn't know it failed
  }
}

// ✅ Handle what you can, re-throw the rest
async function good() {
  try {
    return await riskyOperation();
  } catch (err) {
    logError(err);          // log for observability
    throw err;              // re-throw so caller can react
  }
}

// CommonJS or older environments without top-level await
(async () => {
  try {
    const data = await fetchSomething();
    console.log(data);
  } catch (err) {
    console.error(err);
    process.exit(1);
  }
})();

const { promisify } = require('util');
const fs = require('fs');

const readFile = promisify(fs.readFile);

// Now you can use it with async/await
async function readConfig() {
  const content = await readFile('./config.json', 'utf8');
  return JSON.parse(content);
}

// Or write your own promisify wrapper
function delay(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

async function main() {
  console.log('Starting...');
  await delay(1000);
  console.log('1 second later');
}

// Reading a stream line by line
async function processLargeFile(filename) {
  const { createReadStream } = require('fs');
  const { createInterface } = require('readline');

  const stream = createReadStream(filename);
  const rl = createInterface({ input: stream });

  for await (const line of rl) {
    processLine(line);
  }
}

// Async generator
async function* generateSequence(start, end) {
  for (let i = start; i <= end; i++) {
    await delay(100); // simulate async work
    yield i;
  }
}

for await (const num of generateSequence(1, 5)) {
  console.log(num); // 1, 2, 3, 4, 5 (with delays)
}

// Create
new Promise((resolve, reject) => { ... })
Promise.resolve(value)
Promise.reject(error)

// Consume
promise.then(onFulfilled, onRejected)
promise.catch(onRejected)
promise.finally(onFinally)

// Combinators
Promise.all([p1, p2, p3])         // all must succeed
Promise.allSettled([p1, p2, p3])  // wait for all, never rejects
Promise.race([p1, p2, p3])        // first to settle wins
Promise.any([p1, p2, p3])         // first fulfilled wins

// Async/await
async function fn() { ... }       // returns a Promise
const result = await promise;     // pause until resolved
try { await fn() } catch (err) {} // error handling

function makeCounter() {
  let count = 0;   // This variable lives in makeCounter's scope

  return function() {   // This inner function is a closure
    count++;
    return count;
  };
}

const counter = makeCounter();  // makeCounter has returned...

console.log(counter()); // 1   // ...but count still exists!
console.log(counter()); // 2
console.log(counter()); // 3

const greeting = 'Hello';

function outer() {
  const name = 'Alice';

  function inner() {
    // inner() can access both name and greeting
    // because of where it was defined (inside outer)
    console.log(`${greeting}, ${name}!`);
  }

  return inner;
}

const sayHello = outer();
sayHello(); // 'Hello, Alice!'

// Even if called in a completely different context:
const name = 'Bob';   // different name in outer scope
sayHello(); // Still 'Hello, Alice!' — not 'Bob'

const a = 1;

function level1() {
  const b = 2;

  function level2() {
    const c = 3;

    function level3() {
      const d = 4;
      // level3 can access a, b, c, d
      console.log(a + b + c + d); // 10
    }

    level3();
  }

  level2();
}

level1();

function createBankAccount(initialBalance) {
  let balance = initialBalance;  // private — not accessible from outside

  return {
    deposit(amount) {
      if (amount <= 0) throw new Error('Amount must be positive');
      balance += amount;
      return balance;
    },
    withdraw(amount) {
      if (amount > balance) throw new Error('Insufficient funds');
      balance -= amount;
      return balance;
    },
    getBalance() {
      return balance;
    }
  };
}

const account = createBankAccount(100);
console.log(account.getBalance()); // 100
account.deposit(50);
console.log(account.getBalance()); // 150
account.withdraw(30);
console.log(account.getBalance()); // 120

// Cannot access balance directly:
console.log(account.balance); // undefined

function createMultiplier(factor) {
  return (number) => number * factor;
}

const double  = createMultiplier(2);
const triple  = createMultiplier(3);
const tenTimes = createMultiplier(10);

console.log(double(5));   // 10
console.log(triple(5));   // 15
console.log(tenTimes(5)); // 50

// Another practical example: API endpoint builder
function createApiClient(baseUrl, apiKey) {
  const headers = {
    'Authorization': `Bearer ${apiKey}`,
    'Content-Type': 'application/json',
  };

  return {
    async get(path) {
      const res = await fetch(`${baseUrl}${path}`, { headers });
      return res.json();
    },
    async post(path, body) {
      const res = await fetch(`${baseUrl}${path}`, {
        method: 'POST',
        headers,
        body: JSON.stringify(body),
      });
      return res.json();
    }
  };
}

const api = createApiClient('https://api.example.com', 'secret-key-123');
const users = await api.get('/users');

function memoize(fn) {
  const cache = new Map();  // closure over this cache

  return function(...args) {
    const key = JSON.stringify(args);
    if (cache.has(key)) {
      console.log('Cache hit');
      return cache.get(key);
    }
    const result = fn.apply(this, args);
    cache.set(key, result);
    return result;
  };
}

function slowFibonacci(n) {
  if (n <= 1) return n;
  return slowFibonacci(n - 1) + slowFibonacci(n - 2);
}

const fastFibonacci = memoize(slowFibonacci);
fastFibonacci(40); // computed once
fastFibonacci(40); // 'Cache hit' — instant

function setupButton(buttonId, message) {
  const button = document.getElementById(buttonId);

  button.addEventListener('click', function() {
    // This function closes over 'message'
    alert(message);
  });
}

setupButton('btn1', 'Hello from button 1!');
setupButton('btn2', 'Hello from button 2!');
// Each button remembers its own message

// Partial application: fix some arguments, return a function for the rest
function partial(fn, ...presetArgs) {
  return function(...laterArgs) {
    return fn(...presetArgs, ...laterArgs);
  };
}

function add(a, b, c) { return a + b + c; }

const add5 = partial(add, 5);
const add5and10 = partial(add, 5, 10);

console.log(add5(3, 2));    // 10
console.log(add5and10(1));  // 16

// Currying: transform f(a, b, c) into f(a)(b)(c)
function curry(fn) {
  return function curried(...args) {
    if (args.length >= fn.length) {
      return fn(...args);
    }
    return (...moreArgs) => curried(...args, ...moreArgs);
  };
}

const curriedAdd = curry((a, b, c) => a + b + c);
curriedAdd(1)(2)(3); // 6
curriedAdd(1, 2)(3); // 6
curriedAdd(1)(2, 3); // 6

// IIFE-based module (pre-ES modules pattern)
const userModule = (function() {
  let users = [];  // private

  function findById(id) {  // private helper
    return users.find(u => u.id === id);
  }

  return {
    addUser(user) {
      users.push(user);
    },
    getUser(id) {
      return findById(id);
    },
    getAllUsers() {
      return [...users]; // return a copy, not a reference
    }
  };
})();

userModule.addUser({ id: 1, name: 'Alice' });
console.log(userModule.getUser(1)); // { id: 1, name: 'Alice' }
console.log(userModule.users);     // undefined — private!

// ❌ Bug: all buttons alert "5"
for (var i = 0; i < 5; i++) {
  const button = document.createElement('button');
  button.textContent = `Button ${i}`;
  button.addEventListener('click', function() {
    alert(i);  // closes over the SAME i
  });
  document.body.appendChild(button);
}
// When clicked, i is already 5 (loop finished)

// ✅ Fix 1: use let (block-scoped, new binding each iteration)
for (let i = 0; i < 5; i++) {
  const button = document.createElement('button');
  button.addEventListener('click', function() {
    alert(i);  // each iteration has its own i
  });
  document.body.appendChild(button);
}

// ✅ Fix 2: use an IIFE to capture i
for (var i = 0; i < 5; i++) {
  (function(capturedI) {
    const button = document.createElement('button');
    button.addEventListener('click', function() {
      alert(capturedI);
    });
    document.body.appendChild(button);
  })(i);
}

// ✅ Fix 3: use forEach
[0, 1, 2, 3, 4].forEach(i => {
  const button = document.createElement('button');
  button.addEventListener('click', () => alert(i));
  document.body.appendChild(button);
});

// ⚠️ Potential memory leak
function addHandler() {
  const largeData = new Array(1000000).fill('data');  // large allocation

  document.getElementById('btn').addEventListener('click', function() {
    // This closure holds largeData in memory for as long as the listener exists
    console.log(largeData.length);
  });
}

// ✅ Better: only capture what you need
function addHandler() {
  const largeData = new Array(1000000).fill('data');
  const dataLength = largeData.length;  // capture only what's needed

  document.getElementById('btn').addEventListener('click', function() {
    console.log(dataLength);
    // largeData can now be garbage collected
  });
}

// ✅ Clean up listeners when done
const handler = () => console.log('clicked');
button.addEventListener('click', handler);
// Later:
button.removeEventListener('click', handler);

// React hooks use closures extensively
function Counter() {
  const [count, setCount] = useState(0);

  // This function closes over 'count'
  const handleClick = () => {
    setCount(count + 1);
  };

  // useEffect callback closes over dependencies
  useEffect(() => {
    document.title = `Count: ${count}`;
  }, [count]);

  return <button onClick={handleClick}>{count}</button>;
}

// Stale closure problem in useEffect
function Example({ id }) {
  const [data, setData] = useState(null);

  useEffect(() => {
    // This callback closes over 'id' at the time it was created
    fetchData(id).then(setData);
  }, [id]); // Re-run when id changes — keeps closure fresh
}

// Closure in one sentence:
// A function that carries its birthplace environment with it.

function outer() {
  const secret = 42;
  return () => secret;  // closure: remembers 'secret' forever
}

const getSecret = outer();
getSecret(); // 42 — even though outer() is long gone

from mcp.server.fastmcp import FastMCP
import requests
import os

# Initialize the MCP Server
mcp = FastMCP("paystack")

BASE_URL = "https://api.paystack.co"
HEADERS = {
    "Authorization": f"Bearer {os.getenv('PAYSTACK_SECRET_KEY')}",
    "Content-Type": "application/json"
}

@mcp.tool()
def verify_transaction(reference: str) -> str:
    """
    Verifies the status of a transaction using its reference.

    Args:
        reference: The unique transaction reference code.
    """
    url = f"{BASE_URL}/transaction/verify/{reference}"
    response = requests.get(url, headers=HEADERS)

    if response.status_code == 200:
        data = response.json().get('data', {})
        status = data.get('status')
        amount = data.get('amount') / 100  # Convert kobo to major unit
        return f"Transaction {reference} is {status}. Amount: {amount}."
    else:
        return f"Error verifying transaction: {response.text}"

   git clone https://github.com/thisishaykins/paystack-python-mcp
   cd paystack-python-mcp

   export PAYSTACK_SECRET_KEY="sk_test_..."

   uv run paystack_mcp.py

FROM python:3.10-slim

WORKDIR /app

# Install dependencies
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copy source code
COPY . .

# Set entrypoint
ENTRYPOINT ["python", "paystack_mcp.py"]

docker build -t paystack-mcp .
docker run -e PAYSTACK_SECRET_KEY="sk_test_..." -i paystack-mcp

{
  "mcpServers": {
    "paystack": {
      "command": "uv",
      "args": [
        "run",
        "--with",
        "requests",
        "/absolute/path/to/paystack-python-mcp/paystack_mcp.py"
      ],
      "env": {
        "PAYSTACK_SECRET_KEY": "sk_test_YOUR_KEY_HERE"
      }
    }
  }
}