@bitblit/ratchet-epsilon-common/lib/built-in/http/built-in-handlers.js

Tiny adapter to simplify building API gateway Lambda APIS

import { Logger } from '@bitblit/ratchet-common/logger/logger';
import { StringRatchet } from '@bitblit/ratchet-common/lang/string-ratchet';
import { RestfulApiHttpError } from '@bitblit/ratchet-common/network/restful-api-http-error';
import { NumberRatchet } from '@bitblit/ratchet-common/lang/number-ratchet';
import { BadRequestError } from '../../http/error/bad-request-error.js';
import { UnauthorizedError } from '../../http/error/unauthorized-error.js';
import { NotFoundError } from '../../http/error/not-found-error.js';
import { ForbiddenError } from '../../http/error/forbidden-error.js';
import { NotImplemented } from '../../http/error/not-implemented.js';
import { MisconfiguredError } from '../../http/error/misconfigured-error.js';
export class BuiltInHandlers {
    static async expectedHandledByFilter(evt, _flag) {
        throw new MisconfiguredError().withFormattedErrorMessage('Should not happen - it was expected that route %s would be handled by a filter', evt.path);
    }
    static async handleNotImplemented(evt, _flag) {
        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 async sample(evt, flag, context) {
        const rval = {
            time: new Date().toLocaleString(),
            evt: evt,
            pad: StringRatchet.createRandomHexString(2000),
            flag: flag,
        };
        if (context) {
            rval['context'] = context;
        }
        const errNumber = NumberRatchet.safeNumber(evt.queryStringParameters['error']);
        if (errNumber) {
            switch (errNumber) {
                case -1:
                    throw new Error('Test random failure');
                case 400:
                    throw new BadRequestError('Bad request error');
                case 401:
                    throw new UnauthorizedError('Unauthorized error');
                case 403:
                    throw new ForbiddenError('Forbidden error');
                case 404:
                    throw new NotFoundError('Not Found error');
                case 501:
                    throw new NotImplemented('Not Implemented');
                default:
                    throw new RestfulApiHttpError()
                        .withFormattedErrorMessage('Default error - %s', errNumber)
                        .withHttpStatusCode(500)
                        .withDetails({ src: errNumber })
                        .withEndUserErrors(['msg1', 'msg2']);
            }
        }
        let test = StringRatchet.trimToNull(evt.queryStringParameters['test']);
        if (test) {
            test = test.toLowerCase();
            if (test === 'null') {
                return null;
            }
        }
        return rval;
    }
    static async defaultErrorProcessor(event, err, cfg) {
        Logger.warn('Unhandled error (in promise catch) : %s \nStack was: %s\nEvt was: %j\nConfig was: %j', err.message, err.stack, event, cfg);
    }
}
//# sourceMappingURL=built-in-handlers.js.map