@methodus/server
Version:
dynamic rpc components
140 lines • 6.37 kB
JavaScript
;
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
Object.defineProperty(exports, "__esModule", { value: true });
// <references path='../interfaces/methodus.ts' />
const debug = require('debug')('tmla:methodus');
require("reflect-metadata");
const fp_1 = require("../fp");
const base_1 = require("./base");
let metadataKey = 'methodus';
const log_1 = require("../log");
let SocketIO = class SocketIO extends base_1.BaseServer {
constructor(options, httpServer) {
super();
this.classRouters = [];
var io;
if (httpServer)
this._app = require('socket.io')(httpServer);
else
this._app = require('socket.io').listen(options.port);
global.socketioEngine = this._app;
let nsp = this._app;
if (options && options.nsp) {
nsp = this._app.of(options.nsp);
}
nsp.on('connection', (socket) => {
this.socketHandler(socket);
});
nsp.use((socket, next) => {
next();
});
}
close() {
this._app.close();
}
useClass(classType) {
this.classRouters.push(classType);
}
socketHandler(socket) {
if (!socket.attached) {
this.classRouters.forEach((item) => {
new SocketIORouter(item, socket);
});
socket.attached = true;
}
}
_sendEvent(methodEvent) {
return __awaiter(this, void 0, void 0, function* () {
});
}
_send(functionArgs, methodus, paramsMap) {
return __awaiter(this, void 0, void 0, function* () {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
debug('sending data in socket', functionArgs, methodus, paramsMap);
var dataObject = {};
functionArgs.forEach((element, index) => {
dataObject[paramsMap.filter((item) => {
return item.index === index;
})[0].name] = element;
});
let myUri = yield methodus.resolver();
var socket = require('socket.io-client')(myUri);
socket.on('connect', () => {
debug('socket connection ok');
let messageName = methodus.verb + '_' + methodus.route;
debug('messageName:method:recipient', messageName);
socket.emit(messageName, dataObject, (data) => {
debug('recieved result', data);
if (data.error && data.statusCode) {
log_1.logger.error(data);
reject(data);
}
else {
log_1.logger.info('return value is', data);
resolve(data);
}
});
});
}));
});
}
};
SocketIO = __decorate([
log_1.LogClass(log_1.logger),
__metadata("design:paramtypes", [Object, Object])
], SocketIO);
exports.SocketIO = SocketIO;
let SocketIORouter = class SocketIORouter {
constructor(obj, socket) {
let proto = fp_1.fp.maybeProto(obj);
let methodus = fp_1.fp.maybeMethodus(obj);
let existingClassMetadata = Reflect.getOwnMetadata(metadataKey, proto) || {};
existingClassMetadata.returnMessages = true;
Reflect.defineMetadata(metadataKey, existingClassMetadata, proto);
Object.keys(methodus._descriptors).forEach(itemKey => {
let item = methodus._descriptors[itemKey];
debug('activating controller method', item, methodus);
log_1.logger.info(this, `registering socket event`, item.verb + '_' + item.route);
socket.on(item.verb + '_' + item.route, (data, callback) => __awaiter(this, void 0, void 0, function* () {
//parse params
debug('activating controller method', itemKey, data);
let paramsMap = Reflect.getOwnMetadata('params', proto, itemKey) || [];
debug('method params', itemKey, paramsMap);
let functionArgs = [];
methodus._descriptors[itemKey].params.forEach((item) => {
functionArgs[item.index] = data[item.name];
});
try {
let result = yield proto[itemKey](...functionArgs, socket, data);
debug('result is:', result);
callback(result);
}
catch (error) {
callback(error);
}
}));
});
}
};
SocketIORouter = __decorate([
log_1.LogClass(log_1.logger),
__metadata("design:paramtypes", [Object, Object])
], SocketIORouter);
exports.SocketIORouter = SocketIORouter;
//# sourceMappingURL=socketio.js.map