@bitblit/ratchet-epsilon-common 4.0.85-alpha

package/dist/es/open-api-util/open-api-doc-modifier.js

@@ -0,0 +1,78 @@
+import yaml from 'js-yaml';
+import { Logger } from '@bitblit/ratchet-common';
+export class OpenApiDocModifier {
+    constructor(options) {
+        this.options = options;
+    }
+    modifyOpenApiDoc(yamlString) {
+        let rval;
+        if (!!yamlString && !!this.options) {
+            try {
+                const openApi = yaml.load(yamlString);
+                const removeTags = this.options.removeTags ? this.options.removeTags.map((t) => t.toLowerCase()) : [];
+                if (this.options.newServerPath) {
+                    openApi['servers'] = [{ url: this.options.newServerPath }];
+                }
+                if (!!this.options.removeTags && openApi['tags']) {
+                    if (openApi['tags']) {
+                        openApi['tags'] = openApi.tags.filter((f) => {
+                            const n = !!f && !!f['name'] ? f['name'].toLowerCase() : '';
+                            const i = removeTags.indexOf(n);
+                            return i === -1;
+                        });
+                    }
+                }
+                if (openApi['paths']) {
+                    let newPaths = {};
+                    Object.keys(openApi['paths']).forEach((p) => {
+                        const path = openApi['paths'][p];
+                        Object.keys(path).forEach((verb) => {
+                            const entry = path[verb];
+                            entry.tags = !!entry.tags ? entry.tags.filter((t) => removeTags.lastIndexOf(t.toLowerCase()) == -1) : entry.tags;
+                            const matcher = verb.toLowerCase() + ' ' + p.toLowerCase();
+                            if (this.matchNone(matcher, this.options.removeEndpoints)) {
+                                newPaths[p] = newPaths[p] || {};
+                                newPaths[p][verb] = entry;
+                            }
+                        });
+                    });
+                    if (this.options.sortEndpoints) {
+                        const keys = Object.keys(newPaths).sort();
+                        const newPaths2 = {};
+                        keys.forEach((k) => {
+                            newPaths2[k] = newPaths[k];
+                        });
+                        newPaths = newPaths2;
+                    }
+                    openApi['paths'] = newPaths;
+                }
+                let remSchemas = this.options.removeSchemas || [];
+                remSchemas = remSchemas.map((s) => s.toLowerCase());
+                if (openApi['components'] && openApi['components']['schemas']) {
+                    const keys = Object.keys(openApi['components']['schemas']).sort();
+                    const newComp = {};
+                    keys.forEach((k) => {
+                        if (remSchemas.indexOf(k.toLowerCase()) === -1) {
+                            newComp[k] = openApi['components']['schemas'][k];
+                        }
+                    });
+                    openApi['components']['schemas'] = newComp;
+                }
+                rval = yaml.dump(openApi);
+            }
+            catch (err) {
+                Logger.error('Error processing yaml: %s', err, err);
+            }
+        }
+        return rval;
+    }
+    matchNone(input, regex) {
+        let rval = true;
+        if (!!input && !!regex) {
+            regex.forEach((r) => {
+                rval = rval && !r.test(input);
+            });
+        }
+        return rval;
+    }
+}

package/dist/es/open-api-util/yaml-combiner.js

@@ -0,0 +1,27 @@
+import fs from 'fs';
+import { RequireRatchet } from '@bitblit/ratchet-common';
+import yaml from 'js-yaml';
+import { Logger } from '@bitblit/ratchet-common';
+export class YamlCombiner {
+    static combine(files, inRootPath = []) {
+        RequireRatchet.notNullOrUndefined(files, 'Files argument');
+        RequireRatchet.true(files.length > 0, 'Files argument larger than 0');
+        RequireRatchet.notNullOrUndefined(inRootPath, 'Root path argument');
+        Logger.info('Processing %d files into output', files.length);
+        let allElements = {};
+        for (let i = 0; i < files.length; i++) {
+            const fileContents = fs.readFileSync(files[i]).toString();
+            const openApi = yaml.load(fileContents);
+            allElements = Object.assign(allElements, openApi);
+        }
+        const rootPath = Object.assign([], inRootPath);
+        while (rootPath.length > 0) {
+            const next = {};
+            next[rootPath[rootPath.length - 1]] = allElements;
+            rootPath.splice(rootPath.length - 1, 1);
+            allElements = next;
+        }
+        const rval = yaml.dump(allElements);
+        return rval;
+    }
+}

package/dist/es/run-background-process-from-command-line.js

@@ -0,0 +1,32 @@
+import { ErrorRatchet, Logger, StringRatchet } from '@bitblit/ratchet-common';
+import { program } from 'commander';
+import clear from 'clear';
+export class RunBackgroundProcessFromCommandLine {
+    static async processBackgroundCliRequest(epsilon, dryRun) {
+        let rval = false;
+        clear();
+        Logger.info('Bootstrapping batch processor, args : %j', process.argv);
+        program
+            .version('0.0.1')
+            .requiredOption('-p --process <processKey>', 'Background process key')
+            .option('-d --data <data>', 'Background data block, JSON encoded')
+            .option('-m --metadata <metadata>', 'Background metadata block, JSON encoded')
+            .parse(process.argv);
+        Logger.info('Program definition : %s : %s : %s', program.opts().process, program.opts().data, program.opts().meta);
+        let data = {};
+        if (StringRatchet.trimToNull(program.opts().data)) {
+            data = JSON.parse(program.opts().data);
+        }
+        if (dryRun) {
+            Logger.info('Dry run specified - not executing');
+            rval = false;
+        }
+        else {
+            if (!epsilon) {
+                ErrorRatchet.throwFormattedErr('Cannot run background cli because epsilon global handler is null');
+            }
+            rval = await epsilon.processSingleBackgroundByParts(program.opts().process, data);
+        }
+        return rval;
+    }
+}

package/dist/es/sample/sample-batch-only-local-server.js

@@ -0,0 +1,17 @@
+import { Logger } from '@bitblit/ratchet-common';
+import { SampleServerComponents } from './sample-server-components';
+import { LocalServer } from '../local-server';
+import { LoggerLevelName } from '@bitblit/ratchet-common';
+Logger.setLevel(LoggerLevelName.debug);
+SampleServerComponents.createSampleBatchOnlyEpsilonGlobalHandler()
+    .then((handler) => {
+    const testServer = new LocalServer(handler);
+    testServer.runServer().then((res) => {
+        Logger.info('Got res server');
+        process.exit(0);
+    });
+})
+    .catch((err) => {
+    Logger.error('Error: %s', err, err);
+    process.exit(1);
+});

package/dist/es/sample/sample-local-server.js

@@ -0,0 +1,28 @@
+import { Logger } from '@bitblit/ratchet-common';
+import { SampleServerComponents } from './sample-server-components';
+import { LocalServer } from '../local-server';
+import { LoggerLevelName } from '@bitblit/ratchet-common';
+import { LocalWebTokenManipulator } from '../http/auth/local-web-token-manipulator';
+Logger.setLevel(LoggerLevelName.debug);
+const localTokenHandler = new LocalWebTokenManipulator(['abcd1234'], 'sample-server');
+localTokenHandler
+    .createJWTStringAsync('asdf', {}, ['USER'], 3600)
+    .then((token) => {
+    Logger.info('Use token: %s', token);
+    SampleServerComponents.createSampleEpsilonGlobalHandler()
+        .then((handler) => {
+        const testServer = new LocalServer(handler, 8888, true);
+        testServer.runServer().then((res) => {
+            Logger.info('Got res server');
+            process.exit(0);
+        });
+    })
+        .catch((err) => {
+        Logger.error('Error: %s', err, err);
+        process.exit(1);
+    });
+})
+    .catch((tokenErr) => {
+    Logger.error('Failed to create token : %s', tokenErr);
+    process.exit(1);
+});

package/dist/es/sample/sample-server-components.js

@@ -0,0 +1,192 @@
+import { Logger } from '@bitblit/ratchet-common';
+import { ApolloServer, gql } from 'apollo-server-lambda';
+import { ApolloServerPluginLandingPageGraphQLPlayground } from 'apollo-server-core';
+import { ErrorRatchet } from '@bitblit/ratchet-common';
+import { NumberRatchet } from '@bitblit/ratchet-common';
+import fs from 'fs';
+import path from 'path';
+import { LoggerLevelName, PromiseRatchet } from '@bitblit/ratchet-common';
+import { EpsilonGlobalHandler } from '../epsilon-global-handler';
+import { BuiltInHandlers } from '../built-in/http/built-in-handlers';
+import { LocalWebTokenManipulator } from '../http/auth/local-web-token-manipulator';
+import { EchoProcessor } from '../built-in/background/echo-processor';
+import { NoOpProcessor } from '../built-in/background/no-op-processor';
+import { SampleDelayProcessor } from '../built-in/background/sample-delay-processor';
+import { LogAndEnqueueEchoProcessor } from '../built-in/background/log-and-enqueue-echo-processor';
+import { EpsilonConfigParser } from '../util/epsilon-config-parser';
+import { RouterUtil } from '../http/route/router-util';
+import { SampleInputValidatedProcessor } from '../built-in/background/sample-input-validated-processor';
+import { BuiltInAuthorizers } from '../built-in/http/built-in-authorizers';
+import { ApolloFilter } from '../built-in/http/apollo-filter';
+import { BooleanRatchet } from '@bitblit/ratchet-common';
+import { StringRatchet } from '@bitblit/ratchet-common';
+import { BuiltInFilters } from '../built-in/http/built-in-filters';
+import { EventUtil } from '../http/event-util';
+import { LogMessageBackgroundErrorProcessor } from '../built-in/background/log-message-background-error-processor';
+import { SingleThreadLocalBackgroundManager } from '../background/manager/single-thread-local-background-manager';
+export class SampleServerComponents {
+    constructor() { }
+    static async createSampleApollo() {
+        const gqlString = SampleServerComponents.loadSampleServerGQL();
+        Logger.silly('Creating apollo from : %s', gqlString);
+        const typeDefs = gql(gqlString);
+        const resolvers = {
+            RootQueryType: {
+                serverMeta: async (root) => {
+                    return { version: 'A1', serverTime: new Date().toISOString() };
+                },
+                forceTimeout: async (root) => {
+                    await PromiseRatchet.wait(1000 * 60 * 30);
+                    return { placeholder: 'A1' };
+                },
+            },
+        };
+        const server = new ApolloServer({
+            debug: false,
+            introspection: true,
+            typeDefs,
+            resolvers,
+            plugins: [ApolloServerPluginLandingPageGraphQLPlayground({ endpoint: '/graphql' })],
+            context: async ({ event, context, express }) => {
+                const authTokenSt = EventUtil.extractBearerTokenFromEvent(event);
+                const token = null;
+                if (!!authTokenSt && authTokenSt.startsWith('Bearer')) {
+                    Logger.info('Got : %s', authTokenSt);
+                }
+                const rval = {
+                    user: token,
+                    headers: event.headers,
+                    functionName: context.functionName,
+                    event,
+                    context,
+                };
+                return rval;
+            },
+        });
+        return server;
+    }
+    static async createSampleEpsilonConfig() {
+        const yamlString = SampleServerComponents.loadSampleOpenApiYaml();
+        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 /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 tokenManipulator = new LocalWebTokenManipulator(['abcd1234'], 'sample.erigir.com')
+            .withParseFailureLogLevel(LoggerLevelName.debug)
+            .withExtraDecryptionKeys(['abcdefabcdef'])
+            .withOldKeyUseLogLevel(LoggerLevelName.info);
+        const meta = RouterUtil.defaultHttpMetaProcessingConfigWithAuthenticationHeaderParsing(tokenManipulator);
+        meta.timeoutMS = 10000;
+        ApolloFilter.addApolloFilterToList(meta.preFilters, new RegExp('.*graphql.*'), await SampleServerComponents.createSampleApollo(), {
+            cors: {
+                origin: '*',
+                credentials: true,
+            },
+        });
+        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 = {
+            openApiYamlString: yamlString,
+            httpConfig: cfg,
+            backgroundConfig: background,
+        };
+        return epsilonConfig;
+    }
+    static async createSampleEpsilonGlobalHandler() {
+        const epsilonConfig = await SampleServerComponents.createSampleEpsilonConfig();
+        const backgroundManager = new SingleThreadLocalBackgroundManager();
+        const epsilonInstance = EpsilonConfigParser.epsilonConfigToEpsilonInstance(epsilonConfig, backgroundManager);
+        const rval = new EpsilonGlobalHandler(epsilonInstance);
+        return rval;
+    }
+    static async createSampleBatchOnlyEpsilonGlobalHandler() {
+        const epsilonConfig = await SampleServerComponents.createSampleEpsilonConfig();
+        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;
+    }
+    static loadSampleOpenApiYaml() {
+        const yamlString = fs.readFileSync(path.join(__dirname, '..', 'static', 'sample-open-api-doc.yaml')).toString();
+        return yamlString;
+    }
+    static loadSampleServerGQL() {
+        const yamlString = fs.readFileSync(path.join(__dirname, '..', 'static', 'sample-server.gql')).toString();
+        return yamlString;
+    }
+}

package/dist/es/test-error-server.js

@@ -0,0 +1,43 @@
+import { Logger } from '@bitblit/ratchet-common';
+import { CliRatchet } from '@bitblit/ratchet-node-only';
+import net from 'net';
+export class TestErrorServer {
+    constructor(port = 9999) {
+        this.port = port;
+        this.aborted = false;
+    }
+    async runServer() {
+        Logger.info('Starting Test Error net server on port %d', this.port);
+        return new Promise((res, rej) => {
+            const server = new net.Server({});
+            server.listen(this.port, () => {
+                Logger.info('Server listening for connection requests on socket localhost: %s', this.port);
+            });
+            server.on('connection', async (socket) => {
+                Logger.info('X: A new connection has been established.');
+                socket.write('Hello, client.');
+                socket.on('data', (chunk) => {
+                    Logger.info('Data received from client: %s', chunk);
+                });
+                socket.on('end', () => {
+                    Logger.info('Closing connection with the client');
+                });
+                socket.on('error', (err) => {
+                    Logger.info('Error: %s', err);
+                });
+            });
+        });
+    }
+    async requestHandler(request, response) {
+        Logger.info('Got request %d - closing socket', request);
+        request.setTimeout(100);
+        response.end('x');
+    }
+}
+if (CliRatchet.isCalledFromCLISingle('test-error-server')) {
+    const testServer = new TestErrorServer();
+    testServer.runServer().then((res) => {
+        Logger.info('Got res server');
+        process.exit(0);
+    });
+}

package/dist/es/util/aws-util.js

@@ -0,0 +1,65 @@
+export class AwsUtil {
+    static apiGatewayV2ToApiGatewayV1(srcEvt) {
+        const rval = {
+            requestContext: AwsUtil.apiGatewayV2RequestContextToApiGatewayV1RequestContext(srcEvt.requestContext),
+            httpMethod: srcEvt.requestContext.http.method,
+            path: srcEvt.requestContext.http.path,
+            queryStringParameters: srcEvt.queryStringParameters,
+            headers: srcEvt.headers,
+            body: srcEvt.body,
+            isBase64Encoded: srcEvt.isBase64Encoded,
+            multiValueHeaders: null,
+            multiValueQueryStringParameters: null,
+            pathParameters: srcEvt.pathParameters,
+            stageVariables: srcEvt.stageVariables,
+            resource: null,
+        };
+        return rval;
+    }
+    static apiGatewayV2RequestContextToApiGatewayV1RequestContext(srcEvt) {
+        const rval = {
+            accountId: srcEvt.accountId,
+            apiId: srcEvt.apiId,
+            authorizer: null,
+            domainName: srcEvt.domainName,
+            domainPrefix: srcEvt.domainPrefix,
+            requestId: srcEvt.requestId,
+            routeKey: srcEvt.routeKey,
+            stage: srcEvt.stage,
+            requestTime: srcEvt.time,
+            requestTimeEpoch: srcEvt.timeEpoch,
+            protocol: srcEvt.http.protocol,
+            httpMethod: srcEvt.http.method,
+            identity: null,
+            path: srcEvt.http.path,
+            resourceId: null,
+            resourcePath: null,
+        };
+        return rval;
+    }
+    static findInMap(toFind, map) {
+        let rval = null;
+        map.forEach((val, key) => {
+            if (AwsUtil.matchExact(key, toFind)) {
+                rval = val;
+            }
+        });
+        return rval;
+    }
+    static matchExact(r, str) {
+        const match = str.match(r);
+        return match != null && str == match[0];
+    }
+    static resolvePotentialFunctionToResult(src, def) {
+        let rval = def;
+        if (src) {
+            if (typeof src === 'function') {
+                rval = src();
+            }
+            else {
+                rval = src;
+            }
+        }
+        return rval;
+    }
+}

package/dist/es/util/context-util.js

@@ -0,0 +1,95 @@
+import { NumberRatchet } from '@bitblit/ratchet-common';
+import { ErrorRatchet } from '@bitblit/ratchet-common';
+import { BuiltInTraceIdGenerators } from '../built-in/built-in-trace-id-generators';
+import { StringRatchet } from '@bitblit/ratchet-common';
+export class ContextUtil {
+    constructor() { }
+    static initContext(epsilon, evt, ctx, processLabel) {
+        ContextUtil.CURRENT_EPSILON_REFERENCE = epsilon;
+        ContextUtil.CURRENT_CONTEXT = ctx;
+        ContextUtil.CURRENT_EVENT = evt;
+        ContextUtil.CURRENT_LOG_VARS = {};
+        ContextUtil.CURRENT_PROCESS_LABEL = processLabel;
+    }
+    static clearContext() {
+        ContextUtil.CURRENT_EPSILON_REFERENCE = null;
+        ContextUtil.CURRENT_CONTEXT = null;
+        ContextUtil.CURRENT_EVENT = null;
+        ContextUtil.CURRENT_LOG_VARS = {};
+        ContextUtil.CURRENT_PROCESS_LABEL = null;
+        ContextUtil.CURRENT_OVERRIDE_TRACE_ID = null;
+        ContextUtil.CURRENT_OVERRIDE_TRACE_DEPTH = null;
+    }
+    static setOverrideTrace(traceId, traceDepth) {
+        ContextUtil.CURRENT_OVERRIDE_TRACE_ID = traceId || ContextUtil.CURRENT_OVERRIDE_TRACE_ID;
+        ContextUtil.CURRENT_OVERRIDE_TRACE_DEPTH = traceDepth || ContextUtil.CURRENT_OVERRIDE_TRACE_DEPTH;
+    }
+    static setOverrideTraceFromInternalBackgroundEntry(entry) {
+        ContextUtil.setOverrideTrace(entry.traceId, entry.traceDepth);
+    }
+    static setOverrideTraceFromInterApiEntry(interApiEntry) {
+        ContextUtil.setOverrideTrace(interApiEntry.traceId, interApiEntry.traceDepth);
+    }
+    static addHeadersToRecord(input, depthOffset = 0) {
+        if (input) {
+            input[ContextUtil.traceHeaderName()] = ContextUtil.currentTraceId();
+            input[ContextUtil.traceDepthHeaderName()] = StringRatchet.safeString(ContextUtil.currentTraceDepth() + depthOffset);
+        }
+        else {
+            ErrorRatchet.throwFormattedErr('Cannot add headers to null/undefined input');
+        }
+    }
+    static addTraceToProxyResult(pr) {
+        pr.headers = pr.headers || {};
+        ContextUtil.addHeadersToRecord(pr.headers);
+    }
+    static addTraceToHttpRequestInit(ri) {
+        ri.headers = ri.headers || {};
+        ContextUtil.addHeadersToRecord(ri.headers, 1);
+    }
+    static setProcessLabel(processLabel) {
+        ContextUtil.CURRENT_PROCESS_LABEL = processLabel;
+    }
+    static currentRequestId() {
+        const ctx = ContextUtil.CURRENT_CONTEXT;
+        return ctx ? ctx.awsRequestId : null;
+    }
+    static remainingTimeMS() {
+        const ctx = ContextUtil.CURRENT_CONTEXT;
+        return ctx ? ctx.getRemainingTimeInMillis() : null;
+    }
+    static currentProcessLabel() {
+        return ContextUtil.CURRENT_PROCESS_LABEL || 'unset';
+    }
+    static traceHeaderName() {
+        const headerName = ContextUtil?.CURRENT_EPSILON_REFERENCE?.config?.loggerConfig?.traceHeaderName || 'X-TRACE-ID';
+        return headerName;
+    }
+    static traceDepthHeaderName() {
+        const headerName = ContextUtil?.CURRENT_EPSILON_REFERENCE?.config?.loggerConfig?.traceDepthHeaderName || 'X-TRACE-DEPTH';
+        return headerName;
+    }
+    static currentTraceId() {
+        const traceFn = ContextUtil?.CURRENT_EPSILON_REFERENCE?.config?.loggerConfig?.traceIdGenerator || BuiltInTraceIdGenerators.fullAwsRequestId;
+        const traceId = ContextUtil.CURRENT_OVERRIDE_TRACE_ID ||
+            ContextUtil.CURRENT_EVENT?.headers?.[ContextUtil.traceHeaderName()] ||
+            traceFn(ContextUtil.CURRENT_EVENT, ContextUtil.CURRENT_CONTEXT);
+        return traceId;
+    }
+    static currentTraceDepth() {
+        const caller = ContextUtil.CURRENT_OVERRIDE_TRACE_DEPTH ||
+            NumberRatchet.safeNumber(ContextUtil.CURRENT_EVENT?.headers?.[ContextUtil.traceDepthHeaderName()]) ||
+            1;
+        return caller;
+    }
+    static addLogVariable(name, val) {
+        ContextUtil.CURRENT_LOG_VARS[name] = val;
+    }
+    static fetchLogVariable(name) {
+        return ContextUtil.CURRENT_LOG_VARS?.[name];
+    }
+    static fetchLogVariables() {
+        return Object.assign({}, ContextUtil.CURRENT_LOG_VARS || {});
+    }
+}
+ContextUtil.CURRENT_LOG_VARS = {};

package/dist/es/util/cron-util.js

@@ -0,0 +1,68 @@
+import { RequireRatchet } from '@bitblit/ratchet-common';
+import { ErrorRatchet } from '@bitblit/ratchet-common';
+import { DateTime } from 'luxon';
+import { StringRatchet } from '@bitblit/ratchet-common';
+export class CronUtil {
+    static everyNMinuteFilter(n) {
+        return CronUtil.everyNElementFilter(n, 60);
+    }
+    static everyNDaysOfYearFilter(n) {
+        return CronUtil.everyNElementFilter(n, 365);
+    }
+    static everyNElementFilter(n, m) {
+        RequireRatchet.notNullOrUndefined(n);
+        RequireRatchet.notNullOrUndefined(m);
+        const half = Math.floor(m / 2);
+        if (!n || n < 2 || n > half || m % n !== 0) {
+            ErrorRatchet.throwFormattedErr('Invalid config - this function only makes sense for 2 < N < %d and %d evenly divisible by N', half, m);
+            throw new Error('Invalid config - this function only makes sense for 2 < N < 31 and 60 evenly divisible by N');
+        }
+        const rval = [];
+        for (let i = 0; i < 60; i += n) {
+            rval.push(i);
+        }
+        return rval;
+    }
+    static numberMatchesFilter(num, filter) {
+        return !filter || filter.length === 0 || filter.includes(num);
+    }
+    static eventMatchesEntry(event, entry, cfg, testTimeEpochMS = new Date().getTime()) {
+        let rval = false;
+        if (!!event && !!entry && !!cfg.timezone) {
+            if (!!event.resources && event.resources.length > 0) {
+                const eventSourceName = event.resources[0];
+                const targetTZ = StringRatchet.trimToNull(entry.overrideTimezone) || cfg.timezone;
+                const nowInTZ = DateTime.fromMillis(testTimeEpochMS).setZone(targetTZ);
+                rval = !entry.eventFilter || entry.eventFilter.test(eventSourceName);
+                rval = rval && CronUtil.numberMatchesFilter(nowInTZ.minute, entry.minuteFilter);
+                rval = rval && CronUtil.numberMatchesFilter(nowInTZ.hour, entry.hourFilter);
+                rval = rval && CronUtil.numberMatchesFilter(nowInTZ.weekday, entry.dayOfWeekFilter);
+                rval = rval && CronUtil.numberMatchesFilter(nowInTZ.day, entry.dayOfMonthFilter);
+                rval = rval && CronUtil.numberMatchesFilter(nowInTZ.month, entry.monthOfYearFilter);
+                rval = rval && (!entry.contextMatchFilter || entry.contextMatchFilter.test(StringRatchet.trimToEmpty(cfg.context)));
+                rval = rval && (!entry.contextNoMatchFilter || !entry.contextNoMatchFilter.test(StringRatchet.trimToEmpty(cfg.context)));
+            }
+        }
+        return rval;
+    }
+    static cronEntryName(entry, idx = null) {
+        RequireRatchet.notNullOrUndefined(entry);
+        let rval = null;
+        if (!!entry) {
+            rval = entry.name;
+            rval = rval || entry['backgroundTaskType'];
+            if (!rval && !!entry['directHandler']) {
+                if (!!idx) {
+                    rval = 'Direct Entry ' + idx;
+                }
+                else {
+                    rval = 'Direct Entry (No idx specified)';
+                }
+            }
+        }
+        else {
+            rval = 'ERROR: no entry passed';
+        }
+        return rval;
+    }
+}