Home Reference Source Repository

resolvers/resolveDataDependencies/index.js

/**
 * Resolver dedicated to resolve @assets statements and @res statements
 * @module resolvers/resolveDataDependencies
 */
import {map as asyncMap, mapSeries as asyncMapSeries, waterfall} from 'async';
const CsvConverter = require('csvtojson').Converter;
const csvConverter = new CsvConverter({});

/**
 * Resolves interpolations ni metadata, resources, and contextualizations, and possibly fetches stores necessary data for rendering
 * @param {array} inputSections - the sections to resolve
 * @param {Object} assetsController - the assets controller module to use to communicate with assets
 * @param {Object} assetsParams - the params to use for accessing the assets
 * @param {boolean} resolveData - whether to fetch and store necessary data right away or to store methods for later lazy-loading
 * @param {function(err: error, finalSections: array)} callback - callbacks a possible errors and the updated list of sections
 */
export default function resolveDataDependencies(inputSections, assetsController, assetsParams, resolveData, callback) {
  let res;
  let match;
  const data = {};// this object stores resolved and unresolved promises about resources data
  const resRe = /@res([\d]+)?.(.*)/g;
  const assetsRe = /@assets\/([^']+)/g;
  asyncMap(inputSections, (section, allSectionsCallback)=> {
    waterfall([
      // styles resolution
      (stylesResolutionCallback)=> {
        if (section.customizers && section.customizers.styles) {
          const styles = [];
          for (const prop in section.customizers.styles) {
            if (section.customizers.styles[prop]) {
              styles.push({key: prop, value: section.customizers.styles[prop]});
            }
          }
          // map each style customizer
          asyncMap(styles, (styleCouple, singleStyleCallback)=> {
            let style = styleCouple.value;
            // get all expressions
            const matches = [];
            do {
              match = assetsRe.exec(style);
              if (match) {
                matches.push(match);
              }
            } while (match);
            // some assets interpolations to do
            if (matches.length) {
              // reverse array to begin with last matches and not mess around with indexes
              matches.reverse();
              asyncMap(matches, (thisMatch, matchCallback)=> {
                assetsController.getAssetUri(thisMatch[1], assetsParams, (err4, uri)=> {
                  style = style.substr(0, thisMatch.index) + uri + style.substr(thisMatch.index + thisMatch[0].length);
                  matchCallback(err4, thisMatch);
                });
              }, (matchErrors, theseMatches)=> {
                styleCouple.value = style;
                singleStyleCallback(matchErrors, styleCouple);
              });
            // no interpolations to do
            } else {
              styleCouple.value = style;
              singleStyleCallback(null, styleCouple);
            }
          }, (stylesErrors, styleCouples)=> {
            styleCouples.forEach((styleCouple) =>{
              section.customizers.styles[styleCouple.key] = styleCouple.value;
            });
            stylesResolutionCallback(stylesErrors, section);
          });
        } else stylesResolutionCallback(null, section);
      },
      // resolve metadata
      (sectio, metadataCallback)=> {
        asyncMap(sectio.metadata, (metadata, singleMetadataCallback)=> {
          if (typeof metadata.value === 'string' && metadata.value.indexOf('@assets/') === 0) {
            assetsController.getAssetUri(metadata.value.split('@assets/')[1], assetsParams, (err4, uri)=> {
              metadata.value = uri;
              singleMetadataCallback(err4, metadata);
            });
          } else {
            singleMetadataCallback(null, metadata);
          }
        }, (metadataErrors, newMetadata)=>{
          sectio.metadata = newMetadata;
          metadataCallback(metadataErrors, sectio);
        });
      },
      // resolve resources
      (sectio, resourcesCallback)=> {
        asyncMap(sectio.resources, (resource, singleResourceCallback)=> {
          const props = [];
          // format props as array for performing an async map
          for (const prop in resource) {
            if (resource[prop]) {
              props.push({key: prop, value: resource[prop]});
            }
          }
          asyncMap(props, (prop, resourcePropCallback)=> {
            if (typeof prop.value === 'string' && prop.value.indexOf('@assets/') === 0) {
              assetsController.getAssetUri(prop.value.split('@assets/')[1], assetsParams, (err4, uri)=> {
                prop.value = uri;
                resourcePropCallback(err4, prop);
              });
            } else {
              resourcePropCallback(null, prop);
            }
          }, (singleResourceError, newProps)=> {
            const newResource = newProps.reduce((obj, prop) =>{
              obj[prop.key] = prop.value;
              return obj;
            }, {});
            singleResourceCallback(singleResourceError, newResource);
          });
        }, (resourcesErrors, resources)=> {
          sectio.resources = resources;
          resourcesCallback(resourcesErrors, sectio);
        });
      },
      (sectio, contextualizationsCallback)=> {
        asyncMap(sectio.contextualizations, (contextualization, contextualizationCallback)=> {
          res = undefined;
          const props = [];
          // format props as array for performing an async map
          for (const prop in contextualization.contextualizer) {
            if (contextualization.contextualizer[prop]) {
              props.push({key: prop, value: contextualization.contextualizer[prop]});
            }
          }
          /**
           * First level props
           */
          // resolve async. props
          asyncMap(props, (prop, contextualizationPropCallback)=> {
            const val = prop.value;
            // if prop is itself an array, need for another nested async resolution
            if (Array.isArray(val) && prop.key !== 'resources') {
              // loop through propArray members
              asyncMap(val, (prop2, propArrayMembersCallback)=> {
                // prepare for asyncMap for propArray member
                const nestedProps = [];
                for (const nestedProp in prop2) {
                  if (prop2[nestedProp]) {
                    nestedProps.push({key: nestedProp, value: prop2[nestedProp]});
                  }
                }
                // Second level props (contextualization.arrayProp[array member].prop)
                asyncMap(nestedProps, (nestedProp, nestedPropCallback)=> {
                  // resolve nested props here
                  const val3 = nestedProp.value;
                  if (('' + val3).indexOf('@res') === 0) {
                    while ((match = resRe.exec(val3)) !== null) {
                      // Identify which resource is targetted (handling multi-resource contextualizations)
                      const rank = match[1] ? (+match[1] - 1) : 0;
                      // find resource data
                      res = contextualization.resources[rank];
                      if (res === undefined) {
                        console.log('res is undefined, expression: ', val3);
                        return nestedPropCallback(undefined, nestedProp);
                      }
                      // case: metadata call
                      const resProp = match[match.length - 1];
                      if (resProp.indexOf('data') !== 0) {
                        // interpolate w/ resource value thanks to resourceProp path
                        nestedProp.value = res[resProp];
                        // contextualizationPropCallback(null, prop);
                      // case : data call
                      } else {
                        const dataPath = ('' + val3).split('.').filter(path=>{
                          return path.length;
                        });
                        nestedProp.value = {
                          type: 'path',
                          target: 'data',
                          path: dataPath
                        };
                        const defined = data[res.citeKey];
                        if (!defined) {
                          const accessor = res.data || res.url;
                          if (('' + accessor).indexOf('@assets/') === 0) {
                            const toResolve = {};
                            toResolve.params = {
                              path: accessor.split('@assets/')[1],
                              params: assetsParams,
                              acceptedExtensions: '*'
                            };
                            toResolve.read = assetsController.getReader(assetsParams);
                            data[res.citeKey] = toResolve;
                          } else {
                            console.log('unhandled data accessor : ', accessor);
                          }
                        }
                      }
                    }
                    nestedPropCallback(null, nestedProp);
                  } else if (('' + val3).indexOf('@assets/') === 0) {
                    assetsController.getAssetUri(val3.split('@assets/')[1], assetsParams, (err4, uri)=> {
                      nestedProp.value = uri;
                      nestedPropCallback(err4, nestedProp);
                    });
                  } else {
                    nestedPropCallback(null, nestedProp);
                  }
                }, (err3, propsOut2)=> {
                  const newProp2 = propsOut2.reduce((newCont, newContProp) =>{
                    newCont[newContProp.key] = newContProp.value;
                    return newCont;
                  }, {});
                  propArrayMembersCallback(err3, newProp2);
                });
              // resolve arrayed prop
              }, (err2, arrayMembers)=> {
                prop.value = arrayMembers;
                contextualizationPropCallback(null, prop);
              });
            } else if (typeof val !== undefined && prop.key !== 'resources') {
              if (('' + val).indexOf('@res') === 0) {
                while ((match = resRe.exec(val)) !== null) {
                  // Identify which resource is targetted (handling multi-resource contextualizations)
                  const rank = match[1] ? (+match[1] - 1) : 0;
                  // find resource data
                  res = contextualization.resources[rank];
                  if (res === undefined) {
                    console.log('res is undefined, expression: ', val);
                    return contextualizationPropCallback(undefined, prop);
                  }
                  const resProp = match[match.length - 1];
                  // case: metadata call
                  if (resProp.indexOf('data') !== 0) {
                    // interpolate w/ resource value thanks to resourceProp path
                    prop.value = res[resProp];
                    // contextualizationPropCallback(null, prop);
                  // case : data call
                  } else {
                    const dataPath = ('' + val).split('.').filter(path=>{
                      return path.length;
                    });
                    prop.value = {
                      type: 'path',
                      target: 'data',
                      path: dataPath
                    };
                    const defined = data[res.citeKey];
                    if (!defined) {
                      const accessor = res.data || res.url;
                      if (('' + accessor).indexOf('@assets/') === 0) {
                        const toResolve = {};
                        toResolve.params = {
                          path: accessor.split('@assets/')[1],
                          params: assetsParams,
                          acceptedExtensions: '*'
                        };
                        toResolve.read = assetsController.getReader(assetsParams);
                        data[res.citeKey] = toResolve;
                      } else {
                        console.log('unhandled data accessor : ', accessor);
                      }
                    }
                  }
                }
                contextualizationPropCallback(null, prop);
              } else if (('' + val).indexOf('@assets/') === 0) {
                assetsController.getAssetUri(val.split('@assets/')[1], assetsParams, (err3, uri)=> {
                  prop.value = uri;
                  contextualizationPropCallback(err3, prop);
                });
              } else {
                contextualizationPropCallback(null, prop);
              }
            } else {
              contextualizationPropCallback(null, prop);
            }
          }, (err1, propsOut1)=> {
            const newContextualizer = propsOut1.reduce((newCont, propOut) =>{
              newCont[propOut.key] = propOut.value;
              return newCont;
            }, {});

            // console.log('new contextualization', Object.assign(contextualization, newContextualizer));
            // pass contextualizer's resolved values to contextualization object
            newContextualizer.contextualizerType = newContextualizer.type;
            delete newContextualizer.type;// contextualization has a type also
            const newContextualization = Object.assign(contextualization, newContextualizer);
            contextualizationCallback(err1, newContextualization);
          });
        }, (contextualizationsError, contextualizations)=> {
          sectio.contextualizations = contextualizations;
          contextualizationsCallback(contextualizationsError, sectio);
        });
      }
    // waterfall callback for all sections
    ], (errs, sectios)=> {
      allSectionsCallback(errs, sectios);
    });
  // global & final callback
  }, (err, sections)=> {
    if (resolveDataDependencies) {
      asyncMapSeries(Object.keys(data), (key, dataCallback) =>{
        const toResolve = data[key];
        toResolve.read(toResolve.params, (dataErr, dataResult) =>{
          if (dataErr) {
            data[key] = dataErr;
            dataCallback(null, key);
          } else {
            const raw = dataResult && dataResult.stringContents;
            const ext = dataResult.extname;
            // todo : handle other file formats
            if (raw && ext === '.csv') {
              csvConverter.fromString(raw, (parseErr, json)=>{
                data[key] = {
                  format: 'json',
                  data: json
                };
                dataCallback(parseErr, key);
              });
            }else {
              console.log('unhandled file format ', ext);
              dataCallback(null, key);
            }
          }
        });
      }, (finalErr, keys) =>{
        const finalSections = sections.map(sectio =>{
          return Object.assign(sectio, {data: data});
        });
        callback(finalErr, finalSections);
      });
    } else {
      const finalSections = sections.map(sectio =>{
        return Object.assign(sectio, {data});
      });
      callback(err, finalSections);
    }
  });
}