resolved review comments

Author: shivaji-kharse

README.md

@@ -76,14 +76,15 @@ Valid connection string args:
 | dgraph://foo-bar.grpc.us-west-2.aws.cloud.dgraph.io:443?sslmode=verify-ca&apikey=\<your-api-connection-key\> | Connect to a Dgraph Cloud cluster                                                   |
 | dgraph://foo-bar.grpc.hypermode.com?sslmode=verify-ca&bearertoken=\<some access token\>                      | Connect to a Dgraph cluster protected by a secure gateway                           |
 
-Using the `Open` function with a connection string:
+Using the `open` function with a connection string:
 
 ```js
 // open a connection to an ACL-enabled, non-TLS cluster and login as groot
-const { client, closeStub } = dgraph.Open("dgraph://groot:password@localhost:8090")
+const client = dgraph.open("dgraph://groot:password@localhost:8090")
 // Use the client
 
-closeStub()
+// this will close all the client stubs
+client.close()
 ```
 
 To facilitate debugging, [debug mode](#debug-mode) can be enabled for a client.
@@ -380,14 +381,14 @@ const SERVER_ADDR = "localhost:9080"
 const SERVER_CREDENTIALS = grpc.credentials.createInsecure()
 
 // Create instances of DgraphClient.
-const { client, closeStub } = dgraph.Open("dgraph://groot:password@${SERVER_ADDR}")
+const client = dgraph.open("dgraph://groot:password@${SERVER_ADDR}")
 
 // ...
 // Use dgraphClient
 // ...
 
 // Cleanup resources by closing client stubs.
-closeStub()
+client.close()
 ```
 
 ### Debug mode

examples/simple/index.js

@@ -1,15 +1,5 @@
 const dgraph = require("dgraph-js")
 
-// Create a client stub.
-function newClientStub() {
-  return new dgraph.DgraphClientStub("localhost:9080")
-}
-
-// Create a client.
-function newClient(clientStub) {
-  return new dgraph.DgraphClient(clientStub)
-}
-
 // Drop All - discard all data, schema and start from a clean slate.
 async function dropAll(dgraphClient) {
   const op = new dgraph.Operation()
@@ -125,7 +115,7 @@ async function queryData(dgraphClient) {
 }
 
 async function main() {
-  const { dgraphClient, closeStub } = dgraph.Open()
+  const dgraphClient = dgraph.open()
   await dropAll(dgraphClient)
   await setSchema(dgraphClient)
   await createData(dgraphClient)
@@ -136,7 +126,7 @@ async function main() {
   await queryData(dgraphClient)
 
   // Close the client stub.
-  closeStub()
+  dgraphClient.close()
 }
 
 main()

src/client.ts

@@ -102,6 +102,17 @@ export class DgraphClient {
   public anyClient(): DgraphClientStub {
     return this.clients[Math.floor(Math.random() * this.clients.length)]
   }
+
+  public close(): void {
+    this.clients.forEach((clientStub) => {
+      try {
+        clientStub.close() // Call the close method on each client stub
+        console.log("Closed client stub successfully")
+      } catch (error) {
+        console.error("Failed to close client stub:", error)
+      }
+    })
+  }
 }
 
 // isJwtExpired returns true if the error indicates that the jwt has expired.
@@ -157,9 +168,7 @@ function addBearerTokenToCredentials(
   return grpc.credentials.combineChannelCredentials(baseCreds, metaCreds)
 }
 
-export async function Open(
-  connStr: string,
-): Promise<{ client: DgraphClient; closeStub: () => void }> {
+export async function open(connStr: string): Promise<DgraphClient> {
   const parsedUrl = new URL(connStr)
   if (parsedUrl.protocol !== dgraphScheme) {
     throw new Error("Invalid scheme: must start with dgraph://")
@@ -229,8 +238,5 @@ export async function Open(
     }
   }
 
-  return {
-    client: new DgraphClient(clientStub),
-    closeStub: () => clientStub.close(),
-  }
+  return new DgraphClient(clientStub)
 }

tests/integration/connect.spec.ts

@@ -10,7 +10,7 @@ import { SERVER_ADDR } from "../helper"
 describe("open function", () => {
   it("should connect with authentication and execute a query", async () => {
     const url = `dgraph://groot:password@${SERVER_ADDR}`
-    const { client, closeStub } = await dgraph.Open(url)
+    const client = await dgraph.open(url)
     const query = `
       {
         me(func: uid(1)) {
@@ -25,45 +25,45 @@ describe("open function", () => {
     expect(response).not.toBeNull()
     const parsedJson = response.getJson() // No need for JSON.parse
     expect(parsedJson.me[0].uid).toBe("0x1")
-    closeStub()
+    client.close()
   })
 
   it("should throw an error for invalid scheme", async () => {
     const invalidUrl = `http://${SERVER_ADDR}`
-    await expect(async () => dgraph.Open(invalidUrl)).rejects.toThrowError(
+    await expect(async () => dgraph.open(invalidUrl)).rejects.toThrowError(
       "Invalid scheme: must start with dgraph://",
     )
   })
 
   it("should throw an error for missing hostname", async () => {
     const invalidUrl = `dgraph://:9081`
-    await expect(async () => dgraph.Open(invalidUrl)).rejects.toThrowError("Invalid URL")
+    await expect(async () => dgraph.open(invalidUrl)).rejects.toThrowError("Invalid URL")
   })
 
   it("should throw an error for missing port", async () => {
     const invalidUrl = `dgraph://localhost`
-    await expect(async () => await dgraph.Open(invalidUrl)).rejects.toThrowError(
+    await expect(async () => await dgraph.open(invalidUrl)).rejects.toThrowError(
       "Invalid connection string: port required",
     )
   })
 
   it("should throw an error for username without password", async () => {
     const invalidUrl = `dgraph://groot@${SERVER_ADDR}`
-    await expect(async () => await dgraph.Open(invalidUrl)).rejects.toThrowError(
+    await expect(async () => await dgraph.open(invalidUrl)).rejects.toThrowError(
       "Invalid connection string: password required when username is provided",
     )
   })
 
   it("should throw an error for unsupported sslmode", async () => {
     const invalidUrl = `dgraph://${SERVER_ADDR}?sslmode=invalidsllmode`
-    await expect(async () => await dgraph.Open(invalidUrl)).rejects.toThrowError(
+    await expect(async () => await dgraph.open(invalidUrl)).rejects.toThrowError(
       "Invalid SSL mode: invalidsllmode (must be one of disable, require, verify-ca)",
     )
   })
 
   it("should fail login with invalid credentials", async () => {
     const invalidUrl = `dgraph://groot:wrongpassword@${SERVER_ADDR}`
-    await expect(async () => await dgraph.Open(invalidUrl)).rejects.toThrowError(
+    await expect(async () => await dgraph.open(invalidUrl)).rejects.toThrowError(
       "Failed to sign in user:",
     )
   })