neverthrow Result and ResultAsync pipelines: working versions (tested 2026-10-15)

{
  "name": "neverthrow-async-result",
  "private": true,
  "type": "module",
  "scripts": {
    "test": "node --import tsx --test test/*.test.ts"
  },
  "dependencies": {
    "neverthrow": "8.2.0"
  },
  "devDependencies": {
    "@types/node": "26.6.5",
    "tsx": "4.23.15"
  }
}

import { err, ok, Result, ResultAsync } from "neverthrow";

export class NotFoundError extends Error {
  readonly _tag = "NotFoundError" as const;
  constructor(readonly id: string) { super(`not found: ${id}`); }
}
export class InsufficientFunds extends Error {
  readonly _tag = "InsufficientFunds" as const;
  constructor(readonly balance: number, readonly amount: number) {
    super(`need ${amount}, have ${balance}`);
  }
}

type Account = { id: string; balance: number };
const db = new Map<string, Account>();

export function reset(seed: Account[] = []) {
  db.clear();
  for (const a of seed) db.set(a.id, { ...a });
}

export function getAccount(id: string): Result<Account, NotFoundError> {
  const a = db.get(id);
  return a ? ok({ ...a }) : err(new NotFoundError(id));
}

export function charge(id: string, amount: number): Result<Account, NotFoundError | InsufficientFunds> {
  return getAccount(id).andThen((a) => {
    if (a.balance < amount) return err(new InsufficientFunds(a.balance, amount));
    const next = { ...a, balance: a.balance - amount };
    db.set(id, next);
    return ok(next);
  });
}

export function chargeAsync(id: string, amount: number) {
  return ResultAsync.fromSafePromise(Promise.resolve(charge(id, amount))).andThen((r) => r);
}

import { test } from "node:test";
import assert from "node:assert/strict";
import { charge, chargeAsync, getAccount, reset } from "../src/payments.ts";

test("charge success and errors", async () => {
  reset([{ id: "a1", balance: 100 }]);
  assert.equal(getAccount("missing").isErr(), true);
  const ok = charge("a1", 40);
  assert.equal(ok.isOk(), true);
  if (ok.isOk()) assert.equal(ok.value.balance, 60);
  const poor = charge("a1", 1000);
  assert.equal(poor.isErr(), true);
  if (poor.isErr()) assert.equal(poor.error._tag, "InsufficientFunds");
  const asyncOk = await chargeAsync("a1", 10);
  assert.equal(asyncOk.isOk(), true);
});