@stackfactor/client-api 1.1.12-9.2 → 1.1.13

package/lib/{users.ts → users.js}

@@ -1,15 +1,12 @@
-/* eslint-disable no-undef */
 import { client } from "./axiosClient.js";
 
 /**
  * Add a new API Token
- * @param {string} name Name of the token
  * @param {Date} expiration Expiration date of the token
- * @param {string} token Authorization token
- * @returns {Promise<object>}
+ * @param {String} authToken Authorization token
  */
-const addAPIToken = (name: string, expiration: Date, token: string): Promise<object> => {
-  return new Promise((resolve, reject) => {
+export const addAPIToken = (name, expiration, authToken) => {
+  return new Promise(function (resolve, reject) {
     const requestData = {
       name: name,
       expiration: expiration,
@@ -18,7 +15,7 @@ const addAPIToken = (name: string, expiration: Date, token: string): Promise<obj
       `api/v1/users/addapitoken`,
       requestData,
       {
-        headers: { authorization: token },
+        headers: { authorization: authToken },
       }
     );
     addTokenRequest
@@ -37,11 +34,10 @@ const addAPIToken = (name: string, expiration: Date, token: string): Promise<obj
 
 /**
  * Confirm email address
- * @param {string} validationCode The code was provided to the user in advance by email
- * @returns {Promise<void>}
+ * @param {String} validationCode The code was provided to the user in advance by email
  */
-const confirmEmailAddress = (validationCode: string): Promise<void> => {
-  return new Promise((resolve, reject) => {
+export const confirmEmailAddress = (validationCode) => {
+  return new Promise(function (resolve, reject) {
     const requestData = {
       validationCode: validationCode,
     };
@@ -61,12 +57,11 @@ const confirmEmailAddress = (validationCode: string): Promise<void> => {
 
 /**
  * Confirm phone number
- * @param {string} validationCode The code was provided to the user in advance by email
- * @param {string} token Authorization token
- * @returns {Promise<object>}
+ * @param {String} validationCode The code was provided to the user in advance by email
+ * @param {String} authToken Authorization token
  */
-const confirmPhone = (validationCode: string, token: string): Promise<object> => {
-  return new Promise((resolve, reject) => {
+export const confirmPhone = (validationCode, authToken) => {
+  return new Promise(function (resolve, reject) {
     const requestData = {
       validationCode: validationCode,
     };
@@ -74,7 +69,7 @@ const confirmPhone = (validationCode: string, token: string): Promise<object> =>
       "api/v1/users/confirmPhone",
       requestData,
       {
-        headers: { authorization: token },
+        headers: { authorization: authToken },
       }
     );
     confirmationRequest
@@ -89,12 +84,11 @@ const confirmPhone = (validationCode: string, token: string): Promise<object> =>
 
 /**
  * Generate confirmation code
- * @param {string} phoneNumber Send confirmation code to the phone number
- * @param {string} token Authorization token
- * @returns {Promise<object>}
+ * @param {String} phoneNumber Send confirmation code to the phone number
+ * @param {String} authToken Authorization token
  */
-const confirmPhoneGenerateCode = (phoneNumber: string, token: string): Promise<object> => {
-  return new Promise((resolve, reject) => {
+export const confirmPhoneGenerateCode = (phoneNumber, authToken) => {
+  return new Promise(function (resolve, reject) {
     const requestData = {
       phoneNumber: phoneNumber,
     };
@@ -102,7 +96,7 @@ const confirmPhoneGenerateCode = (phoneNumber: string, token: string): Promise<o
       "api/v1/users/confirmPhoneGenerateCode",
       requestData,
       {
-        headers: { authorization: token },
+        headers: { authorization: authToken },
       }
     );
     confirmationRequest
@@ -117,23 +111,23 @@ const confirmPhoneGenerateCode = (phoneNumber: string, token: string): Promise<o
 
 /**
  * Create a new account (tenant). It returns a promise
- * @param {string} email User's email address
- * @param {string} firstName User's first name
- * @param {string} lastName User's last name
- * @param {string} password User's password
- * @param {string} subSite Subsite where the new account will be created
- * @param {string} inviteCode Invitation code received in advance from one of the account owners
- * @returns {Promise<object>}
+ * @param {String} email User's email address
+ * @param {String} firstName User's first name
+ * @param {String} lastName User's last name
+ * @param {String} password User's password
+ * @param {String} subSite Subsite where the new account will be created
+ * @param {String} inviteCode Invitation code received in advance from one of the account owners
+ * @param
  */
-const createAccount = (
-  email: string,
-  firstName: string,
-  lastName: string,
-  password: string,
-  subSite: string,
-  inviteCode: string
-): Promise<object> => {
-  return new Promise((resolve, reject) => {
+export const createAccount = (
+  email,
+  firstName,
+  lastName,
+  password,
+  subSite,
+  inviteCode
+) => {
+  return new Promise(function (resolve, reject) {
     if (
       email.trim() === "" ||
       firstName.trim() === "" ||
@@ -166,21 +160,20 @@ const createAccount = (
 
 /**
  * Create a new user account. It returns a promise
- * @param {string} email User's email address
- * @param {string} firstName User's first name
- * @param {string} lastName User's last name
- * @param {string} password User's password
- * @param {string} token Invitation token provided to the user
- * @returns {Promise<object>}
+ * @param {String} email User's email address
+ * @param {String} firstName User's first name
+ * @param {String} lastName User's last name
+ * @param {String} password User's password
+ * @param {String} token Invitation token provided to the user
  */
-const createUserAccount = (
-  email: string,
-  firstName: string,
-  lastName: string,
-  password: string,
-  token: string
-): Promise<object> => {
-  return new Promise((resolve, reject) => {
+export const createUserAccount = (
+  email,
+  firstName,
+  lastName,
+  password,
+  token
+) => {
+  return new Promise(function (resolve, reject) {
     if (
       email.trim() === "" ||
       firstName.trim() === "" ||
@@ -211,12 +204,11 @@ const createUserAccount = (
 
 /**
  * Delete an existing API token
- * @param {string} token Expiration date of the token
- * @param {string} authToken Authorization token
- * @returns {Promise<string>}
+ * @param {String} token Expiration date of the token
+ * @param {String} authToken Authorization token
  */
-const deleteAPIToken = (token: string, authToken: string): Promise<string> => {
-  return new Promise((resolve, reject) => {
+export const deleteAPIToken = (token, authToken) => {
+  return new Promise(function (resolve, reject) {
     const deleteTokenRequest = client.delete(`api/v1/users/user/token`, {
       headers: { authorization: authToken },
       data: {
@@ -235,14 +227,13 @@ const deleteAPIToken = (token: string, authToken: string): Promise<string> => {
 
 /**
  * Delete existing users
- * @param {string[]} userIds The ID of the users to be deleted
- * @param {string} token Authorization token
- * @returns {Promise<object>}
+ * @param {Array<String>} userIds The ID of the users to be deleted
+ * @param {String} authToken Authorization token
  */
-const deleteUsers = (userIds: string[], token: string): Promise<object> => {
-  return new Promise((resolve, reject) => {
+export const deleteUsers = (userIds, authToken) => {
+  return new Promise(function (resolve, reject) {
     const deleteTokenRequest = client.delete(`api/v1/users/`, {
-      headers: { authorization: token },
+      headers: { authorization: authToken },
       data: {
         userIds: userIds,
       },
@@ -259,13 +250,12 @@ const deleteUsers = (userIds: string[], token: string): Promise<object> => {
 
 /**
  * Get all the API tokens
- * @param {string} token Authorization token
- * @returns {Promise<object>}
+ * @param {String} authToken Authorization token
  */
-const getAPITokens = (token: string): Promise<object> => {
-  return new Promise((resolve, reject) => {
+export const getAPITokens = (authToken) => {
+  return new Promise(function (resolve, reject) {
     const getTokensRequest = client.get(`api/v1/users/getapitokens`, {
-      headers: { authorization: token },
+      headers: { authorization: authToken },
     });
     getTokensRequest
       .then((result) => {
@@ -279,15 +269,11 @@ const getAPITokens = (token: string): Promise<object> => {
 
 /**
  * Get the specified user account by Id. It returns a promise
- * @param {string} id Id of the user for which information is being requested
- * @param {string} token Authorization token
- * @returns {Promise<object>}
+ * @param {String} id Id of the user for which information is being requested
  */
-const getUserById = (id: string, token: string): Promise<object> => {
-  return new Promise((resolve, reject) => {
-    const getUserInformationRequest = client.get(`api/v1/users/user/${id}`, {
-      headers: { authorization: token },
-    });
+export const getUserById = (id) => {
+  return new Promise(function (resolve, reject) {
+    const getUserInformationRequest = client.get(`api/v1/users/user/${id}`);
     getUserInformationRequest
       .then((result) => {
         if (result != null) {
@@ -304,15 +290,14 @@ const getUserById = (id: string, token: string): Promise<object> => {
 
 /**
  * Get user information
- * @param {string} userId User Id
- * @param {string} category User information category
- * @param {string} token Authorization token
- * @returns {Promise<object>}
+ * @param {String} userId User Id
+ * @param {String} category User information category
+ * @param {String} token Authorization token
  */
-const getUserInformation = (userId: string, category: string, token: string): Promise<object> => {
-  return new Promise((resolve, reject) => {
+export const getUserInformation = (userId, category, token) => {
+  return new Promise(function (resolve, reject) {
     let confirmationRequest = client.get(
-      `api/v1/users/user/${userId || 0}/${category || "*"}`,
+      `api/v1/users/user/${userId ? userId : 0}/${category ? category : "*"}`,
       {
         headers: { authorization: token },
       }
@@ -329,13 +314,12 @@ const getUserInformation = (userId: string, category: string, token: string): Pr
 
 /**
  * Get the list of users
- * @param {object} filter Filter to select the users. Ex: {firstName : "John"}
- * @param {string[]} fields Fields to be loaded. Ex: ["firstName"]
- * @param {string} token Authorization token
- * @returns {Promise<object>}
+ * @param {Object} filter Filter to select the users. Ex: {firstName : "John"}
+ * @param {Array} fields Fields to be loaded. Ex: ["firstName"]
+ * @param {String} token Authorization token
  */
-const getUsers = (filter: object, fields: string[], token: string): Promise<object> => {
-  return new Promise((resolve, reject) => {
+export const getUsers = (filter, fields, token) => {
+  return new Promise(function (resolve, reject) {
     const requestData = {
       filter: filter,
       fields: fields,
@@ -355,14 +339,13 @@ const getUsers = (filter: object, fields: string[], token: string): Promise<obje
 
 /**
  * Invite other users to join the same account
- * @param {string[]} invitees List of emails of the invitees
- * @param {string} groupId The group the user should be added to
- * @param {string} teamId The team the user should be added to
- * @param {string} authToken Authorization token
- * @returns {Promise<object>}
+ * @param {Array<String>} invitees List of emails of the invitees
+ * @param {String} groupId The group the user should be added to
+ * @param {String} teamId The team the user should be added to
+ * @param {String} token Authorization token
  */
-const inviteUsers = (invitees: string[], groupId: string, teamId: string, authToken: string): Promise<object> => {
-  return new Promise((resolve, reject) => {
+export const inviteUsers = (invitees, groupId, teamId, authToken) => {
+  return new Promise(function (resolve, reject) {
     const requestData = {
       invitees: invitees,
       groupId: groupId,
@@ -384,15 +367,16 @@ const inviteUsers = (invitees: string[], groupId: string, teamId: string, authTo
 
 /**
  * Login using email and password. It returns a promise
- * @param {string} email User's email address
- * @param {string} password User's password
- * @returns {Promise<object>}
+ * @param {String} email User's email address
+ * @param {String} password User's password
+ * @param {boolean} rememberMe Set to true if the user wants his account to be saved on the current machine
  */
-const login = (email: string, password: string): Promise<object> => {
-  return new Promise((resolve, reject) => {
+export const login = (email, password, rememberMe) => {
+  return new Promise(function (resolve, reject) {
     const requestData = {
       email: email,
       password: password,
+      rememberMe: rememberMe,
     };
     let request = client.post("api/v1/auth/login", requestData);
     request
@@ -405,45 +389,16 @@ const login = (email: string, password: string): Promise<object> => {
   });
 };
 
-/**
- * Login callback after authentication to exchange the code token for authentication and refresh tokens
- * @param {string} code
- * @param {string} codeVerifier
- * @param {string} redirectUri
- * @returns {Promise<object>}
- */
-const loginExchangeKeys = (code: string, codeVerifier: string, redirectUri: string): Promise<object> => {
-  return new Promise((resolve, reject) => {
-    const requestData = {
-      code: code,
-      codeVerifier: codeVerifier,
-      redirectUri: redirectUri,
-    };
-    let request = client.post("api/v1/auth/loginexchangekeys", requestData);
-    request
-      .then((response) => {
-        resolve(response.data);
-      })
-      .catch((error) => {
-        reject(error);
-      });
-  });
-};
-
 /**
  * Logout from the server. It returns a promise
- * @param {string} token Authorization token
- * @returns {Promise<object>}
+ * @param {String} token Authorization token
  */
-const logout = (token: string): Promise<object> => {
-  return new Promise((resolve, reject) => {
-    let request = client.post(
-      "api/v1/auth/logout",
-      {},
-      {
-        headers: { authorization: token },
-      }
-    );
+export const logout = (token) => {
+  return new Promise(function (resolve, reject) {
+    const options = {
+      headers: { authorization: token },
+    };
+    let request = client.post("api/v1/auth/logout", {}, options);
     request
       .then((response) => {
         resolve(response.data);
@@ -457,14 +412,12 @@ const logout = (token: string): Promise<object> => {
 /**
  * Checks the current auth token and maintain it alive. It returns a promise. In case the token is invalid
  * a new token can be restablished using login
- * @param {string} refreshToken User's auth token to be refreshed
- * @returns {Promise<object>}
+ * @param {String} token  User's auth token to be refreshed
  */
-const refreshToken = (refreshToken: string): Promise<object> => {
-  return new Promise((resolve, reject) => {
-    let request = client.post("api/v1/auth/refreshToken", {
-      refreshToken: refreshToken,
-    });
+export const refreshToken = (token) => {
+  return new Promise(function (resolve, reject) {
+    let options = { headers: { Authorization: token } };
+    let request = client.post("api/v1/auth/refreshToken", {}, options);
     request
       .then((response) => {
         resolve(response.data);
@@ -477,12 +430,11 @@ const refreshToken = (refreshToken: string): Promise<object> => {
 
 /**
  * Remove an existing API token
- * @param {string} id The ID of the token to be removed
- * @param {string} authToken Authorization token
- * @returns {Promise<string>}
+ * @param {String} id The ID of the token to be removed
+ * @param {String} authToken Authorization token
  */
-const removeAPIToken = (id: string, authToken: string): Promise<string> => {
-  return new Promise((resolve, reject) => {
+export const removeAPIToken = (id, authToken) => {
+  return new Promise(function (resolve, reject) {
     const requestData = {
       id: id,
     };
@@ -505,12 +457,11 @@ const removeAPIToken = (id: string, authToken: string): Promise<string> => {
 
 /**
  * Resend invitation emails
- * @param {string[]} invitees List of emails of the invitees
- * @param {string} authToken Authorization token
- * @returns {Promise<object>}
+ * @param {Array<String>} invitees List of emails of the invitees
+ * @param {String} token Authorization token
  */
-const resendInvitationEmails = (invitees: string[], authToken: string): Promise<object> => {
-  return new Promise((resolve, reject) => {
+export const resendInvitationEmails = (invitees, authToken) => {
+  return new Promise(function (resolve, reject) {
     const requestData = {
       invitees: invitees,
       token: authToken,
@@ -530,13 +481,12 @@ const resendInvitationEmails = (invitees: string[], authToken: string): Promise<
 
 /**
  * Reset the password. It returns a promise
- * @param {string} code Code provided to the user by email
- * @param {string} email User's email address
- * @param {string} password User's new password
- * @returns {Promise<object>}
+ * @param {String} code Code provided to the user by email
+ * @param {String} email User's email address
+ * @param {String} password User's new password
  */
-const resetPassword = (email: string, code: string, password: string): Promise<object> => {
-  return new Promise((resolve, reject) => {
+export const resetPassword = (email, code, password) => {
+  return new Promise(function (resolve, reject) {
     let postData = {
       email: email,
       code: code,
@@ -553,41 +503,12 @@ const resetPassword = (email: string, code: string, password: string): Promise<o
   });
 };
 
-/**
- * Send email confirmation code
- * @param {string} email
- * @param {string} token
- * @returns {Promise<object>}
- */
-const sendEmailConfirmationCode = (email: string, token: string): Promise<object> => {
-  return new Promise((resolve, reject) => {
-    let postData = {
-      email: email,
-    };
-    let request = client.post(
-      "api/v1/users/sendemailconfirmationcode",
-      postData,
-      {
-        headers: { authorization: token },
-      }
-    );
-    request
-      .then((response) => {
-        resolve(response.data);
-      })
-      .catch((error) => {
-        reject(error);
-      });
-  });
-};
-
 /**
  * Send an email to the user indicated by the email address to reset the password. It returns a promise
- * @param {string} email Email of the user who needs to reset the password
- * @returns {Promise<object>}
+ * @param {String} email Email of the user who needs to reset the password
  */
-const sendPasswordResetNotification = (email: string): Promise<object> => {
-  return new Promise((resolve, reject) => {
+export const sendPasswordResetNotification = (email) => {
+  return new Promise(function (resolve, reject) {
     let postData = {
       email: email,
     };
@@ -607,14 +528,13 @@ const sendPasswordResetNotification = (email: string): Promise<object> => {
 
 /**
  * Set user profile information
- * @param {string} userId User Id
- * @param {string} category User information category
- * @param {object} data New or updated user data information
- * @param {string} token Authorization token
- * @returns {Promise<object>}
+ * @param {String} userId User Id
+ * @param {String} category User information category
+ * @param {String} data New or updated user data information
+ * @param {Object} token Authorization token
  */
-const setUserInformation = (userId: string, category: string, data: object, token: string): Promise<object> => {
-  return new Promise((resolve, reject) => {
+export const setUserInformation = (userId, category, data, token) => {
+  return new Promise(function (resolve, reject) {
     const requestData = {
       data: category ? { [category]: data } : data,
       userId: userId,
@@ -634,22 +554,14 @@ const setUserInformation = (userId: string, category: string, data: object, toke
 
 /**
  * Update user email
- * @param {string} email The new email address
- * @param {string} verificationCode The verification code
- * @param {string} password The current password
- * @param {string} token Authorization token
- * @returns {Promise<object>}
+ * @param {String} email The new email address
+ * @param {String} password The current password
+ * @param {String} token Authorization token
  */
-const updateUserEmail = (
-  email: string,
-  verificationCode: string,
-  password: string,
-  token: string
-): Promise<object> => {
-  return new Promise((resolve, reject) => {
+export const updateUserEmail = (email, password, token) => {
+  return new Promise(function (resolve, reject) {
     const requestData = {
       email: email,
-      verificationCode: verificationCode,
       password: password,
     };
     let confirmationRequest = client.post(
@@ -671,17 +583,12 @@ const updateUserEmail = (
 
 /**
  * Update user groups
- * @param {String} userId The id of the user
+ * @param {String} userIds The id of the user
  * @param {Array<String>} groups The id of the groups the user should belong to
  * @param {String} token Authorization token
- * @returns {Promise<Object>}
  */
-const updateUserGroups = (
-  userId: string,
-  groups: string[],
-  token: string
-): Promise<object> => {
-  return new Promise((resolve, reject) => {
+export const updateUserGroups = (userId, groups, token) => {
+  return new Promise(function (resolve, reject) {
     const requestData = {
       userId: userId,
       groups: groups || [],
@@ -708,14 +615,9 @@ const updateUserGroups = (
  * @param {String} password The current password
  * @param {String} newPassword The new password
  * @param {String} token Authorization token
- * @returns {Promise<Object>}
  */
-const updateUserPassword = (
-  password: string,
-  newPassword: string,
-  token: string
-): Promise<object> => {
-  return new Promise((resolve, reject) => {
+export const updateUserPassword = (password, newPassword, token) => {
+  return new Promise(function (resolve, reject) {
     const requestData = {
       password: password,
       newPassword: newPassword,
@@ -741,18 +643,17 @@ const updateUserPassword = (
  * Validate reset password code. It returns a promise
  * @param {String} email User's email address
  * @param {String} code Provided reset code
- * @returns {Promise<Object>}
  */
-const validateResetPasswordCode = (
-  email: string,
-  code: string
-): Promise<object> => {
-  return new Promise((resolve, reject) => {
+export const validateResetPasswordCode = (email, code) => {
+  return new Promise(function (resolve, reject) {
     let postData = {
       email: email,
       code: code,
     };
-    let request = client.post("api/v1/users/validateresetpasswordcode", postData);
+    let request = client.post(
+      "api/v1/users/validateresetpasswordcode",
+      postData
+    );
     request
       .then((response) => {
         resolve(response.data);
@@ -763,7 +664,7 @@ const validateResetPasswordCode = (
   });
 };
 
-export default {
+const users = {
   addAPIToken,
   confirmEmailAddress,
   confirmPhone,
@@ -778,17 +679,17 @@ export default {
   getUsers,
   inviteUsers,
   login,
-  loginExchangeKeys,
   logout,
   refreshToken,
   removeAPIToken,
   resendInvitationEmails,
   resetPassword,
-  sendEmailConfirmationCode,
   sendPasswordResetNotification,
   setUserInformation,
   updateUserEmail,
   updateUserGroups,
   updateUserPassword,
   validateResetPasswordCode,
-};
+};
+
+export default users;

package/lib/utils.js

@@ -0,0 +1,48 @@
+import dotenv from "dotenv";
+// Load environment variables from .env file
+dotenv.config();
+
+/**
+ * Convert object to array
+ * @param {Object} data
+ * @returns {Array}
+ */
+export const objectToArray = (data) => {
+  if (typeof data === "object") {
+    return [...data];
+  } else throw new Error("Invalid type");
+};
+
+/**
+ * Returns the backend base API URL
+ * @returns {String}
+ */
+export const getBaseUrl = () => {
+  if (!process.env.NODE_ENV || process.env.NODE_ENV === "production") {
+    return "https://api.stackfactor.io/";
+  } else {
+    return "http://localhost:3100/";
+  }
+};
+
+/**
+ * Remove null properties
+ * @param {Object} object
+ * @returns {Object}
+ */
+export const removeNullProperties = (object) => {
+  Object.keys(object).forEach((key) => {
+    let value = object[key.toString()];
+    let hasProperties = value && Object.keys(value).length > 0;
+    if (value === null) {
+      delete object[key.toString()];
+    } else if (typeof value !== "string" && hasProperties) {
+      removeNullProperties(value);
+    }
+  });
+  return object;
+};
+
+const utils = { getBaseUrl, objectToArray, removeNullProperties };
+
+export default utils;