@eclipse-glsp/server 1.1.0-next.3d7585d.42

package/src/common/utils/registry.ts

@@ -0,0 +1,154 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 STMicroelectronics and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import { remove } from '@eclipse-glsp/protocol/lib/utils/array-util';
+import { injectable } from 'inversify';
+
+/**
+ * A registry manages a set of key-value pairs and provides query functionality. In GLSP this is typically used to
+ * provide a convenience API for working with multi-injected instances e.g. action handlers or
+ * operation handlers.
+ *
+ * @typeParam K Key type
+ * @param V Value type
+ */
+
+@injectable()
+export class Registry<K, V> {
+    protected elements: Map<K, V> = new Map();
+    /**
+     * Registers a new key-value pair.
+     *
+     * @param key     The key object.
+     * @param element The value object.
+     * @returns `true` if the pair was registered successfully, `false` if another pair with the same key is already
+     *         registered.
+     */
+    register(key: K, instance: V): boolean {
+        if (!this.hasKey(key)) {
+            this.elements.set(key, instance);
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Removes the value with the given key from the registry.
+     *
+     * @param key The key of the value which should be removed.
+     * @returns `true` if the value was removed successfully, `false` if no value was registered for the given key.
+     */
+    deregister(key: K): boolean {
+        return this.elements.delete(key);
+    }
+
+    /**
+     * Queries the registry to check whether a value for the given key is registered.
+     *
+     * @param key The key which should be checked.
+     * @returns `true` if a key-value pair is registered for the given key, `false` otherwise.
+     */
+    hasKey(key: K): boolean {
+        return this.elements.has(key);
+    }
+
+    /**
+     * Retrieve the value for the given key.
+     *
+     * @param key The key whose value should be retrieved.
+     * @returns The registered value or `undefined`. Is `undefined` if no value was registered for the given key.
+     */
+    get(key: K): V | undefined {
+        return this.elements.get(key);
+    }
+
+    /**
+     * Retrieve all registered values from the registry.
+     *
+     * @returns An array of all registered keys.
+     */
+
+    getAll(): V[] {
+        return [...new Set(this.elements.values())];
+    }
+
+    /**
+     * Retrieve all registered keys from the registry.
+     *
+     * @returns An array of all registered keys.
+     */
+    keys(): K[] {
+        return [...new Set(this.elements.keys())];
+    }
+}
+
+/**
+ * A multi registry is used to manage a set of key-value pairs. The main difference to {@link Registry} is that
+ * a multi registry doesn't enforce a 1-1 relation between key and value(s).
+ * One key can be associated with multiple values.
+ *
+ *
+ * @typeParam K  Type of the key
+ * @param V Type of the values
+ */
+@injectable()
+export class MultiRegistry<K, V> {
+    protected elements: Map<K, V[]> = new Map();
+
+    register(key: K, instance: V): void {
+        const instances = this.elements.get(key);
+        if (instances) {
+            instances.push(instance);
+        } else {
+            this.elements.set(key, [instance]);
+        }
+    }
+
+    deregister(key: K, element: V): boolean {
+        const instances = this.elements.get(key);
+        if (instances) {
+            remove(instances, element);
+            return true;
+        }
+        return false;
+    }
+
+    deregisterAll(key: K): boolean {
+        return this.elements.delete(key);
+    }
+
+    get(key: K): V[] {
+        const existingInstances = this.elements.get(key);
+        if (existingInstances) {
+            return [...new Set(existingInstances)];
+        } else {
+            return [];
+        }
+    }
+
+    hasKey(key: K): boolean {
+        return this.elements.has(key);
+    }
+
+    getAll(): V[] {
+        const values: V[] = [];
+        Array.from(this.elements.values()).forEach(instances => values.push(...instances));
+        return [...new Set(values)];
+    }
+
+    keys(): K[] {
+        return [...new Set(this.elements.keys())];
+    }
+}

package/src/node/abstract-json-model-storage.ts

@@ -0,0 +1,114 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import { MaybePromise, RequestModelAction, SaveModelAction, TypeGuard } from '@eclipse-glsp/protocol';
+import * as fs from 'fs-extra';
+import { inject, injectable } from 'inversify';
+import { fileURLToPath } from 'url';
+import { ModelState, SOURCE_URI_ARG } from '../common/features/model/model-state';
+import { SourceModelStorage } from '../common/features/model/source-model-storage';
+import { GLSPServerError } from '../common/utils/glsp-server-error';
+
+/**
+ * An abstract implementation of {@link SourceModelStorage} that provides utility methods for loading and saving JSON source models
+ * from/into a file.
+ */
+@injectable()
+export abstract class AbstractJsonModelStorage implements SourceModelStorage {
+    @inject(ModelState)
+    protected modelState: ModelState;
+
+    abstract loadSourceModel(action: RequestModelAction): MaybePromise<void>;
+
+    abstract saveSourceModel(action: SaveModelAction): MaybePromise<void>;
+
+    protected getSourceUri(action: RequestModelAction): string {
+        const sourceUri = action.options?.[SOURCE_URI_ARG];
+        if (typeof sourceUri !== 'string') {
+            throw new GLSPServerError(`Invalid RequestModelAction! Missing argument with key '${SOURCE_URI_ARG}'`);
+        }
+        return sourceUri;
+    }
+
+    protected loadFromFile(sourceUri: string): unknown;
+    protected loadFromFile<T>(sourceUri: string, guard: TypeGuard<T>): T;
+    protected loadFromFile<T>(sourceUri: string, guard?: TypeGuard<T>): T | unknown {
+        try {
+            const path = this.toPath(sourceUri);
+            let fileContent = this.readFile(path);
+            if (!fileContent) {
+                fileContent = this.createModelForEmptyFile(path);
+                if (!fileContent) {
+                    throw new GLSPServerError(`Could not load the source model. The file '${path}' is empty!.`);
+                }
+            }
+            if (guard && !guard(fileContent)) {
+                throw new Error('The loaded root object is not of the expected type!');
+            }
+            return fileContent;
+        } catch (error) {
+            throw new GLSPServerError(`Could not load model from file: ${sourceUri}`, error);
+        }
+    }
+
+    /**
+     * Can be overwritten to customize the behavior if the given file path points to an empty file.
+     * The default implementation returns undefined, concrete subclasses can customize this behavior and
+     * return new source model object instead.
+     * @param path The path of the empty file.
+     * @returns The new model or `undefined`
+     */
+    protected createModelForEmptyFile(path: string): unknown | undefined {
+        return undefined;
+    }
+
+    protected readFile(path: string): unknown | undefined {
+        try {
+            const data = fs.readFileSync(path, { encoding: 'utf8' });
+            if (!data || data.length === 0) {
+                return undefined;
+            }
+            return this.toJson(data);
+        } catch (error) {
+            throw new GLSPServerError(`Could not read & parse file contents of '${path}' as json`, error);
+        }
+    }
+
+    protected toJson(fileContent: string): unknown {
+        return JSON.parse(fileContent);
+    }
+
+    protected toPath(sourceUri: string): string {
+        return sourceUri.startsWith('file://') ? fileURLToPath(sourceUri) : sourceUri;
+    }
+
+    protected getFileUri(action: SaveModelAction): string {
+        const uri = action.fileUri ?? this.modelState.get(SOURCE_URI_ARG);
+        if (!uri) {
+            throw new GLSPServerError('Could not derive fileUri for saving the current source model');
+        }
+        return uri;
+    }
+
+    protected writeFile(fileUri: string, model: unknown): void {
+        const path = this.toPath(fileUri);
+        const content = this.toString(model);
+        fs.writeFileSync(path, content);
+    }
+
+    protected toString(model: unknown): string {
+        return JSON.stringify(model, undefined, 2);
+    }
+}

package/src/node/di/app-module.ts

@@ -0,0 +1,102 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 STMicroelectronics and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import { ContainerModule, interfaces } from 'inversify';
+import * as winston from 'winston';
+import { InjectionContainer, Logger, LoggerFactory, LogLevel, ModuleContext } from '../../common/index';
+import { LaunchOptions } from '../launch/cli-parser';
+import { WinstonLogger } from './winston-logger';
+
+export function createAppModule(options: LaunchOptions): ContainerModule {
+    return new ContainerModule((bind, unbind, isBound, rebind) => {
+        bind(InjectionContainer).toDynamicValue(dynamicContext => dynamicContext.container);
+        const context = { bind, unbind, isBound, rebind };
+        configureWinstonLogger(context, options);
+    });
+}
+
+/**
+ * Creates the global {@link winston.Logger} instance is used internally by all instances of {@link WinstonLogger}. Can be configured with
+ * the given {@link LaunchOptions}.
+ * @param options The {@link LaunchOptions}
+ * @returns the configured winston instance.
+ */
+export function createWinstonInstance<T extends LaunchOptions>(options: T): winston.Logger {
+    const level = LogLevel[options.logLevel];
+    const transports: winston.transport[] = [];
+
+    const printf = winston.format.printf(({ level, message, timestamp }) => `${timestamp} ${level} -  ${message}`);
+    const timestamp = winston.format.timestamp({ format: () => new Date().toLocaleTimeString() });
+
+    const consoleLogFormat = winston.format.combine(winston.format.colorize(), timestamp, printf);
+    const fileLogFormat = winston.format.combine(timestamp, printf);
+
+    if (options.consoleLog) {
+        transports.push(new winston.transports.Console({ format: consoleLogFormat }));
+    }
+
+    if (options.fileLog) {
+        const date = new Date();
+        const dateString = `${date.getDate()}-${
+            date.getMonth() + 1
+        }-${date.getFullYear()}_${date.getHours()}-${date.getMinutes()}-${date.getSeconds()}`;
+
+        const filename = `GLSP-Server_${dateString}.log`;
+        transports.push(new winston.transports.File({ dirname: options.logDir, filename, format: fileLogFormat }));
+    }
+
+    return winston.createLogger({ level, transports });
+}
+
+/**
+ * Configures the binding for {@link WinstonLogger} in the given {@link ModuleContext} with the given {@link LaunchOptions}.
+ * @param context The module context.
+ * @param options The launch options.
+ * @param rebind Flag to determine wether an existing {@link Logger} binding in the context should be rebound. Default is `true`.
+ * @param baseLoggerCreator The underling global {@link winston.Logger} instance.
+ */
+export function configureWinstonLogger<T extends LaunchOptions>(
+    context: ModuleContext,
+    options: T,
+    rebind = true,
+    baseLoggerCreator: (launchOptions: T) => winston.Logger = createWinstonInstance
+): void {
+    const baseLogger = baseLoggerCreator(options);
+    if (rebind) {
+        if (context.isBound(Logger)) {
+            context.unbind(Logger);
+        }
+        if (context.isBound(LoggerFactory)) {
+            context.unbind(LoggerFactory);
+        }
+    }
+
+    context.bind(Logger).toDynamicValue(dynamicContext => new WinstonLogger(baseLogger, getRequestParentName(dynamicContext)));
+    context.bind(LoggerFactory).toFactory(dynamicContext => (caller: string) => {
+        const logger = dynamicContext.container.get(Logger);
+        logger.caller = caller;
+        return logger;
+    });
+}
+
+function getRequestParentName(context: interfaces.Context): string | undefined {
+    if (context.currentRequest.parentRequest) {
+        const bindings = context.currentRequest.parentRequest.bindings;
+        if (bindings.length > 0) {
+            return bindings[0].implementationType?.name;
+        }
+    }
+    return undefined;
+}

package/src/node/di/winston-logger.ts

@@ -0,0 +1,76 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 STMicroelectronics and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import * as winston from 'winston';
+import { asLogLevel, Logger, LogLevel } from '../../common/utils/logger';
+
+export class WinstonLogger extends Logger {
+    constructor(protected baseLogger: winston.Logger, public caller?: string) {
+        super();
+    }
+
+    info(message: string, ...params: any): void {
+        if (this.logLevel !== LogLevel.none) {
+            this.baseLogger.info(this.combinedMessage(message, ...params));
+        }
+    }
+
+    warn(message: string, ...params: any[]): void {
+        if (this.logLevel !== LogLevel.none) {
+            this.baseLogger.warn(this.combinedMessage(message, ...params));
+        }
+    }
+
+    error(message: string, ...params: any[]): void {
+        if (this.logLevel !== LogLevel.none) {
+            this.baseLogger.error(this.combinedMessage(message, ...params));
+        }
+    }
+
+    debug(message: string, ...params: any[]): void {
+        if (this.logLevel !== LogLevel.none) {
+            this.baseLogger.debug(this.combinedMessage(message, ...params));
+        }
+    }
+
+    get logLevel(): LogLevel {
+        return asLogLevel(this.baseLogger.level) || LogLevel.none;
+    }
+
+    set logLevel(level: LogLevel) {
+        this.baseLogger.level = LogLevel[level];
+    }
+
+    combinedMessage(message: string, ...params: any[]): string {
+        const caller = this.caller ? `[${this.caller}]` : '';
+        const additional = this.logAdditionals(...params);
+        return `${caller} ${message} ${additional}`;
+    }
+
+    logAdditionals(...params: any[]): string {
+        if (!params || params.length === 0) {
+            return '';
+        }
+        return params.map(param => this.toString(param)).join(',\n');
+    }
+
+    override toString(param: unknown): string {
+        if (param instanceof Error) {
+            return `${param.message}
+            ${param.stack || ''}`;
+        }
+        return JSON.stringify(param, undefined, 4);
+    }
+}

package/src/node/gmodel/gmodel-storage.ts

@@ -0,0 +1,53 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 STMicroelectronics and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import { GGraph, GModelElementSchema } from '@eclipse-glsp/graph';
+import { MaybePromise, RequestModelAction, SaveModelAction } from '@eclipse-glsp/protocol';
+import { inject, injectable } from 'inversify';
+import { GModelSerializer } from '../../common/features/model/gmodel-serializer';
+import { ModelState } from '../../common/features/model/model-state';
+import { Logger } from '../../common/utils/logger';
+import { AbstractJsonModelStorage } from '../abstract-json-model-storage';
+
+export const EMPTY_ROOT = GGraph.builder().id('empty').build();
+
+/**
+ * A {@link SourceModelStorage} that reads and writes the graph model directly from / into
+ * a JSON file and uses it as source model.
+ */
+@injectable()
+export class GModelStorage extends AbstractJsonModelStorage {
+    @inject(Logger)
+    protected logger: Logger;
+
+    @inject(GModelSerializer)
+    protected modelSerializer: GModelSerializer;
+
+    @inject(ModelState)
+    protected override modelState: ModelState;
+
+    loadSourceModel(action: RequestModelAction): MaybePromise<void> {
+        const sourceUri = this.getSourceUri(action);
+        const rootSchema = this.loadFromFile(sourceUri, GModelElementSchema.is);
+        const root = this.modelSerializer.createRoot(rootSchema);
+        this.modelState.updateRoot(root);
+    }
+
+    saveSourceModel(action: SaveModelAction): MaybePromise<void> {
+        const fileUri = this.getFileUri(action);
+        const schema = this.modelSerializer.createSchema(this.modelState.root);
+        this.writeFile(fileUri, schema);
+    }
+}

package/src/node/index.ts

@@ -0,0 +1,23 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+export * from '../common/index';
+export * from './abstract-json-model-storage';
+export * from './di/app-module';
+export * from './di/winston-logger';
+export * from './gmodel/gmodel-storage';
+export * from './launch/cli-parser';
+export * from './launch/socket-cli-parser';
+export * from './launch/socket-server-launcher';

package/src/node/launch/cli-parser.spec.ts

@@ -0,0 +1,61 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 STMicroelectronics and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import { expect } from 'chai';
+import * as path from 'path';
+import { LogLevel } from '../../common/utils/logger';
+import { createCliParser, defaultLaunchOptions } from './cli-parser';
+
+describe('test createCliParser', () => {
+    const parser = createCliParser();
+
+    parser.command.exitOverride();
+    const argv = ['/usr/bin/node', 'test'];
+
+    it('parse - no args', () => {
+        const options = parser.parse(argv);
+        expect(options).to.deep.equal(defaultLaunchOptions);
+    });
+
+    it('parse - invalid log dir', () => {
+        expect(() => parser.parse([...argv, '--logDir', 'invalid.Path'])).to.throw();
+    });
+
+    it('parse - valid log dir', () => {
+        const logDir = path.resolve('../customLog');
+        const result = parser.parse([...argv, '--logDir', '../customLog/']);
+        expect(result.logDir, logDir);
+    });
+
+    it('parse - invalid logLevel', () => {
+        expect(() => parser.parse([...argv, '--logLevel', 'someRandomLevel'])).to.throw();
+    });
+
+    it('parse - valid logLevel', () => {
+        const result = parser.parse([...argv, '--logLevel', 'error']);
+        expect(result.logLevel).to.be.equal(LogLevel.error);
+    });
+
+    it('parse- no args with custom default options', () => {
+        const options = {
+            logDir: '.myLogDir',
+            logLevel: LogLevel.debug,
+            consoleLog: false,
+            fileLog: true
+        };
+        const result = createCliParser(options).parse(argv);
+        expect(result).to.deep.equal(options);
+    });
+});

package/src/node/launch/cli-parser.ts

@@ -0,0 +1,86 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 STMicroelectronics and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import * as cmd from 'commander';
+import * as fs from 'fs-extra';
+import * as path from 'path';
+import { asLogLevel, LogLevel } from '../../common/utils/logger';
+
+export interface LaunchOptions {
+    logLevel: LogLevel;
+    logDir?: string;
+    fileLog: boolean;
+    consoleLog: boolean;
+}
+
+export interface CliParser<O extends LaunchOptions = LaunchOptions> {
+    command: cmd.Command;
+    parse(argv?: string[]): O;
+}
+
+export const defaultLaunchOptions: Required<LaunchOptions> = {
+    logLevel: LogLevel.info,
+    logDir: '.config',
+    consoleLog: true,
+    fileLog: false
+};
+
+export function createCliParser<O extends LaunchOptions = LaunchOptions>(options: LaunchOptions = defaultLaunchOptions): CliParser<O> {
+    const command = new cmd.Command()
+        .version('1.0.0')
+        .description('GLSP server')
+        .showHelpAfterError(true)
+        .name('Launch a GLSP server')
+        .option('-l , --logLevel <logLevel>', `Set the log level. [default='${options.logLevel}']`, processLogLevel, options.logLevel)
+        .option(
+            '-d , --logDir <logDir>',
+            `Set the directory for log files (when file logging is enabled) [default=${options.logDir}]`,
+            processLogDir,
+            options.logDir
+        )
+        .addHelpText('afterAll', '\n Copyright (c) 2022-2023 Eclipse GLSP');
+
+    return { command, parse: argv => parse<O>(command, options as Partial<O>, argv) };
+}
+
+export function parse<T extends cmd.OptionValues>(command: cmd.Command, defaultOptions: Partial<T>, argv?: string[]): T {
+    command.parse(argv);
+    return { ...defaultOptions, ...command.opts<T>() };
+}
+
+export function processLogLevel(value: string): LogLevel {
+    const level = asLogLevel(value);
+    if (!level) {
+        throw new cmd.InvalidArgumentError("Argument has to be 'none'|'error'|'warn'|'info'|'debug'!");
+    }
+    return level;
+}
+
+export function processLogDir(value: string): string {
+    const logDir = path.resolve(value);
+    if (path.extname(logDir).length !== 0 || !isDirectory(path.dirname(logDir))) {
+        throw new cmd.InvalidArgumentError('Argument is not a valid directory!');
+    }
+
+    return logDir;
+}
+
+export function isDirectory(value: string): boolean {
+    try {
+        return fs.statSync(value).isDirectory();
+    } catch (error) {
+        return false;
+    }
+}