gamoraa-mongostore
Version:
Plugin provides firestore kind of functionality but based on mongodb.
411 lines • 13.6 kB
JavaScript
"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
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) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const grpc_boom_1 = __importDefault(require("grpc-boom"));
const gamoraa_1 = require("gamoraa");
const types_1 = require("../types");
const json_utils_1 = require("./json-utils");
const map_obj_1 = require("./map-obj");
/**
*
* @param routeConfig
*/
function getModelRouteWithDefaults(routeConfig) {
const newRouteConfig = Object.assign({ disable: false, checkPermission: false }, (routeConfig != undefined ? routeConfig : {}));
return newRouteConfig;
}
/**
*
* @param modelOptions
*/
function createModelsMap(modelOptions) {
const modelsMap = {};
for (const modelOpt of modelOptions) {
const { create, insertMany, findById, findOne, find, findAndStreamResponse, findLive, findByIdAndUpdate, findOneAndUpdate, updateMany, findByIdAndDelete, findOneAndDelete, deleteMany, countDocuments, estimatedDocumentCount, watch, } = modelOpt;
const newModelServiceConfig = Object.assign(Object.assign({}, modelOpt), { create: getModelRouteWithDefaults(create), insertMany: getModelRouteWithDefaults(insertMany), findById: getModelRouteWithDefaults(findById), findOne: getModelRouteWithDefaults(findOne), find: getModelRouteWithDefaults(find), findAndStreamResponse: getModelRouteWithDefaults(findAndStreamResponse), findLive: getModelRouteWithDefaults(findLive), findByIdAndUpdate: getModelRouteWithDefaults(findByIdAndUpdate), findOneAndUpdate: getModelRouteWithDefaults(findOneAndUpdate), updateMany: getModelRouteWithDefaults(updateMany), findByIdAndDelete: getModelRouteWithDefaults(findByIdAndDelete), findOneAndDelete: getModelRouteWithDefaults(findOneAndDelete), deleteMany: getModelRouteWithDefaults(deleteMany), countDocuments: getModelRouteWithDefaults(countDocuments), estimatedDocumentCount: getModelRouteWithDefaults(estimatedDocumentCount), watch: getModelRouteWithDefaults(watch) });
modelsMap[modelOpt.model.modelName] = newModelServiceConfig;
}
return modelsMap;
}
exports.createModelsMap = createModelsMap;
/**
*
* @param action
* @param readRoles
* @param writeRoles
* @param routeConfig
*/
function createRouteMiddlewares(action, readRoles, writeRoles, routeConfig) {
const { middleware, checkPermission, roleResolver } = routeConfig;
const allMiddlewares = [];
const forbiddenMessage = `Permission not allowed`;
if (middleware) {
if (Array.isArray(middleware)) {
if (middleware.length > 0) {
allMiddlewares.concat(middleware);
}
}
else {
allMiddlewares.push(middleware);
}
}
if (checkPermission) {
// creating new permission resolver middleware
const prm = function (context, next) {
return __awaiter(this, void 0, void 0, function* () {
if (roleResolver) {
try {
const role = yield roleResolver(context);
if (action == types_1.ActionType.Read) {
let allow = false;
if (writeRoles) {
if (writeRoles.includes(role)) {
allow = true;
}
}
if (readRoles) {
if (readRoles.includes(role)) {
allow = true;
}
}
if (!allow) {
return next(grpc_boom_1.default.permissionDenied(forbiddenMessage));
}
}
else if (action == types_1.ActionType.Create ||
action == types_1.ActionType.Update ||
action == types_1.ActionType.Delete) {
if (writeRoles && writeRoles.length > 0) {
if (!writeRoles.includes(role)) {
return next(grpc_boom_1.default.permissionDenied(forbiddenMessage));
}
}
else {
return next(grpc_boom_1.default.permissionDenied(forbiddenMessage));
}
}
return next();
}
catch (error) {
return next(error);
}
}
else {
return next();
}
});
};
allMiddlewares.push(prm);
}
return allMiddlewares;
}
exports.createRouteMiddlewares = createRouteMiddlewares;
/**
*
* @param context
* @param routeMiddlewares
*/
function executeRouteMiddlewares(context, routeMiddlewares) {
function executor(resolve, reject) {
if (routeMiddlewares.length == 0) {
resolve();
}
else {
const middieCompleter = function (err, ctz) {
return __awaiter(this, void 0, void 0, function* () {
if (err) {
reject(err);
}
else {
resolve();
}
});
};
const middie = new gamoraa_1.Middie(routeMiddlewares, middieCompleter);
middie.run(context);
}
}
return new Promise(executor);
}
exports.executeRouteMiddlewares = executeRouteMiddlewares;
/**
*
* @param model
* @param modelsMap
*/
function checkModelExist(model, modelsMap) {
if (model.length == 0) {
return grpc_boom_1.default.invalidArgument('Model value required');
}
else if (modelsMap[model] == null) {
return grpc_boom_1.default.invalidArgument('Model not defined on server');
}
return undefined;
}
exports.checkModelExist = checkModelExist;
/**
*
* @param model
* @param request
*/
function createDocument(model, request) {
return __awaiter(this, void 0, void 0, function* () {
const payload = yield json_utils_1.jsonParse(request.payload);
try {
const doc = yield model.create(payload);
return doc;
}
catch (error) {
throw grpc_boom_1.default.invalidArgument(error.message);
}
});
}
exports.createDocument = createDocument;
/**
*
* @param model
* @param request
*/
function insertManyDocuments(model, request) {
return __awaiter(this, void 0, void 0, function* () {
const payload = yield json_utils_1.jsonParse(request.payload);
try {
const doc = yield model.insertMany(payload);
return doc;
}
catch (error) {
throw grpc_boom_1.default.invalidArgument(error.message);
}
});
}
exports.insertManyDocuments = insertManyDocuments;
/**
*
* @param model
* @param request
*/
function findByIdDocument(model, request) {
const q = model.findById(request.id);
q.select(request.select);
q.populate(request.populate);
return q.lean().exec();
}
exports.findByIdDocument = findByIdDocument;
/**
*
* @param model
* @param request
*/
function findOneDocument(model, request) {
const q = model.findOne(JSON.parse(request.conditions));
q.select(request.select);
q.sort(request.sort);
q.populate(request.populate);
if (request.skip > 0)
q.skip(request.skip);
return q.lean().exec();
}
exports.findOneDocument = findOneDocument;
/**
*
* @param model
* @param request
*/
function findDocuments(model, request) {
const q = model.find(JSON.parse(request.conditions));
q.select(request.select);
q.sort(request.sort);
q.populate(request.populate);
if (request.skip > 0)
q.skip(request.skip);
if (request.limit > 0)
q.limit(request.limit);
return q.lean().exec();
}
exports.findDocuments = findDocuments;
/**
*
* @param model
* @param request
*/
function findDocumentsAndStreamResponse(model, request) {
const q = model.find(JSON.parse(request.conditions));
q.select(request.select);
q.sort(request.sort);
q.populate(request.populate);
if (request.skip > 0)
q.skip(request.skip);
if (request.limit > 0)
q.limit(request.limit);
return q.lean().cursor();
}
exports.findDocumentsAndStreamResponse = findDocumentsAndStreamResponse;
/**
*
* @param model
* @param request
*/
function findDocumentsLive(model, request) {
const conditions = JSON.parse(request.conditions);
function updateKey(key) {
if (key != null) {
if (key.charAt(0) != '$') {
return `fullDocument.${key}`;
}
}
return key;
}
const updatedConditions = map_obj_1.transformObjKeys(conditions, updateKey, {
deep: true,
});
const changeStream = model.collection.watch([
{
$match: {
$or: [
Object.assign({ operationType: { $in: ['insert', 'update'] } }, updatedConditions),
{
operationType: { $in: ['delete'] },
},
],
},
},
], {
fullDocument: 'updateLookup',
});
return changeStream;
}
exports.findDocumentsLive = findDocumentsLive;
/**
*
* @param model
* @param request
*/
function findByIdAndUpdateDocument(model, request) {
const q = model.findByIdAndUpdate(request.id, JSON.parse(request.update), {
new: request.returnNew,
select: request.select,
upsert: request.upsert,
});
return q.lean().exec();
}
exports.findByIdAndUpdateDocument = findByIdAndUpdateDocument;
/**
*
* @param model
* @param request
*/
function findOneAndUpdateDocument(model, request) {
const q = model.findOneAndUpdate(request.id, JSON.parse(request.update), {
new: request.returnNew,
select: request.select,
upsert: request.upsert,
sort: request.sort,
});
return q.lean().exec();
}
exports.findOneAndUpdateDocument = findOneAndUpdateDocument;
/**
*
* @param model
* @param request
*/
function updateManyDocuments(model, request) {
const q = model.updateMany(JSON.parse(request.conditions), JSON.parse(request.update), {
safe: request.safe,
upsert: request.upsert,
multi: request.multi,
});
return q.lean().exec();
}
exports.updateManyDocuments = updateManyDocuments;
/**
*
* @param model
* @param request
*/
function findByIdAndDeleteDocument(model, request) {
const q = model.findByIdAndDelete(request.id, {
select: request.select,
});
return q.lean().exec();
}
exports.findByIdAndDeleteDocument = findByIdAndDeleteDocument;
/**
*
* @param model
* @param request
*/
function findOneAndDeleteDocument(model, request) {
const q = model.findOneAndDelete(JSON.parse(request.conditions), {
select: request.select,
sort: request.sort,
});
return q.lean().exec();
}
exports.findOneAndDeleteDocument = findOneAndDeleteDocument;
/**
*
* @param model
* @param request
*/
function deleteManyDocuments(model, request) {
const q = model.deleteMany(JSON.parse(request.conditions));
return q.lean().exec();
}
exports.deleteManyDocuments = deleteManyDocuments;
/**
*
* @param model
* @param request
*/
function countDocumentsUtil(model, request) {
const q = model.countDocuments(JSON.parse(request.criteria));
return q.exec();
}
exports.countDocumentsUtil = countDocumentsUtil;
/**
*
* @param model
* @param request
*/
function estimatedDocumentCountUtil(model, request) {
const q = model.estimatedDocumentCount();
return q.exec();
}
exports.estimatedDocumentCountUtil = estimatedDocumentCountUtil;
/**
*
* @param model
* @param request
*/
function watchUtil(model, request) {
const { pipeline, options } = request;
const nOpt = {};
if (options.fullDocument.length > 0)
nOpt.fullDocument = options.fullDocument;
if (options.maxAwaitTimeMS > 0)
nOpt.maxAwaitTimeMS = options.maxAwaitTimeMS;
if (options.resumeAfter.length > 0)
nOpt.resumeAfter = options.resumeAfter;
if (options.startAfter.length > 0)
nOpt.startAfter = options.startAfter;
if (options.batchSize > 0)
nOpt.batchSize = options.batchSize;
if (options.readPreference.length > 0)
nOpt.readPreference = options.readPreference;
const stream = model.collection.watch(JSON.parse(pipeline), nOpt);
return stream;
}
exports.watchUtil = watchUtil;
//# sourceMappingURL=service-utils.js.map