@godspeedsystems/core
Version:
> 4th Generation Declarative Microservice Framework
202 lines (201 loc) • 8.6 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "default", {
enumerable: true,
get: function() {
return _default;
}
});
const _path = /*#__PURE__*/ _interop_require_default(require("path"));
const _logger = require("../logger");
const _yamlLoader = /*#__PURE__*/ _interop_require_default(require("./yamlLoader"));
const _expandVariables = /*#__PURE__*/ _interop_require_default(require("./expandVariables"));
function _async_iterator(iterable) {
var method, async, sync, retry = 2;
for("undefined" != typeof Symbol && (async = Symbol.asyncIterator, sync = Symbol.iterator); retry--;){
if (async && null != (method = iterable[async])) return method.call(iterable);
if (sync && null != (method = iterable[sync])) return new AsyncFromSyncIterator(method.call(iterable));
async = "@@asyncIterator", sync = "@@iterator";
}
throw new TypeError("Object is not async iterable");
}
function AsyncFromSyncIterator(s) {
function AsyncFromSyncIteratorContinuation(r) {
if (Object(r) !== r) return Promise.reject(new TypeError(r + " is not an object."));
var done = r.done;
return Promise.resolve(r.value).then(function(value) {
return {
value: value,
done: done
};
});
}
return AsyncFromSyncIterator = function(s) {
this.s = s, this.n = s.next;
}, AsyncFromSyncIterator.prototype = {
s: null,
n: null,
next: function() {
return AsyncFromSyncIteratorContinuation(this.n.apply(this.s, arguments));
},
return: function(value) {
var ret = this.s.return;
return void 0 === ret ? Promise.resolve({
value: value,
done: !0
}) : AsyncFromSyncIteratorContinuation(ret.apply(this.s, arguments));
},
throw: function(value) {
var thr = this.s.return;
return void 0 === thr ? Promise.reject(value) : AsyncFromSyncIteratorContinuation(thr.apply(this.s, arguments));
}
}, new AsyncFromSyncIterator(s);
}
function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
try {
var info = gen[key](arg);
var value = info.value;
} catch (error) {
reject(error);
return;
}
if (info.done) {
resolve(value);
} else {
Promise.resolve(value).then(_next, _throw);
}
}
function _async_to_generator(fn) {
return function() {
var self = this, args = arguments;
return new Promise(function(resolve, reject) {
var gen = fn.apply(self, args);
function _next(value) {
asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
}
function _throw(err) {
asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
}
_next(undefined);
});
};
}
function _interop_require_default(obj) {
return obj && obj.__esModule ? obj : {
default: obj
};
}
function _getRequireWildcardCache(nodeInterop) {
if (typeof WeakMap !== "function") return null;
var cacheBabelInterop = new WeakMap();
var cacheNodeInterop = new WeakMap();
return (_getRequireWildcardCache = function(nodeInterop) {
return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
})(nodeInterop);
}
function _interop_require_wildcard(obj, nodeInterop) {
if (!nodeInterop && obj && obj.__esModule) {
return obj;
}
if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
return {
default: obj
};
}
var cache = _getRequireWildcardCache(nodeInterop);
if (cache && cache.has(obj)) {
return cache.get(obj);
}
var newObj = {
__proto__: null
};
var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
for(var key in obj){
if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
if (desc && (desc.get || desc.set)) {
Object.defineProperty(newObj, key, desc);
} else {
newObj[key] = obj[key];
}
}
}
newObj.default = obj;
if (cache) {
cache.set(obj, newObj);
}
return newObj;
}
function _default(eventsourcesFolderPath, datasources) {
return _ref.apply(this, arguments);
}
function _ref() {
_ref = _async_to_generator(function*(eventsourcesFolderPath, datasources) {
const eventsourcesConfigs = yield (0, _yamlLoader.default)(eventsourcesFolderPath, false);
if (eventsourcesConfigs && !Object.keys(eventsourcesConfigs).length) {
_logger.logger.fatal(`There are no event sources defined in eventsource dir: ${eventsourcesFolderPath}`);
process.exit(1);
}
const eventSources = {};
{
var _iteratorAbruptCompletion = false, _didIteratorError = false, _iteratorError;
try {
for(var _iterator = _async_iterator(Object.keys(eventsourcesConfigs)), _step; _iteratorAbruptCompletion = !(_step = yield _iterator.next()).done; _iteratorAbruptCompletion = false){
let _value = _step.value;
const esName = _value;
// let's load the event source
const eventSourceConfig = eventsourcesConfigs[esName];
_logger.logger.debug('evaluating event source %s', esName);
const location = {
eventsource_name: esName
};
eventsourcesConfigs[esName] = (0, _expandVariables.default)(eventsourcesConfigs[esName], location);
_logger.logger.debug('evaluated eventsource %s %o', esName, eventsourcesConfigs[esName]);
const fileName = eventsourcesConfigs[esName].type;
try {
const Module = yield Promise.resolve(_path.default.join(eventsourcesFolderPath, 'types', fileName)).then((p)=>/*#__PURE__*/ _interop_require_wildcard(require(p)));
const isPureEventSource = 'initClient' in Module.default.prototype;
// const isPureEventSource = !!Object.hasOwnProperty.call(Module.default.prototype, 'initClient');
let eventSourceInstance;
let Constructor = Module.default;
if (isPureEventSource) {
eventSourceInstance = new Constructor(eventsourcesConfigs[esName], datasources);
if ('init' in eventSourceInstance) {
yield eventSourceInstance.init();
}
} else {
let correspondingDatasource = datasources[esName]; // By design, datasource and event source need to share the same name.
if (!correspondingDatasource) {
_logger.logger.fatal(`Corresponding data source for event source ${esName} is not defined. Please ensure a data source type exists with the same file name in src/datasources directory`);
process.exit(1);
} else {
eventSourceInstance = new Constructor(eventsourcesConfigs[esName], correspondingDatasource.client);
}
}
eventSources[esName] = eventSourceInstance;
} catch (error) {
_logger.logger.error('Failed to load event source %s %s %o', esName, error.message, error);
process.exit(1);
}
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally{
try {
if (_iteratorAbruptCompletion && _iterator.return != null) {
yield _iterator.return();
}
} finally{
if (_didIteratorError) {
throw _iteratorError;
}
}
}
}
return eventSources;
});
return _ref.apply(this, arguments);
}