@mindful-web/export-framework 1.28.0 → 1.68.7

package/utils/format-text.js

@@ -0,0 +1,69 @@
+const replaceCharacter = (t, from, to) => {
+  let text = t.replace(from, to);
+  if (text.includes(from)) text = replaceCharacter(text, from, to);
+  return text;
+};
+const formatText = (t) => {
+  if (t === null) {
+    return null;
+  }
+  // https://www.compart.com/en/unicode/U+00E3
+  let text = t;
+  const trans = [];
+  trans.push({ from: ' ', to: ' ' });
+  trans.push({ from: '  ', to: ' ' });
+  trans.push({ from: '  ,  ', to: ', ' });
+  trans.push({ from: ' , ', to: ', ' });
+  trans.push({ from: 'ä', to: '<0x00E4>' });
+  trans.push({ from: 'â', to: '<0x00E2>' });
+  trans.push({ from: 'ã', to: '<0x00E3>' });
+  trans.push({ from: 'ß', to: '<0x00DF>' });
+  trans.push({ from: 'ç', to: '<0x00E7>' });
+  trans.push({ from: 'è', to: '<0x00E8>' });
+  trans.push({ from: 'é', to: '<0x00E9>' });
+  trans.push({ from: 'ï', to: '<0x00EF>' });
+  trans.push({ from: 'í', to: '<0x00ED>' });
+  trans.push({ from: 'É', to: '<0x00C9>' });
+  trans.push({ from: 'ñ', to: '<0x00F1>' });
+  trans.push({ from: 'ó', to: '<0x00F3>' });
+  trans.push({ from: 'ö', to: '<0x00F6>' });
+  trans.push({ from: 'ú', to: '<0x00FA>' });
+  trans.push({ from: 'ü', to: '<0x00FC>' });
+  trans.push({ from: 'Ü', to: '<0x00DC>' });
+  trans.push({ from: '&#39;', to: "'" });
+  trans.push({ from: '&quot', to: '"' });
+  trans.push({ from: '&hellip;', to: '<0x2026>' });
+  trans.push({ from: '&frac14;', to: '<0x00BC>' });
+  trans.push({ from: '&frac12;', to: '<0x00BD>' });
+  trans.push({ from: '&frac34;', to: '<0x00BE>' });
+  trans.push({ from: '&lsquo;', to: '<0x2018>' });
+  trans.push({ from: '’', to: '<0x2019>' });
+  trans.push({ from: '&rsquo;', to: '<0x2019>' });
+  trans.push({ from: '“', to: '<0x201C>' });
+  trans.push({ from: '&ldquo;', to: '<0x201C>' });
+  trans.push({ from: '”', to: '<0x201D>' });
+  trans.push({ from: '&rdquo;', to: '<0x201D>' });
+  trans.push({ from: '&bull;', to: '<0x2022>' });
+  trans.push({ from: '|0x2022|', to: '<0x2022>' });
+  trans.push({ from: '&ndash;', to: '<0x2013>' });
+  trans.push({ from: '—', to: '<0x2014>' });
+  trans.push({ from: '&mdash;', to: '<0x2014>' });
+  trans.push({ from: '&trade;', to: '<0x2122>' });
+  trans.push({ from: '&copy;', to: '<0x00A9>' });
+  trans.push({ from: '®', to: '<0x00AE>' });
+  trans.push({ from: '&reg;', to: '<0x00AE>' });
+  trans.push({ from: 'º', to: '<0x00B0>' });
+  trans.push({ from: '&deg;', to: '<0x00B0>' });
+  trans.push({ from: '\\', to: '\\\\' });
+  // eslint-disable-next-line no-useless-escape
+  trans.push({ from: '&lt;', to: '\<' });
+  // eslint-disable-next-line no-useless-escape
+  trans.push({ from: '&gt;', to: '\>' });
+  trans.forEach((tran) => {
+    if (text.includes(tran.from)) text = replaceCharacter(text, tran.from, tran.to);
+  });
+
+  return text.trim();
+};
+
+module.exports = { formatText };

package/utils/get-child-sections.js

@@ -0,0 +1,11 @@
+const { getAsArray } = require('@mindful-web/object-path');
+
+const getChildSections = (section, sections = {}, includeSelf = true) => {
+  const { id } = section;
+  const children = getAsArray(section, 'children.edges').map(({ node }) => node);
+  return {
+    ...children.reduce((obj, child) => getChildSections(child, obj), sections),
+    ...(includeSelf && !section[id] && { [id]: section }),
+  };
+};
+module.exports = { getChildSections };

package/utils/image-handler.js

@@ -0,0 +1,54 @@
+const path = require('path');
+const fetch = require('node-fetch');
+const fs = require('fs');
+const zipFolder = require('zip-folder');
+const AWS = require('aws-sdk');
+
+// AWS credentials are validated at startup by tenants/all/env.js (envalid).
+// We read process.env directly here to avoid coupling this shared util to
+// any particular tenant's env.js location.
+const s3 = new AWS.S3({
+  accessKeyId: process.env.AWS_ACCESS_KEY,
+  secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+});
+
+const downloadImages = async (tmpDir, filePaths) => Promise.all(filePaths.map((url) => {
+  // create the directory if it doesn't exists
+  if (!fs.existsSync(tmpDir)) {
+    fs.mkdirSync(tmpDir, { recursive: true });
+  }
+  const fileName = path.basename(url);
+  return fetch(url).then((res) => {
+    const dest = fs.createWriteStream(`${tmpDir}/${fileName}`);
+    res.body.pipe(dest);
+  });
+}));
+
+const zipItUp = (tmpDirToZip, tmpDirToPlace, exportName) => new Promise((resolve, reject) => {
+  zipFolder(tmpDirToZip, `${tmpDirToPlace}/${exportName}`, (err) => {
+    if (err) {
+      reject();
+    } else {
+      resolve();
+    }
+  });
+});
+
+const uploadToS3 = (bucket, keyPrefix, filePath) => {
+  const fileName = path.basename(filePath);
+  const fileStream = fs.createReadStream(filePath);
+  const keyName = path.join(keyPrefix, fileName);
+  return new Promise((resolve, reject) => {
+    fileStream.once('error', reject);
+    s3.upload(
+      {
+        Bucket: bucket,
+        Key: keyName,
+        Body: fileStream,
+        ContentType: 'application/zip',
+      },
+    ).promise().then(resolve, reject);
+  });
+};
+
+module.exports = { downloadImages, zipItUp, uploadToS3 };

package/utils/paginate-query.js

@@ -0,0 +1,74 @@
+const { getAsArray, getAsObject } = require('@mindful-web/object-path');
+
+// @todo clean this up
+const buildVars = (variables, cursorPath, endCursor) => {
+  const keys = cursorPath.split('.');
+  if (keys.length === 0) {
+    return { ...variables, endCursor };
+  }
+  if (keys.length === 1) {
+    return { ...variables, [keys[0]]: endCursor };
+  }
+  if (keys.length === 2) {
+    const k1 = keys[0];
+    const k2 = keys[1];
+    return {
+      ...variables,
+      [k1]: {
+        ...variables[k1],
+        [k2]: endCursor,
+      },
+    };
+  }
+  if (keys.length === 3) {
+    const k1 = keys[0];
+    const k2 = keys[1];
+    const k3 = keys[2];
+    return {
+      ...variables,
+      [k1]: {
+        ...variables[k1],
+        [k2]: {
+          ...variables[k1][k2],
+          [k3]: endCursor,
+        },
+      },
+    };
+  }
+  throw new Error(`Unable to parse cursorPath ${cursorPath}`);
+};
+
+/**
+ * Returns all results from the specified query
+ * @param results     - The results to accumulate
+ * @param client      - The GraphQL client
+ * @param query       - The GraphQL query
+ * @param variables   - The GraphQL query variables
+ * @param cursorPath  - The dot-notated path within `variables` that the cursor should be placed
+ * @param rootValue   - The root query key, e.g; `data.queryName`
+ */
+const executor = async (args) => {
+  const {
+    results = [],
+    client,
+    query,
+    variables,
+    cursorPath,
+    rootValue,
+  } = args;
+  const r = await client.query({ query, variables }, rootValue);
+  const items = getAsArray(r, `data.${rootValue}.edges`).map(({ node }) => node);
+  const pageInfo = getAsObject(r, `data.${rootValue}.pageInfo`);
+  if (pageInfo.hasNextPage) {
+    const { endCursor } = pageInfo;
+    const vars = buildVars(variables, cursorPath, endCursor);
+    return executor({
+      ...args,
+      variables: vars,
+      results: [...results, ...items],
+    });
+  }
+  return [...results, ...items];
+};
+
+module.exports = executor;

package/utils/replace-characters.js

@@ -0,0 +1,6 @@
+const replaceCharacters = (t, from, to) => {
+  let text = t.replace(from, to);
+  if (text.includes(from)) text = replaceCharacters(text, from, to);
+  return text;
+};
+module.exports = { replaceCharacters };

package/utils/retrieve-companies.js

@@ -0,0 +1,109 @@
+const { get, getAsArray } = require('@mindful-web/object-path');
+const paginateQuery = require('./paginate-query');
+
+/**
+ * Retrieve all published companies for a site, applying optional magazine and section filters.
+ *
+ * Each returned company is augmented with a `sectionIds` array (the section IDs from its
+ * currently-active websiteSchedules) and — when `attachTaxonomyIds` is enabled — a
+ * `taxonomyIds` array (the node IDs from its taxonomy edges).
+ *
+ * Usage examples:
+ *
+ *   // Plain — no magazine filter:
+ *   retrieveCompanies(apollo, query, siteId);
+ *   retrieveCompanies(apollo, query, siteId, { additionalParams: { taxonomyId: 12 } });
+ *
+ *   // With a magazine-schedule filter (company must appear in this issue):
+ *   retrieveCompanies(apollo, query, siteId, {
+ *     magazineSchedule: { sectionId: PRINT_SECTION_ID, issueId: PRINT_ISSUE_ID },
+ *   });
+ *
+ *   // Every option enabled (e.g. for an "industry leaders" style listing).
+ *   // descendantSectionIds is any list of section IDs whose companies should
+ *   // also count as matches, even without an active website schedule.
+ *   retrieveCompanies(apollo, query, siteId, {
+ *     injectSiteIdInQuery: true,
+ *     magazineSchedule: { sectionId: PRINT_SECTION_ID, issueId: PRINT_ISSUE_ID },
+ *     descendantSectionIds: DESCENDANT_SECTION_IDS,
+ *     attachTaxonomyIds: true,
+ *   });
+ *
+ * @param {ApolloClient} apollo  GraphQL client used for paginated queries.
+ * @param {DocumentNode} query   GraphQL query selecting `allPublishedContent` of Companies.
+ * @param {string} [siteId]
+ *        When set, scopes websiteSchedules and primarySite checks to this site.
+ * @param {object} [options]
+ * @param {object}  [options.additionalParams={}]
+ *        Extra fields spread into the GraphQL `input` variables.
+ * @param {boolean} [options.injectSiteIdInQuery=false]
+ *        When true, also injects `siteId` into the GraphQL `input` for server-side filtering.
+ * @param {{sectionId:number, issueId:number}|null} [options.magazineSchedule=null]
+ *        When provided, a company must have a `magazineSchedules` entry matching this
+ *        `{sectionId, issueId}` pair to be included.
+ * @param {number[]} [options.descendantSectionIds=[]]
+ *        Additional inclusion path: companies whose `primarySection.id` is in this list are
+ *        kept even without a website-schedule match (e.g. an "industry leaders" tree where
+ *        every descendant section should also count as a match).
+ * @param {boolean} [options.attachTaxonomyIds=false]
+ *        When true, attach a `taxonomyIds` array derived from `taxonomy.edges` to each result.
+ *
+ * @returns {Promise<object[]>} Array of companies, each with `sectionIds`
+ *          (and optionally `taxonomyIds`).
+ */
+const retrieveCompanies = async (apollo, query, siteId, options = {}) => {
+  const {
+    additionalParams = {},
+    injectSiteIdInQuery = false,
+    magazineSchedule = null,
+    descendantSectionIds = [],
+    attachTaxonomyIds = false,
+  } = options;
+
+  const promise = await paginateQuery({
+    client: apollo,
+    query,
+    variables: {
+      input: {
+        includeContentTypes: 'Company',
+        ...(injectSiteIdInQuery ? { siteId } : null),
+        pagination: { limit: 250 },
+        sort: { field: 'name', order: 'asc' },
+        ...additionalParams,
+      },
+    },
+    cursorPath: 'input.pagination.after',
+    rootValue: 'allPublishedContent',
+  });
+
+  const now = Date.now().valueOf();
+  return promise.reduce((arr, company) => {
+    const sectionIds = (siteId)
+      ? getAsArray(company, 'websiteSchedules')
+        // eslint-disable-next-line max-len
+        .filter(({ section, start, end }) => get(section, 'site.id') === siteId && start < now && (!end || end > now))
+        .map(({ section }) => section.id)
+      : getAsArray(company, 'websiteSchedules')
+        .filter(({ start, end }) => start < now && (!end || end > now))
+        .map(({ section }) => section.id);
+
+    const magazineOk = !magazineSchedule || getAsArray(company, 'magazineSchedules')
+      .some(({ section, issue }) => section.id === magazineSchedule.sectionId
+        && issue.id === magazineSchedule.issueId);
+
+    const sectionOk = sectionIds.length
+      || (siteId && get(company, 'primarySite.id') === siteId)
+      || descendantSectionIds.includes(get(company, 'primarySection.id'));
+
+    if (magazineOk && sectionOk) {
+      const next = { ...company, sectionIds };
+      if (attachTaxonomyIds) {
+        next.taxonomyIds = getAsArray(company, 'taxonomy.edges').map(({ node }) => node.id);
+      }
+      arr.push(next);
+    }
+    return arr;
+  }, []);
+};
+
+module.exports = { retrieveCompanies };

package/utils/retrieve-sections.js

@@ -0,0 +1,8 @@
+const retrieveSections = async (client, query, alias, siteId) => {
+  const { data: { websiteSectionAlias } } = await client.query({
+    query,
+    variables: { input: { alias, siteId } },
+  });
+  return websiteSectionAlias;
+};
+module.exports = { retrieveSections };

package/utils/state-abbreviations-list.js

@@ -0,0 +1,258 @@
+module.exports = [
+  {
+    key: 'AL',
+    name: 'Alabama',
+  },
+  {
+    key: 'AK',
+    name: 'Alaska',
+  },
+  {
+    key: 'AB',
+    name: 'Alberta',
+  },
+  {
+    key: 'AZ',
+    name: 'Arizona',
+  },
+  {
+    key: 'AR',
+    name: 'Arkansas',
+  },
+  {
+    key: 'BC',
+    name: 'British Columbia',
+  },
+  {
+    key: 'CA',
+    name: 'California',
+  },
+  {
+    key: 'CO',
+    name: 'Colorado',
+  },
+  {
+    key: 'CT',
+    name: 'Connecticut',
+  },
+  {
+    key: 'DE',
+    name: 'Delaware',
+  },
+  {
+    key: 'DC',
+    name: 'District of Columbia',
+  },
+  {
+    key: 'FL',
+    name: 'Florida',
+  },
+  {
+    key: 'GA',
+    name: 'Georgia',
+  },
+  {
+    key: 'HI',
+    name: 'Hawaii',
+  },
+  {
+    key: 'ID',
+    name: 'Idaho',
+  },
+  {
+    key: 'IL',
+    name: 'Illinois',
+  },
+  {
+    key: 'IN',
+    name: 'Indiana',
+  },
+  {
+    key: 'IA',
+    name: 'Iowa',
+  },
+  {
+    key: 'KS',
+    name: 'Kansas',
+  },
+  {
+    key: 'KY',
+    name: 'Kentucky',
+  },
+  {
+    key: 'LA',
+    name: 'Louisiana',
+  },
+  {
+    key: 'ME',
+    name: 'Maine',
+  },
+  {
+    key: 'MB',
+    name: 'Manitoba',
+  },
+  {
+    key: 'MD',
+    name: 'Maryland',
+  },
+  {
+    key: 'MA',
+    name: 'Massachusetts',
+  },
+  {
+    key: 'MI',
+    name: 'Michigan',
+  },
+  {
+    key: 'MN',
+    name: 'Minnesota',
+  },
+  {
+    key: 'MS',
+    name: 'Mississippi',
+  },
+  {
+    key: 'MO',
+    name: 'Missouri',
+  },
+  {
+    key: 'MT',
+    name: 'Montana',
+  },
+  {
+    key: 'NE',
+    name: 'Nebraska',
+  },
+  {
+    key: 'NV',
+    name: 'Nevada',
+  },
+  {
+    key: 'NB',
+    name: 'New Brunswick',
+  },
+  {
+    key: 'NH',
+    name: 'New Hampshire',
+  },
+  {
+    key: 'NJ',
+    name: 'New Jersey',
+  },
+  {
+    key: 'NM',
+    name: 'New Mexico',
+  },
+  {
+    key: 'NY',
+    name: 'New York',
+  },
+  {
+    key: 'NF',
+    name: 'Newfoundland & Labrador',
+  },
+  {
+    key: 'NC',
+    name: 'North Carolina',
+  },
+  {
+    key: 'ND',
+    name: 'North Dakota',
+  },
+  {
+    key: 'NT',
+    name: 'Northwest Territories',
+  },
+  {
+    key: 'NS',
+    name: 'Nova Scotia',
+  },
+  {
+    key: 'NU',
+    name: 'Nunavut',
+  },
+  {
+    key: 'OH',
+    name: 'Ohio',
+  },
+  {
+    key: 'OK',
+    name: 'Oklahoma',
+  },
+  {
+    key: 'ON',
+    name: 'Ontario',
+  },
+  {
+    key: 'OR',
+    name: 'Oregon',
+  },
+  {
+    key: 'PA',
+    name: 'Pennsylvania',
+  },
+  {
+    key: 'PE',
+    name: 'Prince Edward Island',
+  },
+  {
+    key: 'QC',
+    name: 'Quebec',
+  },
+  {
+    key: 'RI',
+    name: 'Rhode Island',
+  },
+  {
+    key: 'SK',
+    name: 'Saskatchewan',
+  },
+  {
+    key: 'SC',
+    name: 'South Carolina',
+  },
+  {
+    key: 'SD',
+    name: 'South Dakota',
+  },
+  {
+    key: 'TN',
+    name: 'Tennessee',
+  },
+  {
+    key: 'TX',
+    name: 'Texas',
+  },
+  {
+    key: 'UT',
+    name: 'Utah',
+  },
+  {
+    key: 'VT',
+    name: 'Vermont',
+  },
+  {
+    key: 'VA',
+    name: 'Virginia',
+  },
+  {
+    key: 'WA',
+    name: 'Washington',
+  },
+  {
+    key: 'WV',
+    name: 'West Virginia',
+  },
+  {
+    key: 'WI',
+    name: 'Wisconsin',
+  },
+  {
+    key: 'WY',
+    name: 'Wyoming',
+  },
+  {
+    key: 'YT',
+    name: 'Yukon',
+  },
+];

package/utils/state-name-to-abrev.js

@@ -0,0 +1,70 @@
+module.exports = {
+  alabama: 'AL',
+  alaska: 'AK',
+  arizona: 'AZ',
+  arkansas: 'AR',
+  california: 'CA',
+  colorado: 'CO',
+  connecticut: 'CT',
+  delaware: 'DE',
+  'district of columbia': 'DC',
+  florida: 'FL',
+  georgia: 'GA',
+  hawaii: 'HI',
+  idaho: 'ID',
+  illinois: 'IL',
+  indiana: 'IN',
+  iowa: 'IA',
+  kansas: 'KS',
+  kentucky: 'KY',
+  louisiana: 'LA',
+  maine: 'ME',
+  maryland: 'MD',
+  massachusetts: 'MA',
+  michigan: 'MI',
+  minnesota: 'MN',
+  mississippi: 'MS',
+  missouri: 'MO',
+  montana: 'MT',
+  nebraska: 'NE',
+  nevada: 'NV',
+  'new hampshire': 'NH',
+  'new jersey': 'NJ',
+  'new mexico': 'NM',
+  'new york': 'NY',
+  'north carolina': 'NC',
+  'north dakota': 'ND',
+  ohio: 'OH',
+  oklahoma: 'OK',
+  oregon: 'OR',
+  pennsylvania: 'PA',
+  'rhode island': 'RI',
+  'south carolina': 'SC',
+  'south dakota': 'SD',
+  tennessee: 'TN',
+  texas: 'TX',
+  utah: 'UT',
+  vermont: 'VT',
+  virginia: 'VA',
+  washington: 'WA',
+  'west virginia': 'WV',
+  wisconsin: 'WI',
+  wyoming: 'WY',
+  // Canadian
+  alberta: 'AB',
+  'british columbia': 'BC',
+  manitoba: 'MB',
+  'new brunswick': 'NB',
+  newfoundland: 'NL',
+  'newfoundland & labrador': 'NL',
+  labrador: 'NL',
+  'northwest territories': 'NT',
+  'nova scotia': 'NS',
+  nunavut: 'NU',
+  ontario: 'ON',
+  'prince edward island': 'PE',
+  quebec: 'QC',
+  saskatchewan: 'SK',
+  yukon: 'YT',
+  'yukon territory': 'YT',
+};