patternplate-server/library/get-schema.js

Programmatically serve atomic patterns via a REST API

'use strict';

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

var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();

var _path = require('path');

var _findAndReadPackageJson = require('find-and-read-package-json');

var _findAndReadPackageJson2 = _interopRequireDefault(_findAndReadPackageJson);

var _getPatternTree = require('./utilities/get-pattern-tree');

var _getPatternTree2 = _interopRequireDefault(_getPatternTree);

var _getReadme = require('./utilities/get-readme');

var _getReadme2 = _interopRequireDefault(_getReadme);

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"); }); }; }

function getResolvedRoutes(routes, options) {
	const hostname = options.hostname;
	const port = options.port;
	const protocol = options.protocol;
	const resolver = options.resolver;


	const host = `${protocol}://${hostname}:${port}`;

	return Object.entries(routes).filter(entry => {
		var _entry = _slicedToArray(entry, 2);

		const configuration = _entry[1];

		return configuration.enabled;
	}).map(entry => {
		var _entry2 = _slicedToArray(entry, 2);

		const name = _entry2[0];
		const configuration = _entry2[1];
		const path = configuration.path;

		return {
			name: name,
			path: path,
			uri: `${host}${resolver(name)}`
		};
	});
}

exports.default = (() => {
	var _ref = _asyncToGenerator(function* (application, client, server) {
		var _application$configur = application.configuration.pkg;
		const appName = _application$configur.name;
		const appVersion = _application$configur.version;
		const cache = server.cache;
		var _server$configuration = server.configuration;
		const environment = _server$configuration.environment;
		var _server$configuration2 = _server$configuration.pkg;
		const serverName = _server$configuration2.name;
		const serverVersion = _server$configuration2.version;
		var _server$configuration3 = _server$configuration.server;
		const host = _server$configuration3.host;
		const port = _server$configuration3.port;
		const routesConfiguration = _server$configuration.routes.enabled;
		const resolver = server.router.url;
		var _server$runtime = server.runtime;
		const patterncwd = _server$runtime.patterncwd;
		const cwd = _server$runtime.cwd;
		var _client$configuration = client.configuration.pkg;
		const clientName = _client$configuration.name;
		const clientVersion = _client$configuration.version;


		const basePath = (0, _path.resolve)(patterncwd || cwd, 'patterns');

		var _ref2 = yield (0, _findAndReadPackageJson2.default)(patterncwd || cwd);

		const name = _ref2.name;
		const version = _ref2.version;

		// get resolved routes

		const routes = getResolvedRoutes(routesConfiguration, {
			hostname: host,
			port: port,
			protocol: 'http',
			resolver: resolver.bind(application.router)
		});

		// get patterns/readme.md
		const renderingReadme = (0, _getReadme2.default)('.', basePath, {
			cache: cache
		});

		// obtain the pattern tree
		const gettingPatternTree = (0, _getPatternTree2.default)('.', basePath, {
			cache: cache
		});

		return Object.assign({}, {
			name: name,
			version: version,
			appName: appName,
			clientName: clientName,
			serverName: serverName,
			appVersion: appVersion,
			clientVersion: clientVersion,
			serverVersion: serverVersion,
			environment: environment,
			host: host,
			port: port,
			routes: routes,
			meta: yield gettingPatternTree, // TODO: optimize this
			readme: yield renderingReadme
		});
	});

	function getSchema(_x, _x2, _x3) {
		return _ref.apply(this, arguments);
	}

	return getSchema;
})();

module.exports = exports['default'];