@dazn/kopytko-framework 1.4.2 → 2.0.0

package/README.md

@@ -6,6 +6,8 @@ and improving its maintainability overall. It is highly inspired by the Javascri
 of its patterns as well as its API, making it extremely friendly for someone coming from a React components environment.
 It is also inspired by router of the Javascript Angular framework and some other mechanisms taken from the Javascript world.
 
+# Kopytko Roku Ecosystem
+
 Kopytko Framework is part of Kopytko Roku Ecosystem which consists of:
 - [Kopytko Framework](https://github.com/getndazn/kopytko-framework),
 - [Kopytko Utils](https://github.com/getndazn/kopytko-utils) - a collection of modern utility functions for Brightscript applications,
@@ -28,3 +30,7 @@ and used in apps configured by Kopytko Packager.
 - Store: a mechanism to store reusable data. Docs available in [docs/store.md](docs/store.md)
 - Theme: manages UI configuration and allows easy use in any place. Full documentation available in [docs/theme.md](docs/theme.md)
 
+
+## Versions migration
+
+To update Kopytko Framework to the latest major version, please follow the [Versions migration guide](docs/versions-migration-guide.md)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dazn/kopytko-framework",
-  "version": "1.4.2",
+  "version": "2.0.0",
   "description": "A modern Roku's Brightscript framework",
   "keywords": [
     "brightscript",
@@ -25,12 +25,12 @@
     "test": "node node_modules/@dazn/kopytko-unit-testing-framework/scripts/test.js"
   },
   "dependencies": {
-    "@dazn/kopytko-utils": "^2.2.2"
+    "@dazn/kopytko-utils": "^2.3.2"
   },
   "devDependencies": {
     "@dazn/eslint-plugin-kopytko": "^2.1.0",
     "@dazn/kopytko-packager": "^1.2.3",
-    "@dazn/kopytko-unit-testing-framework": "^2.0.1",
+    "@dazn/kopytko-unit-testing-framework": "^2.3.1",
     "eslint": "^8.21.0"
   },
   "license": "MIT",

package/src/components/http/HttpRequest.brs

@@ -9,6 +9,7 @@
 ' @property {String} url
 ' @property {Object} queryParams
 ' @property {String} method
+' @property {Boolean} compression
 ' @property {Object} headers
 ' @property {Integer} timeout
 ' @property {Object} body
@@ -27,6 +28,7 @@ function HttpRequest(options as Object, httpInterceptors = [] as Object) as Obje
     "Accept": "application/json",
   }
 
+  prototype._headers = prototype._DEFAULT_HEADERS
   prototype._httpInterceptors = httpInterceptors
   prototype._options = options
   prototype._urlTransfer = UrlTransfer()
@@ -49,12 +51,10 @@ function HttpRequest(options as Object, httpInterceptors = [] as Object) as Obje
       m._urlTransfer.initClientCertificates()
     end if
 
-    headers = m._DEFAULT_HEADERS
     if (Type(m._options.headers) = "roAssociativeArray")
-      headers.append(m._options.headers)
+      m._headers.append(m._options.headers)
     end if
 
-    m._urlTransfer.setHeaders(headers)
     m._timeout = ternary(m._options.timeout <> Invalid AND m._options.timeout <> 0, m._options.timeout, m._FALLBACK_TIMEOUT)
 
     return m
@@ -63,13 +63,18 @@ function HttpRequest(options as Object, httpInterceptors = [] as Object) as Obje
   ' Performs actual request.
   ' @returns {Object} - Returns instance
   prototype.send = function () as Object
+    method = m.getMethod()
+
+    if (method <> "POST" AND method <> "PUT") then m._headers.delete("Content-Type")
+    m._urlTransfer.setHeaders(m._headers)
+
     for each interceptor in m._httpInterceptors
       interceptor.interceptRequest(m, m._urlTransfer)
     end for
 
-    if (m._options.method = "GET")
+    if (method = "GET")
       m._urlTransfer.asyncGetToString()
-    else if (m._options.method = "POST" OR m._options.method = "PUT" OR m._options.method = "DELETE")
+    else if (method = "POST" OR method = "PUT" OR method = "DELETE")
       body = ""
 
       if (m._options.body <> Invalid)
@@ -119,6 +124,16 @@ function HttpRequest(options as Object, httpInterceptors = [] as Object) as Obje
     return m._urlTransfer.getUrl()
   end function
 
+  ' @returns {String}
+  prototype.getEscapedUrl = function () as String
+    return m._urlTransfer.escape(m.getUrl())
+  end function
+
+  ' @returns {String}
+  prototype.getMethod = function () as String
+    return m._options.method
+  end function
+
   ' Cancels request that times out.
   ' @returns {Boolean}
   prototype.isTimedOut = function () as Boolean
@@ -131,6 +146,15 @@ function HttpRequest(options as Object, httpInterceptors = [] as Object) as Obje
     return isTimedOut
   end function
 
+  ' @returns {Boolean}
+  prototype.isCachingEnabled = function () as Boolean
+    return getProperty(m.options, "enableCaching", true)
+  end function
+
+  prototype.setHeader = sub (name as String, value as Dynamic)
+    m._headers[name] = value
+  end sub
+
   ' Aborts active request.
   prototype.abort = sub ()
     m._urlTransfer.asyncCancel()

package/src/components/http/HttpResponse.brs

@@ -1,91 +1,132 @@
-' @import /components/getProperty.brs from @dazn/kopytko-utils
-
-' The HttpResponse object
-' @typedef {Object} HttpResponse~HttpResponseNode
-' @property {String} id
-' @property {Integer} httpStatusCode
-' @property {Object} rawData
-' @property {Object} requestOptions
-' @property {Node} data
-' @property {String} ?failureReason
-
-' The class parses response to JSON when application/json mimetype is detected.
-' WARNING: the class must be used on the Task threads.
+' @import /components/rokuComponents/DateTime.brs from @dazn/kopytko-utils
+' @import /components/http/HttpStatusCodes.const.brs
+' @import /components/utils/imfFixdateToSeconds.brs
+
 ' @class
-' @param {Object} response
-' @param {String} response.id
-' @param {String} response.rawData
-' @param {Integer} response.httpStatusCode
-' @param {String} response.failureReason
-' @param {Object} response.headers
-' @param {Object} response.requestOptions
-function HttpResponse(response as Object) as Object
+' @param {Object} responseData
+' @param {Object} responseData.content
+' @param {String} responseData.id
+' @param {String} responseData.failureReason
+' @param {Object} responseData.headers
+' @param {Integer} responseData.httpStatusCode
+' @param {Object} responseData.requestOptions
+' @param {Integer} [responseData.time]
+function HttpResponse(responseData as Object) as Object
   prototype = {}
 
-  prototype._HTTP_SUCCESS = 200
-  prototype._HTTP_FAILURE = 400
-  prototype._ACCEPTED_CONTENT_TYPE = "application/json"
-  prototype._CONTENT_TYPE_HEADER = "content-type"
-
-  prototype._id = Invalid
-  prototype._data = {}
-  prototype._httpStatusCode = -1
-  prototype._headers = {}
-  prototype._requestOptions = Invalid
-  prototype._isSuccess = Invalid
-  prototype._failureReason = "OK"
-
-  ' @constructor
-  ' @param {Object} m - instance reference
-  ' @param {Object} response
-  _constructor = function (m as Object, response as Object) as Object
-    if (Type(response.headers) = "roAssociativeArray")
-      m._headers = response.headers
-    end if
-
-    isAcceptedContentType = (getProperty(m._headers, [m._CONTENT_TYPE_HEADER], "").instr(m._ACCEPTED_CONTENT_TYPE) > -1)
-    if (isAcceptedContentType AND getProperty(response, ["rawData"], "") <> "")
-      m._data = ParseJSON(response.rawData)
+  prototype.MAX_AGE_NOT_ALLOWED = -1
+  prototype._CACHE_CONTROL_MAX_AGE = "max-age="
+  prototype._CACHE_CONTROL_NO_CACHE = "no-cache"
+  prototype._CACHE_CONTROL_NO_STORE = "no-store"
+  prototype._HEADER_CACHE_CONTROL = "Cache-Control"
+  prototype._HEADER_EXPIRES = "Expires"
 
-      if (m._data = Invalid)
-        m._data = {}
-      end if
-    end if
+  prototype._id = responseData.id
+  prototype._failureReason = getProperty(responseData, "failureReason", "OK")
+  prototype._headers = getProperty(responseData, "headers", {})
+  prototype._httpStatusCode = getProperty(responseData, "httpStatusCode", -1)
+  prototype._rawData = getProperty(responseData, "rawData", {})
+  prototype._requestOptions = responseData.requestOptions
+  prototype._time = DateTime().asSeconds()
 
-    m._id = response.id
-    m._failureReason = response.failureReason
-    m._httpStatusCode = response.httpStatusCode
-    m._requestOptions = response.requestOptions
-    m._isSuccess = m._checkSuccess()
-
-    return m
-  end function
+  prototype._maxAgeRegex = Invalid
+  prototype._statusCodes = HttpStatusCodes()
 
   ' Casts response object to node.
-  ' @returns {HttpResponse~HttpResponseNode}
+  ' @returns {HttpResponseModel}
   prototype.toNode = function () as Object
-    responseNode = CreateObject("roSGNode", "Node")
-    responseNode.id = m._id
-    responseNode.addFields({
+    responseNode = CreateObject("roSGNode", "HttpResponseModel")
+    responseNode.setFields({
+      failureReason: m._failureReason,
       headers: m._headers,
       httpStatusCode: m._httpStatusCode,
-      isSuccess: m._isSuccess,
-      rawData: m._data,
+      id: m._id,
+      isReusable: m.isReusable(),
+      isSuccess: m._isSuccess(),
+      maxAge: m.getMaxAge(),
+      rawData: m._rawData,
       requestOptions: m._requestOptions,
     })
-    responseNode.addField("data", "node", false)
 
-    if (NOT m._isSuccess)
-      responseNode.addFields({ failureReason: m._failureReason })
+    return responseNode
+  end function
+
+  ' @returns {Object}
+  prototype.serialise = function () as Object
+    return {
+      failureReason: m._failureReason,
+      headers: m._headers,
+      httpStatusCode: m._httpStatusCode,
+      id: m._id,
+      rawData: m._rawData,
+      requestOptions: m._requestOptions,
+      time: m._time,
+    }
+  end function
+
+  ' @returns {Object}
+  prototype.getHeaders = function () as Object
+    return m._headers
+  end function
+
+  ' @returns {Integer}
+  prototype.getStatusCode = function () as Integer
+    return m._httpStatusCode
+  end function
+
+  ' Returns maximum time of storing the cached response in seconds.
+  ' Returns 0 in case of no specified maxiumum time
+  ' Returns -1 in case of not allowed caching (no-cache header) or max age not in the future
+  ' @returns {Integer}
+  prototype.getMaxAge = function () as Integer
+    cacheControl = m._headers[m._HEADER_CACHE_CONTROL]
+    if (cacheControl <> Invalid)
+      if (cacheControl.inStr(m._CACHE_CONTROL_NO_CACHE) > 0)
+        return m.MAX_AGE_NOT_ALLOWED
+      end if
+
+      maxAgeMatches = m._getMaxAgeRegex().match(cacheControl)
+      if (NOT maxAgeMatches.isEmpty())
+        return maxAgeMatches[1].toInt()
+      end if
     end if
 
-    return responseNode
+    expires = m._headers[m._HEADER_EXPIRES]
+    if (expires <> Invalid)
+      expiresInSeconds = imfFixdateToSeconds(expires)
+      if (expiresInSeconds > 0)
+        maxAge = expiresInSeconds - DateTime().asSeconds()
+        if (maxAge < 0) then return m.MAX_AGE_NOT_ALLOWED
+
+        return maxAge
+      end if
+    end if
+
+    return 0
+  end function
+
+  ' Checks whether response is reusable (has no "no-store" Cache-Control header)
+  ' @returns {Boolean}
+  prototype.isReusable = function () as Boolean
+    cacheControl = m._headers[m._HEADER_CACHE_CONTROL]
+    if (cacheControl = Invalid)
+      return false
+    end if
+
+    return cacheControl.inStr(m._CACHE_CONTROL_NO_STORE) = -1
+  end function
+
+  ' @protected
+  prototype._getMaxAgeRegex = function () as Object
+    if (m._maxAgeRegex = Invalid) then m._maxAgeRegex = CreateObject("roRegex", m._CACHE_CONTROL_MAX_AGE + "(\d+)", "i")
+
+    return m._maxAgeRegex
   end function
 
   ' @private
-  prototype._checkSuccess = function () as Boolean
-    return (m._httpStatusCode >= m._HTTP_SUCCESS AND m._httpStatusCode < m._HTTP_FAILURE)
+  prototype._isSuccess = function () as Boolean
+    return (m._httpStatusCode >= m._statusCodes.SUCCESS AND m._httpStatusCode < m._statusCodes.FAILURE)
   end function
 
-  return _constructor(prototype, response)
+  return prototype
 end function

package/src/components/http/HttpResponse.model.xml

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="utf-8" ?>
+
+<component name="HttpResponseModel" extends="Node">
+  <interface>
+    <field id="data" type="node" /> <!-- @deprecated - HttpRequestResultModel is set as Request task's result field instead of HttpResponseModel -->
+    <field id="failureReason" type="string" />
+    <field id="headers" type="assocarray" />
+    <field id="httpStatusCode" type="integer" />
+    <field id="isReusable" type="boolean" />
+    <field id="isSuccess" type="boolean" />
+    <field id="maxAge" type="integer" />
+    <field id="rawData" type="assocarray" />
+    <field id="requestOptions" type="assocarray" />
+  </interface>
+</component>

package/src/components/http/HttpResponseCreator.brs

@@ -0,0 +1,46 @@
+' @import /components/getProperty.brs from @dazn/kopytko-utils
+' @import /components/http/HttpResponse.brs
+
+' @class
+function HttpResponseCreator() as Object
+  prototype = {}
+
+  prototype._CONTENT_TYPE_HEADER = "content-type"
+  prototype._JSON_CONTENT_TYPE = "application/json"
+
+  ' Parses response's content to JSON when application/json mimetype is detected.
+  ' Warning: should be used on a render thread due to parsing json
+  ' @param {roUrlEvent} urlEvent
+  ' @param {HttpRequest} request
+  ' @returns {HttpResponse}
+  prototype.create = function (urlEvent as Object, request as Object) as Object
+    return HttpResponse({
+      failureReason: urlEvent.getFailureReason(),
+      headers: urlEvent.getResponseHeaders(),
+      httpStatusCode: urlEvent.getResponseCode(),
+      id: request.getId(),
+      rawData: m._parseUrlEventContent(urlEvent),
+      requestOptions: request.getOptions(),
+    })
+  end function
+
+  ' @private
+  prototype._parseUrlEventContent = function (urlEvent as Object) as Object
+    if (NOT m._isJsonResponse(urlEvent)) then return {}
+
+    content = urlEvent.getString()
+    if (content = "") then return {}
+
+    data = ParseJSON(content)
+    if (data = Invalid) then return {}
+
+    return data
+  end function
+
+  ' @private
+  prototype._isJsonResponse = function (urlEvent as Object) as Boolean
+    return getProperty(urlEvent.getResponseHeaders(), [m._CONTENT_TYPE_HEADER], "").instr(m._JSON_CONTENT_TYPE) > -1
+  end function
+
+  return prototype
+end function

package/src/components/http/HttpService.brs

@@ -1,6 +1,11 @@
+' @import /components/getProperty.brs from @dazn/kopytko-utils
 ' @import /components/getType.brs from @dazn/kopytko-utils
+' @import /components/http/cache/HttpCache.brs
 ' @import /components/http/HttpRequest.brs
 ' @import /components/http/HttpResponse.brs
+' @import /components/http/HttpResponseCreator.brs
+' @import /components/http/HttpStatusCodes.const.brs
+' @import /components/utils/kopytkoWait.brs
 
 ' WARNING: the service must be used on the Task threads.
 ' @class
@@ -17,62 +22,79 @@ function HttpService(port as Object, httpInterceptors = [] as Object) as Object
   prototype._httpInterceptors = httpInterceptors
   prototype._port = port
 
-  ' Performs HTTP request
+  prototype._cache = HttpCache()
+  prototype._responseCreator = HttpResponseCreator()
+  prototype._statusCodes = HttpStatusCodes()
+
+  ' Performs HTTP request or returns a stored response
+  ' Warning: if a stored response is returned, HttpInterceptors are omitted
   ' @param {HttpRequest~Options} options
-  ' @returns {HttpResponse|Invalid}
+  ' @returns {HttpResponseModel|Invalid}
   prototype.fetch = function (options as Object) as Object
-    request = HttpRequest(options, m._httpInterceptors).setMessagePort(m._port)
+    request = HttpRequest(options, m._httpInterceptors)
+    request.setMessagePort(m._port)
+
+    cachedResponse = m._getCachedResponse(request)
+    if (cachedResponse <> Invalid)
+      if (NOT cachedResponse.hasExpired())
+        return cachedResponse.toNode()
+      end if
+
+      eTag = getProperty(cachedResponse.getHeaders(), "eTag", "")
+      if (eTag <> "")
+        request.setHeader("If-None-Match", eTag)
+      end if
+    end if
+
     request.send()
 
-    return m._waitForResponse(request)
+    return m._waitForResponse(request, cachedResponse)
   end function
 
   ' @private
-  prototype._waitForResponse = function (request as Object) as Object
+  prototype._getCachedResponse = function (request as Object) as Object
+    if (NOT request.isCachingEnabled()) then return Invalid
+
+    return m._cache.read(request.getEscapedUrl())
+  end function
+
+  ' @private
+  prototype._waitForResponse = function (request as Object, cachedResponse as Object) as Object
     while (true)
-      message = m._waitForMessage()
+      message = kopytkoWait(m._TIMEOUT_INTERVAL_CHECK, m._port)
 
       if (getType(message) = "roUrlEvent")
         if (message.getInt() = m._HTTP_REQUEST_COMPLETED)
-          return m._handleResponse(request, message)
+          return m._handleResponse(request, message, cachedResponse)
         end if
       else if (getType(message) = "roSGNodeEvent" AND message.getField() = "abort")
         request.abort()
 
         return Invalid
       else if (message = Invalid AND request.isTimedOut())
-        return m._getTimeoutResponse(request)
+        return HttpResponse({ httpStatusCode: m._TIMEOUT_ERROR_CODE, id: request.getId() }).toNode()
       end if
     end while
   end function
 
   ' @private
-  prototype._waitForMessage = function () as Object
-    return Wait(m._TIMEOUT_INTERVAL_CHECK, m._port)
-  end function
-
-  ' @private
-  prototype._handleResponse = function (request as Object, urlEvent as Object) as Object
+  prototype._handleResponse = function (request as Object, urlEvent as Object, cachedResponse as Object) as Object
     for each interceptor in m._httpInterceptors
       interceptor.interceptResponse(request, urlEvent)
     end for
 
-    return HttpResponse({
-      rawData: urlEvent.getString(),
-      httpStatusCode: urlEvent.getResponseCode(),
-      failureReason: urlEvent.getFailureReason(),
-      id: request.getId(),
-      headers: urlEvent.getResponseHeaders(),
-      requestOptions: request.getOptions(),
-    }).toNode()
-  end function
+    response = m._responseCreator.create(urlEvent, request)
 
-  ' @private
-  prototype._getTimeoutResponse = function (request as Object) as Object
-    return HttpResponse({
-      httpStatusCode: m._TIMEOUT_ERROR_CODE,
-      id: request.getId(),
-    }).toNode()
+    responseCode = response.getStatusCode()
+    if (responseCode >= m._statusCodes.SUCCESS AND responseCode < m._statusCodes.REDIRECTION)
+      if (request.getMethod() = "GET" AND response.isReusable())
+        m._cache.store(request, response)
+      end if
+    else if (responseCode = m._statusCodes.NOT_MODIFIED)
+      return m._cache.prolong(request, cachedResponse, response.getMaxAge()).toNode()
+    end if
+
+    return response.toNode()
   end function
 
   return prototype

package/src/components/http/HttpStatusCodes.const.brs

@@ -0,0 +1,8 @@
+function HttpStatusCodes() as Object
+  return {
+    SUCCESS: 200,
+    REDIRECTION: 300,
+    NOT_MODIFIED: 304,
+    FAILURE: 400,
+  }
+end function

package/src/components/http/cache/CachedHttpResponse.brs

@@ -0,0 +1,44 @@
+' @import /components/getProperty.brs from @dazn/kopytko-utils
+' @import /components/rokuComponents/DateTime.brs from @dazn/kopytko-utils
+' @import /components/http/HttpResponse.brs
+function CachedHttpResponse(responseData as Object) as Object
+  prototype = HttpResponse(responseData)
+
+  ' @constructor
+  ' @param {Object} m - instance reference
+  ' @param {Object} responseData
+  _constructor = function (m as Object, responseData as Object) as Object
+    if (responseData.time <> Invalid)
+      m._time = responseData.time
+    end if
+
+    return m
+  end function
+
+  ' @returns {Boolean} - true if response is expired based on its maxAge and time values
+  prototype.hasExpired = function () as Boolean
+    return DateTime().asSeconds() > m._time + m.getMaxAge()
+  end function
+
+  ' Updates cache max-age value
+  ' @param {Integer} maxAge
+  prototype.setRevalidatedCache = sub (maxAge as Integer)
+    m._time = DateTime().asSeconds()
+
+    cacheControl = getProperty(m._headers, m._HEADER_CACHE_CONTROL, "")
+    if (cacheControl <> "")
+      newCacheControl = m._getMaxAgeRegex().replace(cacheControl, m._CACHE_CONTROL_MAX_AGE + maxAge.toStr())
+      if (newCacheControl = cacheControl AND NOT m._getMaxAgeRegex().isMatch(cacheControl))
+        newCacheControl += ", " + m._CACHE_CONTROL_MAX_AGE + maxAge.toStr()
+      end if
+    else
+      newCacheControl = m._CACHE_CONTROL_MAX_AGE + maxAge.toStr()
+    end if
+
+    ' Cache-Control max-age is handier to use, so let's switch to it
+    m._headers[m._HEADER_CACHE_CONTROL] = newCacheControl
+    m._headers.delete(m._HEADER_EXPIRES)
+  end sub
+
+  return _constructor(prototype, responseData)
+end function

package/src/components/http/cache/HttpCache.brs

@@ -0,0 +1,42 @@
+' @import /components/CacheFS.brs from @dazn/kopytko-utils
+' @import /components/ternary.brs from @dazn/kopytko-utils
+' @import /components/http/cache/CachedHttpResponse.brs
+function HttpCache() as Object
+  prototype = {}
+
+  prototype._cacheFS = CacheFS()
+
+  ' @param {String} escapedUrl
+  ' @returns {CachedHttpResponse|Invalid}
+  prototype.read = function (escapedUrl as String) as Object
+    serialisedResponse = m._cacheFS.read(escapedUrl)
+    if (serialisedResponse = Invalid) then return Invalid
+
+    return CachedHttpResponse(serialisedResponse)
+  end function
+
+  ' @param {HttpRequest} request
+  ' @param {HttpResponse} response
+  ' @returns {Boolean} - true if response has been stored
+  prototype.store = function (request as Object, response as Object) as Boolean
+    maxAge = response.getMaxAge()
+    if (maxAge = response.MAX_AGE_NOT_ALLOWED) then return false
+
+    return m._cacheFS.write(request.getEscapedUrl(), response.serialise())
+  end function
+
+  ' @param {HttpRequest} request
+  ' @param {CachedHttpResponse} response
+  ' @param {Integer} newMaxAge
+  ' @returns {CachedHttpResponse}
+  prototype.prolong = function (request as Object, response as Object, newMaxAge as Integer) as Object
+    escapedUrl = request.getEscapedUrl()
+
+    response.setRevalidatedCache(newMaxAge)
+    m._cacheFS.write(escapedUrl, response.serialise())
+
+    return response
+  end function
+
+  return prototype
+end function

package/src/components/http/cache/_mocks/CachedHttpResponse.mock.brs

@@ -0,0 +1,35 @@
+' @import /components/_mocks/Mock.brs from @dazn/kopytko-unit-testing-framework
+' Required because Kopytko Unit Testing Framework doesn't mock inherited methods
+function CachedHttpResponse(responseData as Object) as Object
+  return Mock({
+    testComponent: m,
+    name: "CachedHttpResponse",
+    constructorParams: { responseData: responseData },
+    methods: {
+      hasExpired: function () as Boolean
+        return m.hasExpiredMock("hasExpired", {}, "Boolean")
+      end function,
+      setRevalidatedCache: sub (maxAge as Integer)
+        m.setRevalidatedCacheMock("setRevalidatedCache", { maxAge: maxAge })
+      end sub,
+      toNode: function () as Object
+        return m.toNodeMock("toNode", {}, "Object")
+      end function,
+      serialise: function () as Object
+        return m.serialiseMock("serialise", {}, "Object")
+      end function,
+      getHeaders: function () as Object
+        return m.getHeadersMock("getHeaders", {}, "Object")
+      end function,
+      getStatusCode: function () as Object
+        return m.getStatusCodeMock("getStatusCode", {}, "Integer")
+      end function,
+      getMaxAge: function () as Object
+        return m.getMaxAgeMock("getMaxAge", {}, "Integer")
+      end function,
+      isReusable: function () as Object
+        return m.isReusableMock("isReusable", {}, "Boolean")
+      end function,
+    },
+  })
+end function

package/src/components/http/request/Http.request.brs

@@ -0,0 +1,80 @@
+' @import /components/getProperty.brs from @dazn/kopytko-utils
+' @import /components/http/HttpService.brs
+
+' Accessing data owned by different threads (render or other tasks) cause a Rendezvous, except accessing render thread-owned data in the `init` function
+' because it's called on the render thread. That's why:
+' - Try to prepare all and only required data before running a task
+' - Avoid using Nodes owned by other threads after running a task
+' - Nodes created inside the 'init' function of a task are owned by the render thread
+' - If a node is read inside a running task it doesn't change ownership - each read operation on nodes owned by a different thread causes a Rendezvous
+' - Rendezvous may happen also between task threads - each task node is owned by the render thread
+sub init()
+  m.top.observeFieldScoped("options", "_onOptionsChange")
+  m.top.observeFieldScoped("state", "_onStateChange")
+
+  m._requestOptions.append({ method: "GET" })
+end sub
+
+sub runRequest()
+  _httpService = HttpService(m._port, getHttpInterceptors())
+  response = _httpService.fetch(m._requestOptions)
+
+  ' When response is Invalid that means http request is aborted (check HttpService _waitForResponse method).
+  ' Handler for aborting request is in createRequest function.
+  if (response = Invalid) then return
+
+  handleResponse(response)
+end sub
+
+' @protected
+' @param {Node<HttpResponseModel>} response
+sub handleResponse(response as Object)
+  result = CreateObject("roSGNode", "HttpRequestResultModel")
+  result.isSuccess = response.isSuccess
+
+  if (response.isSuccess)
+    result.data = parseResponse(response)
+  else
+    result.data = generateErrorData(response)
+  end if
+
+  m.top.result = result
+end sub
+
+' Override by child to return a list of objects implementing HttpInterceptor interface which will be passed to HttpService
+' @protected
+' @returns {HttpInterceptor[]}
+function getHttpInterceptors() as Object
+  return []
+end function
+
+' Override by child to use parsers and potentially return a specific node type
+' @protected
+' @param {Node<HttpResponseModel>} response
+' @returns {Node}
+function parseResponse(response as Object) as Object
+  parsedData = CreateObject("roSGNode", "Node")
+  parsedData.addFields(response.rawData)
+
+  return parsedData
+end function
+
+' Reacting to m.top field's change instead of reading it in runRequest avoids rendezvous
+' @private
+sub _onOptionsChange(event as Object)
+  options = event.getData()
+
+  m._requestOptions.enableCaching = getProperty(options, "enableCaching", true)
+end sub
+
+' Allows to rerun the same instance of a task
+' @private
+sub _onStateChange(event as Object)
+  state = event.getData()
+  m.top.unobserveFieldScoped("abort")
+
+  if (LCase(state) = "run")
+    m._port = CreateObject("roMessagePort")
+    m.top.observeFieldScoped("abort", m._port)
+  end if
+end sub

package/src/components/http/request/Http.request.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8" ?>
+
+<component name="HttpRequest" extends="Request">
+  <script type="text/brightscript" uri="Http.request.brs" />
+</component>

package/src/components/http/request/HttpRequestResult.model.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8" ?>
+
+<component name="HttpRequestResultModel" extends="Node">
+  <interface>
+    <field id="data" type="node" />
+    <field id="isSuccess" type="boolean" />
+  </interface>
+</component>

package/src/components/http/request/Request.brs

@@ -1,4 +1,5 @@
 ' @import /components/uuid.brs from @dazn/kopytko-utils
+' @deprecated - this file will be detached from Request.xml file and deleted
 sub init()
   m._id = uuid()
 
@@ -12,30 +13,33 @@ sub init()
   initRequest()
 end sub
 
-' Implement by each child
+' @abstract
 sub runRequest()
 end sub
 
-' Eventually implement by child
+' Abstract method to prepare data before running a task to avoid rendezvous (becaused it's called on the render thread)
+' The same can be achieved by adding the code to child's init() function
+' @deprecated
+' @protected
 sub initRequest()
 end sub
 
-' Eventually implement by child
+' Override by child to setup request options
 function getRequestOptions(data as Object) as Object
   return {}
 end function
 
-' Implement by child
+' Override by child to use parsers and potentially return a specific node type
 function parseResponseData(data as Object) as Object
-  return {}
+  parsedData = CreateObject("roSGNode", "Node")
+  parsedData.addFields(data)
+
+  return parsedData
 end function
 
-' Implement by child
+' Override by child for returning a specific data structure and/or node type
 function generateErrorData(response as Object) as Object
-  ' Structure:
-  ' { code: "", message: "" }
-
-  return {}
+  return response
 end function
 
 sub _onDataChange(event as Object)

package/src/components/http/request/Request.xml

@@ -4,7 +4,9 @@
   <interface>
     <field id="abort" type="boolean" />
     <field id="data" type="assocarray" />
-    <field id="response" type="node" />
+    <field id="options" type="assocarray" />
+    <field id="response" type="node" /> <!-- @deprecated - use "result" instead -->
+    <field id="result" type="node" />
   </interface>
 
   <script type="text/brightscript" uri="Request.brs" />

package/src/components/http/request/_mocks/Request.mock.brs

@@ -1,3 +1,19 @@
 sub init()
-  m.top.id = "request_mock"
+  m._id = "request_mock"
+
+  m.top.id = m._id
+
+  m._requestOptions = { id: m._id }
+
+  m.top.observeFieldScoped("data", "_onDataChange")
+end sub
+
+function getRequestOptions(data as Object) as Object
+  return data
+end function
+
+sub _onDataChange(event as Object)
+  data = event.getData()
+
+  m._requestOptions.append(getRequestOptions(data))
 end sub

package/src/components/http/request/_mocks/Request.mock.xml

@@ -2,8 +2,10 @@
 
 <component name="RequestMock" extends="Node">
   <interface>
+    <field id="abort" type="boolean" />
     <field id="data" type="assocarray" />
-    <field id="response" type="node" />
+    <field id="options" type="assocarray" />
+    <field id="result" type="node" />
   </interface>
 
   <script type="text/brightscript" uri="Request.mock.brs" />

package/src/components/http/request/createRequest.brs

@@ -19,7 +19,12 @@ function createRequest(task as Dynamic, data = {} as Object, options = {} as Obj
   end if
 
   task.data = data
-  task.observeFieldScoped("response", "createRequest_onPromiseResponse")
+  if (options.taskOptions <> Invalid)
+    task.options = options.taskOptions
+  end if
+
+  task.observeFieldScoped("response", "createRequest_onPromiseResult") ' @todo remove once response field is removed
+  task.observeFieldScoped("result", "createRequest_onPromiseResult")
 
   if (m._requests = Invalid)
     m._requests = {}
@@ -42,7 +47,7 @@ function createRequest(task as Dynamic, data = {} as Object, options = {} as Obj
   return requestPromise
 end function
 
-sub createRequest_onPromiseResponse(event as Object)
+sub createRequest_onPromiseResult(event as Object)
   if (m._requests = Invalid)
     return
   end if
@@ -56,18 +61,19 @@ sub createRequest_onPromiseResponse(event as Object)
 
   ' We stop task manually to make sure that state is changed and task can be rerun
   request.task.control = "stop"
-  request.task.unobserveFieldScoped("response")
+  request.task.unobserveFieldScoped("response") ' @todo remove once response field is removed
+  request.task.unobserveFieldScoped("result")
   createRequest_unsubscribeSignalIfNecessary(request)
 
   requestPromise = request.promise
 
-  response = event.getData()
+  result = event.getData()
   if (getProperty(request, "signal.abort", false))
     requestPromise.reject(createRequest_createAbortedRequestError())
-  else if (response.isSuccess)
-    requestPromise.resolve(response.data)
+  else if (result.isSuccess)
+    requestPromise.resolve(result.data)
   else
-    requestPromise.reject(response.data)
+    requestPromise.reject(result.data)
   end if
 
   m._requests.delete(requestId)
@@ -95,7 +101,8 @@ sub createRequest_onAbortSignal(event as Object)
   for each requestItem in m._requests.items()
     request = requestItem.value
     if (signal.isSameNode(request.signal))
-      request.task.unobserveFieldScoped("response")
+      request.task.unobserveFieldScoped("response") ' @todo remove once response field is removed
+      request.task.unobserveFieldScoped("result")
       request.task.abort = true
       request.task.control = "stop"
       request.promise.reject(createRequest_createAbortedRequestError())

package/src/components/utils/imfFixdateToSeconds.brs

@@ -0,0 +1,27 @@
+' @import /components/ArrayUtils.brs from @dazn/kopytko-utils
+' @import /components/rokuComponents/DateTime.brs from @dazn/kopytko-utils
+
+' Convert from IMF-fixdate format (Internet Message Format) to seconds
+' @param {String} IMFFixdate - the IMF-Fixdate string (Eg. "Sun, 06 Nov 1994 08:49:37 GMT")
+' @returns {Integer} the datetime in seconds (Eg. 784111777) or -1 for incorrect IMF-fixdate
+function imfFixdateToSeconds(imfFixdate as String) as Integer
+  regex = CreateObject("roRegex", "(\d+) (\w{3}) (\d+) (\d+):(\d+):(\d+)", "")
+
+  matches = regex.match(imfFixdate)
+  if (matches.isEmpty()) then return -1
+
+  MONTH_SHORT_NAMES = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
+
+  day = matches[1]
+  month = (ArrayUtils().findIndex(MONTH_SHORT_NAMES, matches[2]) + 1).toStr()
+  year = matches[3]
+  hour = matches[4]
+  minute = matches[5]
+  second = matches[6]
+
+  _dateTime = DateTime()
+  ISOString = year + "-" + month + "-" + day + " " + hour + ":" + minute + ":" + second
+  _dateTime.fromISO8601String(isoString)
+
+  return _dateTime.asSeconds()
+end function

package/src/components/utils/kopytkoWait.brs

@@ -0,0 +1,3 @@
+function kopytkoWait(timeout as Integer, port as Object) as Object
+  return Wait(timeout, port)
+end function

package/src/components/http/_mocks/HttpService.mock.xml

@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="utf-8" ?>
-
-<component name="HttpServiceMock" extends="Group">
-  <interface>
-    <field id="abort" type="string" />
-    <field id="requestOptions" type="assocarray" />
-    <field id="response" type="node" />
-  </interface>
-</component>