This is my presentation from TechBeats #3 hosted by Applause about Server-Side Swift framework called Vapor. Swift is a great language and possibility of using it also in backend is a huge benefit for any iOS developer out there. Using Vapor is a seamless experience. With this framework creating advance APIs by iOS developer is as easy as writing simple iOS app. https://www.meetup.com/TechBeats-hosted-by-Applause/events/254910023/

2. Vapor
(Server-side Swift)

3. Swift
• Multi-paradigm
• Statically typed
• Fast
(https://benchmarksgame-team.pages.debian.net/benchmarksgame/faster/swift.html)
• Safe
• Easy to understand
• Open Source
• Community

4. Where it all started

5. Swift NIO
SwiftNIO is a cross-platform asynchronous event-driven network application
framework for rapid development of maintainable high performance protocol
servers & clients.
https://www.youtube.com/watch?v=QJ3WG9kRLMo

6. How to start
brew install vapor/tap/vapor apt-get install vapor -y

7. Check compatibility
eval "$(curl -sL check.vapor.sh)
And the output should look something like this
⚠ Xcode 10 support hasn't been tested yet.
ℹ Xcode 10 should be compatible with Vapor 2.
ℹ Xcode 10 should be compatible with Vapor 3.
⚠ Swift 4.2 support hasn't been tested yet.
ℹ Swift 4.2 should be compatible with Vapor 2.
ℹ Swift 4.2 should be compatible with Vapor 3.

8. First App
vapor new TestApp
cd TestApp
vapor build
vapor run
http://localhost:8080/hello/

9. Xcode project
No Xcode project 😱

10. Generate Xcode project
vapor xcode -y

11. What Xcode gives you
• All That fun stuff that it already has
• Debugging

12. Let us dive inside vapor
magic

13. Swift Package Manager
(SPM)

14. Routes
//routes.swift
import Vapor
public func routes(_ router: Router) throws {
router.get { req in
return "It works!"
}
router.get("hello") { req in
return "Hello, world!"
}
}
• http://localhost:8080/
• http://localhost:8080/hello/

15. Routes with parameters
router.get("hello", String.parameter) { req -> String in
let name = try req.parameters.next(String.self)
return "Hello, (name)!"
}
• http://localhost:8080/hello/Anna/

16. Route grouping
router.group("hello") { (router) in
router.get { req in
return "Hello, world!"
}
router.get(String.parameter) { req -> String in
let name = try req.parameters.next(String.self)
return "Hello, (name)!"
}
}

17. Route Collection
Conformance to RouteCollection
// HelloRoutesCollection.swift
final class HelloRoutesCollection: RouteCollection {
func boot(router: Router) throws {
router.group("hello") { (router) in
router.get { req in
return "Hello, world!"
}
router.get(String.parameter) { req -> String in
let name = try req.parameters.next(String.self)
return "Hello, (name)!"
}
}
}
}
//routes.swift
try router.register(collection: HelloRoutesCollection())

18. Clean this with Controller.
// HelloController.swift
final class HelloController {
func hello(_ req: Request) -> String {
return "Hello, world!"
}
func personalHello(_ req: Request) throws -> String {
let name = try req.parameters.next(String.self)
return "Hello, (name)!"
}
}
// HelloRoutesCollection.swift
router.group("hello") { (router) in
router.get("", use: controller.hello)
router.get(String.parameter, use:
controller.personalHello)
}

19. Current Route
routes.swift HelloRoutesCollection HelloController

20. Accepting data
// HelloMessage.swift
struct HelloMessage: Content {
let message: String
}
// HelloController.swift
func postHelloMessage(_ req: Request, _ message: HelloMessage) throws -> String {
return message.message + "n"
}
// HelloRoutesCollection.swift
router.post(HelloMessage.self, at: "", use: controller.postHelloMessage)
curl -d '{"message": "hello vapor"}' --header "content-type: application/json" http://localhost:8080/hello/

21. Returning JSON
func postHelloMessage(_ req: Request, _ message: HelloMessage) throws -> HelloMessage {
return HelloMessage(message: "Hello you”)
}
{
"message": "Hello you"
}

22. Troubleshooting
• `vapor xcode -y` - To fix configuration
errors or missing files in project
• `vapor update` - updating dependencies
• `rm -rf .build` - this will remove all build
artifacts

23. Async in Vapor

24. Async code in Vapor
Concept of Future
func getHelloMessages(_ req: Request) throws -> [HelloMessage] {
func getHelloMessages(_ req: Request) throws -> Future<[HelloMessage]> {
func imaginary(_ req: Request) throws -> Future<[Story]> {
let client = try req.make(Client.self)
let url = "https://stories-fetcher.herokuapp.com/hnproxy/topStories/"
return client.send(.GET, to: url)
.flatMap(to: [Story].self, { (response) -> EventLoopFuture<[Story]> in
return try response.content.decode([Story].self)
})
}

25. flatMap()
• Use it when Promise closure returns a Future
• When you want to unpack value and work with raw data

26. map()
• When Promise returns anything else than Future
• To map result from long operation in Future

27. transform
• When you don’t care about result data only want to know
about result status (success/failure)
func imaginary(_ req: Request) throws -> Future<HTTPStatus> {
let client = try req.make(Client.self)
let url = "https://stories-fetcher.herokuapp.com/hnproxy/topStories/"
return client.send(.GET, to: url).transform(to: HTTPStatus.noContent)
}

28. Future - multiple features
• To wait for multiple Futures to end
func imaginary(_ req: Request) throws -> Future<HTTPStatus> {
let client = try req.make(Client.self)
let url = "https://stories-fetcher.herokuapp.com/hnproxy/topStories/"
return map(to: HTTPStatus.self,
try req.content.decode(Story.self),
client.send(.GET, to: url)) { (parameter, response) -> (HTTPStatus) in
return HTTPStatus.noContent
}
}

29. Manual Future
func imaginary(_ req: Request) throws -> Future<HTTPStatus> {
return req.future(HTTPStatus.noContent)
}

30. Error handling
• do{…}.catch{…}
• catchMap{…}
• catchFlatMap{…}

31. Chaining futures
• flatMap and map can be chained
func imaginary(_ req: Request) throws -> Future<HTTPStatus> {
let client = try req.make(Client.self)
let url = "https://stories-fetcher.herokuapp.com/hnproxy/topStories/"
return client.send(.GET, to: url)
.flatMap(to: [Story].self, { (response) -> EventLoopFuture<[Story]> in
return try response.content.decode([Story].self)
}).flatMap(to: HTTPStatus.self, { (_) -> EventLoopFuture<HTTPStatus> in
return req.future(.ok)
})
}

32. always
func imaginary(_ req: Request) throws -> Future<HTTPStatus> {
let _ = try req.content.decode(Story.self).always {
print("This code will execute always")
}
return req.future(.ok)
}
When you need something to execute always, no matter the
result

33. wait
• Mostly not usable in code 💥
func imaginary(_ req: Request) throws -> Future<HTTPStatus> {
let client = try req.make(Client.self)
let url = "https://stories-fetcher.herokuapp.com/hnproxy/topStories/"
let stories = try client.send(.GET, to: url).flatMap(to: [Story].self)
{ (response) -> EventLoopFuture<[Story]> in
return try response.content.decode([Story].self)
}.wait()
return req.future(.ok)
}

34. Fluent
• Mapping between objects with CRUD support
• Querying data
• Relationships
• Session live cache
• Custom queries
• Transaction support
• Migrations
• Numerous database types support

35. Supported types

36. How to add persistence
//configure.swift
let sqlite = try SQLiteDatabase(storage: .memory)
var databases = DatabasesConfig()
databases.add(database: sqlite, as: .sqlite)
services.register(databases)

37. Defining your first model
import FluentSQLite
struct HelloMessage: Content {
var id: Int?
let message: String
}
extension HelloMessage: Model {
typealias Database = SQLiteDatabase
typealias ID = Int
static var idKey: IDKey = HelloMessage.id
}

38. Is it really all?
//HelloMessage.swift
extension HelloMessage: Migration {}
//configure.swift
var migrations = MigrationConfig()
migrations.add(model: HelloMessage.self, database: .sqlite)
services.register(migrations)

39. Migrations
extension HelloMessage: Migration {
static func prepare(on connection: SQLiteConnection) -> Future<Void> {
}
}

40. What can we do now?
func messeges(_ req: Request) throws -> Future<[HelloMessage]> {
return HelloMessage.query(on: req).all()
}
func newMessage(_ req: Request) throws -> Future<HelloMessage> {
let message = try req.content.decode(HelloMessage.self)
return message.save(on: req)
}
func editMessage(_ req: Request, _ message: HelloMessage) throws -> Future<HelloMessage> {
return try req.content.decode(HelloMessage.self).flatMap({ (newMessage) ->
EventLoopFuture<HelloMessage> in
let edited = HelloMessage(id: message.id, message: newMessage.message)
return edited.save(on: req)
})
}
func delete(_ req: Request) throws -> Future<HTTPStatus> {
return try req.parameters.next(HelloMessage.self)
.flatMap({ (message) -> EventLoopFuture<HTTPStatus> in
return message.delete(on: req).transform(to: .ok)
})
}

41. Hosting
https://www.heroku.com/ https://vapor.cloud/ https://www.digitalocean.com/

42. Vapor cloud
• Create an account (https://dashboard.vapor.cloud/)
• Prepare deploy cloud.yml
type: "vapor"
swift_version: "4.1.0"
run_parameters: "serve --port 8080 --hostname 0.0.0.0"
https://docs.vapor.cloud/configuration/general/

43. Vapor CLI Tool
• vapor cloud login
• vapor cloud deploy
• Configure repo (ssh/https)
• Create Project
• Select Organisation
• Name the project
• Provide application Slug (https://<slug>.vapor.cloud)
• Setup Environment
• DB selection
• Build type (incremental, update, clean)

44. Leaf Templates
// Package.swift
.package(url: "https://github.com/vapor/leaf.git", from: “3.0.0-rc")
.target(name: "App", dependencies: ["FluentSQLite", "Vapor", “Leaf”])
//configure.swift
try services.register(LeafProvider())
config.prefer(LeafRenderer.self, for: ViewRenderer.self)
vapor update
Updating [Done]
Changes to dependencies usually require Xcode to be regenerated.
Would you like to regenerate your xcode project now?
y/n> y
Generating Xcode Project [Done]
Select the `Run` scheme to run.
Open Xcode project?
y/n> y
Opening Xcode project...

45. Rendering page
• Create index.leaf view in Resources/Views directory
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8" />
<title>Hello Leaf</title>
</head>
<body>
<h1>Hello Leaf</h1>
</body>
</html>
• Add new route for index and inside render index view
router.get("index") { (req) -> Future<View> in
return try req.view().render("index")
}

46. Injecting context
struct IndexContext: Encodable {
let title: String
}
<title>#(title)</title>
router.get("index") { (req) -> Future<View> in
let context = IndexContext(title: "Home Sweet Home")
return try req.view().render("index", context)
}

47. More about Leaf
• Conditions with #if {} else if {} else {}…
• Loops #for…in…{}
• Content embedding with #embed #set
• Custom tag operations like
• Date formatting with #date
• Text formatting with #capitalize and #lowercase
• Many more

48. Authentication
• Base Authentication
• Token Authentication
• Session
• OAuth 2.0

49. Passwords
import Crypto
self.password = try BCrypt.hash(password)
let password = User.basicAuthMiddleware(using: BCryptDigest())

50. Adding Auth
// Package.swift
.package(url: "https://github.com/vapor/auth.git",from: “2.0.0-rc")
.target(name: "App", dependencies: ["FluentSQLite", "Vapor", "Leaf", "Authentication"]),
vapor update

51. Auth
Conformance
extension User: BasicAuthenticatable {
static var usernameKey: IDKey = User.name
static var passwordKey: IDKey = User.password
}
extension User: PasswordAuthenticatable {
static var usernameKey: IDKey = User.name
static var passwordKey: IDKey = User.password
}
extension User: TokenAuthenticatable {
typealias TokenType = UserToken
}
struct UserToken: Model {
var id: Int?
var string: String
var userID: User.ID
var user: Parent<UserToken, User> {
return parent(.userID)
}
}

52. Make Auth Work
// configure.swift
try services.register(AuthenticationProvider())
let basicMiddleware = User.basicAuthMiddleware(using: BCryptDigest())
let guardAuthMiddleware = User.guardAuthMiddleware()
let protectedRouter = router.grouped([basicMiddleware, guardAuthMiddleware])
protectedRouter.get { req in
return "It works only in auth"
}

53. Session
extension User: PasswordAuthenticatable {}
extension User: SessionAuthenticatable {}
middlewares.use(SessionsMiddleware.self)
config.prefer(MemoryKeyedCache.self, for: KeyedCache.self)
let authSessionRoutes = router.grouped(User.authSessionsMiddleware())

54. OAuth 2.0
• Imperial (https://github.com/vapor-community/
Imperial.git)
• Create and setup project in Google console
• Create dedicated RouteCollection controller to handle
Google login
• Add env variables with Google client id and secret

55. Testing
.testTarget(name: "AppTests", dependencies: ["App"])
Change project Scheme for Testing
final class AppTests: XCTestCase {
func testNothing() throws {
// add your tests here
XCTAssert(true)
}
static let allTests = [
("testNothing", testNothing)
]
}

56. App in tests
override func setUp() {
var config = Config.default()
var services = Services.default()
var env = Environment.testing
try! App.configure(&config, &env, &services)
app = try! Application(config: config,
environment: env,
services: services)
}

57. Endpoint test
func testHelloMessage() throws {
let request = HTTPRequest(method: .GET,
url: "/hello")
let wrapper = Request(http: request, using: app)
let responder = try! app.make(Responder.self)
let response = try! responder.respond(to: wrapper).wait()
let message = String(data: response.http.body.data!, encoding: .utf8)
XCTAssertEqual(message, "Hello, world!", "Wrong response from /hello")
}

58. Cache
• In Memory Cache
• Database Cache
• Redis

59. Middleware
• ErrorMiddleware
• FileMiddleware
func respond(to request: Request, chainingTo next: Responder) throws -> Future<Response>

60. websockets
let ws = NIOWebSocketServer.default()
ws.get("echo") { (ws, req) in
ws.onText({ (ws, str) in
ws.send(str)
})
}

61. Resources
• https://docs.vapor.codes/3.0/

62. Other
Options
https://www.kitura.io/ https://www.perfect.org/

63. Questions?

64. Thanks
https://riamf.github.io/
@riamf1
https://github.com/riamf