@lucaapp/service-utils 5.4.1 → 5.5.0

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

@@ -1,8 +1,5 @@
 import type { Model, ModelStatic, Sequelize } from 'sequelize';
 import { DataTypes } from 'sequelize';
-/**
- * Represents a partition table with its timestamp.
- */
 export interface PartitionTable {
     tableName: string;
     timestamp: Date;
@@ -11,137 +8,28 @@ interface AddHistoryOptions {
     exclude?: string[];
 }
 interface AtomicAuditLogOptions {
-    /**
-     * Name of the audit log table.
-     * Default: 'AuditLogs'
-     */
     attributeRevisionModelTableName?: string;
-    /**
-     * Type of the primary key for the tracked models.
-     * Default: DataTypes.INTEGER
-     */
     primaryKeyType?: typeof DataTypes.UUID | typeof DataTypes.INTEGER;
-    /**
-     * Number of partitions to include in the UNION ALL view.
-     * Default: 6 (current table + 5 archives = ~6 weeks of data)
-     */
     viewPartitionCount?: number;
 }
-/**
- * Result of a partition operation.
- */
 export interface PartitionResult {
     archiveTableName: string;
     timestamp: Date;
 }
-/**
- * AtomicAuditLog provides audit logging with atomic revision assignment.
- *
- * This is a drop-in replacement for sequelize-central-log that solves the
- * race condition issue where concurrent updates could result in duplicate
- * revision numbers.
- *
- * Key differences from sequelize-central-log:
- * - Uses PostgreSQL advisory locks to serialize inserts per entity
- * - Calculates revision using MAX(revision)+1 subquery for atomicity
- * - Runs within the same transaction as entity updates (when transaction provided)
- *
- * @example
- * ```typescript
- * const auditLog = new AtomicAuditLog(sequelize, {
- *   attributeRevisionModelTableName: 'StayReservationAuditLogs',
- *   primaryKeyType: DataTypes.UUID,
- * });
- *
- * await auditLog.addHistory(StayReservation, {
- *   exclude: ['primaryGuest'],
- * });
- * ```
- */
 export declare class AtomicAuditLog {
     private sequelize;
     private tableName;
     private primaryKeyType;
     private viewPartitionCount;
     constructor(sequelize: Sequelize, options?: AtomicAuditLogOptions);
-    /**
-     * Gets the table name for this audit log.
-     */
     getTableName(): string;
-    /**
-     * Gets the view name that combines all partitions.
-     */
     getViewName(): string;
-    /**
-     * Adds audit logging hooks to a Sequelize model.
-     *
-     * @param model - The Sequelize model to track
-     * @param options - Configuration options
-     */
     addHistory<T extends Model>(model: ModelStatic<T>, options?: AddHistoryOptions): void;
-    /**
-     * Creates an audit log entry with atomically assigned revision number.
-     */
     private createAuditLogEntry;
-    /**
-     * Creates an audit hook handler for a specific operation.
-     */
     private createAuditHook;
-    /**
-     * Gets the last N partition tables for this audit log.
-     *
-     * Partition tables follow the naming pattern: `{tableName}_{YYYY_MM_DD}T{HH_MM_SS}`
-     *
-     * @param count - Number of partitions to retrieve (default: viewPartitionCount - 1)
-     * @returns Array of partition tables sorted by timestamp descending
-     */
     getLastNPartitionTables(count?: number): Promise<PartitionTable[]>;
-    /**
-     * Partitions the audit log table by creating a new empty table and
-     * archiving the current data.
-     *
-     * This operation:
-     * 1. Creates a new table with the same schema (including indexes/constraints)
-     * 2. Renames the current table to an archive table with timestamp suffix
-     * 3. Renames the new table to the original table name
-     * 4. Recreates the UNION ALL view
-     *
-     * The entire operation runs in a transaction for atomicity.
-     *
-     * @returns The name of the archive table and timestamp
-     * @example
-     * ```typescript
-     * const result = await auditLog.partitionTable();
-     * console.log(`Archived to: ${result.archiveTableName}`);
-     * ```
-     */
     partitionTable(): Promise<PartitionResult>;
-    /**
-     * Recreates the UNION ALL view that combines the current table with archive partitions.
-     *
-     * The view includes:
-     * - The current (active) table
-     * - The last N-1 archive tables (where N = viewPartitionCount)
-     *
-     * Each row includes a `partition_table` column indicating its source.
-     *
-     * @example
-     * ```typescript
-     * await auditLog.recreateView();
-     * // Creates view: StayReservationAuditLogs_View
-     * // Combining: StayReservationAuditLogs + last 5 archives
-     * ```
-     */
     recreateView(): Promise<void>;
-    /**
-     * Drops old partition tables beyond the retention count.
-     *
-     * This is useful for cleaning up old audit data while maintaining
-     * the view with recent partitions.
-     *
-     * @param retentionCount - Number of archive partitions to keep (default: viewPartitionCount * 2)
-     * @returns Array of dropped table names
-     */
     dropOldPartitions(retentionCount?: number): Promise<string[]>;
 }
 export {};

package/dist/lib/atomicAuditLog/index.js

@@ -2,9 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AtomicAuditLog = void 0;
 const sequelize_1 = require("sequelize");
-/**
- * Default columns to exclude from audit logging.
- */
 const DEFAULT_EXCLUDE = [
     'id',
     'uuid',
@@ -60,30 +57,6 @@ const computeDiff = (instance, operation, exclude) => {
     }
     return computeUpdateDiff(instance, previousValues, currentValues, excludeSet);
 };
-/**
- * AtomicAuditLog provides audit logging with atomic revision assignment.
- *
- * This is a drop-in replacement for sequelize-central-log that solves the
- * race condition issue where concurrent updates could result in duplicate
- * revision numbers.
- *
- * Key differences from sequelize-central-log:
- * - Uses PostgreSQL advisory locks to serialize inserts per entity
- * - Calculates revision using MAX(revision)+1 subquery for atomicity
- * - Runs within the same transaction as entity updates (when transaction provided)
- *
- * @example
- * ```typescript
- * const auditLog = new AtomicAuditLog(sequelize, {
- *   attributeRevisionModelTableName: 'StayReservationAuditLogs',
- *   primaryKeyType: DataTypes.UUID,
- * });
- *
- * await auditLog.addHistory(StayReservation, {
- *   exclude: ['primaryGuest'],
- * });
- * ```
- */
 class AtomicAuditLog {
     constructor(sequelize, options = {}) {
         this.sequelize = sequelize;
@@ -91,24 +64,12 @@ class AtomicAuditLog {
         this.primaryKeyType = options.primaryKeyType ?? sequelize_1.DataTypes.INTEGER;
         this.viewPartitionCount = options.viewPartitionCount ?? 6;
     }
-    /**
-     * Gets the table name for this audit log.
-     */
     getTableName() {
         return this.tableName;
     }
-    /**
-     * Gets the view name that combines all partitions.
-     */
     getViewName() {
         return `${this.tableName}_View`;
     }
-    /**
-     * Adds audit logging hooks to a Sequelize model.
-     *
-     * @param model - The Sequelize model to track
-     * @param options - Configuration options
-     */
     addHistory(model, options = {}) {
         const { exclude = [] } = options;
         const modelName = model.name;
@@ -120,18 +81,16 @@ class AtomicAuditLog {
         model.addHook('afterUpdate', updateHook);
         model.addHook('afterDestroy', destroyHook);
     }
-    /**
-     * Creates an audit log entry with atomically assigned revision number.
-     */
     async createAuditLogEntry(modelId, modelName, operation, diff, transaction) {
-        // Use advisory lock to serialize inserts for the same entity
-        // pg_advisory_xact_lock automatically releases at transaction end
+        const dialect = this.sequelize.getDialect();
+        if (dialect !== 'postgres') {
+            return;
+        }
         const lockKey = `hashtext('${this.tableName}:${modelId}')`;
         await this.sequelize.query(`SELECT pg_advisory_xact_lock(${lockKey})`, {
             transaction,
             type: sequelize_1.QueryTypes.SELECT,
         });
-        // Insert with subquery for atomic revision assignment
         const query = `
       INSERT INTO "${this.tableName}" ("modelId", "model", "operation", "diff", "revision", "createdAt")
       SELECT
@@ -156,9 +115,6 @@ class AtomicAuditLog {
             transaction,
         });
     }
-    /**
-     * Creates an audit hook handler for a specific operation.
-     */
     createAuditHook(modelName, primaryKeyAttribute, exclude, operation) {
         return async (instance, options) => {
             try {
@@ -170,20 +126,11 @@ class AtomicAuditLog {
                 await this.createAuditLogEntry(modelId, modelName, operation, diff, options.transaction);
             }
             catch (error) {
-                // Log error but don't fail the main operation
                 // eslint-disable-next-line no-console
                 console.warn(`Error creating audit log entry for ${modelName}:`, error);
             }
         };
     }
-    /**
-     * Gets the last N partition tables for this audit log.
-     *
-     * Partition tables follow the naming pattern: `{tableName}_{YYYY_MM_DD}T{HH_MM_SS}`
-     *
-     * @param count - Number of partitions to retrieve (default: viewPartitionCount - 1)
-     * @returns Array of partition tables sorted by timestamp descending
-     */
     async getLastNPartitionTables(count) {
         const partitionCount = count ?? this.viewPartitionCount - 1;
         const archiveTables = await this.sequelize.query(`SELECT tablename FROM pg_tables
@@ -200,7 +147,6 @@ class AtomicAuditLog {
             const timestampMatch = table.tablename.match(timestampRegex);
             if (timestampMatch) {
                 const timestampString = timestampMatch[1];
-                // Convert YYYY_MM_DD_HH_MM_SS to YYYY-MM-DD HH:MM:SS
                 const formattedTimestamp = timestampString
                     .replaceAll('_', '-')
                     .replace(/^(\d{4}-\d{2}-\d{2})-(\d{2})-(\d{2})-(\d{2})$/, '$1 $2:$3:$4');
@@ -217,58 +163,19 @@ class AtomicAuditLog {
             .sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime())
             .slice(0, partitionCount);
     }
-    /**
-     * Partitions the audit log table by creating a new empty table and
-     * archiving the current data.
-     *
-     * This operation:
-     * 1. Creates a new table with the same schema (including indexes/constraints)
-     * 2. Renames the current table to an archive table with timestamp suffix
-     * 3. Renames the new table to the original table name
-     * 4. Recreates the UNION ALL view
-     *
-     * The entire operation runs in a transaction for atomicity.
-     *
-     * @returns The name of the archive table and timestamp
-     * @example
-     * ```typescript
-     * const result = await auditLog.partitionTable();
-     * console.log(`Archived to: ${result.archiveTableName}`);
-     * ```
-     */
     async partitionTable() {
         const now = new Date();
         const timestamp = now.toISOString().replaceAll(/[.:-]/g, '_').slice(0, 19);
         const archiveTableName = `${this.tableName}_${timestamp}`;
         const newTableName = `${this.tableName}_New`;
         await this.sequelize.transaction(async (transaction) => {
-            // Create a new empty table by copying the schema from the existing table
             await this.sequelize.query(`CREATE TABLE "${newTableName}" (LIKE "${this.tableName}" INCLUDING ALL)`, { transaction });
-            // Rename current table to archive
             await this.sequelize.query(`ALTER TABLE "${this.tableName}" RENAME TO "${archiveTableName}"`, { transaction });
-            // Rename new table to original name
             await this.sequelize.query(`ALTER TABLE "${newTableName}" RENAME TO "${this.tableName}"`, { transaction });
         });
-        // Recreate the view to include the new archive
         await this.recreateView();
         return { archiveTableName, timestamp: now };
     }
-    /**
-     * Recreates the UNION ALL view that combines the current table with archive partitions.
-     *
-     * The view includes:
-     * - The current (active) table
-     * - The last N-1 archive tables (where N = viewPartitionCount)
-     *
-     * Each row includes a `partition_table` column indicating its source.
-     *
-     * @example
-     * ```typescript
-     * await auditLog.recreateView();
-     * // Creates view: StayReservationAuditLogs_View
-     * // Combining: StayReservationAuditLogs + last 5 archives
-     * ```
-     */
     async recreateView() {
         const viewName = this.getViewName();
         const archiveTables = await this.getLastNPartitionTables();
@@ -284,20 +191,9 @@ class AtomicAuditLog {
     `;
         await this.sequelize.query(viewQuery, { type: sequelize_1.QueryTypes.RAW });
     }
-    /**
-     * Drops old partition tables beyond the retention count.
-     *
-     * This is useful for cleaning up old audit data while maintaining
-     * the view with recent partitions.
-     *
-     * @param retentionCount - Number of archive partitions to keep (default: viewPartitionCount * 2)
-     * @returns Array of dropped table names
-     */
     async dropOldPartitions(retentionCount) {
         const keepCount = retentionCount ?? this.viewPartitionCount * 2;
-        // Get all partitions (more than we want to keep)
         const allPartitions = await this.getLastNPartitionTables(keepCount + 100);
-        // Tables to drop are those beyond the retention count
         const tablesToDrop = allPartitions.slice(keepCount);
         const droppedTables = [];
         for (const table of tablesToDrop) {

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.1",
+  "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"
+  }
 }