@foxtware/mineral 0.1.8 → 0.1.10

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,139 @@
+const { 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 (
+  credsPayload,
+  url,
+  {
+    params,
+    perPage = MAX_PER_PAGE,
+    paginate = true,
+  } = {},
+) => {
+  return loopClient.fetch({
+    requestPayload: {
+      url,
+      ...(paginate && {
+        params: {
+          paginate: true,
+          pageSize: perPage,
+          ...params,
+        },
+      }),
+    },
+    context: {
+      credsPayload,
+    },
+  });
+};
+
+const loopGetPaginator = async (currentParams, response) => {
+  const { args } = currentParams;
+
+  if (!response?.ok) {
+    return [true];
+  }
+
+  const nextPageUrl = response?.data?.nextPageUrl;
+  if (!nextPageUrl) {
+    return [true];
+  }
+
+  const [credsPayload] = args;
+
+  return [false, {
+    args: [credsPayload, 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 getter = new Getter(
+    {
+      args: [credsPayload, url],
+      options: {
+        params,
+        perPage,
+      },
+    },
+    {
+      func: loopGetPacket,
+      digester: (response) => {
+        if (!response?.ok) {
+          return [];
+        }
+
+        if (resultsKey) {
+          return response?.data?.[resultsKey] ?? [];
+        }
+
+        return [];
+      },
+      paginator: loopGetPaginator,
+      ...getterOptions,
+    },
+  );
+
+  if (returnGetter) {
+    return getter;
+  }
+
+  const data = await getter.run({ returnAll: true });
+
+  return {
+    ok: true,
+    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 { 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 params = {
+    ...returnId && { return_id: returnId },
+    ...orderId && { order_id: orderId },
+    ...orderName && { order_name: orderName },
+  };
+
+  return loopClient.fetch({
+    requestPayload: {
+      url: '/warehouse/return/details',
+      params,
+    },
+    context: {
+      credsPayload,
+    },
+  });
+};
+
+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.constants.js

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

package/api/peoplevox/peoplevox.sessions.js

@@ -0,0 +1,54 @@
+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);
+};
+
+module.exports = {
+  getSessionId,
+  setSessionId,
+};

package/api/peoplevox/peoplevox.utils.js

@@ -1,7 +1,12 @@
 const csvtojson = require('csvtojson');
 const xml2js = require('xml2js');
-const { FetchClient, credsFromPayload, appendUrlToBase, logDeep, Chain } = require('../utils');
-const { peoplevoxAuthGet } = require('../peoplevox/peoplevoxAuthGet');
+const { resolveCreds } = require('../pipelineSteps');
+const {
+  FetchClient,
+  appendUrlToBase,
+  logDeep,
+} = require('../utils');
+const { getSessionId, setSessionId } = require('../peoplevox/peoplevox.sessions');
 
 const xml2jsBuilder = new xml2js.Builder({
   headless: true,
@@ -45,46 +50,38 @@ const buildSoapEnvelope = ({
   return xml2jsBuilder.buildObject(envelopeObject);
 };
 
-// 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 { 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(',');
+const useSoapEnvelope = async (state) => {
+  const { requestPayload, context } = state;
+  const { creds, action, sessionId } = context;
+  const { CLIENT_ID } = creds;
 
-    localSessionId = responseSessionId;
+  if (!sessionId) {
+    throw new Error('PeopleVox sessionId is required');
   }
 
   const baseUrl = `https://ap.peoplevox.net/${ CLIENT_ID }/Resources/IntegrationServicev4.asmx`;
+  const { headers, body } = requestPayload;
 
   const envelopeXml = buildSoapEnvelope({
     action,
     body,
     clientId: CLIENT_ID,
-    sessionId: localSessionId,
+    sessionId,
   });
 
   logDeep({ envelopeXml });
 
   return {
-    ...requestPayload,
-    url: appendUrlToBase(baseUrl, requestPayload.url),
-    headers: {
-      ...headers,
-      'Content-Type': 'text/xml; charset=utf-8',
-      'SOAPAction': `http://www.peoplevox.net/${ action }`,
+    requestPayload: {
+      ...requestPayload,
+      url: appendUrlToBase(baseUrl, requestPayload.url),
+      headers: {
+        ...headers,
+        'Content-Type': 'text/xml; charset=utf-8',
+        'SOAPAction': `http://www.peoplevox.net/${ action }`,
+      },
+      body: envelopeXml,
     },
-    body: envelopeXml,
   };
 };
 
@@ -177,15 +174,54 @@ const hoistDetail = (state) => {
 };
 
 const peoplevoxClient = new FetchClient({
-  requestPreparer: peoplevoxRequestPreparer,
-  responseInterpreter: new Chain([
+  pipeline: [
+    resolveCreds,
+    useSoapEnvelope,
+    'fetch',
     stripEnvelope,
     tryToParseDetailAsCsv,
     unwrapSingleDetail,
     hoistDetail,
-  ]),
+  ],
 });
 
+const fetchWithoutAuth = peoplevoxClient.fetch.bind(peoplevoxClient);
+
+peoplevoxClient.fetch = async ({
+  requestPayload,
+  context = {},
+  inspect = false,
+}) => {
+  const { credsPayload } = context;
+
+  const sessionIdResponse = await getSessionId(credsPayload);
+
+  const {
+    ok: sessionIdOk,
+    data: sessionId,
+  } = sessionIdResponse;
+
+  if (!sessionIdOk) {
+    return sessionIdResponse;
+  }
+
+  const response = await fetchWithoutAuth({
+    requestPayload,
+    context: {
+      ...context,
+      sessionId,
+    },
+    inspect,
+  });
+
+  if (response.ok) {
+    await setSessionId(credsPayload, sessionId);
+  }
+
+  // TODO: Check if it was an auth error, and try another auth method if so
+  return response;
+};
+
 module.exports = {
   peoplevoxClient,
-};
+};

package/api/peoplevox/peoplevoxGetSingle.js

@@ -32,11 +32,13 @@ const peoplevoxGetSingle = async (
   const resolvedSearchClause = searchClause || `${ idName }.Equals("${ id }")`;
 
   const response = await peoplevoxClient.fetch({
-    method: 'post',
-    body: {
-      getRequest: {
-        TemplateName: templateName,
-        SearchClause: resolvedSearchClause,
+    requestPayload: {
+      method: 'post',
+      body: {
+        getRequest: {
+          TemplateName: templateName,
+          SearchClause: resolvedSearchClause,
+        },
       },
     },
     context: {

package/api/peoplevox/peoplevoxOrderEdit.js

@@ -37,11 +37,13 @@ const peoplevoxOrderEdit = async (
   }
 
   return peoplevoxClient.fetch({
-    method: 'post',
-    body: {
-      saveRequest: {
-        TemplateName: 'Sales orders',
-        CsvData: csvData,
+    requestPayload: {
+      method: 'post',
+      body: {
+        saveRequest: {
+          TemplateName: 'Sales orders',
+          CsvData: csvData,
+        },
       },
     },
     context: {

package/api/peoplevox/peoplevoxReportGet.js

@@ -25,15 +25,17 @@ const peoplevoxReportGet = async (
   }
 
   const reportGetResponse = await peoplevoxClient.fetch({
-    method: 'post',
-    body: {
-      getReportRequest: {
-        TemplateName: reportName,
-        ...(searchClause ? { SearchClause: searchClause } : {}),
-        ...(perPage ? { ItemsPerPage: perPage } : {}),
-        ...(filter ? { FilterClause: filter } : {}),
-        ...(orderBy ? { OrderBy: orderBy } : {}),
-        ...(columns ? { Columns: columns.join(',') } : {}),
+    requestPayload: {
+      method: 'post',
+      body: {
+        getReportRequest: {
+          TemplateName: reportName,
+          ...(searchClause ? { SearchClause: searchClause } : {}),
+          ...(perPage ? { ItemsPerPage: perPage } : {}),
+          ...(filter ? { FilterClause: filter } : {}),
+          ...(orderBy ? { OrderBy: orderBy } : {}),
+          ...(columns ? { Columns: columns.join(',') } : {}),
+        },
       },
     },
     context: {

package/api/pipelineSteps.js

@@ -0,0 +1,49 @@
+const { appendUrlToBase, credsFromPayload } = require('./utils');
+
+const resolveCreds = async (state) => {
+  const { context } = state;
+  const { creds, credsPayload } = context;
+
+  if (creds || !credsPayload) {
+    return {};
+  }
+
+  const resolvedCreds = await credsFromPayload(credsPayload);
+
+  return {
+    context: {
+      ...context,
+      creds: resolvedCreds,
+    },
+  };
+};
+
+const useBaseUrl = (baseUrl) => async (state) => {
+  const { requestPayload, context } = state;
+  const resolvedBaseUrl = baseUrl ?? context.baseUrl;
+
+  if (!resolvedBaseUrl) {
+    return {
+      breakChain: true,
+      response: {
+        ok: false,
+        error: {
+          code: 'NO_BASE_URL',
+          message: 'No base URL provided',
+        },
+      },
+    };
+  }
+
+  return {
+    requestPayload: {
+      ...requestPayload,
+      url: appendUrlToBase(resolvedBaseUrl, requestPayload.url),
+    },
+  };
+};
+
+module.exports = {
+  resolveCreds,
+  useBaseUrl,
+};

package/api/shopify/shopify.utils.js

@@ -1,7 +1,7 @@
 const { DEFAULT_API_VERSION } = require('../shopify/shopify.constants');
+const { resolveCreds } = require('../pipelineSteps');
 const {
   FetchClient,
-  Chain,
   appendUrlToBase,
   fetchClientCommonSteps,
   pathAsArray,
@@ -49,11 +49,11 @@ const handleMutationUserErrors = async (state) => {
   };
 };
 
-const addUrlAndAuthHeaders = async (state) => {
+const useUrlAndAuthHeaders = async (state) => {
   const { requestPayload, context } = state;
   const {
-    creds,
     apiVersion = DEFAULT_API_VERSION,
+    creds,
   } = context;
   const {
     STORE_HANDLE,
@@ -61,15 +61,13 @@ const addUrlAndAuthHeaders = async (state) => {
   } = creds;
 
   const baseUrl = `https://${ STORE_HANDLE }.myshopify.com/admin/api/${ apiVersion }/graphql.json`;
-  const baseHeaders = {
-    'X-Shopify-Access-Token': API_KEY,
-  };
 
   return {
     requestPayload: {
+      ...requestPayload,
       url: appendUrlToBase(baseUrl, requestPayload.url),
       headers: {
-        ...baseHeaders,
+        'X-Shopify-Access-Token': API_KEY,
         ...requestPayload.headers,
       },
     },
@@ -99,25 +97,21 @@ const movePageInfoToMeta = async (state) => {
   };
 };
 
-const shopifyClientRequestPreparer = new Chain([
-  addUrlAndAuthHeaders,
-]);
-
-const shopifyClientResponseInterpreter = new Chain([
-  movePageInfoToMeta,
-  fetchClientCommonSteps.stripEdgesAndNodes,
-  fetchClientCommonSteps.collapseDataWithOneValue,
-  fetchClientCommonSteps.exitEarlyOnNotOk,
-  fetchClientCommonSteps.exitEarlyOnGraphqlErrors,
-  fetchClientCommonSteps.digToPath,
-  handleMutationUserErrors,
-]);
-
 const shopifyClient = new FetchClient({
-  requestPreparer: shopifyClientRequestPreparer,
-  responseInterpreter: shopifyClientResponseInterpreter,
+  pipeline: [
+    resolveCreds,
+    useUrlAndAuthHeaders,
+    'fetch',
+    movePageInfoToMeta,
+    fetchClientCommonSteps.stripEdgesAndNodes,
+    fetchClientCommonSteps.collapseDataWithOneValue,
+    fetchClientCommonSteps.exitEarlyOnNotOk,
+    fetchClientCommonSteps.exitEarlyOnGraphqlErrors,
+    fetchClientCommonSteps.digToPath,
+    handleMutationUserErrors,
+  ],
 });
 
 module.exports = {
   shopifyClient,
-};
+};