1386

Committed 09 Jul 2024 01:40PM UTC coverage: 78.598% (-0.4%) from 78.986%

Build # 1386

Build Type

push

circleci

Committed by

web-flow

Commit Message

Refactor sendError (#96)

Co-authored-by: Oleg Khasimkhanov <>

Run Details

327 of 499 branches covered (65.53%)

Branch coverage included in aggregate %.

39 of 43 new or added lines in 9 files covered. (90.7%)

1 existing line in 1 file now uncovered.

1164 of 1398 relevant lines covered (83.26%)

3.62 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

46.56

/src/redis-otp/api.js

const redisOTP = require("./datastore");
const constants = require("../constants");
const oauth = require("../oauth/google");
const utils = require("../utils");

const { SECONDS, BAD_REQUEST_ERROR, FORBIDDEN_ERROR } = constants;
const REDIS_OTP_MODULE = "redis-otp";

const saveToDB = (account, credentials) => {
  const pkKey = "credentials:pk";
  return redisOTP.client
    .INCR(pkKey)
    .then((pkValue) => {
      const key = getKey(account, pkValue);
      // add the pk to the company:provider index
      redisOTP.client
        .SET(key, JSON.stringify(credentials))
        .then(() =>
          redisOTP.client.SADD(`${getKeyPrefix(account)}`, String(pkValue))
        );
      return Promise.resolve(credentials);
    })
    .catch((error) => {
      const msg = `Could not save to DB: {account:${account}, provider: google, error: ${JSON.stringify(
        error
      )}}`;
      console.error(msg);
      return Promise.reject(new Error(msg));
    });
};

const deleteCredentials = (key) => {
  const keyInParts = key.split(":");

  // delete entry and remove from the IDENTIFIER:provider index
  // eslint-disable-next-line no-magic-numbers
  return redisOTP.client
    .DEL(key)
    .then(() =>
      redisOTP.client.SREM(`${keyInParts[0]}:${keyInParts[1]}`, [keyInParts[2]])
    );
};

const clearCredentials = (account) => {
  return getKeys(account)
    .then((keys) => {
      if (!keys || keys.length === 0) {
        return;
      }

      return Promise.all(
        keys.map((key) => deleteCredentials(`${getKeyPrefix(account)}:${key}`))
      );
    })
    .catch(() => Promise.resolve());
};

const updateCredentials = (account, updatedCredentials) => {
  return clearCredentials(account).then(() =>
    saveToDB(account, updatedCredentials)
  );
};

const getKeyPrefix = (account) => {
  return `${account}:google`;
};

const getKey = (account, pkValue) => {
  return `${getKeyPrefix(account)}:${pkValue}`;
};

const getKeys = (account) => {
  return redisOTP.client.SMEMBERS(`${getKeyPrefix(account)}`);
};

const getCredentialsVal = (key) => {
  return redisOTP.client
    .GET(key)
    .then((stringCredentials) => JSON.parse(stringCredentials));
};

const getCredentials = (account) => {
  let key = null;

  return getKeys(account)
    .then((keys) => {
      if (!keys || keys.length === 0) {
        return Promise.reject(
          new Error(`No credentials for: ${getKeyPrefix(account)}`)
        );
      }

      key = getKey(account, keys[0]);

      return getCredentialsVal(key);
    })
    .then((credentials) => {
      if (!credentials) {
        throw new Error(`Could not read credentials for: ${key}`);
      }

      return Promise.resolve(credentials);
    });
};

const getUsername = (account) => {
  return getCredentials(account).then((credentials) => {
    if (credentials && credentials.username) {
      return Promise.resolve(credentials.username);
    }

    console.log(
      `username not found in DB. Calling Google API. Account: ${account}`
    );

    return getAccessToken(account)
      .then(oauth.getUserProfile)
      .then((json) => Promise.resolve(json.email));
  });
};

const isAccessTokenValid = (credentials) => {
  const { expires_in, created_at } = credentials;
  const now = Date.now() / SECONDS;
  const expiry = created_at / SECONDS + expires_in;

  return now < expiry;
};

const validateRevokeQueryParams = (req) => {
  const { account } = req.query;

  return utils.validateRequest(req, [account]).then(() => Promise.resolve());
};

const validateUsernameBody = (req) => {
  const account = req.body.account;

  return utils
    .validateRequest(req, [account])
    .then(() => Promise.resolve(account));
};

const getAccessToken = (account) => {
  return getCredentials(account).then((credentials) => {
    if (isAccessTokenValid(credentials)) {
      return Promise.resolve(credentials.access_token);
    }

    return oauth
      .refreshAccessToken(credentials, account)
      .then((results) => {
        const { access_token, expires_in } = results;
        const created_at = Date.now();
        const updatedCredentials = Object.assign({}, credentials, {
          access_token,
          expires_in,
          created_at,
        });

        return updateCredentials(account, updatedCredentials);
      })
      .then((credentials) => {
        return credentials.access_token;
      });
  });
};

const handleRevokeAccess = (req, res) => {
  let key = null;
  let revoked = true;
  const loggingDetails = `account: ${req.query.account}`;

  return validateRevokeQueryParams(req)
    .then(() => {
      return getCredentials(req.query.account)
        .then(oauth.revokeAccess)
        .then((isRevoked) => {
          const { account } = req.query;

          revoked = isRevoked;

          console.log(`Access revoked for account ${account}`);

          return clearCredentials(account);
        })
        .then(() => {
          res.header("Cache-control", `private`);
          res.json({ key, revoked });
        })
        .catch((error) =>
          utils.sendError(
            res,
            REDIS_OTP_MODULE,
            error.message,
            FORBIDDEN_ERROR,
            loggingDetails
          )
        );
    })
    .catch((error) =>
      utils.sendError(
        res,
        REDIS_OTP_MODULE,
        error.message,
        BAD_REQUEST_ERROR,
        loggingDetails
      )
    );
};

const handleUsernameRequest = (req, res) => {
  const account = req.body.account;
  const loggingDetails = `account: ${account}`;

  return validateUsernameBody(req)
    .then(getUsername)
    .then((username) => res.json({ username }))
    .catch((error) =>
      utils.sendError(
        res,
        REDIS_OTP_MODULE,
        error.message,
        BAD_REQUEST_ERROR,
        loggingDetails
      )
    );
};

const debugCheckCredentials = (req, res) => {
  const first10 = (str) => {
    return str ? str.substring(0, 10) + "..." : str;
  };

  return validateRevokeQueryParams(req)
    .then(() => {
      return getCredentials(req.query.account)
        .then((credentials) => {
          let result = {};
          result.access_token = first10(credentials.access_token);
          result.refresh_token = first10(credentials.refresh_token);
          result.expires = credentials.expires;
          result.scope = credentials.scope;
          res.header("Cache-control", `private`);
          res.json(result);
        })
        .catch((error) =>
          utils.sendError(
            res,
            REDIS_OTP_MODULE,
            error.message,
            FORBIDDEN_ERROR,
            ""
          )
        );
    })
    .catch((error) =>
      utils.sendError(
        res,
        REDIS_OTP_MODULE,
        error.message,
        BAD_REQUEST_ERROR,
        ""
      )
    );
};

module.exports = {
  getAccessToken,
  handleRevokeAccess,
  handleUsernameRequest,
  debugCheckCredentials,
};

1	const redisOTP = require("./datastore");	2✔
2	const constants = require("../constants");	2✔
3	const oauth = require("../oauth/google");	2✔
4	const utils = require("../utils");	2✔
5
6	const { SECONDS, BAD_REQUEST_ERROR, FORBIDDEN_ERROR } = constants;	2✔
7	const REDIS_OTP_MODULE = "redis-otp";	2✔
8
9	const saveToDB = (account, credentials) => {	2✔
10	const pkKey = "credentials:pk";	×
11	return redisOTP.client	×
12	.INCR(pkKey)
13	.then((pkValue) => {
14	const key = getKey(account, pkValue);	×
15	// add the pk to the company:provider index
16	redisOTP.client	×
17	.SET(key, JSON.stringify(credentials))
18	.then(() =>
19	redisOTP.client.SADD(`${getKeyPrefix(account)}`, String(pkValue))	×
20	);
21	return Promise.resolve(credentials);	×
22	})
23	.catch((error) => {
24	const msg = `Could not save to DB: {account:${account}, provider: google, error: ${JSON.stringify(	×
25	error
26	)}}`;
27	console.error(msg);	×
28	return Promise.reject(new Error(msg));	×
29	});
30	};
31
32	const deleteCredentials = (key) => {	2✔
33	const keyInParts = key.split(":");	1✔
34
35	// delete entry and remove from the IDENTIFIER:provider index
36	// eslint-disable-next-line no-magic-numbers
37	return redisOTP.client	1✔
38	.DEL(key)
39	.then(() =>
40	redisOTP.client.SREM(`${keyInParts[0]}:${keyInParts[1]}`, [keyInParts[2]])	1✔
41	);
42	};
43
44	const clearCredentials = (account) => {	2✔
45	return getKeys(account)	×
46	.then((keys) => {
47	if (!keys \|\| keys.length === 0) {	×
48	return;	×
49	}
50
51	return Promise.all(	×
52	keys.map((key) => deleteCredentials(`${getKeyPrefix(account)}:${key}`))	×
53	);
54	})
55	.catch(() => Promise.resolve());	×
56	};
57
58	const updateCredentials = (account, updatedCredentials) => {	2✔
59	return clearCredentials(account).then(() =>	×
60	saveToDB(account, updatedCredentials)	×
61	);
62	};
63
64	const getKeyPrefix = (account) => {	2✔
65	return `${account}:google`;	4✔
66	};
67
68	const getKey = (account, pkValue) => {	2✔
69	return `${getKeyPrefix(account)}:${pkValue}`;	2✔
70	};
71
72	const getKeys = (account) => {	2✔
73	return redisOTP.client.SMEMBERS(`${getKeyPrefix(account)}`);	2✔
74	};
75
76	const getCredentialsVal = (key) => {	2✔
77	return redisOTP.client	2✔
78	.GET(key)
79	.then((stringCredentials) => JSON.parse(stringCredentials));	2✔
80	};
81
82	const getCredentials = (account) => {	2✔
83	let key = null;	2✔
84
85	return getKeys(account)	2✔
86	.then((keys) => {
87	if (!keys \|\| keys.length === 0) {	2!
88	return Promise.reject(	×
89	new Error(`No credentials for: ${getKeyPrefix(account)}`)
90	);
91	}
92
93	key = getKey(account, keys[0]);	2✔
94
95	return getCredentialsVal(key);	2✔
96	})
97	.then((credentials) => {
98	if (!credentials) {	2!
99	throw new Error(`Could not read credentials for: ${key}`);	×
100	}
101
102	return Promise.resolve(credentials);	2✔
103	});
104	};
105
106	const getUsername = (account) => {	2✔
107	return getCredentials(account).then((credentials) => {	2✔
108	if (credentials && credentials.username) {	2✔
109	return Promise.resolve(credentials.username);	1✔
110	}
111
112	console.log(	1✔
113	`username not found in DB. Calling Google API. Account: ${account}`
114	);
115
116	return getAccessToken(account)	1✔
117	.then(oauth.getUserProfile)
118	.then((json) => Promise.resolve(json.email));	1✔
119	});
120	};
121
122	const isAccessTokenValid = (credentials) => {	2✔
UNCOV 123	const { expires_in, created_at } = credentials;	×
124	const now = Date.now() / SECONDS;	×
125	const expiry = created_at / SECONDS + expires_in;	×
126
127	return now < expiry;	×
128	};
129
130	const validateRevokeQueryParams = (req) => {	2✔
131	const { account } = req.query;	×
132
133	return utils.validateRequest(req, [account]).then(() => Promise.resolve());	×
134	};
135
136	const validateUsernameBody = (req) => {	2✔
137	const account = req.body.account;	3✔
138
139	return utils	3✔
140	.validateRequest(req, [account])
141	.then(() => Promise.resolve(account));	2✔
142	};
143
144	const getAccessToken = (account) => {	2✔
145	return getCredentials(account).then((credentials) => {	×
146	if (isAccessTokenValid(credentials)) {	×
147	return Promise.resolve(credentials.access_token);	×
148	}
149
150	return oauth	×
151	.refreshAccessToken(credentials, account)
152	.then((results) => {
153	const { access_token, expires_in } = results;	×
154	const created_at = Date.now();	×
155	const updatedCredentials = Object.assign({}, credentials, {	×
156	access_token,
157	expires_in,
158	created_at,
159	});
160
161	return updateCredentials(account, updatedCredentials);	×
162	})
163	.then((credentials) => {
164	return credentials.access_token;	×
165	});
166	});
167	};
168
169	const handleRevokeAccess = (req, res) => {	2✔
170	let key = null;	×
171	let revoked = true;	×
172	const loggingDetails = `account: ${req.query.account}`;	×
173
174	return validateRevokeQueryParams(req)	×
175	.then(() => {
176	return getCredentials(req.query.account)	×
177	.then(oauth.revokeAccess)
178	.then((isRevoked) => {
179	const { account } = req.query;	×
180
181	revoked = isRevoked;	×
182
183	console.log(`Access revoked for account ${account}`);	×
184
185	return clearCredentials(account);	×
186	})
187	.then(() => {
188	res.header("Cache-control", `private`);	×
189	res.json({ key, revoked });	×
190	})
191	.catch((error) =>
NEW 192	utils.sendError(	×
193	res,
194	REDIS_OTP_MODULE,
195	error.message,
196	FORBIDDEN_ERROR,
197	loggingDetails
198	)
199	);
200	})
201	.catch((error) =>
NEW 202	utils.sendError(	×
203	res,
204	REDIS_OTP_MODULE,
205	error.message,
206	BAD_REQUEST_ERROR,
207	loggingDetails
208	)
209	);
210	};
211
212	const handleUsernameRequest = (req, res) => {	2✔
213	const account = req.body.account;	3✔
214	const loggingDetails = `account: ${account}`;	3✔
215
216	return validateUsernameBody(req)	3✔
217	.then(getUsername)
218	.then((username) => res.json({ username }))	2✔
219	.catch((error) =>
220	utils.sendError(	1✔
221	res,
222	REDIS_OTP_MODULE,
223	error.message,
224	BAD_REQUEST_ERROR,
225	loggingDetails
226	)
227	);
228	};
229
230	const debugCheckCredentials = (req, res) => {	2✔
231	const first10 = (str) => {	×
232	return str ? str.substring(0, 10) + "..." : str;	×
233	};
234
235	return validateRevokeQueryParams(req)	×
236	.then(() => {
237	return getCredentials(req.query.account)	×
238	.then((credentials) => {
239	let result = {};	×
240	result.access_token = first10(credentials.access_token);	×
241	result.refresh_token = first10(credentials.refresh_token);	×
242	result.expires = credentials.expires;	×
243	result.scope = credentials.scope;	×
244	res.header("Cache-control", `private`);	×
245	res.json(result);	×
246	})
247	.catch((error) =>
NEW 248	utils.sendError(	×
249	res,
250	REDIS_OTP_MODULE,
251	error.message,
252	FORBIDDEN_ERROR,
253	""
254	)
255	);
256	})
257	.catch((error) =>
NEW 258	utils.sendError(	×
259	res,
260	REDIS_OTP_MODULE,
261	error.message,
262	BAD_REQUEST_ERROR,
263	""
264	)
265	);
266	};
267
268	module.exports = {	2✔
269	getAccessToken,
270	handleRevokeAccess,
271	handleUsernameRequest,
272	debugCheckCredentials,
273	};

Rise-Vision / google-service / 1386

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous