oops

Author: ieedan

src/utils.ts

@@ -1,7 +1,7 @@
-import type { AnyError, UserFacingError, create } from ".";
+import type { AnyError, UserFacingError } from '.';
 
 type ErrorHandlers<T extends AnyError, O> = {
-	[K in T["name"]]: (error: Extract<T, { name: K }>) => O;
+	[K in T['name']]: (error: Extract<T, { name: K }>) => O;
 };
 
 /**
@@ -11,12 +11,15 @@ type ErrorHandlers<T extends AnyError, O> = {
  * @param handlers - The handlers for each error type
  * @returns
  */
-export function match<T extends AnyError, O>(error: T, handlers: ErrorHandlers<T, O>): O {
+export function match<T extends AnyError, O>(
+	error: T,
+	handlers: ErrorHandlers<T, O>,
+): O {
 	return (handlers as any)[error.name](error);
 }
 
 type InternalErrorHandlers<T extends AnyError, O> = {
-	[K in T["name"]]: Extract<T, { name: K }> extends { type: "internal" }
+	[K in T['name']]: Extract<T, { name: K }> extends { type: 'internal' }
 		? (error: Extract<T, { name: K }>) => O
 		: never;
 };
@@ -34,17 +37,15 @@ type NeverNever<T> = {
  */
 export function mapToUserFacingError<E extends AnyError>(
 	error: E,
-	handlers: NeverNever<InternalErrorHandlers<E, string>>
+	handlers: NeverNever<InternalErrorHandlers<E, string>>,
 ): UserFacingError {
-	if (error.type === "user") return error;
+	if (error.type === 'user') return error;
 
 	const message = (handlers as any)[error.name](error);
 
 	return {
 		...error,
-		type: "user",
+		type: 'user',
 		userMessage: message,
 	};
 }
-
-export type ErrorTypes<Factory extends ReturnType<typeof create>, Key extends keyof Factory> = ReturnType<Factory[Key]>;

tests/index.test.ts

@@ -1,46 +1,48 @@
-import { describe, expect, it } from "vitest";
-import * as justerror from "../src/index.js";
+import { describe, expect, it } from 'vitest';
+import * as justerror from '../src/index.js';
 
 const error = justerror.create({
 	InvalidArgumentError: {
-		code: "USER_001",
-		message: (args: { field: string; value?: unknown }) => `Invalid argument: ${args.field} = ${args.value}`,
-		userMessage: (args: { field: string; value?: unknown }) => `Invalid argument: ${args.field} = ${args.value}`,
+		code: 'USER_001',
+		message: (args: { field: string; value?: unknown }) =>
+			`Invalid argument: ${args.field} = ${args.value}`,
+		userMessage: (args: { field: string; value?: unknown }) =>
+			`Invalid argument: ${args.field} = ${args.value}`,
 	},
 	InternalError: {
-		code: "INTERNAL_001",
+		code: 'INTERNAL_001',
 		message: (args: { message: string }) => `Internal error: ${args.message}`,
 	},
 });
 
-describe("create", () => {
-	it("Should create the correct error", () => {
-		const e = error.InternalError({ message: "test" });
+describe('create', () => {
+	it('Should create the correct error', () => {
+		const e = error.InternalError({ message: 'test' });
 
-		expect(e.message).toBe("Internal error: test");
-		expect(e.code).toBe("INTERNAL_001");
-		expect(e.type).toBe("internal");
-		expect(e.name).toBe("InternalError");
+		expect(e.message).toBe('Internal error: test');
+		expect(e.code).toBe('INTERNAL_001');
+		expect(e.type).toBe('internal');
+		expect(e.name).toBe('InternalError');
 		expect(e.recoverable).toBe(false);
-		expect(e.config).toEqual({ message: "test" });
+		expect(e.config).toEqual({ message: 'test' });
 	});
 });
 
-describe("match", () => {
-	it("Should match the correct error", () => {
+describe('match', () => {
+	it('Should match the correct error', () => {
 		const fake = () => true;
 
 		// now can be either error
 		const e = fake()
-			? error.InternalError({ message: "test" })
-			: error.InvalidArgumentError({ field: "test", value: "test" });
+			? error.InternalError({ message: 'test' })
+			: error.InvalidArgumentError({ field: 'test', value: 'test' });
 
 		const result = justerror.match(e, {
 			InternalError: (e) => e.message,
 			InvalidArgumentError: (e) => e.message,
 		});
 
-		expect(result).toBe("Internal error: test");
+		expect(result).toBe('Internal error: test');
 
 		// error matching should be exhaustive if it isn't tsc will fail the next line
 
@@ -51,33 +53,33 @@ describe("match", () => {
 	});
 });
 
-describe("mapToUserFacingError", () => {
-	it("Should map the error to a user facing error", () => {
+describe('mapToUserFacingError', () => {
+	it('Should map the error to a user facing error', () => {
 		const fake = () => true;
 
 		// now can be either error
 		const e = fake()
-			? error.InternalError({ message: "test" })
-			: error.InvalidArgumentError({ field: "test", value: "test" });
+			? error.InternalError({ message: 'test' })
+			: error.InvalidArgumentError({ field: 'test', value: 'test' });
 
-        // only should have to handle internal errors
+		// only should have to handle internal errors
 		const result = justerror.mapToUserFacingError(e, {
-			InternalError: () => "There was an error serving your request",
+			InternalError: () => 'There was an error serving your request',
 		});
 
-		expect(result.userMessage).toBe("There was an error serving your request");
-		expect(result.message).toBe("Internal error: test");
-		expect(result.code).toBe("INTERNAL_001");
-		expect(result.type).toBe("user");
-		expect(result.name).toBe("InternalError");
+		expect(result.userMessage).toBe('There was an error serving your request');
+		expect(result.message).toBe('Internal error: test');
+		expect(result.code).toBe('INTERNAL_001');
+		expect(result.type).toBe('user');
+		expect(result.name).toBe('InternalError');
 		expect(result.recoverable).toBe(false);
-		expect(result.config).toEqual({ message: "test" });
+		expect(result.config).toEqual({ message: 'test' });
 
-        // users should only have to handle internal errors otherwise tsc will fail the next line
+		// users should only have to handle internal errors otherwise tsc will fail the next line
 
 		justerror.mapToUserFacingError(e, {
 			InternalError: (e) => e.message,
-            // @ts-expect-error Shouldn't need to handle user facing errors
+			// @ts-expect-error Shouldn't need to handle user facing errors
 			InvalidArgumentError: (e) => e.message,
 		});
 	});