@lucaapp/service-utils 5.4.2 → 5.5.0

package/dist/lib/kafka/index.d.ts

@@ -1,3 +1,3 @@
 export { KafkaClient } from './kafkaClient';
 export { KafkaTopic } from './events';
-export type { KafkaEvent, EventPayloadHandler, KafkaConfiguration, } from './types';
+export type { KafkaEvent, GenericKafkaEvent, EventPayloadHandler, GenericEventPayloadHandler, KafkaConfiguration, CustomTopicConfig, } from './types';

package/dist/lib/kafka/kafkaClient.d.ts

@@ -1,13 +1,14 @@
 import { Consumer } from 'kafkajs';
 import { Logger } from 'pino';
 import { ServiceIdentity } from '../serviceIdentity';
-import type { EventPayloadHandler, KafkaConfiguration, KafkaEvent } from './types';
+import type { EventPayloadHandler, GenericEventPayloadHandler, KafkaConfiguration, KafkaEvent, GenericKafkaEvent, CustomTopicConfig } from './types';
 import { KafkaTopic } from './events';
 declare class KafkaClient {
     private readonly environment;
     private readonly kafkaClient;
     private readonly logger;
     private readonly topicSecrets;
+    private readonly customTopics;
     private readonly admin;
     private readonly producer;
     private readonly consumers;
@@ -25,6 +26,26 @@ declare class KafkaClient {
     private ensureTopics;
     consume: <T extends KafkaTopic>(kafkaTopic: T, handler: EventPayloadHandler<T>, fromBeginning?: boolean) => Promise<Consumer>;
     produce: <T extends KafkaTopic>(kafkaTopic: T, key: string, value: KafkaEvent<T>) => Promise<void>;
+    /**
+     * Register a custom topic (not in KafkaTopic enum)
+     * This allows services to define their own topics without modifying service-utils
+     */
+    registerCustomTopic: (config: CustomTopicConfig) => void;
+    /**
+     * Get full topic name for custom topic
+     */
+    private getCustomTopic;
+    /**
+     * Produce message to custom topic
+     */
+    produceCustom: <T = unknown>(topicName: string, key: string, value: GenericKafkaEvent<T>) => Promise<void>;
+    /**
+     * Consume messages from custom topic
+     */
+    consumeCustom: <T = unknown>(topicName: string, handler: GenericEventPayloadHandler<T>, fromBeginning?: boolean) => Promise<Consumer>;
+    private encryptCustomValue;
+    private decryptCustomValue;
+    private parseCustomValue;
     shutdown: () => Promise<void>;
 }
 export { KafkaClient };

package/dist/lib/kafka/kafkaClient.js

@@ -245,6 +245,132 @@ class KafkaClient {
                 throw (0, utils_1.logAndGetError)(this.logger, `Could not produce message for topic=${topic}`, error);
             }
         };
+        /**
+         * Register a custom topic (not in KafkaTopic enum)
+         * This allows services to define their own topics without modifying service-utils
+         */
+        this.registerCustomTopic = (config) => {
+            this.customTopics.set(config.topic, config);
+            this.logger.info({ topic: config.topic, issuer: config.issuer }, 'Registered custom Kafka topic');
+        };
+        /**
+         * Get full topic name for custom topic
+         */
+        this.getCustomTopic = async (topicName) => {
+            const config = this.customTopics.get(topicName);
+            if (!config) {
+                throw (0, utils_1.logAndGetError)(this.logger, `Custom topic ${topicName} not registered. Call registerCustomTopic() first.`);
+            }
+            const topic = `${this.environment}_${config.issuer}_${topicName}`;
+            await this.ensureTopics(topic);
+            return topic;
+        };
+        /**
+         * Produce message to custom topic
+         */
+        this.produceCustom = async (topicName, key, value) => {
+            const topic = await this.getCustomTopic(topicName);
+            const serializedValue = JSON.stringify(value);
+            // For custom topics, encryption is optional (skip if no secret provided)
+            const config = this.customTopics.get(topicName);
+            const encryptedValue = config.secret && this.encryptionEnabled
+                ? await this.encryptCustomValue(config.secret, serializedValue)
+                : serializedValue;
+            const signature = await this.generateSignature(serializedValue);
+            try {
+                const producerRecord = {
+                    topic,
+                    messages: [
+                        {
+                            key,
+                            value: encryptedValue,
+                            headers: { signature },
+                        },
+                    ],
+                };
+                await this.producer.send(producerRecord);
+                this.logger.debug(producerRecord, 'Custom topic record sent');
+                messageProducedSizeCounter
+                    .labels({ topic })
+                    .observe(Buffer.byteLength(encryptedValue));
+            }
+            catch (error) {
+                messageProduceError.labels({ topic }).inc();
+                throw (0, utils_1.logAndGetError)(this.logger, `Could not produce message for custom topic=${topicName}`, error);
+            }
+        };
+        /**
+         * Consume messages from custom topic
+         */
+        this.consumeCustom = async (topicName, handler, fromBeginning = false) => {
+            const topic = await this.getCustomTopic(topicName);
+            const groupId = `${this.environment.valueOf()}_${topicName}_${this.serviceIdentity.identityName}`;
+            try {
+                const consumer = this.kafkaClient.consumer({
+                    groupId,
+                    sessionTimeout: 20000,
+                    heartbeatInterval: 3000,
+                });
+                this.consumers.push(consumer);
+                await consumer.connect();
+                await consumer.subscribe({ topic, fromBeginning });
+                await consumer.run({
+                    autoCommit: true,
+                    eachMessage: async ({ message }) => {
+                        try {
+                            messageConsumedCounter.labels({ topic: topicName, groupId }).inc();
+                            // Decrypt if secret was provided
+                            const config = this.customTopics.get(topicName);
+                            const decryptedValue = config.secret && this.encryptionEnabled
+                                ? await this.decryptCustomValue(config.secret, message.value)
+                                : message.value;
+                            const value = this.parseCustomValue(decryptedValue);
+                            this.logger.debug({
+                                key: message.key?.toString(),
+                                value,
+                                timestamp: message.timestamp,
+                            }, 'Custom topic record received');
+                            try {
+                                await handler({ ...message, value });
+                            }
+                            catch (error) {
+                                throw (0, utils_1.logAndGetError)(this.logger, `Could not consume message for custom topic=${topicName}`, error);
+                            }
+                            messageAcknowledgedCounter
+                                .labels({ topic: topicName, groupId })
+                                .inc();
+                        }
+                        catch (error) {
+                            messageConsumedErrorCounter
+                                .labels({ topic: topicName, groupId })
+                                .inc();
+                            throw error;
+                        }
+                    },
+                });
+                return consumer;
+            }
+            catch (error) {
+                throw (0, utils_1.logAndGetError)(this.logger, `Could not create consumer for custom topic=${topicName}`, error);
+            }
+        };
+        this.encryptCustomValue = async (secret, value) => {
+            const jwe = await new jose.CompactEncrypt(new util_1.TextEncoder().encode(value));
+            jwe.setProtectedHeader({ alg: 'A256GCMKW', enc: 'A256GCM' });
+            return jwe.encrypt(Buffer.from(secret));
+        };
+        this.decryptCustomValue = async (secret, jwe) => {
+            if (!jwe)
+                return null;
+            const { plaintext } = await jose.compactDecrypt(jwe, Buffer.from(secret));
+            return Buffer.from(plaintext);
+        };
+        this.parseCustomValue = (value) => {
+            if (!value) {
+                throw (0, utils_1.logAndGetError)(this.logger, 'Unexpected event format `null`');
+            }
+            return JSON.parse(value.toString());
+        };
         this.shutdown = async () => {
             try {
                 for (const consumer of this.consumers) {
@@ -269,6 +395,7 @@ class KafkaClient {
         });
         this.serviceIdentity = serviceIdentity;
         this.topicSecrets = topicSecrets;
+        this.customTopics = new Map();
         try {
             this.kafkaClient = new kafkajs_1.Kafka({
                 brokers: [kafkaConfig.broker],

package/dist/lib/kafka/types.d.ts

@@ -1,11 +1,16 @@
 import { KafkaTopic, MessageFormats } from './events';
-import { Environment } from '../serviceIdentity';
+import { Environment, Service } from '../serviceIdentity';
 import { KafkaMessage } from 'kafkajs';
 type KafkaEvent<T extends KafkaTopic> = {
     id: string;
     type: 'create' | 'update' | 'soft-destroy' | 'destroy';
     entity: MessageFormats[T];
 };
+type GenericKafkaEvent<T = unknown> = {
+    id: string;
+    type: 'create' | 'update' | 'soft-destroy' | 'destroy';
+    entity: T;
+};
 type KafkaConfiguration = {
     environment: Environment;
     broker: string;
@@ -18,4 +23,12 @@ type KafkaConfiguration = {
 type EventPayloadHandler<T extends KafkaTopic> = (message: Omit<KafkaMessage, 'value'> & {
     value: KafkaEvent<T>;
 }) => Promise<void>;
-export type { KafkaEvent, KafkaConfiguration, EventPayloadHandler };
+type GenericEventPayloadHandler<T = unknown> = (message: Omit<KafkaMessage, 'value'> & {
+    value: GenericKafkaEvent<T>;
+}) => Promise<void>;
+type CustomTopicConfig = {
+    topic: string;
+    issuer: Service;
+    secret?: string;
+};
+export type { KafkaEvent, GenericKafkaEvent, KafkaConfiguration, EventPayloadHandler, GenericEventPayloadHandler, CustomTopicConfig, };

package/dist/lib/serviceIdentity/index.d.ts

@@ -1,3 +1,4 @@
-export { ServiceIdentity } from './serviceIdentity';
+export { ServiceIdentity, ServiceIdentityError, ServiceIdentityErrorType, } from './serviceIdentity';
+export type { CallServiceOptions } from './serviceIdentity';
 export { Environment } from './environment';
 export { Service } from './service';

package/dist/lib/serviceIdentity/index.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Service = exports.Environment = exports.ServiceIdentity = void 0;
+exports.Service = exports.Environment = exports.ServiceIdentityErrorType = exports.ServiceIdentityError = exports.ServiceIdentity = void 0;
 var serviceIdentity_1 = require("./serviceIdentity");
 Object.defineProperty(exports, "ServiceIdentity", { enumerable: true, get: function () { return serviceIdentity_1.ServiceIdentity; } });
+Object.defineProperty(exports, "ServiceIdentityError", { enumerable: true, get: function () { return serviceIdentity_1.ServiceIdentityError; } });
+Object.defineProperty(exports, "ServiceIdentityErrorType", { enumerable: true, get: function () { return serviceIdentity_1.ServiceIdentityErrorType; } });
 var environment_1 = require("./environment");
 Object.defineProperty(exports, "Environment", { enumerable: true, get: function () { return environment_1.Environment; } });
 var service_1 = require("./service");

package/dist/lib/serviceIdentity/serviceIdentity.d.ts

@@ -18,6 +18,18 @@ export declare class ServiceIdentityError extends Error {
     meta?: object | undefined;
     constructor(type: ServiceIdentityErrorType, message?: string, meta?: object | undefined);
 }
+type HttpMethodWithoutBody = 'GET' | 'HEAD' | 'DELETE' | 'OPTIONS';
+export type CallServiceOptions<M extends HttpMethod = HttpMethod> = M extends HttpMethodWithoutBody ? {
+    data?: never;
+    responseType?: ResponseType;
+    customHeaders?: Record<string, string>;
+    params?: Record<string, string | number | Array<string | number> | undefined>;
+} : {
+    data?: unknown;
+    responseType?: ResponseType;
+    customHeaders?: Record<string, string>;
+    params?: Record<string, string | number | Array<string | number> | undefined>;
+};
 declare class ServiceIdentity {
     readonly identityName: string;
     readonly identityKid: string;
@@ -31,8 +43,12 @@ declare class ServiceIdentity {
     private getJwtVerifyOptions;
     getIdentityPublicKey: () => Promise<jose.KeyLike>;
     getIdentityPrivateKey: () => Promise<jose.KeyLike>;
-    callService: <T>(service: Service, method: HttpMethod, url: string, data?: unknown, responseType?: ResponseType, customHeaders?: Record<string, string>) => Promise<T>;
-    signJWT: (service: string, method: HttpMethod, url: string, data?: unknown) => Promise<string>;
+    callServiceV2<T>(service: Service, method: HttpMethodWithoutBody, url: string, options?: CallServiceOptions<HttpMethodWithoutBody>): Promise<T>;
+    callServiceV2<T>(service: Service, method: HttpMethod, url: string, options?: CallServiceOptions<HttpMethod>): Promise<T>;
+    callService<T>(service: Service, method: HttpMethodWithoutBody, url: string, options?: CallServiceOptions<HttpMethodWithoutBody>): Promise<T>;
+    callService<T>(service: Service, method: HttpMethod, url: string, options?: CallServiceOptions<HttpMethod>): Promise<T>;
+    callService<T>(service: Service, method: HttpMethod, url: string, data?: unknown, responseType?: ResponseType, customHeaders?: Record<string, string>, params?: Record<string, string | number | Array<string | number> | undefined>): Promise<T>;
+    signJWT: (service: string, method: HttpMethod, url: string, data?: unknown, params?: Record<string, string | number | Array<string | number> | undefined>) => Promise<string>;
     verifyJWT: (request: Request, service: string) => Promise<{
         payload: jose.JWTPayload;
     }>;
@@ -46,9 +62,12 @@ declare class ServiceIdentity {
         'x-identity': string;
     }>, z.ZodObject<{
         payload: z.ZodAny;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">, z.ZodUndefined]>>>;
     }, "strip", z.ZodTypeAny, {
+        params?: Record<string, string | number | (string | number)[] | undefined> | undefined;
         payload?: any;
     }, {
+        params?: Record<string, string | number | (string | number)[] | undefined> | undefined;
         payload?: any;
     }>>;
     identityJWKSRoute: RequestHandler;

package/dist/lib/serviceIdentity/serviceIdentity.js

@@ -86,27 +86,12 @@ class ServiceIdentity {
             }
             return this.keyCache.private;
         };
-        this.callService = async (service, method, url, data, responseType, customHeaders) => {
-            const jwt = await this.signJWT(service, method, url, data);
-            const request = {
-                headers: {
-                    [JWT_HEADER_NAME]: jwt,
-                    ...(0, requestTracer_1.getRequestIdHeader)(),
-                    ...customHeaders,
-                },
-                baseURL: `http://${service}:8080/`,
-                url,
-                method,
-                responseType,
-            };
-            const response = await this.axiosClient.request(request);
-            return response.data;
-        };
-        this.signJWT = async (service, method, url, data) => {
+        this.signJWT = async (service, method, url, data, params) => {
             return await new jose.SignJWT({
                 method,
                 url,
                 data,
+                params,
             })
                 .setProtectedHeader({
                 alg: JWT_ALGORITHM,
@@ -141,6 +126,9 @@ class ServiceIdentity {
             if (request.method !== payload.method)
                 throw (0, boom_1.forbidden)(`${request.method} !== ${payload.method}`);
             request.body = payload.data;
+            if (payload.params) {
+                request.query = payload.params;
+            }
             next();
         };
         this.requireServiceIdentityV3 = (...services) => (0, api_1.createMiddleware)({
@@ -148,7 +136,17 @@ class ServiceIdentity {
                 headers: zod_1.z.object({
                     'x-identity': zod_1.z.string().refine(value => validator_1.default.isJWT(value)),
                 }),
-                context: zod_1.z.object({ payload: zod_1.z.any() }),
+                context: zod_1.z.object({
+                    payload: zod_1.z.any(),
+                    params: zod_1.z
+                        .record(zod_1.z.string(), zod_1.z.union([
+                        zod_1.z.string(),
+                        zod_1.z.number(),
+                        zod_1.z.array(zod_1.z.union([zod_1.z.string(), zod_1.z.number()])),
+                        zod_1.z.undefined(),
+                    ]))
+                        .optional(),
+                }),
             },
             responses: [],
             errors: {
@@ -179,7 +177,10 @@ class ServiceIdentity {
             if (method !== payload.method) {
                 throw new ServiceIdentityError(ServiceIdentityErrorType.METHOD_MISMATCH, `${method} !== ${payload.method}`);
             }
-            return next({ payload: payload.data });
+            return next({
+                payload: payload.data,
+                params: payload.params,
+            });
         });
         this.identityJWKSRoute = async (_, response) => {
             response.send(await this.getIdentityJWKS());
@@ -210,5 +211,48 @@ class ServiceIdentity {
             });
         }
     }
+    // Implementation
+    async callServiceV2(service, method, url, options) {
+        const { data, responseType, customHeaders, params } = options || {};
+        // HTTP methods that should not have a request body
+        const methodsWithoutBody = ['GET', 'HEAD', 'DELETE', 'OPTIONS'];
+        const shouldIncludeBody = !methodsWithoutBody.includes(method);
+        const jwt = await this.signJWT(service, method, url, data, params);
+        const request = {
+            headers: {
+                [JWT_HEADER_NAME]: jwt,
+                ...(0, requestTracer_1.getRequestIdHeader)(),
+                ...customHeaders,
+            },
+            baseURL: `http://${service}:8080/`,
+            url,
+            method,
+            responseType,
+            ...(params ? { params } : {}),
+            ...(data && shouldIncludeBody ? { data } : {}),
+        };
+        const response = await this.axiosClient.request(request);
+        return response.data;
+    }
+    // Implementation
+    async callService(service, method, url, dataOrOptions, responseType, customHeaders, params) {
+        // Check if using new options object pattern
+        if (dataOrOptions &&
+            typeof dataOrOptions === 'object' &&
+            ('data' in dataOrOptions ||
+                'responseType' in dataOrOptions ||
+                'customHeaders' in dataOrOptions ||
+                'params' in dataOrOptions)) {
+            // Delegate to V2 with options object
+            return this.callServiceV2(service, method, url, dataOrOptions);
+        }
+        // Old positional parameters pattern - delegate to V2
+        return this.callServiceV2(service, method, url, {
+            data: dataOrOptions,
+            responseType,
+            customHeaders,
+            params,
+        });
+    }
 }
 exports.ServiceIdentity = ServiceIdentity;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lucaapp/service-utils",
-  "version": "5.4.2",
+  "version": "5.5.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
@@ -81,5 +81,8 @@
     "vite-tsconfig-paths": "4.3.2",
     "vitest": "3.2.4"
   },
-  "resolutions": {}
+  "resolutions": {
+    "tar": "^7.5.7",
+    "lodash": "^4.17.23"
+  }
 }