Add call options parameter to client objects and options parameter to the constructor

gpahal · gpahal · commit f3bde42862d9 · 2018-01-29T11:13:20.000+05:30
diff --git a/generated/api_grpc_pb.d.ts b/generated/api_grpc_pb.d.ts
@@ -5,9 +5,38 @@ import * as grpc from "grpc";
 import * as api_pb from "./api_pb";
 
 export class DgraphClient extends grpc.Client {
-    public alter(operation: api_pb.Operation, callback: (err?: Error | null, res?: api_pb.Payload) => void): void;
-    public query(request: api_pb.Request, callback: (err?: Error | null, res?: api_pb.Response) => void): void;
-    public mutate(request: api_pb.Mutation, callback: (err?: Error | null, res?: api_pb.Assigned) => void): void;
-    public commitOrAbort(request: api_pb.TxnContext, callback: (err?: Error | null, res?: api_pb.TxnContext) => void): void;
-    public checkVersion(request: api_pb.Check, callback: (err?: Error | null, res?: api_pb.Version) => void): void;
+    public alter(
+        operation: api_pb.Operation,
+        metadata: grpc.Metadata | null,
+        options: grpc.CallOptions | null,
+        callback: (err?: Error | null, res?: api_pb.Payload) => void,
+    ): void;
+
+    public query(
+        request: api_pb.Request,
+        metadata: grpc.Metadata | null,
+        options: grpc.CallOptions | null,
+        callback: (err?: Error | null, res?: api_pb.Response) => void,
+    ): void;
+
+    public mutate(
+        request: api_pb.Mutation,
+        metadata: grpc.Metadata | null,
+        options: grpc.CallOptions | null,
+        callback: (err?: Error | null, res?: api_pb.Assigned) => void,
+    ): void;
+
+    public commitOrAbort(
+        request: api_pb.TxnContext,
+        metadata: grpc.Metadata | null,
+        options: grpc.CallOptions | null,
+        callback: (err?: Error | null, res?: api_pb.TxnContext) => void,
+    ): void;
+
+    public checkVersion(
+        request: api_pb.Check,
+        metadata: grpc.Metadata | null,
+        options: grpc.CallOptions | null,
+        callback: (err?: Error | null, res?: api_pb.Version) => void,
+    ): void;
 }
diff --git a/src/clientStub.ts b/src/clientStub.ts
@@ -3,23 +3,48 @@ import * as grpc from "grpc";
 import * as services from "../generated/api_grpc_pb";
 import * as messages from "../generated/api_pb";
 
-import { promisify } from "./util";
+import { promisify1, promisify3 } from "./util";
 
 /**
  * Stub is a stub/client connecting to a single dgraph server instance.
  */
 export class DgraphClientStub {
     private stub: services.DgraphClient;
     private promisified: {
-        alter(op: messages.Operation): Promise<messages.Payload>;
-        query(req: messages.Request): Promise<messages.Response>;
-        mutate(mu: messages.Mutation): Promise<messages.Assigned>;
-        commitOrAbort(ctx: messages.TxnContext): Promise<messages.TxnContext>;
-        checkVersion(check: messages.Check): Promise<messages.Version>;
+        alter(
+            op: messages.Operation,
+            metadata: grpc.Metadata | null,
+            options: grpc.CallOptions | null,
+        ): Promise<messages.Payload>;
+
+        query(
+            req: messages.Request,
+            metadata: grpc.Metadata | null,
+            options: grpc.CallOptions | null,
+        ): Promise<messages.Response>;
+
+        mutate(
+            mu: messages.Mutation,
+            metadata: grpc.Metadata | null,
+            options: grpc.CallOptions | null,
+        ): Promise<messages.Assigned>;
+
+        commitOrAbort(
+            ctx: messages.TxnContext,
+            metadata: grpc.Metadata | null,
+            options: grpc.CallOptions | null,
+        ): Promise<messages.TxnContext>;
+
+        checkVersion(
+            check: messages.Check,
+            metadata: grpc.Metadata | null,
+            options: grpc.CallOptions | null,
+        ): Promise<messages.Version>;
+
         waitForReady(deadline: grpc.Deadline): Promise<void>;
     };
 
-    constructor(addr?: string | null, credentials?: grpc.ChannelCredentials | null) {
+    constructor(addr?: string | null, credentials?: grpc.ChannelCredentials | null, options?: object | null) {
         if (addr == null) {
             // tslint:disable-next-line no-parameter-reassignment
             addr = "localhost:9080";
@@ -29,35 +54,35 @@ export class DgraphClientStub {
             credentials = grpc.credentials.createInsecure();
         }
 
-        this.stub = new services.DgraphClient(addr, credentials);
+        this.stub = new services.DgraphClient(addr, credentials, options);
         this.promisified = {
-            alter: promisify(this.stub.alter, this.stub),
-            query: promisify(this.stub.query, this.stub),
-            mutate: promisify(this.stub.mutate, this.stub),
-            commitOrAbort: promisify(this.stub.commitOrAbort, this.stub),
-            checkVersion: promisify(this.stub.checkVersion, this.stub),
-            waitForReady: promisify(this.stub.waitForReady, this.stub),
+            alter: promisify3(this.stub.alter, this.stub),
+            query: promisify3(this.stub.query, this.stub),
+            mutate: promisify3(this.stub.mutate, this.stub),
+            commitOrAbort: promisify3(this.stub.commitOrAbort, this.stub),
+            checkVersion: promisify3(this.stub.checkVersion, this.stub),
+            waitForReady: promisify1(this.stub.waitForReady, this.stub),
         };
     }
 
-    public alter(op: messages.Operation): Promise<messages.Payload> {
-        return this.promisified.alter(op);
+    public alter(op: messages.Operation, options?: grpc.CallOptions | null): Promise<messages.Payload> {
+        return this.promisified.alter(op, undefined, options);
     }
 
-    public query(req: messages.Request): Promise<messages.Response> {
-        return this.promisified.query(req);
+    public query(req: messages.Request, options?: grpc.CallOptions | null): Promise<messages.Response> {
+        return this.promisified.query(req, undefined, options);
     }
 
-    public mutate(mu: messages.Mutation): Promise<messages.Assigned> {
-        return this.promisified.mutate(mu);
+    public mutate(mu: messages.Mutation, options?: grpc.CallOptions | null): Promise<messages.Assigned> {
+        return this.promisified.mutate(mu, undefined, options);
     }
 
-    public commitOrAbort(ctx: messages.TxnContext): Promise<messages.TxnContext> {
-        return this.promisified.commitOrAbort(ctx);
+    public commitOrAbort(ctx: messages.TxnContext, options?: grpc.CallOptions | null): Promise<messages.TxnContext> {
+        return this.promisified.commitOrAbort(ctx, undefined, options);
     }
 
-    public checkVersion(check: messages.Check): Promise<messages.Version> {
-        return this.promisified.checkVersion(check);
+    public checkVersion(check: messages.Check, options?: grpc.CallOptions | null): Promise<messages.Version> {
+        return this.promisified.checkVersion(check, undefined, options);
     }
 
     public waitForReady(deadline: grpc.Deadline): Promise<void> {
diff --git a/src/util.ts b/src/util.ts
@@ -49,7 +49,7 @@ export function isConflictError(err: any): boolean { // tslint:disable-line no-a
     return ec.valid && (ec.code === grpc.status.ABORTED || ec.code === grpc.status.FAILED_PRECONDITION);
 }
 
-export function promisify<A, T>(
+export function promisify1<A, T>(
     f: (arg: A, cb: (err?: Error | null, res?: T) => void) => void,
     thisContext?: any, // tslint:disable-line no-any
 ): (arg: A) => Promise<T> {
@@ -65,6 +65,24 @@ export function promisify<A, T>(
     };
 }
 
+export function promisify3<A, B, C, T>(
+    f: (argA: A, argB: B, argC: C, cb: (err?: Error | null, res?: T) => void) => void,
+    thisContext?: any, // tslint:disable-line no-any
+): (argA: A, argB: B, argC: C) => Promise<T> {
+    return (argA: A, argB: B, argC: C) => {
+        // tslint:disable-next-line no-any
+        return new Promise((resolve: (value?: T | PromiseLike<T>) => void, reject: (reason?: any) => void): void => {
+            f.call(
+                thisContext,
+                argA,
+                argB,
+                argC,
+                (err?: Error | null, result?: T): void => (err != null) ? reject(err) : resolve(result),
+            );
+        });
+    };
+}
+
 export function stringifyMessage(msg: jspb.Message): string {
     return JSON.stringify(msg.toObject());
 }
diff --git a/tests/clientStub.spec.ts b/tests/clientStub.spec.ts
@@ -1,3 +1,5 @@
+import * as grpc from "grpc";
+
 import * as dgraph from "../src";
 
 import { SERVER_ADDR, SERVER_CREDENTIALS, setup } from "./helper";
@@ -24,6 +26,19 @@ describe("clientStub", () => {
         });
     });
 
+    describe("checkVersion with call options", () => {
+        it("should check version with call options", async () => {
+            const clientStub = new dgraph.DgraphClientStub(SERVER_ADDR, SERVER_CREDENTIALS);
+            const p = clientStub.checkVersion(new dgraph.Check(), {
+                deadline: 0,
+                propagate_flags: grpc.propagate.DEFAULTS,
+                credentials: null,
+            });
+
+            await expect(p).rejects.toBeDefined();
+        });
+    });
+
     describe("waitForReady", () => {
         it("should provide a promisified version of grpc.Client#waitForReady", async () => {
             const clientStub = new dgraph.DgraphClientStub(SERVER_ADDR, SERVER_CREDENTIALS);
diff --git a/tests/util.spec.ts b/tests/util.spec.ts
@@ -2,15 +2,20 @@ import * as grpc from "grpc";
 
 import * as dgraph from "../src";
 // Non-exported functions.
-import { isAbortedError, isBase64, isConflictError, mergeLinReads, promisify } from "../src/util";
+import { isAbortedError, isBase64, isConflictError, mergeLinReads, promisify1, promisify3 } from "../src/util";
 
 import { areLinReadsEqual, createLinRead } from "./helper";
 
-function fnAddThisVal(a: number, cb: (err?: Error | null, res?: number) => void): void {
+function fnAddThisVal1(a: number, cb: (err?: Error | null, res?: number) => void): void {
     // tslint:disable-next-line no-invalid-this
     cb(null, (<{ val: number }>this).val + a);
 }
 
+function fnAddThisVal3(a: number, b: number, c: number, cb: (err?: Error | null, res?: number) => void): void {
+    // tslint:disable-next-line no-invalid-this
+    cb(null, (<{ val: number }>this).val + a + b + c);
+}
+
 describe("util", () => {
     describe("mergeLinReads", () => {
         it("should merge two differnt linReads", () => {
@@ -70,13 +75,13 @@ describe("util", () => {
         });
     });
 
-    describe("promisify", () => {
+    describe("promisify1", () => {
         it("should handle valid response in callback", async () => {
             const f = (_: number, cb: (err?: Error | null, res?: number) => void) => {
                 cb(null, 2);
             };
 
-            await expect(promisify(f, null)(1)).resolves.toBe(2);
+            await expect(promisify1(f, null)(1)).resolves.toBe(2);
         });
 
         it("should handle error in callback", async () => {
@@ -85,7 +90,7 @@ describe("util", () => {
                 cb(e);
             };
 
-            await expect(promisify(f, null)(1)).rejects.toBe(e);
+            await expect(promisify1(f, null)(1)).rejects.toBe(e);
         });
 
         it("should handle error if valid response is also present in callback", async () => {
@@ -94,23 +99,67 @@ describe("util", () => {
                 cb(e, 2);
             };
 
-            await expect(promisify(f, null)(1)).rejects.toBe(e);
+            await expect(promisify1(f, null)(1)).rejects.toBe(e);
         });
 
         it("should handle callback called without arguments", async () => {
             const f = (_: number, cb: (err?: Error | null, res?: number) => void) => {
                 cb();
             };
 
-            await expect(promisify(f, null)(1)).resolves.toBeUndefined();
+            await expect(promisify1(f, null)(1)).resolves.toBeUndefined();
+        });
+
+        it("should handle thisContext argument", async () => {
+            const o = {
+                val: 45,
+            };
+
+            await expect(promisify1(fnAddThisVal1, o)(5)).resolves.toEqual(50);
+        });
+    });
+
+    describe("promisify3", () => {
+        it("should handle valid response in callback", async () => {
+            const f = (a: number, b: number, c: number, cb: (err?: Error | null, res?: number) => void) => {
+                cb(null, 2);
+            };
+
+            await expect(promisify3(f, null)(1, 2, 3)).resolves.toBe(2);
+        });
+
+        it("should handle error in callback", async () => {
+            const e = new Error();
+            const f = (a: number , b: number, c: number, cb: (err?: Error | null, res?: number) => void) => {
+                cb(e);
+            };
+
+            await expect(promisify3(f, null)(1, 2, 3)).rejects.toBe(e);
+        });
+
+        it("should handle error if valid response is also present in callback", async () => {
+            const e = new Error();
+            const f = (a: number, b: number, c: number, cb: (err?: Error | null, res?: number) => void) => {
+                cb(e, 2);
+            };
+
+            await expect(promisify3(f, null)(1, 2, 3)).rejects.toBe(e);
+        });
+
+        it("should handle callback called without arguments", async () => {
+            const f = (a: number, b: number, c: number, cb: (err?: Error | null, res?: number) => void) => {
+                cb();
+            };
+
+            await expect(promisify3(f, null)(1, 2, 3)).resolves.toBeUndefined();
         });
 
         it("should handle thisContext argument", async () => {
             const o = {
                 val: 45,
             };
 
-            await expect(promisify(fnAddThisVal, o)(5)).resolves.toEqual(50);
+            await expect(promisify3(fnAddThisVal3, o)(5, 10, 15)).resolves.toEqual(75);
         });
     });
 
