@bitblit/epsilon/built-in/http/built-in-handlers.js

Tiny adapter to simplify building API gateway Lambda APIS

"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());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.BuiltInHandlers = void 0;
const string_ratchet_1 = require("@bitblit/ratchet/common/string-ratchet");
const logger_1 = require("@bitblit/ratchet/common/logger");
const number_ratchet_1 = require("@bitblit/ratchet/common/number-ratchet");
const bad_request_error_1 = require("../../http/error/bad-request-error");
const unauthorized_error_1 = require("../../http/error/unauthorized-error");
const not_found_error_1 = require("../../http/error/not-found-error");
const forbidden_error_1 = require("../../http/error/forbidden-error");
const not_implemented_1 = require("../../http/error/not-implemented");
const misconfigured_error_1 = require("../../http/error/misconfigured-error");
const common_1 = require("@bitblit/ratchet/common");
class BuiltInHandlers {
    static expectedHandledByFilter(evt, flag) {
        return __awaiter(this, void 0, void 0, function* () {
            throw new misconfigured_error_1.MisconfiguredError().withFormattedErrorMessage('Should not happen - it was expected that route %s would be handled by a filter', evt.path);
        });
    }
    static handleNotImplemented(evt, flag) {
        return __awaiter(this, void 0, void 0, function* () {
            logger_1.Logger.info('A request was made to %s with body %j - not yet implemented', evt.path, evt.body);
            const rval = {
                time: new Date().toLocaleString(),
                path: evt.path,
                message: 'NOT IMPLEMENTED YET',
            };
            return rval;
        });
    }
    static sample(evt, flag, context) {
        return __awaiter(this, void 0, void 0, function* () {
            const rval = {
                time: new Date().toLocaleString(),
                evt: evt,
                pad: string_ratchet_1.StringRatchet.createRandomHexString(2000),
                flag: flag,
            };
            if (context) {
                rval['context'] = context;
            }
            const errNumber = number_ratchet_1.NumberRatchet.safeNumber(evt.queryStringParameters['error']);
            if (errNumber) {
                switch (errNumber) {
                    case -1:
                        throw new Error('Test random failure');
                    case 400:
                        throw new bad_request_error_1.BadRequestError('Bad request error');
                    case 401:
                        throw new unauthorized_error_1.UnauthorizedError('Unauthorized error');
                    case 403:
                        throw new forbidden_error_1.ForbiddenError('Forbidden error');
                    case 404:
                        throw new not_found_error_1.NotFoundError('Not Found error');
                    case 501:
                        throw new not_implemented_1.NotImplemented('Not Implemented');
                    default:
                        throw new common_1.RestfulApiHttpError()
                            .withFormattedErrorMessage('Default error - %s', errNumber)
                            .withHttpStatusCode(500)
                            .withDetails({ src: errNumber })
                            .withEndUserErrors(['msg1', 'msg2']);
                }
            }
            let test = string_ratchet_1.StringRatchet.trimToNull(evt.queryStringParameters['test']);
            if (test) {
                test = test.toLowerCase();
                if (test === 'null') {
                    return null;
                }
            }
            return rval;
        });
    }
    static defaultErrorProcessor(event, err, cfg) {
        return __awaiter(this, void 0, void 0, function* () {
            logger_1.Logger.warn('Unhandled error (in promise catch) : %s \nStack was: %s\nEvt was: %j\nConfig was: %j', err.message, err.stack, event, cfg);
        });
    }
}
exports.BuiltInHandlers = BuiltInHandlers;
//# sourceMappingURL=built-in-handlers.js.map