@asyncapi/cli 3.2.0 → 3.3.0

package/lib/domains/services/validation.service.js

@@ -0,0 +1,288 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationService = exports.ValidationStatus = void 0;
+const tslib_1 = require("tslib");
+const base_service_1 = require("./base.service");
+const avro_schema_parser_1 = require("@asyncapi/avro-schema-parser");
+const openapi_schema_parser_1 = require("@asyncapi/openapi-schema-parser");
+const cjs_1 = require("@asyncapi/parser/cjs");
+const raml_dt_schema_parser_1 = require("@asyncapi/raml-dt-schema-parser");
+const protobuf_schema_parser_1 = require("@asyncapi/protobuf-schema-parser");
+const spectral_core_1 = require("@stoplight/spectral-core");
+const spectral_formatters_1 = require("@stoplight/spectral-formatters");
+const chalk_1 = require("chalk");
+const fs_1 = require("fs");
+const path_1 = tslib_1.__importDefault(require("path"));
+const scoreCalculator_1 = require("../../utils/scoreCalculator");
+const { writeFile } = fs_1.promises;
+var ValidationStatus;
+(function (ValidationStatus) {
+    ValidationStatus["INVALID"] = "invalid";
+    ValidationStatus["VALID"] = "valid";
+})(ValidationStatus || (exports.ValidationStatus = ValidationStatus = {}));
+const formatExtensions = {
+    stylish: '.txt',
+    json: '.json',
+    junit: '.xml',
+    html: '.html',
+    text: '.txt',
+    teamcity: '.txt',
+    pretty: '.txt',
+};
+const validFormats = [
+    'stylish',
+    'json',
+    'junit',
+    'html',
+    'text',
+    'teamcity',
+    'pretty',
+];
+class ValidationService extends base_service_1.BaseService {
+    constructor(parserOptions = {}) {
+        var _a;
+        super();
+        this.parser = new cjs_1.Parser(Object.assign(Object.assign({}, parserOptions), { __unstable: Object.assign({ resolver: {
+                    cache: false,
+                } }, (_a = parserOptions.__unstable) === null || _a === void 0 ? void 0 : _a.resolver) }));
+        this.parser.registerSchemaParser((0, openapi_schema_parser_1.OpenAPISchemaParser)());
+        this.parser.registerSchemaParser((0, raml_dt_schema_parser_1.RamlDTSchemaParser)());
+        this.parser.registerSchemaParser((0, avro_schema_parser_1.AvroSchemaParser)());
+        this.parser.registerSchemaParser((0, protobuf_schema_parser_1.ProtoBuffSchemaParser)());
+    }
+    /**
+     * Determine validation status from diagnostics
+     */
+    determineDiagnosticsStatus(diagnostics, options) {
+        var _a;
+        const failSeverity = (_a = options['fail-severity']) !== null && _a !== void 0 ? _a : 'error';
+        const hasIssues = diagnostics.length > 0;
+        const isFailSeverity = hasIssues && this.hasFailSeverity(diagnostics, failSeverity);
+        return isFailSeverity ? ValidationStatus.INVALID : ValidationStatus.VALID;
+    }
+    /**
+     * Parses an AsyncAPI document and returns the parsed result
+     */
+    parseDocument(specFile_1, parseOptions_1) {
+        return tslib_1.__awaiter(this, arguments, void 0, function* (specFile, parseOptions, options = {}) {
+            try {
+                const { document, diagnostics } = yield this.parser.parse(specFile.text(), Object.assign({ source: specFile.getSource() }, parseOptions));
+                if (!document) {
+                    return this.createErrorResult('Failed to parse document');
+                }
+                const status = this.determineDiagnosticsStatus(diagnostics, options);
+                const result = {
+                    document,
+                    diagnostics,
+                    status: status,
+                };
+                return this.createSuccessResult(result);
+            }
+            catch (error) {
+                return this.handleServiceError(error);
+            }
+        });
+    }
+    /**
+     * Validates an AsyncAPI document
+     */
+    validateDocument(specFile_1) {
+        return tslib_1.__awaiter(this, arguments, void 0, function* (specFile, options = {}) {
+            var _a, _b;
+            try {
+                const suppressAllWarnings = (_a = options.suppressAllWarnings) !== null && _a !== void 0 ? _a : false;
+                const suppressedWarnings = (_b = options.suppressWarnings) !== null && _b !== void 0 ? _b : [];
+                let activeParser;
+                if (suppressAllWarnings || suppressedWarnings.length) {
+                    activeParser = yield this.buildAndRegisterCustomParser(specFile, suppressedWarnings, suppressAllWarnings);
+                }
+                else {
+                    activeParser = this.parser;
+                }
+                const { document, diagnostics } = yield activeParser.parse(specFile.text(), {
+                    source: specFile.getSource(),
+                });
+                const status = this.determineDiagnosticsStatus(diagnostics, options);
+                const result = {
+                    status: status,
+                    diagnostics,
+                    score: yield (0, scoreCalculator_1.calculateScore)(document),
+                    document: (document === null || document === void 0 ? void 0 : document.json) ? document.json() : undefined,
+                };
+                return this.createSuccessResult(result);
+            }
+            catch (error) {
+                return this.handleServiceError(error);
+            }
+        });
+    }
+    /**
+     * Helper to build and register a custom parser with suppressed rules
+     */
+    buildAndRegisterCustomParser(specFile, suppressedWarnings, suppressAllWarnings) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            // Helper to build a parser with given rules turned off
+            const buildCustomParser = (rulesToSuppress) => new cjs_1.Parser({
+                ruleset: {
+                    extends: [],
+                    rules: Object.fromEntries(rulesToSuppress.map((rule) => [rule, 'off'])),
+                },
+                __unstable: {
+                    resolver: {
+                        cache: false,
+                    },
+                },
+            });
+            let activeParser;
+            if (suppressAllWarnings || suppressedWarnings.length) {
+                if (suppressAllWarnings) {
+                    // Run the default parser to discover all rule codes
+                    const diagnostics = yield this.parser.validate(specFile.text(), {
+                        source: specFile.getSource(),
+                    });
+                    const allRuleNames = Array.from(new Set(diagnostics
+                        .map((d) => d.code)
+                        .filter((c) => typeof c === 'string')));
+                    activeParser = buildCustomParser(allRuleNames);
+                }
+                else {
+                    try {
+                        activeParser = buildCustomParser(suppressedWarnings);
+                    }
+                    catch (e) {
+                        const msg = e.message || '';
+                        const matches = [
+                            ...msg.matchAll(/Cannot extend non-existing rule: "([^"]+)"/g),
+                        ];
+                        const invalidRules = matches.map((m) => m[1]);
+                        if (invalidRules.length > 0) {
+                            const validRules = suppressedWarnings.filter((rule) => !invalidRules.includes(rule));
+                            activeParser = buildCustomParser(validRules);
+                        }
+                        else {
+                            throw e;
+                        }
+                    }
+                }
+                // Register schema parsers for active parser
+                activeParser.registerSchemaParser((0, avro_schema_parser_1.AvroSchemaParser)());
+                activeParser.registerSchemaParser((0, openapi_schema_parser_1.OpenAPISchemaParser)());
+                activeParser.registerSchemaParser((0, raml_dt_schema_parser_1.RamlDTSchemaParser)());
+                activeParser.registerSchemaParser((0, protobuf_schema_parser_1.ProtoBuffSchemaParser)());
+            }
+            else {
+                throw new Error('No rules to suppress provided');
+            }
+            return activeParser;
+        });
+    }
+    /**
+     * Save validation diagnostics to file
+     */
+    saveDiagnosticsToFile(outputPath, format, formatOutput) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!validFormats.includes(format)) {
+                    return this.createErrorResult(`Invalid diagnostics format: "${format}"`);
+                }
+                const expectedExtension = formatExtensions[format];
+                const actualExtension = path_1.default.extname(outputPath);
+                // Validate file extension against diagnostics format
+                if (expectedExtension && actualExtension !== expectedExtension) {
+                    return this.createErrorResult(`Invalid file extension for format "${format}". Expected extension: "${expectedExtension}"`);
+                }
+                yield writeFile(path_1.default.resolve(process.cwd(), outputPath), formatOutput, {
+                    encoding: 'utf-8',
+                });
+                return this.createSuccessResult(outputPath);
+            }
+            catch (error) {
+                return this.handleServiceError(error);
+            }
+        });
+    }
+    /**
+     * Generate governance message based on validation results
+     */
+    generateGovernanceMessage(sourceString, hasIssues, isFailSeverity) {
+        if (!hasIssues) {
+            return `\n${sourceString} is valid! ${sourceString} and referenced documents don't have governance issues.`;
+        }
+        if (isFailSeverity) {
+            return `\n${sourceString} and/or referenced documents have governance issues.`;
+        }
+        return `\n${sourceString} is valid but has (itself and/or referenced documents) governance issues.`;
+    }
+    /**
+     * Check if diagnostics contain failure severity issues
+     */
+    hasFailSeverity(diagnostics, failSeverity) {
+        const diagnosticSeverity = (0, spectral_core_1.getDiagnosticSeverity)(failSeverity);
+        return diagnostics.some((diagnostic) => diagnostic.severity <= diagnosticSeverity);
+    }
+    /**
+     * Format validation diagnostics output
+     */
+    formatDiagnosticsOutput(diagnostics, format = 'stylish', failSeverity = 'error') {
+        const diagnosticSeverity = (0, spectral_core_1.getDiagnosticSeverity)(failSeverity);
+        const options = {
+            failSeverity: diagnosticSeverity !== -1
+                ? diagnosticSeverity
+                : cjs_1.DiagnosticSeverity.Error,
+        };
+        switch (format) {
+            case 'stylish':
+                return this.formatStylish(diagnostics, options);
+            case 'json':
+                return (0, spectral_formatters_1.json)(diagnostics, options);
+            case 'junit':
+                return (0, spectral_formatters_1.junit)(diagnostics, options);
+            case 'html':
+                return (0, spectral_formatters_1.html)(diagnostics, options);
+            case 'text':
+                return (0, spectral_formatters_1.text)(diagnostics, options);
+            case 'teamcity':
+                return (0, spectral_formatters_1.teamcity)(diagnostics, options);
+            case 'pretty':
+                return (0, spectral_formatters_1.pretty)(diagnostics, options);
+            default:
+                return (0, spectral_formatters_1.stylish)(diagnostics, options);
+        }
+    }
+    /**
+     * Format diagnostics in stylish format with severity grouping
+     */
+    formatStylish(diagnostics, options) {
+        const groupedDiagnostics = diagnostics.reduce((acc, diagnostic) => {
+            const severity = diagnostic.severity;
+            if (!acc[severity]) {
+                acc[severity] = [];
+            }
+            acc[severity].push(diagnostic);
+            return acc;
+        }, {});
+        return Object.entries(groupedDiagnostics)
+            .map(([severity, diagnostics]) => {
+            return `${this.getSeverityTitle(Number(severity))} ${(0, spectral_formatters_1.stylish)(diagnostics, options)}`;
+        })
+            .join('\n');
+    }
+    /**
+     * Get colored severity title
+     */
+    getSeverityTitle(severity) {
+        switch (severity) {
+            case cjs_1.DiagnosticSeverity.Error:
+                return (0, chalk_1.red)('Errors');
+            case cjs_1.DiagnosticSeverity.Warning:
+                return (0, chalk_1.yellow)('Warnings');
+            case cjs_1.DiagnosticSeverity.Information:
+                return (0, chalk_1.cyan)('Information');
+            case cjs_1.DiagnosticSeverity.Hint:
+                return (0, chalk_1.green)('Hints');
+            default:
+                return 'Unknown';
+        }
+    }
+}
+exports.ValidationService = ValidationService;

package/lib/{core/errors → errors}/specification-file.js

@@ -38,7 +38,7 @@ class ErrorLoadingSpec extends Error {
     constructor(from, param) {
         super();
         this.errorMessages = {
-            default: context_error_1.NO_CONTEXTS_SAVED
+            default: context_error_1.NO_CONTEXTS_SAVED,
         };
         if (from === 'file') {
             this.name = 'error loading AsyncAPI document from file';

package/lib/{core/errors → errors}/validation-error.js

@@ -14,7 +14,8 @@ class ValidationError extends Error {
             this.message = `Syntax Error in "${error.filepath}".`;
         }
         if (error.type === 'no-spec-found') {
-            this.message = 'Unable to perform validation. Specify what AsyncAPI file should be validated.\n\nThese are your options to specify in the CLI what AsyncAPI file should be used:\n- You can provide a path to the AsyncAPI file: asyncapi validate path/to/file/asyncapi.yml\n- You can also pass a saved context that points to your AsyncAPI file: asyncapi validate mycontext\n- In case you did not specify a context that you want to use, the CLI checks if there is a default context and uses it. To set default context run: asyncapi context use mycontext\n- In case you did not provide any reference to AsyncAPI file and there is no default context, the CLI detects if in your current working directory you have files like asyncapi.json, asyncapi.yaml, asyncapi.yml. Just rename your file accordingly.';
+            this.message =
+                'Unable to perform validation. Specify what AsyncAPI file should be validated.\n\nThese are your options to specify in the CLI what AsyncAPI file should be used:\n- You can provide a path to the AsyncAPI file: asyncapi validate path/to/file/asyncapi.yml\n- You can also pass a saved context that points to your AsyncAPI file: asyncapi validate mycontext\n- In case you did not specify a context that you want to use, the CLI checks if there is a default context and uses it. To set default context run: asyncapi context use mycontext\n- In case you did not provide any reference to AsyncAPI file and there is no default context, the CLI detects if in your current working directory you have files like asyncapi.json, asyncapi.yaml, asyncapi.yml. Just rename your file accordingly.';
         }
         this.name = 'ValidationError';
     }
@@ -31,10 +32,10 @@ class ValidationError extends Error {
                 const errorHasTitle = !!e.title;
                 const errorHasLocation = !!e.location;
                 /*
-                * All the conditions below are needed since validationErrors (from ParserError) come from Parser JS library,
-                * so we cannot assure that all the fields or properties are always provided in the error. There might be cases
-                * that even title is not provided.
-                */
+                 * All the conditions below are needed since validationErrors (from ParserError) come from Parser JS library,
+                 * so we cannot assure that all the fields or properties are always provided in the error. There might be cases
+                 * that even title is not provided.
+                 */
                 if (errorHasTitle && errorHasLocation) {
                     errorsInfo.push(`${e.title} ${e.location.startLine}:${e.location.startColumn}`);
                     continue;

package/lib/interfaces/index.d.ts

@@ -0,0 +1,87 @@
+import { AsyncAPIDocumentInterface } from '@asyncapi/parser/cjs';
+import { OutputFormat } from '@stoplight/spectral-cli/dist/services/config';
+export type DiagnosticsFormat = 'stylish' | 'json' | 'junit' | 'html' | 'text' | 'teamcity' | 'pretty';
+export type SeverityKind = 'error' | 'warn' | 'info' | 'hint';
+export type Adapter = 'cli' | 'api';
+import specs from '@asyncapi/specs';
+import { Router } from 'express';
+import { AsyncAPIConvertVersion } from '@asyncapi/converter';
+export interface Controller {
+    basepath: string;
+    boot(): Router | Promise<Router>;
+}
+export interface Problem {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    [key: string]: any;
+}
+export type AsyncAPIDocument = {
+    asyncapi: string;
+} & Record<string, unknown>;
+export declare const ALL_SPECS: string[];
+export declare const LAST_SPEC_VERSION: string;
+export type SpecsEnum = keyof typeof specs | 'latest';
+export interface AsyncAPIServiceOptions {
+    source?: string;
+    path?: string;
+}
+export interface ServiceResult<T = any> {
+    success: boolean;
+    data?: T;
+    error?: string;
+    diagnostics?: any[];
+}
+export interface ParsedDocument {
+    document: AsyncAPIDocumentInterface;
+    diagnostics: any[];
+    status: 'valid' | 'invalid';
+}
+export interface ValidationOptions {
+    'log-diagnostics'?: boolean;
+    'diagnostics-format'?: `${OutputFormat}`;
+    'fail-severity'?: SeverityKind;
+    output?: string;
+    suppressWarnings?: string[];
+    suppressAllWarnings?: boolean;
+}
+export interface ValidationResult {
+    status: 'valid' | 'invalid';
+    document?: AsyncAPIDocument;
+    diagnostics?: any[];
+    score?: number;
+}
+export interface ConversionOptions {
+    format: 'asyncapi' | 'openapi' | 'postman-collection';
+    'target-version'?: AsyncAPIConvertVersion;
+    perspective?: 'client' | 'server';
+}
+export interface ConversionResult {
+    convertedDocument: string;
+    originalFormat: string;
+}
+export interface IMapBaseUrlToFlag {
+    url: string;
+    folder: string;
+}
+export interface GenerationOptions {
+    templateParams?: Record<string, any>;
+    forceWrite?: boolean;
+    install?: boolean;
+    debug?: boolean;
+    noOverwriteGlobs?: string[];
+    disabledHooks?: Record<string, string>;
+    mapBaseUrl?: IMapBaseUrlToFlag;
+    registry?: {
+        url?: string;
+        auth?: string;
+        token?: string;
+    };
+}
+export interface GenerationResult {
+    success: boolean;
+    outputPath: string;
+    logs?: string[];
+}

package/lib/interfaces/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LAST_SPEC_VERSION = exports.ALL_SPECS = void 0;
+const tslib_1 = require("tslib");
+const specs_1 = tslib_1.__importDefault(require("@asyncapi/specs"));
+exports.ALL_SPECS = [...Object.keys(specs_1.default)];
+exports.LAST_SPEC_VERSION = exports.ALL_SPECS[exports.ALL_SPECS.length - 1];

package/lib/utils/ajv.d.ts

@@ -0,0 +1,2 @@
+import type AjvCore from 'ajv/dist/core';
+export declare function createAjvInstance(): AjvCore;

package/lib/utils/ajv.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAjvInstance = createAjvInstance;
+const tslib_1 = require("tslib");
+const ajv_1 = tslib_1.__importDefault(require("ajv"));
+const ajv_formats_1 = tslib_1.__importDefault(require("ajv-formats"));
+function createAjvInstance() {
+    const ajv = new ajv_1.default({
+        allErrors: true,
+        meta: true,
+        strict: false,
+        allowUnionTypes: true,
+        logger: false,
+        unicodeRegExp: false,
+    });
+    (0, ajv_formats_1.default)(ajv);
+    return ajv;
+}

package/lib/utils/app-openapi.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Retrieve application's OpenAPI document.
+ */
+export declare function getAppOpenAPI(): Promise<any>;

package/lib/utils/app-openapi.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAppOpenAPI = getAppOpenAPI;
+const tslib_1 = require("tslib");
+const fs_1 = require("fs");
+const path_1 = tslib_1.__importDefault(require("path"));
+const js_yaml_1 = tslib_1.__importDefault(require("js-yaml"));
+const json_schema_ref_parser_1 = tslib_1.__importDefault(require("@apidevtools/json-schema-ref-parser"));
+let parsedOpenAPI = undefined;
+/**
+ * Retrieve application's OpenAPI document.
+ */
+function getAppOpenAPI() {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        if (parsedOpenAPI) {
+            return parsedOpenAPI;
+        }
+        const openaAPI = yield fs_1.promises.readFile(path_1.default.join(__dirname, '../../openapi.yaml'), 'utf-8');
+        parsedOpenAPI = js_yaml_1.default.load(openaAPI);
+        // due to the fact that `@asyncapi/specs: 3.0.0` have moved to a new way of bundling schemas, it makes no sense to resolve the references for AsyncAPI specs
+        parsedOpenAPI.components.schemas.AsyncAPIDocument.oneOf = {
+            type: ['string', 'object'],
+        };
+        const refParser = new json_schema_ref_parser_1.default();
+        yield refParser.dereference(parsedOpenAPI);
+        return parsedOpenAPI;
+    });
+}

package/lib/{core/utils/generator.js → utils/fileWatcher.js}

@@ -39,7 +39,10 @@ class Watcher {
      * @param {*} errorCallback Calback to call when it is no longer possible to watch a file.
      */
     initiateWatchOnPath(path, changeCallback, errorCallback) {
-        const watcher = chokidar_1.default.watch(path, { ignoreInitial: true, ignored: this.ignorePaths });
+        const watcher = chokidar_1.default.watch(path, {
+            ignoreInitial: true,
+            ignored: this.ignorePaths,
+        });
         watcher.on('all', (eventType, changedPath) => this.fileChanged(path, changedPath, eventType, changeCallback, errorCallback));
         this.watchers[String(path)] = watcher;
     }
@@ -67,7 +70,10 @@ class Watcher {
         try {
             if (fs.existsSync(listenerPath)) {
                 const newEventType = this.convertEventType(eventType);
-                this.filesChanged[String(changedPath)] = { eventType: newEventType, path: changedPath };
+                this.filesChanged[String(changedPath)] = {
+                    eventType: newEventType,
+                    path: changedPath,
+                };
                 // Since multiple changes can occur at the same time, lets wait a bit before processing.
                 if (this.fsWait) {
                     return;

package/lib/utils/logger.d.ts

@@ -0,0 +1,6 @@
+import winston from 'winston';
+declare const logger: winston.Logger;
+declare const stream: {
+    write: (message: string) => void;
+};
+export { logger, stream };

package/lib/utils/logger.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stream = exports.logger = void 0;
+const tslib_1 = require("tslib");
+const config_1 = tslib_1.__importDefault(require("config"));
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const winston_1 = tslib_1.__importDefault(require("winston"));
+const logDir = path_1.default.join(__dirname, config_1.default.get('log.dir'));
+if (!fs_1.default.existsSync(logDir)) {
+    fs_1.default.mkdirSync(logDir);
+}
+/*
+ * Log Level
+ * error: 0, warn: 1, info: 2, http: 3, verbose: 4, debug: 5, silly: 6
+ */
+const logger = winston_1.default.createLogger({
+    format: winston_1.default.format.combine(winston_1.default.format.timestamp({
+        format: 'YYYY-MM-DD HH:mm:ss',
+    }), 
+    // Define log format
+    winston_1.default.format.printf(({ timestamp, level, message }) => `${timestamp} ${level}: ${message}`)),
+});
+exports.logger = logger;
+logger.add(new winston_1.default.transports.Console({
+    format: winston_1.default.format.combine(winston_1.default.format.splat(), winston_1.default.format.colorize()),
+}));
+const stream = {
+    write: (message) => {
+        logger.info(message.substring(0, message.lastIndexOf('\n')));
+    },
+};
+exports.stream = stream;

package/lib/utils/retrieve-language.d.ts

@@ -0,0 +1 @@
+export declare function retrieveLangauge(content: string): 'json' | 'yaml';

package/lib/utils/retrieve-language.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.retrieveLangauge = retrieveLangauge;
+function retrieveLangauge(content) {
+    if (content.trim()[0] === '{') {
+        return 'json';
+    }
+    return 'yaml';
+}

package/lib/utils/temp-dir.d.ts

@@ -0,0 +1,2 @@
+export declare function createTempDirectory(): Promise<string>;
+export declare function removeTempDirectory(tmpDir: string): Promise<void>;

package/lib/utils/temp-dir.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTempDirectory = createTempDirectory;
+exports.removeTempDirectory = removeTempDirectory;
+const tslib_1 = require("tslib");
+const os_1 = tslib_1.__importDefault(require("os"));
+const fs_1 = tslib_1.__importStar(require("fs"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const uuid_1 = require("uuid");
+const logger_1 = require("./logger");
+function createTempDirectory() {
+    return fs_1.promises.mkdtemp(path_1.default.join(os_1.default.tmpdir(), (0, uuid_1.v4)()));
+}
+function removeTempDirectory(tmpDir) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        try {
+            tmpDir &&
+                fs_1.default.existsSync(tmpDir) &&
+                (yield fs_1.promises.rm(tmpDir, { recursive: true }));
+        }
+        catch (e) {
+            logger_1.logger.error(`An error has occurred while removing the temp folder at ${tmpDir}. Please remove it manually. Error: ${e}`);
+        }
+    });
+}