@flexiblepersistence/backnextapi
Version:
A simple API framework using Flexible Persistence
211 lines • 7 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const flexiblepersistence_1 = require("flexiblepersistence");
const ts_mixer_1 = require("ts-mixer");
ts_mixer_1.settings.initFunction = 'init';
class BaseControllerDefault extends flexiblepersistence_1.Default {
constructor(initDefault) {
super(initDefault);
this.regularErrorStatus = {
error: 400,
Error: 400,
RemoveError: 400,
JsonWebTokenError: 401,
Unauthorized: 401,
PaymentRequired: 402,
TypeError: 403,
NotFound: 404,
MethodNotAllowed: 405,
UnknownError: 500,
};
this.method = {
GET: 'read',
POST: 'store',
PUT: 'update',
PATCH: 'update',
DELETE: 'delete',
};
}
async mainRequestHandler(req, res) {
try {
let response;
if (req.method &&
this.method[req.method] &&
this[this.method[req.method]])
response = await this[this.method[req.method]](req, res);
else {
const error = new Error('Missing HTTP method.');
throw error;
}
return response;
}
catch (error) {
return new Promise(() => this.generateError(res, error));
}
}
errorStatus(error) {
if (error)
return this.regularErrorStatus[error];
return this.regularErrorStatus;
}
init(initDefault) {
super.init(initDefault);
if (initDefault) {
this.handler = initDefault.handler;
this.middlewares = [];
if (initDefault.middlewares)
this.middlewares.push(...initDefault.middlewares);
}
// console.log(this.handler);
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any
async event(event) {
return new Promise(async (resolve, reject) => {
if (!this.journaly)
reject(new Error('No journaly connected!'));
if (this.handler) {
this.handler
.addEvent(event)
.then((value) => resolve(value))
.catch((error) => reject(error));
}
else
reject(new Error('No handler connected!'));
});
}
runMiddleware(req, res, fn) {
return new Promise((resolve, reject) => {
fn(req, res, (result) => {
if (result instanceof Error) {
return reject(result);
}
return resolve(result);
});
});
}
async runMiddlewares(req, res) {
if (this.middlewares)
for (const middleware of this.middlewares)
await this.runMiddleware(req, res, middleware);
}
generateName() {
this.setName(this.getClassName().replace('Controller', this.getType()));
}
generateError(res, error) {
if (error.message.includes('does not exist'))
error.name = 'NotFound';
if (!this.errorStatus() || this.errorStatus(error.name) === undefined)
res
.status(this.errorStatus('UnknownError'))
.send({ error: error.message });
else
res
.status(this.errorStatus(error.name))
.send({ error: error.message });
return res;
}
hasObjectName() {
if (process.env.API_HAS_OBJECT_NAME)
return /^true$/i.test(process.env.API_HAS_OBJECT_NAME);
return false;
}
getObject(object) {
if (this.hasObjectName())
return object[this.getName()];
return object;
}
setObject(object, value) {
if (value === undefined)
value = {};
if (this.hasObjectName()) {
if (!this.getName())
throw new Error('Element is not specified.');
object[this.getName()] = value;
}
else
object = value;
return object;
}
formatName() {
const name = this.getClassName().replace('Controller', '');
return name;
}
formatContent(req) {
const content = req.body;
return content;
}
formatParams(req) {
return req['params'];
}
formatQuery(req) {
const { query } = req;
return query;
}
formatSingle(params, singleDefault) {
// deepcode ignore HTTPSourceWithUncheckedType: params do not exist on next
let single;
if (params) {
single = params.single;
}
// console.log(single);
if (singleDefault !== undefined && single === undefined)
single = singleDefault;
return single;
}
formatSelection(params, query) {
let selection;
if (params && params.filter)
selection = params.filter;
else
selection = query;
return selection;
}
formatEvent(req, operation, singleDefault) {
const params = this.formatParams(req);
const name = this.formatName();
const event = new flexiblepersistence_1.Event({
operation,
single: this.formatSingle(params, singleDefault),
content: this.formatContent(req),
selection: this.formatSelection(params, this.formatQuery(req)),
name,
options: req.headers,
});
req['event'] = {
operation,
name,
};
return event;
}
generateStatus(operation, object) {
const resultObject = this.getObject(object);
switch (operation) {
case flexiblepersistence_1.Operation.create:
return 201;
case flexiblepersistence_1.Operation.nonexistent:
return 410;
default:
if (resultObject === undefined ||
Object.keys(resultObject).length === 0 ||
resultObject.length === 0)
return 204;
else
return 200;
}
// 206 Partial Content - pagination
}
// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
async generateObject(useFunction, event) {
return this.setObject({}, (await useFunction(event))['receivedItem']);
}
async generateEvent(req, res, operation, useFunction, singleDefault) {
const event = this.formatEvent(req, operation, singleDefault);
await this.runMiddlewares(req, res);
const object = await this.generateObject(useFunction, event);
const status = this.generateStatus(operation, object);
res.status(status).json(object);
return res;
}
}
exports.default = BaseControllerDefault;
//# sourceMappingURL=baseControllerDefault.js.map