patternplate-server/library/utilities/get-environments.js

Programmatically serve atomic patterns via a REST API

'use strict';

Object.defineProperty(exports, "__esModule", {
	value: true
});
exports.defaultEnvironment = undefined;

var _path = require('path');

var _util = require('util');

var _pathExists = require('path-exists');

var _pathExists2 = _interopRequireDefault(_pathExists);

var _lodash = require('lodash');

var _readFile = require('../filesystem/read-file');

var _readFile2 = _interopRequireDefault(_readFile);

var _readTree = require('../filesystem/read-tree');

var _readTree2 = _interopRequireDefault(_readTree);

var _decorations = require('../log/decorations');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }

const envDebug = (0, _util.debuglog)('environments');

const defaultEnvironment = exports.defaultEnvironment = {
	name: 'index',
	display: true,
	displayName: 'Default',
	version: '0.1.0',
	applyTo: ['**/*'],
	include: ['**/*'],
	excludes: [],
	priority: 0,
	environment: {}
};

exports.default = (() => {
	var _ref = _asyncToGenerator(function* (base) {
		let options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
		const log = options.log;
		const cache = options.cache;

		const readFile = (0, _readFile2.default)({ cache: cache });

		// Check if there is a user environment folder
		const environmentBase = (0, _path.resolve)(base, '@environments');
		const hasUserEnvironments = yield (0, _pathExists2.default)(environmentBase);

		// Get available environments ids
		const userEnvironmentPaths = hasUserEnvironments ? (yield (0, _readTree2.default)(environmentBase, cache)).filter(function (item) {
			return (0, _path.basename)(item) === 'pattern.json';
		}) : [];

		envDebug('found environment files at %s', userEnvironmentPaths);

		// Load environments
		const userEnvironmentFiles = yield Promise.all(userEnvironmentPaths.map(function (envFilePath) {
			envDebug('reading env file %s', envFilePath);
			const content = readFile(envFilePath);
			envDebug('%s %s', envFilePath, content);
			return content;
		}));

		// Parse environment file contents
		const userEnvironments = userEnvironmentFiles.map(function (userEnvironmentFile) {
			try {
				const raw = JSON.parse(userEnvironmentFile.toString('utf-8'));
				return (0, _lodash.merge)({}, defaultEnvironment, raw);
			} catch (error) {
				if (log) {
					log.error(_decorations.fail`Failed reading environment file ${userEnvironmentFile}:\n${error}`);
				}
				return null;
			}
		}).filter(Boolean);

		envDebug('read environment data');
		envDebug(userEnvironments);

		return userEnvironments.length ? userEnvironments : [defaultEnvironment];
	});

	function getEnvironments(_x) {
		return _ref.apply(this, arguments);
	}

	return getEnvironments;
})();