@bitblit/ratchet-epsilon-common/lib/sample/sample-server-components.js

Tiny adapter to simplify building API gateway Lambda APIS

import { ErrorRatchet } from '@bitblit/ratchet-common/lang/error-ratchet';
import { StringRatchet } from '@bitblit/ratchet-common/lang/string-ratchet';
import { LoggerLevelName } from '@bitblit/ratchet-common/logger/logger-level-name';
import { NumberRatchet } from '@bitblit/ratchet-common/lang/number-ratchet';
import { BooleanRatchet } from '@bitblit/ratchet-common/lang/boolean-ratchet';
import { EpsilonGlobalHandler } from '../epsilon-global-handler.js';
import { BuiltInHandlers } from '../built-in/http/built-in-handlers.js';
import { LocalWebTokenManipulator } from '../http/auth/local-web-token-manipulator.js';
import { EchoProcessor } from '../built-in/background/echo-processor.js';
import { NoOpProcessor } from '../built-in/background/no-op-processor.js';
import { SampleDelayProcessor } from '../built-in/background/sample-delay-processor.js';
import { LogAndEnqueueEchoProcessor } from '../built-in/background/log-and-enqueue-echo-processor.js';
import { EpsilonConfigParser } from '../util/epsilon-config-parser.js';
import { RouterUtil } from '../http/route/router-util.js';
import { SampleInputValidatedProcessor } from '../built-in/background/sample-input-validated-processor.js';
import { BuiltInAuthorizers } from '../built-in/http/built-in-authorizers.js';
import { BuiltInFilters } from '../built-in/http/built-in-filters.js';
import { LogMessageBackgroundErrorProcessor } from '../built-in/background/log-message-background-error-processor.js';
import { SingleThreadLocalBackgroundManager } from '../background/manager/single-thread-local-background-manager.js';
import { SampleServerStaticFiles } from './sample-server-static-files.js';
export class SampleServerComponents {
    constructor() { }
    static createSampleTokenManipulator() {
        const tokenManipulator = new LocalWebTokenManipulator(['abcd1234'], 'sample.erigir.com')
            .withParseFailureLogLevel(LoggerLevelName.debug)
            .withExtraDecryptionKeys(['abcdefabcdef'])
            .withOldKeyUseLogLevel(LoggerLevelName.info);
        return tokenManipulator;
    }
    static async createSampleEpsilonConfig(label) {
        const yamlString = SampleServerStaticFiles.SAMPLE_OPEN_API_DOC;
        const authorizers = new Map();
        authorizers.set('SampleAuthorizer', (token, evt) => BuiltInAuthorizers.simpleLoggedInAuth(token, evt));
        authorizers.set('LogAuthorizer', (token, evt) => BuiltInAuthorizers.simpleNoAuthenticationLogAccess(token, evt));
        const handlers = new Map();
        handlers.set('get /', (event, context) => BuiltInHandlers.sample(event, null, context));
        handlers.set('get /meta/server', (event) => BuiltInHandlers.sample(event));
        handlers.set('get /meta/user', (event) => BuiltInHandlers.sample(event));
        handlers.set('get /meta/item/{itemId}', (event) => BuiltInHandlers.sample(event));
        handlers.set('post /secure/access-token', (event) => BuiltInHandlers.sample(event));
        handlers.set('get /multi/fixed', (event) => BuiltInHandlers.sample(event, 'fixed'));
        handlers.set('get /multi/{v}', (event) => BuiltInHandlers.sample(event, 'variable'));
        handlers.set('get /event', (event) => {
            return Promise.resolve({
                statusCode: 200,
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify(event, null, 2),
            });
        });
        handlers.set('get /err/{code}', (event) => {
            const err = ErrorRatchet.fErr('Fake Err : %j', event);
            err['statusCode'] = NumberRatchet.safeNumber(event.pathParameters['code']);
            throw err;
        });
        handlers.set('get /meta/sample-item', async (event) => {
            const numberToUse = NumberRatchet.safeNumber(event.queryStringParameters['num']) || 5;
            const rval = {
                numberParam: numberToUse,
                nameParam: 'Test-String',
            };
            return rval;
        });
        handlers.set('post /meta/sample-item', async (event) => {
            const parsed = event.parsedBody;
            const forceFail = BooleanRatchet.parseBool(StringRatchet.trimToNull(event.queryStringParameters['forceFail'])) === true;
            if (forceFail) {
                parsed['numberParam'] = 'test';
            }
            return parsed;
        });
        const meta = RouterUtil.defaultHttpMetaProcessingConfigWithAuthenticationHeaderParsing(SampleServerComponents.createSampleTokenManipulator());
        meta.timeoutMS = 10_000;
        meta.errorFilters.push((fCtx) => BuiltInFilters.secureOutboundServerErrorForProduction(fCtx, 'Clean Internal Server Error', 500));
        const preFiltersAllowingNull = Object.assign({}, meta);
        preFiltersAllowingNull.preFilters = Object.assign([], preFiltersAllowingNull.preFilters);
        preFiltersAllowingNull.preFilters.splice(8, 1);
        const cfg = {
            defaultMetaHandling: meta,
            handlers: handlers,
            authorizers: authorizers,
            overrideMetaHandling: [
                {
                    pathRegex: '/background',
                    methods: null,
                    config: Object.assign({}, meta, { overrideAuthorizerName: 'LogAuthorizer' }),
                },
                {
                    pathRegex: '/meta/server',
                    methods: ['GET'],
                    config: preFiltersAllowingNull,
                },
            ],
            prefixesToStripBeforeRouteMatch: ['v0'],
            filterHandledRouteMatches: ['options .*'],
        };
        const background = {
            httpMetaEndpoint: '/background/meta',
            httpSubmissionPath: '/background',
            implyTypeFromPathSuffix: false,
            processors: [
                new EchoProcessor(),
                new NoOpProcessor(),
                new SampleDelayProcessor(),
                new SampleInputValidatedProcessor(),
                new LogAndEnqueueEchoProcessor(),
            ],
            errorProcessor: new LogMessageBackgroundErrorProcessor(),
        };
        const epsilonConfig = {
            label: label,
            openApiYamlString: yamlString,
            httpConfig: cfg,
            backgroundConfig: background,
        };
        return epsilonConfig;
    }
    static async createSampleEpsilonGlobalHandler(label) {
        const epsilonConfig = await SampleServerComponents.createSampleEpsilonConfig(label);
        const backgroundManager = new SingleThreadLocalBackgroundManager();
        const epsilonInstance = EpsilonConfigParser.epsilonConfigToEpsilonInstance(epsilonConfig, backgroundManager);
        const rval = new EpsilonGlobalHandler(epsilonInstance);
        return rval;
    }
    static async createSampleBatchOnlyEpsilonGlobalHandler(label) {
        const epsilonConfig = await SampleServerComponents.createSampleEpsilonConfig(label);
        epsilonConfig.httpConfig.handlers = new Map();
        const byPassCfg = Object.assign({}, epsilonConfig.httpConfig.defaultMetaHandling);
        byPassCfg.preFilters = byPassCfg.preFilters.concat([
            (fCtx) => BuiltInFilters.autoRespond(fCtx, { message: 'Background Processing Only' }),
        ]);
        epsilonConfig.httpConfig.overrideMetaHandling = [
            {
                pathRegex: '.*background.*',
                invertPathMatching: true,
                config: byPassCfg,
            },
        ];
        epsilonConfig.httpConfig.filterHandledRouteMatches = ['.*'];
        const backgroundManager = new SingleThreadLocalBackgroundManager();
        const epsilonInstance = EpsilonConfigParser.epsilonConfigToEpsilonInstance(epsilonConfig, backgroundManager);
        const rval = new EpsilonGlobalHandler(epsilonInstance);
        return rval;
    }
}
//# sourceMappingURL=sample-server-components.js.map