Implement CRUD REST APIs

Problem

You need to implement a simplified REST API handler that processes HTTP requests for managing user resources. Your system should support standard CRUD operations through appropriate HTTP methods and maintain an in-memory data store.

The API handler receives a sequence of operations, where each operation consists of an HTTP method, a path, and optional request data. You must process these operations in order and return the result of the final operation.

Your implementation should handle the following endpoints:

• POST /users - Create a new user with auto-incremented ID
• GET /users - Retrieve all users as an array
• GET /users/{id} - Retrieve a specific user by ID
• PUT /users/{id} - Update an existing user (merge with existing data)
• DELETE /users/{id} - Remove a user by ID

Requirements

1. Implement an in-memory storage system for user data
2. Auto-increment user IDs starting from 1
3. POST requests should create new users and return the created user object
4. GET requests should return individual users, all users, or null if not found
5. PUT requests should update existing user fields (partial updates allowed)
6. DELETE requests should remove users and return true on success
7. Return null when attempting to access non-existent resources
8. Process all operations sequentially and return the result of the last operation

Constraints

• Number of operations: 1 ≤ n ≤ 1000
• User IDs are positive integers
• User data contains at least "name" and "email" fields
• All inputs are valid (no malformed requests)
• Time complexity should be O(1) for individual operations
• Space complexity: O(n) where n is the number of users

Examples

Example 1:

Input: [ ("POST", "/users", {"name": "Alice", "email": "alice@example.com"}), ("GET", "/users/1", {}) ] Output: {"id": 1, "name": "Alice", "email": "alice@example.com"} Explanation: First operation creates a user with ID 1. Second operation retrieves that user, which is returned as the final result.

Example 2:

Input: [ ("POST", "/users", {"name": "Bob", "email": "bob@test.com"}), ("PUT", "/users/1", {"email": "bob.updated@test.com"}), ("GET", "/users/1", {}) ] Output: {"id": 1, "name": "Bob", "email": "bob.updated@test.com"} Explanation: Create user, update email field, then retrieve the updated user.

Example 3:

Input: [ ("POST", "/users", {"name": "Alice", "email": "alice@test.com"}), ("POST", "/users", {"name": "Bob", "email": "bob@test.com"}), ("GET", "/users", {}) ] Output: [{"id": 1, "name": "Alice", "email": "alice@test.com"}, {"id": 2, "name": "Bob", "email": "bob@test.com"}] Explanation: Create two users, then retrieve all users as an array.

Hint 1: Data Structure Choice Use a dictionary to store users with their IDs as keys. This provides O(1) access time for lookups, updates, and deletions. Keep track of the next available ID separately.

Hint 2: Parsing the Path For paths like "/users/1", you need to extract the ID portion. Consider splitting the path by "/" and checking the length to determine if it's a collection endpoint or a specific resource endpoint.

Hint 3: Handling Different HTTP Methods Create separate helper functions for each HTTP method (POST, GET, PUT, DELETE). This makes your code more maintainable and easier to test. Each method should handle both the logic and the appropriate return value.

Full Solution `` Explanation:

The solution implements a simple REST API handler with the following components:

1. Data Storage: We use a dictionary users to store user objects with their IDs as keys, providing O(1) access time. A counter next_id tracks the next available ID.

2. Request Parsing: For each operation, we parse the path to determine whether it's targeting the collection ("/users") or a specific resource ("/users/{id}").

3. HTTP Method Handlers:

   • POST /users: Creates a new user by combining the auto-generated ID with the provided data, stores it, and increments the ID counter.
   • GET /users: Returns all users as a list by calling list(users.values()).
   • GET /users/{id}: Looks up a specific user by ID using dict.get(), returning None if not found.
   • PUT /users/{id}: Updates an existing user by merging new data with existing data using dict.update().
   • DELETE /users/{id}: Removes a user from storage if it exists.

4. Return Value: After processing each operation, we store its result and return the result of the final operation.

Time Complexity: O(n × m) where n is the number of operations and m is the average number of users (for GET /users). Individual operations on specific users are O(1).

Space Complexity: O(u) where u is the number of users stored in the system.

This implementation provides a clean, maintainable foundation for a REST API system that can be easily extended with additional endpoints or validation logic.