vscode-jsonrpc - npm Package Compare versions

Comparing version 2.1.1 to 2.2.0

lib/main.d.ts

@@ -1,2 +0,2 @@
-import { RequestType, ResponseError, ErrorCodes, NotificationType } from './messages';
+import { Message, RequestMessage, RequestType, ResponseError, ErrorCodes, NotificationMessage, NotificationType } from './messages';
 import { MessageReader, DataCallback, StreamMessageReader, IPCMessageReader } from './messageReader';
@@ -6,3 +6,3 @@ import { MessageWriter, StreamMessageWriter, IPCMessageWriter } from './messageWriter';
 import { CancellationTokenSource, CancellationToken } from './cancellation';
-export { ErrorCodes, ResponseError, RequestType, NotificationType, MessageReader, DataCallback, StreamMessageReader, IPCMessageReader, MessageWriter, StreamMessageWriter, IPCMessageWriter, CancellationTokenSource, CancellationToken, Disposable, Event, Emitter };
+export { Message, ErrorCodes, ResponseError, RequestMessage, RequestType, NotificationMessage, NotificationType, MessageReader, DataCallback, StreamMessageReader, IPCMessageReader, MessageWriter, StreamMessageWriter, IPCMessageWriter, CancellationTokenSource, CancellationToken, Disposable, Event, Emitter };
 export interface RequestHandler<P, R, E> {
@@ -37,2 +37,4 @@ (params: P, token: CancellationToken): R | ResponseError<E> | Thenable<R | ResponseError<E>>;
     trace(value: Trace, tracer: Tracer): void;
+    onError: Event<[Error, Message, number]>;
+    onClose: Event<void>;
     listen(): any;
@@ -39,0 +41,0 @@ dispose(): void;

lib/main.js

@@ -49,2 +49,7 @@ /* --------------------------------------------------------------------------------------------
 })(Trace = exports.Trace || (exports.Trace = {}));
+var ConnectionState;
+(function (ConnectionState) {
+    ConnectionState[ConnectionState["Active"] = 1] = "Active";
+    ConnectionState[ConnectionState["Closed"] = 2] = "Closed";
+})(ConnectionState || (ConnectionState = {}));
 function createMessageConnection(messageReader, messageWriter, logger, client) {
@@ -60,2 +65,22 @@ if (client === void 0) { client = false; }
     var tracer;
+    var state = ConnectionState.Active;
+    var errorEmitter = new events_1.Emitter();
+    var closeEmitter = new events_1.Emitter();
+    function closeHandler() {
+        if (state !== ConnectionState.Closed) {
+            state = ConnectionState.Closed;
+            closeEmitter.fire(undefined);
+        }
+    }
+    ;
+    function readErrorHandler(error) {
+        errorEmitter.fire([error, undefined, undefined]);
+    }
+    function writeErrorHandler(data) {
+        errorEmitter.fire(data);
+    }
+    messageReader.onClose(closeHandler);
+    messageReader.onError(readErrorHandler);
+    messageWriter.onClose(closeHandler);
+    messageWriter.onError(writeErrorHandler);
     function handleRequest(requestMessage) {
@@ -154,2 +179,3 @@ function reply(resultOrError) {
         if (responsePromise) {
+            delete responsePromises[key];
             try {
@@ -165,3 +191,2 @@ if (is.defined(responseMessage.error)) {
                 }
-                delete responsePromises[key];
             }
@@ -313,7 +338,17 @@ catch (error) {
                 };
-                responsePromises[String(id)] = { method: type.method, timerStart: Date.now(), resolve: resolve, reject: reject };
+                var responsePromise = { method: type.method, timerStart: Date.now(), resolve: resolve, reject: reject };
                 if (trace != Trace.Off && tracer) {
                     traceRequest(requestMessage);
                 }
-                messageWriter.write(requestMessage);
+                try {
+                    messageWriter.write(requestMessage);
+                }
+                catch (e) {
+                    // Writing the message failed. So we need to reject the promise.
+                    responsePromise.reject(new messages_1.ResponseError(messages_1.ErrorCodes.MessageWriteError, e.message ? e.message : 'Unknown reason'));
+                    responsePromise = null;
+                }
+                if (responsePromise) {
+                    responsePromises[String(id)] = responsePromise;
+                }
             });
@@ -339,2 +374,4 @@ if (token) {
         },
+        onError: errorEmitter.event,
+        onClose: closeEmitter.event,
         dispose: function () {
@@ -341,0 +378,0 @@ },

lib/messageReader.d.ts

 import { ChildProcess } from 'child_process';
 import { Message } from './messages';
+import { Event } from './events';
 export interface DataCallback {
@@ -7,5 +8,17 @@ (data: Message): void;
 export interface MessageReader {
+    onError: Event<Error>;
+    onClose: Event<void>;
     listen(callback: DataCallback): void;
 }
-export declare class StreamMessageReader implements MessageReader {
+export declare abstract class AbstractMessageReader {
+    private errorEmitter;
+    private closeEmitter;
+    constructor();
+    onError: Event<Error>;
+    protected fireError(error: any): void;
+    onClose: Event<void>;
+    protected fireClose(): void;
+    private asError(error);
+}
+export declare class StreamMessageReader extends AbstractMessageReader implements MessageReader {
     private readable;
@@ -19,3 +32,3 @@ private callback;
 }
-export declare class IPCMessageReader implements MessageReader {
+export declare class IPCMessageReader extends AbstractMessageReader implements MessageReader {
     private process;
@@ -22,0 +35,0 @@ constructor(process: NodeJS.Process | ChildProcess);

lib/messageReader.js

@@ -6,2 +6,9 @@ /* --------------------------------------------------------------------------------------------
 'use strict';
+var __extends = (this && this.__extends) || function (d, b) {
+    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+};
+var events_1 = require('./events');
+var is = require('./is');
 var DefaultSize = 8192;
@@ -85,5 +92,43 @@ var CR = new Buffer('\r', 'ascii')[0];
 })();
-var StreamMessageReader = (function () {
+var AbstractMessageReader = (function () {
+    function AbstractMessageReader() {
+        this.errorEmitter = new events_1.Emitter();
+        this.closeEmitter = new events_1.Emitter();
+    }
+    Object.defineProperty(AbstractMessageReader.prototype, "onError", {
+        get: function () {
+            return this.errorEmitter.event;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    AbstractMessageReader.prototype.fireError = function (error) {
+        this.errorEmitter.fire(this.asError(error));
+    };
+    Object.defineProperty(AbstractMessageReader.prototype, "onClose", {
+        get: function () {
+            return this.closeEmitter.event;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    AbstractMessageReader.prototype.fireClose = function () {
+        this.closeEmitter.fire(undefined);
+    };
+    AbstractMessageReader.prototype.asError = function (error) {
+        if (error instanceof Error) {
+            return error;
+        }
+        else {
+            return new Error("Reader recevied error. Reason: " + (is.string(error.message) ? error.message : 'unknown'));
+        }
+    };
+    return AbstractMessageReader;
+})();
+exports.AbstractMessageReader = AbstractMessageReader;
+var StreamMessageReader = (function (_super) {
+    __extends(StreamMessageReader, _super);
     function StreamMessageReader(readable, encoding) {
         if (encoding === void 0) { encoding = 'utf-8'; }
+        _super.call(this);
         this.readable = readable;
@@ -99,2 +144,4 @@ this.buffer = new MessageBuffer(encoding);
         });
+        this.readable.on('error', function (error) { return _this.fireError(error); });
+        this.readable.on('close', function () { return _this.fireClose(); });
     };
@@ -129,7 +176,12 @@ StreamMessageReader.prototype.onData = function (data) {
     return StreamMessageReader;
-})();
+})(AbstractMessageReader);
 exports.StreamMessageReader = StreamMessageReader;
-var IPCMessageReader = (function () {
+var IPCMessageReader = (function (_super) {
+    __extends(IPCMessageReader, _super);
     function IPCMessageReader(process) {
+        var _this = this;
+        _super.call(this);
         this.process = process;
+        this.process.on('error', function (error) { return _this.fireError(error); });
+        this.process.on('close', function () { return _this.fireClose(); });
     }
@@ -140,3 +192,3 @@ IPCMessageReader.prototype.listen = function (callback) {
     return IPCMessageReader;
-})();
+})(AbstractMessageReader);
 exports.IPCMessageReader = IPCMessageReader;

lib/messages.d.ts

@@ -35,2 +35,4 @@ /**
     const serverErrorEnd: number;
+    const MessageWriteError: number;
+    const MessageReadError: number;
 }
@@ -37,0 +39,0 @@ export interface ResponseErrorLiteral<D> {

lib/messages.js

@@ -17,2 +17,3 @@ /* --------------------------------------------------------------------------------------------
 (function (ErrorCodes) {
+    // Defined by JSON RPC
     ErrorCodes.ParseError = -32700;
@@ -25,2 +26,5 @@ ErrorCodes.InvalidRequest = -32600;
     ErrorCodes.serverErrorEnd = -32000;
+    // Defined by VSCode.
+    ErrorCodes.MessageWriteError = 1;
+    ErrorCodes.MessageReadError = 2;
 })(ErrorCodes = exports.ErrorCodes || (exports.ErrorCodes = {}));
@@ -27,0 +31,0 @@ /**

lib/messageWriter.d.ts

 import { ChildProcess } from 'child_process';
 import { Message } from './messages';
+import { Event } from './events';
 export interface MessageWriter {
+    onError: Event<[Error, Message, number]>;
+    onClose: Event<void>;
     write(msg: Message): void;
 }
-export declare class StreamMessageWriter implements MessageWriter {
+export declare abstract class AbstractMessageWriter {
+    private errorEmitter;
+    private closeEmitter;
+    constructor();
+    onError: Event<[Error, Message, number]>;
+    protected fireError(error: any, message?: Message, count?: number): void;
+    onClose: Event<void>;
+    protected fireClose(): void;
+    private asError(error);
+}
+export declare class StreamMessageWriter extends AbstractMessageWriter implements MessageWriter {
     private writable;
     private encoding;
+    private errorCount;
     constructor(writable: NodeJS.WritableStream, encoding?: string);
     write(msg: Message): void;
 }
-export declare class IPCMessageWriter implements MessageWriter {
+export declare class IPCMessageWriter extends AbstractMessageWriter implements MessageWriter {
     private process;
+    private errorCount;
     constructor(process: NodeJS.Process | ChildProcess);
     write(msg: Message): void;
 }

lib/messageWriter.js

@@ -6,9 +6,58 @@ /* --------------------------------------------------------------------------------------------
 'use strict';
+var __extends = (this && this.__extends) || function (d, b) {
+    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+};
+var events_1 = require('./events');
+var is = require('./is');
 var ContentLength = 'Content-Length: ';
 var CRLF = '\r\n';
-var StreamMessageWriter = (function () {
+var AbstractMessageWriter = (function () {
+    function AbstractMessageWriter() {
+        this.errorEmitter = new events_1.Emitter();
+        this.closeEmitter = new events_1.Emitter();
+    }
+    Object.defineProperty(AbstractMessageWriter.prototype, "onError", {
+        get: function () {
+            return this.errorEmitter.event;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    AbstractMessageWriter.prototype.fireError = function (error, message, count) {
+        this.errorEmitter.fire([this.asError(error), message, count]);
+    };
+    Object.defineProperty(AbstractMessageWriter.prototype, "onClose", {
+        get: function () {
+            return this.closeEmitter.event;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    AbstractMessageWriter.prototype.fireClose = function () {
+        this.closeEmitter.fire(undefined);
+    };
+    AbstractMessageWriter.prototype.asError = function (error) {
+        if (error instanceof Error) {
+            return error;
+        }
+        else {
+            return new Error("Writer recevied error. Reason: " + (is.string(error.message) ? error.message : 'unknown'));
+        }
+    };
+    return AbstractMessageWriter;
+})();
+exports.AbstractMessageWriter = AbstractMessageWriter;
+var StreamMessageWriter = (function (_super) {
+    __extends(StreamMessageWriter, _super);
     function StreamMessageWriter(writable, encoding) {
+        var _this = this;
         if (encoding === void 0) { encoding = 'utf8'; }
+        _super.call(this);
         this.writable = writable;
         this.encoding = encoding;
+        this.errorCount = 0;
+        this.writable.on('error', function (error) { return _this.fireError(error); });
+        this.writable.on('close', function () { return _this.fireClose(); });
     }
@@ -22,19 +71,39 @@ StreamMessageWriter.prototype.write = function (msg) {
         ];
-        // Header must be written in ASCII encoding
-        this.writable.write(headers.join(''), 'ascii');
-        // Now write the content. This can be written in any encoding
-        this.writable.write(json, this.encoding);
+        try {
+            // Header must be written in ASCII encoding
+            this.writable.write(headers.join(''), 'ascii');
+            // Now write the content. This can be written in any encoding
+            this.writable.write(json, this.encoding);
+            this.errorCount = 0;
+        }
+        catch (error) {
+            this.errorCount++;
+            this.fireError(error, msg, this.errorCount);
+        }
     };
     return StreamMessageWriter;
-})();
+})(AbstractMessageWriter);
 exports.StreamMessageWriter = StreamMessageWriter;
-var IPCMessageWriter = (function () {
+var IPCMessageWriter = (function (_super) {
+    __extends(IPCMessageWriter, _super);
     function IPCMessageWriter(process) {
+        var _this = this;
+        _super.call(this);
         this.process = process;
+        this.errorCount = 0;
+        this.process.on('error', function (error) { return _this.fireError(error); });
+        this.process.on('close', function () { return _this.fireClose; });
     }
     IPCMessageWriter.prototype.write = function (msg) {
-        this.process.send(msg);
+        try {
+            this.process.send(msg);
+            this.errorCount = 0;
+        }
+        catch (error) {
+            this.errorCount++;
+            this.fireError(error, msg, this.errorCount);
+        }
     };
     return IPCMessageWriter;
-})();
+})(AbstractMessageWriter);
 exports.IPCMessageWriter = IPCMessageWriter;

package.json

 {
 	"name": "vscode-jsonrpc",
 	"description": "A json rpc implementation over streams",
-	"version": "2.1.1",
+	"version": "2.2.0",
 	"author": "Microsoft Corporation",
@@ -6,0 +6,0 @@ "license": "MIT",

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

57434

increased by15.56%

Lines of code

1390

increased by16.32%

No dependency changes