Friday, May 24, 2024
HomeIOS DevelopmentEncoding and decoding knowledge utilizing the Hummingbird framework

Encoding and decoding knowledge utilizing the Hummingbird framework


HTTP is all about sending and receiving knowledge over the community. Initially it was solely utilized to switch HTML paperwork, however these days we use HTTP to switch CSS, JavaScript, JSON and plenty of different knowledge varieties. Based on the requirements, the Content material-Kind and Content material-Size headers can be utilized to have a greater understanding concerning the knowledge contained in the physique of the HTTP request.

Trendy internet servers can mechanically ship again these headers based mostly on the item you come back in a request handler operate. That is the case with Hummingbird, it has built-in encoding and decoding assist, which makes the information transformation course of actually easy.

For instance if we setup the next route handler and name the hiya endpoint utilizing cURL with the -i flag, the output will comprise a bit extra details about the response. โ„น๏ธ

router.get("hiya") { _ in "hiya" }
        

There are some primary headers within the response, the content-type header comprises the kind of the physique, which is presently a plain textual content with an UTF-8 encoded string, since we have returned a String kind utilizing our Swift code. The content-length is 5, as a result of the character rely of hiya is 5.

There are another headers, however ignore these, the attention-grabbing half for us is the content-type header, and the way it’s injected into the response. Each Hummingbird utility has an encoder and a decoder property. The default values for these are NullEncoder and NullDecoder. The encoders can magically add the correct content material kind header to the response and encode some object right into a HTTP response knowledge. Not all the things is response encodable and decodable by default, however you possibly can encode String objects in Hummingbird by default. ๐Ÿ‘

Encoding and decoding JSON objects

Most of the server-side Swift techniques are used to create JSON-based RESTful API backends for cellular frontends. Hummingbird will help you with this, because it has built-in encoding and decoding assist for JSON objects by the Codable protocol.

First it’s important to import the HummingbirdFoundation library, since it’s a standalone helper software constructed across the Basis framework, and that bundle comprises the Codable kind extensions. Subsequent it’s important to setup the encoder and decoder utilizing a JSONEncoder and JSONDecoder occasion. After this, you possibly can simply remodel incoming HTTP physique objects into Swift knowledge buildings and return with them as nicely. Let me present you a fast instance. โคต๏ธ

import Hummingbird
import HummingbirdFoundation

struct Foo: Codable {
    let bar: String
    let baz: Int
}

extension Foo: HBResponseCodable {}


extension HBApplication {

    func configure(_ args: AppArguments) throws {
        
        decoder = JSONDecoder()
        encoder = JSONEncoder()
        
        router.put up("foo") { req async throws -> Foo in
            guard let foo = attempt? req.decode(as: Foo.self) else {
                throw HBHTTPError(.badRequest, message: "Invalid request physique.")
            }
            return foo
        }
    }

    
}

As you possibly can see the kind of the returned content material is now correctly set to utility/json and the size can also be offered by default. We have been additionally in a position to decode the Foo object from the request physique and mechanically encode the item after we returned with it.

Codable routing works like magic and these days it is a fairly commonplace strategy if it involves server-side Swift frameworks. Enjoyable reality: this strategy was initially ‘invented’ for Swift by the builders of the Kitura framework. Thanks. ๐Ÿ™

The HBResponseCodable and the HBResponseEncodable protocols are the fundamental constructing blocks and the HBRequestDecoder and the HBResponseEncoder are answerable for this magic. They make it potential to decode a Decodable object from a HBRequest and encode issues right into a HBResponse object and in addition present extra headers. If you want to know extra, I extremely advocate to try the JSONCoding.swift file contained in the framework. ๐Ÿ˜‰

Encoding and decoding HTML varieties

I do not need to get an excessive amount of into the small print of constructing varieties utilizing HTML code, by the way in which there’s a higher approach utilizing SwiftHtml, however I might wish to focus extra on the underlying knowledge switch mechanism and the enctype attribute. There are 3 potential, however solely two helpful values of the encoding kind:

  • utility/x-www-form-urlencoded
  • multipart/form-data

URL encoding and decoding is supported out of the field when utilizing HummingbirdFoundation, it is a easy wrapper across the URL encoding mechanism to simply assist knowledge transformation.

decoder = URLEncodedFormDecoder()
encoder = URLEncodedFormEncoder()

In order that’s one solution to course of a URL encoded kind, the opposite model is predicated on the multipart strategy, which has no built-in assist in Hummingbird, however you need to use the multipart-kit library from the Vapor framework to course of such varieties. You’ll find a working instance right here. I even have an article about the best way to add recordsdata utilizing multipart kind knowledge requests. So there are many sources on the market, that is why I will not embody an instance on this article. ๐Ÿ˜…

Header based mostly encoding and decoding

First we have now to implement a customized request decoder and a response encoder. Within the decoder, we will test the Content material-Kind header for a given request and decode the HTTP physique based mostly on that. The encoder will do the very same factor, however the response physique output goes to rely upon the Settle for header area. Here is how one can implement it:

struct AppDecoder: HBRequestDecoder {
    
    func decode<T>(
        _ kind: T.Kind,
        from req: HBRequest
    ) throws -> T the place T: Decodable {
        swap req.headers["content-type"].first {
        case "utility/json", "utility/json; charset=utf-8":
            return attempt JSONDecoder().decode(kind, from: req)
        case "utility/x-www-form-urlencoded":
            return attempt URLEncodedFormDecoder().decode(kind, from: req)
        default:
            throw HBHTTPError(.badRequest)
        }
    }
}

struct AppEncoder: HBResponseEncoder {

    func encode<T>(
        _ worth: T,
        from req: HBRequest
    ) throws -> HBResponse the place T: Encodable {
        swap req.headers["accept"].first {
        case "utility/json":
            return attempt JSONEncoder().encode(worth, from: req)
        case "utility/x-www-form-urlencoded":
            return attempt URLEncodedFormEncoder().encode(worth, from: req)
        default:
            throw HBHTTPError(.badRequest)
        }
    }
}

Now if you happen to change the configuration and use the AppEncoder & AppDecoder you must have the ability to reply based mostly on the Settle for header and course of the enter based mostly on the Content material-Kind header.

import Hummingbird
import HummingbirdFoundation

struct Foo: Codable {
    let bar: String
    let baz: Int
}

extension Foo: HBResponseEncodable {}
extension Foo: HBResponseCodable {}

extension HBApplication {

    func configure(_ args: AppArguments) throws {
        
        decoder = AppDecoder()
        encoder = AppEncoder()
        
        router.put up("foo") { req async throws -> Foo in
            guard let foo = attempt? req.decode(as: Foo.self) else {
                throw HBHTTPError(.badRequest, message: "Invalid request physique.")
            }
            return foo
        }
    }
}

Be happy to mess around with some cURL snippets… ๐Ÿ‘พ

# ought to return JSON encoded knowledge
curl -i -X POST http://localhost:8080/foo 
    -H "Content material-Kind: utility/x-www-form-urlencoded" 
    -H "Settle for: utility/json" 
    --data-raw 'bar=bar&baz=42'

# ought to return URL encoded knowledge
curl -i -X POST http://localhost:8080/foo 
    -H "Content material-Kind: utility/json" 
    -H "Settle for: utility/x-www-form-urlencoded" 
    --data-raw '{"bar": "bar", "baz": 42}'

# ought to return with a 400 standing code
curl -i -X POST http://localhost:8080/foo 
    -H "Content material-Kind: utility/json" 
    -H "Settle for: multipart/form-data" 
    --data-raw '{"bar": "bar", "baz": 42}'

So, based mostly on this text you must have the ability to implement assist to much more content material varieties by merely extending the app encoder and decoder. After all you might need to import some extra bundle dependencies, however that is wonderful.

Uncooked requests and responses

Yet another little factor, earlier than I finish this text: you possibly can entry the uncooked request physique knowledge and ship again a uncooked response utilizing the HBResponse object like this:

router.put up("foo") { req async throws -> HBResponse in
    
    if let buffer = req.physique.buffer {
        let rawInputData = buffer.getData(
            at: 0,
            size: buffer.readableBytes
        )
        print(rawInputData)
    }
    
    
    if let sequence = req.physique.stream?.sequence {
        for attempt await chunk in sequence {
            print(chunk)
        }
    }
    
    guard let knowledge = "hiya".knowledge(utilizing: .utf8) else {
        throw HBHTTPError(.internalServerError)
    }
    
    return .init(
        standing: .okay,
        headers: .init(),
        physique: .byteBuffer(.init(knowledge: knowledge))
    )
}

For smaller requests, you need to use the req.physique.buffer property and switch it right into a Information kind if wanted. Hummingbird has nice assist for the brand new Swift Concurreny API, so you need to use the sequence on the physique stream if you happen to want chunked reads. Now just one query left:

What varieties ought to I assist?

The reply is straightforward: it relies upon. Like actually. These days I began to ditch multipart encoding and I choose to speak with my API utilizing REST (JSON) and add recordsdata as uncooked HTTP physique. I by no means actually needed to assist URL encoding, as a result of if you happen to submit HTML varieties, you may ultimately face the necessity of file add and that will not work with URL encoded varieties, however solely with multipart.

In conclusion I might say that the excellent news is that we have now loads of alternatives and if you wish to present assist for many of those varieties you do not have to reinvent the wheel in any respect. The multipart-kit library is constructed into Vapor 4, however that is one of many causes I began to love Hummingbird a bit extra, as a result of I can solely embody what I actually need. Anyway, competitors is an efficient factor to have on this case, as a result of hopefully each frameworks will evolve for good… ๐Ÿ™ƒ

RELATED ARTICLES

LEAVE A REPLY

Please enter your comment!
Please enter your name here

Most Popular

Recent Comments