@foxtware/mineral 0.1.8 → 0.1.10

package/api/utils.js

@@ -10,6 +10,10 @@ const { getWorkspace } = require('./workspace');
 const wait = (ms) => new Promise((resolve, reject) => setTimeout(resolve, ms));
 
 const objHasAny = (obj, keys) => {
+  if (obj == null || typeof obj !== 'object') {
+    return false;
+  }
+
   return keys.some((key) => obj[key] !== undefined);
 };
 
@@ -104,6 +108,30 @@ const getResponseParser = (contentType) => {
   return (res) => res.text(); // safe default
 };
 
+const objectToFormData = (object) => {
+  const formData = new FormData();
+  for (const [key, value] of Object.entries(object)) {
+    formData.append(key, value);
+  }
+  return formData;
+};
+
+const bodyPassesThrough = (body) => {
+  if (body == null) {
+    return false;
+  }
+
+  if (typeof body === 'string') {
+    return true;
+  }
+
+  if (body instanceof FormData) {
+    return true;
+  }
+
+  return typeof body.getHeaders === 'function';
+};
+
 const customFetch = async (url, {
   method = 'get',
   headers = {},
@@ -119,7 +147,11 @@ const customFetch = async (url, {
     headers['x-request-id'] = String(Date.now());
   }
 
-  if (body && !headers['Content-Type']) {
+  if (body?.getHeaders) {
+    Object.assign(headers, body.getHeaders());
+  }
+
+  if (body && !headers['Content-Type'] && !bodyPassesThrough(body)) {
     headers['Content-Type'] = 'application/json';
   }
 
@@ -138,11 +170,11 @@ const customFetch = async (url, {
       const response = await fetch(url, {
         method,
         headers,
-        ...body 
-          ? { body: typeof body === 'string' 
-              ? body 
-              : JSON.stringify(body) 
-          } : {},
+        ...body && {
+          body: bodyPassesThrough(body)
+            ? body
+            : JSON.stringify(body),
+        },
       });
 
       const responseContentType = response.headers.get('content-type');
@@ -412,89 +444,57 @@ class Chain {
   }
 }
 
-// TODO: client wrapper enabling auth and retrying with different auth
-
 class FetchClient {
   constructor({
-    context, // necessary data for preparer and interpreters to refer to    
-    requestPreparer, // a function that updates requests before sending
-    responseInterpreter, // a function that transforms responses to report back
+    pipeline = ['fetch'], // an array of functions that transform the request and response, including a string 'fetch' step.
   } = {}) {
-    this.context = context;
-    this.requestPreparer = requestPreparer; // can be a Chain
-    this.responseInterpreter = responseInterpreter; // can be a Chain  
+    if (!this.pipelineHasFetchStep(pipeline)) {
+      throw new Error('Pipeline must have a fetch step');
+    }
+    this.pipeline = pipeline;
+  }
+
+  pipelineHasFetchStep = (pipeline) => {
+    return pipeline.find(step => step === 'fetch');
+  }
+
+  async #fetch(state) {
+    const { requestPayload } = state;
+
+    return {
+      response: await customFetch(
+        requestPayload.url,
+        requestPayload,
+      ),
+    };
   }
 
   async fetch({
-    url,
+    // url, body, etc.
+    requestPayload,
 
-    // customFetch payload
-    method,
-    headers,
-    params,
-    body,
-    
-    responseInterpreter,
+    // additional information to inform behaviour
+    context,
 
-    context = {},
+    // options for the fetch itself, as opposed to data it uses
     inspect = false,
   } = {}) {
 
-    let mergedContext = {
-      ...(this.context ?? {}),
-      ...(context ?? {}),
-    };
-    inspect && logDeep({ mergedContext });
-    inspect && await askQuestion('?');
-
-    let requestPayload = {
-      url,
-      ...(method ? { method } : {}),
-      ...(headers ? { headers } : {}),
-      ...(params ? { params } : {}),
-      ...(body ? { body } : {}),
-    };
-    inspect && logDeep({ requestPayload });
-    inspect && await askQuestion('?');
-
-    if (this.requestPreparer) {
-      if (this.requestPreparer.run) {
-        ({ requestPayload, context: mergedContext } = await this.requestPreparer.run(
-          { requestPayload, context: mergedContext },
-          { inspect },
-        ));
-      } else {
-        const result = await this.requestPreparer(requestPayload, mergedContext);
-        if (result) {
-          requestPayload = result;
-        }
-      }
-    }
-    inspect && logDeep({ requestPayload, mergedContext });
-    inspect && await askQuestion('?');
+    const { pipeline } = this;
+
+    const pipelineChain = new Chain(pipeline.map(step => {
+      return step === 'fetch' 
+        ? this.#fetch 
+        : step;
+    }));
 
-    let response = await customFetch(
-      requestPayload.url,
+    // fetch step will add response to this, for subsequent steps
+    const state = await pipelineChain.run({
       requestPayload,
-    );
-    inspect && logDeep({ response });
-    inspect && await askQuestion('?');
-    
-    const usedResponseInterpreter = responseInterpreter || this.responseInterpreter;
-    if (usedResponseInterpreter) {
-      if (usedResponseInterpreter.run) {
-        ({ response, context: mergedContext } = await usedResponseInterpreter.run(
-          { response, context: mergedContext },
-          { inspect },
-        ));
-      } else {
-        response = await usedResponseInterpreter(response, mergedContext);
-      }
-    }
-    inspect && logDeep({ response });
-    inspect && await askQuestion('?');
+      context,
+    }, { inspect });
 
-    return response;
+    return state.response;
   }
 }
 
@@ -606,6 +606,17 @@ const ensureArray = (value) => {
   return [value];
 };
 
+const objectArrayToJsonl = (objects) => {
+  return objects.map((object) => JSON.stringify(object)).join('\n');
+};
+
+const jsonlToObjectArray = (jsonl) => {
+  return jsonl
+    .split('\n')
+    .filter((line) => line.trim())
+    .map((line) => JSON.parse(line));
+};
+
 const everyIfArray = (func, value) => {
   if (Array.isArray(value)) {
     if (value.length === 0) {
@@ -1153,7 +1164,10 @@ module.exports = {
   Chain,
   FetchClient,
   fetchClientCommonSteps,
+  objectToFormData,
   ensureArray,
+  objectArrayToJsonl,
+  jsonlToObjectArray,
   everyIfArray,
   simpleSort,
   arrayToChunks,
@@ -1167,4 +1181,4 @@ module.exports = {
   sentenceCaseString,
   ArgsWarden,
   gidToId,
-};
+};

package/api/validators.js

@@ -9,4 +9,4 @@ const credsValidator = (creds) => {
 
 module.exports = {
   credsValidator,
-};
+};

package/api/workable/workable.constants.js

@@ -0,0 +1,3 @@
+module.exports = {
+  MAX_PER_PAGE: 100,
+};

package/api/workable/workable.utils.js

@@ -0,0 +1,41 @@
+const { resolveCreds } = require('../pipelineSteps');
+const {
+  FetchClient,
+  appendUrlToBase,
+  fetchClientCommonSteps,
+} = require('../utils');
+
+// TODO: Allow creds failure (e.g. missing BASE_URL / ACCESS_TOKEN → INVALID_CREDS before fetch)
+const useAuthHeaders = async (state) => {
+  const { requestPayload, context } = state;
+  const { creds } = context;
+  const {
+    BASE_URL,
+    ACCESS_TOKEN,
+  } = creds;
+
+  return {
+    requestPayload: {
+      ...requestPayload,
+      url: appendUrlToBase(BASE_URL, requestPayload.url),
+      headers: {
+        Accept: 'application/json',
+        Authorization: `Bearer ${ ACCESS_TOKEN }`,
+        ...requestPayload.headers,
+      },
+    },
+  };
+};
+
+const workableClient = new FetchClient({
+  pipeline: [
+    resolveCreds,
+    useAuthHeaders,
+    'fetch',
+    fetchClientCommonSteps.exitEarlyOnNotOk,
+  ],
+});
+
+module.exports = {
+  workableClient,
+};

package/api/workable/workableGet.js

@@ -0,0 +1,151 @@
+// https://workable.readme.io/reference/jobs
+
+const { ArgsWarden, Getter } = require('../utils');
+const { credsValidator } = require('../validators');
+const { workableClient } = require('../workable/workable.utils');
+const { MAX_PER_PAGE } = require('../workable/workable.constants');
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+  ['url'],
+]);
+
+const digResults = (data, resultsKey) => {
+  if (resultsKey) {
+    return data?.[resultsKey] ?? [];
+  }
+
+  const arrayEntry = Object.entries(data || {}).find(([, value]) => Array.isArray(value));
+  return arrayEntry ? arrayEntry[1] : [];
+};
+
+const workableGetPacket = async (
+  credsPayload,
+  url,
+  {
+    params,
+    perPage = MAX_PER_PAGE,
+  } = {},
+) => {
+  return workableClient.fetch({
+    requestPayload: {
+      url,
+      params: {
+        limit: Math.min(perPage, MAX_PER_PAGE),
+        ...params,
+      },
+    },
+    context: {
+      credsPayload,
+    },
+  });
+};
+
+const workableGetPaginator = async (currentParams, response) => {
+  const { args, options } = currentParams;
+
+  if (!response?.ok) {
+    return [true];
+  }
+
+  const nextUrl = response?.data?.paging?.next;
+  if (!nextUrl) {
+    return [true];
+  }
+
+  const nextParams = Object.fromEntries(new URL(nextUrl).searchParams.entries());
+
+  return [false, {
+    args,
+    options: {
+      ...options,
+      params: nextParams,
+    },
+  }];
+};
+
+const workableGet = async (
+  returnGetter,
+
+  credsPayload,
+  url,
+  {
+    params,
+    perPage = MAX_PER_PAGE,
+    resultsKey,
+    ...getterOptions
+  } = {},
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({
+    credsPayload,
+    url,
+  });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  const getter = new Getter(
+    {
+      args: [credsPayload, url],
+      options: {
+        params,
+        perPage,
+      },
+    },
+    {
+      func: workableGetPacket,
+      digester: (response) => {
+        if (!response?.ok) {
+          return [];
+        }
+
+        return digResults(response.data, resultsKey);
+      },
+      paginator: workableGetPaginator,
+      ...getterOptions,
+    },
+  );
+
+  if (returnGetter) {
+    return getter;
+  }
+
+  const data = await getter.run({ returnAll: true });
+
+  return {
+    ok: true,
+    data,
+  };
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  workableGet: (...args) => workableGet(false, ...args),
+  workableGetter: (...args) => workableGet(true, ...args),
+  funcApiConfig,
+};
+
+/*
+curl -X POST "http://localhost:8000/workableGet" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "workable" },
+    "url": "/jobs"
+  }'
+
+curl -X POST "http://localhost:8000/workableGet" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "workable" },
+    "url": "/jobs",
+    "options": {
+      "params": { "state": "published" },
+      "resultsKey": "jobs",
+      "limit": 10
+    }
+  }'
+*/

package/api/workable/workableJobCandidateCreate.js

@@ -0,0 +1,87 @@
+// https://workable.readme.io/reference/job-candidates-create
+
+const { ArgsWarden } = require('../utils');
+const { credsValidator } = require('../validators');
+const { workableClient } = require('../workable/workable.utils');
+
+const candidateValidator = (candidate) => {
+  return Boolean(candidate) && typeof candidate === 'object';
+};
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+  ['shortcode'],
+  ['candidate', candidateValidator],
+]);
+
+const workableJobCandidateCreate = async (
+  credsPayload,
+  shortcode,
+  candidate,
+  {
+    stage,
+    sourced = true,
+  } = {},
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({
+    credsPayload,
+    shortcode,
+    candidate,
+  });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  return workableClient.fetch({
+    requestPayload: {
+      url: `/jobs/${ shortcode }/candidates`,
+      method: 'post',
+      body: {
+        sourced,
+        ...stage !== undefined && { stage },
+        candidate,
+      },
+    },
+    context: {
+      credsPayload,
+    },
+  });
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  workableJobCandidateCreate,
+  funcApiConfig,
+};
+
+/*
+curl -X POST "http://localhost:8000/workableJobCandidateCreate" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "workable" },
+    "shortcode": "RKT001",
+    "candidate": {
+      "name": "Jessie",
+      "email": "jessie@teamrocket.org"
+    }
+  }'
+
+curl -X POST "http://localhost:8000/workableJobCandidateCreate" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "workable" },
+    "shortcode": "RKT001",
+    "candidate": {
+      "name": "James",
+      "email": "james@teamrocket.org"
+    },
+    "options": {
+      "sourced": false,
+      "stage": "applied"
+    }
+  }'
+*/

package/api/workable/workableJobGet.js

@@ -0,0 +1,52 @@
+// https://workable.readme.io/reference/jobsshortcode
+
+const { ArgsWarden } = require('../utils');
+const { credsValidator } = require('../validators');
+const { workableClient } = require('../workable/workable.utils');
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+  ['shortcode'],
+]);
+
+const workableJobGet = async (
+  credsPayload,
+  shortcode,
+  options = {},
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({
+    credsPayload,
+    shortcode,
+  });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  return workableClient.fetch({
+    requestPayload: {
+      url: `/jobs/${ shortcode }`,
+    },
+    context: {
+      credsPayload,
+    },
+  });
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  workableJobGet,
+  funcApiConfig,
+};
+
+/*
+curl -X POST "http://localhost:8000/workableJobGet" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "workable" },
+    "shortcode": "RKT001"
+  }'
+*/

package/api/workable/workableJobMembersGet.js

@@ -0,0 +1,52 @@
+// https://workable.readme.io/reference/job-members
+
+const { ArgsWarden } = require('../utils');
+const { credsValidator } = require('../validators');
+const { workableClient } = require('../workable/workable.utils');
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+  ['shortcode'],
+]);
+
+const workableJobMembersGet = async (
+  credsPayload,
+  shortcode,
+  options = {},
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({
+    credsPayload,
+    shortcode,
+  });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  return workableClient.fetch({
+    requestPayload: {
+      url: `/jobs/${ shortcode }/members`,
+    },
+    context: {
+      credsPayload,
+    },
+  });
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  workableJobMembersGet,
+  funcApiConfig,
+};
+
+/*
+curl -X POST "http://localhost:8000/workableJobMembersGet" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "workable" },
+    "shortcode": "RKT001"
+  }'
+*/

package/api/workable/workableJobStagesGet.js

@@ -0,0 +1,52 @@
+// https://workable.readme.io/reference/job-stages
+
+const { ArgsWarden } = require('../utils');
+const { credsValidator } = require('../validators');
+const { workableClient } = require('../workable/workable.utils');
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+  ['shortcode'],
+]);
+
+const workableJobStagesGet = async (
+  credsPayload,
+  shortcode,
+  options = {},
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({
+    credsPayload,
+    shortcode,
+  });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  return workableClient.fetch({
+    requestPayload: {
+      url: `/jobs/${ shortcode }/stages`,
+    },
+    context: {
+      credsPayload,
+    },
+  });
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  workableJobStagesGet,
+  funcApiConfig,
+};
+
+/*
+curl -X POST "http://localhost:8000/workableJobStagesGet" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "workable" },
+    "shortcode": "RKT001"
+  }'
+*/