@platformatic/kafka 2.5.0 → 2.6.1

package/dist/registries/confluent-schema-registry.d.ts

@@ -1,4 +1,4 @@
-import { type ValidateFunction } from 'ajv';
+import { type Options, type ValidateFunction } from 'ajv';
 import { type Type } from 'avsc';
 import { type Root } from 'protobufjs';
 import { type Callback } from '../apis/definitions.ts';
@@ -20,6 +20,7 @@ export interface ConfluentSchemaRegistryOptions {
     };
     protobufTypeMapper?: ConfluentSchemaRegistryProtobufTypeMapper;
     jsonValidateSend?: boolean;
+    jsonAjvOptions?: Options;
 }
 export interface Schema {
     id: number;

package/dist/registries/confluent-schema-registry.js

@@ -1,7 +1,8 @@
+import { Ajv2020 } from 'ajv/dist/2020.js';
 import avro from 'avsc';
 import { createRequire } from 'node:module';
 import { jsonDeserializer, jsonSerializer, stringDeserializer, stringSerializer } from "../clients/serde.js";
-import { ajv, EMPTY_BUFFER, UnsupportedFormatError, UserError } from "../index.js";
+import { EMPTY_BUFFER, UnsupportedFormatError, UserError } from "../index.js";
 import { getCredential } from "../protocol/sasl/utils.js";
 import { AbstractSchemaRegistry } from "./abstract.js";
 const require = createRequire(import.meta.url);
@@ -10,13 +11,14 @@ export function defaultProtobufTypeMapper(_, type, context) {
     // Confluent Schema Registry convention
     return `${context.topic}-${type}`;
 }
-// TODO(ShogunPanda): Authentication support
 export class ConfluentSchemaRegistry extends AbstractSchemaRegistry {
     #url;
     #schemas;
     #protobufParse;
     #protobufTypeMapper;
     #jsonValidateSend;
+    #jsonAjv;
+    #pendingFetches;
     #auth;
     constructor(options) {
         super();
@@ -24,7 +26,9 @@ export class ConfluentSchemaRegistry extends AbstractSchemaRegistry {
         this.#schemas = new Map();
         this.#protobufTypeMapper = options.protobufTypeMapper ?? defaultProtobufTypeMapper;
         this.#jsonValidateSend = options.jsonValidateSend ?? false;
+        this.#jsonAjv = new Ajv2020({ allErrors: true, coerceTypes: false, strict: true, ...options.jsonAjvOptions });
         this.#auth = options.auth;
+        this.#pendingFetches = new Map();
     }
     getSchemaId(message, type) {
         if (message === null) {
@@ -42,42 +46,15 @@ export class ConfluentSchemaRegistry extends AbstractSchemaRegistry {
         return this.#schemas.get(id);
     }
     async fetchSchema(id, callback) {
+        let fetch = this.#pendingFetches.get(id);
+        if (!fetch) {
+            fetch = this.#fetchSchema(id).finally(() => {
+                this.#pendingFetches.delete(id);
+            });
+            this.#pendingFetches.set(id, fetch);
+        }
         try {
-            const requestInit = {};
-            if (this.#auth) {
-                if (this.#auth.token) {
-                    const token = await getCredential('token', this.#auth.token);
-                    requestInit.headers = {
-                        Authorization: `Bearer ${token}`
-                    };
-                }
-                else {
-                    const username = await getCredential('username', this.#auth.username);
-                    const password = await getCredential('password', this.#auth.password);
-                    requestInit.headers = {
-                        Authorization: `Basic ${Buffer.from(`${username}:${password}`).toString('base64')}`
-                    };
-                }
-            }
-            const response = await fetch(`${this.#url}/schemas/ids/${id}`, requestInit);
-            if (!response.ok) {
-                throw new UserError(`Failed to fetch a schema: [HTTP ${response.status}]`, { response: await response.text() });
-            }
-            const responseBody = (await response.json());
-            const { schema } = responseBody;
-            const schemaType = responseBody.schemaType ?? 'AVRO';
-            switch (schemaType) {
-                case 'AVRO':
-                    this.#schemas.set(id, { id, type: 'avro', schema: avro.Type.forSchema(JSON.parse(schema)) });
-                    break;
-                case 'PROTOBUF':
-                    this.#protobufParse ??= this.#loadProtobuf();
-                    this.#schemas.set(id, { id, type: 'protobuf', schema: this.#protobufParse(schema).root });
-                    break;
-                case 'JSON':
-                    this.#schemas.set(id, { id, type: 'json', schema: ajv.compile(JSON.parse(schema)) });
-                    break;
-            }
+            await fetch;
             process.nextTick(callback);
         }
         catch (err) {
@@ -136,6 +113,43 @@ export class ConfluentSchemaRegistry extends AbstractSchemaRegistry {
             registry.fetchSchema(schemaId, callback);
         };
     }
+    async #fetchSchema(id) {
+        const requestInit = {};
+        if (this.#auth) {
+            if (this.#auth.token) {
+                const token = await getCredential('token', this.#auth.token);
+                requestInit.headers = {
+                    Authorization: `Bearer ${token}`
+                };
+            }
+            else {
+                const username = await getCredential('username', this.#auth.username);
+                const password = await getCredential('password', this.#auth.password);
+                requestInit.headers = {
+                    Authorization: `Basic ${Buffer.from(`${username}:${password}`).toString('base64')}`
+                };
+            }
+        }
+        const response = await fetch(`${this.#url}/schemas/ids/${id}`, requestInit);
+        if (!response.ok) {
+            throw new UserError(`Failed to fetch a schema: [HTTP ${response.status}]`, { response: await response.text() });
+        }
+        const responseBody = (await response.json());
+        const { schema } = responseBody;
+        const schemaType = responseBody.schemaType ?? 'AVRO';
+        switch (schemaType) {
+            case 'AVRO':
+                this.#schemas.set(id, { id, type: 'avro', schema: avro.Type.forSchema(JSON.parse(schema)) });
+                break;
+            case 'PROTOBUF':
+                this.#protobufParse ??= this.#loadProtobuf();
+                this.#schemas.set(id, { id, type: 'protobuf', schema: this.#protobufParse(schema).root });
+                break;
+            case 'JSON':
+                this.#schemas.set(id, { id, type: 'json', schema: this.#jsonAjv.compile(JSON.parse(schema)) });
+                break;
+        }
+    }
     #schemaSerializer(type, fallbackSerializer, data, headers, message) {
         /* c8 ignore next 3 - Hard to test */
         if (typeof data === 'undefined') {
@@ -169,7 +183,7 @@ export class ConfluentSchemaRegistry extends AbstractSchemaRegistry {
                     const validate = schema.schema;
                     const valid = validate(data);
                     if (!valid) {
-                        throw new UserError(`JSON Schema validation failed before serialization: ${ajv.errorsText(validate.errors)}`, { type, data, headers, validationErrors: validate.errors });
+                        throw new UserError(`JSON Schema validation failed before serialization: ${this.#jsonAjv.errorsText(validate.errors)}`, { type, data, headers, validationErrors: validate.errors });
                     }
                 }
                 encodedMessage = Buffer.from(JSON.stringify(data));
@@ -208,7 +222,7 @@ export class ConfluentSchemaRegistry extends AbstractSchemaRegistry {
                 const validate = schema.schema;
                 const valid = validate(parsed);
                 if (!valid) {
-                    throw new UserError(`JSON Schema validation failed before deserialization: ${ajv.errorsText(validate.errors)}`, { type, data: parsed, headers, validationErrors: validate.errors });
+                    throw new UserError(`JSON Schema validation failed before deserialization: ${this.#jsonAjv.errorsText(validate.errors)}`, { type, data: parsed, headers, validationErrors: validate.errors });
                 }
                 return parsed;
             }

package/dist/typescript-4/dist/registries/confluent-schema-registry.d.ts

@@ -1,4 +1,4 @@
-import { type ValidateFunction } from 'ajv';
+import { type Options, type ValidateFunction } from 'ajv';
 import { type Type } from 'avsc';
 import { type Root } from 'protobufjs';
 import { type Callback } from "../apis/definitions";
@@ -20,6 +20,7 @@ export interface ConfluentSchemaRegistryOptions {
   };
   protobufTypeMapper?: ConfluentSchemaRegistryProtobufTypeMapper;
   jsonValidateSend?: boolean;
+  jsonAjvOptions?: Options;
 }
 export interface Schema {
   id: number;

package/dist/version.js

@@ -1,2 +1,2 @@
 export const name = "@platformatic/kafka";
-export const version = "2.5.0";
+export const version = "2.6.1";

package/package.json

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