function _graphAPI()

in src/utils/graphAPIUtils.js [55:159]
104 lines of code
16 McCabe index (conditional complexity)

function _graphAPI(
  apiVersion: ?string,
  apiPath: string,
  method: 'GET' | 'POST' | 'DELETE',
  data: Object,
): Promise<Object> {
  return new Promise((resolve, reject) => {
    const urlPrefix = apiVersion != null
      ? `https://graph.facebook.com/${apiVersion}`
      : 'https://graph.facebook.com';
    const baseParams = {
      hostname: 'graph.facebook.com',
      port: 443,
      method,
    };
    let params;
    let jsonData;
    if (method === 'GET') {
      const encodedParams = [];
      if (data) {
        for (let key in data) {
          encodedParams.push(
            `${encodeURIComponent(key)}=${encodeURIComponent(data[key])}`,
          );
        }
      }
      const path = encodedParams.length > 0
        ? `${urlPrefix}/${apiPath}?${encodedParams.join('&')}`
        : `${urlPrefix}/${apiPath}`;
      params = {
        ...baseParams,
        path,
      };
    } else if (method === 'POST' || method === 'DELETE') {
      let headers;
      if (data != null) {
        jsonData = stringify(data);
        headers = {
          'Content-Type': 'application/json',
          'Content-Length': Buffer.byteLength(jsonData),
        };
      }
      params = {
        ...baseParams,
        path: `${urlPrefix}/${apiPath}`,
        headers,
      };
    } else {
      winston.error(`Invalid API method: ${method}`);
      process.exit(1);
    }

    const req = https.request(
      params || {},
      res => {
        let body = '';
        res.setEncoding('utf8');
        res.on('data', d => {
          body += d;
        });
        res.on('end', () => {
          let parsedResponse, error;
          if (res.statusCode === 200) {
            try {
              parsedResponse = JSON.parse(body);
            } catch (ex) {
              reject(new Error('Invalid JSON: ' + body));
              return;
            }
            error = getErrorFromAPIResponse(parsedResponse);
            if (error) {
              reject(_wrapError(error));
            } else {
              resolve(parsedResponse);
            }
          } else {
            const genericError = _wrapError({
              code: 1,
              error_subcode: ERROR_CODE_EMPTY_RESPONSE,
              is_network_error: true,
            });
            try {
              parsedResponse = JSON.parse(body);
              error = getErrorFromAPIResponse(parsedResponse);
              if (error) {
                reject(_wrapError(error));
              } else {
                reject(genericError);
              }
            } catch (ex) {
              reject(genericError);
            }
          }
        });
      },
    );
    req.on('error', error => {
      reject(error);
    });
    if (jsonData != null) {
      req.write(jsonData);
    }
    req.end();
  });
}