@real-db/server
Version:
The library for syncing data changes to multiple devices from your database
372 lines (371 loc) • 17.7 kB
JavaScript
"use strict";
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());
});
};
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
var __importStar = (this && this.__importStar) || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
result["default"] = mod;
return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
var enums_1 = require("../shared/enums");
var utilService = __importStar(require("../services"));
var lodash_1 = require("lodash");
var RealDBRoom = /** @class */ (function () {
function RealDBRoom(roomId, config, auths, adapter) {
this._roomId = roomId;
this._auths = auths;
this._registeredSocketData = {};
this._unregisteredSocketData = {};
this._adapter = adapter;
this.collectionName = config.queryOptions.collection;
this._globalAuthStates = {};
// sets default config and override with provided config
config.queryOptions = lodash_1.assign({}, {
isCollectionQuery: true
}, config.queryOptions);
this._config = lodash_1.assign({}, {
queryParams: {},
template: ''
}, config);
}
/**
* Return true if socket is a registered member of this room
* @param socketId socket id
*/
RealDBRoom.prototype.isSocketRegistered = function (socketId) {
return !!(this._registeredSocketData[socketId] && this._registeredSocketData[socketId].socket);
};
/**
* Sets the registration status of socket in room
* @param status The current global status determining whether socket is eligible to be registered in room
* @param socketId socket id
*/
RealDBRoom.prototype.setGlobalAuthState = function (status, socketId) {
var connectionData = this.getSocketDataInRoom(socketId);
if (connectionData && this._globalAuthStates[socketId] !== status) {
connectionData.authStateChanged(status);
}
};
/**
* Gets socket connection data in room. Whether registered or not
* @param socketId socket id
*/
RealDBRoom.prototype.getSocketDataInRoom = function (socketId) {
return this.isSocketRegistered(socketId)
? this._registeredSocketData[socketId]
: this._unregisteredSocketData[socketId];
};
/**
* Broadcasts changed document events with payload to registered and authenticated sockets
* in room that match the specified query
* @param doc affected document
* @param operation Write operation type either CREATE, UPDATE or DELETE
*/
RealDBRoom.prototype.broadcastChangesToRoom = function (doc, operation) {
};
/**
* Used to update the connection data of socket if already a member of this room
* also for updating the meta query list and creating auth for the query
* @param socketId socket id
* @param payload client payload data input
*/
RealDBRoom.prototype.updateSocketData = function (socketId, payload) {
return __awaiter(this, void 0, void 0, function () {
var socketData, metadata, e_1;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
socketData = this.getSocketDataInRoom(socketId);
if (!this.isValidSyncRequest(socketData.socket, payload)) {
return [2 /*return*/];
}
_a.label = 1;
case 1:
_a.trys.push([1, 3, , 4]);
return [4 /*yield*/, this.createConnectionMetadata(socketId, payload)];
case 2:
metadata = _a.sent();
socketData.meta.push(metadata);
return [3 /*break*/, 4];
case 3:
e_1 = _a.sent();
console.log(e_1);
this.emitSocketOnError(socketData.socket, payload.responseId, {
code: enums_1.RealDBErrorCodeTypes.INTERNAL_SERVER_ERROR,
message: 'An error was encountered while processing request'
});
return [3 /*break*/, 4];
case 4: return [2 /*return*/];
}
});
});
};
/**
* Emits event to socket when successful action has occurs
* @param socket socket object to emit event to
* @param event event id on which to emit at
* @param data data returned to client
* @param operationType Write operation type either CREATE, UPDATE or DELETE
*/
RealDBRoom.prototype.emitSocketOnSuccess = function (socket, event, data, operationType) {
var res = {
data: data, operationType: operationType
};
socket.emit(event, res);
};
/**
* Emits event to socket when unsuccessful action has occurs
* @param socket socket object to emit event to
* @param event event id on which to emit at
* @param error error body containing code, message, timestamp etc
*/
RealDBRoom.prototype.emitSocketOnError = function (socket, event, error) {
var res = {
error: {
code: error.code,
message: error.message,
timestamp: new Date()
}
};
socket.emit(event || 'REAL_DB_ERROR', res);
};
/**
* Checks the validity of a client sync action
* @param socket socket object
* @param payload payload data check against
*/
RealDBRoom.prototype.isValidSyncRequest = function (socket, payload) {
if (payload.params) {
// make sure the params match the config definition
var queryParamKeys = lodash_1.keys(this._config.queryParams).sort();
var payloadParamKeys = lodash_1.keys(payload.params).sort();
if (JSON.stringify(queryParamKeys) === JSON.stringify(payloadParamKeys)) {
return true;
}
else {
this.emitSocketOnError(socket, payload.responseId, {
code: enums_1.RealDBErrorCodeTypes.INVALID_QUERY,
message: 'Invalid query parameters'
});
}
}
else {
this.emitSocketOnError(socket, payload.responseId, {
code: enums_1.RealDBErrorCodeTypes.QUERY_PARAMS_NOT_SPECIFIED,
message: "Invalid or incomplete query parameters for request type: '" + this._roomId + "'"
});
}
return false;
};
/**
* Adds socket to room and sets registered depending on global auth value for this socket
* @param socket socket to add to room
* @param payload client payload data
*/
RealDBRoom.prototype.addSocketToRoom = function (socket, payload) {
return __awaiter(this, void 0, void 0, function () {
var metadata, connectionData;
var _this = this;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
if (!this.isValidSyncRequest(socket, payload)) {
return [2 /*return*/];
}
return [4 /*yield*/, this.createConnectionMetadata(socket.id, payload)];
case 1:
metadata = _a.sent();
connectionData = {
socket: socket,
meta: [metadata],
// this is for global auth state trigger
authStateChanged: function (status) {
_this.toggleSocketInRoom(status, connectionData);
}
};
// by default, socket is an unregistered member of this room until authFn says otherwise
this._unregisteredSocketData[socket.id] = connectionData;
if (this._globalAuthStates[socket.id]) {
// global auth state was set already
this.toggleSocketInRoom(true, connectionData);
}
return [2 /*return*/];
}
});
});
};
/**
* Applies the effect of auth state value of global and query at query meta level
* @param socketData socket connection data
* @param meta query option on which auth state change has ocurred
*/
RealDBRoom.prototype.queryAuthStateChangedTrigger = function (socketData, meta) {
return __awaiter(this, void 0, void 0, function () {
var result, e_2;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
if (!(this._globalAuthStates[socketData.socket.id] && meta.isAuth)) return [3 /*break*/, 4];
_a.label = 1;
case 1:
_a.trys.push([1, 3, , 4]);
return [4 /*yield*/, this.getQueryResult(meta.query)];
case 2:
result = _a.sent();
// sends result to client socket
this.emitSocketOnSuccess(socketData.socket, meta.responseId, result);
return [3 /*break*/, 4];
case 3:
e_2 = _a.sent();
this.emitSocketOnError(socketData.socket, meta.responseId, {
code: enums_1.RealDBErrorCodeTypes.INTERNAL_SERVER_ERROR,
message: "An error was encountered while fetching data with responseId: " + meta.responseId
});
return [3 /*break*/, 4];
case 4: return [2 /*return*/];
}
});
});
};
/**
* Creates and initializes auth function triggers for query metadata of a socket
* @param socketId socket id
* @param payload payload from client
*/
RealDBRoom.prototype.createConnectionMetadata = function (socketId, payload) {
var _this = this;
try {
var generatedQuery = utilService.generateQueryFromTemplate(this._config.template, payload.params);
var meta_1 = {
isAuth: false,
// this is for each query level auth state trigger
authStateChange: function (status) {
// checks if auth state just changed
if (meta_1.isAuth !== status) {
meta_1.isAuth = status;
_this.queryAuthStateChangedTrigger(_this.getSocketDataInRoom(socketId), meta_1);
}
},
query: generatedQuery,
responseId: payload.responseId
};
// initial meta auth fns trigger
utilService.resolveAuths(this._auths, lodash_1.cloneDeep(payload), meta_1.authStateChange);
return Promise.resolve(meta_1);
}
catch (e) {
return Promise.reject(e);
}
};
/**
* Makes the real request to database adapter to get the real data (initial)
* @param query query values to get data from database
*/
RealDBRoom.prototype.getQueryResult = function (query) {
var _this = this;
return new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
var result, e_3;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
_a.trys.push([0, 5, , 6]);
if (!this._config.queryOptions.isCollectionQuery) return [3 /*break*/, 2];
return [4 /*yield*/, this._adapter.find(query, this._config.queryOptions)];
case 1:
result = _a.sent();
return [3 /*break*/, 4];
case 2: return [4 /*yield*/, this._adapter.findOne(query, this._config.queryOptions)];
case 3:
result = _a.sent();
_a.label = 4;
case 4:
resolve(result);
return [3 /*break*/, 6];
case 5:
e_3 = _a.sent();
reject(e_3);
return [3 /*break*/, 6];
case 6: return [2 /*return*/];
}
});
}); });
};
/**
* Toggles between sockets registration membership of this room. True status registers the socket in room
* @param status boolean determind whether socket is authenticated or not
* @param socketData socket connection data
*/
RealDBRoom.prototype.toggleSocketInRoom = function (status, socketData) {
return __awaiter(this, void 0, void 0, function () {
var socketId, _loop_1, _i, _a, meta, _b, _c, meta;
var _this = this;
return __generator(this, function (_d) {
socketId = socketData.socket.id;
if (status) {
// register socket to room
this._registeredSocketData[socketId] = socketData;
delete this._unregisteredSocketData[socketId];
_loop_1 = function (meta) {
// socket listens for re-auth triggers
socketData.socket.on(meta.responseId + "_auth", function (payload) {
utilService.resolveAuths(_this._auths, payload, meta.authStateChange);
});
};
for (_i = 0, _a = socketData.meta; _i < _a.length; _i++) {
meta = _a[_i];
_loop_1(meta);
}
}
else {
// unregister the socket
this._unregisteredSocketData[socketId] = socketData;
delete this._registeredSocketData[socketId];
for (_b = 0, _c = socketData.meta; _b < _c.length; _b++) {
meta = _c[_b];
socketData.socket.off(meta.responseId + "_auth", function () {
// socket is no longer listening for query level auth triggers
});
}
}
return [2 /*return*/];
});
});
};
return RealDBRoom;
}());
exports.RealDBRoom = RealDBRoom;