@focus-reactive/graphql-content-layer/dist/index.js

[](https://badge.fury.io/js/%40focus-reactive%2Fgraphql-content-layer) # GitNation GraphQL Content Layer

const {
  GraphQLClient
} = require('graphql-request');

const {
  credentials
} = require('./config');

const RequestQueue = require('./request-queue');

const textContent = require('./fetch-texts');

const pageContent = require('./fetch-pages');

const brandContent = require('./fetch-brand');

const speakerContent = require('./fetch-speakers');

const advisersContent = require('./fetch-advisers');

const performanceContent = require('./fetch-performance');

const sponsorContent = require('./fetch-sponsors');

const talksContent = require('./fetch-talks');

const workshopContent = require('./fetch-workshops');

const mcContent = require('./fetch-mc');

const faqContent = require('./fetch-faq');

const extContent = require('./fetch-extended');

const jobsContent = require('./fetch-jobs');

const committeeContent = require('./fetch-committee');

const diversityContent = require('./fetch-diversity');

const latestLinksContent = require('./fetch-landings');

const {
  postProcessLayer
} = require('./postprocess');

const createClient = ({
  endpoint,
  token
}) => {
  return new GraphQLClient(endpoint, {
    headers: {
      authorization: `Bearer ${token}`
    }
  });
};

const client = createClient(credentials);
const queriesData = [];

const getQueriesData = (content, conferenceSettings) => {
  try {
    const {
      fetchData,
      selectSettings = () => undefined,
      ...data
    } = content;
    if (!Object.keys(data).length) return;
    data.vars = selectSettings(conferenceSettings);
    queriesData.push(data);
  } catch (err) {
    console.error(err);
  }
};

const getContent = async conferenceSettings => {
  const queue = new RequestQueue({
    concurrency: 5,
    retryAttempts: 3,
    retryDelay: 2000,
    maxRetryDelay: 30000,
    timeout: 60000
  });
  const contentModules = [{
    module: textContent,
    name: 'texts'
  }, {
    module: pageContent,
    name: 'pages'
  }, {
    module: brandContent,
    name: 'brand'
  }, {
    module: speakerContent,
    name: 'speakers'
  }, {
    module: advisersContent,
    name: 'advisers'
  }, {
    module: performanceContent,
    name: 'performance'
  }, {
    module: sponsorContent,
    name: 'sponsors'
  }, {
    module: talksContent,
    name: 'talks'
  }, {
    module: workshopContent,
    name: 'workshops'
  }, {
    module: mcContent,
    name: 'mc'
  }, {
    module: faqContent,
    name: 'faq'
  }, {
    module: extContent,
    name: 'extended'
  }, {
    module: jobsContent,
    name: 'jobs'
  }, {
    module: committeeContent,
    name: 'committee'
  }, {
    module: diversityContent,
    name: 'diversity'
  }, {
    module: latestLinksContent,
    name: 'landings'
  }];
  const fetchPromises = contentModules.map(({
    module: content,
    name
  }) => {
    return queue.add(async () => {
      try {
        getQueriesData(content, conferenceSettings);

        const getVarsFromSettings = content.selectSettings || (() => undefined);

        const {
          conferenceTitle,
          eventYear
        } = conferenceSettings; // eslint-disable-next-line no-console

        console.log(`Fetching ${name} for ${conferenceTitle} ${eventYear}`);
        const result = await content.fetchData(client, {
          conferenceTitle,
          eventYear,
          ...getVarsFromSettings(conferenceSettings)
        }); // eslint-disable-next-line no-console

        console.log(`Successfully fetched ${name} for ${conferenceTitle} ${eventYear}`);
        return result;
      } catch (err) {
        console.error(`Failed to fetch ${name} for ${conferenceSettings.conferenceTitle}:`, err);
        throw err;
      }
    }, name);
  });
  const contentArray = await Promise.all(fetchPromises);
  const contentMap = contentArray.reduce((content, piece) => {
    try {
      const newKeys = Object.keys(piece);
      const existentKeys = Object.keys(content);
      const intersectedKeys = newKeys.filter(k => existentKeys.includes(k));
      intersectedKeys.forEach(k => {
        // eslint-disable-next-line no-param-reassign
        piece[k] = { ...content[k],
          ...piece[k]
        };
      });
    } catch (err) {
      // eslint-disable-next-line no-console
      console.log('content, piece', piece);
      console.error(err);
    }

    return { ...content,
      ...piece
    };
  }, {});
  contentMap.conferenceSettings = conferenceSettings;
  const processedContent = postProcessLayer(contentMap);
  return processedContent;
};

module.exports = {
  getContent,
  queriesData
};