@rainbow-o23/n1 0.1.1

package/index.js

@@ -0,0 +1,732 @@
+import dayjs from 'dayjs';
+import ArraySupport from 'dayjs/plugin/arraySupport.js';
+import CustomParseFormat from 'dayjs/plugin/customParseFormat.js';
+import Duration from 'dayjs/plugin/duration.js';
+import IsToday from 'dayjs/plugin/isToday.js';
+import ObjectSupport from 'dayjs/plugin/objectSupport.js';
+import QuarterOfYear from 'dayjs/plugin/quarterOfYear.js';
+import RelativeTime from 'dayjs/plugin/relativeTime.js';
+import UTC from 'dayjs/plugin/utc.js';
+import WeekOfYear from 'dayjs/plugin/weekOfYear.js';
+import { customAlphabet, nanoid } from 'nanoid';
+
+const ERR_PIPELINE_NOT_FOUND = 'O01-00001';
+const ERR_TRIM_NON_STRING = 'O01-00002';
+const ERR_UNKNOWN = 'O01-99999';
+class CatchableError extends Error {
+    _code;
+    constructor(_code, message) {
+        super(message);
+        this._code = _code;
+    }
+    getCode() {
+        return this._code;
+    }
+}
+class UncatchableError extends Error {
+    _code;
+    constructor(_code, message) {
+        super(message);
+        this._code = _code;
+    }
+    getCode() {
+        return this._code;
+    }
+}
+class ExposedUncatchableError extends UncatchableError {
+    _status;
+    constructor(status, code, message) {
+        super(code, message);
+        this._status = status;
+    }
+    getStatus() {
+        return this._status;
+    }
+}
+
+const buildOutput = (message, ...optionalParams) => {
+    if (optionalParams == null || optionalParams.length === 0) {
+        return { message, optionalParams };
+    }
+    const key = optionalParams.pop();
+    if (typeof key === 'string') {
+        return { key, message, optionalParams };
+    }
+    else {
+        return { message, optionalParams: [...optionalParams, key] };
+    }
+};
+class EnhancedLogger {
+    static ENABLED_LEVELS = ['warn', 'error'];
+    static ENABLEMENTS = {};
+    _logger;
+    constructor(logger) {
+        this._logger = logger;
+    }
+    getInternalLogger() {
+        return this._logger;
+    }
+    static enableLevel(level) {
+        if (EnhancedLogger.ENABLED_LEVELS.includes(level)) ;
+        else {
+            const levels = ['debug', 'verbose', 'log', 'warn', 'error'];
+            const foundIndex = levels.indexOf(level);
+            EnhancedLogger.ENABLED_LEVELS = levels.filter((_level, index) => {
+                return index >= foundIndex;
+            });
+        }
+    }
+    static disableLevel(level) {
+        if (!EnhancedLogger.ENABLED_LEVELS.includes(level)) ;
+        else {
+            const levels = ['debug', 'verbose', 'log', 'warn', 'error'];
+            const foundIndex = levels.indexOf(level);
+            EnhancedLogger.ENABLED_LEVELS = levels.filter((_level, index) => {
+                return index > foundIndex;
+            });
+        }
+    }
+    static isLevelEnabled(level) {
+        return EnhancedLogger.ENABLED_LEVELS.includes(level);
+    }
+    static enable(name) {
+        if (['debug', 'verbose', 'log', 'warn', 'error'].some(level => name.endsWith(`.${level}`))) {
+            EnhancedLogger.ENABLEMENTS[name] = true;
+        }
+        else {
+            ['debug', 'verbose', 'log', 'warn', 'error'].forEach(level => {
+                EnhancedLogger.ENABLEMENTS[`${name}.${level}`] = true;
+            });
+        }
+    }
+    static disable(name) {
+        if (['debug', 'verbose', 'log', 'warn', 'error'].some(level => name.endsWith(`.${level}`))) {
+            EnhancedLogger.ENABLEMENTS[name] = false;
+        }
+        else {
+            ['debug', 'verbose', 'log', 'warn', 'error'].forEach(level => {
+                EnhancedLogger.ENABLEMENTS[`${name}.${level}`] = false;
+            });
+        }
+    }
+    static isEnabled(name) {
+        if (EnhancedLogger.ENABLEMENTS[name] === false) {
+            return false;
+        }
+        else if (EnhancedLogger.ENABLEMENTS[name] === true) {
+            return true;
+        }
+        else {
+            if (this.ENABLED_LEVELS.some(level => name.endsWith(`.${level}`))) {
+                return true;
+            }
+            else {
+                return false;
+            }
+        }
+    }
+    takeover(to) {
+        this._logger = to ?? console;
+    }
+    restore() {
+        this._logger = console;
+    }
+    debug(message, ...optionalParams) {
+        const { key } = buildOutput(message, ...optionalParams);
+        if (key != null && EnhancedLogger.isEnabled(`${key}.debug`)) {
+            return this._logger.debug(message, ...optionalParams);
+        }
+        else if (EnhancedLogger.isLevelEnabled('debug')) {
+            return this._logger.debug(message, ...optionalParams);
+        }
+    }
+    verbose(message, ...optionalParams) {
+        const { key } = buildOutput(message, ...optionalParams);
+        if (key != null && EnhancedLogger.isEnabled(`${key}.verbose`)) {
+            return this._logger.verbose(message, ...optionalParams);
+        }
+        else if (EnhancedLogger.isLevelEnabled('verbose')) {
+            return this._logger.verbose(message, ...optionalParams);
+        }
+    }
+    log(message, ...optionalParams) {
+        const { key } = buildOutput(message, ...optionalParams);
+        if (key != null && EnhancedLogger.isEnabled(`${key}.log`)) {
+            return this._logger.log(message, ...optionalParams);
+        }
+        else if (EnhancedLogger.isLevelEnabled('log')) {
+            return this._logger.log(message, ...optionalParams);
+        }
+    }
+    warn(message, ...optionalParams) {
+        const { key } = buildOutput(message, ...optionalParams);
+        if (key != null && EnhancedLogger.isEnabled(`${key}.warn`)) {
+            return this._logger.warn(message, ...optionalParams);
+        }
+        else if (EnhancedLogger.isLevelEnabled('warn')) {
+            return this._logger.warn(message, ...optionalParams);
+        }
+    }
+    error(message, ...optionalParams) {
+        const { key } = buildOutput(message, ...optionalParams);
+        if (key != null && EnhancedLogger.isEnabled(`${key}.error`)) {
+            return this._logger.error(message, ...optionalParams);
+        }
+        else if (EnhancedLogger.isLevelEnabled('error')) {
+            return this._logger.error(message, ...optionalParams);
+        }
+    }
+}
+class ConsoleLogger {
+    buildPrefix(level, message, ...optionalParams) {
+        const date = new Date();
+        const { key, message: msg, optionalParams: params } = buildOutput(message, ...optionalParams);
+        return [
+            `%c[${date.toLocaleDateString()} ${date.toLocaleTimeString()}] %c[${key ?? 'UNKNOWN CATEGORY'}] %c[${level.toUpperCase()}]`,
+            'color: #871094', 'color: #0033B3', 'color: #9E880D',
+            msg, ...params
+        ];
+    }
+    debug(message, ...optionalParams) {
+        return console.debug(...this.buildPrefix('debug', message, ...optionalParams));
+    }
+    verbose(message, ...optionalParams) {
+        return console.trace(...this.buildPrefix('verbose', message, ...optionalParams));
+    }
+    log(message, ...optionalParams) {
+        return console.log(...this.buildPrefix('log', message, ...optionalParams));
+    }
+    warn(message, ...optionalParams) {
+        return console.warn(...this.buildPrefix('warn', message, ...optionalParams));
+    }
+    error(message, ...optionalParams) {
+        return console.error(...this.buildPrefix('error', message, ...optionalParams));
+    }
+}
+const createLogger = (logger) => {
+    return new EnhancedLogger(logger ?? new ConsoleLogger());
+};
+class LoggerPerformanceSaver {
+    message;
+    constructor(message) {
+        this.message = message;
+    }
+    get [Symbol.toStringTag]() {
+        return this.message();
+    }
+}
+const saveLoggerPerformance = (message) => {
+    return new LoggerPerformanceSaver(message);
+};
+class LoggerUtils {
+    constructor() {
+    }
+    static stringifyObject(given) {
+        if (given instanceof Buffer) {
+            return '...Buffer (content ignored)';
+        }
+        else if (typeof given === 'object' && given.type === 'Buffer' && given.data != null && Array.isArray(given.data)) {
+            return '...Buffer (content ignored)';
+        }
+        return JSON.stringify(given, (_key, value) => {
+            if (value == null) {
+                return (void 0);
+            }
+            else if (value instanceof Buffer) {
+                return '...Buffer (content ignored)';
+            }
+            else if (typeof value === 'object' && value.type === 'Buffer' && value.data != null && Array.isArray(value.data)) {
+                return '...Buffer (content ignored)';
+            }
+            else {
+                return value;
+            }
+        });
+    }
+    static normalizeObject(given) {
+        if (given instanceof Buffer) {
+            return '...Buffer (content ignored)';
+        }
+        else if (typeof given === 'object' && given.type === 'Buffer' && given.data != null && Array.isArray(given.data)) {
+            return '...Buffer (content ignored)';
+        }
+        return Object.keys(given).reduce((normalized, key) => {
+            const value = given[key];
+            if (value == null) {
+                return (void 0);
+            }
+            else if (Array.isArray(value)) {
+                return value.map(LoggerUtils.normalizeObject);
+            }
+            else if (value instanceof Buffer) {
+                return '...Buffer (content ignored)';
+            }
+            else if (typeof value === 'object' && value.type === 'Buffer' && value.data != null && Array.isArray(value.data)) {
+                return '...Buffer (content ignored)';
+            }
+            else {
+                return value;
+            }
+        }, {});
+    }
+}
+
+const MISSED = Symbol();
+class Config {
+    _logger;
+    valueCache = {};
+    constructor(_logger) {
+        this._logger = _logger;
+    }
+    getLogger() {
+        return this._logger;
+    }
+    setLogger(value) {
+        this._logger = value;
+    }
+    generateKey(name) {
+        const key = name
+            .split('.')
+            .filter(s => s.trim().length !== 0)
+            .map(s => s.toUpperCase())
+            .join('_');
+        return `CFG_${key}`;
+    }
+    getFromCache(name, read, defaultValue) {
+        const cached = this.valueCache[name];
+        if (cached === MISSED) {
+            return defaultValue ?? (void 0);
+        }
+        else if (cached != null) {
+            return cached;
+        }
+        else {
+            const value = read();
+            this.valueCache[name] = value ?? MISSED;
+            return value ?? defaultValue ?? (void 0);
+        }
+    }
+    getString(name, defaultValue) {
+        return this.getFromCache(name, () => {
+            const value = process.env[this.generateKey(name)];
+            if (value == null || value.trim().length === 0) {
+                return (void 0);
+            }
+            else {
+                return value.trim();
+            }
+        }, defaultValue);
+    }
+    getBoolean(name, defaultValue) {
+        return this.getFromCache(name, () => {
+            const value = process.env[this.generateKey(name)];
+            if (value == null || value.trim().length === 0) {
+                return (void 0);
+            }
+            else if (['TRUE', 'YES', 'ON', '1'].includes(value.trim().toUpperCase())) {
+                return true;
+            }
+            else if (['FALSE', 'NO', 'OFF', '0'].includes(value.trim().toUpperCase())) {
+                return false;
+            }
+            else {
+                this._logger.warn(`Cannot parse given configuration item value[${value}] to boolean, ignored.`, Config.name);
+                return (void 0);
+            }
+        }, defaultValue);
+    }
+    getNumber(name, defaultValue) {
+        return this.getFromCache(name, () => {
+            const value = process.env[this.generateKey(name)];
+            if (value == null || value.trim().length === 0) {
+                return (void 0);
+            }
+            const v = Number(value);
+            if (isNaN(v)) {
+                this._logger.error(`Cannot parse given configuration item value[${value}] to number, ignored.`, Config.name);
+                return (void 0);
+            }
+            else {
+                return v;
+            }
+        }, defaultValue);
+    }
+    getJson(name, defaultValue) {
+        return this.getFromCache(name, () => {
+            const value = process.env[this.generateKey(name)];
+            if (value == null || value.trim().length === 0) {
+                return (void 0);
+            }
+            else {
+                try {
+                    return JSON.parse(value);
+                }
+                catch {
+                    this._logger.warn(`Cannot parse given configuration item value[${value}] to boolean, ignored.`, Config.name);
+                    return (void 0);
+                }
+            }
+        }, defaultValue);
+    }
+}
+const createConfig = (logger) => {
+    return new Config(logger ?? createLogger());
+};
+
+dayjs.extend(WeekOfYear);
+dayjs.extend(QuarterOfYear);
+dayjs.extend(Duration);
+dayjs.extend(IsToday);
+dayjs.extend(RelativeTime);
+dayjs.extend(ArraySupport);
+dayjs.extend(ObjectSupport);
+dayjs.extend(CustomParseFormat);
+dayjs.extend(UTC);
+
+const PIPELINE_STEP_FILE_SYMBOL = Symbol();
+const PIPELINE_STEP_RETURN_NULL = Symbol();
+class StepHelpersUtils {
+    static asciiNanoId = customAlphabet('1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_', 32);
+    static OBJECT_PROTOTYPE = Object.prototype;
+    constructor() {
+    }
+    static $nano(size) {
+        return nanoid(size);
+    }
+    static $ascii(size) {
+        return StepHelpersUtils.asciiNanoId(size);
+    }
+    static createCatchableError = (options) => {
+        throw new CatchableError(options.code, options.reason);
+    };
+    static createExposedUncatchableError = (options) => {
+        throw new ExposedUncatchableError(options.status, options.code, options.reason);
+    };
+    static createUncatchableError = (options) => {
+        throw new UncatchableError(options.code, options.reason);
+    };
+    static $errors = {
+        catchable: StepHelpersUtils.createCatchableError,
+        exposed: StepHelpersUtils.createExposedUncatchableError,
+        uncatchable: StepHelpersUtils.createUncatchableError
+    };
+    static createFile(options) {
+        return {
+            $file: PIPELINE_STEP_FILE_SYMBOL,
+            name: options.name, type: options.type,
+            content: typeof options.content === 'string' ? Buffer.from(options.content) : options.content
+        };
+    }
+    static $clearContextData() {
+        return PIPELINE_STEP_RETURN_NULL;
+    }
+    static isPrototype(value) {
+        const Ctor = value && value.constructor;
+        const proto = (typeof Ctor === 'function' && Ctor.prototype) || StepHelpersUtils.OBJECT_PROTOTYPE;
+        return value === proto;
+    }
+    static isLength(value) {
+        return typeof value === 'number' && value > -1 && value % 1 === 0 && value <= Number.MAX_SAFE_INTEGER;
+    }
+    static isArrayLike(value) {
+        return value != null && typeof value !== 'function' && StepHelpersUtils.isLength(value.length);
+    }
+    static isEmpty(value) {
+        if (value == null) {
+            return true;
+        }
+        if (StepHelpersUtils.isArrayLike(value) && (Array.isArray(value) || typeof value === 'string')) {
+            return value.length === 0;
+        }
+        else if (value instanceof Map) {
+            return value.size === 0;
+        }
+        else if (value instanceof Set) {
+            return value.size === 0;
+        }
+        else if (StepHelpersUtils.isPrototype(value)) {
+            return Object.keys(value).length === 0;
+        }
+        return false;
+    }
+    static isNotEmpty(value) {
+        return !StepHelpersUtils.isEmpty(value);
+    }
+    static isBlank(value) {
+        if (value == null) {
+            return true;
+        }
+        if (typeof value !== 'string') {
+            return false;
+        }
+        return value.trim().length === 0;
+    }
+    static isNotBlank(value) {
+        return !StepHelpersUtils.isBlank(value);
+    }
+    static trim(value) {
+        if (value == null) {
+            return '';
+        }
+        if (typeof value === 'string') {
+            return value.trim();
+        }
+        throw new UncatchableError(ERR_TRIM_NON_STRING, `Cannot apply trim to non-string object[type=${typeof value}, value=${value}].`);
+    }
+}
+
+class PerformanceExecution {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async execute(measured) {
+        try {
+            return await measured();
+        }
+        finally {
+            this.options.print(() => {
+                return {
+                    exec: this.options.exec, ptraceId: this.options.traceId,
+                    spent: Number((process.hrtime.bigint() - this.options.start) / 1000000n)
+                };
+            });
+        }
+    }
+}
+class AbstractPipelineExecution {
+    _config;
+    _logger;
+    _performanceLogEnabled;
+    _debugLogEnabled;
+    constructor(options) {
+        const { config, logger } = options ?? {};
+        this._logger = logger ?? createLogger();
+        this._config = config ?? createConfig(this._logger);
+        this._debugLogEnabled = this._config.getBoolean('pipeline.debug.log.enabled', false);
+        this._performanceLogEnabled = this._debugLogEnabled || this._config.getBoolean('pipeline.performance.log.enabled', false);
+    }
+    getConfig() {
+        return this._config;
+    }
+    getLogger() {
+        return this._logger;
+    }
+    isDebugLogEnabled() {
+        return this._debugLogEnabled;
+    }
+    debug(message, ...optionsParams) {
+        if (this.isDebugLogEnabled()) {
+            message = typeof message === 'function' ? message() : message;
+            message = Array.isArray(message) ? message : [message];
+            const [first, ...rest] = [...message, ...optionsParams.map(m => typeof m === 'function' ? m() : m)];
+            this.getLogger().debug(first ?? '', ...rest, this.constructor.name);
+        }
+    }
+    traceRequest(traceId, data) {
+        this.debug(() => ({ exec: 'PIPELINE', ptraceId: traceId, request: LoggerUtils.normalizeObject(data) }));
+        return data;
+    }
+    traceResponse(traceId, data) {
+        this.debug(() => ({ exec: 'PIPELINE', ptraceId: traceId, response: LoggerUtils.normalizeObject(data) }));
+        return data;
+    }
+    traceStepIn(traceId, step, data) {
+        this.debug(() => ({
+            exec: 'STEP', name: step.getName(), ptraceId: traceId, in: LoggerUtils.normalizeObject(data)
+        }));
+    }
+    traceStepOut(traceId, step, data) {
+        this.debug(() => ({
+            exec: 'STEP', name: step.getName(), ptraceId: traceId, out: LoggerUtils.normalizeObject(data)
+        }));
+    }
+    isPerformanceLogEnabled() {
+        return this._performanceLogEnabled;
+    }
+    debugPerformance(message) {
+        if (this.isPerformanceLogEnabled()) {
+            this.getLogger().debug(message(), this.constructor.name);
+        }
+    }
+    measurePerformance(traceId, exec) {
+        return new PerformanceExecution({
+            exec, traceId, start: process.hrtime.bigint(), print: (message) => this.debugPerformance(message)
+        });
+    }
+    returnOrContinueOrClear(request, response) {
+        if (response.content === PIPELINE_STEP_RETURN_NULL) {
+            return response;
+        }
+        else if (response.content == null) {
+            return request;
+        }
+        else {
+            return response;
+        }
+    }
+}
+
+class PipelineStepDateHelper {
+    _dateTimeFormat;
+    constructor(config) {
+        this._dateTimeFormat = config.getString('format.datetime', 'YYYY-MM-DD HH:mm:ss');
+    }
+    getDateTimeFormat() {
+        return this._dateTimeFormat;
+    }
+    now() {
+        return dayjs().format(this.getDateTimeFormat());
+    }
+    get dayjs() {
+        return dayjs;
+    }
+}
+const createStepHelpers = (config, logger) => {
+    return {
+        $config: config, $logger: logger,
+        $date: new PipelineStepDateHelper(config),
+        $nano: StepHelpersUtils.$nano, $ascii: StepHelpersUtils.$ascii,
+        $error: StepHelpersUtils.createExposedUncatchableError, $errors: StepHelpersUtils.$errors,
+        $file: StepHelpersUtils.createFile,
+        $clearContextData: StepHelpersUtils.$clearContextData,
+        isEmpty: StepHelpersUtils.isEmpty, isNotEmpty: StepHelpersUtils.isNotEmpty,
+        isBlank: StepHelpersUtils.isBlank, isNotBlank: StepHelpersUtils.isNotBlank,
+        trim: StepHelpersUtils.trim
+    };
+};
+
+class AbstractPipelineStep extends AbstractPipelineExecution {
+    _$helpers;
+    _name;
+    constructor(options) {
+        super(options);
+        this._name = options?.name;
+    }
+    getName() {
+        return (this._name == null || this._name.trim().length === 0) ? this.constructor.name : this._name;
+    }
+    getHelpers() {
+        if (this._$helpers == null) {
+            this._$helpers = createStepHelpers(this.getConfig(), this.getLogger());
+        }
+        return this._$helpers;
+    }
+    getHelpersVariableNames() {
+        return ['$helpers', '$'];
+    }
+}
+class DefaultPipelineStepBuilder {
+    step;
+    constructor(step) {
+        this.step = step;
+    }
+    async create(options) {
+        return new this.step(options);
+    }
+}
+
+class AbstractPipeline extends AbstractPipelineExecution {
+    constructor(options) {
+        super(options);
+    }
+    buildStepOptions() {
+        return { config: this._config, logger: this._logger };
+    }
+    async createSteps() {
+        const options = this.buildStepOptions();
+        return await Promise.all(this.getStepBuilders().map(async (builder) => await builder.create(options)));
+    }
+    convertRequestToPipelineData(request) {
+        return { content: request.payload };
+    }
+    convertPipelineDataToResponse(result) {
+        return { payload: result.content };
+    }
+    createTraceId(request) {
+        const { traceId } = request;
+        if (traceId == null || traceId.trim().length === 0) {
+            return nanoid(16);
+        }
+        else {
+            return traceId;
+        }
+    }
+    async perform(request) {
+        const traceId = this.createTraceId(request);
+        const response = await this.measurePerformance(traceId, 'PIPELINE')
+            .execute(async () => {
+            this.traceRequest(traceId, request);
+            const steps = await this.createSteps();
+            const data = await steps.reduce(async (promise, step) => {
+                const request = await promise;
+                return await this.measurePerformance(traceId, 'STEP')
+                    .execute(async () => {
+                    this.traceStepIn(traceId, step, request);
+                    const response = await step.perform({
+                        ...request, $context: { ...request.$context, traceId }
+                    });
+                    this.traceStepOut(traceId, step, response);
+                    return this.returnOrContinueOrClear(request, response);
+                });
+            }, Promise.resolve(this.convertRequestToPipelineData(request)));
+            return this.traceResponse(traceId, this.convertPipelineDataToResponse(data));
+        });
+        return response;
+    }
+}
+class AbstractStaticPipeline extends AbstractPipeline {
+    getStepBuilders() {
+        return this.getStepTypes().map(type => new DefaultPipelineStepBuilder(type));
+    }
+}
+class DefaultPipelineBuilder {
+    pipeline;
+    constructor(pipeline) {
+        this.pipeline = pipeline;
+    }
+    async create(options) {
+        return new this.pipeline(options);
+    }
+}
+
+class PipelineRepository {
+    static PIPELINE_BUILDERS = {};
+    static STEP_BUILDERS = {};
+    constructor() {
+    }
+    static async findPipeline(code, options) {
+        const builder = this.PIPELINE_BUILDERS[code];
+        if (builder == null) {
+            return (void 0);
+        }
+        else {
+            return await builder.create(options);
+        }
+    }
+    static putPipeline(builders) {
+        return Object.keys(builders).reduce((duplicated, code) => {
+            const existing = PipelineRepository.PIPELINE_BUILDERS[code];
+            PipelineRepository.PIPELINE_BUILDERS[code] = builders[code];
+            if (existing != null) {
+                duplicated[code] = existing;
+            }
+            return duplicated;
+        }, {});
+    }
+    static async findStep(code) {
+        return PipelineRepository.STEP_BUILDERS[code];
+    }
+    static putStep(builders) {
+        return Object.keys(builders).reduce((duplicated, code) => {
+            const existing = PipelineRepository.STEP_BUILDERS[code];
+            PipelineRepository.STEP_BUILDERS[code] = builders[code];
+            if (existing != null) {
+                duplicated[code] = existing;
+            }
+            return duplicated;
+        }, {});
+    }
+}
+
+export { AbstractPipeline, AbstractPipelineExecution, AbstractPipelineStep, AbstractStaticPipeline, CatchableError, Config, ConsoleLogger, DefaultPipelineBuilder, DefaultPipelineStepBuilder, ERR_PIPELINE_NOT_FOUND, ERR_TRIM_NON_STRING, ERR_UNKNOWN, EnhancedLogger, ExposedUncatchableError, LoggerPerformanceSaver, LoggerUtils, PIPELINE_STEP_FILE_SYMBOL, PIPELINE_STEP_RETURN_NULL, PerformanceExecution, PipelineRepository, PipelineStepDateHelper, StepHelpersUtils, UncatchableError, createConfig, createLogger, createStepHelpers, saveLoggerPerformance };