jovo-plugin-class-handler
Version:
Jovo plugin that allows using classes for defining handlers.
146 lines • 6.47 kB
JavaScript
;
var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, privateMap) {
if (!privateMap.has(receiver)) {
throw new TypeError("attempted to get private field on non-instance");
}
return privateMap.get(receiver);
};
var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, privateMap, value) {
if (!privateMap.has(receiver)) {
throw new TypeError("attempted to set private field on non-instance");
}
privateMap.set(receiver, value);
return value;
};
var _handlers, _processedConstructors;
Object.defineProperty(exports, "__esModule", { value: true });
const glob = require("glob");
const jovo_core_1 = require("jovo-core");
const _get = require("lodash.get");
const _set = require("lodash.set");
const Handler_1 = require("./decorators/Handler");
const BaseHandler_1 = require("./BaseHandler");
const JovoClassHandlerException_1 = require("./JovoClassHandlerException");
function asyncGlob(pattern, options) {
return new Promise((resolve, reject) => {
glob(pattern, options || {}, (err, matches) => {
if (err) {
return reject(err);
}
resolve(matches);
});
});
}
class JovoClassHandler {
constructor() {
this.config = {
handlers: [],
};
_handlers.set(this, []);
_processedConstructors.set(this, []);
}
get loadedHandlers() {
return __classPrivateFieldGet(this, _handlers).slice();
}
get name() {
return this.constructor.name;
}
install(app) {
app.middleware('setup').use(this.setup.bind(this));
}
async setup(handleRequest) {
try {
await this.loadHandlers(handleRequest, this.config.handlers);
handleRequest.app.setHandler(...__classPrivateFieldGet(this, _handlers));
}
catch (e) {
if (e instanceof JovoClassHandlerException_1.JovoClassHandlerException) {
throw e;
}
throw new JovoClassHandlerException_1.JovoClassHandlerException(e);
}
}
async loadHandlers(handleRequest, references) {
if (references.length === 0) {
throw new JovoClassHandlerException_1.JovoClassHandlerException('No references are given in the config. No handlers could be loaded.');
}
__classPrivateFieldSet(this, _processedConstructors, []);
for (let i = 0, len = references.length; i < len; i++) {
await this.processReference(handleRequest, references[i]);
}
}
async processReference(handleRequest, reference) {
if (typeof reference === 'string') {
try {
const matches = await asyncGlob(reference);
for (let i = 0, len = matches.length; i < len; i++) {
const importedMatch = await Promise.resolve().then(() => require(matches[i]));
if (importedMatch) {
for (const potentialHandler in importedMatch) {
if (importedMatch.hasOwnProperty(potentialHandler) &&
typeof importedMatch[potentialHandler] === 'function') {
this.processPotentialHandler(handleRequest, importedMatch[potentialHandler]);
}
}
}
}
}
catch (e) {
console.log(e);
throw new JovoClassHandlerException_1.JovoClassHandlerException(e);
}
}
else if (typeof reference === 'function') {
this.processPotentialHandler(handleRequest, reference);
}
else {
jovo_core_1.Log.info(`[${this.name}] reference of type ${typeof reference} is not supported.`);
}
}
processPotentialHandler(handleRequest, constructor) {
const metaData = Reflect.getMetadata(Handler_1.HandlerMetaDataKey, constructor);
const instanceExists = __classPrivateFieldGet(this, _processedConstructors).some((ctr) => {
return ctr === constructor;
});
if (metaData && metaData.intents.length > 0 && !instanceExists) {
const instance = new constructor(handleRequest.app, handleRequest.host, handleRequest);
const handler = {};
for (let i = 0, len = metaData.intents.length; i < len; i++) {
const { key, name, dataParameters } = metaData.intents[i];
if (typeof instance[key] === 'function') {
const fn = instance[key];
const newFn = ((func, dataParams, jovo) => {
const injectParams = dataParams
.sort((a, b) => {
return a.index - b.index;
})
.map((dataParam) => {
const path = dataParam.accessor ? `${dataParam.type}.${dataParam.accessor}` : dataParam.type;
return _get(jovo, path);
});
if (instance instanceof BaseHandler_1.BaseHandler) {
for (const prop in jovo) {
if (jovo.hasOwnProperty(prop)) {
instance[prop] = jovo[prop];
}
}
return func.apply(instance, injectParams);
}
return func.apply(instance, [jovo, ...injectParams]);
}).bind(instance, fn, dataParameters);
if (metaData.state.length === 0) {
handler[name] = newFn;
}
else {
_set(handler, `${metaData.state}.${name}`, newFn);
}
}
}
__classPrivateFieldGet(this, _processedConstructors).push(constructor);
__classPrivateFieldGet(this, _handlers).push(handler);
}
}
}
exports.JovoClassHandler = JovoClassHandler;
_handlers = new WeakMap(), _processedConstructors = new WeakMap();
//# sourceMappingURL=JovoClassHandler.js.map