universalify 2.0.1: fromPromise

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: verify universalify.fromPromise in pkg:npm/universalify@2.0.1
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:npm/universalify@2.0.1
Demonstrate these symbols/APIs:
  - universalify.fromPromise
Constraints:
  - executionContext: node
Required runtime conditions:
  - ecosystem: npm
  - language: javascript
  - moduleSystem: cjs
  - runtime: node@22.23.2

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:2de8a308b3466162c39d81e2352d0613c45cc9d053f89f21e00ce0a7fcef24cb","constraints":{"executionContext":"node"},"contract":["universalify exports fromPromise as a function","fromPromise wraps an async function to return a promise when called without a callback","fromPromise delivers resolved value to a trailing error-first callback","fromPromise delivers rejection error to a trailing error-first callback","fromPromise propagates rejection when invoked as a promise without a callback","fromPromise passes all arguments correctly to the wrapped function in both promise and callback modes","fromPromise preserves the function name and this context"],"goal":"verify universalify.fromPromise in pkg:npm/universalify@2.0.1","kind":"HOW","packages":["pkg:npm/universalify@2.0.1"],"schemaVersion":1,"symbols":["universalify.fromPromise"]},"contractCommand":["node","test/contract.mjs"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"npm","executionContext":"node","language":"javascript","libc":"glibc","libcVersion":"2.39","moduleSystem":"cjs","os":"linux","osVersionBucket":"24","packageManager":"npm","packageManagerVersion":"10.9.8","runtime":"node","runtimeVersion":"22.23.2","schemaVersion":1},"license":"MIT-0","packages":["pkg:npm/universalify@2.0.1"],"schemaVersion":1,"subject":"pkg:npm/universalify@2.0.1","symbols":["universalify.fromPromise"],"verifierAdapter":"node-typescript@1"}

{
  "name": "sample-universalify-frompromise",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "sample-universalify-frompromise",
      "version": "1.0.0",
      "license": "MIT-0",
      "dependencies": {
        "universalify": "2.0.1"
      }
    },
    "node_modules/universalify": {
      "version": "2.0.1",
      "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
      "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
      "license": "MIT",
      "engines": {
        "node": ">= 10.0.0"
      }
    }
  }
}

{
  "name": "sample-universalify-frompromise",
  "version": "1.0.0",
  "private": true,
  "description": "Clean-room code sample for universalify.fromPromise in universalify@2.0.1",
  "main": "src/index.js",
  "license": "MIT-0",
  "dependencies": {
    "universalify": "2.0.1"
  }
}

{
  "schemaVersion": 1,
  "goal": "verify universalify.fromPromise in pkg:npm/universalify@2.0.1",
  "kind": "HOW",
  "packages": [
    "pkg:npm/universalify@2.0.1"
  ],
  "symbols": [
    "universalify.fromPromise"
  ],
  "constraints": {
    "executionContext": "node"
  },
  "runtimeConditions": {
    "ecosystem": "npm",
    "language": "javascript",
    "moduleSystem": "cjs",
    "runtime": "node@22.23.2"
  }
}

const universalify = require('universalify');

/**
 * Wraps an async or Promise-returning function so it can be invoked with
 * either standard async/await (returning a Promise) or a Node.js-style error-first callback.
 *
 * @param {Function} fn - An async function or function returning a Promise.
 * @returns {Function} Universal function callable with Promise or callback style.
 */
function wrapPromise(fn) {
  return universalify.fromPromise(fn);
}

module.exports = {
  universalify,
  fromPromise: universalify.fromPromise,
  wrapPromise
};

import assert from 'node:assert/strict';
import { createRequire } from 'node:module';

const require = createRequire(import.meta.url);
const {
  universalify,
  fromPromise,
  wrapPromise
} = require('../src/index.js');

async function testAll() {
  // 1. universalify exports fromPromise as a function
  assert.equal(typeof universalify, 'object', 'universalify should be an object');
  assert.equal(typeof universalify.fromPromise, 'function', 'universalify.fromPromise should be a function');
  assert.equal(typeof fromPromise, 'function', 'fromPromise should be a function');
  assert.equal(typeof wrapPromise, 'function', 'wrapPromise should be a function');

  // 2. fromPromise wraps an async function to return a promise when called without a callback
  async function computeSum(a, b) {
    return a + b;
  }
  const universalSum = fromPromise(computeSum);
  const promiseResult = await universalSum(10, 20);
  assert.equal(promiseResult, 30, 'Promise mode should resolve to the expected sum');

  // 3. fromPromise delivers resolved value to a trailing error-first callback
  const callbackResult = await new Promise((resolve, reject) => {
    universalSum(15, 25, (err, res) => {
      if (err) return reject(err);
      resolve(res);
    });
  });
  assert.equal(callbackResult, 40, 'Callback mode should deliver (null, result) on success');

  // 4. fromPromise delivers rejection error to a trailing error-first callback
  async function failAsync(message) {
    throw new Error(message);
  }
  const universalFail = fromPromise(failAsync);

  const errorCallbackResult = await new Promise((resolve) => {
    universalFail('callback error test', (err, res) => {
      resolve({ err, res });
    });
  });
  assert.ok(errorCallbackResult.err instanceof Error, 'Callback should receive Error instance');
  assert.equal(errorCallbackResult.err.message, 'callback error test');
  assert.equal(errorCallbackResult.res, undefined);

  // 5. fromPromise propagates rejection when invoked as a promise without a callback
  await assert.rejects(
    async () => {
      await universalFail('promise rejection test');
    },
    {
      name: 'Error',
      message: 'promise rejection test'
    },
    'Promise mode should reject when the underlying function rejects'
  );

  // 6. fromPromise passes all arguments correctly to the wrapped function in both promise and callback modes
  async function concatenate(a, b, c) {
    return `${a}-${b}-${c}`;
  }
  const universalConcat = wrapPromise(concatenate);

  const joinedPromise = await universalConcat('foo', 'bar', 'baz');
  assert.equal(joinedPromise, 'foo-bar-baz', 'All arguments should be forwarded in promise mode');

  const joinedCallback = await new Promise((resolve, reject) => {
    universalConcat('alpha', 'beta', 'gamma', (err, res) => {
      if (err) return reject(err);
      resolve(res);
    });
  });
  assert.equal(joinedCallback, 'alpha-beta-gamma', 'All arguments should be forwarded in callback mode');

  // 7. fromPromise preserves the function name and this context
  async function namedOperation(factor) {
    return this.base * factor;
  }
  const universalNamed = fromPromise(namedOperation);
  assert.equal(universalNamed.name, 'namedOperation', 'Function name should be preserved');

  const context = { base: 7 };
  const contextPromiseResult = await universalNamed.call(context, 6);
  assert.equal(contextPromiseResult, 42, 'this context should be preserved in promise mode');

  const contextCallbackResult = await new Promise((resolve, reject) => {
    universalNamed.call(context, 8, (err, res) => {
      if (err) return reject(err);
      resolve(res);
    });
  });
  assert.equal(contextCallbackResult, 56, 'this context should be preserved in callback mode');

  console.log('All universalify.fromPromise contract tests passed successfully.');
}

testAll().catch((err) => {
  console.error('Contract test failed:', err);
  process.exit(1);
});