Koa Nodejs

How to Use Koa to Build Simple Web Apps

Spread the love

Koa is a simple web framework for building backend applications. By default, it comes with nothing. You get what you need by adding packages that extend the default functionality. This makes building apps easy and keeps the code as simple as possible.

In this article, we will build an address book app. Users can add, edit, and remove contacts and also view them in a table. We build the back end with Koa and a simple frontend with React.

To start the project, we create folder for it and inside it, we create a backend directory.

Back End

Now we can build the back end, we run npm init and answer the questions by entering the default values. Then we install our own packages. Koa comes with nothing, so we need to install a request body parser, a router, and a CORS add-on to enable cross domain requests. We also need to add libraries for the database.

To install all these packages, run npm i @babel/cli @babel/core @babel/node @babel/preset-env @koa/cors koa-bodyparser koa-router sequelize sqlite3. We need the Babel packages for running with the latest JavaScript features. Sequelize and SQLite are the ORM and database that we will use respectively. The Koa packages are for enabling CORS, parsing JSON request body, and enable routing respectively.

Next run:

npx sequelize-cli init

This creates the database boilerplate code.

Then we run:

npx sequelize-cli --name Contact --attributes firstName:string,lastName:string,,region:string,country:string,postalCode:string,phone:string,email:string,age:number

This creates a Contacts table with the fields and data types listed in the attributes option.

After that is done, run npx sequelize-cli db:migrate to create the database.

Next create app.js in the root of the backend folder and add:

const Koa = require("koa");
const cors = require("@koa/cors");
const Router = require("koa-router");
const models = require("./models");
const bodyParser = require("koa-bodyparser");

const app = new Koa();
const router = new Router();

router.get("/contacts", async (ctx, next) => {
  const contacts = await models.Contact.findAll();
  ctx.body = contacts;
});"/contacts", async (ctx, next) => {
  const contact = await models.Contact.create(ctx.request.body);
  ctx.body = contact;

router.put("/contacts/:id", async (ctx, next) => {
  const { id, ...body } = ctx.request.body;
  const contact = await models.Contact.update(body, { where: { id } });
  ctx.body = contact;

router.delete("/contacts/:id", async (ctx, next) => {
  const id =;
  await models.Contact.destroy({ where: { id } });
  ctx.body = {};



This is the file with all the logic for our app. We use the Sequelize model we created by importing the models module that is created by running sequelize-cli init.

Then we enable CORS by adding app.use(cors()); JSON request body parsing is enabled by adding app.use(bodyParser());. We add a router by adding: const router = new Router(); .

In the GET contacts route, we get all the contacts. The POST is for adding a contact. The PUT route is used for updating an existing contact by looking it up by ID. And the DELETE route is for deleting a contact by ID.

Now the back end is done. It is that simple.

Front End

To start we need to run Create React App to scaffold the app. We run npx create-react-app address-book to create the app project folder with the initial files. The app will have a home page to display the contacts and let us open a modal to add a contact. There will be a table that displays all the contacts and Edit and Delete buttons on each row to edit or delete each contact. The contacts will store in a central Redux store to store the contacts in a central place, making them easy to access. React Router will be used for routing. Contacts will be saved in the back end spawned using the JSON server package, located at

For form validation, then you need to use a third party library. Formik and Yup work great together to allow us to take care of most form validation needs. Formik lets us build the forms and display the errors, and handle form value changes, which is another thing we have to do all my hand otherwise. Yup let us write a schema for validating our form fields. It can check almost anything, with common validation code like email and required fields available as built in functions. It can also check for fields that depend on other fields, like the postal code format depending on country. Bootstrap forms can be used seamlessly with Formik and Yup.

Once that is done, we have to install some libraries. To install the libraries we mentioned above, we run npm i axios bootstrap formik react-bootstrap mobx mobx-react react-router-dom yup . Axios is the HTTP client that we use for making HTTP requests to back end. react-router-dom is the package name for the latest version of React Router.

Now that we have all the libraries installed, we can start building the app. All files will be in the src folder except mentioned otherwise. First we work on the MobX store. We create a file called store.js in the src folder and add the following:

import { observable, action, decorate } from "mobx";

class ContactsStore {
  contacts = [];

  setContacts(contacts) {
    this.contacts = contacts;

ContactsStore = decorate(ContactsStore, {
  contacts: observable,
  setContacts: action,

export { ContactsStore };

This is a simple store which stores the contacts the contacts array is where we store the contacts for the whole app. The setContacts function let us set contacts from any component where we pass in the this store object to.

This block:

ContactsStore = decorate(ContactsStore, {
  contacts: observable,
  setContacts: action,

designates the contacts array in ContactsStore as the entity that can be watched by components for changes. The setContacts is designated as the function that can be used to set the contacts array in the store.

In App.js , we replace what is existing with the following:

import React from "react";
import { Router, Route } from "react-router-dom";
import HomePage from "./HomePage";
import { createBrowserHistory as createHistory } from "history";
import Navbar from "react-bootstrap/Navbar";
import Nav from "react-bootstrap/Nav";
import "./App.css";
const history = createHistory();

function App({ contactsStore }) {
  return (
    <div className="App">
      <Router history={history}>
        <Navbar bg="primary" expand="lg" variant="dark">
          <Navbar.Brand href="#home">Address Book App</Navbar.Brand>
          <Navbar.Toggle aria-controls="basic-navbar-nav" />
          <Navbar.Collapse id="basic-navbar-nav">
            <Nav className="mr-auto">
              <Nav.Link href="/">Home</Nav.Link>
          component={props => (
            <HomePage {...props} contactsStore={contactsStore} />

export default App;

We pass the store into any component that needs it like the HomePage , which will pass the component to the ContactForm .

This is where we add the navigation bar and show our routes routed by the React Router. In App.css , we replace the existing code with:

.App {
  text-align: center;

This centers the text.

Next we build our contact form. This is the most logic heavy part of our app. We create a file called ContactForm.js and add:

import React from "react";
import { Formik } from "formik";
import Form from "react-bootstrap/Form";
import Col from "react-bootstrap/Col";
import InputGroup from "react-bootstrap/InputGroup";
import Button from "react-bootstrap/Button";
import * as yup from "yup";
import { COUNTRIES } from "./exports";
import PropTypes from "prop-types";
import { addContact, editContact, getContacts } from "./requests";

const schema = yup.object({
  firstName: yup.string().required("First name is required"),
  lastName: yup.string().required("Last name is required"),
  address: yup.string().required("Address is required"),
  city: yup.string().required("City is required"),
  region: yup.string().required("Region is required"),
  country: yup
    .required("Country is required")
  postalCode: yup
    .when("country", {
      is: "United States",
      then: yup
        .matches(/^[0-9]{5}(?:-[0-9]{4})?$/, "Invalid postal code"),
    .when("country", {
      is: "Canada",
      then: yup
          /^[A-Za-z]d[A-Za-z][ -]?d[A-Za-z]d$/,
          "Invalid postal code"
  phone: yup
    .when("country", {
      is: country => ["United States", "Canada"].includes(country),
      then: yup
        .matches(/^[2-9]d{2}[2-9]d{2}d{4}$/, "Invalid phone nunber"),
  email: yup
    .email("Invalid email")
    .required("Email is required"),
  age: yup
    .required("Age is required")
    .min(0, "Minimum age is 0")
    .max(200, "Maximum age is 200"),

function ContactForm({
}) {
  const handleSubmit = async evt => {
    const isValid = await schema.validate(evt);
    if (!isValid) {
    if (!edit) {
      await addContact(evt);
    } else {
      await editContact(evt);
    const response = await getContacts();

  return (
    <div className="form">
        initialValues={contact || {}}
        }) => (
          <Form noValidate onSubmit={handleSubmit}>
              <Form.Group as={Col} md="12" controlId="firstName">
                <Form.Label>First name</Form.Label>
                  placeholder="First Name"
                  value={values.firstName || ""}
                  isInvalid={touched.firstName && errors.firstName}
                <Form.Control.Feedback type="invalid">
              <Form.Group as={Col} md="12" controlId="lastName">
                <Form.Label>Last name</Form.Label>
                  placeholder="Last Name"
                  value={values.lastName || ""}
                  isInvalid={touched.firstName && errors.lastName}

                <Form.Control.Feedback type="invalid">
              <Form.Group as={Col} md="12" controlId="address">
                    value={values.address || ""}
                    isInvalid={touched.address && errors.address}
                  <Form.Control.Feedback type="invalid">
              <Form.Group as={Col} md="12" controlId="city">
                  value={ || ""}
                  isInvalid={ &&}

                <Form.Control.Feedback type="invalid">
              <Form.Group as={Col} md="12" controlId="region">
                  value={values.region || ""}
                  isInvalid={touched.region && errors.region}
                <Form.Control.Feedback type="invalid">

              <Form.Group as={Col} md="12" controlId="country">
                  value={ || ""}
                  isInvalid={touched.region &&}
                  { => (
                    <option key={c} value={c}>
                <Form.Control.Feedback type="invalid">

              <Form.Group as={Col} md="12" controlId="postalCode">
                <Form.Label>Postal Code</Form.Label>
                  placeholder="Postal Code"
                  value={values.postalCode || ""}
                  isInvalid={touched.postalCode && errors.postalCode}

                <Form.Control.Feedback type="invalid">

              <Form.Group as={Col} md="12" controlId="phone">
                  value={ || ""}
                  isInvalid={ &&}

                <Form.Control.Feedback type="invalid">

              <Form.Group as={Col} md="12" controlId="email">
                  value={ || ""}
                  isInvalid={ &&}

                <Form.Control.Feedback type="invalid">

              <Form.Group as={Col} md="12" controlId="age">
                  value={values.age || ""}
                  isInvalid={touched.age && errors.age}

                <Form.Control.Feedback type="invalid">
            <Button type="submit" style={{ marginRight: "10px" }}>
            <Button type="button" onClick={edit ? onCancelEdit : onCancelAdd}>

ContactForm.propTypes = {
  edit: PropTypes.bool,
  onSave: PropTypes.func,
  onCancelAdd: PropTypes.func,
  onCancelEdit: PropTypes.func,
  contact: PropTypes.object,
  contactsStore: PropTypes.object

export default ContactForm;

We pass in the contactsStore from the HomePage component, allowing us to use the data and functions in contactsStore.

For form validation, we use Formik to facilitate building our contact form here, with our Boostrap Form component nested in the Formik component so that we can use Formik’s handleChange, handleSubmit, values, touched, and errors parameters. handleChange is a function that let us update the form field data from the inputs without writing the code ourselves. handleSubmit is the function that we passed into the onSubmit handler of the Formik component. The parameter in the function is the data we entered, with the field name as the key, as defined by the name attribute of each field and the value of each field as the value of those keys. Notice that in each value prop, we have ||'' so we do not get undefined values and prevent uncontrolled form warnings from getting triggered.

To display form validation messages, we have to pass in the isInvalid prop to each Form.Control component. The schema object is what Formik will check against for form validation. The argument in the required function is the validation error message. The second argument of the matches , min and max functions are also validation messages.

The parameter of the ContactForm function are props, which we will pass in from the HomePage component that we will build later. The handleSubmit function checks if the data is valid, then if it is then it will proceed to saving according to whether it is adding or editing a contact. Then when saving is successful we set the contacts in the store and call onSave prop, which is a function to close the modal the form is in. The modal will be defined in the home page.

Next we create a file called exports.js , and put:

export const COUNTRIES = [
  "Antigua &amp; Barbuda",
  "Bosnia &amp; Herzegovina",
  "British Virgin Islands",
  "Burkina Faso",
  "Cape Verde",
  "Cayman Islands",
  "Cook Islands",
  "Costa Rica",
  "Cote D Ivoire",
  "Cruise Ship",
  "Czech Republic",
  "Dominican Republic",
  "El Salvador",
  "Equatorial Guinea",
  "Falkland Islands",
  "Faroe Islands",
  "French Polynesia",
  "French West Indies",
  "Guinea Bissau",
  "Hong Kong",
  "Isle of Man",
  "Kyrgyz Republic",
  "Netherlands Antilles",
  "New Caledonia",
  "New Zealand",
  "Papua New Guinea",
  "Puerto Rico",
  "Saint Pierre &amp; Miquelon",
  "San Marino",
  "Saudi Arabia",
  "Sierra Leone",
  "South Africa",
  "South Korea",
  "Sri Lanka",
  "St Kitts &amp; Nevis",
  "St Lucia",
  "St Vincent",
  "St. Lucia",
  "Timor L'Este",
  "Trinidad &amp; Tobago",
  "Turks &amp; Caicos",
  "United Arab Emirates",
  "United Kingdom",
  "United States",
  "United States Minor Outlying Islands",
  "Virgin Islands (US)",

These are countries for the countries field in the form.

In HomePage.js , we put:

import React from "react";
import { useState, useEffect } from "react";
import Table from "react-bootstrap/Table";
import ButtonToolbar from "react-bootstrap/ButtonToolbar";
import Button from "react-bootstrap/Button";
import Modal from "react-bootstrap/Modal";
import ContactForm from "./ContactForm";
import "./HomePage.css";
import { getContacts, deleteContact } from "./requests";
import { observer } from "mobx-react";

function HomePage({ contactsStore }) {
  const [openAddModal, setOpenAddModal] = useState(false);
  const [openEditModal, setOpenEditModal] = useState(false);
  const [initialized, setInitialized] = useState(false);
  const [selectedContact, setSelectedContact] = useState({});

const openModal = () => {

const closeModal = () => {

const cancelAddModal = () => {

const editContact = contact => {

const cancelEditModal = () => {

const getData = async () => {
    const response = await getContacts();

const deleteSelectedContact = async id => {
    await deleteContact(id);

useEffect(() => {
    if (!initialized) {

return (
    <div className="home-page">
      <Modal show={openAddModal} onHide={closeModal}>
        <Modal.Header closeButton>
          <Modal.Title>Add Contact</Modal.Title>

<Modal show={openEditModal} onHide={closeModal}>
        <Modal.Header closeButton>
          <Modal.Title>Edit Contact</Modal.Title>
      <ButtonToolbar onClick={openModal}>
        <Button variant="outline-primary">Add Contact</Button>
      <br />
      <Table striped bordered hover>
            <th>First Name</th>
            <th>Last Name</th>
            <th>Postal Code</th>
          { => (
            <tr key={}>
                  onClick={editContact.bind(this, c)}
export default observer(HomePage);

Notice that we have export default observer(HomePage); instead of export default HomePage; . We need to wrap HomePage by the observer function call so that the latest data from the store will be propagated into this component.

It has the table to display the contacts and buttons to add, edit, and delete a contact. It gets data once on the first load with the getData function called in the useEffect’s callback function. useEffect’s callback is called on every render so we want to set a initialized flag and check that it loads only if it’s true.

Note that we pass in all the props in this component to the ContactForm component. To pass an argument a onClick handler function, we have to call bind on the function and pass in the argument for the function as a second argument to bind. For example, in this file, we have editContact.bind(this, c), where c is the contact object. The editContact function is defined as follows:

const editContact = (contact) => {

c is the contact parameter we pass in.

Next we create a file called HomePage.css and put:

.home-page {
  padding: 20px;

This adds padding to our home page.

In index.js, we replace the existing code with:

import React from "react";
import ReactDOM from "react-dom";
import "./index.css";
import App from "./App";
import * as serviceWorker from "./serviceWorker";
import { ContactsStore } from "./store";
const contactsStore = new ContactsStore();

  <App contactsStore={contactsStore} />,

// If you want your app to work offline and load faster, you can change
// unregister() to register() below. Note this comes with some pitfalls.
// Learn more about service workers: [](

Then we make a file called requests.js, and add:

const APIURL = '[http://localhost:3000'](http://localhost:3000%27);
const axios = require('axios');
export const getContacts = () => axios.get(`${APIURL}/contacts`);
export const addContact = (data) =>`${APIURL}/contacts`, data);
export const editContact = (data) => axios.put(`${APIURL}/contacts/${}`, data);
export const deleteContact = (id) => axios.delete(`${APIURL}/contacts/${id}`);

These are functions are making our HTTP requests to the back end to save and delete contacts.

Finally, in public/index.html, we replace the existing code with:

<!DOCTYPE html>
<html lang="en">

  <meta charset="utf-8" />
  <link rel="shortcut icon" href="%PUBLIC_URL%/favicon.ico" />
  <meta name="viewport" content="width=device-width, initial-scale=1" />
  <meta name="theme-color" content="#000000" />
  <meta name="description" content="Web site created using create-react-app" />
  <link rel="apple-touch-icon" href="logo192.png" />
  <link rel="manifest" crossorigin="use-credentials" href="%PUBLIC_URL%/manifest.json" />

      manifest.json provides metadata used when your web app is installed on a
      user's mobile device or desktop. See [](
      Notice the use of %PUBLIC_URL% in the tags above.
      It will be replaced with the URL of the `public` folder during the build.
      Only files inside the `public` folder can be referenced from the HTML.

Unlike "/favicon.ico" or "favicon.ico", "%PUBLIC_URL%/favicon.ico" will
      work correctly both with client-side routing and a non-root public URL.
      Learn how to configure a non-root public URL by running `npm run build`.
  <title>React Address Book App</title>
  <link rel="stylesheet" href=""
    integrity="sha384-ggOyR0iXCbMQv3Xipma34MD+dH/1fQ784/j6cY/iJTQUOhcWr7x9JvoRxT2MZw1T" crossorigin="anonymous" />

  <noscript>You need to enable JavaScript to run this app.</noscript>
  <div id="root"></div>
      This HTML file is a template.
      If you open it directly in the browser, you will see an empty page.

You can add webfonts, meta tags, or analytics to this file.
      The build step will place the bundled scripts into the <body> tag.

To begin the development, run `npm start` or `yarn start`.
      To create a production bundle, use `npm run build` or `yarn build`.


This changes the title and adds the Bootstrap stylesheet.

After writing all that code, we can run our app. Before running anything, install nodemon by running npm i -g nodemon so that we don’t have to restart back end ourselves when files change.

Then run back end by running npm start in the backend folder and npm start in the frontend folder, then choose ‘yes’ if you’re asked to run it from a different port.

At the end, we have the following:

By John Au-Yeung

Web developer specializing in React, Vue, and front end development.

Leave a Reply

Your email address will not be published. Required fields are marked *