# Retrieving All Books - Implementation

## 1 - Route Name

`GET /api/v1/books`

For the route version prefix, we can do the following.

*File: src/server.js*

```javascript
const getRouter = require('./routes')
const router = getRouter()
app.use('/api/v1', router) // add the prefix '/api/v1' to all our URIs
```

We will then proceed to include all of the book routes.

*File: src/routes/index.js*

```javascript
const express = require('express')
const router = express.Router()

const bookRoutes = require('./book.route') // all our book routes

function getRouter() {
  router.use('/books', bookRoutes) // we prefix it here as 'books'
  
  return router
}

module.exports = getRouter
```

Here, we specify and create a controller method, let's call it `getAllBooks`.

*File: src/routes/book.route.js*

```javascript
const express = require('express')
const router = express.Router()

const {
  getAllBooks
} = require('../controllers/book')

router.get('/', getAllBooks)

module.exports = router
```

This is where we will put the service layer and the response output.

*File: src/controllers/book/getAllBooks.js*

```javascript
const catchException = require('../utils/catchExceptions')

const getAllBooks = catchException(async (req, res, next) => {
  // our code goes here...
})

module.exports = getAllBooks
```

Now that all the setup is done, we can proceed with the other layers in our application.

## 2 - Input Request

None.

## 3 - Middleware

None.

## 4 - Validation

None.

## 5 - Domain

The domain layer is quite simple, we want to first create a model that satisfies all our business requirements from the user stories we have in the previous chapter. We are going to create the book model as follows.

*File: src/domain/models/book.model.js*

```javascript
const mongoose = require('mongoose')
const Schema = mongoose.Schema

const BookSchema = new mongoose.Schema({
  userId: {
    type: Schema.Types.ObjectId,
    ref: 'user'
  },
  title: {
    type: String,
    required: true
  },
  description: {
    type: String
  },
  price: {
    type: Number,
    required: true
  },
  author: {
    type: String
  },
  datePublished: {
    type: String
  },
  createdAt: {
    type: Date,
    default: Date.now
  }
})

module.exports = mongoose.model('book', BookSchema)
```

Then, we will wrap it in a repository. Remember why we are using repositories, we want to be able to create an abstraction layer between the concrete implementation of the model and our service layer so that we may swap out database types any time we want. In our case, we are using MongoDB. If for some reason in the future we decide to use something like MySQL, PostgresQL, or OracleDB, it would be much easier to swap out.

*File: src/domain/repositories/book.repository.js*

```javascript
const Model = require('../models/book.model')

// Retrieve - all
const getAll = async () => {
  return await Model.find({})
}

module.exports = {
  getAll
}
```

And finally, our service layer.

*File src/domain/services/book.service.js*

```javascript
const bookRepository = require('../repositories/book.repository')
const ApiException = require('../../utils/ApiException')
const mongoose = require('mongoose')

// Retrieve - all books
const getAllBooks = async () => {
  return bookRepository.getAll()
}

module.exports = {
  getAllBooks
}
```

## 6 - Events

None.

## 7 - Response

Here is what we will do to our controller in order to return a list of books

*File: src/controllers/book.controller.js*

```javascript
const globalResponseDto = require('../../responses/globalResponseDto')
const booksResponseDto = require('../../responses/booksResponseDto')
const catchException = require('../../utils/catchExceptions')
const bookService = require('../../domain/services/book.service')

/**
 * Gets all book listings from the database.
 */
const getAllBooks = catchException(async (req, res) => {
  const books = await bookService.getAllBooks()

  res.json(
    globalResponseDto({
      status: 'success',
      code: 200,
      message: `List of all books in the database.`,
      data: booksResponseDto(books),
      errors: null
    })
  )
})

module.exports = getAllBooks
```

*File: src/responses/bookResponseDTO.js*

```javascript
function bookResponseDTO(book) {
  return {
    id: book['id'],
    title: book['title'],
    description: book['description'],
    price: book['price'],
    author: book['author'],
    datePublished: book['datePublished']
  }
}

module.exports = bookResponseDTO
```

*File: src/responses/booksResponseDTO.js*

```javascript
const bookResponseDTO = require('./bookResponseDTO')

function booksResponseDTO(books) {
  return books.map((book) => bookResponseDTO(book))
}

module.exports = booksResponseDTO
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://book.restfulnode.com/part-3/chapter-7/2-retrieving-all-books-implementation.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.