Format code

packages/grpc-js-core/src/call-stream.ts

@@ -153,7 +153,8 @@ export class Http2CallStream extends Duplex implements CallStream {
       return;
     }
     this.isReadFilterPending = true;
-    this.filterStack.receiveMessage(Promise.resolve(framedMessage)).then(
+    this.filterStack.receiveMessage(Promise.resolve(framedMessage))
+        .then(
             this.handleFilteredRead.bind(this),
             this.handleFilterError.bind(this));
   }
@@ -291,7 +292,8 @@ export class Http2CallStream extends Duplex implements CallStream {
                 if (this.readMessageRemaining > 0) {
                   this.readState = ReadState.READING_MESSAGE;
                 } else {
-                  this.tryPush(Buffer.concat([this.readCompressFlag, this.readPartialSize]));
+                  this.tryPush(Buffer.concat(
+                      [this.readCompressFlag, this.readPartialSize]));
                   this.readState = ReadState.NO_DATA;
                 }
               }
@@ -306,8 +308,11 @@ export class Http2CallStream extends Duplex implements CallStream {
               // readMessageRemaining >=0 here
               if (this.readMessageRemaining === 0) {
                 // At this point, we have read a full message
-                const framedMessageBuffers = [this.readCompressFlag, this.readPartialSize].concat(this.readPartialMessage);
+                const framedMessageBuffers = [
-                const framedMessage = Buffer.concat(framedMessageBuffers, this.readMessageSize + 5);
+                  this.readCompressFlag, this.readPartialSize
+                ].concat(this.readPartialMessage);
+                const framedMessage = Buffer.concat(
+                    framedMessageBuffers, this.readMessageSize + 5);
                 this.tryPush(framedMessage);
                 this.readState = ReadState.NO_DATA;
               }

packages/grpc-js-core/src/compression-filter.ts

@@ -1,9 +1,10 @@
-import {CallStream, WriteObject, WriteFlags} from './call-stream';
+import * as zlib from 'zlib';
+
+import {CallStream, WriteFlags, WriteObject} from './call-stream';
 import {Channel} from './channel';
+import {Status} from './constants';
 import {BaseFilter, Filter, FilterFactory} from './filter';
 import {Metadata, MetadataValue} from './metadata';
-import {Status} from './constants';
-import * as zlib from 'zlib';
 
 abstract class CompressionHandler {
   protected abstract compressMessage(message: Buffer): Promise<Buffer>;
@@ -61,53 +62,49 @@ class IdentityHandler extends CompressionHandler{
 
 class DeflateHandler extends CompressionHandler {
   compressMessage(message: Buffer) {
-    return new Promise<Buffer>((resolve, reject) => {
+    return new Promise<Buffer>(
-      zlib.deflate(message, (err, output) => {
+        (resolve, reject) => {zlib.deflate(message, (err, output) => {
           if (err) {
             reject(err);
           } else {
             resolve(output);
           }
-      })
+        })});
-    });
   }
 
   decompressMessage(message: Buffer) {
-    return new Promise<Buffer>((resolve, reject) => {
+    return new Promise<Buffer>(
-      zlib.inflate(message, (err, output) => {
+        (resolve, reject) => {zlib.inflate(message, (err, output) => {
           if (err) {
             reject(err);
           } else {
             resolve(output);
           }
-      })
+        })});
-    });
   }
 }
 
 class GzipHandler extends CompressionHandler {
   compressMessage(message: Buffer) {
-    return new Promise<Buffer>((resolve, reject) => {
+    return new Promise<Buffer>(
-      zlib.gzip(message, (err, output) => {
+        (resolve, reject) => {zlib.gzip(message, (err, output) => {
           if (err) {
             reject(err);
           } else {
             resolve(output);
           }
-      })
+        })});
-    });
   }
 
   decompressMessage(message: Buffer) {
-    return new Promise<Buffer>((resolve, reject) => {
+    return new Promise<Buffer>(
-      zlib.unzip(message, (err, output) => {
+        (resolve, reject) => {zlib.unzip(message, (err, output) => {
           if (err) {
             reject(err);
           } else {
             resolve(output);
           }
-      })
+        })});
-    });
   }
 }
 
@@ -117,13 +114,14 @@ class UnknownHandler extends CompressionHandler {
   }
   compressMessage(message: Buffer): Promise<Buffer> {
     return Promise.reject<Buffer>(new Error(
-      `Received message compressed wth unsupported compression method ${this.compressionName}`));
+        `Received message compressed wth unsupported compression method ${
+            this.compressionName}`));
   }
 
   decompressMessage(message: Buffer): Promise<Buffer> {
     // This should be unreachable
-    return Promise.reject<Buffer>(new Error(
+    return Promise.reject<Buffer>(
-      `Compression method not supported: ${this.compressionName}`));
+        new Error(`Compression method not supported: ${this.compressionName}`));
   }
 }
 
@@ -165,15 +163,16 @@ export class CompressionFilter extends BaseFilter implements Filter {
   }
 
   async sendMessage(message: Promise<WriteObject>): Promise<WriteObject> {
-    
     /* This filter is special. The input message is the bare message bytes,
      * and the output is a framed and possibly compressed message. For this
      * reason, this filter should be at the bottom of the filter stack */
     const resolvedMessage: WriteObject = await message;
-    const compress = resolvedMessage.flags === undefined ? false :
+    const compress = resolvedMessage.flags === undefined ?
+        false :
         (resolvedMessage.flags & WriteFlags.NoCompress) === 0;
     return {
-      message: await this.sendCompression.writeMessage(resolvedMessage.message, compress),
+      message: await this.sendCompression.writeMessage(
+          resolvedMessage.message, compress),
       flags: resolvedMessage.flags
     };
   }

packages/grpc-js-core/src/filter-stack.ts

@@ -19,14 +19,13 @@ export class FilterStack implements Filter {
   }
 
   sendMessage(message: Promise<WriteObject>): Promise<WriteObject> {
-    return flow(map(
+    return flow(map(this.filters, (filter) => filter.sendMessage.bind(filter)))(
-        this.filters, (filter) => filter.sendMessage.bind(filter)))(message);
+        message);
   }
 
   receiveMessage(message: Promise<Buffer>): Promise<Buffer> {
-    return flowRight(
+    return flowRight(map(
-        map(this.filters, (filter) => filter.receiveMessage.bind(filter)))(
+        this.filters, (filter) => filter.receiveMessage.bind(filter)))(message);
-        message);
   }
 
   receiveTrailers(status: Promise<StatusObject>): Promise<StatusObject> {

packages/grpc-js-core/src/index.ts

@@ -35,7 +35,8 @@ export interface OAuth2Client {
 /**** Client Credentials ****/
 
 // Using assign only copies enumerable properties, which is what we want
-export const credentials = mixin({
+export const credentials = mixin(
+    {
       /**
        * Create a gRPC credential from a Google credential object.
        * @param googleCredentials The authentication client to use.
@@ -84,7 +85,8 @@ export const credentials = mixin({
           CallCredentials => {
             return additional.reduce((acc, other) => acc.compose(other), first);
           }
-    }, ChannelCredentials, CallCredentials);
+    },
+    ChannelCredentials, CallCredentials);
 
 /**** Metadata ****/
 

packages/grpc-js-core/src/make-client.ts

@@ -6,9 +6,13 @@ import {ChannelCredentials} from './channel-credentials';
 import {Client, UnaryCallback} from './client';
 import {Metadata} from './metadata';
 
-export interface Serialize<T> { (value: T): Buffer; }
+export interface Serialize<T> {
+  (value: T): Buffer;
+}
 
-export interface Deserialize<T> { (bytes: Buffer): T; }
+export interface Deserialize<T> {
+  (bytes: Buffer): T;
+}
 
 export interface MethodDefinition<RequestType, ResponseType> {
   path: string;
@@ -25,7 +29,9 @@ export interface ServiceDefinition {
   [index: string]: MethodDefinition<object, object>;
 }
 
-export interface PackageDefinition { [index: string]: ServiceDefinition; }
+export interface PackageDefinition {
+  [index: string]: ServiceDefinition;
+}
 
 function getDefaultValues<T>(metadata?: Metadata, options?: T):
     {metadata: Metadata; options: Partial<T>;} {

packages/grpc-js-core/src/metadata.ts

@@ -3,7 +3,9 @@ import {forOwn} from 'lodash';
 
 export type MetadataValue = string|Buffer;
 
-export interface MetadataObject { [key: string]: MetadataValue[]; }
+export interface MetadataObject {
+  [key: string]: MetadataValue[];
+}
 
 function cloneMetadataObject(repr: MetadataObject): MetadataObject {
   const result: MetadataObject = {};

packages/grpc-js-core/test/test-call-stream.ts

@@ -6,13 +6,13 @@ import * as stream from 'stream';
 
 import {CallCredentials} from '../src/call-credentials';
 import {Http2CallStream} from '../src/call-stream';
+import {Channel} from '../src/channel';
 import {CompressionFilterFactory} from '../src/compression-filter';
 import {Status} from '../src/constants';
 import {FilterStackFactory} from '../src/filter-stack';
 import {Metadata} from '../src/metadata';
 
 import {assert2, mockFunction} from './common';
-import { Channel } from '../src/channel';
 
 interface DataFrames {
   payload: Buffer;
@@ -89,7 +89,8 @@ describe('CallStream', () => {
    * Currently the channel is unused, so we can replace it with an empty object,
    * but this might break if we start checking channel arguments, in which case
    * we will need a more sophisticated fake */
-  const filterStackFactory = new FilterStackFactory([new CompressionFilterFactory(<Channel>{})]);
+  const filterStackFactory =
+      new FilterStackFactory([new CompressionFilterFactory(<Channel>{})]);
   const message = 'eat this message';  // 16 bytes
 
   beforeEach(() => {