Properly re-throw errors from async actions

CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 2.4.1
+
+### Bugfix
+* Properly re-throw errors from async actions.
+
 ## 2.4.0
 
 ### Feature

package.json

@@ -1,6 +1,6 @@
 {
   "name": "exome",
-  "version": "2.4.0",
+  "version": "2.4.1",
   "description": "Proxy based store manager for deeply nested states",
   "main": "./dist/exome.js",
   "module": "./dist/exome.mjs",

src/constructor.test.ts

@@ -41,4 +41,21 @@ test('extended exome instance has "Person" in id', () => {
 	assert.match(instance[exomeId], /^Person-[A-Z0-9]+$/);
 });
 
+test("throws error for async action", async () => {
+	class TestStore extends Exome {
+		public async run() {
+			throw new Error("Poop");
+		}
+	}
+	const test1 = new TestStore();
+
+	try {
+		await test1.run();
+		assert.unreachable();
+	} catch (err) {
+		assert.instance(err, Error);
+		assert.equal(err.message, "Poop");
+	}
+});
+
 test.run();

src/utils.test.ts

@@ -124,7 +124,9 @@ const { getActionStatus } = proxyquire
 			`{"loading":true,"error":false}`,
 		);
 
-		await promise;
+		try {
+			await promise;
+		} catch (_) {}
 
 		assert.snapshot(
 			JSON.stringify(test1.status),

src/utils/wrapper.test.ts

@@ -0,0 +1,85 @@
+import { suite } from "uvu";
+import assert from "uvu/assert";
+
+import { wrapper } from "./wrapper.ts";
+
+{
+	const test = suite("wrapper");
+
+	test("exports `wrapper`", () => {
+		assert.ok(wrapper);
+	});
+
+	test("that `wrapper` is function", () => {
+		assert.instance(wrapper, Function);
+	});
+
+	test("doesn't throw with sync success action", () => {
+		class TestStore {
+			constructor() {
+				return wrapper(this as any);
+			}
+			public test() {}
+		}
+		const testStore = new TestStore();
+
+		assert.not.throws(testStore.test);
+	});
+
+	test("doesn't throw with async success action", async () => {
+		class TestStore {
+			constructor() {
+				return wrapper(this as any);
+			}
+			public async test() {
+				await Promise.resolve();
+			}
+		}
+		const testStore = new TestStore();
+
+		try {
+			await testStore.test();
+			assert.ok(true);
+		} catch (err) {
+			assert.instance(err, Error);
+			assert.equal(err.message, "test error");
+		}
+	});
+
+	test("throws with sync error action", () => {
+		class TestStore {
+			constructor() {
+				return wrapper(this as any);
+			}
+			public test() {
+				throw new Error("test error");
+			}
+		}
+		const testStore = new TestStore();
+
+		assert.throws(testStore.test);
+	});
+
+	test("throws with async error action", async () => {
+		class TestStore {
+			constructor() {
+				return wrapper(this as any);
+			}
+			public async test() {
+				await Promise.resolve();
+				throw new Error("test error");
+			}
+		}
+		const testStore = new TestStore();
+
+		try {
+			await testStore.test();
+			assert.unreachable();
+		} catch (err) {
+			assert.instance(err, Error);
+			assert.equal(err.message, "test error");
+		}
+	});
+
+	test.run();
+}

src/utils/wrapper.ts

@@ -25,9 +25,11 @@ export const wrapper = <T extends Exome>(parent: T): T => {
 						const output = value.apply(parent, args);
 
 						if (output instanceof Promise) {
-							return output
-								.then((result) => (middleware(), result))
-								.catch(middleware);
+							return new Promise<any>((resolve, reject) => {
+								output
+									.then((result) => (middleware(), resolve(result)))
+									.catch((error) => (reject(error), middleware(error)));
+							});
 						}
 
 						return middleware(), output;