pulsar-client 1.12.0-rc.1 → 1.13.0-rc.2

package/.github/workflows/ci-build-release-napi.yml

@@ -83,7 +83,7 @@ jobs:
           npx node-pre-gyp package --target_arch=${{ matrix.arch }}
 
       - name: Upload artifacts
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
           name: macos-${{matrix.nodejs}}-${{matrix.arch}}
           path: build/stage/*/*.tar.gz
@@ -135,7 +135,7 @@ jobs:
               /pulsar-client-node/pkg/linux/build-napi-inside-docker.sh
 
       - name: Upload artifacts
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
           name: ${{matrix.image}}-${{matrix.nodejs}}-${{matrix.cpu.platform}}
           path: build/stage/*/*.tar.gz
@@ -205,7 +205,7 @@ jobs:
           npx node-pre-gyp package --target_arch=${{ env.TARGET }}
 
       - name: Upload artifacts
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
           name: windows-${{matrix.nodejs}}-${{matrix.arch}}
           path: build/stage/*/*.tar.gz

package/examples/consumer-schema.js

@@ -0,0 +1,66 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+const Pulsar = require('../');
+
+(async () => {
+  // Create a client
+  const client = new Pulsar.Client({
+    serviceUrl: 'pulsar://localhost:6650',
+    operationTimeoutSeconds: 30,
+  });
+
+  const schemaInfo = {
+    schemaType: "Json",
+    schema: JSON.stringify({
+      type: 'record',
+      name: 'Example',
+      namespace: 'test',
+      fields: [
+        {
+          name: 'a',
+          type: 'int',
+        },
+        {
+          name: 'b',
+          type: 'int',
+        },
+      ],
+    }),
+  };
+
+  // Create a consumer
+  const consumer = await client.subscribe({
+    topic: 'persistent://public/default/schema-test',
+    subscription: 'sub1',
+    subscriptionType: 'Shared',
+    ackTimeoutMs: 10000,
+    schema: schemaInfo,
+  });
+
+  // Receive messages
+  for (let i = 0; i < 10; i += 1) {
+    const msg = await consumer.receive();
+    console.log(msg.getData().toString());
+    consumer.acknowledge(msg);
+  }
+
+  await consumer.close();
+  await client.close();
+})();

package/examples/consummer_token_auth.js

@@ -0,0 +1,50 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+const { exit } = require('process');
+const Pulsar = require('../');
+console.log("Starting consumer");
+(async () => {
+
+  const auth = new Pulsar.AuthenticationToken({token: "eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJKb2UifQ.ipevRNuRP6HflG8cFKnmUPtypruRC4fb1DWtoLL62SY"});
+
+  // Create a client
+  const client = new Pulsar.Client({
+    serviceUrl: 'pulsar://localhost:6650',
+    authentication: auth,
+  });
+
+  // Create a consumer
+  const consumer = await client.subscribe({
+    topic: 'persistent://public/default/my-topic',
+    subscription: 'sub1',
+    subscriptionType: 'Shared',
+    ackTimeoutMs: 10000,
+  });
+
+  // Receive messages
+  for (let i = 0; i < 10; i += 1) {
+    const msg = await consumer.receive();
+    console.log(msg.getData().toString());
+    consumer.acknowledge(msg);
+  }
+
+  await consumer.close();
+  await client.close();
+})();

package/examples/consummer_token_auth_supplier.js

@@ -0,0 +1,56 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+const { exit } = require('process');
+const Pulsar = require('..');
+console.log("Starting consumer");
+
+async function getToken() {
+  console.log("Get token");
+  return "eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJKb2UifQ.ipevRNuRP6HflG8cFKnmUPtypruRC4fb1DWtoLL62SY";
+}
+
+(async () => {
+
+  const auth = new Pulsar.AuthenticationToken({token: getToken});
+
+  // Create a client
+  const client = new Pulsar.Client({
+    serviceUrl: 'pulsar://localhost:6650',
+    authentication: auth,
+  });
+
+  // Create a consumer
+  const consumer = await client.subscribe({
+    topic: 'persistent://public/default/my-topic',
+    subscription: 'sub1',
+    subscriptionType: 'Shared',
+    ackTimeoutMs: 10000,
+  });
+
+  // Receive messages
+  for (let i = 0; i < 10; i += 1) {
+    const msg = await consumer.receive();
+    console.log(msg.getData().toString());
+    consumer.acknowledge(msg);
+  }
+
+  await consumer.close();
+  await client.close();
+})();

package/examples/custom_logger.js

@@ -24,10 +24,10 @@ const Pulsar = require('..');
     const client = new Pulsar.Client({
         serviceUrl: 'pulsar://localhost:6650',
         operationTimeoutSeconds: 30,
-    });
-
-    Pulsar.Client.setLogHandler((level, file, line, message) => {
-        console.log('[%s][%s:%d] %s', Pulsar.LogLevel.toString(level), file, line, message);
+        log: (level, file, line, message) => {
+            console.log('[%s][%s:%d] %s', Pulsar.LogLevel.toString(level), file, line, message);
+        },
+        logLevel: Pulsar.LogLevel.DEBUG,
     });
 
     // Create a producer

package/examples/producer-schema.js

@@ -0,0 +1,76 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+const Pulsar = require('../');
+
+(async () => {
+
+  // Create a client
+  const client = new Pulsar.Client({
+    serviceUrl: 'pulsar://localhost:6650',
+    operationTimeoutSeconds: 30,
+  });
+
+  const schemaInfo = {
+    schemaType: "Json",
+    schema: JSON.stringify({
+      type: 'record',
+      name: 'Example',
+      namespace: 'test',
+      fields: [
+        {
+          name: 'a',
+          type: 'int',
+        },
+        {
+          name: 'b',
+          type: 'int',
+        },
+      ],
+    }),
+  };
+
+  const message = {
+    a: 1,
+    b: 2,
+  };
+
+// Create a producer
+  const producer = await client.createProducer({
+    topic: 'persistent://public/default/schema-test',
+    sendTimeoutMs: 30000,
+    batchingEnabled: true,
+    schema: schemaInfo,
+  });
+
+// Send messages
+  for (let i = 0; i < 100; i += 1) {
+    message.a = i;
+    message.b = i * 2;
+    const data = JSON.stringify(message);
+    producer.send({
+      data: Buffer.from(data),
+    });
+    console.log(`Sent message: ${data}`);
+  }
+  await producer.flush();
+
+  await producer.close();
+  await client.close();;
+})();

package/examples/producer_token_auth.js

@@ -0,0 +1,48 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+const Pulsar = require('../');
+
+(async () => {
+  const auth = new Pulsar.AuthenticationToken({token: "eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJKb2UifQ.ipevRNuRP6HflG8cFKnmUPtypruRC4fb1DWtoLL62SY"});
+
+  // Create a client
+  const client = new Pulsar.Client({
+    serviceUrl: 'pulsar://localhost:6650',
+    authentication: auth,
+  });
+
+  // Create a producer
+  const producer = await client.createProducer({
+    topic: 'persistent://public/default/my-topic',
+  });
+
+  // Send messages
+  for (let i = 0; i < 10; i += 1) {
+    const msg = `my-message-${i}`;
+    producer.send({
+      data: Buffer.from(msg),
+    });
+    console.log(`Sent message: ${msg}`);
+  }
+  await producer.flush();
+
+  await producer.close();
+  await client.close();
+})();

package/examples/producer_token_auth_supplier.js

@@ -0,0 +1,53 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+const Pulsar = require('..');
+
+async function getToken() {
+  console.log("Get token");
+  return "eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJKb2UifQ.ipevRNuRP6HflG8cFKnmUPtypruRC4fb1DWtoLL62SY";
+}
+
+(async () => {
+  const auth = new Pulsar.AuthenticationToken({token: getToken});
+
+  // Create a client
+  const client = new Pulsar.Client({
+    serviceUrl: 'pulsar://localhost:6650',
+    authentication: auth,
+  });
+
+  // Create a producer
+  const producer = await client.createProducer({
+    topic: 'persistent://public/default/my-topic',
+  });
+
+  // Send messages
+  for (let i = 0; i < 10; i += 1) {
+    const msg = `my-message-${i}`;
+    producer.send({
+      data: Buffer.from(msg),
+    });
+    console.log(`Sent message: ${msg}`);
+  }
+  await producer.flush();
+
+  await producer.close();
+  await client.close();
+})();

package/index.d.ts

@@ -32,6 +32,7 @@ export interface ClientConfig {
   statsIntervalInSeconds?: number;
   listenerName?: string;
   log?: (level: LogLevel, file: string, line: number, message: string) => void;
+  logLevel?: LogLevel;
 }
 
 export class Client {
@@ -224,7 +225,7 @@ export class AthenzX509Config {
 }
 
 export class AuthenticationToken {
-  constructor(params: { token: string });
+  constructor(params: { token: string | (() => string) | (() => Promise<string>) });
 }
 
 export class AuthenticationOauth2 {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pulsar-client",
-  "version": "1.12.0-rc.1",
+  "version": "1.13.0-rc.2",
   "description": "Pulsar Node.js client",
   "main": "index.js",
   "types": "index.d.ts",

package/pulsar-client-cpp.txt

@@ -1,2 +1,2 @@
-CPP_CLIENT_BASE_URL=https://archive.apache.org/dist/pulsar/pulsar-client-cpp-3.6.0
-CPP_CLIENT_VERSION=3.6.0
+CPP_CLIENT_BASE_URL=https://archive.apache.org/dist/pulsar/pulsar-client-cpp-3.7.0
+CPP_CLIENT_VERSION=3.7.0

package/src/Authentication.cc

@@ -18,6 +18,7 @@
  */
 
 #include "Authentication.h"
+#include <future>
 
 static const std::string PARAM_TLS_CERT = "certificatePath";
 static const std::string PARAM_TLS_KEY = "privateKeyPath";
@@ -25,6 +26,62 @@ static const std::string PARAM_TOKEN = "token";
 static const std::string PARAM_USERNAME = "username";
 static const std::string PARAM_PASSWORD = "password";
 
+void FinalizeTokenSupplierCallback(Napi::Env env, TokenSupplierCallback *cb, void *) { delete cb; }
+
+struct TokenSupplierProxyData {
+  std::function<void(void)> callback;
+  std::string token;
+
+  TokenSupplierProxyData(std::function<void(void)> callback) : callback(callback), token(std::string()) {}
+};
+
+void TokenSupplierProxy(Napi::Env env, Napi::Function jsCallback, TokenSupplierProxyData *data) {
+  Napi::Value ret = jsCallback.Call({});
+  if (ret.IsPromise()) {
+    Napi::Promise promise = ret.As<Napi::Promise>();
+    Napi::Value thenValue = promise.Get("then");
+    if (thenValue.IsFunction()) {
+      Napi::Function then = thenValue.As<Napi::Function>();
+      Napi::Function callback = Napi::Function::New(env, [data](const Napi::CallbackInfo &info) {
+        Napi::Value value = info[0];
+        if (value.IsString()) {
+          data->token = value.ToString().Utf8Value();
+        }
+        data->callback();
+      });
+      then.Call(promise, {callback});
+      return;
+    }
+  }
+  if (ret.IsString()) {
+    data->token = ret.ToString().Utf8Value();
+  }
+  data->callback();
+}
+
+char *TokenSupplier(void *ctx) {
+  TokenSupplierCallback *tokenSupplierCallback = (TokenSupplierCallback *)ctx;
+  if (tokenSupplierCallback->callback.Acquire() != napi_ok) {
+    char *empty = (char *)malloc(0);
+    return empty;
+  }
+
+  std::promise<void> promise;
+  std::future<void> future = promise.get_future();
+
+  std::unique_ptr<TokenSupplierProxyData> dataPtr(
+      new TokenSupplierProxyData([&promise]() { promise.set_value(); }));
+
+  tokenSupplierCallback->callback.BlockingCall(dataPtr.get(), TokenSupplierProxy);
+  tokenSupplierCallback->callback.Release();
+
+  future.wait();
+
+  char *token = (char *)malloc(dataPtr->token.size());
+  strcpy(token, dataPtr->token.c_str());
+  return token;
+}
+
 Napi::FunctionReference Authentication::constructor;
 
 Napi::Object Authentication::Init(Napi::Env env, Napi::Object exports) {
@@ -69,12 +126,28 @@ Authentication::Authentication(const Napi::CallbackInfo &info)
           pulsar_authentication_tls_create(obj.Get(PARAM_TLS_CERT).ToString().Utf8Value().c_str(),
                                            obj.Get(PARAM_TLS_KEY).ToString().Utf8Value().c_str());
     } else if (authMethod == "token") {
-      if (!obj.Has(PARAM_TOKEN) || !obj.Get(PARAM_TOKEN).IsString()) {
-        Napi::Error::New(env, "Missing required parameter").ThrowAsJavaScriptException();
-        return;
+      if (obj.Has(PARAM_TOKEN)) {
+        if (obj.Get(PARAM_TOKEN).IsString()) {
+          this->cAuthentication =
+              pulsar_authentication_token_create(obj.Get(PARAM_TOKEN).ToString().Utf8Value().c_str());
+          return;
+        }
+
+        if (obj.Get(PARAM_TOKEN).IsFunction()) {
+          this->tokenSupplier = new TokenSupplierCallback();
+          Napi::ThreadSafeFunction callback = Napi::ThreadSafeFunction::New(
+              obj.Env(), obj.Get(PARAM_TOKEN).As<Napi::Function>(), "Token Supplier Callback", 1, 1,
+              (void *)NULL, FinalizeTokenSupplierCallback, this->tokenSupplier);
+          this->tokenSupplier->callback = std::move(callback);
+
+          this->cAuthentication =
+              pulsar_authentication_token_create_with_supplier(&TokenSupplier, this->tokenSupplier);
+          return;
+        }
       }
-      this->cAuthentication =
-          pulsar_authentication_token_create(obj.Get(PARAM_TOKEN).ToString().Utf8Value().c_str());
+
+      Napi::Error::New(env, "Missing required parameter").ThrowAsJavaScriptException();
+      return;
     } else if (authMethod == "basic") {
       if (!obj.Has(PARAM_USERNAME) || !obj.Get(PARAM_USERNAME).IsString() || !obj.Has(PARAM_PASSWORD) ||
           !obj.Get(PARAM_PASSWORD).IsString()) {
@@ -105,6 +178,9 @@ Authentication::Authentication(const Napi::CallbackInfo &info)
 }
 
 Authentication::~Authentication() {
+  if (this->tokenSupplier != nullptr) {
+    this->tokenSupplier->callback.Release();
+  }
   if (this->cAuthentication != nullptr) {
     pulsar_authentication_free(this->cAuthentication);
   }

package/src/Authentication.h

@@ -22,6 +22,7 @@
 
 #include <napi.h>
 #include <pulsar/c/authentication.h>
+#include "TokenSupplier.h"
 
 class Authentication : public Napi::ObjectWrap<Authentication> {
  public:
@@ -33,6 +34,8 @@ class Authentication : public Napi::ObjectWrap<Authentication> {
  private:
   static Napi::FunctionReference constructor;
   pulsar_authentication_t *cAuthentication;
+
+  TokenSupplierCallback *tokenSupplier;
 };
 
 #endif

package/src/Client.cc

@@ -40,6 +40,7 @@ static const std::string CFG_TLS_VALIDATE_HOSTNAME = "tlsValidateHostname";
 static const std::string CFG_TLS_ALLOW_INSECURE = "tlsAllowInsecureConnection";
 static const std::string CFG_STATS_INTERVAL = "statsIntervalInSeconds";
 static const std::string CFG_LOG = "log";
+static const std::string CFG_LOG_LEVEL = "logLevel";
 static const std::string CFG_LISTENER_NAME = "listenerName";
 
 LogCallback *Client::logCallback = nullptr;
@@ -107,7 +108,18 @@ Client::Client(const Napi::CallbackInfo &info) : Napi::ObjectWrap<Client>(info)
                                                                        pulsar_client_configuration_free);
 
   // The logger can only be set once per process, so we will take control of it
-  pulsar_client_configuration_set_logger(cClientConfig.get(), &LogMessage, nullptr);
+  if (clientConfig.Has(CFG_LOG_LEVEL) && clientConfig.Get(CFG_LOG_LEVEL).IsNumber()) {
+    int32_t logLevelInt = clientConfig.Get(CFG_LOG_LEVEL).ToNumber().Int32Value();
+    this->logLevel = static_cast<pulsar_logger_level_t>(logLevelInt);
+  }
+  pulsar_logger_t logger;
+  logger.ctx = &this->logLevel;
+  logger.is_enabled = [](pulsar_logger_level_t level, void *ctx) {
+    auto *logLevel = static_cast<pulsar_logger_level_t *>(ctx);
+    return level >= *logLevel;
+  };
+  logger.log = &LogMessage;
+  pulsar_client_configuration_set_logger_t(cClientConfig.get(), logger);
 
   // log config option should be deprecated in favour of static setLogHandler method
   if (clientConfig.Has(CFG_LOG) && clientConfig.Get(CFG_LOG).IsFunction()) {

package/src/Client.h

@@ -53,6 +53,7 @@ class Client : public Napi::ObjectWrap<Client> {
   static Napi::FunctionReference constructor;
   std::shared_ptr<pulsar_client_t> cClient;
   std::shared_ptr<pulsar_client_configuration_t> cClientConfig;
+  pulsar_logger_level_t logLevel = pulsar_logger_level_t::pulsar_INFO;
 
   Napi::Value CreateProducer(const Napi::CallbackInfo &info);
   Napi::Value Subscribe(const Napi::CallbackInfo &info);

package/src/TokenSupplier.h

@@ -0,0 +1,31 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#ifndef PULSAR_CLIENT_NODE_TOKENSUPPLIER_H
+#define PULSAR_CLIENT_NODE_TOKENSUPPLIER_H
+
+#include <napi.h>
+
+struct TokenSupplierCallback {
+  Napi::ThreadSafeFunction callback;
+
+  TokenSupplierCallback() {}
+};
+
+#endif  // PULSAR_CLIENT_NODE_TOKENSUPPLIER_H

package/tests/end_to_end.test.js

@@ -1284,5 +1284,49 @@ const Pulsar = require('../index');
       await consumer.close();
       await client.close();
     });
+
+    test('AuthenticationToken token supplier', async () => {
+      const mockTokenSupplier = jest.fn().mockReturnValue('token');
+      const auth = new Pulsar.AuthenticationToken({
+        token: mockTokenSupplier,
+      });
+      const client = new Pulsar.Client({
+        serviceUrl: 'pulsar://localhost:6650',
+        authentication: auth,
+      });
+
+      // A producer/consumer is needed to triger the callback function
+      const topic = 'persistent://public/default/token-auth';
+      const producer = await client.createProducer({
+        topic,
+      });
+      expect(producer).not.toBeNull();
+      expect(mockTokenSupplier).toHaveBeenCalledTimes(1);
+
+      await producer.close();
+      await client.close();
+    });
+
+    test('AuthenticationToken async token supplier', async () => {
+      const mockTokenSupplier = jest.fn().mockResolvedValue('token');
+      const auth = new Pulsar.AuthenticationToken({
+        token: mockTokenSupplier,
+      });
+      const client = new Pulsar.Client({
+        serviceUrl: 'pulsar://localhost:6650',
+        authentication: auth,
+      });
+
+      // A producer/consumer is needed to triger the callback function
+      const topic = 'persistent://public/default/token-auth';
+      const producer = await client.createProducer({
+        topic,
+      });
+      expect(producer).not.toBeNull();
+      expect(mockTokenSupplier).toHaveBeenCalledTimes(1);
+
+      await producer.close();
+      await client.close();
+    });
   });
 })();

package/tstest.ts

@@ -67,7 +67,9 @@ import Pulsar = require('./index');
   });
 
   const authToken: Pulsar.AuthenticationToken = new Pulsar.AuthenticationToken({
-    token: 'foobar',
+    token: async () => {
+      return 'foobar';
+    },
   });
 
   const authBasic: Pulsar.AuthenticationBasic = new Pulsar.AuthenticationBasic({