@kepi0809/gatsby-source-greenhouse/gatsby-node.js

Gatsby source plugin for loading job posts from greenhouse.io

"use strict";

/**
 * Return all open jobs for a given department
 * @param apiToken string.
 * @param departmentId string.
 */
let getJobsForDepartment = (() => {
  var _ref = _asyncToGenerator(function*(apiToken, departmentId) {
    return axios.get("https://harvest.greenhouse.io/v1/jobs", {
      params: {
        department_id: departmentId,
        status: "open"
      },
      auth: {
        username: apiToken,
        password: ""
      }
    });
  });

  return function getJobsForDepartment(_x, _x2) {
    return _ref.apply(this, arguments);
  };
})();

/**
 * Return all job posts
 * @param apiToken string.
 * @param queryParams object, defaults to only live job posts
 */

let getJobPosts = (() => {
  var _ref2 = _asyncToGenerator(function*(apiToken, queryParams) {
    return axios.get("https://harvest.greenhouse.io/v1/job_posts", {
      params: queryParams,
      auth: {
        username: apiToken,
        password: ""
      }
    });
  });

  return function getJobPosts(_x3, _x4) {
    return _ref2.apply(this, arguments);
  };
})();

/**
 * Gets all departments for a given organization
 * @param apiToken string.
 */

let getDepartments = (() => {
  var _ref3 = _asyncToGenerator(function*(apiToken) {
    return axios.get("https://harvest.greenhouse.io/v1/departments", {
      auth: {
        username: apiToken,
        password: ""
      }
    });
  });

  return function getDepartments(_x5) {
    return _ref3.apply(this, arguments);
  };
})();

/**
 * Gatsby requires ID to be a string to define nodes and greenhouse.io uses an integer instead.
 *
 * @param obj object.
 * @returns object.
 */

var _nodes = require("./nodes");

function _asyncToGenerator(fn) {
  return function() {
    var gen = fn.apply(this, arguments);
    return new Promise(function(resolve, reject) {
      function step(key, arg) {
        try {
          var info = gen[key](arg);
          var value = info.value;
        } catch (error) {
          reject(error);
          return;
        }
        if (info.done) {
          resolve(value);
        } else {
          return Promise.resolve(value).then(
            function(value) {
              step("next", value);
            },
            function(err) {
              step("throw", err);
            }
          );
        }
      }
      return step("next");
    });
  };
}

const crypto = require("crypto");
const axios = require("axios");
const changeId = obj => {
  const updatedObj = obj;
  updatedObj.id = updatedObj.id.toString();
  return updatedObj;
};

const defaultPluginOptions = {
  jobPosts: {
    live: true
  }
};

exports.sourceNodes = (() => {
  var _ref4 = _asyncToGenerator(function*(
    { boundActionCreators },
    { apiToken, pluginOptions }
  ) {
    const createNode = boundActionCreators.createNode;

    const options = pluginOptions || defaultPluginOptions;

    console.log(`Fetch Greenhouse data`);

    console.log(`Starting to fetch data from Greenhouse`);

    let departments, jobPosts;
    try {
      departments = yield getDepartments(apiToken).then(function(response) {
        return response.data;
      });
      jobPosts = yield getJobPosts(apiToken, options.jobPosts).then(function(
        response
      ) {
        return response.data;
      });
    } catch (e) {
      console.log(`Failed to fetch data from Greenhouse`);
      process.exit(1);
    }

    console.log(`jobPosts fetched`, jobPosts.length);
    console.log(`departments fetched`, departments.length);
    return Promise.all(
      departments.map(
        (() => {
          var _ref5 = _asyncToGenerator(function*(department) {
            const convertedDepartment = changeId(department);

            let jobs;
            try {
              const jobsForDepartmentResults = yield getJobsForDepartment(
                apiToken,
                convertedDepartment.id
              );
              jobs = jobsForDepartmentResults.data.map(function(job) {
                return changeId(job);
              });
            } catch (e) {
              console.log(`Failed to fetch jobs for department.`);
              process.exit(1);
            }

            var jobPostsMapping = jobPosts.reduce(function(map, jobPost) {
              map[jobPost.job_id] = jobPost;
              return map;
            }, {});

            var officesForDepartment = jobs.reduce(function(arr, job) {
              arr = [];
              const jobOfOffice = [];
              const offices = job.offices.filter(
                sourceOffice =>
                  !arr.find(office => office.id === sourceOffice.id)
              );

              if (offices && offices.length > 0) {
                for (let i = 0, l = offices.length; i < l; i++) {
                  const jobsOfOffice = jobs.filter(job =>
                    job.offices.find(
                      jobOffice => jobOffice.id === offices[i].id
                    )
                  );
                  arr.push({ ...offices[i], jobs: jobsOfOffice });
                }
              }
              return arr;
            }, []);

            var jobPostsForDepartment = jobs.reduce(function(arr, job) {
              const mappedJobPost = jobPostsMapping[job.id];
              if (mappedJobPost) {
                mappedJobPost.offices = job.offices.map(office =>
                  changeId(office)
                );
                arr.push(mappedJobPost);
              }
              return arr;
            }, []);

            convertedDepartment.jobPosts = jobPostsForDepartment;
            const departmentNode = (0, _nodes.DepartmentNode)(
              changeId(convertedDepartment)
            );

            departmentNode.jobs = jobs;

            jobs.forEach(job => {
              const convertedJob = {
                ...changeId(job),
                offices: job.offices.map(office => changeId(office))
              };

              const jobNode = (0, _nodes.JobNode)(convertedJob);
              createNode(jobNode);
            });

            officesForDepartment.forEach(function(office) {
              const convertedOffice = changeId(office);
              const officeNode = (0, _nodes.OfficeNode)(convertedOffice, {
                parent: departmentNode.id
              });
              createNode(officeNode);
            });

            jobPostsForDepartment.forEach(function(jobPost) {
              const jobOfJobpost = jobs.find(
                job => Number(job.id) === jobPost.job_id
              );
              const convertedJobPost = {
                ...changeId(jobPost),
                job: { ...jobOfJobpost, id: Number(jobOfJobpost.id) }
              };

              const jobPostNode = (0, _nodes.JobPostNode)(convertedJobPost, {
                parent: departmentNode.id
              });
              createNode(jobPostNode);
            });
            createNode(departmentNode);
          });

          return function(_x8) {
            return _ref5.apply(this, arguments);
          };
        })()
      )
    );
  });

  return function(_x6, _x7) {
    return _ref4.apply(this, arguments);
  };
})();