@foxtware/mineral 0.1.0

package/api/linear/linearIssuesGet.js

@@ -0,0 +1,106 @@
+// https://linear.app/developers/graphql
+
+const { credsFromPayload, ArgsWarden } = require('../utils');
+const { credsValidator } = require('../validators');
+const { linearClient } = require('../linear/linear.utils');
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+]);
+
+const linearIssuesGet = async (
+  credsPayload,
+  {
+    first = 50,
+    teamId,
+    inspect = false,
+  } = {},
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({
+    credsPayload,
+  });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  const creds = await credsFromPayload(credsPayload);
+
+  const filter = teamId
+    ? { team: { id: { eq: teamId } } }
+    : undefined;
+
+  const response = await linearClient.fetch({
+    body: {
+      query: `
+        query IssuesGet($first: Int!, $filter: IssueFilter) {
+          issues(first: $first, filter: $filter) {
+            nodes {
+              id
+              identifier
+              title
+              priority
+              createdAt
+              updatedAt
+              state {
+                id
+                name
+              }
+              team {
+                id
+                name
+              }
+              assignee {
+                id
+                name
+              }
+            }
+          }
+        }
+      `,
+      variables: {
+        first,
+        ...(filter && { filter }),
+      },
+    },
+    context: { creds },
+    inspect,
+  });
+
+  if (!response.ok) {
+    return response;
+  }
+
+  const issues = response.data?.data?.issues?.nodes ?? [];
+
+  return {
+    ok: true,
+    data: issues,
+  };
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  linearIssuesGet,
+  funcApiConfig,
+};
+
+/*
+curl -X POST "http://localhost:8000/linearIssuesGet" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "linear" }
+  }'
+
+curl -X POST "http://localhost:8000/linearIssuesGet" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "linear" },
+    "options": {
+      "first": 5
+    }
+  }'
+*/

package/api/peoplevox/_example.js

@@ -0,0 +1,49 @@
+const { credsValidator } = require('../validators');
+const { logDeep, ArgsWarden } = require('../utils');
+const { peoplevoxGetSingle } = require('../peoplevox/peoplevoxGetSingle');
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+  ['salesOrderNumber'],
+]);
+
+const FUNC = async (
+  credsPayload,
+  salesOrderNumber,
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({ credsPayload, salesOrderNumber });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  const response = await peoplevoxGetSingle(
+    credsPayload,
+    'Sales orders',
+    {
+      id: salesOrderNumber,
+      idName: 'SalesOrderNumber',
+    },
+  );
+
+  logDeep('response', response);
+  return response;
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  FUNC,
+  funcApiConfig,
+};
+
+/*
+curl -X POST "http://localhost:8000/FUNC" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "peoplevox" },
+    "salesOrderNumber": "5977690603592"
+  }'
+*/

package/api/peoplevox/peoplevox.constants.js

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

package/api/peoplevox/peoplevox.utils.js

@@ -0,0 +1,191 @@
+const csvtojson = require('csvtojson');
+const xml2js = require('xml2js');
+const { FetchClient, credsFromPayload, appendUrlToBase, logDeep, Chain } = require('../utils');
+const { peoplevoxAuthGet } = require('../peoplevox/peoplevoxAuthGet');
+
+const xml2jsBuilder = new xml2js.Builder({
+  headless: true,
+  renderOpts: {
+    pretty: false,
+  },
+});
+
+const buildSoapEnvelope = ({
+  action,
+  body,
+  clientId,
+  sessionId,
+}) => {
+  const envelopeObject = {
+    'soap:Envelope': {
+      '$': {
+        'xmlns:soap': 'http://schemas.xmlsoap.org/soap/envelope/',
+      },
+      'soap:Header': {
+        'UserSessionCredentials': {
+          '$': {
+            'xmlns': 'http://www.peoplevox.net/',
+          },
+          'UserId': 1,
+          'ClientId': clientId,
+          'SessionId': sessionId,
+        },
+      },
+      'soap:Body': {
+        [action]: {
+          '$': {
+            'xmlns': 'http://www.peoplevox.net/',
+          },
+          ...body,
+        },
+      },
+    },
+  };
+
+  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(',');
+
+    localSessionId = responseSessionId;
+  }
+
+  const baseUrl = `https://ap.peoplevox.net/${ CLIENT_ID }/Resources/IntegrationServicev4.asmx`;
+
+  const envelopeXml = buildSoapEnvelope({
+    action,
+    body,
+    clientId: CLIENT_ID,
+    sessionId: localSessionId,
+  });
+
+  logDeep({ envelopeXml });
+
+  return {
+    ...requestPayload,
+    url: appendUrlToBase(baseUrl, requestPayload.url),
+    headers: {
+      ...headers,
+      'Content-Type': 'text/xml; charset=utf-8',
+      'SOAPAction': `http://www.peoplevox.net/${ action }`,
+    },
+    body: envelopeXml,
+  };
+};
+
+const stripEnvelope = (state) => {
+  const { response, context } = state;
+  const { action } = context;
+
+  if (!response?.data) {
+    return {};
+  }
+
+  return {
+    response: {
+      data: response.data?.['soap:Envelope']?.['soap:Body']?.[`${ action }Response`]?.[`${ action }Result`],
+    },
+  };
+};
+
+const tryToParseDetailAsCsv = async (state) => {
+  const { response } = state;
+
+  if (!response?.ok || !response?.data?.Detail) {
+    return {};
+  }
+
+  const { Detail } = response.data;
+
+  if (typeof Detail !== 'string') {
+    return {};
+  }
+
+  let parsedDetail = Detail;
+
+  try {
+    const parsed = await csvtojson().fromString(Detail);
+
+    if (parsed.length || !Detail.trim()) {
+      parsedDetail = parsed;
+    }
+  } catch (error) {
+    console.warn('error parsing Detail', error, Detail);
+  }
+
+  return {
+    response: {
+      data: {
+        Detail: parsedDetail,
+      },
+    },
+  };
+};
+
+const unwrapSingleDetail = (state) => {
+  const { response } = state;
+
+  if (!response?.ok || !Array.isArray(response?.data?.Detail)) {
+    return {};
+  }
+
+  const { Detail } = response.data;
+
+  if (Detail.length !== 1) {
+    return {};
+  }
+
+  return {
+    response: {
+      data: {
+        Detail: Detail[0],
+      },
+    },
+  };
+};
+
+const hoistDetail = (state) => {
+  const { response } = state;
+
+  if (!response?.ok || !response?.data || response.data.Detail === undefined) {
+    return {};
+  }
+
+  const { Detail, ...metaFromData } = response.data;
+
+  return {
+    response: {
+      data: Detail,
+      meta: metaFromData,
+    },
+  };
+};
+
+const peoplevoxClient = new FetchClient({
+  requestPreparer: peoplevoxRequestPreparer,
+  responseInterpreter: new Chain([
+    stripEnvelope,
+    tryToParseDetailAsCsv,
+    unwrapSingleDetail,
+    hoistDetail,
+  ]),
+});
+
+module.exports = {
+  peoplevoxClient,
+};

package/api/peoplevox/peoplevoxAuthGet.js

@@ -0,0 +1,99 @@
+const { credsFromPayload, customFetch, ArgsWarden } = require('../utils');
+const { credsValidator } = require('../validators');
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+]);
+
+const peoplevoxAuthGet = async (
+  credsPayload,
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({ credsPayload });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  const {
+    CLIENT_ID,
+    USERNAME,
+    PASSWORD,
+  } = await credsFromPayload(credsPayload);
+
+  const url = `https://ap.peoplevox.net/${ CLIENT_ID }/Resources/IntegrationServicev4.asmx`;
+
+  const headers = {
+    'Content-Type': 'text/xml; charset=utf-8',
+    'SOAPAction': 'http://www.peoplevox.net/Authenticate',
+  };
+
+  const envelope = `
+    <soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
+      <soap:Body>
+        <Authenticate xmlns="http://www.peoplevox.net/">
+          <clientId>${ CLIENT_ID }</clientId>
+          <username>${ USERNAME }</username>
+          <password>${ btoa(PASSWORD) }</password>
+        </Authenticate>
+      </soap:Body>
+    </soap:Envelope>
+  `.trim();
+
+  const response = await customFetch(
+    url,
+    {
+      headers,
+      method: 'post',
+      body: envelope,
+    },
+  );
+
+  /* e.g.
+  'soap:Envelope': {
+    'soap:Body': {
+      AuthenticateResponse: {
+        AuthenticateResult: {
+          ResponseId: '0',
+          TotalCount: '1',
+          Detail: 'abc123,9999999-3e02-46a3-bb7c-9dca6b9db243',
+          Statuses: '',
+          ImportingQueueId: '0',
+          SalesOrdersToDespatchIds: '',
+          ErrorCode: ''
+        }
+      }
+    }
+  }
+  */
+
+  return response;
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  peoplevoxAuthGet,
+  funcApiConfig,
+};
+
+/*
+curl -X POST "http://localhost:8000/peoplevoxAuthGet" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": {
+      "credsObject": {
+        "CLIENT_ID": "aveng1963",
+        "USERNAME": "bannerb",
+        "PASSWORD": "$MASh123!"
+      }
+    }
+  }'
+
+curl -X POST "http://localhost:8000/peoplevoxAuthGet" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "peoplevox" }
+  }'
+*/

package/api/peoplevox/peoplevoxGetSingle.js

@@ -0,0 +1,119 @@
+const { peoplevoxClient } = require('../peoplevox/peoplevox.utils');
+const { credsValidator } = require('../validators');
+const { ArgsWarden } = require('../utils');
+
+const searchParametersValidator = ({ searchClause, id, idName }) => {
+  return searchClause || (id && idName);
+};
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+  ['templateName'],
+  ['searchParameters', searchParametersValidator],
+]);
+
+const peoplevoxGetSingle = async (
+  credsPayload,
+  templateName,
+  searchParameters = {},
+  options = {},
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({
+    credsPayload,
+    templateName,
+    searchParameters,
+  });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  const { searchClause, id, idName } = searchParameters;
+  const resolvedSearchClause = searchClause || `${ idName }.Equals("${ id }")`;
+
+  const response = await peoplevoxClient.fetch({
+    method: 'post',
+    body: {
+      getRequest: {
+        TemplateName: templateName,
+        SearchClause: resolvedSearchClause,
+      },
+    },
+    context: {
+      credsPayload,
+      action: 'GetData',
+    },
+  });
+
+  if (!response.ok) {
+    return response;
+  }
+
+  const { data } = response;
+
+  const multipleResults = Array.isArray(data) && data.length > 1;
+
+  if (!multipleResults) {
+    return response;
+  }
+
+  if (id && idName) {
+    const targetResults = data.filter(result => result[idName] === id);
+
+    const stillMultipleResults = Array.isArray(targetResults) && targetResults.length > 1;
+    if (stillMultipleResults) {
+      return {
+        ok: false,
+        error: {
+          code: 'MULTIPLE_RESULTS',
+          message: 'Multiple results found',
+          details: targetResults,
+        },
+      };
+    }
+
+    if (targetResults.length === 0) {
+      return {
+        ok: false,
+        error: {
+          code: 'NOT_FOUND',
+          message: 'No results found',
+        },
+      };
+    }
+
+    return {
+      ...response,
+      data: targetResults[0],
+    };
+  }
+
+  return response;
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  peoplevoxGetSingle,
+  funcApiConfig,
+};
+
+/*
+curl -X POST "http://localhost:8000/peoplevoxGetSingle" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "peoplevox" },
+    "templateName": "Sales orders",
+    "searchParameters": { "id": "7680864157768", "idName": "SalesOrderNumber" }
+  }'
+
+curl -X POST "http://localhost:8000/peoplevoxGetSingle" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "peoplevox" },
+    "templateName": "Sales orders",
+    "searchParameters": { "searchClause": "SalesOrderNumber.Equals(\"7680864157768\")" }
+  }'
+*/

package/api/peoplevox/peoplevoxOrderEdit.js

@@ -0,0 +1,82 @@
+const { json2csv } = require('json-2-csv');
+const { credsValidator } = require('../validators');
+const { ensureArray, everyIfArray, ArgsWarden } = require('../utils');
+const { peoplevoxClient } = require('../peoplevox/peoplevox.utils');
+const { MAX_REQUEST_ITEMS } = require('../peoplevox/peoplevox.constants');
+
+const orderPayloadValidator = (orderPayload) => orderPayload?.SalesOrderNumber;
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+  ['orderPayload', (i) => everyIfArray(orderPayloadValidator, i)],
+]);
+
+const peoplevoxOrderEdit = async (
+  credsPayload,
+  orderPayload,
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({ credsPayload, orderPayload });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  // TODO: Consider making CSV transformation a request preparer step
+  const csvData = await json2csv(ensureArray(orderPayload));
+  
+  // TODO: Handle by chunking
+  // TODO: Chunk objects by common fields so that each call has a consistent schema - bedrock groupObjectsByFields
+  if (csvData.length > MAX_REQUEST_ITEMS) {
+    return {
+      ok: false,
+      error: {
+        code: 'MAX_REQUEST_ITEMS_EXCEEDED',
+        message: `Max request items exceeded. Max is ${ MAX_REQUEST_ITEMS }.`,
+      },
+    };
+  }
+
+  return peoplevoxClient.fetch({
+    method: 'post',
+    body: {
+      saveRequest: {
+        TemplateName: 'Sales orders',
+        CsvData: csvData,
+      },
+    },
+    context: {
+      credsPayload,
+      action: 'SaveData',
+    },
+  });
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  peoplevoxOrderEdit,
+  funcApiConfig,
+};
+
+/*
+curl -X POST "http://localhost:8000/peoplevoxOrderEdit" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "peoplevox" },
+    "orderPayload": { "SalesOrderNumber": "7696610951240", "Attribute1": "Whatever" }
+  }'
+
+Take order off hold:
+curl -X POST "http://localhost:8000/peoplevoxOrderEdit" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "peoplevox" },
+    "orderPayload": {
+      "SalesOrderNumber": "7696610951240",
+      "OnHold": false,
+      "StopShip": false
+    }
+  }'
+*/

package/api/peoplevox/peoplevoxOrderGet.js

@@ -0,0 +1,60 @@
+const { credsValidator } = require('../validators');
+const { ArgsWarden } = require('../utils');
+const { peoplevoxGetSingle } = require('../peoplevox/peoplevoxGetSingle');
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+  ['salesOrderNumber'],
+]);
+
+const peoplevoxOrderGet = async (
+  credsPayload,
+  salesOrderNumber,
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({ credsPayload, salesOrderNumber });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  return peoplevoxGetSingle(
+    credsPayload,
+    'Sales orders',
+    {
+      id: salesOrderNumber,
+      idName: 'SalesOrderNumber',
+    },
+  );
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  peoplevoxOrderGet,
+  funcApiConfig,
+};
+
+/*
+curl localhost:8000/peoplevoxOrderGet \
+  -X POST \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": {
+      "credsObject": {
+        "CLIENT_ID": "kaibacorp",
+        "USERNAME": "Seto",
+        "PASSWORD": "8lu33y3z8e$t"
+      }
+    },
+    "salesOrderNumber": "7680864157768"
+  }'
+
+curl -X POST "http://localhost:8000/peoplevoxOrderGet" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "peoplevox" },
+    "salesOrderNumber": "7680864157768"
+  }'
+*/