@teamscale/coverage-collector 0.0.1-beta.6 → 0.0.1-beta.60

package/dist/src/storage/DataStorage.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -18,10 +22,15 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DataStorage = exports.ProjectCoverage = void 0;
 const commons_1 = require("@cqse/commons");
 const fs = __importStar(require("fs"));
+const path_1 = __importDefault(require("path"));
+const dat = __importStar(require("date-and-time"));
 /**
  * The coverage information received for one particular project.
  */
@@ -77,6 +86,10 @@ class DataStorage {
      * @param logger - The logger to use.
      */
     constructor(logger) {
+        /**
+         * Date format for the timestamp appended to the coverage files
+         */
+        this.DATE_FORMAT = 'YYYY-MM-DD-HH-mm-ss.SSS';
         this.coverageByProject = new Map();
         this.logger = commons_1.Contract.requireDefined(logger);
         this.timesUnmappedCoverage = 0;
@@ -89,7 +102,7 @@ class DataStorage {
      * @param coveredOriginalLines - The lines covered in the file.
      */
     putCoverage(project, sourceFilePath, coveredOriginalLines) {
-        const uniformPath = this.normalizeSourceFileName(sourceFilePath);
+        const uniformPath = DataStorage.normalizeSourceFileName(sourceFilePath);
         let projectCoverage = this.coverageByProject.get(project);
         if (!projectCoverage) {
             projectCoverage = new ProjectCoverage(project);
@@ -104,7 +117,7 @@ class DataStorage {
      *
      * @param sourceFile - The file name to normalize, produced by the instrumenter.
      */
-    normalizeSourceFileName(sourceFile) {
+    static normalizeSourceFileName(sourceFile) {
         return (0, commons_1.removePrefix)('webpack:///', sourceFile.replace('\\', '/'));
     }
     /**
@@ -125,29 +138,55 @@ class DataStorage {
         return projectCoverage === null || projectCoverage === void 0 ? void 0 : projectCoverage.getCoverage();
     }
     /**
-     * {@inheritDoc IReadableStorage.writeToSimpleCoverageFile}
+     * @inheritDoc
      */
-    dumpToSimpleCoverageFile(filePath) {
-        const toSimpleCoverage = () => {
-            const result = [];
-            commons_1.Contract.require(this.getProjects().length < 2, 'Only one project supported to be handled in parallel.');
-            for (const project of this.getProjects()) {
-                const projectCoverage = this.getCoverageBySourceFile(project);
-                if (!projectCoverage) {
-                    return [0, ''];
-                }
-                for (const entry of projectCoverage) {
-                    result.push(this.normalizeSourceFileName(entry.sourceFile));
-                    for (const lineNo of entry.coveredLines) {
-                        result.push(String(lineNo));
-                    }
+    dumpToSimpleCoverageFile(coverageFolder, date) {
+        const [lines, content] = this.toSimpleCoverage();
+        const coverageFolderTrimmed = coverageFolder.trim();
+        const finalFilePath = this.initCoverageFile(coverageFolderTrimmed, date);
+        fs.writeFileSync(finalFilePath, content, { flag: 'w', encoding: 'utf8' });
+        this.resetCoverage();
+        return [finalFilePath, lines];
+    }
+    /**
+     * Set the collected coverage to 0 for all projects
+     * @private
+     */
+    resetCoverage() {
+        this.coverageByProject = new Map();
+    }
+    /**
+     * Appends the timestamp given with date to the coverageFolder (before the file ending if there is one)
+     * @param coverageFolder Path to the coverage file
+     * @param date Represents the timestamp to be appended with the format {@link DataStorage.DATE_FORMAT}
+     * @private
+     */
+    initCoverageFile(coverageFolder, date) {
+        if (!fs.existsSync(coverageFolder)) {
+            fs.mkdirSync(coverageFolder);
+        }
+        const formattedDate = dat.format(date, this.DATE_FORMAT);
+        return path_1.default.join(coverageFolder, `coverage-${formattedDate}.simple`);
+    }
+    /**
+     * Generate simple coverage format for the collected coverage
+     */
+    toSimpleCoverage() {
+        const result = [];
+        commons_1.Contract.require(this.getProjects().length < 2, 'Only one project supported to be handled in parallel.');
+        for (const project of this.getProjects()) {
+            const projectCoverage = this.getCoverageBySourceFile(project);
+            if (!projectCoverage) {
+                return [0, ''];
+            }
+            for (const entry of projectCoverage) {
+                result.push(DataStorage.normalizeSourceFileName(entry.sourceFile));
+                for (const lineNo of entry.coveredLines) {
+                    result.push(String(lineNo));
                 }
             }
-            return [result.length, result.join('\n')];
-        };
-        const [lines, content] = toSimpleCoverage();
-        fs.writeFileSync(filePath.trim(), content, { flag: 'w', encoding: 'utf8' });
-        return lines;
+        }
+        return [result.length, result.join('\n')];
     }
     /**
      * {@inheritDoc IReadableStorage.getProjects}
@@ -155,5 +194,11 @@ class DataStorage {
     getProjects() {
         return Array.from(this.coverageByProject.keys());
     }
+    /**
+     * {@inheritDoc IWritableStorage.discardCollectedCoverage}
+     */
+    discardCollectedCoverage() {
+        this.coverageByProject.clear();
+    }
 }
 exports.DataStorage = DataStorage;

package/dist/src/upload/ArtifactoryUpload.d.ts

@@ -0,0 +1,6 @@
+import { ConfigParameters } from '../utils/ConfigParameters';
+import Logger from 'bunyan';
+/**
+ * Uploads a coverage file to artifactory with the provided configuration.
+ */
+export declare function uploadToArtifactory(config: ConfigParameters, logger: Logger, coverageFile: string, lines: number): Promise<void>;

package/dist/src/upload/ArtifactoryUpload.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadToArtifactory = void 0;
+const CommonUpload_1 = require("./CommonUpload");
+const axios_1 = __importDefault(require("axios"));
+const ProxyUpload_1 = require("./ProxyUpload");
+/**
+ * Uploads a coverage file to artifactory with the provided configuration.
+ */
+async function uploadToArtifactory(config, logger, coverageFile, lines) {
+    if (!(config.artifactory_access_token || (config.artifactory_user && config.artifactory_password))) {
+        throw new CommonUpload_1.UploadError('API key or user name and password must be configured!');
+    }
+    if (lines === 0) {
+        return;
+    }
+    logger.info('Preparing upload to Artifactory');
+    const form = (0, CommonUpload_1.prepareFormData)(coverageFile);
+    await performArtifactoryUpload(config, form, logger);
+}
+exports.uploadToArtifactory = uploadToArtifactory;
+async function performArtifactoryUpload(config, form, logger) {
+    var _a;
+    if (!config.teamscale_commit) {
+        throw new CommonUpload_1.UploadError('The "--teamscale-commit" option must be set with a valid branch and timestamp.');
+    }
+    const branchAndTimestamp = config.teamscale_commit.split(':');
+    let url = `${(_a = config.artifactory_server_url) === null || _a === void 0 ? void 0 : _a.replace(/\/$/, '')}/uploads/${branchAndTimestamp[0]}/${branchAndTimestamp[1]}`;
+    if (config.teamscale_revision) {
+        url = url + `-${config.teamscale_revision}`;
+    }
+    url = url + `/${config.teamscale_partition}/simple`;
+    if (config.artifactory_path_suffix !== undefined) {
+        url = `${url}/${config.artifactory_path_suffix}`;
+    }
+    url = `${url}/report.simple`;
+    await (0, CommonUpload_1.performUpload)(url, form, prepareArtifactoryConfig(config, form), axios_1.default.put, logger);
+}
+function prepareArtifactoryConfig(config, form) {
+    var _a, _b;
+    const proxyConfig = (0, ProxyUpload_1.extractProxyOptions)(config);
+    if (config.artifactory_access_token) {
+        return {
+            headers: {
+                Accept: '*/*',
+                'X-JFrog-Art-Api': config.artifactory_access_token,
+                'Content-Type': `multipart/form-data; boundary=${form.getBoundary()}`
+            },
+            proxy: proxyConfig
+        };
+    }
+    return {
+        auth: {
+            username: (_a = config.artifactory_user) !== null && _a !== void 0 ? _a : 'no username provided',
+            password: (_b = config.artifactory_password) !== null && _b !== void 0 ? _b : 'no password provided'
+        },
+        headers: {
+            Accept: '*/*',
+            'Content-Type': `multipart/form-data; boundary=${form.getBoundary()}`
+        },
+        proxy: proxyConfig
+    };
+}

package/dist/src/upload/CommonUpload.d.ts

@@ -0,0 +1,16 @@
+import FormData from 'form-data';
+import Logger from 'bunyan';
+import { AxiosRequestConfig, AxiosResponse } from 'axios';
+/**
+ * Error that is thrown when the upload failed
+ */
+export declare class UploadError extends Error {
+}
+/**
+ * Prepares the form data from a given configuration file for the upload.
+ */
+export declare function prepareFormData(coverageFile: string): FormData;
+/**
+ * Uploads a coverage file with the provided configuration.
+ */
+export declare function performUpload(url: string, form: FormData, config: AxiosRequestConfig<FormData>, uploadFunction: <T = unknown, R = AxiosResponse<T>, D = FormData>(url: string, data?: D, config?: AxiosRequestConfig<D>) => Promise<R>, logger: Logger): Promise<void>;

package/dist/src/upload/CommonUpload.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.performUpload = exports.prepareFormData = exports.UploadError = void 0;
+const form_data_1 = __importDefault(require("form-data"));
+const fs_1 = __importDefault(require("fs"));
+const axios_1 = __importDefault(require("axios"));
+const util_1 = require("util");
+/**
+ * Error that is thrown when the upload failed
+ */
+class UploadError extends Error {
+}
+exports.UploadError = UploadError;
+/**
+ * Prepares the form data from a given configuration file for the upload.
+ */
+function prepareFormData(coverageFile) {
+    const form = new form_data_1.default();
+    form.append('report', fs_1.default.readFileSync(coverageFile), 'coverage.simple');
+    return form;
+}
+exports.prepareFormData = prepareFormData;
+/**
+ * Uploads a coverage file with the provided configuration.
+ */
+async function performUpload(url, form, config, uploadFunction, logger) {
+    try {
+        const response = await uploadFunction(url, form, config);
+        logger.info(`Upload finished with code ${response.status}.`);
+    }
+    catch (error) {
+        if (axios_1.default.isAxiosError(error)) {
+            if (error.response) {
+                const response = error.response;
+                if (response.status >= 400) {
+                    throw new UploadError(`Upload failed with code ${response.status}: ${response.statusText}. Response Data: ${response.data}`);
+                }
+                else {
+                    logger.info(`Upload with status code ${response.status} finished.`);
+                }
+            }
+            else if (error.request) {
+                throw new UploadError(`Upload request did not receive a response.`);
+            }
+            if (error.message) {
+                logger.debug(`Something went wrong when uploading data: ${error.message}. Details of the error: ${(0, util_1.inspect)(error)}`);
+                throw new UploadError(`Something went wrong when uploading data: ${error.message}`);
+            }
+        }
+        throw new UploadError(`Something went wrong when uploading data: ${(0, util_1.inspect)(error)}`);
+    }
+}
+exports.performUpload = performUpload;

package/dist/src/upload/ProxyUpload.d.ts

@@ -0,0 +1,6 @@
+import { ConfigParameters } from "../utils/ConfigParameters";
+import { AxiosProxyConfig } from "axios";
+/**
+ * Creates an AxiosProxyConfig object if proxy variables are provided.
+ */
+export declare function extractProxyOptions(config: ConfigParameters): AxiosProxyConfig | undefined;

package/dist/src/upload/ProxyUpload.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractProxyOptions = void 0;
+const url_1 = __importDefault(require("url"));
+/**
+ * Creates an AxiosProxyConfig object if proxy variables are provided.
+ */
+function extractProxyOptions(config) {
+    if (config.http_proxy) {
+        // Expected format: http://username:password@host:port/
+        // See https://nodejs.org/api/url.html#url-strings-and-url-objects for URL parsing
+        const proxyAddress = new url_1.default.URL(config.http_proxy);
+        const proxyConfig = {
+            protocol: proxyAddress.protocol.replace(':', ''),
+            host: proxyAddress.hostname,
+            port: +proxyAddress.port,
+        };
+        if (proxyAddress.username && proxyAddress.password) {
+            proxyConfig.auth = {
+                username: proxyAddress.username,
+                password: proxyAddress.password
+            };
+        }
+        return proxyConfig;
+    }
+}
+exports.extractProxyOptions = extractProxyOptions;

package/dist/src/upload/TeamscaleUpload.d.ts

@@ -0,0 +1,6 @@
+import { ConfigParameters } from '../utils/ConfigParameters';
+import Logger from 'bunyan';
+/**
+ * Uploads a coverage file to Teamscale with the provided configuration.
+ */
+export declare function uploadToTeamscale(config: ConfigParameters, logger: Logger, coverageFile: string, lines: number): Promise<void>;

package/dist/src/upload/TeamscaleUpload.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadToTeamscale = void 0;
+const QueryParameters_1 = __importDefault(require("../utils/QueryParameters"));
+const CommonUpload_1 = require("./CommonUpload");
+const axios_1 = __importDefault(require("axios"));
+const ProxyUpload_1 = require("./ProxyUpload");
+/**
+ * Uploads a coverage file to Teamscale with the provided configuration.
+ */
+async function uploadToTeamscale(config, logger, coverageFile, lines) {
+    if (!(config.teamscale_access_token && config.teamscale_user && config.teamscale_server_url)) {
+        throw new CommonUpload_1.UploadError('API key and user name must be configured!');
+    }
+    if (lines === 0) {
+        return;
+    }
+    logger.info('Preparing upload to Teamscale');
+    const form = (0, CommonUpload_1.prepareFormData)(coverageFile);
+    const queryParameters = prepareQueryParameters(config);
+    await performTeamscaleUpload(config, queryParameters, form, logger);
+}
+exports.uploadToTeamscale = uploadToTeamscale;
+async function performTeamscaleUpload(config, parameters, form, logger) {
+    var _a;
+    await (0, CommonUpload_1.performUpload)(`${(_a = config.teamscale_server_url) === null || _a === void 0 ? void 0 : _a.replace(/\/$/, '')}/api/projects/${config.teamscale_project}/external-analysis/session/auto-create/report?${parameters.toString()}`, form, prepareTeamscaleConfig(config, form), axios_1.default.post, logger);
+}
+function prepareQueryParameters(config) {
+    const parameters = new QueryParameters_1.default();
+    parameters.addIfDefined('format', 'SIMPLE');
+    parameters.addIfDefined('message', config.teamscale_message);
+    parameters.addIfDefined('repository', config.teamscale_repository);
+    parameters.addIfDefined('t', config.teamscale_commit);
+    parameters.addIfDefined('revision', config.teamscale_revision);
+    parameters.addIfDefined('partition', config.teamscale_partition);
+    return parameters;
+}
+function prepareTeamscaleConfig(config, form) {
+    var _a, _b;
+    return {
+        auth: {
+            username: (_a = config.teamscale_user) !== null && _a !== void 0 ? _a : 'no username provided',
+            password: (_b = config.teamscale_access_token) !== null && _b !== void 0 ? _b : 'no password provided'
+        },
+        headers: {
+            Accept: '*/*',
+            'Content-Type': `multipart/form-data; boundary=${form.getBoundary()}`
+        },
+        proxy: (0, ProxyUpload_1.extractProxyOptions)(config)
+    };
+}

package/dist/src/utils/ConfigParameters.d.ts

@@ -0,0 +1,36 @@
+import { ArgumentParser } from 'argparse';
+/**
+ * The command line parameters the profiler can be configured with.
+ *
+ * ATTENTION: We use snake_case here because ArgParse creates
+ * the parameters that way---as in Python from which ArgParse stems.
+ */
+export type ConfigParameters = {
+    dump_to_folder: string;
+    log_to_file: string;
+    keep_coverage_files: boolean;
+    log_level: string;
+    dump_after_mins: number;
+    port: number;
+    json_log: boolean;
+    teamscale_server_url?: string;
+    teamscale_access_token?: string;
+    teamscale_project?: string;
+    teamscale_user?: string;
+    teamscale_partition?: string;
+    teamscale_revision?: string;
+    teamscale_commit?: string;
+    teamscale_repository?: string;
+    teamscale_message?: string;
+    artifactory_server_url?: string;
+    artifactory_user?: string;
+    artifactory_password?: string;
+    artifactory_access_token?: string;
+    artifactory_path_suffix?: string;
+    enable_control_port?: number;
+    http_proxy?: string;
+};
+/**
+ * Construct the object for parsing the command line arguments.
+ */
+export declare function buildParameterParser(): ArgumentParser;

package/dist/src/utils/ConfigParameters.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildParameterParser = void 0;
+const argparse_1 = require("argparse");
+const package_json_1 = require("../../package.json");
+/**
+ * Construct the object for parsing the command line arguments.
+ */
+function buildParameterParser() {
+    var _a;
+    const parser = new argparse_1.ArgumentParser({
+        description: 'Collector of the Teamscale JavaScript Profiler. Collects coverage information from a' +
+            '(headless) Web browser that executes code instrumented with our instrumenter.'
+    });
+    parser.add_argument('-v', '--version', { action: 'version', version: package_json_1.version });
+    parser.add_argument('-p', '--port', { help: 'The port to receive coverage information on.', default: 54678 });
+    parser.add_argument('-f', '--dump-to-folder', {
+        help: 'Target folder for coverage files.',
+        default: 'coverage'
+    });
+    parser.add_argument('-k', '--keep-coverage-files', {
+        help: 'Whether to keep the coverage files on disk after a successful upload to Teamsacle',
+        action: 'store_true',
+        default: false
+    });
+    parser.add_argument('-l', '--log-to-file', { help: 'Log file', default: 'logs/collector-combined.log' });
+    parser.add_argument('-e', '--log-level', { help: 'Log level', default: 'info' });
+    parser.add_argument('-c', '--enable-control-port', {
+        help: 'Enables the remote control API on the specified port (<=0 means "disabled").',
+        default: 0
+    });
+    parser.add_argument('-t', '--dump-after-mins', {
+        help: 'Dump the coverage information to the target file every N minutes.',
+        default: 360
+    });
+    parser.add_argument('-d', '--debug', {
+        help: 'Print received coverage information to the terminal?',
+        default: false
+    });
+    parser.add_argument('-j', '--json-log', {
+        help: 'Additional JSON-like log file format.',
+        action: 'store_true'
+    });
+    // Parameters for the upload to Teamscale
+    parser.add_argument('-u', '--teamscale-server-url', {
+        help: 'Upload the coverage to the given Teamscale server URL, for example, https://teamscale.dev.example.com:8080/production.',
+        default: process.env.TEAMSCALE_SERVER_URL
+    });
+    parser.add_argument('--teamscale-access-token', {
+        help: 'The API key to use for uploading to Teamscale.',
+        default: process.env.TEAMSCALE_ACCESS_TOKEN
+    });
+    parser.add_argument('--teamscale-project', {
+        help: 'The project ID to upload coverage to.',
+        default: process.env.TEAMSCALE_PROJECT
+    });
+    parser.add_argument('--teamscale-user', {
+        help: 'The user for uploading coverage to Teamscale.',
+        default: process.env.TEAMSCALE_USER
+    });
+    parser.add_argument('--teamscale-partition', {
+        help: 'The partition to upload coverage to.',
+        default: process.env.TEAMSCALE_PARTITION
+    });
+    parser.add_argument('--teamscale-revision', {
+        help: 'The revision (commit hash, version id) to upload coverage for.',
+        default: process.env.TEAMSCALE_REVISION
+    });
+    parser.add_argument('--teamscale-commit', {
+        help: 'The branch and timestamp to upload coverage for, separated by colon.',
+        default: process.env.TEAMSCALE_COMMIT
+    });
+    parser.add_argument('--teamscale-repository', {
+        help: 'The repository to upload coverage for. Optional: Only needed when uploading via revision to a project that has more than one connector.',
+        default: process.env.TEAMSCALE_REPOSITORY
+    });
+    parser.add_argument('--teamscale-message', {
+        help: 'The commit message shown within Teamscale for the coverage upload. Default is "JavaScript coverage upload".',
+        default: (_a = process.env.TEAMSCALE_MESSAGE) !== null && _a !== void 0 ? _a : 'JavaScript coverage upload'
+    });
+    parser.add_argument('--artifactory-server-url', {
+        help: 'Upload the coverage to the given Artifactory server URL. The URL may include a subpath on the artifactory server, e.g. https://artifactory.acme.com/my-repo/my/subpath',
+        default: process.env.ARTIFACTORY_SERVER_URL
+    });
+    parser.add_argument('--artifactory-user', {
+        help: 'The user for uploading coverage to Artifactory. Only needed when not using the --artifactory-access-token option',
+        default: process.env.ARTIFACTORY_USER
+    });
+    parser.add_argument('--artifactory-password', {
+        help: 'The password for uploading coverage to Artifactory. Only needed when not using the --artifactory-access-token option',
+        default: process.env.ARTIFACTORY_PASSWORD
+    });
+    parser.add_argument('--artifactory-access-token', {
+        help: 'The access_token for uploading coverage to Artifactory.',
+        default: process.env.ARTIFACTORY_ACCESS_TOKEN
+    });
+    parser.add_argument('--artifactory-path-suffix', {
+        help: '(optional): The path within the storage location between the default path and the uploaded artifact.',
+        default: process.env.ARTIFACTORY_PATH_SUFFIX
+    });
+    parser.add_argument('--http-proxy', {
+        help: '(optional): The HTTP/HTTPS proxy address that should be used in the format: http://host:port/ or http://username:password@host:port/.',
+        default: process.env.HTTP_PROXY
+    });
+    return parser;
+}
+exports.buildParameterParser = buildParameterParser;

package/dist/src/utils/PrettyFileLogger.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import 'dotenv/config';
+import { WriteStream } from 'fs';
+/**
+ * Class for log4j-like logger. Stream output shows less information than the
+ * standard JSON format of the bunyan logger and therefore has better readability.
+ */
+export declare class PrettyFileLogger {
+    outputStream: WriteStream;
+    constructor(outputStream: WriteStream);
+    write(rec: any): void;
+    end(): void;
+}

package/dist/src/utils/PrettyFileLogger.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrettyFileLogger = void 0;
+const bunyan_1 = __importDefault(require("bunyan"));
+require("dotenv/config");
+/**
+ * Class for log4j-like logger. Stream output shows less information than the
+ * standard JSON format of the bunyan logger and therefore has better readability.
+ */
+class PrettyFileLogger {
+    constructor(outputStream) {
+        this.outputStream = outputStream;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    write(rec) {
+        this.outputStream.write(`[${rec.time.toISOString()}] ${bunyan_1.default.nameFromLevel[rec.level].toUpperCase()}: ${rec.msg}\n`);
+    }
+    end() {
+        this.outputStream.close();
+    }
+}
+exports.PrettyFileLogger = PrettyFileLogger;

package/dist/src/utils/QueryParameters.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Helper class for building HTTP query parameter strings.
+ */
+export default class QueryParameters extends URLSearchParams {
+    /**
+     * Adds a parameter if the value is defined.
+     */
+    addIfDefined(key: string, value: string | undefined): void;
+}

package/dist/src/utils/QueryParameters.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Helper class for building HTTP query parameter strings.
+ */
+class QueryParameters extends URLSearchParams {
+    /**
+     * Adds a parameter if the value is defined.
+     */
+    addIfDefined(key, value) {
+        if (value) {
+            this.append(key, value);
+        }
+        else {
+            this.delete(key);
+        }
+    }
+}
+exports.default = QueryParameters;

package/dist/src/utils/StdConsoleLogger.d.ts

@@ -0,0 +1,5 @@
+import 'dotenv/config';
+/** Class for console logger. Doesn't print all information to ensure better readability. */
+export declare class StdConsoleLogger {
+    write(rec: any): void;
+}

package/dist/src/utils/StdConsoleLogger.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StdConsoleLogger = void 0;
+const bunyan_1 = __importDefault(require("bunyan"));
+require("dotenv/config");
+/** Class for console logger. Doesn't print all information to ensure better readability. */
+class StdConsoleLogger {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    write(rec) {
+        console.log(`[${rec.time.toISOString()}] ${bunyan_1.default.nameFromLevel[rec.level].toUpperCase()}: ${rec.msg}`);
+    }
+}
+exports.StdConsoleLogger = StdConsoleLogger;