@skitter/cognidesk-jwt 0.0.10

package/.eslintrc.js

@@ -0,0 +1,17 @@
+module.exports = {
+  env: {
+    browser: true,
+    commonjs: true,
+    es6: true
+  },
+  extends: "eslint:recommended",
+  globals: {
+    Atomics: "readonly",
+    Buffer: "readonly",
+    SharedArrayBuffer: "readonly"
+  },
+  parserOptions: {
+    ecmaVersion: 2018
+  },
+  rules: {}
+};

package/README.md

@@ -0,0 +1,54 @@
+# cognidesk-jwt!
+
+Simple jwt library with custom configuration for cognidesk 
+
+# How to use
+
+## Express middleware
+
+### To sign JWT
+
+ *setSessionAsJWT* function transforms the given data as JWT token with expiration of two days and sets it as a httpOnly cookie under the key *session* 
+
+The function throws exception in case of errors in encoding
+
+```javascript
+ const { setSessionAsJWT } = require("@skitter/cognidesk-jwt/middleware/signSession")
+ var express = require('express')
+ var app = express()
+
+ const secret = "shhh"
+ const data = { test : "data"}
+ 
+app.get('/', function (req, res) {
+  setSessionAsJWT(secret,data,res)
+  res.send('hello world')
+})
+```
+
+
+### To decode token
+
+The functionality has been exposed as a middleware and it decodes the http-cookie and can be accessed as `req.sesssion`
+
+The middleware throws `401` in case of issues with token verification
+
+```javascript
+ const { sessionFromToken } =  require("@skitterorg/cognidesk-jwt/src/express/middleware/sessionFromToken");
+ var express = require('express')
+ var app = express()
+
+ const secret = "shhh"
+ const middlewareSetup = sessionFromToken("shhh")
+ 
+ app.use(middlewareSetup)
+ 
+ app.get('/', function (req, res) {
+  console.log("session data" , req.session)
+  res.send('hello world')
+})
+```
+
+
+
+

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@skitter/cognidesk-jwt",
+  "version": "0.0.10",
+  "main": "src/verify.js",
+  "author": "selva.g <selva.g@skitter.in>",
+  "license": "MIT",
+  "dependencies": {
+    "crocks": "^0.11.1",
+    "jsonwebtoken": "^8.5.1",
+    "ramda": "^0.26.1"
+  },
+  "devDependencies": {
+    "@pika/plugin-build-node": "^0.3.14",
+    "@pika/plugin-bundle-node": "^0.3.14",
+    "@pika/plugin-copy-assets": "^0.3.14",
+    "@pika/plugin-standard-pkg": "^0.3.14",
+    "eslint": "^5.16.0",
+    "jest": "^24.7.0",
+    "microbundle": "^0.11.0",
+    "prettier": "^1.16.4"
+  },
+  "scripts": {
+    "test": "jest",
+    "bundle": "microbundle src/verify.js -o dist/stockroom.js",
+    "lint": "eslint src/*.js",
+    "test:watch": "jest --watch"
+  },
+  "@pika/pack": {
+    "pipeline": [
+      [
+        "@pika/plugin-standard-pkg"
+      ],
+      [
+        "@pika/plugin-build-node",
+        {
+          "minNodeVersion": 10
+        }
+      ],
+      [
+        "@pika/plugin-bundle-node"
+      ]
+    ]
+  }
+}

package/pkg/README.md

@@ -0,0 +1,54 @@
+# cognidesk-jwt!
+
+Simple jwt library with custom configuration for cognidesk 
+
+# How to use
+
+## Express middleware
+
+### To sign JWT
+
+ *setSessionAsJWT* function transforms the given data as JWT token with expiration of two days and sets it as a httpOnly cookie under the key *session* 
+
+The function throws exception in case of errors in encoding
+
+```javascript
+ const { setSessionAsJWT } = require("@skitter/cognidesk-jwt/middleware/signSession")
+ var express = require('express')
+ var app = express()
+
+ const secret = "shhh"
+ const data = { test : "data"}
+ 
+app.get('/', function (req, res) {
+  setSessionAsJWT(secret,data,res)
+  res.send('hello world')
+})
+```
+
+
+### To decode token
+
+The functionality has been exposed as a middleware and it decodes the http-cookie and can be accessed as `req.sesssion`
+
+The middleware throws `401` in case of issues with token verification
+
+```javascript
+ const { sessionFromToken } = require("@skitter/cognidesk-jwt/middleware/sessionFromToken")
+ var express = require('express')
+ var app = express()
+
+ const secret = "shhh"
+ const middlewareSetup = sessionFromToken("shhh")
+ 
+ app.use(middlewareSetup)
+ 
+ app.get('/', function (req, res) {
+  console.log("session data" , req.session)
+  res.send('hello world')
+})
+```
+
+
+
+

package/pkg/dist-node/index.js

@@ -0,0 +1,11 @@
+'use strict';
+
+const {
+  verify
+} = require("./verify");
+
+const R = require("ramda");
+
+module.exports = {
+  verify
+};

package/pkg/dist-src/constants.js

@@ -0,0 +1,4 @@
+module.exports = {
+  DEFAULT_ALGORITHM: "HS384",
+  VALID_ISSUERS: ["cognidesk-jwt"]
+};

package/pkg/dist-src/express/middleware/sessionFromToken.js

@@ -0,0 +1,40 @@
+var cookie = require("cookie");
+
+const {
+  verify
+} = require("../verify");
+
+const {
+  isError
+} = require("../helpers");
+
+function sessionFromJWT(secret, mockdata) {
+  return function _verifyJwt(req, res, next) {
+    if (mockdata) {
+      req.session = mockdata;
+      return next();
+    }
+
+    let cookies = req.headers.cookie;
+
+    if (!cookies) {
+      res.send(401, "No cookie found");
+      return next();
+    }
+
+    const parsedCookie = cookie.parse(cookies);
+    const session = cookies.session;
+    const data = verify(secret)(session);
+
+    if (isError(data)) {
+      res.send(401, `Invalid token : ${data.name}`);
+    }
+
+    req.session = data;
+    next();
+  };
+}
+
+module.exports = {
+  sessionFromJWT
+};

package/pkg/dist-src/express/middleware/setCrossDomainCookieAccess.js

@@ -0,0 +1,9 @@
+function crossDomainCookieAccess(req, res, next) {
+  res.header("Access-Control-Allow-Credentials", true);
+  res.header("Access-Control-Allow-Origin", "*");
+  next();
+}
+
+module.exports = {
+  crossDomainCookieAccess
+};

package/pkg/dist-src/express/signSession.js

@@ -0,0 +1,18 @@
+var cookie = require("cookie");
+
+const {
+  sign
+} = require("../sign");
+
+const {
+  isError
+} = require("../helpers");
+
+function setSessionAsJWT(secret, data, res) {
+  const token = sign(secret)(data);
+  let options = {
+    httpOnly: true // The cookie only accessible by the web server
+
+  };
+  res.cookie("session", token, options);
+}

package/pkg/dist-src/help.js

@@ -0,0 +1,6 @@
+//const { concat, reduce } = require("crocks/pointfree");
+//const Either = require("crocks/Either");
+//const { Left, Right } = Either;
+////console.log(concat(Right("ad"), Right("asd"), Left("ssh")));
+//const arr = [Right("ad"), Right("asd"), Left("ssh")];
+////console.log(reduce(concat, Right(""), arr));

package/pkg/dist-src/helpers.js

@@ -0,0 +1,12 @@
+const R = require("ramda");
+
+let isError = function (e) {
+  return e && e.stack && e.message && typeof e.stack === "string" && typeof e.message === "string";
+};
+
+const logTag = tag => data => console.log(tag, data);
+
+module.exports = {
+  isError,
+  logTag
+};

package/pkg/dist-src/helpers.test.js

@@ -0,0 +1,25 @@
+const {
+  isError
+} = require("./helpers");
+
+const {
+  verify
+} = require("./verify");
+
+test("verify iserror", () => {
+  const invalidToken = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVC.eyJCj19qlQPasOu_JsUmJEe5yst_iTf0ECu4";
+  const secret = "shhhh";
+  const verifyOutput = verify(secret)(invalidToken);
+  expect(isError(verifyOutput)).toBe(true);
+});
+test("sample error", () => {
+  const error = new Error("test error");
+  expect(isError(error)).toBe(true);
+});
+test("with error like properties", () => {
+  const error2 = {
+    name: "error",
+    stack: "test"
+  };
+  expect(isError(error2)).toBeFalsy();
+});

package/pkg/dist-src/index.js

@@ -0,0 +1,9 @@
+const {
+  verify
+} = require("./verify");
+
+const R = require("ramda");
+
+module.exports = {
+  verify
+};

package/pkg/dist-src/sign.js

@@ -0,0 +1,17 @@
+const {
+  DEFAULT_ALGORITHM
+} = require("./constants");
+
+var jwt = require("jsonwebtoken");
+
+const sign = secret => data => {
+  return jwt.sign(data, secret, {
+    algorithm: DEFAULT_ALGORITHM,
+    expiresIn: "2 days",
+    issuer: "cognidesk-jwts"
+  });
+};
+
+module.exports = {
+  sign
+};

package/pkg/dist-src/validations.js

@@ -0,0 +1,67 @@
+const R = require("ramda");
+
+const Either = require("crocks/Either");
+
+const {
+  isString
+} = require("crocks/predicates");
+
+const safe = require("crocks/Maybe/safe");
+
+const prop = require("crocks/Maybe/prop");
+
+const Maybe = require("crocks/Maybe");
+
+const maybeToEither = require("crocks/Either/maybeToEither");
+
+const {
+  head,
+  map,
+  chain,
+  concat,
+  reduce
+} = require("crocks/pointfree");
+
+const {
+  logTag
+} = require("./helpers");
+
+const {
+  Nothing
+} = Maybe;
+const {
+  Left,
+  Right
+} = Either;
+
+const {
+  DEFAULT_ALGORITHM,
+  VALID_ISSUERS
+} = require("./constants");
+
+const secondElement = arr => arr.length >= 2 ? Maybe.of(arr[1]) : Nothing();
+
+const createBuffer = encoding => object => Buffer.from(object, encoding);
+
+const safeParse = toParse => {
+  try {
+    return Right(JSON.parse(toParse));
+  } catch (err) {
+    return Left("Invalid JSON");
+  }
+};
+
+const decodeJwtHeader = R.compose(chain(safeParse), map(createBuffer("base64")), maybeToEither("No Header"), chain(head), map(R.split(".")), safe(isString));
+const decodePayLoad = R.compose(chain(safeParse), map(createBuffer("base64")), maybeToEither("No Payload"), chain(secondElement), map(R.split(".")), safe(isString));
+const validAlgorithm = R.cond([[R.equals(DEFAULT_ALGORITHM), R.always(Right("Valid Algorithm"))], [R.T, R.always(Left("Invalid Algorithm"))]]);
+const flipedIncludes = R.flip(R.includes);
+const validIssuers = R.cond([[flipedIncludes(VALID_ISSUERS), R.always(Right("Valid Issuer"))], [R.T, R.always(Left("Invalid Issuer"))]]);
+const checkAlg = R.compose(chain(validAlgorithm), maybeToEither("No Algorithm in Header"), prop("alg"));
+const checkIssuer = R.compose(chain(validIssuers), maybeToEither("No Issuer in Payload"), prop("iss"));
+const checkHeader = R.compose(chain(checkAlg), map(R.tap(logTag("head"))), decodeJwtHeader);
+const checkPayload = R.compose(chain(checkIssuer), map(R.tap(logTag("payload"))), decodePayLoad);
+const validations = [checkHeader, checkPayload];
+const mergeValidations = R.compose(R.converge((...args) => reduce(concat, Right(""))(args), validations));
+module.exports = {
+  mergeValidations
+};

package/pkg/dist-src/verify.js

@@ -0,0 +1,60 @@
+var jwt = require("jsonwebtoken");
+
+const R = require("ramda");
+
+const Either = require("crocks/Either");
+
+const maybeToEither = require("crocks/Either/maybeToEither");
+
+const {
+  chain,
+  merge,
+  either
+} = require("crocks/pointfree");
+
+const {
+  isString
+} = require("crocks/predicates");
+
+const safe = require("crocks/Maybe/safe");
+
+const prop = require("crocks/Maybe/prop");
+
+const fanout = require("crocks/helpers/fanout");
+
+const Maybe = require("crocks/Maybe");
+
+const {
+  Just,
+  Nothing
+} = Maybe;
+const {
+  Left,
+  Right
+} = Either;
+
+const {
+  mergeValidations
+} = require("./validations");
+
+const safeVerify = secret => token => {
+  try {
+    return Right(jwt.verify(token, secret));
+  } catch (err) {
+    return Left(err);
+  }
+};
+
+const mergeEither = (e1, e2) => e1.chain(_ => e2);
+
+const makeError = error => new Error(error);
+
+const handleToken = secret => token => R.compose(either(makeError, R.identity), chain(safeVerify(secret)), merge(mergeEither), fanout(mergeValidations, Right))(token);
+
+const verify = (secret, mockData) => token => {
+  return R.cond([[R.isNil, R.always(handleToken(secret)(token))], [R.T, R.identity]])(mockData);
+};
+
+module.exports = {
+  verify
+};

package/pkg/dist-src/verify.test.js

@@ -0,0 +1,25 @@
+const {
+  verify
+} = require("./verify");
+
+const validToken = "eyJhbGciOiJIUzM4NCIsInR5cCI6IkpXVCJ9.eyJmb28iOiJiYXIiLCJpYXQiOjE1NTQzMzcyODR9.k6R3HV1_QB-B4CQ1PQYrXCSxM9mxnPtR6lJb-sKIHpLIbAmWgbjVAc6vGYqRSF4W";
+const invalidToken = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVC.eyJCj19qlQPasOu_JsUmJEe5yst_iTf0ECu4";
+const secret = "shhhh";
+test("verify valid token", () => {
+  const valid = "eyJhbGciOiJIUzM4NCIsInR5cCI6IkpXVCJ9.eyJmb28iOiJiYXIiLCJpc3MiOiJjb2duaWRlc2stand0In0.8V-6DUJzTQpFgGEoLQxSjOaxslVdsOHLLM04zTcJhWnpsdQearWS_nhpIaM2LskP";
+  expect(verify(secret)(valid)).toHaveProperty("foo");
+});
+test("wrong secret", () => {
+  const wrongSecret = "sad";
+  expect(verify(wrongSecret)(validToken)).toHaveProperty("name");
+});
+test("wrong token", () => {
+  const wrongSecret = "sad";
+  expect(verify(secret)(invalidToken)).toHaveProperty("name");
+});
+test("has mock data", () => {
+  const mockData = {
+    test: "test"
+  };
+  expect(verify(secret, mockData)(invalidToken)).toHaveProperty("test");
+});

package/pkg/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@skitter/cognidesk-jwt",
+  "description": "Simple jwt library with custom configuration for cognidesk",
+  "version": "0.0.1",
+  "license": "MIT",
+  "esnext": "dist-src/index.js",
+  "main": "dist-node/index.js",
+  "pika": true,
+  "sideEffects": false,
+  "files": [
+    "dist-*/",
+    "assets/",
+    "bin/"
+  ],
+  "dependencies": {
+    "crocks": "^0.11.1",
+    "jsonwebtoken": "^8.5.1",
+    "ramda": "^0.26.1"
+  },
+  "devDependencies": {
+    "@pika/plugin-build-node": "^0.3.14",
+    "@pika/plugin-bundle-node": "^0.3.14",
+    "@pika/plugin-copy-assets": "^0.3.14",
+    "@pika/plugin-standard-pkg": "^0.3.14",
+    "eslint": "^5.16.0",
+    "jest": "^24.7.0",
+    "microbundle": "^0.11.0",
+    "prettier": "^1.16.4"
+  }
+}

package/src/constants.js

@@ -0,0 +1,4 @@
+module.exports = {
+  DEFAULT_ALGORITHM: "HS384",
+  VALID_ISSUERS: ["cognidesk-jwt"]
+};

package/src/express/middleware/sessionFromToken.js

@@ -0,0 +1,34 @@
+var cookie = require("cookie");
+const { verify } = require("../../verify");
+const { isError, makeError } = require("../../helpers");
+
+function sessionFromJWT(secret, mockdata) {
+  return function _verifyJwt(req, res, next) {
+    if (mockdata) {
+      req.session = mockdata;
+      return next();
+    }
+
+    let cookies = req.headers.cookie;
+
+    if (!cookies) {
+      const cookieError = makeError("No cookie found");
+      return next(cookieError);
+    }
+
+    const parsedCookie = cookie.parse(cookies);
+    const session = parsedCookie.session;
+    const data = verify(secret)(session);
+
+    if (isError(data)) {
+      return next(data);
+    }
+
+    req.session = data;
+    next();
+  };
+}
+
+module.exports = {
+  sessionFromJWT
+};

package/src/express/middleware/setCrossDomainCookieAccess.js

@@ -0,0 +1,8 @@
+function crossDomainCookieAccess(req, res, next) {
+  res.header("Access-Control-Allow-Credentials", true);
+  res.header("Access-Control-Allow-Origin", "*");
+  next();
+}
+module.exports = {
+  crossDomainCookieAccess
+};

package/src/express/signSession.js

@@ -0,0 +1,16 @@
+var cookie = require("cookie");
+const { sign } = require("../sign");
+const { isError } = require("../helpers");
+
+function setSessionAsJWT(secret, data, res) {
+  const token = sign(secret)(data);
+  let options = {
+    httpOnly: true,
+    maxAge: 60 * 60 * 24
+  };
+  res.cookie("session", token, options);
+}
+
+module.exports = {
+  setSessionAsJWT
+};

package/src/helpers.js

@@ -0,0 +1,24 @@
+let isError = function(e) {
+  return (
+    e &&
+    e.stack &&
+    e.message &&
+    typeof e.stack === "string" &&
+    typeof e.message === "string"
+  );
+};
+/* eslint-disable no-alert, no-console */
+const logTag = tag => data => console.log(tag, data);
+/* eslint-disable no-alert, no-console */
+
+const makeError = error => {
+  const tokenError = new Error(error);
+  tokenError.code = "TokenValidationError";
+  return tokenError;
+};
+
+module.exports = {
+  isError,
+  logTag,
+  makeError
+};

package/src/helpers.test.js

@@ -0,0 +1,22 @@
+/* eslint-disable */
+const { isError } = require("./helpers");
+const { verify } = require("./verify");
+
+test("verify iserror", () => {
+  const invalidToken =
+    "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVC.eyJCj19qlQPasOu_JsUmJEe5yst_iTf0ECu4";
+  const secret = "shhhh";
+  const verifyOutput = verify(secret)(invalidToken);
+
+  expect(isError(verifyOutput)).toBe(true);
+});
+
+test("sample error", () => {
+  const error = new Error("test error");
+  expect(isError(error)).toBe(true);
+});
+
+test("with error like properties", () => {
+  const error2 = { name: "error", stack: "test" };
+  expect(isError(error2)).toBeFalsy();
+});

package/src/index.js

@@ -0,0 +1,5 @@
+const { verify } = require("./verify");
+
+module.exports = {
+  verify
+};

package/src/sign.js

@@ -0,0 +1,25 @@
+const { DEFAULT_ALGORITHM } = require("./constants");
+var jwt = require("jsonwebtoken");
+const R = require("ramda");
+
+const isObject = require("crocks/predicates/isObject");
+
+const sign = secret => data => {
+  if (!isObject(data)) {
+    throw new Error("Data must be an object");
+  }
+
+  if (R.isNil(secret)) {
+    throw new Error("Secret should not be nil");
+  }
+
+  return jwt.sign(data, secret, {
+    algorithm: DEFAULT_ALGORITHM,
+    expiresIn: "24h",
+    issuer: "cognidesk-jwt"
+  });
+};
+
+module.exports = {
+  sign
+};

package/src/sign.test.js

@@ -0,0 +1,31 @@
+/* eslint-disable */
+const { sign } = require("./sign");
+
+const secret = "472D4B614E645267556B587032733576";
+const data = { id: 1 };
+
+test("verify valid token", () => {
+  const token = sign(secret)(data);
+  console.log(token);
+  expect(token).toBeDefined();
+});
+
+test("invalid data", () => {
+  const invalidData = null;
+  expect(sign(secret)(invalidData)).toThrow();
+});
+
+test("invalid secret", () => {
+  const secret = null;
+  expect(sign(secret)(data)).toThrow();
+});
+
+//test("wrong token", () => {
+//const wrongsecret = "sad";
+//expect(verify(secret)(invalidToken)).toHaveProperty("name");
+//});
+
+//test("has mock data", () => {
+//const mockData = { test: "test" };
+//expect(verify(secret, mockData)(invalidToken)).toHaveProperty("test");
+//});

package/src/validations.js

@@ -0,0 +1,89 @@
+const R = require("ramda");
+const Either = require("crocks/Either");
+const { isString } = require("crocks/predicates");
+const safe = require("crocks/Maybe/safe");
+const prop = require("crocks/Maybe/prop");
+const Maybe = require("crocks/Maybe");
+const maybeToEither = require("crocks/Either/maybeToEither");
+const { head, map, chain, concat, reduce } = require("crocks/pointfree");
+const { logTag } = require("./helpers");
+
+const { Nothing } = Maybe;
+const { Left, Right } = Either;
+
+const { DEFAULT_ALGORITHM, VALID_ISSUERS } = require("./constants");
+
+const secondElement = arr => (arr.length >= 2 ? Maybe.of(arr[1]) : Nothing());
+const createBuffer = encoding => object => Buffer.from(object, encoding);
+const safeParse = toParse => {
+  try {
+    return Right(JSON.parse(toParse));
+  } catch (err) {
+    return Left("Invalid JSON");
+  }
+};
+
+const decodeJwtHeader = R.compose(
+  chain(safeParse),
+  map(createBuffer("base64")),
+  maybeToEither("No Header"),
+  chain(head),
+  map(R.split(".")),
+  safe(isString)
+);
+
+const decodePayLoad = R.compose(
+  chain(safeParse),
+  map(createBuffer("base64")),
+  maybeToEither("No Payload"),
+  chain(secondElement),
+  map(R.split(".")),
+  safe(isString)
+);
+
+const validAlgorithm = R.cond([
+  [R.equals(DEFAULT_ALGORITHM), R.always(Right("Valid Algorithm"))],
+  [R.T, R.always(Left("Invalid Algorithm"))]
+]);
+
+const flipedIncludes = R.flip(R.includes);
+
+const validIssuers = R.cond([
+  [flipedIncludes(VALID_ISSUERS), R.always(Right("Valid Issuer"))],
+  [R.T, R.always(Left("Invalid Issuer"))]
+]);
+
+const checkAlg = R.compose(
+  chain(validAlgorithm),
+  maybeToEither("No Algorithm in Header"),
+  prop("alg")
+);
+
+const checkIssuer = R.compose(
+  chain(validIssuers),
+  maybeToEither("No Issuer in Payload"),
+  prop("iss")
+);
+const checkHeader = R.compose(
+  chain(checkAlg),
+  map(R.tap(logTag("head"))),
+  decodeJwtHeader
+);
+
+const checkPayload = R.compose(
+  chain(checkIssuer),
+  map(R.tap(logTag("payload"))),
+  decodePayLoad
+);
+
+const validations = [checkHeader, checkPayload];
+
+//const signValidations = [checkHeader, checkPayload];
+
+const jwtValidations = R.compose(
+  R.converge((...args) => reduce(concat, Right(""))(args), validations)
+);
+
+module.exports = {
+  jwtValidations
+};

package/src/verify.js

@@ -0,0 +1,39 @@
+var jwt = require("jsonwebtoken");
+const R = require("ramda");
+const Either = require("crocks/Either");
+const { chain, merge, either } = require("crocks/pointfree");
+const fanout = require("crocks/helpers/fanout");
+
+const { Left, Right } = Either;
+const { makeError } = require("./helpers");
+
+const { jwtValidations } = require("./validations");
+
+const safeVerify = secret => token => {
+  try {
+    return Right(jwt.verify(token, secret));
+  } catch (err) {
+    return Left(err);
+  }
+};
+
+const mergeEither = (e1, e2) => e1.chain(() => e2);
+
+const handleToken = secret => token =>
+  R.compose(
+    either(makeError, R.identity),
+    chain(safeVerify(secret)),
+    merge(mergeEither),
+    fanout(jwtValidations, Right)
+  )(token);
+
+const verify = (secret, mockData) => token => {
+  return R.cond([
+    [R.isNil, R.always(handleToken(secret)(token))],
+    [R.T, R.identity]
+  ])(mockData);
+};
+
+module.exports = {
+  verify
+};

package/src/verify.test.js

@@ -0,0 +1,40 @@
+/* eslint-disable */
+const { verify } = require("./verify");
+
+const validToken =
+  "eyJhbGciOiJIUzM4NCIsInR5cCI6IkpXVCJ9.eyJmb28iOiJiYXIiLCJpYXQiOjE1NTQzMzcyODR9.k6R3HV1_QB-B4CQ1PQYrXCSxM9mxnPtR6lJb-sKIHpLIbAmWgbjVAc6vGYqRSF4W";
+
+const invalidToken =
+  "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVC.eyJCj19qlQPasOu_JsUmJEe5yst_iTf0ECu4";
+const secret = "shhhh";
+
+test("verify valid token", () => {
+  const valid =
+    "eyJhbGciOiJIUzM4NCIsInR5cCI6IkpXVCJ9.eyJmb28iOiJiYXIiLCJpc3MiOiJjb2duaWRlc2stand0In0.8V-6DUJzTQpFgGEoLQxSjOaxslVdsOHLLM04zTcJhWnpsdQearWS_nhpIaM2LskP";
+  expect(verify(secret)(valid)).toHaveProperty("foo");
+});
+
+test("wrong secret", () => {
+  const wrongSecret = "sad";
+  const out = verify(wrongSecret)(validToken);
+  console.log(out.name, out.code, out.message, out.stack);
+  expect(out).toHaveProperty("name");
+});
+
+test("wrong token", () => {
+  const wrongSecret = "sad";
+  expect(verify(secret)(invalidToken)).toHaveProperty("name");
+});
+
+test("has mock data", () => {
+  const mockData = { test: "test" };
+  expect(verify(secret, mockData)(invalidToken)).toHaveProperty("test");
+});
+
+test("test actual token", () => {
+  const token =
+    "eyJhbGciOiJIUzM4NCIsInR5cCI6IkpXVCJ9.eyJpZCI6MSwiaWF0IjoxNTU0ODI1NzUxLCJleHAiOjE1NTQ5OTg1NTEsImlzcyI6ImNvZ25pZGVzay1qd3QifQ.6yyrr4kqKHyqEj8f_fPAzPN1BogNrT7JsiiZOyzS-gRd1227LxcTxphqm49WXPHC";
+  //const secret = "472D4B614E645267556B587032733576";
+  const secret = "472D4B614E645267556B587032733576";
+  expect(verify(secret)(token)).toHaveProperty("id");
+});