Swift on server – Part 3: Handling Date type with Vapor / PostgreSQL
In this Part 3 (final one), I’ll show you how to handle Date types. This works with PostgreSQL, should work about the same with MariaDB/MySQL, but couldn’t make it work with MongoDB (see the conclusion for a tip).
If you missed:
– In Part 1 of this series of articles I went through installing Swift, Vapor and PostgreSQL.
– In Part 2 I created an app using Vapor and do the saving and retrieving of an object from the Postgres database. The model us just basic types Int & String (Double is also supported by Vapor).
Vapor 2.0 (and Fluent 2.0 – the database framework used by Vapor) are currently in alpha versions. The final releases should include date handling. Since then, here’s my workaround.
So at this time the User model looks like:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 |
import Foundation import Vapor struct User: Model { var exists: Bool = false var id: Node? let name: String let lastconnection: String? let points: Int? init(name: String, lastconnection: String?, points: Int?) { self.name = name self.lastconnection = lastconnection self.points = points } //Intializable from a Node init(node: Node, in context: Context) throws { id = try node.extract("id") name = try node.extract("name") lastconnection = try node.extract("lastconnection") points = try node.extract("points") } //Node represantable func makeNode(context: Context) throws -> Node { return try Node(node: ["id": id, "name": name, "lastconnection": lastconnection, "points": points]) } //Database preparation static func prepare(_ database: Database) throws { try database.create("users") {users in users.id() users.string("name") users.int("points", optional: true) users.string("lastconnection", optional: true) } } static func revert(_ database: Database) throws { try database.delete("users") } } |
First, let’s change the prepare function to make a Timestamp type column instead of Varchar for lastconnection.
|
1 2 3 4 5 6 7 8 9 |
//Database preparation static func prepare(_ database: Database) throws { try database.create("users") {users in users.id() users.string("name") users.int("points", optional: true) users.custom("lastconnection", type: "TIMESTAMP", optional: true) } } |
As Timestamp (or DateTime for MariaDB/MySQL) is not a basic type known by the framework we have to use the custom type and precise the database specific type.
Next let’s change the User model’s lastconnection type to Date:
|
1 |
let lastconnection: Date? |
And fix the init:
|
1 2 3 4 5 |
init(name: String, lastconnection: Date?, points: Int?) { self.name = name self.lastconnection = lastconnection self.points = points } |
Now the delicate part, fixing init(node…) and makeNode functions.
The Node type does not handle Date, so the workaround in order to keep the database column as Date/Timestamp is to transform it from String to Date when read from database, and from Date to String when writing to database. This works because Postgres and MariaDB/MySQL return the Timestamp type (for Postgres, DateTime for MariaDB) as String. Just connect to your database and do a Select on a table with a Timestamp column and you’ll see.
So let’s write transformation functions from Date to String and from String to Date.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
extension User { static func dateFromString(_ dateAsString: String?) -> Date? { guard let string = dateAsString else { return nil } let dateformatter = DateFormatter() dateformatter.timeZone = TimeZone(identifier: "France/Paris") dateformatter.dateFormat = "yyyy-MM-dd HH:mm:ss.SSSS" let val = dateformatter.date(from: string) return val } static func dateToString(_ dateIn: Date?) -> String? { guard let date = dateIn else { return nil } let dateformatter = DateFormatter() dateformatter.timeZone = TimeZone(identifier: "France/Paris") dateformatter.dateFormat = "yyyy-MM-dd HH:mm:ss.SSSS" let val = dateformatter.string(from: date) return val } } |
You can also extend the Date class with these functions instead of a specific model if you want to share the functions between several models. In this example we just have one model, so I just added them to the model.
And let’s use them.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
//Intializable from a Node init(node: Node, in context: Context) throws { id = try node.extract("id") name = try node.extract("name") lastconnection = try node.extract("lastconnection", transform: User.dateFromString) points = try node.extract("points") } //Node represantable func makeNode(context: Context) throws -> Node { return try Node(node: ["id": id, "name": name, "lastconnection": User.dateToString(lastconnection), "points": points]) } |
And then, let’s fix main.swift
Change users route to:
|
1 2 3 4 5 6 7 8 9 |
drop.get("users") { req in let users = [User(name: "Tim", lastconnection: User.dateFromString("2017-02-12 13:21:12.2837"), points: 12), User(name: "Craig", lastconnection: User.dateFromString("2017-02-17 08:34:52.1353"), points: 39), User(name: "Phil", lastconnection: User.dateFromString("2017-02-18 20:15:31.3241"), points: nil) ] return try JSON(node: users.makeNode()) } |
And the createusers route:
|
1 2 3 4 5 6 7 8 9 10 11 |
drop.get("createusers") { req in var user = User(name: "Tim", lastconnection: Date(), points: 12) try user.save() user = User(name: "Craig", lastconnection: User.dateFromString("2017-02-17 08:34:52.1353"), points: 39) try user.save() user = User(name: "Phil", lastconnection: nil, points: nil) try user.save() return "Users created" } |
Now build the project:
|
1 |
$ vapor build |
Before running, let’s revert the previous created table.
For that, run in a terminal:
|
1 2 3 4 5 6 7 8 |
$ vapor run prepare --revert Running testdate... Are you sure you want to revert the database? y/n>y Reverting User Reverted User Removing metadata Reversion complete |
and answer y when asked.
If you check the Postgres database you should no longer see fluent and users tables.
Now ready for run:
|
1 |
$ vapor run |
If we check the database there should be a Users table looking like:
|
1 2 3 4 5 6 7 8 |
> \d+ users Column | Type | ----------------+-----------------------------+ id | integer | name | character varying(255) | points | integer | lastconnection | timestamp without time zone | |
And if you browse to the url: http://localhost:8080/createusers
and check the database you should see the users:
|
1 2 3 4 5 6 7 |
> select * from users; id | name | points | lastconnection ----+-------+--------+------------------------- 25 | Tim | 12 | 2017-02-23 06:24:41.179 26 | Craig | 39 | 2017-02-17 08:34:52.135 27 | Phil | | (3 rows) |
And you should also get the same if you browse to the url: http://localhost:8080/allusers
|
1 |
[{"id":1,"lastconnection":"2017-02-23 06:37:50.1710","name":"Tim","points":12},{"id":2,"lastconnection":"2017-02-17 08:34:52.1350","name":"Craig","points":39},{"id":3,"lastconnection":null,"name":"Phil","points":null}] |
Also works the creation of a new user using the Rest client and POST to the route: http://localhost:8080/user
So to finish here’s the final main.swift:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 |
import Vapor import Foundation import VaporPostgreSQL let drop = Droplet( preparations: [User.self], providers: [VaporPostgreSQL.Provider.self] ) drop.get { req in return try drop.view.make("welcome", [ "message": drop.localization[req.lang, "welcome", "title"] ]) } drop.get("users") { req in let users = [User(name: "Tim", lastconnection: User.dateFromString("2017-02-12 13:21:12.2837"), points: 12), User(name: "Craig", lastconnection: User.dateFromString("2017-02-17 08:34:52.1353"), points: 39), User(name: "Phil", lastconnection: nil, points: nil) ] return try JSON(node: users.makeNode()) } drop.post("user") { req in var user = try User(node: req.json) try user.save() return try user.makeJSON() } drop.get("allusers") { req in return try JSON(node: User.all().makeNode()) } drop.get("createusers") { req in var user = User(name: "Tim", lastconnection: Date(), points: 12) try user.save() user = User(name: "Craig", lastconnection: User.dateFromString("2017-02-17 08:34:52.1353"), points: 39) try user.save() user = User(name: "Phil", lastconnection: nil, points: nil) try user.save() return "Users created" } drop.resource("posts", PostController()) drop.run() |
And User.swift:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 |
import Foundation import Vapor struct User: Model { var exists: Bool = false var id: Node? let name: String let lastconnection: Date? let points: Int? init(name: String, lastconnection: Date?, points: Int?) { self.name = name self.lastconnection = lastconnection self.points = points } //Intializable from a Node init(node: Node, in context: Context) throws { id = try node.extract("id") name = try node.extract("name") lastconnection = try node.extract("lastconnection", transform: User.dateFromString) points = try node.extract("points") } //Node represantable func makeNode(context: Context) throws -> Node { return try Node(node: ["id": id, "name": name, "lastconnection": User.dateToString(lastconnection), "points": points]) } //Database preparation static func prepare(_ database: Database) throws { try database.create("users") {users in users.id() users.string("name") users.int("points", optional: true) users.custom("lastconnection", type: "TIMESTAMP", optional: true) } } static func revert(_ database: Database) throws { try database.delete("users") } } extension User { static func dateFromString(_ dateAsString: String?) -> Date? { guard let string = dateAsString else { return nil } let dateformatter = DateFormatter() dateformatter.timeZone = TimeZone(identifier: "France/Paris") dateformatter.dateFormat = "yyyy-MM-dd HH:mm:ss.SSSS" let val = dateformatter.date(from: string) return val } static func dateToString(_ dateIn: Date?) -> String? { guard let date = dateIn else { return nil } let dateformatter = DateFormatter() dateformatter.timeZone = TimeZone(identifier: "France/Paris") dateformatter.dateFormat = "yyyy-MM-dd HH:mm:ss.SSSS" let val = dateformatter.string(from: date) return val } } |
That’s the trick, just transform Date to String and String to Date. Pay attention to the format (MySQL does not have the milliseconds).
It took me some time to figure it out, especially as I started with a MongoDB database at first where the trick it doesn’t work (I guess you can achieve the same result with MongoDB using a Timestamp type for the column instead of Date and transforming from Int to Date and Date to Int, but I didn’t want to change my database column format). I did found a lot of Vapor tutorials (big shout out to Ray Wenderlich‘s screencasts who initiated me to Swift on Server using Vapor) but none was using dates.
If anyone else is struggling with this, I hope these posts will help.