initial ver

Author: Sachin Maheshwari

.gitignore

@@ -0,0 +1,2 @@
+node_modules
+package-lock.json

index.js

@@ -0,0 +1,9 @@
+const { configureConnector, getFreshToken } = require ('./src/connector-wrapper')
+const { isTokenExpired, decodeToken } = require('./src/token')
+
+module.exports = {
+    configureConnector,
+    getFreshToken,
+    isTokenExpired,
+    decodeToken
+}

package.json

@@ -0,0 +1,26 @@
+{
+  "name": "tc-auth-lib",
+  "version": "1.0.0",
+  "description": "Topcoder Authentication lib   ",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/topcoder-platform/authlib.git"
+  },
+  "keywords": [
+    "topcoder",
+    "authentication"
+  ],
+  "author": "Topcoder Team",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/topcoder-platform/authlib/issues"
+  },
+  "homepage": "https://github.com/topcoder-platform/authlib#readme",
+  "dependencies": {
+    "lodash": "^4.17.19"
+  }
+}

src/connector-wrapper.js

@@ -0,0 +1,85 @@
+const {createFrame} = require('./iframe')
+const {getToken} = require ('./token')
+
+let iframe = null
+let loading = null
+let url = ''
+let mock = false
+let token = ''
+
+function configureConnector({connectorUrl, frameId, mockMode, mockToken}) {
+  if (mockMode) {
+    mock = true
+    token = mockToken
+  } else if (iframe) {
+    console.warn('tc-accounts connector can only be configured once, this request has been ignored.')
+  } else {
+    iframe = createFrame(frameId, connectorUrl)
+    url = connectorUrl 
+    
+    loading = new Promise( (resolve) => {
+      iframe.onload = function() {
+        loading = null
+        resolve()
+      }
+    })
+  }
+}
+
+const proxyCall = function() {
+  if (mock) {
+    throw new Error('connector is running in mock mode. This method (proxyCall) should not be invoked.')
+  }
+
+  if (!iframe) {
+    throw new Error('connector has not yet been configured.')
+  }
+
+  function request() {
+    /*return new Promise( (resolve, reject) => {
+      function receiveMessage(e) {
+          const safeFormat = e.data.type === SUCCESS || e.data.type === FAILURE
+          if (safeFormat) {
+              window.removeEventListener('message', receiveMessage)
+              if (e.data.type === SUCCESS) resolve(e.data)
+              if (e.data.type === FAILURE) reject(e.error)
+          }
+      }
+
+      window.addEventListener('message', receiveMessage)
+
+      const payload = Object.assign({}, { type: REQUEST }, params)
+
+      iframe.contentWindow.postMessage(payload, url)
+    }) */
+    return new Promise((resolve, reject) => {
+      const token = getToken('tcjwt')
+      token ? resolve({ token: token }) : reject("tcjwt cookie not found")
+    })
+  }
+
+  if (loading) {
+    return loading = loading.then(request)
+  } else {
+    return request()
+  }
+}
+
+function getFreshToken() {
+  if (mock) {
+    if (token) {
+      return Promise.resolve(token)
+    } else {
+      return Promise.reject('connector is running in mock mode, but no token has been specified.')
+    }
+  }
+
+  return proxyCall()
+    .then( data => data.token )
+}
+
+module.exports = {
+  getFreshToken,
+  configureConnector
+}
+

src/iframe.js

@@ -0,0 +1,16 @@
+function createFrame(id, src) {
+  const iframe = document.createElement('iframe')
+
+  iframe.id = id
+  iframe.src = src
+  iframe.width = 0
+  iframe.height = 0
+  iframe.frameborder = 0
+
+  document.body.appendChild(iframe)
+
+  return iframe
+}
+module.exports = {
+  createFrame
+}

src/token.js

@@ -0,0 +1,97 @@
+const fromPairs = require('lodash/fromPairs')
+
+
+function getToken(key) {
+  return readCookie(key)
+}
+
+
+function decodeToken(token) {
+  const parts = token.split('.')
+
+  if (parts.length !== 3) {
+    throw new Error('The token is invalid')
+  }
+
+  const decoded = urlBase64Decode(parts[1])
+
+  if (!decoded) {
+    throw new Error('Cannot decode the token')
+  }
+
+  // covert base64 token in JSON object
+  let t = JSON.parse(decoded)
+
+  // tweaking for custom claim for RS256
+  t.userId = _.parseInt(_.find(t, (value, key) => {
+    return (key.indexOf('userId') !== -1)
+  }))
+  t.handle = _.find(t, (value, key) => {
+    return (key.indexOf('handle') !== -1)
+  })
+  t.roles = _.find(t, (value, key) => {
+    return (key.indexOf('roles') !== -1)
+  })
+
+  return t
+}
+
+function isTokenExpired(token, offsetSeconds = 0) {
+  const d = getTokenExpirationDate(token)
+
+  if (d === null) {
+    return false
+  }
+
+  // Token expired?
+  return !(d.valueOf() > (new Date().valueOf() + (offsetSeconds * 1000)))
+}
+
+function urlBase64Decode(str) {
+  let output = str.replace(/-/g, '+').replace(/_/g, '/')
+
+  switch (output.length % 4) {
+    case 0:
+      break
+
+    case 2:
+      output += '=='
+      break
+
+    case 3:
+      output += '='
+      break
+
+    default:
+      throw 'Illegal base64url string!'
+  }
+  return decodeURIComponent(escape(atob(output))) //polyfill https://github.com/davidchambers/Base64.js
+}
+
+function getTokenExpirationDate(token) {
+  const decoded = decodeToken(token)
+
+  if (typeof decoded.exp === 'undefined') {
+    return null
+  }
+
+  const d = new Date(0) // The 0 here is the key, which sets the date to the epoch
+  d.setUTCSeconds(decoded.exp)
+
+  return d
+}
+
+function parseCookie(cookie) {
+  return fromPairs(cookie.split(';').map((pair) => pair.split('=').map((part) => part.trim())))
+}
+
+function readCookie(name) {
+  return parseCookie(document.cookie)[name]
+}
+
+
+module.exports = {
+  isTokenExpired,
+  decodeToken,
+  getToken
+}