This course teaches all the major concepts you need to build a production ready SaaS application by step by step _building a fully functional application_. The course is divided into two main parts - the _frontend_, which uses Svelte to build an interactive, rich user interface and the _backend_, which uses Express and PostgreSQL to build a server that handles data management.

Svelte is an exciting new frontend UI framework that offers a very developer friendly workflow and easy to learn syntax. Express and PostgreSQL are tried-and-true technologies that provide a rock solid backend.

Across about 7 hours of video instruction with full source code, this course covers everything from setting up your development environment to securing your application with a multi-tenant architecture and ultimately deploying the application to production.

Build a Svelte app with Node.js, Express, and Postgresql

In this course, we'll be creating a full stack SaaS application with Svelte, Express and PostgreSQL

Fullstack Svelte

---
title: Sveltekit Endpoints - How to Use Post, Put, and Delete
description: Adding Post, Put and Delete Endpoints to the Backend
privateVideoUrl: https://fullstack.wistia.com/medias/xtmqpek0iu
isPublicLesson: false
code: https://gitlab.com/fullstackio/books/newline-course-apps/blair-googer-fullstack-svelte-app/-/tree/main/code/module_06/lesson_04/App?ref_type=heads
---

### Creating and Updating Data

We need a way to be able to create and update rows on the `lunch_week` and `lunch_day` tables. For creating new records, we'll use a `POST` endpoint. For updating existing records, we'll use a `PUT` endpoint.

Let's start with a `POST` endpoint to create a row in the `lunch_week` table. When we create a new row, the database will generate an ID for that row. We'll return that ID back to the API caller:

```js
const createLunchWeek = (lunchWeek) => {
  // for Postgres, we need to specifiy what columns to return back
  // from the insert statement with a call to `.returning()`
  return knex('lunch_week').insert(lunchWeek).returning('lunch_week_id')
}

router.post('/', async function (req, res) {
  const lunchWeek = req.body
  try {
    const insertResponse = await createLunchWeek(lunchWeek)
    // Since you can insert more than one row with `knex.insert`, the response is
    // an array, so we need to return the 0 position
    const insertedLunchWeekId = insertResponse[0]
    const response = {
      lunchWeekId: insertedLunchWeekId,
    }
    res.send(response)
  } catch (e) {
    const message = `Error creating Lunch Week`
    res.status(500).send({ message: message, error: e.toString() })
  }
})
```

### Testing POST and PUT Endpoints

We can only test GET endpoints in the URL bar of a web browser. Now that we have a POST endpoint to test, we need another tool. For this course, we are going to use [Postman](https://www.postman.com/) to test these endpoints.

Postman is a robust tool for making API requests. If you don't already have it, go ahead and install it now.

Once Postman is open, we can make a POST request to our new endpoint. One big difference between POST/PUT requests and GET requests is that they can have a JSON body.

When we submit a POST request with a body to Express, we can access the body as a JavaScript object by calling `req.body` as we did above. Therefore, in our Postman request, we'll need to provide a basic `lunchWeek` entity as the body.

Here's what it looks like in Postman:

![postman-request](https://d2uusema5elisf.cloudfront.net/courses/fullstack-svelte/module_07/lesson_07.04/public/postman-request.png)

There are a couple of gotchas in getting this to work in Postman. First, make sure POST is selected to the left of the URL.

Second, click the Body tab, select the option for `raw` and select `JSON (application/json)` in the Content Type dropdown.

![content-type selection](https://d2uusema5elisf.cloudfront.net/courses/fullstack-svelte/module_07/lesson_07.04/public/content-type.png)

When everything is ready, hit the Send button in Postman to send the request. You should see the newly created `lunchWeekId` in the response. You can also run a select statement against the `lunch_week` table to verify that a new row was inserted.

### Lunch Week PUT Endpoint

Next let's create another endpoint to update rows on the `lunch_week` table. We'll use a PUT endpoint for this. The concept is similar to POST, but we'll use an update statement this time and the route will contain the ID to be updated.

In this case, the body of the request may contain a `lunchWeekId` as well, so it's a good idea to return a `400 Bad Request` error if the route does not match the body.

Here's the code:

```js
const updateLunchWeek = (id, lunchWeek) => {
  return knex('lunch_week').where('lunch_week_id', id).update(lunchWeek)
}

router.put('/:lunchWeekId', async function (req, res) {
  try {
    const id = parseInt(req.params.lunchWeekId)
    const lunchWeek = req.body

    if (id !== lunchWeek.lunchWeekId) {
      const message = `Bad request, IDs do not match`
      res.status(400).send({ message: message })
      // IMPORTANT, we need to explicitly return here, otherwise the rest
      // of the endpoint code will continue to run.
      // In other words, res.send does not return like you might think it would
      return
    }

    await updateLunchWeek(id, lunchWeek)
    res.send()
  } catch (e) {
    const message = `Error updating Lunch Week`
    res.status(500).send({ message: message, error: e.toString() })
  }
})
```

Give this one a try in Postman as well. Remember that the route for the PUT endpoint requires the ID to be in the route, e.g., `api/lunch-week/6`.

You can try toggling the `isPublished` flag. For example if `isPublished` is false for lunchWeekId 6, then you could set it to true with the following call:

Adding Post, Put and Delete Endpoints to the Backend