# Exercise: Pet Listings Data Layer

Move the Maple Street Pet Adoption Center's API from an array to MongoDB by finishing its data layer with the official driver, from the paged and filtered list to the right status for a bad id and a missing pet and the indexes the list needs, and let the tests check every request on a throwaway MongoDB.

Journeyman · MongoDB · Node.js · Updated November 19, 2026

By Gregor Dzierzon

The Maple Street Pet Adoption Center's API from *Exercise: Pet API Warm-Up* works, but every restart forgets the pets. Its routes, its app and its server are now ready for MongoDB; only the data layer is left. You'll write it with the official driver: the pet list with its filters and pages, one pet by its id, adding and changing a pet, telling a real id from text that can't be one, and the two indexes the collection needs. Tests send every request to the API on a throwaway MongoDB and check each answer.

## Get the exercise code

Open this lesson's GitHub repository, [github.com/ask-codey/exercise-mongodb-pet-listings-data-layer](https://github.com/ask-codey/exercise-mongodb-pet-listings-data-layer), also linked from the **Exercise** box beside the lesson. Clone it into your `mongodb-course` folder. In VS Code, open the `mongodb-course` folder, open the terminal with **Terminal > New Terminal**, and type:

```bash
git clone https://github.com/ask-codey/exercise-mongodb-pet-listings-data-layer.git
```

Git makes a folder, `exercise-mongodb-pet-listings-data-layer`, with the exercise code inside. Open that folder in VS Code (**File > Open Folder**), open its terminal, and install the packages:

```bash
npm install
```

Then copy `.env.example` to a new file named `.env` (`Copy-Item .env.example .env` in PowerShell, or `cp .env.example .env` on a Mac), as in *Connecting from Node: MongoClient and the Connection String*.

The folder holds:

- `data/pets.js`: the data layer, with six functions for you to finish.
- `routes/pets.js`, `app.js`, `problems.js` and `server.js`: the API, ready to use. The routes call only the data layer.
- `pets.http`: requests to try, with the answers to expect.
- `test/`: the tests, the helper that starts their throwaway MongoDB, and the center's 12 pets in `test/seed/pets.json`. You don't need to change any of them.

## What to do

Open `data/pets.js`. `useDatabase`, `toPet` and `toListing` are ready to use. Each of the six functions after them has a comment that says exactly what it should give back, with examples, and a placeholder that stops with an error for now:

```javascript
/*
 * 3. Give back the whole pet whose id is id, made with toPet, or null when no pet has it.
 *    id is text that isPetId says yes to, such as "6740c0000000000000000002": the routes check it first.
 *
 *    getPet("6740c0000000000000000002")  -> { id: "6740c0000000000000000002", name: "Mochi", species: "cat", age: 2,
 *                                            traits: ["calm", "indoor only"], status: "available" }
 *    getPet("6740c0000000000000000099")  -> null
 */
export async function getPet(id) {
  // For now it stops with an error, so GET /pets/:id answers 500.
  throw new Error("getPet isn't built yet.");
}
```

Replace each placeholder with your own code:

1. **`isPetId(id)`**: `true` for text that can be an ObjectId, such as `"6740c0000000000000000002"`, and `false` for text that can't, such as `"2"`. The routes answer 400 when it says no.
2. **`listPets({ species, goodWithKids, page })`**: one page of 5 pets, sorted by name, made with `toListing`. Only one species when `species` isn't `undefined`; only pets whose traits include `"good with kids"` when `goodWithKids` is true. Page 1 of all 12 pets is Bean, Biscuit, Clover, Hazel and Juniper; page 3 is Rocket and Ziggy.
3. **`getPet(id)`**: the whole pet, made with `toPet`, or `null` when no pet has the id. The route answers 404 for `null`.
4. **`addPet(pet)`**: saves `{ name, species, age, traits }` with the status `"available"`, and gives the pet back with its new id.
5. **`updatePet(id, changes)`**: sets the fields in `changes`, such as `{ status: "adopted" }`, and gives back the changed pet, or `null` when no pet has the id.
6. **`createIndexes()`**: makes two indexes, `{ species: 1, name: 1 }` for the list, and `{ name: 1 }` with `unique: true`, so a second Biscuit answers 409.

To see the API run against your own MongoDB, load the 12 pets into `maple_street` first: start `mongosh` in the exercise folder, type `use maple_street`, then `load("test/seed/load-into-mongosh.js")`. Then `npm start`, and try the requests in `pets.http`.

## Check your work

Run the tests from the exercise folder:

```bash
npm test
```

At first all 17 tests fail. That's expected: each function you finish turns its tests green. When a test fails, its message says what it sent and what came back, for example *GET /pets should answer 200, but it answered 500 with {"status":500,"title":"Internal Server Error","detail":"Something went wrong on our side."}.*

The tests start their own throwaway MongoDB and put the 12 pets back before every test, so they never change your databases. If you installed MongoDB in *Setup: MongoDB, mongosh and Compass*, they use it.

## Hints

- **Start with `isPetId`.** Tests 1, 11 and 15 need only it, and *When the Database Says No: Bad ids, Duplicates and Not Found* shows the driver call that answers it without asking the database.
- **Build the list's filter piece by piece.** Start with an empty object and add a field only when the address asked for it, as *A Data Layer: One File That Talks to the Database* does. Then sort, skip and limit before `toArray()`, as in *Sorting and Paging: sort, limit and skip*.
- **Turn the id into an ObjectId before you ask.** Text never equals an ObjectId: *From mongosh to the Driver: find, insertOne and toArray* shows the difference.
- **`insertOne` doesn't give back the pet.** It gives back the new `_id`. Put it with the fields you saved before you hand the document to `toPet`.
- **Give back the pet as it is after the change.** *Upserts and Replacing a Whole Document* has the call that changes a document and hands it back, and the option that says "after".
- **Indexes are the same calls as in mongosh.** *Compound Indexes and the Order of Fields* and *Unique and Text Indexes* show both.

## When you're done

Every test is green, and `npm test` prints:

```text
✔ 1) isPetId("6740c0000000000000000002") gives true, and isPetId("2") gives false (1058.0516ms)
✔ 2) listPets({ species: "cat", goodWithKids: true, page: 1 }) gives Juniper, Olive and Pickles (13.5434ms)
✔ 3) listPets gives listings: Bean is { id, name, species, age, status }, with his id as text (10.9343ms)
✔ 4) GET /pets answers 200 with the first 5 pets in name order, Bean to Juniper (26.5574ms)
✔ 5) GET /pets?page=3 answers 200 with Rocket and Ziggy, the last 2 pets (16.1763ms)
✔ 6) GET /pets?species=cat answers 200 with the 5 cats, Juniper to Ziggy (14.2422ms)
✔ 7) GET /pets?species=dog&goodWithKids=true answers 200 with Bean, Biscuit and Maple (13.6256ms)
✔ 8) GET /pets?species=dog&page=2 answers 200 with an empty list: the 5 dogs fit on page 1 (14.2736ms)
✔ 9) GET /pets/6740c0000000000000000002 answers 200 with Mochi, whole (14.2761ms)
✔ 10) GET /pets/6740c0000000000000000099 answers 404 with "There's no pet 6740c0000000000000000099." (12.856ms)
✔ 11) GET /pets/2 answers 400 with "2 isn't a pet id." (11.3938ms)
✔ 12) POST /pets with Waffles answers 201 with Waffles, a new id and the status "available", and saves him (21.2035ms)
✔ 13) PATCH /pets/6740c0000000000000000006 with { status: "adopted" } answers 200 with Rocket adopted, and saves it (13.8944ms)
✔ 14) PATCH /pets/6740c0000000000000000099 answers 404 with "There's no pet 6740c0000000000000000099." (11.9422ms)
✔ 15) PATCH /pets/not-a-pet answers 400 with "not-a-pet isn't a pet id." (11.587ms)
✔ 16) createIndexes() adds the index { species: 1, name: 1 }, and the cats' list query uses it (39.1839ms)
✔ 17) After createIndexes(), POST /pets with a second Biscuit answers 409 with "Another pet already has that name." (46.2675ms)
ℹ tests 17
ℹ suites 0
ℹ pass 17
ℹ fail 0
ℹ cancelled 0
ℹ skipped 0
ℹ todo 0
ℹ duration_ms 1834.7444
```

The times in parentheses will be different on your computer. Now open `routes/pets.js` and search it for `ObjectId`, `collection` or `mongodb`. You won't find one: if the center moved to another database tomorrow, which file would change, and which would stay exactly as it is?

## Submit your exercise

The exercise is how you finish this lesson. When your work is done, put it on GitHub in a repo of your own, then submit that repo's address here.

1. On GitHub, click **+**, then **New repository**. Name it (for example `exercise-mongodb-pet-listings-data-layer`), choose **Public**, and click **Create repository**. Leave out the README: your folder already has one.
2. In VS Code's terminal, in your exercise folder, send your work to your new repo. Point your copy at your own repo, then commit and push:

   ```bash
   git remote set-url origin https://github.com/your-name/exercise-mongodb-pet-listings-data-layer.git
   git add .
   git commit -m "My solution"
   git push -u origin main
   ```

3. Paste your repo's address, such as `https://github.com/your-name/exercise-mongodb-pet-listings-data-layer`, into **Submit your exercise** on this page. The site checks that the repo is public and holds your commits, and then the lesson is complete.

Changed something after you submitted? Push it, and submit again: your latest submission is the one that counts.

## So what

A data layer behind real routes, the right answer for every bad request, indexes for the questions the app asks, and tests that prove it on a throwaway database: that's the database half of a real API, and it's yours now.

## Key terms

- [MongoDB Driver](https://www.ask-codey.com/glossary/mongodb-driver)
- [Repository Pattern](https://www.ask-codey.com/glossary/repository-pattern)
- [Cursor](https://www.ask-codey.com/glossary/cursor-mongodb)
- [mongodb-memory-server](https://www.ask-codey.com/glossary/mongodb-memory-server)
- [Compound Index](https://www.ask-codey.com/glossary/compound-index)

## Related

- [A Data Layer: One File That Talks to the Database](https://www.ask-codey.com/lessons/mongodb-driver-a-data-layer)
- [When the Database Says No: Bad ids, Duplicates and Not Found](https://www.ask-codey.com/lessons/mongodb-driver-when-the-database-says-no)
- [Testing the Data Layer with mongodb-memory-server](https://www.ask-codey.com/lessons/mongodb-driver-testing-with-mongodb-memory-server)

Source: https://www.ask-codey.com/lessons/exercise-mongodb-pet-listings-data-layer
