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: How to Use Knex js in an Express Backend App
description: Using Knex with an Express Application
privateVideoUrl: https://fullstack.wistia.com/medias/czleo9d1t6
isPublicLesson: false
code: https://gitlab.com/fullstackio/books/newline-course-apps/blair-googer-fullstack-svelte-app/-/tree/main/code/module_06/lesson_03/App?ref_type=heads
---

### Using Knex in the Backend App

Previously, we created a `knexfile` that contained configuration for Knex Migrations to connect to our database. We can use the same `knexfile` in our backend Express app to allow it to work with the database.

We'll start by adding a directory in the root of the backend project called `database` and then create a JavaScript file that initializes Knex.

Create the file`client.js` in `/school-lunch/backend/database`:

```js
// /school-lunch/backend/database/client.js

const knex = require('knex')

// determine the environment from the ENV VAR called `ENVIRONMENT`, or
// default to development
const environment = process.env.ENVIRONMENT || 'development'

// get the appropriate config for the given environment
const config = require('../knexfile.js')[environment]

// instantiate Knex with the config
const db = knex(config)

module.exports = db
```

Now let's take a look at the `GET /lunch-week` endpoint. Previously, we just returned a static, hard-coded array of `lunch-week` objects:

```js
const lunchWeekList = [
  {
    lunchWeekId: 1,
    weekOf: '2020-10-05',
    isPublished: true,
  },
  {
    lunchWeekId: 2,
    weekOf: '2020-10-12',
    isPublished: true,
  },
  {
    lunchWeekId: 3,
    weekOf: '2020-10-19',
    isPublished: false,
  },
]

router.get('/', async function (req, res) {
  await new Promise((f) => setTimeout(f, 2000))
  res.send(lunchWeekList)
})
```

We can change it to use Knex and return data from the database like this:

```js
var express = require('express')
var router = express.Router()
const knex = require('../database/client') // Import our knex client that we just created

// Create a helper function to select all the rows from the
// lunch_week table
const getLunchWeekList = () => {
  return knex.select().from('lunch_week').orderBy('week_of')
}

// Call the helper function in our endpoint. Knex database queries
// return Promises, so the `await` keyword needs to be used in combination with
// `async function`
router.get('/', async function (req, res) {
  const lunchWeekList = await getLunchWeekList()
  res.send(lunchWeekList)
})

module.exports = router
```

Now, you can give it a try in your browser at <http://localhost:3000/api/lunch-week>. If everything works, you should see the following JSON response, based on the data from the `lunch_week` table.

```json
[
  {
    "lunch_week_id": 1,
    "week_of": "2020-10-05T04:00:00.000Z",
    "is_published": true
  },
  {
    "lunch_week_id": 2,
    "week_of": "2020-10-12T04:00:00.000Z",
    "is_published": true
  },
  {
    "lunch_week_id": 3,
    "week_of": "2020-10-19T04:00:00.000Z",
    "is_published": false
  },
  {
    "lunch_week_id": 4,
    "week_of": "2020-10-26T04:00:00.000Z",
    "is_published": false
  },
  {
    "lunch_week_id": 5,
    "week_of": "2020-11-02T05:00:00.000Z",
    "is_published": false
  }
]
```

### Knex Stringcase

You may have noticed that the JSON property names are in snake-case, just like the database column names. We can use a little bit of extra configuration to convert them to camelCase. Install the package `knex-stringcase`.

```shell
$ npm install knex-stringcase
```

Then update the `/database/client.js` to use `knex-stringcase` as follows:

```js { actualFilename=../../../code/module_06/lesson_03/school-lunch/backend/database/client.js endChar=279 endLine=9 startChar=0 startLine=1 statedFilename=database/client.js url=https&#x3A;//gitlab.com/fullstackio/books/fullstack-svelte-course/module_07/lesson_07.03/.../../code/module_06/lesson_03/school-lunch/backend/database/client.js }
const knex = require('knex')
const environment = process.env.ENVIRONMENT || 'development'
const config = require('../knexfile.js')[environment]
const knexStringcase = require('knex-stringcase')
const options = knexStringcase(config)
const db = knex(options)