Search for a command to run...
Software developer documenting my journey through web and mobile development. I share what I learn, build, and struggle with—from React to SwiftUI, architecture decisions to deployment challenges. Not an expert, just passionate about coding and learning in public. Join me as I navigate the tech landscape one commit at a time.
No comments yet. Be the first to comment.
The Problem Every Developer Faces with AI Coding Assistants You've probably experienced this frustration: you ask Claude, Cursor, or any AI coding assistant to write a function, and it confidently generates code that looks perfect at first glance. Bu...
The Backstory So there I was, staring at my shiny new Passbolt installation on Ubuntu 24.04, when that familiar dread crept in: "What happens when (not if) something goes wrong?" After one too many "I'll set up backups tomorrow" moments, I finally de...
TL;DR The custom Reactotron transport for react-native-logs improves logging by handling various message types, adding metadata, and allowing custom prefixes, making your logs more informative and easier to manage. The Backstory Logging is a crucial ...
TL;DR Add parallel: N to your GitLab CI job and pass --shard=${CI_NODE_INDEX}/${CI_NODE_TOTAL} to Playwright to slash your test execution time and keep your team shipping fast. The Backstory Last week, our test suite execution time crossed the dreade...
Error messages are often the first interaction users have with your support system. When they're cryptic, technical, or in the wrong language, they create confusion rather than clarity. That's why I built the Appwrite Exceptions Translator - a lightw...
In this tutorial, we'll explore how to handle errors in a TypeScript application using the neverthrow library, focusing on a practical e-commerce scenario. Specifically, we'll write a service to check product availability and place an order, handling potential errors in a type-safe manner similar to Rust's error handling.
Let's set up our environment with TypeScript and the necessary domain-driven design elements. First, we'll define the models and interfaces that represent the domain model, and import the necessary packages like neverthrow and luxon for date handling.
import { Product } from '@domain/product/Product';
import { InventoryRepositoryInterface } from '@domain/inventory/InventoryRepositoryInterface';
import { Order, OrderDetails } from '@domain/order/Order';
import { OrderRepositoryInterface } from '@domain/order/OrderRepositoryInterface';
import { DateTime } from 'luxon';
import { err, ok, Result } from 'neverthrow';
import { makeTaggedUnion, none, MemberType } from 'safety-match';
Next, we define the input for our service and the types of errors that could occur:
export interface PlaceOrderInput {
productId: string;
quantity: number;
orderDate: DateTime;
}
export const PlaceOrderError = makeTaggedUnion({
ProductNotFound: none,
InsufficientStock: none,
OrderSaveFailed: none,
});
export type PlaceOrderError = MemberType<typeof PlaceOrderError>;
In this setup, PlaceOrderInput specifies the information required to place an order, and PlaceOrderError defines possible error scenarios.
Now, let's implement the service. We'll use the neverthrow library to manage different outcomes of operations explicitly, ensuring that every function call that might fail is clear in its intent and handling.
export class OrderService {
constructor(
private readonly inventoryRepository: InventoryRepositoryInterface,
private readonly orderRepository: OrderRepositoryInterface
) {}
async placeOrder(input: PlaceOrderInput): Promise<Result<Order, PlaceOrderError>> {
// Check product availability
const stockLevel = await this.inventoryRepository.getStockLevel(input.productId);
if (stockLevel === null) return err(PlaceOrderError.ProductNotFound);
if (stockLevel < input.quantity) return err(PlaceOrderError.InsufficientStock);
// Create and save the order
const orderDetails: OrderDetails = {
productId: input.productId,
quantity: input.quantity,
orderDate: input.orderDate
};
const order = new Order(orderDetails);
const saveResult = await this.orderRepository.saveOrder(order);
if (!saveResult) return err(PlaceOrderError.OrderSaveFailed);
return ok(order);
}
}
Check Product Availability: The service first checks if the product is available and in sufficient quantity. It returns early with an appropriate error if not.
Place the Order: If the product is available, the service creates an order. It attempts to save this order using the order repository.
Error Handling: If saving the order fails, an error is returned. Otherwise, the successfully placed order is returned.
Using neverthrow provides several advantages:
Explicit Error Handling: Each function's outcome, whether success or failure, is clearly defined through its return type.
Type Safety: Errors are part of the type system, forcing developers to handle them explicitly, reducing the chance of unhandled exceptions.
Improved Maintainability: Having a clear and predictable error handling strategy makes the code easier to maintain and debug.
This method aligns with modern best practices in TypeScript application development, where enhancing clarity, type safety, and robustness are key priorities. By structuring your error handling in this detailed manner, your codebase becomes more predictable and less prone to runtime errors.
To conclude, while this tutorial showcases an approach to structured and type-safe error handling in TypeScript using the neverthrow library, I must credit the initial inspiration to my colleague, Killian. His insights and innovative ideas significantly influenced the development of these error handling techniques, demonstrating the power of collaboration in software development.