@lucaapp/service-utils 1.0.0 → 1.2.0

package/dist/index.d.ts

@@ -1 +1,2 @@
-export * from './lib/kafka-client';
+export * from './lib/kafka';
+export * from './lib/serviceIdentity';

package/dist/index.js

@@ -14,4 +14,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./lib/kafka-client"), exports);
+__exportStar(require("./lib/kafka"), exports);
+__exportStar(require("./lib/serviceIdentity"), exports);

package/dist/lib/kafka/events/consumer.d.ts

@@ -0,0 +1,8 @@
+declare type Consumer = {
+    uuid: string;
+    username: string;
+    createdAt: Date;
+    updatedAt: Date;
+    deletedAt: Date | null;
+};
+export type { Consumer };

package/dist/lib/kafka/events/consumer.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/kafka/events/operator.d.ts

@@ -0,0 +1,18 @@
+declare type Operator = {
+    uuid: string;
+    firstName: string;
+    lastName: string;
+    email: string;
+    username: string;
+    activated: boolean;
+    phone: string | null;
+    businessEntityName: string | null;
+    businessEntityStreetName: string | null;
+    businessEntityStreetNumber: string | null;
+    businessEntityZipCode: string | null;
+    businessEntityCity: string | null;
+    createdAt: Date;
+    updatedAt: Date;
+    deletedAt: Date | null;
+};
+export type { Operator };

package/dist/lib/kafka/events/operator.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/kafka/events/payment.d.ts

@@ -0,0 +1,29 @@
+declare type Payment = {
+    uuid: string;
+    locationId: string;
+    locationName: string | null;
+    table: string | null;
+    paymentRequestId: string | null;
+    paymentCreatedAt: Date;
+    paidAt: Date | null;
+    paymentVerifier: string;
+    totalAmount: number;
+    invoiceAmount: number;
+    tipAmount: number;
+    fixedFee: number;
+    variableFee: number;
+    rapydPaymentId: string | null;
+    rapydErrorCode: string | null;
+    rapydErrorMessage: string | null;
+    rapydPaymentStatus: 'ACT' | 'CAN' | 'CLO' | 'ERR' | 'EXP' | 'NEW' | 'REV';
+    rapydCustomerId: string | null;
+    payoutId: string | null;
+    statusActiveAt: Date | null;
+    statusCanceledAt: Date | null;
+    statusClosedAt: Date | null;
+    statusErrorAt: Date | null;
+    statusExpiredAt: Date | null;
+    statusNewAt: Date | null;
+    statusReversedAt?: Date | null;
+};
+export type { Payment };

package/dist/lib/kafka/events/payment.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,20 @@
+import type { Payment } from './events/payment';
+import type { Consumer } from './events/consumer';
+import type { Operator } from './events/operator';
+declare enum KafkaTopic {
+    PAYMENTS = "PAYMENTS",
+    CONSUMERS = "CONSUMERS",
+    OPERATORS = "OPERATORS"
+}
+declare type MessageFormats = {
+    [KafkaTopic.PAYMENTS]: Payment;
+    [KafkaTopic.CONSUMERS]: Consumer;
+    [KafkaTopic.OPERATORS]: Operator;
+};
+declare const MessageIssuer: {
+    PAYMENTS: string;
+    CONSUMERS: string;
+    OPERATORS: string;
+};
+export { KafkaTopic, MessageIssuer };
+export type { MessageFormats };

package/dist/lib/kafka/events.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageIssuer = exports.KafkaTopic = void 0;
+var KafkaTopic;
+(function (KafkaTopic) {
+    KafkaTopic["PAYMENTS"] = "PAYMENTS";
+    KafkaTopic["CONSUMERS"] = "CONSUMERS";
+    KafkaTopic["OPERATORS"] = "OPERATORS";
+})(KafkaTopic || (KafkaTopic = {}));
+exports.KafkaTopic = KafkaTopic;
+const MessageIssuer = {
+    [KafkaTopic.PAYMENTS]: 'backend-pay',
+    [KafkaTopic.CONSUMERS]: 'backend',
+    [KafkaTopic.OPERATORS]: 'backend',
+};
+exports.MessageIssuer = MessageIssuer;

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

@@ -0,0 +1,2 @@
+export { KafkaClient } from './kafkaClient';
+export { KafkaTopic } from './events';

package/dist/lib/kafka/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KafkaTopic = exports.KafkaClient = void 0;
+var kafkaClient_1 = require("./kafkaClient");
+Object.defineProperty(exports, "KafkaClient", { enumerable: true, get: function () { return kafkaClient_1.KafkaClient; } });
+var events_1 = require("./events");
+Object.defineProperty(exports, "KafkaTopic", { enumerable: true, get: function () { return events_1.KafkaTopic; } });

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

@@ -0,0 +1,26 @@
+import { Consumer } from 'kafkajs';
+import { Logger } from 'pino';
+import { ServiceIdentity } from '../serviceIdentity';
+import type { EventPayloadHandler, KafkaConfiguration, KafkaEvent, KafkaTopics, KafkaTopicType } from './types';
+declare class KafkaClient {
+    private readonly environment;
+    private readonly kafkaClient;
+    private readonly logger;
+    private readonly topicSecrets;
+    private readonly admin;
+    private readonly producer;
+    private readonly serviceIdentity;
+    constructor(parentLogger: Logger, kafkaConfig: KafkaConfiguration, topicSecrets: Record<KafkaTopics, string | null>, serviceIdentity: ServiceIdentity);
+    connect: () => Promise<void>;
+    private getTopic;
+    private getTopicSecret;
+    private encryptValue;
+    private decryptValue;
+    private generateSignature;
+    private verifySignature;
+    private parseValue;
+    private ensureTopics;
+    consume: <T extends KafkaTopicType>(groupId: string, kafkaTopic: T, handler: EventPayloadHandler<T>, fromBeginning?: boolean) => Promise<Consumer>;
+    produce: <T extends KafkaTopicType>(kafkaTopic: T, key: string, value: KafkaEvent<T>) => Promise<void>;
+}
+export { KafkaClient };

package/dist/lib/kafka/kafkaClient.js

@@ -0,0 +1,200 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KafkaClient = void 0;
+const kafkajs_1 = require("kafkajs");
+const jose = __importStar(require("jose"));
+const util_1 = require("util");
+const serviceIdentity_1 = require("../serviceIdentity");
+const events_1 = require("./events");
+const utils_1 = require("../../utils/utils");
+const KEY_ALG = 'ES256';
+const getIssuer = (kafkaTopic) => {
+    return events_1.MessageIssuer[kafkaTopic].valueOf();
+};
+class KafkaClient {
+    constructor(parentLogger, kafkaConfig, topicSecrets, serviceIdentity) {
+        this.connect = async () => {
+            try {
+                await this.admin.connect();
+                await this.producer.connect();
+            }
+            catch (error) {
+                throw (0, utils_1.logAndGetError)(this.logger, 'Unable to connect kafkaClient', error);
+            }
+        };
+        this.getTopic = async (kafkaTopic) => {
+            const topic = `${this.environment}_${this.serviceIdentity.identityName}_${kafkaTopic}`;
+            await this.ensureTopics(topic);
+            return topic;
+        };
+        this.getTopicSecret = (topic) => {
+            const topicSecret = this.topicSecrets[topic];
+            if (!topicSecret) {
+                throw (0, utils_1.logAndGetError)(this.logger, `No secret present for topic=${topic}`);
+            }
+            return Buffer.from(topicSecret);
+        };
+        this.encryptValue = async (topic, value) => {
+            if (!value) {
+                throw (0, utils_1.logAndGetError)(this.logger, 'Invalid value argument `null | undefined` supplied.');
+            }
+            const jwe = await new jose.CompactEncrypt(new util_1.TextEncoder().encode(value));
+            jwe.setProtectedHeader({ alg: 'A256GCMKW', enc: 'A256GCM' });
+            return jwe.encrypt(this.getTopicSecret(topic));
+        };
+        this.decryptValue = async (topic, jwe) => {
+            if (!jwe) {
+                return null;
+            }
+            const { plaintext } = await jose.compactDecrypt(jwe, this.getTopicSecret(topic));
+            return Buffer.from(plaintext);
+        };
+        this.generateSignature = async (value) => {
+            const privateKey = await this.serviceIdentity.getIdentityPrivateKey();
+            return await new jose.CompactSign(new util_1.TextEncoder().encode(value))
+                .setProtectedHeader({ alg: KEY_ALG })
+                .sign(privateKey);
+        };
+        this.verifySignature = async (kafkaTopic, value, headers) => {
+            if (!headers || !headers.signature) {
+                throw (0, utils_1.logAndGetError)(this.logger, 'Unable to verify signature. Expected header not present');
+            }
+            const issuer = getIssuer(kafkaTopic);
+            const { signature } = headers;
+            const jwks = await this.serviceIdentity.getRemoteJWKS(issuer);
+            if (!jwks) {
+                throw (0, utils_1.logAndGetError)(this.logger, `Unable to find jwks for issuer=${issuer}`);
+            }
+            try {
+                const { payload } = await jose.compactVerify(signature, jwks);
+                if (payload.toString() !== value?.toString()) {
+                    // noinspection ExceptionCaughtLocallyJS
+                    throw (0, utils_1.logAndGetError)(this.logger, `Signed payload does not match signature for event from ${issuer}`);
+                }
+                else {
+                    this.logger.debug('Successfully validated signature');
+                }
+            }
+            catch (error) {
+                throw (0, utils_1.logAndGetError)(this.logger, `Unable to verify signature for event from ${issuer}`, error);
+            }
+        };
+        this.parseValue = (value) => {
+            if (!value) {
+                throw (0, utils_1.logAndGetError)(this.logger, 'Unexpected event format `null`');
+            }
+            return JSON.parse(value.toString());
+        };
+        this.ensureTopics = async (topic) => {
+            const existingTopics = await this.admin.listTopics();
+            if (existingTopics.includes(topic)) {
+                this.logger.debug(`Topic=${topic} already exists. Not creating.`);
+                return;
+            }
+            await this.admin.createTopics({ topics: [{ topic }] });
+            if (this.environment !== serviceIdentity_1.Environment.LOCAL) {
+                await this.admin.createPartitions({
+                    topicPartitions: [{ topic, count: 2 }],
+                });
+            }
+            this.logger.debug(`Topic=${topic} created.`);
+        };
+        this.consume = async (groupId, kafkaTopic, handler, fromBeginning = false) => {
+            const topic = await this.getTopic(kafkaTopic);
+            try {
+                const consumer = this.kafkaClient.consumer({ groupId });
+                await consumer.connect();
+                await consumer.subscribe({ topic, fromBeginning });
+                await consumer.run({
+                    autoCommit: true,
+                    eachMessage: async ({ message }) => {
+                        const decryptedValue = await this.decryptValue(kafkaTopic, message.value);
+                        await this.verifySignature(kafkaTopic, decryptedValue, message.headers);
+                        const value = this.parseValue(decryptedValue);
+                        await handler({ ...message, value });
+                    },
+                });
+                return consumer;
+            }
+            catch (error) {
+                throw (0, utils_1.logAndGetError)(this.logger, `Could not create consumer for groupId=${groupId}, topic=${topic}`, error);
+            }
+        };
+        this.produce = async (kafkaTopic, key, value) => {
+            const topic = await this.getTopic(kafkaTopic);
+            const serializedValue = JSON.stringify(value);
+            const encryptedValue = await this.encryptValue(kafkaTopic, 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, 'Record sent');
+            }
+            catch (error) {
+                throw (0, utils_1.logAndGetError)(this.logger, `Could not create producer for topic=${topic}`, error);
+            }
+        };
+        this.environment = kafkaConfig.environment;
+        this.logger = parentLogger.child({
+            kafkaClientId: kafkaConfig.clientId,
+        });
+        this.serviceIdentity = serviceIdentity;
+        this.topicSecrets = topicSecrets;
+        try {
+            this.kafkaClient = new kafkajs_1.Kafka({
+                brokers: [kafkaConfig.broker],
+                clientId: kafkaConfig.clientId,
+                ...(kafkaConfig?.ssl &&
+                    kafkaConfig.username &&
+                    kafkaConfig.password && {
+                    ssl: {
+                        rejectUnauthorized: false,
+                    },
+                    sasl: {
+                        mechanism: 'plain',
+                        username: kafkaConfig.username,
+                        password: kafkaConfig.password,
+                    },
+                }),
+            });
+            this.admin = this.kafkaClient.admin();
+            this.producer = this.kafkaClient.producer();
+        }
+        catch (error) {
+            throw (0, utils_1.logAndGetError)(this.logger, 'Unable to connect to Kafka', error);
+        }
+    }
+}
+exports.KafkaClient = KafkaClient;

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

@@ -0,0 +1,22 @@
+import { KafkaTopic, MessageFormats } from './events';
+import { Environment } from '../serviceIdentity';
+import { KafkaMessage } from 'kafkajs';
+declare type KafkaTopics = keyof typeof KafkaTopic;
+declare type KafkaTopicType = typeof KafkaTopic[KafkaTopics];
+declare type KafkaEvent<T extends KafkaTopicType> = {
+    id: string;
+    type: 'create' | 'update' | 'destroy';
+    entity: MessageFormats[T];
+};
+declare type KafkaConfiguration = {
+    environment: Environment;
+    broker: string;
+    clientId: string;
+    username?: string;
+    password?: string;
+    ssl?: boolean;
+};
+declare type EventPayloadHandler<T extends KafkaTopicType> = (message: Omit<KafkaMessage, 'value'> & {
+    value: KafkaEvent<T>;
+}) => Promise<void>;
+export type { KafkaTopics, KafkaTopicType, KafkaEvent, KafkaConfiguration, EventPayloadHandler, };

package/dist/lib/kafka/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,19 @@
+declare enum Environment {
+    LOCAL = "LOCAL",
+    DEV = "DEV",
+    QS = "QS",
+    AQS = "AQS",
+    RELEASE = "RELEASE",
+    HOTFIX = "HOTFIX",
+    PENTEST = "PENTEST",
+    P1 = "P1",
+    P2 = "P2",
+    P3 = "P3",
+    P4 = "P4",
+    P5 = "P5",
+    P6 = "P6",
+    DEMO = "DEMO",
+    PREPROD = "PREPROD",
+    PROD = "PROD"
+}
+export { Environment };

package/dist/lib/serviceIdentity/environment.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Environment = void 0;
+var Environment;
+(function (Environment) {
+    Environment["LOCAL"] = "LOCAL";
+    Environment["DEV"] = "DEV";
+    Environment["QS"] = "QS";
+    Environment["AQS"] = "AQS";
+    Environment["RELEASE"] = "RELEASE";
+    Environment["HOTFIX"] = "HOTFIX";
+    Environment["PENTEST"] = "PENTEST";
+    Environment["P1"] = "P1";
+    Environment["P2"] = "P2";
+    Environment["P3"] = "P3";
+    Environment["P4"] = "P4";
+    Environment["P5"] = "P5";
+    Environment["P6"] = "P6";
+    Environment["DEMO"] = "DEMO";
+    Environment["PREPROD"] = "PREPROD";
+    Environment["PROD"] = "PROD";
+})(Environment || (Environment = {}));
+exports.Environment = Environment;

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

@@ -0,0 +1,2 @@
+export { ServiceIdentity } from './serviceIdentity';
+export { Environment } from './environment';

package/dist/lib/serviceIdentity/index.js

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

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

@@ -0,0 +1,23 @@
+import * as jose from 'jose';
+import { HttpMethod } from 'types/http';
+import { Json } from 'types/json';
+import { RequestHandler } from 'express';
+declare class ServiceIdentity {
+    readonly identityName: string;
+    readonly identityKid: string;
+    private readonly identityPrivateKey;
+    private readonly identityPublicKey;
+    private readonly jwksCache;
+    private readonly keyCache;
+    private readonly axiosClient;
+    constructor(identityName: string, identityKid: string, identityPrivateKey: string, identityPublicKey: string);
+    getRemoteJWKS: (service: string) => import("jose/dist/types/types").GetKeyFunction<jose.JWSHeaderParameters, jose.FlattenedJWSInput>;
+    private getJwtVerifyOptions;
+    getIdentityPublicKey: () => Promise<jose.KeyLike>;
+    getIdentityPrivateKey: () => Promise<jose.KeyLike>;
+    callService: <T>(service: string, method: HttpMethod, url: string, data?: Json) => Promise<T>;
+    private getIdentityJWKS;
+    requireServiceIdentity: (service: string) => RequestHandler;
+    identityJWKSRoute: RequestHandler;
+}
+export { ServiceIdentity };

package/dist/lib/serviceIdentity/serviceIdentity.js

@@ -0,0 +1,126 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceIdentity = void 0;
+const jose = __importStar(require("jose"));
+const url_1 = require("url");
+const boom_1 = require("@hapi/boom");
+const moment_1 = __importDefault(require("moment"));
+const axios_1 = __importDefault(require("axios"));
+const JWT_ALGORITHM = 'ES256';
+const JWT_HEADER_NAME = 'X-Identity';
+const JWT_ALLOWED_ALGORITHMS = [JWT_ALGORITHM];
+const JWT_NBF = '0s';
+const JWT_EXP = '1m';
+const JWT_CLOCK_TOLERANCE = moment_1.default.duration(1, 'minute').asSeconds();
+class ServiceIdentity {
+    constructor(identityName, identityKid, identityPrivateKey, identityPublicKey) {
+        this.jwksCache = {};
+        this.keyCache = {};
+        this.getRemoteJWKS = (service) => {
+            if (this.jwksCache[String(service)])
+                return this.jwksCache[String(service)];
+            const jwks = jose.createRemoteJWKSet(new url_1.URL(`http://${service}:8080/identity/jwks`));
+            this.jwksCache[String(service)] = jwks;
+            return jwks;
+        };
+        this.getJwtVerifyOptions = (service) => ({
+            issuer: service,
+            clockTolerance: JWT_CLOCK_TOLERANCE,
+            algorithms: JWT_ALLOWED_ALGORITHMS,
+            audience: this.identityName,
+        });
+        this.getIdentityPublicKey = async () => {
+            if (!this.keyCache.public) {
+                this.keyCache.public = await jose.importSPKI(this.identityPublicKey, JWT_ALGORITHM);
+            }
+            return this.keyCache.public;
+        };
+        this.getIdentityPrivateKey = async () => {
+            if (!this.keyCache.private) {
+                this.keyCache.private = await jose.importPKCS8(this.identityPrivateKey, JWT_ALGORITHM);
+            }
+            return this.keyCache.private;
+        };
+        this.callService = async (service, method, url, data) => {
+            const jwt = await new jose.SignJWT({
+                method,
+                url,
+            })
+                .setProtectedHeader({
+                alg: JWT_ALGORITHM,
+                typ: 'JWT',
+                kid: this.identityKid,
+            })
+                .setIssuer(this.identityName)
+                .setAudience(service)
+                .setIssuedAt()
+                .setNotBefore(JWT_NBF)
+                .setExpirationTime(JWT_EXP)
+                .sign(await this.getIdentityPrivateKey());
+            const request = {
+                headers: {
+                    [JWT_HEADER_NAME]: jwt,
+                },
+                baseURL: `http://${service}:8080/`,
+                url,
+                method,
+                data,
+            };
+            const response = await this.axiosClient.request(request);
+            return response.data;
+        };
+        this.getIdentityJWKS = async () => {
+            const publicKey = await this.getIdentityPublicKey();
+            const jwk = await jose.exportJWK(publicKey);
+            jwk.kid = this.identityKid;
+            return { keys: [jwk] };
+        };
+        this.requireServiceIdentity = (service) => async (request, response, next) => {
+            const jwt = request.header(JWT_HEADER_NAME);
+            if (typeof jwt !== 'string') {
+                throw (0, boom_1.unauthorized)();
+            }
+            const { payload } = await jose.jwtVerify(jwt, this.getRemoteJWKS(service), this.getJwtVerifyOptions(service));
+            if (request.originalUrl !== payload.url)
+                throw (0, boom_1.forbidden)(`${request.originalUrl} !== ${payload.url}`);
+            if (request.method !== payload.method)
+                throw (0, boom_1.forbidden)(`${request.method} !== ${payload.method}`);
+            next();
+        };
+        this.identityJWKSRoute = async (request, response) => {
+            response.send(await this.getIdentityJWKS());
+        };
+        this.identityName = identityName;
+        this.identityKid = identityKid;
+        this.identityPrivateKey = identityPrivateKey;
+        this.identityPublicKey = identityPublicKey;
+        this.axiosClient = axios_1.default.create({ proxy: false });
+    }
+}
+exports.ServiceIdentity = ServiceIdentity;

package/dist/types/http.d.ts

@@ -0,0 +1 @@
+export declare type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'HEAD' | 'PATCH' | 'OPTIONS' | 'TRACE' | 'CONNECT';

package/dist/types/http.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/json.d.ts

@@ -0,0 +1,4 @@
+export declare type Literal = boolean | null | number | string;
+export declare type Json = Literal | {
+    [key: string]: Json;
+} | Json[];

package/dist/types/json.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/utils.d.ts

@@ -0,0 +1,3 @@
+import { Logger } from 'pino';
+declare const logAndGetError: (logger: Logger, message: string, error?: unknown) => Error;
+export { logAndGetError };

package/dist/utils/utils.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logAndGetError = void 0;
+const logAndGetError = (logger, message, error) => {
+    logger.error(error, message);
+    return Error(message);
+};
+exports.logAndGetError = logAndGetError;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lucaapp/service-utils",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
@@ -18,7 +18,9 @@
     "audit": "improved-yarn-audit --ignore-dev-deps"
   },
   "devDependencies": {
+    "@types/express": "4.17.13",
     "@types/jest": "^28.1.5",
+    "@types/pino": "^7.0.5",
     "@typescript-eslint/eslint-plugin": "^5.30.6",
     "@typescript-eslint/parser": "^5.30.6",
     "conventional-changelog-conventionalcommits": "^5.0.0",
@@ -33,6 +35,10 @@
   },
   "dependencies": {
     "@types/express": "4.17.13",
-    "kafkajs": "2.1.0"
+    "@hapi/boom": "^10.0.0",
+    "axios": "^0.27.2",
+    "jose": "4.9.2",
+    "kafkajs": "2.1.0",
+    "moment": "^2.29.4"
   }
 }

package/dist/lib/kafka-client.d.ts

@@ -1,4 +0,0 @@
-import { Message } from 'kafkajs';
-declare const initializeKafkaClient: () => Promise<void>;
-declare const sendKafkaMessage: (message: Message) => Promise<void>;
-export { initializeKafkaClient, sendKafkaMessage };

package/dist/lib/kafka-client.js

@@ -1,36 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sendKafkaMessage = exports.initializeKafkaClient = void 0;
-const kafkajs_1 = require("kafkajs");
-const groupId = 'test-group';
-let producer;
-let consumer;
-const initializeKafkaClient = async () => {
-    const kafka = new kafkajs_1.Kafka({
-        clientId: 'backend',
-        brokers: ['kafka:9092'],
-    });
-    producer = kafka.producer();
-    consumer = kafka.consumer({ groupId });
-    await producer.connect();
-    await consumer.connect();
-    await consumer.subscribe({ topic: groupId, fromBeginning: true });
-    await consumer.run({
-        eachMessage: async ({ topic, partition, message }) => {
-            console.log({
-                topic,
-                partition,
-                offset: message.offset,
-                value: message.value?.toString(),
-            }, 'Message consumed');
-        },
-    });
-};
-exports.initializeKafkaClient = initializeKafkaClient;
-const sendKafkaMessage = async (message) => {
-    await producer.send({
-        topic: groupId,
-        messages: [message],
-    });
-};
-exports.sendKafkaMessage = sendKafkaMessage;