todos.js

Overview

The todos.js file implements a simple in-memory API to manage a list of "to-do" items. It provides asynchronous functions to retrieve and add todo items, simulating network delay and occasional failures to mimic real-world API behavior. The main exported function acts as an HTTP request handler supporting GET and POST methods to fetch all todos or add a new todo item, respectively.

This file is likely part of the backend or API layer of a to-do list application, serving as a lightweight, mock API for managing todo data without persistent storage.

Detailed Explanation

Variables

• todos:
  An array that holds the current list of todo objects in memory. Each todo is expected to have at least a text property.

• delay:
  A utility function that returns a promise resolved after 1 second, simulating network latency for asynchronous operations.

const delay = () => new Promise(res => setTimeout(() => res(), 1000));

Functions

async function getTodos()

Fetches the current list of todos, sorted alphabetically by their text property.

• Parameters: None

• Returns: Promise<Array<Object>> — resolves to an array of todo objects sorted by text.

• Behavior: Waits for 1 second (simulated delay), then returns a sorted copy of the todos array.

Usage example:

const todos = await getTodos();
console.log(todos);

async function addTodo(todo)

Adds a new todo item to the list.

• Parameters:
  todo (Object) — an object representing a todo item. Expected to have a text property (string).

• Returns:
  Promise<Object> — resolves to the added todo object after formatting.

• Throws:
  Throws an error if:

  • The todo.text property is missing or empty.

  • A random failure occurs (20% chance) to simulate API error, causing UI regression testing scenarios.

• Behavior:

  1. Waits for 1 second (simulated delay).

  2. Validates the todo object.

  3. Capitalizes the first character of the text property.

  4. Adds the new todo to the todos array (immutable update).

  5. Returns the newly added todo.

Usage example:

try {
  const newTodo = await addTodo({ text: 'buy groceries' });
  console.log(newTodo); // { text: 'Buy groceries' }
} catch (err) {
  console.error(err.message);
}

Exported default function: async function api(req, res)

HTTP request handler function that routes incoming API requests based on HTTP method:

• Parameters:

  • req (Request Object) — incoming HTTP request, must have:

    • method property (string), e.g., "GET", "POST".

    • body property (string) for POST request containing JSON.

  • res (Response Object) — HTTP response object, must support:

    • json(data) method to send JSON response.

    • status(code) method to set HTTP status code.

• Behavior:

  • For POST requests:

    • Parses the JSON body.

    • Calls addTodo with the parsed object.

    • Returns the added todo in JSON format.

  • For other methods (assumed GET):

    • Calls getTodos.

    • Returns the sorted todos array in JSON format.

  • Catches any errors and returns a 500 status with error message.

Usage example (pseudo-code):

// Express-like usage example
app.all('/api/todos', async (req, res) => {
  await api(req, res);
});

Implementation Details and Algorithms

• Simulated Latency:
  The delay function introduces a fixed 1-second delay in getTodos and addTodo to simulate network or processing latency. This helps in testing asynchronous UI behavior.

• Sorting Algorithm:
  The todos are sorted alphabetically by their text property using the standard JavaScript array .sort() method with a simple comparator (a.text < b.text ? -1 : 1).

• Random Failure Injection:
  The addTodo function randomly fails 20% of the time or if the input todo is invalid. This introduces non-deterministic error scenarios to test UI robustness and error handling.

• Immutable Updates:
  When adding a todo, the todos array is recreated (todos = [...todos, todo]) to avoid direct mutation, which is beneficial for predictable state management.

• Capitalization:
  The first letter of the todo text is capitalized before storage to enforce a consistent format.

Interaction with Other System Components

• Frontend/UI Layer:
  This file acts as an API backend for a client-side app that manages todos. The simulated delay and failures help test UI responsiveness and error recovery.

• API Layer:
  The exported api function is designed to integrate with a server or serverless function environment that routes HTTP requests.

• Data Persistence Layer:
  This file currently uses in-memory storage (todos array), so it does not interact with any database or file system. For production, this would likely be replaced or extended to interact with a database.

Visual Diagram

flowchart TD
  A[api(req, res)] -->|POST| B[addTodo(todo)]
  A -->|GET| C[getTodos()]
  B --> D[delay() - 1 sec]
  C --> D
  B --> E{Random Failure?}
  E -- No --> F[Capitalize text]
  F --> G[Add todo to todos array]
  E -- Yes --> H[Throw Error]
  A --> I{Try/Catch}
  I -->|Success| J[res.json(data)]
  I -->|Error| K[res.status(500).json({error})]

Summary

• Provides asynchronous API for managing todos with get and add functionalities.

• Simulates latency and failure to mimic real-world API conditions.

• Uses in-memory data store with immutable updates.

• Exposes a single HTTP handler function supporting GET (list todos) and POST (add todo).

• Designed for integration with frontend applications and server environments.

• Useful for development, testing, and prototyping todo management features.

If extending this file, consider adding:

• Persistent storage (database).

• Additional todo properties (e.g., completed status).

• More robust validation.

• Support for other HTTP methods (PUT, DELETE).

• Logging for errors and requests.