pink-bears/src/backend-template/index.js

Intelligent rate limiting middleware with MongoDB integration and caching for Node.js applications

const constants = await require("../constants/index");
const { initHandlers } = require("../appnest-backup/sparrowapps-helper/index");
const { hasExpired } = require("../helpers/index");

const { $Storage, $Fetch } = initHandlers();
const { baseUrl, endPoints, grantType, httpMethods } = constants;

class BackendTemplate {
  constructor(appnestUserId, productId, userId, clientId, clientSecret, redirectUri, IntegrationName) {
    Object.assign(this, {
      appnestUserId,
      productId, 
      userId,
      clientId,
      clientSecret,
      redirectUri,
      IntegrationName
    });
  }

  async checkHasFeature(featureName) {
    try {
      const feature = await this.makeRequest({
        appnestUserId: this.appnestUserId,
        userId: this.userId,
        method: httpMethods.GET,
        endPoint: endPoints.featureEndpoint,
        queryString: `feature_name=${featureName}`,
      });
      return feature?.data.data.feature_exists;
    } catch (error) {
      this.logError('Error while checking feature', error);
      throw error;
    }
  }

  async makeRequest({
    method,
    endPoint,
    queryString = null,
    payload,
    apiKey,
  }) {
    try {
      let accessToken = apiKey;

      if (!apiKey) {
        accessToken = await this.getAccessToken();
      }

      const url = `${baseUrl}${endPoint}${queryString ? `?${queryString}` : ''}`;
      const apiConfig = {
        headers: { Authorization: `Bearer ${accessToken}` },
        isOAuth: false,
        maxAttempts: 5,
      };

      this.logApiRequest(method, url, payload);

      return await this.executeRequest(method, url, payload, apiConfig);
    } catch (error) {
      this.logError('Error while making request', error);
      throw error;
    }
  }

  async getAccessToken() {
    const storage = await $Storage.getV2(this.userId);
    let { accessToken, refreshToken, expiresIn } = storage;

    if (hasExpired(expiresIn)) {
      const refreshedToken = await this.refreshAccessToken(refreshToken);
      accessToken = refreshedToken.data.access_token;
      
      await $Storage.setV2(this.userId, {
        ...storage,
        accessToken,
        expiresIn: new Date(
          (Math.floor(Date.now() / 1000) + refreshedToken.data.expires_in) * 1000
        ),
      });
    }

    return accessToken;
  }

  async refreshAccessToken(refreshToken) {
    const refreshPayload = {
      client_id: this.clientId,
      client_secret: this.clientSecret,
      grant_type: grantType.refreshToken,
      refresh_token: refreshToken,
    };

    return await $Fetch.post(
      `${baseUrl}${endPoints.tokenEndpoint}`,
      refreshPayload
    );
  }

  executeRequest(method, url, payload, apiConfig) {
    const methodMap = {
      [httpMethods.GET]: () => $Fetch.get(url, apiConfig),
      [httpMethods.POST]: () => $Fetch.post(url, payload, apiConfig),
      [httpMethods.PUT]: () => $Fetch.put(url, payload, apiConfig),
      [httpMethods.DELETE]: () => $Fetch.delete(url, apiConfig),
    };

    const requestMethod = methodMap[method];
    if (!requestMethod) {
      throw new Error(`Unsupported method: ${method}`);
    }

    return requestMethod();
  }

  logApiRequest(method, url, payload) {
    console.log(
      `<------------- [${this.IntegrationName}] Api request => ${method} Url => ${url} ${
        payload ? `Payload => ${JSON.stringify(payload)}` : ''
      } ------------->`
    );
  }

  logError(message, error) {
    console.error(
      `[${this.IntegrationName}] ${message} for userId ${this.appnestUserId}`,
      error
    );
  }

  async setStorageV2({ key, data }) {
    try {
      const userData = (await $Storage.getV2(this.userId)) || {};
      userData[key] = data;
      return await $Storage.setV2(this.userId, { ...userData });
    } catch (error) {
      this.logError('Error while setting storage', error);
      throw error;
    }
  }

  async getStorageV2({ key }) {
    try {
      const userData = (await $Storage.getV2(this.userId)) || {};
      return userData[key];
    } catch (error) {
      this.logError('Error while getting storage', error);
      throw error;
    }
  }

  async getUser() {
    try {
      const user = await this.makeRequest({
        appnestUserId: this.appnestUserId,
        method: httpMethods.GET,
        endPoint: endPoints.usersEndpoint,
      });
      return user?.data.data.filter(user => user.current_user);
    } catch (error) {
      this.logError('Error while getting user', error);
      throw error;
    }
  }

  async exchangeAuthCode(code) {
    const payload = {
      grant_type: grantType.authorizationCode,
      code,
      redirect_uri: this.redirectUri,
      client_id: this.clientId,
      client_secret: this.clientSecret,
    };
    return await $Fetch.post(`${baseUrl}${endPoints.tokenEndpoint}`, payload, {});
  }
}

module.exports = BackendTemplate;