inflight 1.0.6: deduplicate concurrent async operations by key

Clean-room public code sample — generation instructions

Write a brand-new, minimal, self-contained code sample in this clean-room directory.
Do not copy, paraphrase, or reference any existing project source. Work only from this spec.

A csx.json manifest scaffold already exists. Do not recreate it from memory. Preserve its case.goal, packages and symbols; fill its empty case.contract with exact assertions and correct its environment, commands and verifierAdapter for the files you generate.

Goal: deduplicate concurrent async operations by key
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:npm/inflight@1.0.6
Demonstrate these symbols/APIs:
  - inflight

Rules:
  - One focused purpose; the smallest project that proves the goal.
  - Include a contract test (test/contract.*) that runs OFFLINE and exits 0 exactly when the goal behavior works.
  - Pin every dependency with a lockfile so resolution is reproducible.
  - No secrets, credentials, or tokens. No real URLs (only example.com or localhost). No absolute paths.
  - No personal names, emails, company names, or project identifiers of any kind.
  - No binaries and no generated output (node_modules, dist, target, venv, .git, .env).
  - Keep it under 200 files and 256KB packed.

{"case":{"caseId":"case:sha256:8423857a680b0a8e3d6ef73b78bd513204f3554ebd4e9a068b40113ee20748cd","contract":["inflight(key, cb) returns a completion callback function on first call for a key and null for concurrent calls with the same key","inflight completion callback notifies all registered callbacks for that key with the passed arguments","inflight cleans up key state after completion, allowing subsequent calls for the same key to run again","concurrent calls with distinct keys run and resolve independently"],"goal":"deduplicate concurrent async operations by key","kind":"HOW","packages":["pkg:npm/inflight@1.0.6"],"schemaVersion":1,"symbols":["inflight"]},"contractCommand":["node","test/contract.mjs"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"npm","libc":"glibc","libcVersion":"2.39","os":"linux","osVersionBucket":"24","packageManager":"npm","schemaVersion":1},"license":"MIT-0","packages":["pkg:npm/inflight@1.0.6"],"schemaVersion":1,"subject":"pkg:npm/inflight@1.0.6","symbols":["inflight"],"verifierAdapter":"node-typescript@1"}

import inflight from 'inflight'

/**
 * Deduplicates concurrent async operations by key.
 *
 * @param {string} key - Unique key identifying the operation.
 * @param {Function} taskFn - The async task taking a callback (err, result).
 * @param {Function} callback - Caller callback to receive (err, result).
 */
export function deduplicateTask(key, taskFn, callback) {
  const cb = inflight(key, callback)
  if (!cb) {
    // Another request for key is in flight; callback is queued.
    return
  }

  taskFn((err, result) => {
    cb(err, result)
  })
}

{
  "name": "sample-inflight",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "sample-inflight",
      "version": "1.0.0",
      "dependencies": {
        "inflight": "1.0.6"
      }
    },
    "node_modules/inflight": {
      "version": "1.0.6",
      "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
      "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==",
      "deprecated": "This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful.",
      "license": "ISC",
      "dependencies": {
        "once": "^1.3.0",
        "wrappy": "1"
      }
    },
    "node_modules/once": {
      "version": "1.4.0",
      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
      "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
      "license": "ISC",
      "dependencies": {
        "wrappy": "1"
      }
    },
    "node_modules/wrappy": {
      "version": "1.0.2",
      "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
      "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==",
      "license": "ISC"
    }
  }
}

{
  "name": "sample-inflight",
  "version": "1.0.0",
  "description": "deduplicate concurrent async operations by key using inflight",
  "type": "module",
  "scripts": {
    "test": "node test/contract.mjs"
  },
  "dependencies": {
    "inflight": "1.0.6"
  }
}

{
  "schemaVersion": 1,
  "goal": "deduplicate concurrent async operations by key",
  "kind": "HOW",
  "packages": [
    "pkg:npm/inflight@1.0.6"
  ],
  "symbols": [
    "inflight"
  ]
}

import assert from 'node:assert/strict'
import inflight from 'inflight'
import { deduplicateTask } from '../index.mjs'

// Test 1: inflight(key, cb) returns completion callback on first call and null on concurrent calls
{
  let calledA = false
  let calledB = false
  const cb1 = (err, val) => { calledA = true }
  const cb2 = (err, val) => { calledB = true }

  const res1 = inflight('op-1', cb1)
  assert.equal(typeof res1, 'function', 'first inflight call must return a callback function')

  const res2 = inflight('op-1', cb2)
  assert.equal(res2, null, 'concurrent inflight call for same key must return null')

  // Resolve op-1
  res1(null, 'ok')
  assert.equal(calledA, true, 'first callback must be called')
  assert.equal(calledB, true, 'second callback must be called')
}

// Test 2: inflight cleans up key state after completion, allowing subsequent calls to run again
{
  let runCount = 0
  const firstRes = inflight('op-2', (err, val) => { runCount++ })
  assert.equal(typeof firstRes, 'function')
  firstRes(null, 'first')
  assert.equal(runCount, 1)

  // Subsequent call after completion should return a new callback function
  const secondRes = inflight('op-2', (err, val) => { runCount++ })
  assert.equal(typeof secondRes, 'function', 'subsequent call after completion must return a new callback function')
  secondRes(null, 'second')
  assert.equal(runCount, 2)
}

// Test 3: concurrent calls with distinct keys run independently
{
  const results = {}
  const cbKeyA = inflight('key-a', (err, val) => { results.a = val })
  const cbKeyB = inflight('key-b', (err, val) => { results.b = val })

  assert.equal(typeof cbKeyA, 'function', 'key-a should return a function')
  assert.equal(typeof cbKeyB, 'function', 'key-b should return a function')

  cbKeyA(null, 'val-a')
  assert.equal(results.a, 'val-a')
  assert.equal(results.b, undefined, 'key-b callback should not be triggered by key-a')

  cbKeyB(null, 'val-b')
  assert.equal(results.b, 'val-b')
}

// Test 4: deduplicateTask executes task function only once for concurrent callers
await new Promise((resolve, reject) => {
  let executions = 0
  const mockTask = (cb) => {
    executions++
    setTimeout(() => {
      cb(null, 'shared-data')
    }, 10)
  }

  let received1 = null
  let received2 = null
  let received3 = null

  deduplicateTask('resource-123', mockTask, (err, res) => {
    received1 = res
  })

  deduplicateTask('resource-123', mockTask, (err, res) => {
    received2 = res
  })

  deduplicateTask('resource-123', mockTask, (err, res) => {
    received3 = res
  })

  setTimeout(() => {
    try {
      assert.equal(executions, 1, 'task should only be executed once for concurrent requests')
      assert.equal(received1, 'shared-data')
      assert.equal(received2, 'shared-data')
      assert.equal(received3, 'shared-data')
      resolve()
    } catch (err) {
      reject(err)
    }
  }, 30)
})

console.log('Contract tests passed successfully.')