JavaScript: Fundamental (ES6), part 2, 38–68

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40const Ok = (value) => ({
  ok: true,
  value,
  map: (fn) => Ok(fn(value)),
  mapErr: () => Ok(value),
  andThen: (fn) => fn(value),
  unwrapOr: () => value,
});

const Err = (error) => ({
  ok: false,
  error,
  map: () => Err(error),                          // your function is never called
  mapErr: (fn) => Err(fn(error)),
  andThen: () => Err(error),
  unwrapOr: (fallback) => fallback,
});

const attempt = (fn) => { try { return Ok(fn()); } catch (err) { return Err(err.message); } };
const attemptAsync = (promise) => promise.then(Ok, (err) => Err(err.message));

// The methods make these objects awkward to compare, so project them first.
const shape = (result) => (result.ok ? ['ok', result.value] : ['err', result.error]);

let mapperCalls = 0;
const doubled = Ok(1500).map((amount) => { mapperCalls++; return amount * 2; });
const skipped = Err('till offline').map((amount) => { mapperCalls++; return amount * 2; });

const parsed = attempt(() => JSON.parse('{"till":"yaba"}'));
const broken = attempt(() => JSON.parse('{till:'));
const chained = Ok(3).andThen((n) => (n > 0 ? Ok(n * 100) : Err('not a positive count')));
const shortCircuit = Err('nothing to work with').andThen(() => Ok('never reached'));
const defaults = [Ok(10).unwrapOr(0), Err('boom').unwrapOr(0)];
const fromRejection = shape(await attemptAsync(Promise.reject(new Error('gateway down'))));
const tidied = shape(Err('ECONNRESET').mapErr((message) => 'network: ' + message));

console.log('success :', shape(doubled), '- mapper calls:', mapperCalls);
console.log('failure :', shape(skipped));
console.log('parse failure as data:', [broken.ok, broken.error.length > 0]);
console.log('from a rejection     :', fromRejection);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56const log = [];

const chargeCard = async () => {
  await Promise.resolve();
  log.push('charge attempted');
  throw new Error('gateway declined');
};

const readReceipt = async () => {
  await Promise.resolve();
  await Promise.resolve();
  log.push('receipt read');
  return 'LAG-0039';
};

const noAwait = async () => {
  try { return chargeCard(); }                 // leaves the try before it settles
  catch { return 'handled here'; }
};

const withAwait = async () => {
  try { return await chargeCard(); }
  catch { return 'handled here'; }
};

const escaped = await noAwait().then((v) => 'resolved: ' + v, (err) => 'ESCAPED: ' + err.message);
const caught = await withAwait();

log.length = 0;
const releaseEarly = async () => {
  try { return readReceipt(); }
  finally { log.push('printer released'); }
};
const earlyValue = await releaseEarly();
const earlyOrder = log.slice();

log.length = 0;
const releaseAfter = async () => {
  try { return await readReceipt(); }
  finally { log.push('printer released'); }
};
const lateValue = await releaseAfter();
const properOrder = log.slice();

log.length = 0;
const finallyOnly = async () => {
  try { return chargeCard(); }
  finally { log.push('released too soon'); }
};
const stillRejects = await finallyOnly().catch((err) => err.message);
const tooSoon = log.slice();

console.log('no await   :', escaped);
console.log('with await :', caught);
console.log('finally    :', earlyOrder, 'vs', properOrder);
console.log('and still rejects:', stillRejects, tooSoon);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41const order = [];

async function chargeTill(amount) {
  order.push('body starts, synchronously');
  if (amount <= 0) throw new RangeError('amount must be positive');
  await Promise.resolve();
  order.push('body resumes, a tick later');
  return `charged ₦${amount}`;
}

let syncCatch = 'nothing was thrown at the call site';
let returned;
try {
  returned = chargeTill(-1);
} catch {
  syncCatch = 'caught synchronously';
}
order.push('caller carries on');

const promiseShape = [typeof returned.then, returned instanceof Promise, returned.constructor.name];
const asRejection = await returned.then(() => 'resolved', (err) => err.name);
const orderAtThatPoint = order.slice();

const plainNumber = async () => 42;
const beforeAwait = plainNumber();
const wrapped = [typeof beforeAwait.then, await beforeAwait];

const receipt = await chargeTill(2500);

// Validate in a synchronous wrapper, and a bad call fails at the call site again.
const chargeGuarded = (amount) => {
  if (amount <= 0) throw new RangeError('amount must be positive');
  return chargeTill(amount);
};
let guarded = 'still nothing';
try { chargeGuarded(-1); } catch (err) { guarded = err.name; }

console.log('sync try/catch :', syncCatch);
console.log('what came back :', promiseShape, '-> rejects with', asRejection);
console.log('order          :', orderAtThatPoint);
console.log('guarded call   :', guarded);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47function singleFlight(fn) {
  const inFlight = new Map();
  const wrapped = (key) => {
    if (inFlight.has(key)) return inFlight.get(key);          // join the one in progress
    const promise = (async () => fn(key))().finally(() => inFlight.delete(key));
    inFlight.set(key, promise);
    return promise;
  };
  wrapped.pending = () => inFlight.size;
  return wrapped;
}

let calls = 0;
const tillBalance = singleFlight(async (name) => {
  calls++;
  await Promise.resolve();
  await Promise.resolve();
  if (name === 'broken') throw new Error(name + ': 500 from the API');
  return name + ' balance ₦24,000';
});

const three = await Promise.all([tillBalance('yaba'), tillBalance('yaba'), tillBalance('yaba')]);
const callsAfterThree = calls;

const started = tillBalance('lekki');
const pendingDuring = tillBalance.pending();
await started;
const pendingAfter = tillBalance.pending();

await tillBalance('yaba');                                    // long settled, so a fresh call
const callsAfterLater = calls;

const bothFailed = await Promise.all([
  tillBalance('broken').catch((err) => err.message),
  tillBalance('broken').catch((err) => err.message),
]);
const callsAfterFailure = calls;
const retried = await tillBalance('broken').catch((err) => err.message);
const callsAfterRetry = calls;

const twoKeys = await Promise.all([tillBalance('ikeja'), tillBalance('ajah')]);
const callsAfterTwoKeys = calls;

console.log('three callers, calls made:', callsAfterThree);
console.log('pending during / after   :', pendingDuring, '/', pendingAfter);
console.log('shared failure           :', bothFailed[0] === bothFailed[1]);
console.log('calls, in order          :', [callsAfterThree, callsAfterLater, callsAfterFailure, callsAfterRetry, callsAfterTwoKeys]);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23const failure = new Error('yaba till timed out', { cause: new Error('ECONNRESET') });
failure.till = 'yaba';
failure.retryable = true;

const naive = JSON.stringify(failure);
const insideAReport = JSON.stringify({ status: 'failed', error: failure });
const enumerability = [failure.propertyIsEnumerable('message'), failure.propertyIsEnumerable('till')];
const spreadKeys = Object.keys({ ...failure });

function toPlain(err) {
  const out = { name: err.name, message: err.message };
  if (err.cause instanceof Error) out.cause = toPlain(err.cause);
  return out;
}

const serialised = JSON.stringify(toPlain(failure));
const revived = JSON.parse(serialised);
const afterTheRoundTrip = [revived instanceof Error, revived.cause.message];

console.log('naive       :', naive);
console.log('in a report :', insideAReport);
console.log('projected   :', serialised);
console.log('String()    :', String(failure));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54const log = [];
let open = 0;

const openTill = (name) => {
  open++;
  log.push('open ' + name);
  return {
    name,
    print: (line) => 'receipt from ' + name + ': ' + line,
    close: () => { open--; log.push('close ' + name); },
  };
};

async function withTill(name, use) {
  const till = openTill(name);
  try { return await use(till); }
  finally { till.close(); }
}

async function withTillBroken(name, use) {
  const till = openTill(name);
  try { return use(till); }                  // no await: the finally runs at once
  finally { till.close(); }
}

const receipt = await withTill('yaba', async (till) => {
  await Promise.resolve();
  return till.print('₦2,500');
});
const afterSuccess = [open, log.slice()];

log.length = 0;
const failure = await withTill('lekki', async () => {
  throw new Error('printer jammed');
}).catch((err) => err.message);
const afterFailure = [open, log.slice()];

log.length = 0;
const nested = await withTill('outer', (a) => withTill('inner', async (b) => a.name + ' + ' + b.name));
const nestedOrder = log.slice();

log.length = 0;
const broken = await withTillBroken('ajah', (till) =>
  Promise.resolve().then(() => {
    log.push('used ' + till.name + ', open tills: ' + open);
    return till.name;
  })
);
const brokenOrder = log.slice();

console.log('receipt :', receipt);
console.log('failure :', failure, afterFailure);
console.log('nested  :', nestedOrder);
console.log('broken  :', brokenOrder);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59function deferred() {
  let resolve;
  let reject;
  const promise = new Promise((res, rej) => { resolve = res; reject = rej; });
  return { promise, resolve, reject };
}

function emitter() {
  const handlers = [];
  return {
    on(fn) { handlers.push(fn); },
    off(fn) { const at = handlers.indexOf(fn); if (at !== -1) handlers.splice(at, 1); },
    emit(value) { for (const fn of handlers.slice()) fn(value); },
    get listeners() { return handlers.length; },
  };
}

// The next event, as a promise, cleaning up after itself.
function once(source) {
  const { promise, resolve } = deferred();
  const handler = (value) => { source.off(handler); resolve(value); };
  source.on(handler);
  return promise;
}

const gate = deferred();
let arrived = 'nothing yet';
gate.promise.then((value) => { arrived = value; });
for (let i = 0; i < 3; i++) await Promise.resolve();
const beforeResolve = arrived;
gate.resolve('opened');
const firstValue = await gate.promise;
gate.resolve('opened again');
const afterSecondResolve = await gate.promise;

const tills = emitter();
const next = once(tills);
const listenersWhileWaiting = tills.listeners;
tills.emit('till 3 opened');
const first = await next;
const listenersAfter = tills.listeners;

const failing = deferred();
failing.reject(new Error('till 4 never opened'));
const rejected = await failing.promise.catch((err) => err.message);

const forgotten = deferred();
let everSettled = false;
forgotten.promise.then(() => { everSettled = true; }, () => { everSettled = true; });
for (let i = 0; i < 8; i++) await Promise.resolve();

const late = emitter();
late.emit('fired before anyone subscribed');
const missed = await Promise.race([once(late), Promise.resolve('nothing arrived')]);

console.log('before resolve :', beforeResolve, '-> after:', firstValue);
console.log('listeners      :', listenersWhileWaiting, 'while waiting,', listenersAfter, 'after');
console.log('rejected       :', rejected);
console.log('never settled  :', everSettled, '- missed event:', missed);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70const fakeClock = () => {
  let now = 0;
  return { get time() { return now; }, advance(ms) { now += ms; } };
};

function breaker(call, { threshold = 3, cooldownMs = 1000, clock }) {
  let state = 'closed';
  let failures = 0;
  let openedAt = 0;

  const wrapped = async (...args) => {
    if (state === 'open') {
      if (clock.time - openedAt < cooldownMs) throw new Error('circuit open, not calling');
      state = 'half-open';                          // one trial call gets through
    }
    try {
      const value = await call(...args);
      state = 'closed';
      failures = 0;
      return value;
    } catch (err) {
      failures++;
      if (state === 'half-open' || failures >= threshold) {
        state = 'open';
        openedAt = clock.time;
        failures = 0;
      }
      throw err;
    }
  };
  wrapped.state = () => state;
  return wrapped;
}

const clock = fakeClock();
let calls = 0;
let healthy = false;
const gateway = async () => {
  calls++;
  if (!healthy) throw new Error('502 from the gateway');
  return 'receipt LAG-0045';
};
const guarded = breaker(gateway, { threshold: 3, cooldownMs: 1000, clock });

const messages = [];
for (let attempt = 0; attempt < 5; attempt++) {
  messages.push(await guarded().catch((err) => err.message));
}
const afterFive = [guarded.state(), calls];

clock.advance(999);
const stillOpen = await guarded().catch((err) => err.message);
clock.advance(1);
const trial = await guarded().catch((err) => err.message);
const afterTrial = [guarded.state(), calls];

clock.advance(1000);
healthy = true;
const recovered = await guarded();
const afterRecovery = [guarded.state(), calls];

healthy = false;
await guarded().catch(() => {});
await guarded().catch(() => {});
const afterTwoMore = [guarded.state(), calls];

console.log('first five  :', messages);
console.log('state, calls:', afterFive, '->', afterTrial, '->', afterRecovery);
console.log('recovered   :', recovered);
console.log('10 attempts made,', calls, 'calls actually reached the gateway');

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55const fakeClock = () => {
  let now = 0;
  return { get time() { return now; }, advance(ms) { now += ms; } };
};

function tokenBucket({ capacity, refillMs, clock }) {
  let tokens = capacity;
  let lastRefill = clock.time;

  const refill = () => {
    const earned = Math.floor((clock.time - lastRefill) / refillMs);
    if (earned > 0) {
      tokens = Math.min(capacity, tokens + earned);   // the cap is the whole point
      lastRefill += earned * refillMs;                // keep the remainder
    }
  };

  return {
    take() { refill(); if (tokens === 0) return false; tokens--; return true; },
    get available() { refill(); return tokens; },
  };
}

const limited = (fn, bucket) => async (...args) => {
  if (!bucket.take()) throw new Error('429: rate limit exceeded');
  return fn(...args);
};

const clock = fakeClock();
const bucket = tokenBucket({ capacity: 3, refillMs: 100, clock });

const burst = [bucket.take(), bucket.take(), bucket.take(), bucket.take()];
const emptied = bucket.available;

clock.advance(99);
const justBefore = [bucket.available, bucket.take()];
clock.advance(1);
const atTheRefill = [bucket.available, bucket.take(), bucket.available];

clock.advance(1000);                                  // ten intervals of idling
const banked = bucket.available;

let calls = 0;
const sendSms = limited(async (to) => { calls++; return 'sent to ' + to; }, bucket);
const sent = [
  await sendSms('0801').catch((err) => err.message),
  await sendSms('0802').catch((err) => err.message),
  await sendSms('0803').catch((err) => err.message),
  await sendSms('0804').catch((err) => err.message),
];

console.log('burst of four :', burst, '- left:', emptied);
console.log('at 99ms / 100ms:', justBefore, '/', atTheRefill);
console.log('after idling 1000ms:', banked, 'not 10');
console.log('sms            :', sent, '- calls made:', calls);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48const finishing = [];
const slow = (name, value, rounds) => (async () => {
  for (let i = 0; i < rounds; i++) await Promise.resolve();
  finishing.push(name);
  return value;
})();

async function allObject(tasks) {
  const keys = Object.keys(tasks);
  const values = await Promise.all(keys.map((key) => tasks[key]));
  return Object.fromEntries(keys.map((key, i) => [key, values[i]]));
}

async function settledObject(tasks) {
  const keys = Object.keys(tasks);
  const settled = await Promise.allSettled(keys.map((key) => tasks[key]));
  return Object.fromEntries(keys.map((key, i) => [
    key,
    settled[i].status === 'fulfilled'
      ? { ok: true, value: settled[i].value }
      : { ok: false, reason: settled[i].reason.message },
  ]));
}

const dashboard = await allObject({
  balance: slow('balance', 24000, 6),
  tills: slow('tills', 3, 2),
  area: 'lekki',                                  // a plain value passes through
});

const rejected = await allObject({
  balance: Promise.resolve(24000),
  tills: Promise.reject(new Error('till service offline')),
}).then(() => 'resolved', (err) => err.message);

const report = await settledObject({
  balance: Promise.resolve(24000),
  tills: Promise.reject(new Error('till service offline')),
});

const empty = await allObject({});
const missing = await allObject({ note: Promise.resolve(undefined) });
const withSymbol = await allObject({ [Symbol('hidden')]: Promise.resolve('dropped'), kept: Promise.resolve(1) });

console.log('dashboard :', dashboard);
console.log('finished in this order:', finishing);
console.log('rejected  :', rejected);
console.log('report    :', report);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42const order = { ref: 'LAG-0048', subtotal: 24000, area: 'lekki' };
const trace = [];

const steps = [
  async (o) => { trace.push('vat'); return { ...o, vat: Math.round(o.subtotal * 0.075) }; },
  async (o) => { trace.push('delivery'); return { ...o, delivery: o.area === 'lekki' ? 1500 : 800 }; },
  async (o) => { trace.push('total'); return { ...o, total: o.subtotal + o.vat + o.delivery }; },
];

const pipe = (fns) => (input) => fns.reduce((acc, fn) => acc.then(fn), Promise.resolve(input));

const runInOrder = async (fns, input) => {
  let acc = input;
  for (const fn of fns) acc = await fn(acc);
  return acc;
};

const piped = await pipe(steps)(order);
const traceFromPipe = trace.slice();
const looped = await runInOrder(steps, order);

// Not a pipeline: every step gets the original order, so nothing composes.
const inParallel = await Promise.all(steps.map((fn) => fn(order)));
const parallelKeys = inParallel.map((o) => Object.keys(o).slice(3));

const awaited = await [1, 2, 3].reduce(async (sum, n) => (await sum) + n, Promise.resolve(0));
const forgotten = await [1, 2, 3].reduce(async (sum, n) => sum + n, Promise.resolve(0));

let stepsRun = 0;
const failing = [
  async (n) => { stepsRun++; return n + 1; },
  async () => { stepsRun++; throw new Error('rate lookup failed'); },
  async (n) => { stepsRun++; return n * 100; },
];
const stopped = await pipe(failing)(1).then(() => 'finished', (err) => err.message);

const unchanged = await pipe([])(order);

console.log('piped   :', piped.total, 'from', traceFromPipe);
console.log('parallel:', parallelKeys);
console.log('reduce  :', awaited, 'vs', forgotten);
console.log('stopped :', stopped, 'after', stepsRun, 'steps');

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62function readingsFrom(values) {
  const state = { started: false, produced: 0, finished: false };
  async function* generate() {
    state.started = true;
    for (const value of values) {
      state.produced++;
      await Promise.resolve();                    // pretend the meter is slow
      yield value;
    }
    state.finished = true;
  }
  return { readings: generate(), state };
}

async function take(n, iterable) {
  const out = [];
  for await (const value of iterable) {
    out.push(value);
    if (out.length === n) break;
  }
  return out;
}

const lazy = readingsFrom([24, 25, 26, 27, 28]);
const beforeAnyPull = [lazy.state.started, lazy.state.produced];

const eagerLog = [];
async function eager() {
  eagerLog.push('async function body started');
  await Promise.resolve();
  eagerLog.push('and resumed later');
}
eager();
const eagerRanAtOnce = eagerLog.slice();

const first = await lazy.readings.next();
const afterOnePull = [lazy.state.started, lazy.state.produced, lazy.state.finished];

const partial = readingsFrom([24, 25, 26, 27, 28]);
const twoOfFive = await take(2, partial.readings);
const afterBreak = [partial.state.produced, partial.state.finished];

const whole = readingsFrom([24, 25, 26]);
const everything = [];
for await (const value of whole.readings) everything.push(value);
const afterDraining = [whole.state.produced, whole.state.finished];
const pastTheEnd = await whole.readings.next();

let endless = 0;
async function* forEver() {
  while (true) {
    endless++;
    await Promise.resolve();
    yield endless;
  }
}
const firstThree = await take(3, forEver());

console.log('generator, before any pull:', beforeAnyPull);
console.log('async function, no pull   :', eagerRanAtOnce);
console.log('after one next()          :', afterOnePull, first.value);
console.log('take(2) of five           :', twoOfFive, afterBreak);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72function manualClock() {
  let now = 0;
  const timers = [];
  return {
    get time() { return now; },
    get pending() { return timers.length; },
    wait(ms) { return new Promise((resolve) => timers.push({ at: now + ms, resolve })); },
    async advance(ms) {
      now += ms;
      for (const timer of timers.filter((t) => t.at <= now)) {
        timers.splice(timers.indexOf(timer), 1);
        timer.resolve();
      }
      for (let i = 0; i < 20; i++) await Promise.resolve();   // let the waiters run
    },
  };
}

async function* asCompleted(tasks) {
  const pending = new Map(
    tasks.map((task, index) => [
      index,
      Promise.resolve(task).then(
        (value) => ({ index, value }),
        (reason) => ({ index, reason })       // a failure is a result, not an exit
      ),
    ])
  );
  while (pending.size) {
    const settled = await Promise.race(pending.values());
    pending.delete(settled.index);
    yield settled;
  }
}

const clock = manualClock();
const after = (ms, name) => clock.wait(ms).then(() => name);
const tasks = [after(300, 'ikeja'), after(100, 'yaba'), after(200, 'lekki')];

const arrivals = [];
const draining = (async () => {
  for await (const settled of asCompleted(tasks)) arrivals.push([settled.index, settled.value]);
})();

await clock.advance(100);
const firstOut = arrivals.slice();
await clock.advance(100);
await clock.advance(100);
await draining;
const inInputOrder = await Promise.all(tasks);

const second = manualClock();
const later = (ms, name) => second.wait(ms).then(() => name);
const breaks = (ms, message) => second.wait(ms).then(() => { throw new Error(message); });
const mixed = [];
const withFailure = (async () => {
  for await (const settled of asCompleted([later(300, 'ikeja'), breaks(100, 'yaba offline'), later(200, 'lekki')])) {
    mixed.push(settled.reason ? 'ERR ' + settled.reason.message : settled.value);
  }
})();
await second.advance(100);
await second.advance(100);
await second.advance(100);
await withFailure;

const nothing = [];
for await (const settled of asCompleted([])) nothing.push(settled);

console.log('first out    :', firstOut);
console.log('all arrivals :', arrivals);
console.log('Promise.all  :', inInputOrder);
console.log('with a failure:', mixed);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35const caught = (fn) => { try { fn(); return 'nothing was thrown'; } catch (err) { return err; } };

const aString = caught(() => { throw 'till offline'; });
const aNumber = caught(() => { throw 404; });
const nothing = caught(() => { throw undefined; });
const lookalike = caught(() => { throw { code: 'E_TILL', message: 'looks like an error' }; });

const handlerThrew = (() => {
  try {
    try { throw undefined; }
    catch (err) { return 'message was ' + err.message; }     // the handler is now the bug
  } catch (err) { return err.name; }
})();

function normalise(value) {
  if (value instanceof Error) return value;
  if (typeof value === 'string') return new Error(value);
  if (value !== null && typeof value === 'object' && typeof value.message === 'string') {
    return Object.assign(new Error(value.message), { thrown: value });
  }
  return new Error('non-error thrown: ' + String(value));
}

const real = new RangeError('a genuine error');
const normalised = [aString, aNumber, nothing, lookalike, real].map(normalise);
const messages = normalised.map((err) => err.message);
const allErrors = normalised.every((err) => err instanceof Error);
const untouched = normalise(real) === real;
const evidenceKept = normalised[3].thrown.code;
const fromRejection = await Promise.reject('a rejected string').catch((value) => [typeof value, normalise(value).message]);

console.log('a thrown string  :', typeof aString, JSON.stringify(aString), '- message:', aString.message);
console.log('throw undefined  :', nothing === undefined, '- and the handler:', handlerThrew);
console.log('normalised       :', messages);
console.log('evidence kept    :', normalised[3].thrown);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65class TransientError extends Error {
  constructor(message, options) { super(message, options); this.name = 'TransientError'; }
}
class PermanentError extends Error {
  constructor(message, options) { super(message, options); this.name = 'PermanentError'; }
}

const fakeClock = () => {
  let now = 0;
  const waits = [];
  return {
    get time() { return now; },
    get waits() { return waits.slice(); },
    wait(ms) { waits.push(ms); now += ms; return Promise.resolve(); },
  };
};

const worthRetrying = (err) =>
  err instanceof TransientError || (typeof err.status === 'number' && err.status >= 500);

async function retryIf(task, { attempts = 4, baseMs = 100, retryable, clock }) {
  let last;
  for (let attempt = 1; attempt <= attempts; attempt++) {
    try { return { value: await task(attempt), attempts: attempt }; }
    catch (err) {
      last = err;
      if (!retryable(err)) throw new Error('not retryable: ' + err.name, { cause: err });
      if (attempt === attempts) break;
      await clock.wait(baseMs * attempt);
    }
  }
  throw new Error('gave up after ' + attempts + ' attempts', { cause: last });
}

const withStatus = (status, message) => Object.assign(new Error(message), { status });

const flaky = fakeClock();
let tries = 0;
const recovered = await retryIf(async () => {
  tries++;
  if (tries < 3) throw new TransientError('socket hang up');
  return 'receipt LAG-0052';
}, { baseMs: 100, retryable: worthRetrying, clock: flaky });

const declined = fakeClock();
const refused = await retryIf(async () => { throw new PermanentError('card declined'); },
  { retryable: worthRetrying, clock: declined }).catch((err) => err);

const serverError = fakeClock();
let fiveHundreds = 0;
const gaveUpOn500 = await retryIf(async () => { fiveHundreds++; throw withStatus(503, 'service unavailable'); },
  { attempts: 3, baseMs: 100, retryable: worthRetrying, clock: serverError }).catch((err) => err);

const notFound = fakeClock();
let lookups = 0;
const gaveUpOn404 = await retryIf(async () => { lookups++; throw withStatus(404, 'no such till'); },
  { attempts: 3, retryable: worthRetrying, clock: notFound }).catch((err) => err.message);

const clean = fakeClock();
const firstTime = await retryIf(async () => 'nothing to retry', { retryable: worthRetrying, clock: clean });

console.log('recovered  :', recovered, 'after waits', flaky.waits);
console.log('declined   :', refused.message, '/ cause:', refused.cause.name, '- waits:', declined.waits);
console.log('503        :', gaveUpOn500.message, 'after', fiveHundreds, 'attempts and waits', serverError.waits);
console.log('404        :', gaveUpOn404, 'after', lookups, 'attempt');

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117function manualClock() {
  let now = 0;
  const timers = [];
  return {
    get time() { return now; },
    get pending() { return timers.length; },
    wait(ms) {
      const timer = { at: now + ms };
      const promise = new Promise((resolve) => { timer.resolve = resolve; });
      timers.push(timer);
      promise.clear = () => {                         // the clearTimeout handle
        const at = timers.indexOf(timer);
        if (at !== -1) timers.splice(at, 1);
      };
      return promise;
    },
    async advance(ms) {
      now += ms;
      for (const timer of timers.filter((t) => t.at <= now)) {
        timers.splice(timers.indexOf(timer), 1);
        timer.resolve();
      }
      for (let i = 0; i < 20; i++) await Promise.resolve();
    },
  };
}

class CancelledError extends Error {
  constructor(reason) { super(reason); this.name = 'CancelledError'; }
}

function cancellation() {
  let cancelled = false;
  let reason = '';
  return {
    get cancelled() { return cancelled; },
    get reason() { return reason; },
    throwIfCancelled() { if (cancelled) throw new CancelledError(reason); },
    cancel(why) { if (cancelled) return false; cancelled = true; reason = why; return true; },
  };
}

async function withDeadline(work, ms, clock) {
  const token = cancellation();
  const running = work(token);
  running.catch(() => {});                            // the loser must not go unhandled
  const timer = clock.wait(ms);
  const expired = timer.then(() => {
    token.cancel(`deadline of ${ms}ms passed`);
    throw new Error(`timed out after ${ms}ms`);
  });
  expired.catch(() => {});
  try {
    return await Promise.race([running, expired]);
  } finally {
    timer.clear();                                    // no timer left pending
    token.cancel('work finished');                    // no work left running
  }
}

const clock = manualClock();
const steps = [];
const payTills = async (token) => {
  for (const till of ['ikeja', 'yaba', 'lekki', 'ajah']) {
    token.throwIfCancelled();
    await clock.wait(100);
    steps.push(till);
  }
  return 'all four paid';
};

const outcome = withDeadline(payTills, 250, clock).then((v) => v, (err) => err.message);
await clock.advance(100);
await clock.advance(100);
const atTheDeadline = steps.slice();
await clock.advance(50);
const timedOut = await outcome;
await clock.advance(100);
const afterTheInFlightStep = steps.slice();
await clock.advance(500);
const nothingMore = steps.slice();
const timersLeft = clock.pending;

const second = manualClock();
const quickSteps = [];
const payOne = async (token) => {
  await second.wait(50);
  token.throwIfCancelled();
  quickSteps.push('paid');
  return 'paid in time';
};
const winner = withDeadline(payOne, 500, second).then((v) => v, (err) => err.message);
await second.advance(50);
const won = await winner;
const noLeak = second.pending;

const third = manualClock();
const stubbornSteps = [];
const ignoresTheToken = async () => {
  for (const till of ['ikeja', 'yaba', 'lekki']) {
    await third.wait(100);
    stubbornSteps.push(till);
  }
  return 'finished anyway';
};
const abandoned = withDeadline(ignoresTheToken, 150, third).then((v) => v, (err) => err.message);
await third.advance(100);
await third.advance(50);
const gaveUpAt = await abandoned;
await third.advance(100);
await third.advance(100);
const keptGoing = stubbornSteps.slice();

console.log('timed out      :', timedOut, 'with', atTheDeadline, 'done');
console.log('then one more  :', afterTheInFlightStep, '-> and stopped:', nothingMore);
console.log('work won       :', won, '- timers left:', noLeak);
console.log('token ignored  :', gaveUpAt, '- work did', keptGoing);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38const log = [];
const task = (name, rounds) => async () => {
  log.push('start ' + name);
  for (let i = 0; i < rounds; i++) await Promise.resolve();
  log.push('end ' + name);
  return name.toUpperCase();
};
const tasks = [task('a', 3), task('b', 1), task('c', 2)];

const oneAtATime = [];
for (const start of tasks) oneAtATime.push(await start());
const sequentialLog = log.slice();

log.length = 0;
const started = tasks.map((start) => start());
const startedAtOnce = log.slice();
const inOrder = [];
for (const running of started) inOrder.push(await running);
const overlappedLog = log.slice();

const viaAll = await Promise.all(started);
const nothingReran = log.slice();

let attempts = 0;
const fails = (name) => async () => { attempts++; await Promise.resolve(); throw new Error(name + ' failed'); };
const risky = [task('ok', 1)(), fails('b')(), fails('c')()];

let stoppedAt = '';
try { for (const running of risky) await running; }
catch (err) { stoppedAt = err.message; }

const handledLate = await risky[2].then(() => 'resolved', (err) => 'handled late: ' + err.message);
const everyOutcome = (await Promise.allSettled(risky)).map((r) => r.status);

console.log('one at a time :', sequentialLog);
console.log('all started   :', startedAtOnce);
console.log('then awaited  :', overlappedLog);
console.log('loop stopped  :', stoppedAt, '- index 2:', handledLate);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44function disposalStack() {
  const entries = [];
  return {
    use(name, dispose) { entries.push({ name, dispose }); return name; },
    get size() { return entries.length; },
    async disposeAll() {
      const failures = [];
      while (entries.length) {
        const { name, dispose } = entries.pop();          // reverse order, and it empties
        try { await dispose(); }
        catch (err) { failures.push(new Error('could not release ' + name, { cause: err })); }
      }
      if (failures.length) {
        throw new AggregateError(failures, failures.length + ' resource(s) failed to release');
      }
    },
  };
}

const released = [];
const clean = disposalStack();
clean.use('database connection', () => released.push('database connection'));
clean.use('temp file', async () => { await Promise.resolve(); released.push('temp file'); });
clean.use('till printer', () => released.push('till printer'));
const sizeBefore = clean.size;
const noComplaint = await clean.disposeAll().then(() => 'released cleanly', (err) => err.message);
const orderOut = released.slice();
const sizeAfter = clean.size;

const messy = disposalStack();
const attempted = [];
messy.use('database connection', () => { attempted.push('database connection'); });
messy.use('temp file', () => { attempted.push('temp file'); throw new Error('file already gone'); });
messy.use('till printer', async () => { attempted.push('till printer'); throw new Error('printer not responding'); });
const failure = await messy.disposeAll().catch((err) => err);
const reported = failure.errors.map((err) => err.message);
const rootCauses = failure.errors.map((err) => err.cause.message);

const twice = await messy.disposeAll().then(() => 'nothing left to do', (err) => err.message);

console.log('clean   :', noComplaint, orderOut);
console.log('messy   :', failure.message);
console.log('reported:', reported);
console.log('causes  :', rootCauses);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33const fromEnd = (array) => new Proxy(array, {
  get(target, key, receiver) {
    if (typeof key === 'string' && /^-\d+$/.test(key)) {
      const at = target.length + Number(key);
      return at >= 0 ? target[at] : undefined;
    }
    return Reflect.get(target, key, receiver);   // everything else, untouched
  },
});

const base = ['Yaba', 'Surulere', 'Ojuelegba', 'Ikeja'];
const stops = fromEnd(base);

const negatives = [stops[-1], stops[-2]];
const outOfRange = stops[-9] === undefined;
const positives = [stops[0], stops.length];
const joined = stops.join(' - ');
const spread = [...stops];
const stillAnArray = Array.isArray(stops);

stops.push('Agege');                  // push reads length and writes through the untrapped set
const afterPush = [base.length, stops[-1]];

stops[-1] = 'Mushin';                 // NOT the last element: a property literally named "-1"
const lengthUnchanged = base.length;
const literalKey = Object.hasOwn(base, '-1');
const readBack = stops[-1];
const onTheTarget = base['-1'];

console.log('negatives :', negatives);
console.log('joined    :', joined);
console.log('after push:', afterPush);
console.log('base      :', base, 'plus a "-1" key holding', onTheTarget);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30const withDefault = (fallback, seed = {}) => new Proxy({ ...seed }, {
  get(target, key, receiver) {
    return Reflect.has(target, key) ? Reflect.get(target, key, receiver) : fallback;
  },
});

const fares = withDefault(0, { Yaba: 300, Ikeja: 500 });

const seeded = fares.Yaba;
const missing = fares.Lekki;
const tallied = fares.Lekki + fares.Ikeja + 100;      // no ?? 0 anywhere
const inSaysNo = 'Lekki' in fares;
const realKeys = Object.keys(fares);

fares.Lekki = 700;                                     // set is untrapped, so this is real
const nowPresent = ['Lekki' in fares, fares.Lekki];
const serialised = JSON.parse(JSON.stringify(fares));

// The same idea with `has` trapped too, which is a much bigger claim.
const everything = new Proxy({ Yaba: 300, Ikeja: 500 }, {
  get: (t, k, r) => (Reflect.has(t, k) ? Reflect.get(t, k, r) : 0),
  has: () => true,
});
const inSaysYes = ['Ojota' in everything, 'nonsense' in everything];
const keysUnmoved = Object.keys(everything);

console.log('seeded, missing:', seeded, missing);
console.log('tallied        :', tallied);
console.log('real keys      :', realKeys);
console.log('serialised     :', serialised);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51const rules = {
  customer: (v) => (typeof v === 'string' && v.trim() !== '' ? '' : 'must be a name'),
  amount: (v) => (Number.isInteger(v) && v > 0 ? '' : 'must be a positive whole number of naira'),
};
const check = (key, value) => {
  const rule = rules[key];
  if (!rule) throw new TypeError('no such field: ' + String(key));
  const complaint = rule(value);
  if (complaint) throw new TypeError(String(key) + ' ' + complaint);
};

const validated = (target) => new Proxy(target, {
  set(t, key, value, receiver) {
    check(key, value);
    return Reflect.set(t, key, value, receiver);      // returns true, which the trap must
  },
  defineProperty(t, key, desc) {
    if ('value' in desc) check(key, desc.value);      // or defineProperty slips past set
    return Reflect.defineProperty(t, key, desc);
  },
});

const attempt = (fn) => { try { fn(); return 'no error'; } catch (err) { return err.message; } };
const attemptName = (fn) => { try { fn(); return 'no error'; } catch (err) { return err.name; } };

const raw = {};
const order = validated(raw);
order.customer = 'Adaeze';
order.amount = 25000;
const accepted = { ...order };

const badAmount = attempt(() => { order.amount = -500; });
const badName = attempt(() => { order.customer = '   '; });
const unknownField = attempt(() => { order.status = 'paid'; });
const targetAfter = { ...raw };

const viaDefine = attempt(() => Object.defineProperty(order, 'amount', { value: -999 }));

// A trap that refuses by returning false rather than throwing.
const refuses = new Proxy({}, { set: () => false });
const strictWrite = attemptName(() => { refuses.anything = 1; });
const reflectWrite = Reflect.set(refuses, 'anything', 1);

// The same object with only a set trap: defineProperty is not checked at all.
const setOnly = new Proxy({}, { set() { throw new Error('no writes allowed'); } });
Object.defineProperty(setOnly, 'amount', { value: -999, enumerable: true, configurable: true });
const slippedThrough = setOnly.amount;

console.log('accepted   :', accepted);
console.log('rejections :', [badAmount, badName, unknownField]);
console.log('defineProp :', viaDefine, '| unguarded:', slippedThrough);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37const readOnly = (target) => new Proxy(target, {
  get(t, key, receiver) {
    const value = Reflect.get(t, key, receiver);
    return value !== null && typeof value === 'object' ? readOnly(value) : value;
  },
  set: () => false,
  deleteProperty: () => false,
  defineProperty: () => false,
  setPrototypeOf: () => false,
});

const attemptName = (fn) => { try { fn(); return 'no error'; } catch (err) { return err.name; } };

const settings = {
  till: 'Balogun 3',
  limits: { perOrder: 500000, daily: 2000000 },
};
const view = readOnly(settings);

const reads = [view.till, view.limits.perOrder];
const writeAttempt = attemptName(() => { view.till = 'Ikeja 1'; });
const deleteAttempt = attemptName(() => { delete view.till; });
const defineAttempt = attemptName(() => Object.defineProperty(view, 'till', { value: 'Ikeja 1' }));
const reflectSays = [Reflect.set(view, 'till', 'Ikeja 1'), Reflect.deleteProperty(view, 'till')];
const untouched = settings.till;

const nestedWrite = attemptName(() => { view.limits.daily = 0; });
const nestedUntouched = settings.limits.daily;

settings.limits.daily = 3000000;                 // the owner still writes to the original
const viewSeesIt = view.limits.daily;
const looksFrozen = [Object.isFrozen(view), Object.isFrozen(settings)];
const sameTwice = view.limits === view.limits;

console.log('reads      :', reads);
console.log('refusals   :', [writeAttempt, deleteAttempt, defineAttempt, nestedWrite]);
console.log('view sees  :', viewSeesIt, '| identity stable:', sameTwice);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33const log = [];
const watch = (target) => new Proxy(target, {
  get(t, k, r) { log.push('get ' + String(k)); return Reflect.get(t, k, r); },
  set(t, k, v, r) { log.push('set ' + String(k)); return Reflect.set(t, k, v, r); },
  has(t, k) { log.push('has ' + String(k)); return Reflect.has(t, k); },
  deleteProperty(t, k) { log.push('delete ' + String(k)); return Reflect.deleteProperty(t, k); },
  ownKeys(t) { log.push('ownKeys'); return Reflect.ownKeys(t); },
});

const trip = watch({ stop: 'Ojota', fare: 400 });

trip.stop;
trip.fare = 450;
const asked = 'fare' in trip;
const gone = delete trip.stop;
const afterFour = log.slice();

log.length = 0;
const keys = Object.keys(trip);
const afterKeys = log.slice();

log.length = 0;
const copy = { ...trip };
const afterSpread = log.slice();

log.length = 0;
const json = JSON.stringify(trip);
const afterJson = log.slice();

console.log('four operations:', afterFour);
console.log('Object.keys    :', afterKeys);
console.log('spread         :', afterSpread);
console.log('stringify      :', afterJson, '->', json);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42const attemptName = (fn) => { try { fn(); return 'no error'; } catch (err) { return err.name; } };

const base = { stop: 'Ojota' };

// An invented key, reported by ownKeys but described by nobody.
const halfDone = new Proxy(base, {
  ownKeys: (t) => [...Reflect.ownKeys(t), 'zone'],
});
const reflectSees = Reflect.ownKeys(halfDone);
const objectKeysSees = Object.keys(halfDone);
const spreadSees = Object.keys({ ...halfDone });

// The same trap, with a descriptor for the invented key.
const consistent = new Proxy(base, {
  ownKeys: (t) => [...Reflect.ownKeys(t), 'zone'],
  getOwnPropertyDescriptor(t, key) {
    if (key === 'zone') return { value: 'Lagos Mainland', enumerable: true, configurable: true };
    return Reflect.getOwnPropertyDescriptor(t, key);
  },
  get(t, key, r) { return key === 'zone' ? 'Lagos Mainland' : Reflect.get(t, key, r); },
});
const nowKeys = Object.keys(consistent);
const nowSpread = { ...consistent };

// Invariant 1: no duplicates.
const duplicated = new Proxy({}, { ownKeys: () => ['stop', 'stop'] });
const duplicateError = attemptName(() => Reflect.ownKeys(duplicated));

// Invariant 2: a non-configurable own key cannot be hidden.
const pinned = {};
Object.defineProperty(pinned, 'id', { value: 'LAG-0061', configurable: false, enumerable: true });
const hiding = new Proxy(pinned, { ownKeys: () => [] });
const hidingError = attemptName(() => Reflect.ownKeys(hiding));

// Invariant 3: nothing may be invented on a non-extensible target.
const sealedTarget = Object.preventExtensions({ stop: 'Ojota' });
const inventing = new Proxy(sealedTarget, { ownKeys: (t) => [...Reflect.ownKeys(t), 'zone'] });
const inventingError = attemptName(() => Reflect.ownKeys(inventing));

console.log('Reflect vs Object.keys:', reflectSees, objectKeysSees);
console.log('once consistent       :', nowKeys, nowSpread);
console.log('invariant errors      :', [duplicateError, hidingError, inventingError]);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39const thenCalls = [];

// A trap that answers every unknown key with a string. 'then' is a string, so
// the proxy is not a thenable, and await hands it straight back.
const withString = new Proxy({ receipt: 'LAG-0062' }, {
  get: (t, k, r) => (Reflect.has(t, k) ? Reflect.get(t, k, r) : 'unknown field'),
});
const awaited = await withString;
const sameObject = awaited === withString;
const readable = awaited.receipt;
const thenIsAString = typeof withString.then;

// The same trap, answering with a function. Now it looks like a promise.
const withFunction = new Proxy({ receipt: 'LAG-0062' }, {
  get: (t, k, r) => (Reflect.has(t, k) ? Reflect.get(t, k, r)
    : (...args) => { thenCalls.push([String(k), args.length, typeof args[0], typeof args[1]]); }),
});
const looksThenable = typeof withFunction.then === 'function';
thenCalls.length = 0;

const adopted = Promise.resolve(withFunction);      // NOT awaited: it can never settle
await Promise.resolve();                            // let the thenable job run
await Promise.resolve();
const whatThenGot = thenCalls.slice();
const raced = await Promise.race([adopted.then(() => 'settled'), Promise.resolve('still pending')]);

// The fix: answer 'then' honestly, whatever else the trap invents.
const safe = new Proxy({ receipt: 'LAG-0062' }, {
  get(t, k, r) {
    if (k === 'then' || k === 'catch' || k === 'finally') return Reflect.get(t, k, r);
    return Reflect.has(t, k) ? Reflect.get(t, k, r) : 'unknown field';
  },
});
const safeAwait = await safe;
const safeIsSame = [safeAwait === safe, safeAwait.receipt, typeof safe.then];

console.log('await a non-thenable proxy:', sameObject, readable);
console.log('then was called with      :', whatThenGot);
console.log('race says                 :', raced);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48const attemptName = (fn) => { try { fn(); return 'no error'; } catch (err) { return err.name; } };

const fares = new Map([['Yaba', 300], ['Ikeja', 500]]);
const bare = new Proxy(fares, {});
const slotError = attemptName(() => bare.get('Yaba'));

// The usual fix: hand back methods already bound to the target.
const bound = new Proxy(fares, {
  get(t, key, receiver) {
    const value = Reflect.get(t, key, receiver);
    return typeof value === 'function' ? value.bind(t) : value;
  },
});
const worksNow = bound.get('Yaba');
bound.set('Ojota', 250);
const targetChanged = fares.get('Ojota');
const identityLost = bound.get === bound.get;
const accessorStillFails = attemptName(() => bound.size);   // size is a getter, not a method

// Forwarding the target as the RECEIVER too is what fixes the accessor.
const forwarded = new Proxy(fares, {
  get(t, key) {
    const value = Reflect.get(t, key, t);
    return typeof value === 'function' ? value.bind(t) : value;
  },
});
const sizeWorks = forwarded.size;

class Account {
  #balance = 0;
  constructor(name) { this.name = name; }
  deposit(naira) { this.#balance += naira; return this.#balance; }
  get balance() { return this.#balance; }
}
const account = new Account('Adaeze');
account.deposit(15000);
const proxied = new Proxy(account, {});
const privateError = attemptName(() => proxied.balance);
const publicFine = proxied.name;
const noSuchKey = [Object.getOwnPropertyNames(account), Object.keys(account)];

const identity = [proxied === account, bare === fares];
const typeofSays = [typeof new Proxy({}, {}), typeof new Proxy(function () {}, {})];
const stillAnInstance = [proxied instanceof Account, bare instanceof Map];

console.log('Map behind a bare proxy:', slotError, '| bound:', worksNow, '| size:', accessorStillFails);
console.log('private field          :', privateError, '| public:', publicFine);
console.log('typeof                 :', typeofSays);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37const attemptName = (fn) => { try { fn(); return 'no error'; } catch (err) { return err.name; } };

const stallPrototype = {
  get label() { return this.item + ' by the ' + this.unit; },
};
const yam = { item: 'yam', unit: 'tuber' };
const rice = Object.create(stallPrototype);
rice.item = 'rice';
rice.unit = 'kg';

const own = Reflect.get(rice, 'item');
const throughChain = Reflect.get(rice, 'label');
const withOtherReceiver = Reflect.get(stallPrototype, 'label', yam);

const source = { fare: 400 };
const receiver = {};
const setReported = Reflect.set(source, 'fare', 450, receiver);
const whereItLanded = [source.fare, receiver.fare];

const AUDIT = Symbol('audit');
const order = { customer: 'Bisi', [AUDIT]: 'Balogun till 3' };
Object.defineProperty(order, 'internalRef', { value: 'LAG-0064', enumerable: false });
const objectKeys = Object.keys(order);
const allKeys = Reflect.ownKeys(order).map(String);
const names = Object.getOwnPropertyNames(order);

const frozen = Object.freeze({ fare: 400 });
const reflectRefuses = Reflect.defineProperty(frozen, 'fare', { value: 500 });
const objectThrows = attemptName(() => Object.defineProperty(frozen, 'fare', { value: 500 }));
const deleteRefuses = Reflect.deleteProperty(frozen, 'fare');
const deleteThrows = attemptName(() => { delete frozen.fare; });

const hasAgrees = [Reflect.has(rice, 'label'), 'label' in rice, Reflect.has(rice, 'zone')];

console.log('getter with another receiver:', withOtherReceiver);
console.log('set landed on               :', whereItLanded);
console.log('keys                        :', objectKeys, 'vs', allKeys);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29class Naira {
  constructor(kobo) { this.kobo = kobo; }
  [Symbol.toPrimitive](hint) {
    if (hint === 'number') return this.kobo / 100;
    if (hint === 'string') return '\u20a6' + (this.kobo / 100).toFixed(2);
    return 'Naira(' + this.kobo + ' kobo)';            // 'default'
  }
  toString() { return 'toString ran'; }
  valueOf() { return -1; }
  toJSON() { return { naira: this.kobo / 100 }; }
}

const fare = new Naira(45000);       // 450 naira
const tip = new Naira(5000);         // 50 naira

const asNumber = [Number(fare), +fare];
const arithmetic = [fare * 2, fare - tip, Math.max(fare, tip)];
const asString = [String(fare), `fare is ${fare}`, fare.toFixed ? 'has toFixed' : 'no toFixed'];
const concatenated = fare + '';
const added = fare + tip;
const compared = [fare > tip, [fare, tip].sort((a, b) => a - b).map((m) => m.kobo)];
const looseEqual = fare == 'Naira(45000 kobo)';
const serialised = JSON.stringify({ fare });
const unreachable = [String(fare) === 'toString ran', Number(fare) === -1];

console.log('number hint :', asNumber, arithmetic);
console.log('string hint :', asString.slice(0, 2));
console.log('default hint:', concatenated, '|', added);
console.log('serialised  :', serialised);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32const typeOf = (value) => Object.prototype.toString.call(value).slice(8, -1);

class Receipt {
  constructor(total) { this.total = total; }
}
class Tagged {
  constructor(total) { this.total = total; }
  get [Symbol.toStringTag]() { return 'Receipt'; }
}

const plainInstance = typeOf(new Receipt(45000));
const taggedInstance = typeOf(new Tagged(45000));
const stringified = String(new Tagged(45000));
const constructorName = new Receipt(45000).constructor.name;

const primitivesAndBuiltins = [
  typeOf(null), typeOf(undefined), typeOf(42), typeOf('Lagos'),
  typeOf([]), typeOf(new Map()), typeOf(Promise.resolve()), typeOf(/x/),
];
const generator = (function* () {})();
const fromSameMechanism = [typeOf(generator), typeOf(Math), typeOf(JSON)];

const tagged = new Tagged(45000);
const invisible = [Object.keys(tagged), JSON.stringify(tagged), Object.getOwnPropertySymbols(tagged).length];

const liar = { [Symbol.toStringTag]: 'Array', length: 0 };
const lieBelieved = typeOf(liar);
const lieRejected = [Array.isArray(liar), liar instanceof Array];

console.log('untagged, tagged:', plainInstance, taggedInstance);
console.log('built-ins       :', primitivesAndBuiltins);
console.log('the liar        :', lieBelieved, lieRejected);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41const attemptName = (fn) => { try { fn(); return 'no error'; } catch (err) { return err.name; } };

// Not a function, not a constructor, still usable on the right of instanceof.
const Callable = { [Symbol.hasInstance]: (v) => typeof v === 'function' };
const notCallable = {};

const functionMatches = [(() => {}) instanceof Callable, 42 instanceof Callable];
const withoutTheSymbol = attemptName(() => 42 instanceof notCallable);
const rightSideType = typeof Callable;

class Payable {
  static [Symbol.hasInstance](value) {
    return Boolean(value) && typeof value.amount === 'number' && typeof value.pay === 'function';
  }
  constructor(amount) { this.amount = amount; }
  pay() { return 'paid ' + this.amount; }
}

const duck = { amount: 45000, pay: () => 'transfer sent' };
const duckPasses = duck instanceof Payable;
const notInTheChain = [Object.getPrototypeOf(duck) === Payable.prototype, Payable.prototype.isPrototypeOf(duck)];

const real = new Payable(45000);
const realPasses = real instanceof Payable;
const halfShaped = { amount: 45000 } instanceof Payable;

// It can refuse a genuine instance just as easily.
class Fussy {
  static [Symbol.hasInstance]() { return false; }
}
const genuine = new Fussy();
const refused = [genuine instanceof Fussy, Object.getPrototypeOf(genuine) === Fussy.prototype];

// What normally runs is Function.prototype[Symbol.hasInstance], and it is callable.
const theDefault = Function.prototype[Symbol.hasInstance];
const defaultAnswers = [theDefault.call(Array, []), theDefault.call(Array, 'Lagos')];
const primitiveArrives = [] instanceof Callable;

console.log('function instanceof Callable:', functionMatches);
console.log('duck typed                  :', duckPasses, '| in the chain:', notInTheChain);
console.log('genuine instance refused    :', refused);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32const AUDIT = Symbol('audit');
const order = { customer: 'Bisi', total: 45000, [AUDIT]: 'Balogun till 3, 15:40' };

const stringKeys = Object.keys(order);
const enumerated = [];
for (const key in order) enumerated.push(key);
const serialised = JSON.stringify(order);
const revived = JSON.parse(serialised);

const symbolKeys = Object.getOwnPropertySymbols(order).map(String);
const everyKey = Reflect.ownKeys(order).map(String);
const readsFine = order[AUDIT];

const spread = { ...order };
const assigned = Object.assign({}, order);
const copiedTheSymbol = [spread[AUDIT], assigned[AUDIT], Object.keys(spread)];
const survivesRoundTrip = revived[AUDIT] === undefined;

const LOOKALIKE = Symbol('audit');
order[LOOKALIKE] = 'Ikeja till 1, 09:05';
const bothCoexist = [order[AUDIT], order[LOOKALIKE], Object.getOwnPropertySymbols(order).length];
const freshMisses = order[Symbol('audit')] === undefined;

const description = [AUDIT.description, String(AUDIT), AUDIT === LOOKALIKE];
let conversion;
try { conversion = '' + AUDIT; } catch (err) { conversion = err.name; }
let templated;
try { templated = `${AUDIT}`; } catch (err) { templated = err.name; }

console.log('string keys :', stringKeys, '| serialised:', serialised);
console.log('symbol keys :', symbolKeys, '| every key:', everyKey);
console.log('conversions :', conversion, templated, String(AUDIT));