@c15t/backend 1.8.0 → 2.0.0-rc.0

package/src/pkgs/results/__tests__/neverthrow-integration.test.ts

@@ -1,92 +0,0 @@
-// packages/backend/src/pkgs/errors/__tests__/neverthrow-integration.test.ts
-import { describe, expect, it } from 'vitest';
-import {
-	DoubleTieError,
-	ERROR_CODES,
-	fail,
-	failAsync,
-	ok,
-	tryCatchAsync,
-} from '../index';
-
-describe('DoubleTie - neverthrow integration', () => {
-	describe('ok function', () => {
-		it('creates a successful Result with the provided value', () => {
-			const value = { id: '123', name: 'Test User' };
-			const result = ok(value);
-
-			expect(result.isOk()).toBe(true);
-			expect(result._unsafeUnwrap()).toBe(value);
-		});
-	});
-
-	describe('fail function', () => {
-		it('creates a Result.err with a DoubleTieError', () => {
-			const result = fail('Resource not found', {
-				code: ERROR_CODES.NOT_FOUND,
-				status: 404,
-			});
-
-			expect(result.isErr()).toBe(true);
-
-			const error = result._unsafeUnwrapErr();
-			expect(error).toBeInstanceOf(DoubleTieError);
-			expect(error.message).toBe('Resource not found');
-			expect(error.code).toBe(ERROR_CODES.NOT_FOUND);
-		});
-
-		it('preserves the error details when mapping errors', () => {
-			const result = fail('Invalid data', {
-				code: ERROR_CODES.BAD_REQUEST,
-				status: 400,
-				meta: { field: 'email' },
-			});
-
-			const mapped = result.mapErr((err) => {
-				expect(err).toBeInstanceOf(DoubleTieError);
-				expect(err.meta.field).toBe('email');
-				return err.withMeta({ additionalInfo: 'mapped' });
-			});
-
-			expect(mapped.isErr()).toBe(true);
-			const error = mapped._unsafeUnwrapErr();
-			expect(error.meta).toEqual({
-				field: 'email',
-				additionalInfo: 'mapped',
-			});
-		});
-	});
-
-	describe('ResultAsync integration', () => {
-		it('properly handles async operations with DoubleTieErrors', async () => {
-			const asyncResult = failAsync('Network error', {
-				code: ERROR_CODES.NETWORK_ERROR,
-				status: 503,
-			});
-
-			const result = await asyncResult;
-
-			expect(result.isErr()).toBe(true);
-			const error = result._unsafeUnwrapErr();
-			expect(error).toBeInstanceOf(DoubleTieError);
-			expect(error.code).toBe(ERROR_CODES.NETWORK_ERROR);
-		});
-
-		it('catches errors in async operations with tryCatchAsync', async () => {
-			const asyncFn = async () => {
-				throw new Error('Something went wrong');
-			};
-
-			const resultAsync = await tryCatchAsync(
-				asyncFn,
-				ERROR_CODES.INTERNAL_SERVER_ERROR
-			);
-
-			expect(resultAsync.isErr()).toBe(true);
-			const error = resultAsync._unsafeUnwrapErr();
-			expect(error).toBeInstanceOf(DoubleTieError);
-			expect(error.code).toBe(ERROR_CODES.INTERNAL_SERVER_ERROR);
-			expect(error.cause).toBeInstanceOf(Error);
-		});
-	});
-});

package/src/pkgs/results/__tests__/recovery-utils.test.ts

@@ -1,140 +0,0 @@
-import { err, ok } from 'neverthrow';
-import { describe, expect, it } from 'vitest';
-import { DoubleTieError } from '../core/error-class';
-import { ERROR_CATEGORIES, ERROR_CODES } from '../core/error-codes';
-import {
-	withFallbackForCategory,
-	withFallbackForCodes,
-} from '../results/recovery-utils';
-
-describe('recovery-utils', () => {
-	describe('withFallbackForCodes', () => {
-		it('should return the original result if it is a success', () => {
-			const successValue = { id: '123', name: 'John' };
-			const successResult = ok(successValue);
-			const defaultValue = { id: '0', name: 'Default User' };
-
-			const result = withFallbackForCodes(
-				successResult,
-				[ERROR_CODES.NOT_FOUND],
-				defaultValue
-			);
-
-			expect(result.isOk()).toBe(true);
-			expect(result._unsafeUnwrap()).toBe(successValue);
-		});
-
-		it('should return a success result with the default value if the error code matches', () => {
-			const error = new DoubleTieError('User not found', {
-				code: ERROR_CODES.NOT_FOUND,
-				status: 404,
-			});
-			const failureResult = err(error);
-			const defaultValue = { id: '0', name: 'Default User' };
-
-			const result = withFallbackForCodes(
-				failureResult,
-				[ERROR_CODES.NOT_FOUND],
-				defaultValue
-			);
-
-			expect(result.isOk()).toBe(true);
-			expect(result._unsafeUnwrap()).toBe(defaultValue);
-		});
-
-		it('should return the original error result if the error code does not match', () => {
-			const error = new DoubleTieError('Server error', {
-				code: ERROR_CODES.INTERNAL_SERVER_ERROR,
-				status: 500,
-			});
-			const failureResult = err(error);
-			const defaultValue = { id: '0', name: 'Default User' };
-
-			const result = withFallbackForCodes(
-				failureResult,
-				[ERROR_CODES.NOT_FOUND],
-				defaultValue
-			);
-
-			expect(result.isErr()).toBe(true);
-			expect(result._unsafeUnwrapErr()).toBe(error);
-		});
-
-		it('should handle multiple error codes to recover from', () => {
-			const error = new DoubleTieError('Bad request', {
-				code: ERROR_CODES.BAD_REQUEST,
-				status: 400,
-			});
-			const failureResult = err(error);
-			const defaultValue = { success: false };
-
-			const result = withFallbackForCodes(
-				failureResult,
-				[
-					ERROR_CODES.NOT_FOUND,
-					ERROR_CODES.BAD_REQUEST,
-					ERROR_CODES.UNAUTHORIZED,
-				],
-				defaultValue
-			);
-
-			expect(result.isOk()).toBe(true);
-			expect(result._unsafeUnwrap()).toBe(defaultValue);
-		});
-	});
-
-	describe('withFallbackForCategory', () => {
-		it('should return the original result if it is a success', () => {
-			const successValue = { data: 'some data' };
-			const successResult = ok(successValue);
-			const defaultValue = { data: 'default data' };
-
-			const result = withFallbackForCategory(
-				successResult,
-				ERROR_CATEGORIES.NETWORK,
-				defaultValue
-			);
-
-			expect(result.isOk()).toBe(true);
-			expect(result._unsafeUnwrap()).toBe(successValue);
-		});
-
-		it('should return a success result with the default value if the error category matches', () => {
-			const error = new DoubleTieError('Network error', {
-				code: ERROR_CODES.NETWORK_ERROR,
-				status: 503,
-				category: ERROR_CATEGORIES.NETWORK,
-			});
-			const failureResult = err(error);
-			const defaultValue = { data: 'cached data', fromCache: true };
-
-			const result = withFallbackForCategory(
-				failureResult,
-				ERROR_CATEGORIES.NETWORK,
-				defaultValue
-			);
-
-			expect(result.isOk()).toBe(true);
-			expect(result._unsafeUnwrap()).toBe(defaultValue);
-		});
-
-		it('should return the original error result if the error category does not match', () => {
-			const error = new DoubleTieError('Authentication failed', {
-				code: ERROR_CODES.UNAUTHORIZED,
-				status: 401,
-				category: ERROR_CATEGORIES.AUTHORIZATION,
-			});
-			const failureResult = err(error);
-			const defaultValue = { data: 'default data' };
-
-			const result = withFallbackForCategory(
-				failureResult,
-				ERROR_CATEGORIES.NETWORK,
-				defaultValue
-			);
-
-			expect(result.isErr()).toBe(true);
-			expect(result._unsafeUnwrapErr()).toBe(error);
-		});
-	});
-});

package/src/pkgs/results/__tests__/result-helpers.test.ts

@@ -1,206 +0,0 @@
-import { ResultAsync } from 'neverthrow';
-import { describe, expect, it, vi } from 'vitest';
-import { DoubleTieError } from '../core/error-class';
-import { ERROR_CODES } from '../core/error-codes';
-import {
-	fail,
-	failAsync,
-	ok,
-	tryCatch,
-	tryCatchAsync,
-} from '../results/result-helpers';
-
-describe('result-helpers', () => {
-	describe('ok', () => {
-		it('should create a successful result containing the provided value', () => {
-			const value = { name: 'Test User' };
-			const result = ok(value);
-
-			expect(result.isOk()).toBe(true);
-			expect(result.isErr()).toBe(false);
-
-			// Extract the value and verify it's the same object
-			expect(result._unsafeUnwrap()).toBe(value);
-		});
-	});
-
-	describe('fail', () => {
-		it('should create a failure result with a DoubleTieError', () => {
-			const errorMessage = 'Failed to find user';
-			const errorOptions = {
-				code: ERROR_CODES.NOT_FOUND,
-				status: 404,
-				meta: { userId: '123' },
-			};
-
-			const result = fail(errorMessage, errorOptions);
-
-			expect(result.isOk()).toBe(false);
-			expect(result.isErr()).toBe(true);
-
-			// Extract the error and verify properties
-			const error = result._unsafeUnwrapErr();
-			expect(error).toBeInstanceOf(DoubleTieError);
-			expect(error.message).toBe(errorMessage);
-			expect(error.code).toBe(ERROR_CODES.NOT_FOUND);
-			expect(error.statusCode).toBe(404);
-			expect(error.meta).toEqual({ userId: '123' });
-		});
-	});
-
-	describe('failAsync', () => {
-		it('should create an async failure result with a DoubleTieError', async () => {
-			const errorMessage = 'Failed to connect to database';
-			const errorOptions = {
-				code: ERROR_CODES.DATABASE_CONNECTION_ERROR,
-				status: 500,
-				meta: { connectionId: 'db1' },
-			};
-
-			const result = failAsync(errorMessage, errorOptions);
-
-			expect(result).toBeInstanceOf(ResultAsync);
-
-			// Await and verify the result
-			const awaitedResult = await result;
-			expect(awaitedResult.isOk()).toBe(false);
-			expect(awaitedResult.isErr()).toBe(true);
-
-			// Extract the error and verify properties
-			const error = awaitedResult._unsafeUnwrapErr();
-			expect(error).toBeInstanceOf(DoubleTieError);
-			expect(error.message).toBe(errorMessage);
-			expect(error.code).toBe(ERROR_CODES.DATABASE_CONNECTION_ERROR);
-			expect(error.statusCode).toBe(500);
-			expect(error.meta).toEqual({ connectionId: 'db1' });
-		});
-	});
-
-	describe('tryCatch', () => {
-		it('should return a successful result when the function succeeds', () => {
-			const fn = () => 'success';
-			const result = tryCatch(fn);
-
-			expect(result.isOk()).toBe(true);
-			expect(result._unsafeUnwrap()).toBe('success');
-		});
-
-		it('should return a failure result when the function throws', () => {
-			const fn = () => {
-				throw new Error('Something went wrong');
-			};
-			const result = tryCatch(fn);
-
-			expect(result.isErr()).toBe(true);
-			const error = result._unsafeUnwrapErr();
-			expect(error).toBeInstanceOf(DoubleTieError);
-			expect(error.message).toBe('Something went wrong');
-			expect(error.code).toBe(ERROR_CODES.UNKNOWN_ERROR); // Default error code
-		});
-
-		it('should use the provided error code when the function throws', () => {
-			const fn = () => {
-				throw new Error('Invalid data');
-			};
-			const result = tryCatch(fn, ERROR_CODES.BAD_REQUEST);
-
-			expect(result.isErr()).toBe(true);
-			const error = result._unsafeUnwrapErr();
-			expect(error).toBeInstanceOf(DoubleTieError);
-			expect(error.message).toBe('Invalid data');
-			expect(error.code).toBe(ERROR_CODES.BAD_REQUEST);
-		});
-
-		it('should use the provided error mapper when the function throws', () => {
-			const originalError = new Error('Original error');
-			const fn = () => {
-				throw originalError;
-			};
-
-			const customError = new DoubleTieError('Mapped error', {
-				code: ERROR_CODES.INVALID_REQUEST,
-				status: 400,
-			});
-
-			const errorMapper = vi.fn().mockReturnValue(customError);
-
-			const result = tryCatch(fn, ERROR_CODES.UNKNOWN_ERROR, errorMapper);
-
-			expect(result.isErr()).toBe(true);
-			expect(errorMapper).toHaveBeenCalledWith(originalError);
-			expect(result._unsafeUnwrapErr()).toBe(customError);
-		});
-	});
-
-	describe('tryCatchAsync', () => {
-		it('should return a successful result when the async function succeeds', async () => {
-			const fn = async () => 'async success';
-			const result = tryCatchAsync(fn);
-
-			expect(result).toBeInstanceOf(ResultAsync);
-
-			const finalResult = await result;
-			expect(finalResult.isOk()).toBe(true);
-			expect(finalResult._unsafeUnwrap()).toBe('async success');
-		});
-
-		it('should return a failure result when the async function throws', async () => {
-			const fn = async () => {
-				throw new Error('Async error');
-			};
-
-			const result = tryCatchAsync(fn);
-			expect(result).toBeInstanceOf(ResultAsync);
-
-			const finalResult = await result;
-
-			expect(finalResult.isErr()).toBe(true);
-			const error = finalResult._unsafeUnwrapErr();
-			expect(error).toBeInstanceOf(DoubleTieError);
-			expect(error.message).toBe('Async error');
-			expect(error.code).toBe(ERROR_CODES.UNKNOWN_ERROR); // Default error code
-		});
-
-		it('should use the provided error code when the async function throws', async () => {
-			const fn = async () => {
-				throw new Error('Network failure');
-			};
-
-			const resultPromise = tryCatchAsync(fn, ERROR_CODES.NETWORK_ERROR);
-			const result = await resultPromise;
-			const finalResult = await result;
-
-			expect(finalResult.isErr()).toBe(true);
-			const error = finalResult._unsafeUnwrapErr();
-			expect(error).toBeInstanceOf(DoubleTieError);
-			expect(error.message).toBe('Network failure');
-			expect(error.code).toBe(ERROR_CODES.NETWORK_ERROR);
-		});
-
-		it('should use the provided error mapper when the async function throws', async () => {
-			const originalError = new Error('Original async error');
-			const fn = async () => {
-				throw originalError;
-			};
-
-			const customError = new DoubleTieError('Mapped async error', {
-				code: ERROR_CODES.INVALID_REQUEST,
-				status: 400,
-			});
-
-			const errorMapper = vi.fn().mockReturnValue(customError);
-
-			const resultPromise = tryCatchAsync(
-				fn,
-				ERROR_CODES.UNKNOWN_ERROR,
-				errorMapper
-			);
-			const result = await resultPromise;
-			const finalResult = await result;
-
-			expect(finalResult.isErr()).toBe(true);
-			expect(errorMapper).toHaveBeenCalledWith(originalError);
-			expect(finalResult._unsafeUnwrapErr()).toBe(customError);
-		});
-	});
-});