@platformatic/kafka 1.22.0-alpha.2 → 1.22.0

package/dist/clients/base/options.d.ts

@@ -121,6 +121,21 @@ export declare const baseOptionsSchema: {
                         type?: undefined;
                     })[];
                 };
+                oauthBearerExtensions: {
+                    oneOf: ({
+                        type: string;
+                        patternProperties: {
+                            '.+': {
+                                type: string;
+                            };
+                        };
+                        function?: undefined;
+                    } | {
+                        function: boolean;
+                        type?: undefined;
+                        patternProperties?: undefined;
+                    })[];
+                };
                 authBytesValidator: {
                     function: boolean;
                 };

package/dist/clients/base/options.js

@@ -41,6 +41,9 @@ export const baseOptionsSchema = {
                 username: { oneOf: [{ type: 'string' }, { function: true }] },
                 password: { oneOf: [{ type: 'string' }, { function: true }] },
                 token: { oneOf: [{ type: 'string' }, { function: true }] },
+                oauthBearerExtensions: {
+                    oneOf: [{ type: 'object', patternProperties: { '.+': { type: 'string' } } }, { function: true }]
+                },
                 authBytesValidator: { function: true },
                 authenticate: { function: true }
             },

package/dist/network/connection.d.ts

@@ -6,7 +6,7 @@ import { type Callback, type ResponseParser } from '../apis/definitions.ts';
 import { type SASLMechanismValue } from '../apis/enumerations.ts';
 import { type SaslAuthenticateResponse, type SASLAuthenticationAPI } from '../apis/security/sasl-authenticate-v2.ts';
 import { Writer } from '../protocol/writer.ts';
-export type SASLCredentialProvider = () => string | Promise<string>;
+export type SASLCredentialProvider<T = string> = () => T | Promise<T>;
 export interface Broker {
     host: string;
     port: number;
@@ -17,8 +17,9 @@ export interface SASLOptions {
     username?: string | SASLCredentialProvider;
     password?: string | SASLCredentialProvider;
     token?: string | SASLCredentialProvider;
-    authBytesValidator?: (authBytes: Buffer, callback: CallbackWithPromise<Buffer>) => void;
+    oauthBearerExtensions?: Record<string, string> | SASLCredentialProvider<Record<string, string>>;
     authenticate?: SASLCustomAuthenticator;
+    authBytesValidator?: (authBytes: Buffer, callback: CallbackWithPromise<Buffer>) => void;
 }
 export interface ConnectionOptions {
     connectTimeout?: number;

package/dist/network/connection.js

@@ -68,9 +68,11 @@ export class Connection extends EventEmitter {
         this.#socketMustBeDrained = false;
         notifyCreation('connection', this);
     }
+    /* c8 ignore next 3 - Simple getter */
     get host() {
         return this.#status === ConnectionStatuses.CONNECTING || ConnectionStatuses.CONNECTED ? this.#host : undefined;
     }
+    /* c8 ignore next 3 - Simple getter */
     get port() {
         return this.#status === ConnectionStatuses.CONNECTING || ConnectionStatuses.CONNECTED ? this.#port : undefined;
     }
@@ -257,7 +259,7 @@ export class Connection extends EventEmitter {
         if (this.#status === ConnectionStatuses.CONNECTING) {
             this.#status = ConnectionStatuses.AUTHENTICATING;
         }
-        const { mechanism, username, password, token, authenticate } = this.#options.sasl;
+        const { mechanism, username, password, token, oauthBearerExtensions, authenticate } = this.#options.sasl;
         if (!allowedSASLMechanisms.includes(mechanism)) {
             this.#onConnectionError(host, port, diagnosticContext, new UserError(`SASL mechanism ${mechanism} not supported.`));
             return;
@@ -276,7 +278,7 @@ export class Connection extends EventEmitter {
                 saslPlain.authenticate(saslAuthenticateV2.api, this, username, password, callback);
             }
             else if (mechanism === SASLMechanisms.OAUTHBEARER) {
-                saslOAuthBearer.authenticate(saslAuthenticateV2.api, this, token, callback);
+                saslOAuthBearer.authenticate(saslAuthenticateV2.api, this, token, oauthBearerExtensions, callback);
             }
             else if (mechanism === SASLMechanisms.GSSAPI) {
                 callback(new UserError('No custom SASL/GSSAPI authenticator provided.'), undefined);

package/dist/protocol/sasl/oauth-bearer.d.ts

@@ -2,5 +2,5 @@ import { type CallbackWithPromise } from '../../apis/callbacks.ts';
 import { type SASLAuthenticationAPI, type SaslAuthenticateResponse } from '../../apis/security/sasl-authenticate-v2.ts';
 import { type Connection, type SASLCredentialProvider } from '../../network/connection.ts';
 export declare function jwtValidateAuthenticationBytes(authBytes: Buffer, callback: CallbackWithPromise<Buffer>): void;
-export declare function authenticate(authenticateAPI: SASLAuthenticationAPI, connection: Connection, tokenOrProvider: string | SASLCredentialProvider, callback: CallbackWithPromise<SaslAuthenticateResponse>): void;
-export declare function authenticate(authenticateAPI: SASLAuthenticationAPI, connection: Connection, tokenOrProvider: string | SASLCredentialProvider): Promise<SaslAuthenticateResponse>;
+export declare function authenticate(authenticateAPI: SASLAuthenticationAPI, connection: Connection, tokenOrProvider: string | SASLCredentialProvider, extensions: Record<string, string> | SASLCredentialProvider<Record<string, string>>, callback: CallbackWithPromise<SaslAuthenticateResponse>): void;
+export declare function authenticate(authenticateAPI: SASLAuthenticationAPI, connection: Connection, tokenOrProvider: string | SASLCredentialProvider, extensions: Record<string, string> | SASLCredentialProvider<Record<string, string>>): Promise<SaslAuthenticateResponse>;

package/dist/protocol/sasl/oauth-bearer.js

@@ -18,7 +18,7 @@ export function jwtValidateAuthenticationBytes(authBytes, callback) {
     }
     callback(null, authBytes);
 }
-export function authenticate(authenticateAPI, connection, tokenOrProvider, callback) {
+export function authenticate(authenticateAPI, connection, tokenOrProvider, extensionsOrProvider, callback) {
     if (!callback) {
         callback = createPromisifiedCallback();
     }
@@ -27,7 +27,18 @@ export function authenticate(authenticateAPI, connection, tokenOrProvider, callb
             callback(error, undefined);
             return;
         }
-        authenticateAPI(connection, Buffer.from(`n,,\x01auth=Bearer ${token}\x01\x01`), callback);
+        getCredential('SASL/OAUTHBEARER extensions', extensionsOrProvider ?? {}, (error, extensionsMap) => {
+            if (error) {
+                return callback(error, undefined);
+            }
+            let extensions = '';
+            if (extensionsMap) {
+                for (const [key, value] of Object.entries(extensionsMap)) {
+                    extensions += `\x01${key}=${value}`;
+                }
+            }
+            authenticateAPI(connection, Buffer.from(`n,,\x01auth=Bearer ${token}${extensions}\x01\x01`), callback);
+        });
     });
     return callback[kCallbackPromise];
 }

package/dist/protocol/sasl/utils.d.ts

@@ -1,4 +1,4 @@
 import { type CallbackWithPromise } from '../../apis/index.ts';
 import { type SASLCredentialProvider } from '../../network/connection.ts';
-export declare function getCredential(label: string, credentialOrProvider: string | SASLCredentialProvider, callback: CallbackWithPromise<string>): void;
-export declare function getCredential(label: string, credentialOrProvider: string | SASLCredentialProvider): Promise<string>;
+export declare function getCredential<T>(label: string, credentialOrProvider: T | SASLCredentialProvider<T>, callback: CallbackWithPromise<T>): void;
+export declare function getCredential<T>(label: string, credentialOrProvider: T | SASLCredentialProvider<T>): Promise<T>;

package/dist/protocol/sasl/utils.js

@@ -4,33 +4,34 @@ export function getCredential(label, credentialOrProvider, callback) {
     if (!callback) {
         callback = createPromisifiedCallback();
     }
-    if (typeof credentialOrProvider === 'string') {
-        callback(null, credentialOrProvider);
+    if (typeof credentialOrProvider === 'undefined') {
+        callback(new AuthenticationError(`The ${label} should be a value or a function.`), undefined);
         return callback[kCallbackPromise];
     }
     else if (typeof credentialOrProvider !== 'function') {
-        callback(new AuthenticationError(`The ${label} should be a string or a function.`), undefined);
+        callback(null, credentialOrProvider);
         return callback[kCallbackPromise];
     }
     try {
         const credential = credentialOrProvider();
-        if (typeof credential === 'string') {
-            callback(null, credential);
+        if (credential == null) {
+            callback(new AuthenticationError(`The ${label} provider should return a string or a promise that resolves to a value.`), undefined);
             return callback[kCallbackPromise];
         }
         else if (typeof credential?.then !== 'function') {
-            callback(new AuthenticationError(`The ${label} provider should return a string or a promise that resolves to a string.`), undefined);
+            callback(null, credential);
             return callback[kCallbackPromise];
         }
+        ;
         credential
-            .then(token => {
-            if (typeof token !== 'string') {
-                process.nextTick(callback, new AuthenticationError(`The ${label} provider should resolve to a string.`), undefined);
-                return callback[kCallbackPromise];
+            .then((result) => {
+            if (result == null) {
+                process.nextTick(callback, new AuthenticationError(`The ${label} provider should resolve to a value.`), undefined);
+                return;
             }
-            process.nextTick(callback, null, token);
+            process.nextTick(callback, null, result);
         })
-            .catch(error => {
+            .catch((error) => {
             process.nextTick(callback, new AuthenticationError(`The ${label} provider threw an error.`, { cause: error }));
         });
     }

package/dist/version.js

@@ -1,2 +1,2 @@
 export const name = "@platformatic/kafka";
-export const version = "1.22.0-alpha.2";
+export const version = "1.22.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/kafka",
-  "version": "1.22.0-alpha.2",
+  "version": "1.22.0",
   "description": "Modern and performant client for Apache Kafka",
   "homepage": "https://github.com/platformatic/kafka",
   "author": "Platformatic Inc. <oss@platformatic.dev> (https://platformatic.dev)",