Add test case

src/result_promise.ts

@@ -72,7 +72,9 @@ export class ResultPromise<T, E> implements PromiseLike<Result<T, E>> {
 	/**
 	 * Async version of `Result#andThenAsync`.
 	 */
-	andThenAsync<U, F>(f: (value: T) => Promise<Result<U, F>>): ResultPromise<U, E | F> {
+	andThenAsync<U, F>(
+		f: (value: T) => ResultPromise<U, F> | Promise<Result<U, F>>,
+	): ResultPromise<U, E | F> {
 		return new ResultPromise(this.then((result) => result.andThenAsync((value) => f(value))))
 	}
 

test/result.test.ts

@@ -1,6 +1,5 @@
 import {describe, it, expect, expectTypeOf, vi} from "vitest"
-import {Panic, Ok, Err, Result, Some, None, ErrorWithTag} from "../src"
-import {test} from "vitest"
+import {Panic, Ok, Err, Result, Some, None, ErrorWithTag, ResultPromise} from "../src"
 
 export function TestOk<T, E>(value: T): Result<T, E> {
 	return Ok(value)
@@ -148,6 +147,20 @@ describe.concurrent("andThenAsync", () => {
 			a.unwrapErr(),
 		)
 	})
+
+	it("can map error type", async () => {
+		const a = TestErr<number, "foo">("foo")
+		const b = a.andThenAsync(async (value) => {
+			if (value < 0) {
+				return Err("bar" as const)
+			}
+			if (value > 1) {
+				return Ok(value)
+			}
+			return Err("baz" as const)
+		})
+		expectTypeOf(b).toEqualTypeOf<ResultPromise<number, "foo" | "bar" | "baz">>()
+	})
 })
 
 describe.concurrent("expect", () => {

test/result_promise.test.ts

@@ -1,5 +1,16 @@
 import {describe, it, expect, expectTypeOf} from "vitest"
-import {Err, Panic, ResultPromise, Ok, Result, ErrorWithTag, Some, None} from "../src"
+import {
+	Err,
+	Panic,
+	ResultPromise,
+	Ok,
+	Result,
+	ErrorWithTag,
+	Some,
+	None,
+	CaughtError,
+	tryPromise,
+} from "../src"
 import {TestErr, TestOk} from "./result.test"
 import {vi} from "vitest"
 
@@ -73,6 +84,65 @@ describe.concurrent("andThenAsync", () => {
 		const a = TestErrPromise<number, string>(0)
 		await expect(a.andThenAsync(async (value) => Ok(value + 1)).unwrapErr()).resolves.toEqual(0)
 	})
+
+	it("can map error type", async () => {
+		const a = TestErrPromise<"foo", number>("foo")
+		const b = a.andThenAsync(async (value) => {
+			if (value < 0) {
+				return Err("bar" as const)
+			}
+			if (value > 1) {
+				return Ok(value)
+			}
+			return Err("baz" as const)
+		})
+		expectTypeOf(b).toEqualTypeOf<ResultPromise<number, "foo" | "bar" | "baz">>()
+	})
+
+	it("can map error type with complicated error", async () => {
+		class PrismaError extends ErrorWithTag {
+			readonly tag = "prisma"
+			// readonly message = "Prisma error"
+
+			// constructor(public readonly error: CaughtError) {
+			// 	super()
+			// }
+		}
+
+		abstract class NotFoundError extends ErrorWithTag {
+			// category = "not_found"
+		}
+
+		class AccountNotFoundError extends NotFoundError {
+			readonly tag = "account"
+			// readonly message = "Account not found"
+		}
+
+		async function fn(): Promise<{id: number} | null> {
+			return {id: 1}
+		}
+
+		const maybeExpiredToken = await tryPromise(fn())
+			.mapErr((error) => new PrismaError(error))
+			.andThen((maybeAccount) => {
+				if (maybeAccount) {
+					return Ok(maybeAccount)
+				}
+				return Err(new AccountNotFoundError())
+			})
+			.andThenAsync(async (account) => {
+				if (account.id < 0) {
+					return Err(new AccountNotFoundError())
+				}
+
+				const ye = await tryPromise(fn()).mapErr((error) => new PrismaError(error))
+				if (ye.isErr) {
+					return Err(ye.value)
+				}
+
+				return Ok(account)
+			})
+	})
 })
 
 describe.concurrent("expect", () => {