Latest 1.0.4
License MIT
Platforms ios 9.0
Dependencies PromiseKit, PromiseKit/Alamofire, Alamofire, AlamofireObjectMapper, ObjectMapper


I would like to present you an easy way to communicate with your API. It’s light network layer, which in all cases guided by SOLID principles.



Network layer consists of six parts:

  • Environment
  • Request
  • Response
  • Operation
  • Dispatcher
  • Service


Describes your API information: the host URL, the caching policy, also contains a headers property, which can be global for all your requests.


Describes your network request. You can create any request you want: GET, POST, DELETE, etc. Also, you can create a download request if needed.


An object, which contains information about data you received from the request by the operation, which described below. It can be a local file, mapped object, etc.


An instance, which consists of the strongly typed requests and response objects. It executes by the dispatcher.


The Dispatcher responsible for the executes a request. By default, the library has two dispatchers, called Network Dispatcher and Download Dispatcher, but you could inherit Base Dispatcher and write your own class if needed.


And the last one is Service. A service is an object, which executes your operations by dispatchers you provided.


  • Swift >= 3.0
  • iOS >= 8.0


PowerfulNetworkLayer is available through CocoaPods. To install it, simply add the following line to your Podfile:

pod 'PowerfulNetworkLayer'


After installation library via CocoaPods dependency manager, you could import this library by writing next command in files, which will be using it.

import PowerfulNetworkLayer

If you want to create custom request, for example, request to send (POST data) some information, you could write code like below:

import Foundation
import Alamofire
import PowerfulNetworkLayer

final class SignUpRequest: BaseRequest<DataRequest> {
    private let email: String
    private let firstName: String
    private let lastName: String
    private let password: String

    override var path: String {
        return "auth/signup"

    override var method: HTTPMethod {
        return .post

    override var encoding: ParameterEncoding {
        return JSONEncoding()

    override var parameters: Parameters {
        return [
            "email" : email,
            "first_name" : firstName,
            "last_name" : lastName,
            "password" : password

    init(email: String, firstName: String, lastName: String, password: String) { = email
        self.firstName = firstName
        self.lastName = lastName
        self.password = password

You also could create a response (if needed), the code looks like this:

import Foundation
import ObjectMapper
import PowerfulNetworkLayer

final class SignUpResponse: Response, Mappable {
    let user: User
    let token: AccessToken

    required init?(map: Map) { }

    func mapping(map: Map) {
        user <- map["user"]
        token <- map["access_token"]

Each request should not exist without operation. The operation initialized with the request, which executes and returns a response by promise.
You could override execute method in inherited Operation class and saved some properties in service if needed like below.

import Foundation
import PromiseKit
import PowerfulNetworkLayer

final class SignUpOperation: DispatchOperation<SignUpRequest, SignUpResponse> {
    override func execute<ServiceType>(
        in dispatcher: Dispatcher,
        by service: ServiceType
    ) -> Promise<SignUpResponse>
        where ServiceType : AuthService {
            return super.execute(in: dispatcher, by: service).tap { result in
                switch result {
                    case .fulfilled(let response):
                        service.user = response.user

                    case .rejected(_):

Also, you have an example project, where you can see how to use this framework.


Latest podspec

    "name": "PowerfulNetworkLayer",
    "version": "1.0.4",
    "summary": "Light way to communicate with your API.",
    "description": "I would like to present you an easy way to communicate with your API. Its light network layer, which in all cases guided by SOLID principles.",
    "homepage": "",
    "license": {
        "type": "MIT",
        "file": "LICENSE"
    "authors": {
        "AndrewKochulab": "[email protected]"
    "source": {
        "git": "",
        "tag": "master",
        "branch": "master"
    "platforms": {
        "ios": "9.0"
    "source_files": "PowerfulNetworkLayer/Classes/**/*",
    "dependencies": {
        "PromiseKit": [
            "~> 6.2"
        "PromiseKit/Alamofire": [],
        "Alamofire": [
            "~> 4.7"
        "AlamofireObjectMapper": [
            "~> 5.0"
        "ObjectMapper": [
            "~> 3.1"

Pin It on Pinterest

Share This