Structuring Business Logic

Welcome back! In the last few lessons, you learned how to validate incoming data, centralize error responses, and log API requests. These are all important steps for building a reliable API. Now, let’s talk about another key part of making your code easy to manage: organizing your business logic.

Business logic is the part of your code that handles the main rules and operations of your application. For example, deciding how to create a new user, update user information, or delete a user. If you mix this logic directly into your API routes, your code can quickly become messy and hard to update.

By keeping business logic in its own place, you make your code easier to read, test, and reuse. This lesson will show you how to do that using a simple and practical approach.

A service is a file or module where you put all the main logic for working with your data. Instead of writing the logic for creating, updating, or deleting users directly in your API routes, you put it in a service. Then, your routes can just call these service functions.

Why is this helpful?

• It keeps your code organized and easy to read.
• You can reuse the same logic in different parts of your app.
• If you need to change how something works (like how users are created), you only have to update it in one place. This approach is especially helpful as your application grows. For example, if you later add validation, database calls, or caching to user creation, those changes would live entirely in the service—without touching your API route. This separation allows you to scale features without bloating route handlers.

Think of a service as a toolbox: instead of building a new tool every time you need to do something, you keep your tools in one place and use them whenever you need. This pattern also prepares your app for future upgrades, like switching from a mock database to a real one (e.g., PostgreSQL or MongoDB). You won’t need to rewrite all your routes—just adjust the service functions.

Let’s build a user service step by step. We’ll create a file called userService.ts and add functions for all the main user operations.

Here’s the complete code for our user service:

// src/lib/services/userService.ts
import { users, type User } from '@/lib/data';

// Get all users
export function getAllUsers(): User[] {
  return users;
}

// Get a user by ID
export function getUserById(id: number): User | undefined {
  return users.find(u => u.id === id);
}

// Create a new user
export function createUser(data: Omit<User, 'id'>): User {
  const newId = Math.max(...users.map(u => u.id), 0) + 1;
  const newUser: User = { id: newId, ...data };
  users.push(newUser);
  return newUser;
}

// Update an existing user
export function updateUser(id: number, updates: Omit<User, 'id'>): User | null {
  const idx = users.findIndex(u => u.id === id);
  if (idx === -1) return null;
  users[idx] = { id, ...updates };
  return users[idx];
}

// Delete a user
export function deleteUser(id: number): boolean {
  const idx = users.findIndex(u => u.id === id);
  if (idx === -1) return false;
  users.splice(idx, 1);
  return true;
}

Let’s break down what each function does:

• getAllUsers: Returns the full list of users.
• getUserById: Finds and returns a user with a specific id. If no user is found, it returns undefined.
• createUser: Takes user data (without an id), creates a new user with a unique id, adds it to the list, and returns the new user.
• updateUser: Finds a user by id and updates their information. If the user doesn’t exist, it returns null.
• deleteUser: Removes a user by id from the list. Returns true if successful, or false if the user wasn’t found.

Example Usage:

// Example: Creating a new user
const newUser = createUser({ name: "Charlie", email: "charlie@example.com" });
console.log(newUser);
// Output: { id: 3, name: "Charlie", email: "charlie@example.com" }

// Example: Getting all users
console.log(getAllUsers());
// Output: [
//   { id: 1, name: "Alice", email: "alice@example.com" },
//   { id: 2, name: "Bob", email: "bob@example.com" },
//   { id: 3, name: "Charlie", email: "charlie@example.com" }
// ]

By putting all these functions in one file, you can now use them anywhere in your app, making your code much cleaner and easier to manage.