@adminide-stack/extension-api 0.0.2-alpha.0

package/LICENSE

@@ -0,0 +1,39 @@
+The CDEBase Enterprise license (the “Enterprise License”)
+Copyright (c) 2018 cdebase LLC.
+
+With regard to the CDEBase Software:
+
+This software and associated documentation files (the "Software") may only be
+used in production, if you (and any entity that you represent) have agreed to,
+and are in compliance with, the CDEBase Terms of Service, available
+at https://about.cdebase.com/terms (the “Enterprise Terms”), or other
+agreement governing the use of the Software, as agreed by you and CDEBase,
+and otherwise have a valid CDEBase Enterprise subscription for the
+correct number of user seats. Subject to the foregoing sentence, you are free to
+modify this Software and publish patches to the Software. You agree that CDEBase
+and/or its licensors (as applicable) retain all right, title and interest in and
+to all such modifications and/or patches, and all such modifications and/or
+patches may only be used, copied, modified, displayed, distributed, or otherwise
+exploited with a valid CDEBase Enterprise subscription for the correct
+number of user seats. Notwithstanding the foregoing, you may copy and modify
+the Software for development and testing purposes, without requiring a
+subscription. You agree that CDEBase and/or its licensors (as applicable) retain
+all right, title and interest in and to all such modifications. You are not
+granted any other rights beyond what is expressly stated herein. Subject to the
+foregoing, it is forbidden to copy, merge, publish, distribute, sublicense,
+and/or sell the Software.
+
+The full text of this Enterprise License shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+For all third party components incorporated into the CDEBase Software, those
+components are licensed under the original license provided by the owner of the
+applicable component.

package/README.md

@@ -0,0 +1,9 @@
+
+
+## To run tests
+
+    `npm link`
+    `npm link @xtermstack/xterm-core`
+    `npm install`
+    `tsc`
+    `npm run test`

package/lib/connections/jsonrpc2/connection.d.ts

@@ -0,0 +1,55 @@
+import { Observable, Unsubscribable } from 'rxjs';
+import { Event } from './events';
+import { Message, NotificationMessage, ResponseError } from './messages';
+import { Tracer } from './trace';
+import { MessageReader, MessageWriter } from './transport';
+export interface Logger {
+    error(message: string): void;
+    warn(message: string): void;
+    info(message: string): void;
+    log(message: string): void;
+}
+export declare enum ConnectionErrors {
+    /**
+     * The connection is closed.
+     */
+    Closed = 1,
+    /**
+     * The connection got unsubscribed (i.e., disposed).
+     */
+    Unsubscribed = 2,
+    /**
+     * The connection is already in listening mode.
+     */
+    AlreadyListening = 3
+}
+export declare class ConnectionError extends Error {
+    readonly code: ConnectionErrors;
+    constructor(code: ConnectionErrors, message: string);
+}
+declare type HandlerResult<R, E> = R | ResponseError<E> | Promise<R> | Promise<ResponseError<E>> | Promise<R | ResponseError<E>> | Observable<R>;
+declare type StarRequestHandler = (method: string, params?: any, signal?: AbortSignal) => HandlerResult<any, any>;
+declare type GenericRequestHandler<R, E> = (params?: any, signal?: AbortSignal, methodName?: string) => HandlerResult<R, E>;
+declare type StarNotificationHandler = (method: string, params?: any) => void;
+declare type GenericNotificationHandler = (params: any) => void;
+export interface Connection extends Unsubscribable {
+    sendRequest<R>(method: string, params?: any[], signal?: AbortSignal, toSecondary?: boolean): Promise<R>;
+    observeRequest<R>(method: string, params?: any[]): Observable<R>;
+    onRequest<R, E>(method: string, handler: GenericRequestHandler<R, E>): void;
+    onRequest(handler: StarRequestHandler): void;
+    sendNotification(method: string, params?: any[], toSecondary?: boolean): void;
+    onNotification(method: string, handler: GenericNotificationHandler): void;
+    onNotification(handler: StarNotificationHandler): void;
+    trace(tracer: Tracer | null): void;
+    onError: Event<[Error, Message | undefined, number | undefined]>;
+    onClose: Event<void>;
+    onUnhandledNotification: Event<NotificationMessage>;
+    listen(): void;
+    onUnsubscribe: Event<void>;
+}
+export interface MessageTransports {
+    reader: MessageReader;
+    writer: MessageWriter;
+}
+export declare function createConnection(transports: MessageTransports, logger?: Logger): Connection;
+export {};

package/lib/connections/jsonrpc2/connection.js

@@ -0,0 +1,575 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createConnection = exports.ConnectionError = exports.ConnectionErrors = void 0;
+const abortable_rx_1 = require("abortable-rx");
+const rxjs_1 = require("rxjs");
+const utils_1 = require("../../utils");
+const events_1 = require("./events");
+const linkedMap_1 = require("./linkedMap");
+const abort_controller_1 = require("abort-controller");
+const messages_1 = require("./messages");
+const trace_1 = require("./trace");
+const NullLogger = Object.freeze({
+    error: () => {
+        /* noop */
+    },
+    warn: () => {
+        /* noop */
+    },
+    info: () => {
+        /* noop */
+    },
+    log: () => {
+        /* noop */
+    },
+});
+var ConnectionErrors;
+(function (ConnectionErrors) {
+    /**
+     * The connection is closed.
+     */
+    ConnectionErrors[ConnectionErrors["Closed"] = 1] = "Closed";
+    /**
+     * The connection got unsubscribed (i.e., disposed).
+     */
+    ConnectionErrors[ConnectionErrors["Unsubscribed"] = 2] = "Unsubscribed";
+    /**
+     * The connection is already in listening mode.
+     */
+    ConnectionErrors[ConnectionErrors["AlreadyListening"] = 3] = "AlreadyListening";
+})(ConnectionErrors = exports.ConnectionErrors || (exports.ConnectionErrors = {}));
+class ConnectionError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        Object.setPrototypeOf(this, ConnectionError.prototype);
+    }
+}
+exports.ConnectionError = ConnectionError;
+function createConnection(transports, logger) {
+    if (!logger) {
+        logger = NullLogger;
+    }
+    return _createConnection(transports, logger);
+}
+exports.createConnection = createConnection;
+var ConnectionState;
+(function (ConnectionState) {
+    ConnectionState[ConnectionState["New"] = 1] = "New";
+    ConnectionState[ConnectionState["Listening"] = 2] = "Listening";
+    ConnectionState[ConnectionState["Closed"] = 3] = "Closed";
+    ConnectionState[ConnectionState["Unsubscribed"] = 4] = "Unsubscribed";
+})(ConnectionState || (ConnectionState = {}));
+const ABORT_REQUEST_METHOD = '$/abortRequest';
+function _createConnection(transports, logger) {
+    let sequenceNumber = 0;
+    let notificationSquenceNumber = 0;
+    let unknownResponseSquenceNumber = 0;
+    const version = '2.0';
+    let starRequestHandler;
+    const requestHandlers = Object.create(null);
+    let starNotificationHandler;
+    const notificationHandlers = Object.create(null);
+    let timer = false;
+    let messageQueue = new linkedMap_1.LinkedMap();
+    let responseObservables = Object.create(null);
+    let requestAbortControllers = Object.create(null);
+    let tracer = trace_1.noopTracer;
+    let state = ConnectionState.New;
+    const errorEmitter = new events_1.Emitter();
+    const closeEmitter = new events_1.Emitter();
+    const unhandledNotificationEmitter = new events_1.Emitter();
+    const unsubscribeEmitter = new events_1.Emitter();
+    function createRequestQueueKey(id) {
+        return 'req-' + id.toString();
+    }
+    function createResponseQueueKey(id) {
+        if (id === null) {
+            return 'res-unknown-' + (++unknownResponseSquenceNumber).toString();
+        }
+        else {
+            return 'res-' + id.toString();
+        }
+    }
+    function createNotificationQueueKey() {
+        return 'not-' + (++notificationSquenceNumber).toString();
+    }
+    function addMessageToQueue(queue, message) {
+        if ((0, messages_1.isRequestMessage)(message)) {
+            queue.set(createRequestQueueKey(message.id), message);
+        }
+        else if ((0, messages_1.isResponseMessage)(message)) {
+            const key = createResponseQueueKey(message.id) + Math.random(); // TODO(sqs)
+            queue.set(key, message);
+        }
+        else {
+            queue.set(createNotificationQueueKey(), message);
+        }
+    }
+    function isListening() {
+        return state === ConnectionState.Listening;
+    }
+    function isClosed() {
+        return state === ConnectionState.Closed;
+    }
+    function isUnsubscribed() {
+        return state === ConnectionState.Unsubscribed;
+    }
+    function closeHandler() {
+        if (state === ConnectionState.New || state === ConnectionState.Listening) {
+            state = ConnectionState.Closed;
+            closeEmitter.fire(undefined);
+        }
+        // If the connection is unsubscribed don't sent close events.
+    }
+    function readErrorHandler(error) {
+        errorEmitter.fire([error, undefined, undefined]);
+    }
+    function writeErrorHandler(data) {
+        errorEmitter.fire(data);
+    }
+    transports.reader.onClose(closeHandler);
+    transports.reader.onError(readErrorHandler);
+    transports.writer.onClose(closeHandler);
+    transports.writer.onError(writeErrorHandler);
+    function triggerMessageQueue() {
+        if (timer || messageQueue.size === 0) {
+            return;
+        }
+        timer = true;
+        setImmediateCompat(() => {
+            timer = false;
+            processMessageQueue();
+        });
+    }
+    function processMessageQueue() {
+        if (messageQueue.size === 0) {
+            return;
+        }
+        const message = messageQueue.shift();
+        try {
+            if ((0, messages_1.isRequestMessage)(message)) {
+                handleRequest(message);
+            }
+            else if ((0, messages_1.isNotificationMessage)(message)) {
+                handleNotification(message);
+            }
+            else if ((0, messages_1.isResponseMessage)(message)) {
+                handleResponse(message);
+            }
+            else {
+                handleInvalidMessage(message);
+            }
+        }
+        finally {
+            triggerMessageQueue();
+        }
+    }
+    const callback = (message) => {
+        console.log("[callback.ON_MESSAGE]: ", { transports, message });
+        try {
+            // We have received an abort signal. Check if the message is still in the queue and abort it if allowed
+            // to do so.
+            if ((0, messages_1.isNotificationMessage)(message) && message.method === ABORT_REQUEST_METHOD) {
+                const key = createRequestQueueKey(message.params[0]);
+                const toAbort = messageQueue.get(key);
+                if ((0, messages_1.isRequestMessage)(toAbort)) {
+                    messageQueue.delete(key);
+                    const response = {
+                        jsonrpc: '2.0',
+                        id: toAbort.id,
+                        error: { code: messages_1.ErrorCodes.RequestAborted, message: 'request aborted' },
+                    };
+                    tracer.responseAborted(response, toAbort, message);
+                    transports.writer.write(response);
+                    return;
+                }
+            }
+            addMessageToQueue(messageQueue, message);
+        }
+        finally {
+            triggerMessageQueue();
+        }
+    };
+    function handleRequest(requestMessage) {
+        if (isUnsubscribed()) {
+            // we return here silently since we fired an event when the
+            // connection got unsubscribed.
+            return;
+        }
+        const startTime = Date.now();
+        function reply(resultOrError, complete) {
+            const message = {
+                jsonrpc: version,
+                id: requestMessage.id,
+                complete,
+            };
+            if (resultOrError instanceof messages_1.ResponseError) {
+                message.error = resultOrError.toJSON();
+            }
+            else {
+                message.result = resultOrError === undefined ? null : resultOrError;
+            }
+            tracer.responseSent(message, requestMessage, startTime);
+            transports.writer.write(message);
+        }
+        function replyError(error) {
+            const message = {
+                jsonrpc: version,
+                id: requestMessage.id,
+                error: error.toJSON(),
+                complete: true,
+            };
+            tracer.responseSent(message, requestMessage, startTime);
+            transports.writer.write(message);
+        }
+        function replySuccess(result) {
+            // The JSON RPC defines that a response must either have a result or an error
+            // So we can't treat undefined as a valid response result.
+            if (result === undefined) {
+                result = null;
+            }
+            const message = {
+                jsonrpc: version,
+                id: requestMessage.id,
+                result,
+                complete: true,
+            };
+            tracer.responseSent(message, requestMessage, startTime);
+            transports.writer.write(message);
+        }
+        function replyComplete() {
+            const message = {
+                jsonrpc: version,
+                id: requestMessage.id,
+                complete: true,
+            };
+            tracer.responseSent(message, requestMessage, startTime);
+            transports.writer.write(message);
+        }
+        tracer.requestReceived(requestMessage);
+        const element = requestHandlers[requestMessage.method] || requestHandlers[matchedStartActor(Object.keys(requestHandlers), requestMessage.method)];
+        const requestHandler = element && element.handler;
+        if (requestHandler || starRequestHandler) {
+            const abortController = new abort_controller_1.default();
+            const signalKey = String(requestMessage.id);
+            requestAbortControllers[signalKey] = abortController;
+            try {
+                const params = requestMessage.params !== undefined ? requestMessage.params : null;
+                const handlerResult = requestHandler
+                    ? requestHandler(params, abortController.signal, requestMessage.method)
+                    : starRequestHandler(requestMessage.method, params, abortController.signal);
+                if (!handlerResult) {
+                    delete requestAbortControllers[signalKey];
+                    replySuccess(handlerResult);
+                }
+                else if ((0, utils_1.isPromise)(handlerResult) || (0, rxjs_1.isObservable)(handlerResult)) {
+                    const onComplete = () => {
+                        delete requestAbortControllers[signalKey];
+                    };
+                    (0, rxjs_1.from)(handlerResult).subscribe(value => reply(value, false), error => {
+                        onComplete();
+                        if (error instanceof messages_1.ResponseError) {
+                            replyError(error);
+                        }
+                        else if (error && typeof error.message === 'string') {
+                            replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, error.message, Object.assign({ stack: error.stack }, error)));
+                        }
+                        else {
+                            replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, `Request ${requestMessage.method} failed unexpectedly without providing any details.`));
+                        }
+                    }, () => {
+                        onComplete();
+                        replyComplete();
+                    });
+                }
+                else {
+                    delete requestAbortControllers[signalKey];
+                    reply(handlerResult, true);
+                }
+            }
+            catch (error) {
+                console.log('[ERROR]: ', error);
+                delete requestAbortControllers[signalKey];
+                if (error instanceof messages_1.ResponseError) {
+                    reply(error, true);
+                }
+                else if (error && typeof error.message === 'string') {
+                    replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, error.message, Object.assign({ stack: error.stack }, error)));
+                }
+                else {
+                    replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, `Request ${requestMessage.method} failed unexpectedly without providing any details.`));
+                }
+            }
+        }
+        else {
+            replyError(new messages_1.ResponseError(messages_1.ErrorCodes.MethodNotFound, `Unhandled method ${requestMessage.method}`));
+        }
+    }
+    function handleResponse(responseMessage) {
+        if (isUnsubscribed()) {
+            // See handle request.
+            return;
+        }
+        if (responseMessage.id === null) {
+            if (responseMessage.error) {
+                logger.error(`Received response message without id: Error is: \n${JSON.stringify(responseMessage.error, undefined, 4)}`);
+            }
+            else {
+                logger.error(`Received response message without id. No further error information provided.`);
+            }
+        }
+        else {
+            const key = String(responseMessage.id);
+            const responseObservable = responseObservables[key];
+            if (responseObservable) {
+                tracer.responseReceived(responseMessage, responseObservable.request || responseObservable.method, responseObservable.timerStart);
+                try {
+                    if (responseMessage.error) {
+                        const { code, message, data } = responseMessage.error;
+                        const err = new messages_1.ResponseError(code, message, data);
+                        if (data && data.stack) {
+                            err.stack = data.stack;
+                        }
+                        responseObservable.observer.error(err);
+                    }
+                    else if (responseMessage.result !== undefined) {
+                        responseObservable.observer.next(responseMessage.result);
+                    }
+                    if (responseMessage.complete) {
+                        responseObservable.complete = true;
+                        responseObservable.observer.complete();
+                    }
+                }
+                catch (error) {
+                    if (error.message) {
+                        logger.error(`Response handler '${responseObservable.method}' failed with message: ${error.message}`);
+                    }
+                    else {
+                        logger.error(`Response handler '${responseObservable.method}' failed unexpectedly.`);
+                    }
+                }
+                finally {
+                    if (responseMessage.complete) {
+                        delete responseObservables[key];
+                    }
+                }
+            }
+            else {
+                tracer.unknownResponseReceived(responseMessage);
+            }
+        }
+    }
+    function handleNotification(message) {
+        if (isUnsubscribed()) {
+            // See handle request.
+            return;
+        }
+        let notificationHandler;
+        if (message.method === ABORT_REQUEST_METHOD) {
+            notificationHandler = (params) => {
+                const id = params[0];
+                const abortController = requestAbortControllers[String(id)];
+                if (abortController) {
+                    abortController.abort();
+                }
+            };
+        }
+        else {
+            const element = notificationHandlers[message.method];
+            if (element) {
+                notificationHandler = element.handler;
+            }
+        }
+        if (notificationHandler || starNotificationHandler) {
+            try {
+                console.log('handleNotification.notificationHandler');
+                tracer.notificationReceived(message);
+                notificationHandler
+                    ? notificationHandler(message.params)
+                    : starNotificationHandler(message.method, message.params);
+            }
+            catch (error) {
+                if (error.message) {
+                    logger.error(`Notification handler '${message.method}' failed with message: ${error.message}`);
+                }
+                else {
+                    logger.error(`Notification handler '${message.method}' failed unexpectedly.`);
+                }
+            }
+        }
+        else {
+            console.log('handleNotification.notificationHandler.else', { notificationHandlers });
+            unhandledNotificationEmitter.fire(message);
+        }
+    }
+    function handleInvalidMessage(message) {
+        if (!message) {
+            logger.error('Received empty message.');
+            return;
+        }
+        logger.error(`Received message which is neither a response nor a notification message:\n${JSON.stringify(message, null, 4)}`);
+        // Test whether we find an id to reject the promise
+        const responseMessage = message;
+        if (typeof responseMessage.id === 'string' || typeof responseMessage.id === 'number') {
+            const key = String(responseMessage.id);
+            const responseHandler = responseObservables[key];
+            if (responseHandler) {
+                responseHandler.observer.error(new Error('The received response has neither a result nor an error property.'));
+            }
+        }
+    }
+    function throwIfClosedOrUnsubscribed() {
+        if (isClosed()) {
+            throw new ConnectionError(ConnectionErrors.Closed, 'Connection is closed.');
+        }
+        if (isUnsubscribed()) {
+            throw new ConnectionError(ConnectionErrors.Unsubscribed, 'Connection is unsubscribed.');
+        }
+    }
+    function throwIfListening() {
+        if (isListening()) {
+            throw new ConnectionError(ConnectionErrors.AlreadyListening, 'Connection is already listening');
+        }
+    }
+    function throwIfNotListening() {
+        if (!isListening()) {
+            throw new Error('Call listen() first.');
+        }
+    }
+    const sendNotification = (method, params, toSecondary = false) => {
+        throwIfClosedOrUnsubscribed();
+        const notificationMessage = {
+            jsonrpc: version,
+            method,
+            params,
+        };
+        tracer.notificationSent(notificationMessage);
+        transports.writer.write(notificationMessage);
+    };
+    /**
+     * @returns a hot observable with the result of sending the request
+     */
+    const requestHelper = (method, params, toSecondary) => {
+        const id = sequenceNumber++;
+        const requestMessage = {
+            jsonrpc: version,
+            id,
+            method,
+            params,
+            toSecondary,
+        };
+        const subject = new rxjs_1.Subject();
+        const responseObserver = {
+            method,
+            request: requestMessage,
+            timerStart: Date.now(),
+            complete: false,
+            observer: subject,
+        };
+        tracer.requestSent(requestMessage);
+        try {
+            transports.writer.write(requestMessage);
+            responseObservables[String(id)] = responseObserver;
+        }
+        catch (e) {
+            responseObserver.observer.error(new messages_1.ResponseError(messages_1.ErrorCodes.MessageWriteError, e.message ? e.message : 'Unknown reason'));
+        }
+        return new rxjs_1.Observable(observer => {
+            subject.subscribe(observer).add(() => {
+                if (!isUnsubscribed() &&
+                    responseObserver &&
+                    !responseObserver.complete &&
+                    !responseObserver.observer.closed) {
+                    sendNotification(ABORT_REQUEST_METHOD, [id]);
+                }
+            });
+        });
+    };
+    const connection = {
+        sendNotification,
+        onNotification: (type, handler) => {
+            throwIfClosedOrUnsubscribed();
+            if (typeof type === 'function') {
+                starNotificationHandler = type;
+            }
+            else if (handler) {
+                notificationHandlers[type] = { type: undefined, handler };
+            }
+        },
+        sendRequest: (method, params, signal, toSecondary = false) => {
+            throwIfClosedOrUnsubscribed();
+            throwIfNotListening();
+            return (0, abortable_rx_1.toPromise)(requestHelper(method, params, toSecondary), signal);
+        },
+        observeRequest: (method, params) => {
+            throwIfClosedOrUnsubscribed();
+            throwIfNotListening();
+            return requestHelper(method, params);
+        },
+        onRequest: (type, handler) => {
+            throwIfClosedOrUnsubscribed();
+            if (typeof type === 'function') {
+                starRequestHandler = type;
+            }
+            else if (handler) {
+                requestHandlers[type] = { type: undefined, handler };
+            }
+        },
+        trace: (_tracer) => {
+            if (_tracer) {
+                tracer = _tracer;
+            }
+            else {
+                tracer = trace_1.noopTracer;
+            }
+        },
+        onError: errorEmitter.event,
+        onClose: closeEmitter.event,
+        onUnhandledNotification: unhandledNotificationEmitter.event,
+        onUnsubscribe: unsubscribeEmitter.event,
+        unsubscribe: () => {
+            if (isUnsubscribed()) {
+                return;
+            }
+            state = ConnectionState.Unsubscribed;
+            unsubscribeEmitter.fire(undefined);
+            for (const key of Object.keys(responseObservables)) {
+                responseObservables[key].observer.error(new ConnectionError(ConnectionErrors.Unsubscribed, `The underlying JSON-RPC connection got unsubscribed while responding to this ${responseObservables[key].method} request.`));
+            }
+            responseObservables = Object.create(null);
+            requestAbortControllers = Object.create(null);
+            messageQueue = new linkedMap_1.LinkedMap();
+            transports.writer.unsubscribe();
+            transports.reader.unsubscribe();
+        },
+        listen: () => {
+            throwIfClosedOrUnsubscribed();
+            throwIfListening();
+            state = ConnectionState.Listening;
+            transports.reader.listen(callback);
+        },
+    };
+    return connection;
+}
+/** Support browser and node environments without needing a transpiler. */
+function setImmediateCompat(f) {
+    if (typeof setImmediate !== 'undefined') {
+        setImmediate(f);
+        return;
+    }
+    setTimeout(f, 0);
+}
+function matchedStartActor(requestHandlersKeys, method) {
+    try {
+        return requestHandlersKeys.filter(name => {
+            let methodName = method.split('/')[0];
+            return `${methodName}/*` === name;
+        })[0];
+    }
+    catch (e) {
+        console.log('no matched value');
+        return null;
+    }
+}
+//# sourceMappingURL=connection.js.map