@frontify/frontify-api/index.js

'use strict';

var path = require('path');
var globby = require('globby');
var rp = require('request-promise');
var extend = require('extend');
var _ = require('lodash');
var fs = require('mz/fs');
var humanize = require('humanize-string');
var cache = {};

var defaults = {
  baseUrl: 'https://app.frontify.com',
  qs: {
    access_token: 'xxxxx xxxxx' // -> uri + '?access_token=xxxxx%20xxxxx'
  },
  json: true
};

function _auth(meta, options) {
  if (!(meta && meta.access_token)) {
    throw new Error('Please provide an access_token');
  }
  if(meta.baseUrl) {
    options.baseUrl = meta.baseUrl;
  }
  options.qs.access_token = meta.access_token;
  return options;
}

function _reset() {
  cache = {};
}

function _library(meta) {
  if (cache['library']) {
    return cache['library'];
  }

  return cache['library'] = Promise.resolve().then(function () {
    var options = extend(true, {}, defaults);
    options = _auth(meta, options);

    if (!(meta && meta.project)) {
      throw new Error('Please provide a project id');
    }
    options.uri = '/v1/patterns/list/' + meta.project;
    options.method = 'GET';

    return rp(options).catch(function (err) {
      throw new Error('Could not get your pattern library data. ' + err.message);
    });
  });
}

function _changed(pattern, existing) {
  var changed = true;
  return changed;
}

function _granularity(value) {
  value = value.toUpperCase();
  var granularities = [
    'ATOM',
    'MOLECULE',
    'ORGANISM'
  ];

  var granularity = _.find(granularities, function (granularity) {
    return value.indexOf(granularity) !== -1;
  });

  if (!granularity) {
    granularity = granularities[0];
  }

  return granularity;
}

function _indent(value) {
  return value.replace(/\t/g, '  ');
}

function _stability(value) {
  // according to https://www.npmjs.com/package/stability-badges
  value = _.toString(value).toLowerCase();
  var stability;

  switch (value) {
    case '0':
    case 'deprecated':
      stability = 0;
      break;
    case '1':
    case 'experimental':
      stability = 0;
      break;
    case '2':
    case 'unstable':
      stability = 0;
      break;
    case '3':
    case 'stable':
      stability = 0;
      break;
    case '4':
    case 'frozen':
      stability = 0;
      break;
    case '5':
    case 'locked':
      stability = 0;
      break;
    default:
      stability = 1;
  }

  return stability;
}

function _snippets(opts, assets) {
  var promises = [];

  _.forIn(assets, function (values, lang) {
    promises.push(Promise.resolve().then(function () {
      return Promise.all(values.map(function (value) {
        return fs.readFile(path.resolve(opts.cwd, value), 'utf8')
      })).then(function (data) {
        return {lang: lang, code: _indent(data.join('\n')), id_api: opts.idApi + '-' + lang};
      });
    }));
  });

  return Promise.all(promises).then(function (data) {
    var snippets = {};
    data.forEach(function (snippet) {
      if (snippet.lang) {
        snippets[snippet.lang] = snippet;
      }
    });
    return snippets;
  });
}

function _pattern(meta, pattern) {
  return Promise.resolve().then(function () {
    var options = extend(true, {}, defaults);
    options = _auth(meta, options);

    if (!(meta && meta.project)) {
      throw new Error('Please provide a project id');
    }

    if (!pattern) {
      throw new Error('Please provide pattern data');
    }

    return _library(meta).then(function (data) {
      pattern.mode = 'CODE';
      var existing = null;

      if (pattern.id) {
        // check whether the pattern already exists
        existing = _.find(data.patterns, function (item) {
          return item.id == pattern.id;
        });

        if (!existing) {
          throw new Error('The pattern id ' + pattern.id + ' does not exist in your pattern library');
        }
      }
      else {
        // check whether the api id (eg. path) already exists
        existing = _.find(data.patterns, function (item) {
          return item.id_api == pattern.id_api;
        });

        if (existing) {
          // update
          _.forIn(pattern.snippets, function (snippet, lang) {
            if (existing.snippets[lang]) {
              snippet['id'] = parseInt(existing.snippets[lang].id);
            }
          });
        }
      }

      // skip pattern if it is unchanged
      if(existing) {
        pattern.id = parseInt(existing.id);
        if(!_changed(pattern, existing)) {
          return Promise.resolve(null);
        }
      }

      return Promise.resolve(pattern);
    });
  });
}

function syncPatterns(meta, patterns) {
  var opts = {};
  opts.cwd = meta.cwd || '';

  // reset library cache
  _reset();

  return globby(patterns, opts).then(function (files) {
    if (files.length === 0) {
      throw new Error('No files found');
    }

    return Promise.all(files.map(function (file) {
      var filename = path.resolve(opts.cwd, file);

      if (path.extname(filename) === '.json') {
        return fs.readFile(filename, 'utf8').then(function (content) {
          var localOpts = extend(true, {}, opts, {
            idApi: _.kebabCase(file.substr(0, file.length - 5))
          });
          var def = JSON.parse(content);
          var patternData = {
            id: def.id || null,
            id_api: localOpts.idApi,
            name: def.name || humanize(path.basename(filename, '.json')),
            description: def.description || '',
            granularity: _granularity(def.type),
            stability: _stability(def.stability)
          };

          return _snippets(localOpts, def.assets).then(function (snippets) {
            patternData.snippets = snippets;
            return _pattern(meta, patternData);
          }).then(function (parent) {
            var promises = [ parent ];
            if (def.variations) {
              _.forIn(def.variations, function (variation, key) {
                var variationData = extend(true, {}, patternData, {
                  id: variation.id || null,
                  id_api: localOpts.idApi + '-' + _.kebabCase(key),
                  pattern: parent.id,
                  description: variation.description || '',
                  name: variation.name || patternData.name + ' ' + humanize(key)
                });

                promises.push(_snippets(localOpts, variation.assets).then(function (snippets) {
                  variationData.snippets = snippets;
                  return _pattern(meta, variationData);
                }));
              });
            }
            return Promise.all(promises);
          });
        });
      }
      else if (path.extname(filename) === '.html') {
        return fs.readFile(filename, 'utf8').then(function (content) {
          var idApi = _.kebabCase(file.substr(0, file.length - 5));
          var promises = [];
          promises.push(_pattern(meta, {
            name: humanize(path.basename(filename, '.html')),
            id_api: idApi,
            snippets: {
              html: {
                lang: 'html',
                id_api: idApi + '-html',
                code: _indent(content)
              }
            }
          }));
          return Promise.all(promises);
        }).catch(function (err) {
          throw new Error('An error occured reading ' + filename + ' : ' + err.message);
        });
      }
    }));
  }).then(function(patternLists) {
    var options = extend(true, {}, defaults);
    options = _auth(meta, options);

    options.uri = '/v1/patterns/';
    options.method = 'POST';

    var patterns = [];
    patternLists.forEach(function (patternList) {
      patterns = patterns.concat(patternList);
    });

    options.body = { patterns: patterns, project: meta.project };

    if(meta.dryRun) {
      return Promise.resolve(patterns);
    }

    return rp(options)
      .then(function (data) {
        if (!data.success) {
          if (data.errors && data.errors.length > 0) {
            throw new Error(data.errors.join('\n'));
          }
          else {
            throw new Error(data);
          }
        }

        return data.patterns;
      })
      .catch(function (err) {
        throw new Error('Could not create/update your patterns. ' + err.message);
      });
  });
}

/* function assets(meta, assets) {
  var opts = {};
  opts.cwd = meta.cwd || '';

  return globby(assets, opts).then(function (files) {
    if (files.length === 0) {
      throw new Error('No files found');
    }

    return Promise.all(files.map(function (file) {
      var filename = path.resolve(opts.cwd, file);
      var folderName = path.dirname(file);
      var folders = folderName.split('/');

      return Promise.all(folders.map(function(folder) {
        return folder(folder);
      }));
    }));
  });
}

function folder(meta, folder) {
  if (!(meta && meta.project)) {
    throw new Error('Please provide a project id');
  }

  return Promise.resolve();
} */

module.exports = {
  syncPatterns: syncPatterns,
  _pattern: _pattern,
  _library: _library,
  _reset: _reset
};