akeyless-server-commons 1.0.203 → 1.0.205

package/dist/helpers/time_helpers.js

@@ -0,0 +1,167 @@
+import { Timestamp } from "firebase-admin/firestore";
+import moment from "moment";
+export function sort_by_timestamp(a, b, reverse = false) {
+    return reverse ? any_datetime_to_millis(b) - any_datetime_to_millis(a) : any_datetime_to_millis(a) - any_datetime_to_millis(b);
+}
+export const calculate_time_passed = (datetime) => {
+    const now = new Date();
+    const diff_in_milliseconds = Math.max(0, now.getTime() - datetime.getTime());
+    const seconds_passed = Math.floor(diff_in_milliseconds / 1000);
+    const minutes_passed = Math.floor(seconds_passed / 60);
+    const hours_passed = Math.floor(minutes_passed / 60);
+    const days_passed = Math.floor(hours_passed / 24);
+    const remaining_hours = hours_passed % 24;
+    const remaining_minutes = minutes_passed % 60;
+    const remaining_seconds = seconds_passed % 60;
+    const pad_zero = (value) => (value < 10 ? `0${value}` : `${value}`);
+    let parts = [];
+    if (days_passed > 0)
+        parts.push(days_passed);
+    if (remaining_hours > 0 || days_passed > 0)
+        parts.push(pad_zero(remaining_hours));
+    parts.push(pad_zero(remaining_minutes));
+    parts.push(pad_zero(remaining_seconds));
+    const time_passed_formatted_short = parts.join(":");
+    parts = [];
+    if (days_passed > 0)
+        parts.push(`${days_passed} d`);
+    if (days_passed > 0 || remaining_hours > 0)
+        parts.push(`${remaining_hours} h`);
+    if (days_passed > 0 || remaining_hours > 0 || remaining_minutes > 0)
+        parts.push(`${remaining_minutes} min`);
+    parts.push(`${remaining_seconds} sec`);
+    const time_passed_formatted_long = parts.join(" ");
+    return {
+        seconds_passed,
+        minutes_passed,
+        hours_passed,
+        days_passed,
+        time_passed_formatted_short,
+        time_passed_formatted_long,
+    };
+};
+export function any_datetime_to_string(firebaseTimestamp, options) {
+    const { defaultReturnedValue, format, fromFormat, tz, debug } = {
+        defaultReturnedValue: options?.defaultReturnedValue ?? "-",
+        format: options?.format ?? "DD/MM/YYYY HH:mm:ss",
+        fromFormat: options?.fromFormat ?? "DD/MM/YYYY HH:mm:ss",
+        tz: options?.tz,
+        debug: options?.debug ?? false,
+    };
+    let date;
+    switch (true) {
+        case !firebaseTimestamp: {
+            return defaultReturnedValue;
+        }
+        case firebaseTimestamp instanceof Timestamp: {
+            date = firebaseTimestamp.toDate();
+            break;
+        }
+        case firebaseTimestamp instanceof Date: {
+            date = firebaseTimestamp;
+            break;
+        }
+        case typeof firebaseTimestamp === "string" || typeof firebaseTimestamp === "number": {
+            const m = moment.utc(firebaseTimestamp, fromFormat);
+            switch (m.isValid()) {
+                case true:
+                    date = m.toDate();
+                    break;
+                default:
+                    return defaultReturnedValue;
+            }
+            break;
+        }
+        case !!firebaseTimestamp._seconds: {
+            const ft = firebaseTimestamp;
+            date = new Date(ft._seconds * 1000 + (ft._nanoseconds ?? 0) / 1000000);
+            break;
+        }
+        case !!firebaseTimestamp.seconds: {
+            const ft = firebaseTimestamp;
+            date = new Date(ft.seconds * 1000 + ft.nanoseconds / 1000000);
+            break;
+        }
+        default: {
+            if (debug) {
+                console.error("Invalid timestamp format: ", firebaseTimestamp);
+            }
+            return defaultReturnedValue;
+        }
+    }
+    switch (Boolean(tz)) {
+        case true:
+            return moment(date)
+                .tz(tz)
+                .format(format);
+        default:
+            return moment.utc(date).format(format);
+    }
+}
+export function any_datetime_to_millis(firebaseTimestamp, options) {
+    const { defaultReturnedValue, fromFormat, tz, debug } = {
+        defaultReturnedValue: options?.defaultReturnedValue ?? 0,
+        fromFormat: options?.fromFormat ?? "DD/MM/YYYY HH:mm:ss",
+        tz: options?.tz,
+        debug: options?.debug ?? false,
+    };
+    switch (true) {
+        case !firebaseTimestamp: {
+            return defaultReturnedValue;
+        }
+        case firebaseTimestamp instanceof Timestamp: {
+            return firebaseTimestamp.toMillis();
+        }
+        case firebaseTimestamp instanceof Date: {
+            const ms = firebaseTimestamp.getTime();
+            return isNaN(ms) ? defaultReturnedValue : ms;
+        }
+        case typeof firebaseTimestamp === "string" || typeof firebaseTimestamp === "number": {
+            const m = moment.utc(firebaseTimestamp, fromFormat);
+            switch (m.isValid()) {
+                case true:
+                    return m.valueOf();
+                default:
+                    return defaultReturnedValue;
+            }
+        }
+        case !!firebaseTimestamp._seconds: {
+            const seconds = firebaseTimestamp._seconds;
+            const nanos = firebaseTimestamp._nanoseconds ?? 0;
+            return seconds * 1000 + Math.floor(nanos / 1000000);
+        }
+        case !!firebaseTimestamp.seconds: {
+            const seconds = firebaseTimestamp.seconds;
+            const nanos = firebaseTimestamp.nanoseconds ?? 0;
+            return seconds * 1000 + Math.floor(nanos / 1000000);
+        }
+        default: {
+            if (debug) {
+                console.error("Invalid timestamp format: ", firebaseTimestamp);
+            }
+            return defaultReturnedValue;
+        }
+    }
+}
+// old versions of the functions kept for backward compatibility
+/**
+ * Converts a Firebase Timestamp object into a formatted string.
+ *
+ * @param {firebase_timestamp} firebaseTimestamp - The Firebase timestamp object containing _seconds and _nanoseconds.
+ * @param {string} [format="DD-MM-YYYY HH:mm:ss"] - Optional the format string used to format the date. Default is "DD-MM-YYYY HH:mm:ss".
+ * @returns {string} - A formatted date string according to the specified format or the default format.
+ */
+export function timestamp_to_string(firebaseTimestamp, format = "DD-MM-YYYY HH:mm:ss") {
+    const timestamp = new Timestamp(firebaseTimestamp._seconds, firebaseTimestamp._nanoseconds);
+    return moment(timestamp.toDate()).utc().format(format);
+}
+/**
+ * Converts a Firebase Timestamp object into milliseconds since the Unix epoch.
+ *
+ * @param {firebase_timestamp} firebaseTimestamp - The Firebase timestamp object containing _seconds and _nanoseconds.
+ * @returns {number} - Time in milliseconds
+ */
+export function timestamp_to_millis(firebaseTimestamp) {
+    const timestamp = new Timestamp(firebaseTimestamp._seconds, firebaseTimestamp._nanoseconds);
+    return timestamp.toMillis();
+}

package/dist/index.js

@@ -0,0 +1,5 @@
+import * as helpers from "./helpers";
+import * as managers from "./managers";
+import * as middlewares from "./middlewares";
+import * as types from "./types";
+export { helpers, managers, middlewares, types };

package/dist/managers/cache_manager.js

@@ -0,0 +1,37 @@
+export class CacheManager {
+    static instance;
+    data = {};
+    constructor() { }
+    static getInstance() {
+        if (!CacheManager.instance) {
+            CacheManager.instance = new CacheManager();
+        }
+        return CacheManager.instance;
+    }
+    setArrayData(key, data) {
+        this.data[key] = data;
+    }
+    getArrayData(key) {
+        if (!this.data[key]) {
+            return [];
+        }
+        return this.data[key];
+    }
+    setObjectData(key, data) {
+        this.data[key] = data;
+    }
+    getObjectData(key, default_value = null) {
+        return this.data[key] || default_value;
+    }
+    getObjectDataAsArray(key, default_value = []) {
+        const value = this.data[key];
+        if (!value) {
+            return default_value;
+        }
+        if (Array.isArray(value)) {
+            return value;
+        }
+        return Object.values(value);
+    }
+}
+export const cache_manager = CacheManager.getInstance();

package/dist/managers/index.js

@@ -0,0 +1,4 @@
+export * from "./cache_manager";
+export * from "./translation_manager";
+export * from "./logger_manager";
+export * from "./rabbitmq_manager";

package/dist/managers/logger_manager.js

@@ -0,0 +1,68 @@
+import moment_timezone from "moment-timezone";
+import axios from "axios";
+import { isObject } from "lodash";
+import { parse_error } from "../helpers";
+class LoggerManager {
+    static instance;
+    constructor() { }
+    static getInstance() {
+        if (!LoggerManager.instance) {
+            LoggerManager.instance = new LoggerManager();
+        }
+        return LoggerManager.instance;
+    }
+    get_date() {
+        return moment_timezone().tz("Asia/Jerusalem").format("DD/MM/YYYY HH:mm:ss.SS");
+    }
+    is_gcp() {
+        return !!(process.env.KUBERNETES_SERVICE_HOST || process.env.K_SERVICE);
+    }
+    emit(severity, text) {
+        if (this.is_gcp()) {
+            // GCP: structured JSON on stdout so Cloud Logging reads `severity`, not the stream
+            console.log(JSON.stringify({ severity, message: text }));
+            return;
+        }
+        const method = severity === "ERROR" ? console.error : severity === "WARNING" ? console.warn : console.log;
+        method(text);
+    }
+    log(msg, data) {
+        const is_table = !process.env.KUBERNETES_SERVICE_HOST &&
+            Array.isArray(data) &&
+            data.length > 1 &&
+            data.every((val) => {
+                if (typeof val === "object" && !Array.isArray(val)) {
+                    return Object.values(val).every((v) => ["string", "number", "boolean"].includes(typeof v) || v === null);
+                }
+                return false;
+            }) &&
+            data.some((val) => Object.values(val).length > 1);
+        if (is_table) {
+            console.log(`${this.get_date()} - `, msg, ": ");
+            console.table(data);
+            return;
+        }
+        const text = `${this.get_date()} - ${msg}${data === undefined ? "" : `: ${isObject(data) || Array.isArray(data) ? JSON.stringify(data) : data}`}`;
+        this.emit("INFO", text);
+    }
+    error(msg, data) {
+        let text;
+        if (axios.isAxiosError(data)) {
+            if (!!data.response?.data) {
+                text = `${this.get_date()} - ${msg}, axios error: ${data.message}, data: ${JSON.stringify(data)}`;
+            }
+            else {
+                text = `${this.get_date()} - ${msg}, axios error: ${data.message}`;
+            }
+        }
+        else {
+            text = `${this.get_date()} - ${msg}${data === undefined ? "" : `: ${JSON.stringify(parse_error(data))}`}`;
+        }
+        this.emit("ERROR", text);
+    }
+    warn(msg, data) {
+        const text = `${this.get_date()} - ${msg}${data === undefined ? "" : `: ${JSON.stringify(data)}`}`;
+        this.emit("WARNING", text);
+    }
+}
+export const logger = LoggerManager.getInstance();

package/dist/managers/rabbitmq_manager.js

@@ -0,0 +1,182 @@
+import amqp from "amqplib";
+import { randomUUID as random_uuid } from "node:crypto";
+import { logger } from "./logger_manager";
+const SAFE_NAME = /^[A-Za-z0-9_.:-]{1,120}$/;
+/**
+ * JSON event transport backed by durable fanout exchanges and durable queues.
+ *
+ * Each channel name maps to an exchange. Each distinct subscriber name gets a
+ * queue and therefore its own copy of every event. Instances sharing the same
+ * subscriber name compete for work, which supports horizontal scaling.
+ */
+export class RabbitManager {
+    prefetch_count = 10;
+    connection;
+    channel;
+    connecting;
+    constructor() {
+        if (!(process.env.RABBITMQ_URL ?? "")) {
+            logger.warn("Missing ENV parameter RABBITMQ_URL");
+        }
+    }
+    async connect() {
+        if (this.connection && this.channel)
+            return;
+        this.connecting ??= this.open_connection().finally(() => {
+            this.connecting = undefined;
+        });
+        await this.connecting;
+    }
+    async close() {
+        const channel = this.channel;
+        const connection = this.connection;
+        this.channel = undefined;
+        this.connection = undefined;
+        if (channel)
+            await channel.close().catch(() => undefined);
+        if (connection)
+            await connection.close().catch(() => undefined);
+    }
+    async push_event(channel_name, payload, options = {}) {
+        const channel = await this.declare_exchange(channel_name);
+        const { ttl_seconds, headers = {} } = options;
+        if (ttl_seconds !== undefined && (!Number.isFinite(ttl_seconds) || ttl_seconds <= 0)) {
+            throw new Error("ttl_seconds must be a finite number greater than zero");
+        }
+        let encoded;
+        try {
+            encoded = JSON.stringify(payload);
+        }
+        catch (error) {
+            throw new Error("payload must be JSON serializable", { cause: error });
+        }
+        if (encoded === undefined)
+            throw new Error("payload must be JSON serializable");
+        const event_id = random_uuid();
+        const created_at = new Date().toISOString();
+        channel.publish(channel_name, "", Buffer.from(encoded, "utf8"), {
+            contentType: "application/json",
+            contentEncoding: "utf-8",
+            persistent: true,
+            messageId: event_id,
+            timestamp: Math.floor(Date.now() / 1_000),
+            ...(ttl_seconds === undefined ? {} : { expiration: String(Math.round(ttl_seconds * 1_000)) }),
+            headers: { created_at, ...headers },
+        });
+        await channel.waitForConfirms();
+        return event_id;
+    }
+    subscriptions = [];
+    async subscribe_for_channel(channel_name, subscriber_name, handler, options = {}) {
+        const { channel, queue_name } = await this.declare_subscription(channel_name, subscriber_name);
+        const requeue_on_error = options.requeue_on_error ?? true;
+        const reply = await channel.consume(queue_name, (message) => {
+            if (!message)
+                return;
+            void this.handle_message(channel, message, handler, requeue_on_error);
+        }, { noAck: false });
+        const subscription = {
+            queue_name,
+            consumer_tag: reply.consumerTag,
+            cancel: async () => {
+                await channel.cancel(reply.consumerTag);
+            },
+        };
+        this.subscriptions.push(subscription);
+        return subscription;
+    }
+    async cancel_subscriptions() {
+        await Promise.all(this.subscriptions.map((subscription) => subscription.cancel()));
+    }
+    async pull_and_delete(channel_name, subscriber_name) {
+        const { channel, queue_name } = await this.declare_subscription(channel_name, subscriber_name);
+        const message = await channel.get(queue_name, { noAck: false });
+        if (!message)
+            return undefined;
+        const event = this.to_event(message);
+        channel.ack(message);
+        return event;
+    }
+    /**
+     * Diagnostic peek implemented as get + nack + requeue.
+     * It is not a reliable queue browser: the same event can repeat or move.
+     */
+    async pull_and_leave(channel_name, subscriber_name) {
+        const { channel, queue_name } = await this.declare_subscription(channel_name, subscriber_name);
+        const message = await channel.get(queue_name, { noAck: false });
+        if (!message)
+            return undefined;
+        const event = this.to_event(message);
+        channel.nack(message, false, true);
+        return event;
+    }
+    async open_connection() {
+        if (!(process.env.RABBITMQ_URL ?? "")) {
+            return;
+        }
+        const connection_url = new URL(process.env.RABBITMQ_URL);
+        if (!connection_url.searchParams.has("heartbeat")) {
+            connection_url.searchParams.set("heartbeat", "30");
+        }
+        const connection = await amqp.connect(connection_url.toString(), { timeout: 30_000 });
+        const channel = await connection.createConfirmChannel();
+        await channel.prefetch(this.prefetch_count);
+        this.connection = connection;
+        this.channel = channel;
+    }
+    async get_channel() {
+        await this.connect();
+        if (!this.channel)
+            throw new Error("RabbitMQ channel is not available");
+        return this.channel;
+    }
+    async declare_exchange(channel_name) {
+        this.validate_name(channel_name, "channel_name");
+        const channel = await this.get_channel();
+        await channel.assertExchange(channel_name, "fanout", { durable: true });
+        return channel;
+    }
+    async declare_subscription(channel_name, subscriber_name) {
+        this.validate_name(channel_name, "channel_name");
+        this.validate_name(subscriber_name, "subscriber_name");
+        const channel = await this.declare_exchange(channel_name);
+        const queue_name = `${channel_name}.${subscriber_name}`;
+        await channel.assertQueue(queue_name, { durable: true });
+        await channel.bindQueue(queue_name, channel_name, "");
+        return { channel, queue_name };
+    }
+    async handle_message(channel, message, handler, requeue_on_error) {
+        try {
+            await handler(this.to_event(message));
+            channel.ack(message);
+        }
+        catch (error) {
+            console.error(`RabbitMQ handler failed for ${message.properties.messageId ?? "unknown"}`, error);
+            channel.nack(message, false, requeue_on_error);
+        }
+    }
+    to_event(message) {
+        let body;
+        try {
+            body = JSON.parse(message.content.toString("utf8"));
+        }
+        catch (error) {
+            throw new Error("received a message that is not valid JSON", { cause: error });
+        }
+        const headers = { ...message.properties.headers };
+        const created_at = headers.created_at;
+        return {
+            body,
+            redelivered: message.fields.redelivered,
+            headers,
+            ...(message.properties.messageId ? { event_id: message.properties.messageId } : {}),
+            ...(typeof created_at === "string" ? { created_at } : {}),
+        };
+    }
+    validate_name(value, parameter) {
+        if (!SAFE_NAME.test(value)) {
+            throw new Error(`${parameter} must be 1-120 characters using letters, digits, _, ., :, or -`);
+        }
+    }
+}
+export const rabbitmq = new RabbitManager();

package/dist/managers/translation_manager.js

@@ -0,0 +1,38 @@
+export class TranslationManager {
+    static instance;
+    data = {};
+    constructor() { }
+    static getInstance() {
+        if (!TranslationManager.instance) {
+            TranslationManager.instance = new TranslationManager();
+        }
+        return TranslationManager.instance;
+    }
+    setTranslationData(data) {
+        this.data = data;
+    }
+    getTranslationData() {
+        return this.data;
+    }
+    get_translation(scope, lang, entity, key) {
+        key = entity + (entity === "" ? "" : "__") + key;
+        return this.data[scope][lang][key] || key;
+    }
+    get_sms(lang, entity, key) {
+        try {
+            return this.data["sms"][lang][entity + "__" + key];
+        }
+        catch (error) {
+            return "N/A";
+        }
+    }
+    get_email(lang, entity, key) {
+        try {
+            return this.data["email"][lang][entity + "__" + key];
+        }
+        catch (error) {
+            return "N/A";
+        }
+    }
+}
+export const translation_manager = TranslationManager.getInstance();

package/dist/middlewares/auth_mw.js

@@ -0,0 +1,50 @@
+import { verify_token, json_failed, query_document_optional, get_user_by_identifier } from "../helpers";
+import { logger } from "../managers";
+export const verify_user_auth = async (req, res, next) => {
+    try {
+        const user = await verify_token(req.headers.authorization);
+        req.body.firebase_user = user;
+        next();
+    }
+    catch (error) {
+        logger.error("error from verify user auth", error);
+        res.status(403).send(json_failed(error));
+    }
+};
+export const nx_user_login = async (req, res, next) => {
+    try {
+        const authorization = req.headers.authorization;
+        const user_data = await verify_token(authorization);
+        const { phone_number, email } = user_data;
+        if (!phone_number && !email) {
+            throw "Invalid authorization token";
+        }
+        const nx_user = await get_user_by_identifier(phone_number || email);
+        if (!nx_user) {
+            throw `No user found with phone number: ${phone_number} or email: ${email}.`;
+        }
+        const full_name = `${nx_user.first_name || ""} ${nx_user.last_name || ""}`.trim();
+        req.body.user = { ...nx_user, full_name };
+        next();
+    }
+    catch (error) {
+        res.status(403).send(json_failed(error));
+    }
+};
+export const client_login = async (req, res, next) => {
+    try {
+        const token = req.headers.authorization;
+        if (!token) {
+            throw new Error("Authorization token not found.");
+        }
+        const client_data = (await query_document_optional("nx-clients", "api_token", "==", token));
+        if (!client_data) {
+            throw new Error(`No client found with token: ${token} .`);
+        }
+        req.body.client = client_data;
+        next();
+    }
+    catch (error) {
+        res.status(403).send(json_failed(error.message || error));
+    }
+};

package/dist/middlewares/error_handling.js

@@ -0,0 +1,20 @@
+import { logger } from "../managers";
+/**
+ * Utility to handle async errors
+ */
+const async_error_handler = (service) => {
+    return (req, res, next) => {
+        Promise.resolve(service(req, res)).catch(next);
+    };
+};
+/**
+ * Global error-handling middleware.
+ */
+const error_handler = (err, req, res, next) => {
+    logger.error("Global Error Handler:", err.stack);
+    res.status(500).json({
+        status: "error",
+        message: err.message || "Internal Server Error",
+    });
+};
+export { error_handler, async_error_handler };