New Horizons with Server-Side Swift

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 the great performance of Swift, I decided to give it a try. And here comes my first experience, step by step.

There are two major frameworks for the 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 the 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 the Sources directory gave me this ability to me. At this point, my current folder structure was like this:

1
SwiftBackend
2
  .gitignore
3
  Package.swift
4
  |--Sources
5
  main.swift
6
  |--Tests

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

1
import PackageDescription
2

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

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.

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

1
import Kitura
2

3
let router = Router()
4
router.get("/") { request, response, next in
5
  response.send("Hello, World!")
6
  next()
7
}
8
Kitura.addHTTPServer(onPort: 8090, with: router)
9
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 by 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 didn’t see any logs about these requests.

HeliumLogger came in 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 it as a new dependency. At this point, my Package.swift file was like this:

1
import PackageDescription
2

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

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:

1
import Kitura
2
import HeliumLogger
3

4
HeliumLogger.use()
5

6
let router = Router()
7
router.get("/") { request, response, next in
8
  response.send("Hello, World!")
9
  next()
10
}
11
Kitura.addHTTPServer(onPort: 8090, with: router)
12
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 the database to my backend API. I used CouchDB because there is a Kitura-CouchDB package.

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

1
import PackageDescription
2

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

Again, I ran the command swift build to install a 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 to add this User object to the CouchDB database as a document. Easy model, easy operation. So User struct was like this:

1
import Foundation
2

3
public struct User {
4
  let name: String
5
  let identifier: String
6
}

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

1
import Foundation
2
import CouchDB
3
import SwiftyJSON
4

5
public struct DatabaseInteraction {
6
  var db: Database
7
  public init(db: Database) {
8
    self.db = db
9
  }
10

11
func addNewUser(_ user: User, handler: @escaping (String?, String?, JSON?, NSError?) -> ()) {
12
    let userDict: [String: Any] = [
13
      "name": user.name,
14
      "identifier": user.identifier
15
    ]
11 collapsed lines
16
    let userJSON = JSON(userDict)
17
    db.create(userJSON) {  (id, revision, doc, error) in
18
      if let error = error {
19
        handler(nil, nil, nil, error)
20
        return
21
      } else {
22
        handler(id, revision, doc, nil)
23
      }
24
    }
25
  }
26
}

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

1
import Foundation
2
import Kitura
3
import CouchDB
4
import SwiftyJSON
5

6
public class UserRouter {
7
  var db: DatabaseInteraction
8

9
  public init(db: DatabaseInteraction) {
10
    self.db = db
11
  }
12

13
  public func bindAll(to router: Router) {
14
    addCreateUser(to: router)
15
  }
33 collapsed lines
16

17
  private func addCreateUser(to router: Router) {
18
    router.post("/user/", handler: { req, res, next in
19
      guard let parsedBody = req.body else {
20
        res.status(.badRequest)
21
        next()
22
        return
23
      }
24
      switch(parsedBody) {
25
        case .json(let jsonBody):
26
          let name = jsonBody["name"].string ??
27
          let user = User(name: name, identifier: "\(name.characters.count)")
28
          self.db.addNewUser(user) { (id, revision, doc, error) in
29
            if let error = error {
30
              res.status(.internalServerError)
31
              next()
32
            } else {
33
              res.status(.OK)
34
              if let doc = doc {
35
                res.send(json: doc)
36
              } else {
37
                res.send("Something is wrong in the doc")
38
              }
39
              next()
40
            }
41
          }
42
        default:
43
          res.status(.badRequest)
44
          next()
45
      }
46
    })
47
  }
48
}

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

1
import Foundation
2
import Kitura
3

4
public class BackendRouter {
5
  public let router = Router()
6
  var db: DatabaseInteraction
7
  public init(db: DatabaseInteraction) {
8
    self.db = db
9
    router.get("/status") { req, res, callNextHandler in
10
      res.status(.OK).send("Everything is working")
11
      callNextHandler()
12
    }
13

14
    router.all("*", middleware: BodyParser())
15
    self.routeToUser()
7 collapsed lines
16
  }
17

18
  func routeToUser() {
19
    let user = UserRouter(db: self.db)
20
    user.bindAll(to: self.router)
21
  }
22
}

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

1
import Kitura
2
import HeliumLogger
3
import CouchDB
4

5
HeliumLogger.use()
6

7
let connProperties = ConnectionProperties(
8
    host: "127.0.0.1",  // httpd address
9
    port: 5984,         // httpd port
10
    secured: false,     // https or http
11
    username: "admin",  // admin username
12
    password: "password"// admin password
13
)
14

15
let db = Database(connProperties: connProperties, dbName: "swift_backend_test_db")
5 collapsed lines
16
let databaseInteraction = DatabaseInteraction(db: db)
17
let app = MainRouter(db: databaseInteraction)
18

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

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

1
SwiftBackend
2
  .gitignore
3
  |--Sources
4
    BackendRouter.swift
5
    DatabaseInteraction.swift
6
    main.swift
7
    User.swift
8
    UserRouter.swift
9
  |--Tests
10
  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 it to the cloud. But my first impression was really good. I should say that I am convinced to work on the backend side of 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.