@foxtware/mineral 0.1.8 → 0.1.9

package/.creds.yml.sample

@@ -26,4 +26,25 @@ linear:
   API_KEY: _______________________________
 
 slack:
-  BOT_TOKEN: xoxb________________________________
+  BOT_TOKEN: xoxb_________________________
+
+workable:
+  BASE_URL: https://[subdomain].workable.com/spi/v3
+  ACCESS_TOKEN: __________________________
+
+loop:
+  au:
+    API_KEY: _____________________________
+
+upstash:
+  BASE_URL: https://________.upstash.io
+  TOKEN: ______________________________
+
+supabase:
+  project:
+    BASE_URL: https://_____.supabase.co
+    API_KEY: __________________________
+
+stripe:
+  API_KEY: sk__________________________
+

package/api/loop/loop.constants.js

@@ -0,0 +1,7 @@
+const LOOP_API_BASE_URL = 'https://api.loopreturns.com/api/v1';
+const MAX_PER_PAGE = 750;
+
+module.exports = {
+  LOOP_API_BASE_URL,
+  MAX_PER_PAGE,
+};

package/api/loop/loop.utils.js

@@ -0,0 +1,43 @@
+const { LOOP_API_BASE_URL } = require('../loop/loop.constants');
+const {
+  FetchClient,
+  Chain,
+  appendUrlToBase,
+  fetchClientCommonSteps,
+} = require('../utils');
+
+// TODO: Allow creds failure (e.g. missing API_KEY → INVALID_CREDS before fetch)
+const addUrlAndAuthHeaders = async (state) => {
+  const { requestPayload, context } = state;
+  const { creds } = context;
+  const { API_KEY } = creds;
+
+  return {
+    requestPayload: {
+      ...requestPayload,
+      url: appendUrlToBase(LOOP_API_BASE_URL, requestPayload.url),
+      headers: {
+        'Content-Type': 'application/json',
+        'X-Authorization': API_KEY,
+        ...requestPayload.headers,
+      },
+    },
+  };
+};
+
+const loopClientRequestPreparer = new Chain([
+  addUrlAndAuthHeaders,
+]);
+
+const loopClientResponseInterpreter = new Chain([
+  fetchClientCommonSteps.exitEarlyOnNotOk,
+]);
+
+const loopClient = new FetchClient({
+  requestPreparer: loopClientRequestPreparer,
+  responseInterpreter: loopClientResponseInterpreter,
+});
+
+module.exports = {
+  loopClient,
+};

package/api/loop/loopAllowlistItemsGet.js

@@ -0,0 +1,42 @@
+const { ArgsWarden } = require('../utils');
+const { credsValidator } = require('../validators');
+const { loopGet } = require('../loop/loopGet');
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+]);
+
+const loopAllowlistItemsGet = async (
+  credsPayload,
+  {
+    ...getterOptions
+  } = {},
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({ credsPayload });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  return loopGet(credsPayload, '/allowlists', {
+    resultsKey: 'data',
+    ...getterOptions,
+  });
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  loopAllowlistItemsGet,
+  funcApiConfig,
+};
+
+/*
+curl -X POST "http://localhost:8000/loopAllowlistItemsGet" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "loop.au" }
+  }'
+*/

package/api/loop/loopBlocklistItemsGet.js

@@ -0,0 +1,46 @@
+const { ArgsWarden } = require('../utils');
+const { credsValidator } = require('../validators');
+const { loopGet } = require('../loop/loopGet');
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+]);
+
+const loopBlocklistItemsGet = async (
+  credsPayload,
+  {
+    ...getterOptions
+  } = {},
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({ credsPayload });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  return loopGet(credsPayload, '/blocklists', {
+    resultsKey: 'data',
+    ...getterOptions,
+  });
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  loopBlocklistItemsGet,
+  funcApiConfig,
+};
+
+/*
+curl -X POST "http://localhost:8000/loopBlocklistItemsGet" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "loop.au" },
+    "options": {
+      "limit": 20,
+      "perPage": 7
+    }
+  }'
+*/

package/api/loop/loopDestinationsGet.js

@@ -0,0 +1,42 @@
+const { ArgsWarden } = require('../utils');
+const { credsValidator } = require('../validators');
+const { loopGet } = require('../loop/loopGet');
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+]);
+
+const loopDestinationsGet = async (
+  credsPayload,
+  {
+    ...getterOptions
+  } = {},
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({ credsPayload });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  return loopGet(credsPayload, '/destinations', {
+    resultsKey: 'destinations',
+    ...getterOptions,
+  });
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  loopDestinationsGet,
+  funcApiConfig,
+};
+
+/*
+curl -X POST "http://localhost:8000/loopDestinationsGet" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "loop.au" }
+  }'
+*/

package/api/loop/loopGet.js

@@ -0,0 +1,143 @@
+const { credsFromPayload, ArgsWarden, Getter } = require('../utils');
+const { credsValidator } = require('../validators');
+const { loopClient } = require('../loop/loop.utils');
+const { MAX_PER_PAGE } = require('../loop/loop.constants');
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+  ['url'],
+]);
+
+const loopGetPacket = async (
+  creds,
+  url,
+  {
+    params,
+    perPage = MAX_PER_PAGE,
+    paginate = true,
+  } = {},
+) => {
+  return loopClient.fetch({
+    url,
+    ...(paginate && {
+      params: {
+        paginate: true,
+        pageSize: perPage,
+        ...params,
+      },
+    }),
+    context: {
+      creds,
+    },
+  });
+};
+
+const loopGetPaginator = async (currentParams, response) => {
+  const { args } = currentParams;
+
+  if (!response?.ok) {
+    return [true];
+  }
+
+  const nextPageUrl = response?.data?.nextPageUrl;
+  if (!nextPageUrl) {
+    return [true];
+  }
+
+  const [creds] = args;
+
+  return [false, {
+    args: [creds, nextPageUrl],
+    options: {
+      paginate: false,
+    },
+  }];
+};
+
+const loopGet = async (
+  returnGetter,
+
+  credsPayload,
+  url,
+  {
+    params,
+    perPage = MAX_PER_PAGE,
+    resultsKey,
+    ...getterOptions
+  } = {},
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({
+    credsPayload,
+    url,
+  });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  const creds = await credsFromPayload(credsPayload);
+
+  let firstError = null;
+
+  const getter = new Getter(
+    {
+      args: [creds, url],
+      options: {
+        params,
+        perPage,
+      },
+    },
+    {
+      func: loopGetPacket,
+      digester: (response) => {
+        if (!response?.ok) {
+          firstError = response;
+          return [];
+        }
+
+        if (resultsKey) {
+          return response?.data?.[resultsKey] ?? [];
+        }
+
+        return [];
+      },
+      paginator: loopGetPaginator,
+      ...getterOptions,
+    },
+  );
+
+  if (returnGetter) {
+    return getter;
+  }
+
+  const data = await getter.run({ returnAll: true });
+
+  if (firstError) {
+    return firstError;
+  }
+
+  return data;
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  loopGet: (...args) => loopGet(false, ...args),
+  loopGetter: (...args) => loopGet(true, ...args),
+  funcApiConfig,
+};
+
+/*
+curl -X POST "http://localhost:8000/loopGet" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "loop.au" },
+    "url": "/warehouse/return/list",
+    "options": {
+      "resultsKey": "returns",
+      "limit": 10
+    }
+  }'
+*/

package/api/loop/loopReturnGet.js

@@ -0,0 +1,73 @@
+// https://docs.loopreturns.com/api-reference/latest/return-data/get-return-details
+
+const { credsFromPayload, objHasAny, ArgsWarden } = require('../utils');
+const { credsValidator } = require('../validators');
+const { loopClient } = require('../loop/loop.utils');
+
+const returnIdentifierValidator = (returnIdentifier) => {
+  return objHasAny(returnIdentifier, [
+    'returnId',
+    'orderId',
+    'orderName',
+  ]);
+};
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+  ['returnIdentifier', returnIdentifierValidator],
+]);
+
+const loopReturnGet = async (
+  credsPayload,
+  returnIdentifier,
+  options = {},
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({
+    credsPayload,
+    returnIdentifier,
+  });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  const {
+    returnId,
+    orderId,
+    orderName,
+  } = returnIdentifier;
+
+  const creds = await credsFromPayload(credsPayload);
+
+  const params = {
+    ...returnId && { return_id: returnId },
+    ...orderId && { order_id: orderId },
+    ...orderName && { order_name: orderName },
+  };
+
+  return loopClient.fetch({
+    url: '/warehouse/return/details',
+    params,
+    context: {
+      creds,
+    },
+  });
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  loopReturnGet,
+  funcApiConfig,
+};
+
+/*
+curl -X POST "http://localhost:8000/loopReturnGet" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "loop.au" },
+    "returnIdentifier": { "returnId": "85747906" }
+  }'
+*/

package/api/loop/loopReturnsGet.js

@@ -0,0 +1,46 @@
+const { ArgsWarden } = require('../utils');
+const { credsValidator } = require('../validators');
+const { loopGet } = require('../loop/loopGet');
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+]);
+
+const loopReturnsGet = async (
+  credsPayload,
+  {
+    ...getterOptions
+  } = {},
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({ credsPayload });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  return loopGet(credsPayload, '/warehouse/return/list', {
+    resultsKey: 'returns',
+    ...getterOptions,
+  });
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  loopReturnsGet,
+  funcApiConfig,
+};
+
+/*
+curl -X POST "http://localhost:8000/loopReturnsGet" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "loop.au" },
+    "options": {
+      "limit": 20,
+      "perPage": 7
+    }
+  }'
+*/

package/api/peoplevox/peoplevox.sessions.js

@@ -0,0 +1,87 @@
+const { HOSTED } = require('../constants');
+const { credsFromPayload } = require('../utils');
+const { peoplevoxAuthGet } = require('./peoplevoxAuthGet');
+
+// TODO: Track where auth comes from in order to facilitate retrying
+// TODO: Consider only storing auth when successful request goes through
+
+const SESSION_IDS = new Map();
+
+const getSessionId = async (credsPayload) => {
+  const { CLIENT_ID } = await credsFromPayload(credsPayload);
+
+  let sessionId = SESSION_IDS.get(CLIENT_ID);
+
+  if (sessionId) {
+    !HOSTED && console.log('Peoplevox auth: from memory');
+    return {
+      ok: true,
+      data: sessionId,
+      meta: {
+        source: 'memory',
+      },
+    };
+  }
+
+  const authResponse = await peoplevoxAuthGet(credsPayload);
+
+  if (!authResponse.ok) {
+    return authResponse;
+  }
+
+  const { Detail } = authResponse?.data?.['soap:Envelope']?.['soap:Body']?.['AuthenticateResponse']?.['AuthenticateResult'];
+  const [, responseSessionId] = Detail.split(',');
+
+  SESSION_IDS.set(CLIENT_ID, responseSessionId);
+  !HOSTED && console.log('Peoplevox auth: from API');
+  return {
+    ok: true,
+    data: responseSessionId,
+    meta: {
+      source: 'api',
+    },
+  };
+};
+
+const setSessionId = async (credsPayload, sessionId) => {
+  const { CLIENT_ID } = await credsFromPayload(credsPayload);
+  SESSION_IDS.set(CLIENT_ID, sessionId);
+};
+
+const withPeoplevoxAuth = async (fetchPayload, next) => {
+  const { context = {} } = fetchPayload;
+  const { credsPayload } = context;
+
+  const sessionIdResponse = await getSessionId(credsPayload);
+
+  const { 
+    ok: sessionIdOk, 
+    data: sessionId,
+  } = sessionIdResponse;
+
+  if (!sessionIdOk) {
+    return sessionIdResponse;
+  }
+
+  const response = await next({
+    ...fetchPayload,
+    context: {
+      ...context,
+      sessionId,
+    },
+  });
+
+  if (response.ok) {
+    await setSessionId(credsPayload, sessionId);
+    return response;
+  }
+  
+  // TODO: Check if it was an auth error, and try another auth method if so
+  return response;
+};
+
+module.exports = {
+  getSessionId,
+  setSessionId,
+  withPeoplevoxAuth,
+};

package/api/peoplevox/peoplevox.utils.js

@@ -1,7 +1,7 @@
 const csvtojson = require('csvtojson');
 const xml2js = require('xml2js');
 const { FetchClient, credsFromPayload, appendUrlToBase, logDeep, Chain } = require('../utils');
-const { peoplevoxAuthGet } = require('../peoplevox/peoplevoxAuthGet');
+const { withPeoplevoxAuth } = require('../peoplevox/peoplevox.sessions');
 
 const xml2jsBuilder = new xml2js.Builder({
   headless: true,
@@ -48,21 +48,11 @@ const buildSoapEnvelope = ({
 // TODO: Split into multiple steps, allow mutating context
 const peoplevoxRequestPreparer = async (requestPayload, context) => {
   const { headers, body } = requestPayload;
-  const { credsPayload, action } = context;
-  let { sessionId: localSessionId } = context;
+  const { credsPayload, action, sessionId } = context;
   const { CLIENT_ID } = await credsFromPayload(credsPayload);
 
-  if (!localSessionId) {
-    const authResponse = await peoplevoxAuthGet(credsPayload);
-
-    if (!authResponse.ok) {
-      return { ...authResponse, breakChain: true };
-    }
-
-    const { Detail } = authResponse?.data?.['soap:Envelope']?.['soap:Body']?.['AuthenticateResponse']?.['AuthenticateResult'];
-    const [, responseSessionId] = Detail.split(',');
-
-    localSessionId = responseSessionId;
+  if (!sessionId) {
+    throw new Error('PeopleVox sessionId is required');
   }
 
   const baseUrl = `https://ap.peoplevox.net/${ CLIENT_ID }/Resources/IntegrationServicev4.asmx`;
@@ -71,7 +61,7 @@ const peoplevoxRequestPreparer = async (requestPayload, context) => {
     action,
     body,
     clientId: CLIENT_ID,
-    sessionId: localSessionId,
+    sessionId,
   });
 
   logDeep({ envelopeXml });
@@ -186,6 +176,8 @@ const peoplevoxClient = new FetchClient({
   ]),
 });
 
+peoplevoxClient.use(withPeoplevoxAuth);
+
 module.exports = {
   peoplevoxClient,
 };

package/api/shopify/shopifyCollectionGet.js

@@ -75,7 +75,7 @@ const shopifyCollectionGet = async (
   return shopifyGetSingle(
     credsPayload,
     'collection',
-    collectionIdentifier,
+    id,
     {
       apiVersion,
       attrs,

package/api/shopify/shopifyTagsAdd.js

@@ -7,7 +7,7 @@ const { shopifyMutationDo } = require('../shopify/shopifyMutationDo');
 const argsWarden = new ArgsWarden([
   ['credsPayload', credsValidator],
   ['gid'],
-  ['tags', Array],
+  ['tags', Array.isArray],
 ]);
 
 const defaultAttrs = 'id';

package/api/shopify/shopifyTagsRemove.js

@@ -7,7 +7,7 @@ const { shopifyMutationDo } = require('../shopify/shopifyMutationDo');
 const argsWarden = new ArgsWarden([
   ['credsPayload', credsValidator],
   ['gid'],
-  ['tags', Array],
+  ['tags', Array.isArray],
 ]);
 
 const defaultAttrs = 'id';

package/api/stripe/_example.js

@@ -0,0 +1,48 @@
+const { credsFromPayload, ArgsWarden } = require('../utils');
+const { credsValidator } = require('../validators');
+const { stripeClient } = require('../stripe/stripe.utils');
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+  ['arg'],
+]);
+
+const FUNC = async (
+  credsPayload,
+  arg,
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({ credsPayload, arg });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  const creds = await credsFromPayload(credsPayload);
+
+  const response = await stripeClient.fetch({
+    url: '/things',
+    method: 'post',
+    body: { arg },
+    context: { creds },
+  });
+
+  return response;
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  FUNC,
+  funcApiConfig,
+};
+
+/*
+curl -X POST "http://localhost:8000/FUNC" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "stripe" },
+    "arg": "1234"
+  }'
+*/

package/api/stripe/stripe.constants.js

@@ -0,0 +1,5 @@
+const BASE_URL = 'https://api.stripe.com/v1';
+
+module.exports = {
+  BASE_URL,
+};