After deciding to join more conferences this year, the very first one was dotSwift. It was held in a great old theater in Paris. It was a half day conference but it was better than I guessed. There were good talks about backend development in Swift. After hearing a lot about that and great performance of Swift, I decided to give it a try. And here comes my first experiences step by step.

There are two major frameworks for backend in Swift, Kitura and Vapor. I choose Kitura first. Because Kitura’s methods naming was close to the ones that I knew from Node.js. I felt more comfortable about understanding what each method does.

First, setting up the environment was easy because I have Mac and I’m actively developing iOS applications. So, Xcode and other stuff were already set up.

Creating a Swift backend project means creating a new Swift package with single line command swift package init. This creates a structured new package. But packages are not executable and I needed an executable project to run my backend. Creating main.swift file under Sources directory gave this ability to me. At this point my current folder structure was like this:

SwiftBackend
  .gitignore
  Package.swift
  |--Sources
  main.swift
  |--Tests

Now, it was time to arrange Package.swift and add Kitura. Here is the Package.swift file with Kitura added as a dependency:

import PackageDescription

let package = Package(
  name: "SwiftBackend",
  dependencies: [
    .Package(url: "https://github.com/IBM-Swift/Kitura.git", majorVersion: 1, minor: 4)
  ]
)

swift build command installs the dependencies and builds the project. After adding a new dependency, it’s always logical to build the project and see if it works.

Next step is setting up an endpoint. The basic example in Kitura’s tutorial is:

import Kitura

let router = Router()
router.get("/") { request, response, next in
  response.send("Hello, World!")
  next()
}
Kitura.addHTTPServer(onPort: 8090, with: router)
Kitura.run()

I added this code to main.swift file. When I ran the project locally, I should have seen Hello, World! when I enter localhost:8090 via browser (or make a get request via Postman etc.). To run this project, first I needed to build it via swift build and this command created the executable for me under .build/debug/SwiftBackend . I’ve just run the executable with typing the command line .build/debug/SwiftBackend. At this point, I was able to send a request and see “Hello, World!” text in the browser. But in the console, I wasn’t seeing any logs about these requests.

HeliumLogger came into at that point. It’s a logger component which available as a separate Swift module. I added this module to Package.swift file by adding as a new dependency. At this point, my Package.swift file was like this:

import PackageDescription

let package = Package(
  name: "SwiftBackend",
  dependencies: [
    .Package(url: "https://github.com/IBM-Swift/Kitura.git", majorVersion: 1, minor: 4),
    .Package(url: "https://github.com/IBM-Swift/HeliumLogger.git", majorVersion: 1, minor: 4)
  ]
)

And I ran the swift build command again to install HeliumLogger. After that, I needed to import HeliumLogger and use it in main.swift file. It was just one line. My main.swift file became like this:

import Kitura
import HeliumLogger

HeliumLogger.use()

let router = Router()
router.get("/") { request, response, next in
  response.send("Hello, World!")
  next()
}
Kitura.addHTTPServer(onPort: 8090, with: router)
Kitura.run()

After building and running the project again, I was able to see the request logs in the console.

As the next step, I wanted to connect database to my backend API. I used CouchDB because there is a Kitura-CouchDB package.

After adding CouchDB package to my Package.swift file, it became like this:

import PackageDescription

let package = Package(
  name: "SwiftBackend",
  dependencies: [
    .Package(url: "https://github.com/IBM-Swift/Kitura.git", majorVersion: 1, minor: 4),
    .Package(url: "https://github.com/IBM-Swift/HeliumLogger.git", majorVersion: 1, minor: 4),
    .Package(url: "https://github.com/IBM-Swift/Kitura-CouchDB.git", majorVersion: 1, minor: 4)
  ]
)

Again, I ran the command swift build to install new package.

While implementing database operations, I wanted to create a structure to not do everything in main.swift file. First, I created a User struct as a model object. My main purpose for database operations was adding this User object to CouchDB database as a document. Easy model, easy operation. So User struct was like this:

import Foundation

public struct User {
  let name: String
  let identifier: String
}

So, as I said my main purpose was adding a document to CouchDB database. I created a DatabaseInteraction struct with one method to achieve that goal. My plan was adding all database operations to this struct. Here is the DatabaseInteraction struct:

import Foundation
import CouchDB
import SwiftyJSON

public struct DatabaseInteraction {
  var db: Database
  public init(db: Database) {
    self.db = db
  }

func addNewUser(_ user: User, handler: @escaping (String?, String?, JSON?, NSError?) -> ()) {
    let userDict: [String: Any] = [
      "name": user.name,
      "identifier": user.identifier
    ]
    let userJSON = JSON(userDict)
    db.create(userJSON) {  (id, revision, doc, error) in
      if let error = error {
        handler(nil, nil, nil, error)
        return
      } else {
        handler(id, revision, doc, nil)
      }
    }
  }
}

I also separated HTTP request methods to routers. First, I created UserRouter to handle HTTP requests for user and I only wrote one post method to get user data in the body.UserRouter class is like this:

import Foundation
import Kitura
import CouchDB
import SwiftyJSON

public class UserRouter {
  var db: DatabaseInteraction

  public init(db: DatabaseInteraction) {
    self.db = db
  }

  public func bindAll(to router: Router) {
    addCreateUser(to: router)
  }

  private func addCreateUser(to router: Router) {
    router.post("/user/", handler: { req, res, next in
      guard let parsedBody = req.body else {
        res.status(.badRequest)
        next()
        return
      }
      switch(parsedBody) {
        case .json(let jsonBody):
          let name = jsonBody["name"].string ??
          let user = User(name: name, identifier: "\(name.characters.count)")
          self.db.addNewUser(user) { (id, revision, doc, error) in
            if let error = error {
              res.status(.internalServerError)
              next()
            } else {
              res.status(.OK)
              if let doc = doc {
                res.send(json: doc)
              } else {
                res.send("Something is wrong in the doc")
              }
              next()
            }
          }
        default:
          res.status(.badRequest)
          next()
      }
    })
  }
}

After that, I created the main router to manage separate routing operations from here. Here is the BackendRouter as main router object:

import Foundation
import Kitura

public class BackendRouter {
  public let router = Router()
  var db: DatabaseInteraction
  public init(db: DatabaseInteraction) {
    self.db = db
    router.get("/status") { req, res, callNextHandler in
      res.status(.OK).send("Everything is working")
      callNextHandler()
    }

    router.all("*", middleware: BodyParser())
    self.routeToUser()
  }

  func routeToUser() {
    let user = UserRouter(db: self.db)
    user.bindAll(to: self.router)
  }
}

Lastly, I connected all of them in the main.swift file.

import Kitura
import HeliumLogger
import CouchDB

HeliumLogger.use()

let connProperties = ConnectionProperties(
    host: "127.0.0.1",  // httpd address
    port: 5984,         // httpd port
    secured: false,     // https or http
    username: "admin",  // admin username
    password: "password"// admin password
)

let db = Database(connProperties: connProperties, dbName: "swift_backend_test_db")
let databaseInteraction = DatabaseInteraction(db: db)
let app = MainRouter(db: databaseInteraction)

Kitura.addHTTPServer(onPort: 8090, with: app.router)
Kitura.run()

So, let’s see how the overall folder structure looks right now.

SwiftBackend
  .gitignore
  |--Sources
    BackendRouter.swift
    DatabaseInteraction.swift
    main.swift
    User.swift
    UserRouter.swift
  |--Tests
  Package.swift

After all coding, it was time to build the API and send a request via Postman. I got success after some trials. (Note: Be careful about connection properties and escaping closures). Of course, there are a lot of things to improve in code. But all these codes were intended to create a working backend API developed with Swift.

In the next post, I made this project testable and Dockerized. There are some points to be careful while making it testable.

As a final step, I’ll try to upload to cloud. But my first impression was really good. I should say that I convinced to work on the backend side in Swift. It’s pretty easy. I’m working with SublimeText instead of Xcode. Thus, I can understand each line I wrote without auto-completion. If you’re working with Swift, you should definitely try to create some backend APIs with Swift.

Cover Photo by Joshua Earle on Unsplash