akeyless-server-commons 1.0.203 → 1.0.204

package/dist/helpers/tasks_helpers.js

@@ -0,0 +1,139 @@
+import { cache_manager, logger } from "../managers";
+import { get_document_by_id_optional, set_document } from "./firebase_helpers";
+import admin from "firebase-admin";
+export var TaskName;
+(function (TaskName) {
+    TaskName["send_reset_sms"] = "send_reset_sms";
+    TaskName["collect_devices_health"] = "collect_devices_health";
+    TaskName["collect_charge_locations"] = "collect_charge_locations";
+    TaskName["collect_charge_cdrs"] = "collect_charge_cdrs";
+    TaskName["auto_connect_to_call_center"] = "auto_connect_to_call_center";
+    TaskName["make_erm_ev_events"] = "make_erm_ev_events";
+    TaskName["collect_jimi_cars_odometer"] = "collect_jimi_cars_odometer";
+})(TaskName || (TaskName = {}));
+export var TaskStatus;
+(function (TaskStatus) {
+    TaskStatus["running"] = "running";
+    TaskStatus["completed"] = "completed";
+    TaskStatus["failed"] = "failed";
+    TaskStatus["suspeneded"] = "suspeneded";
+})(TaskStatus || (TaskStatus = {}));
+const save_task_data_in_cache = (task_name, data) => {
+    if (Array.isArray(data)) {
+        cache_manager.setArrayData(task_name, data);
+    }
+    else {
+        cache_manager.setObjectData(task_name, data);
+    }
+};
+export const execute_task = async (source, task_name, task, options) => {
+    const { debug_logs = true, save_in } = options || {};
+    try {
+        await set_document("nx-tasks", task_name, {
+            source,
+            status: TaskStatus.running,
+            started: new Date(),
+            timestamp: new Date(),
+            error: "",
+        }, false);
+        if (debug_logs) {
+            logger.log(`Task [${task_name}] started`);
+        }
+        const start = performance.now();
+        const data = await task();
+        const update = {
+            status: TaskStatus.completed,
+            completed: new Date(),
+            timestamp: new Date(),
+        };
+        if (data) {
+            if (save_in === "none") {
+                update.data = "no data to save";
+            }
+            else if (save_in === "storage" && typeof data === "object") {
+                save_task_data_in_cache(task_name, data);
+                const url = await keep_task_data_in_storage(task_name, data);
+                update.data = url;
+            }
+            else {
+                save_task_data_in_cache(task_name, data);
+                update.data = data;
+            }
+        }
+        else {
+            update.data = "no data to save";
+        }
+        await set_document("nx-tasks", task_name, update);
+        if (debug_logs) {
+            logger.log(`Task [${task_name}] ended. It took ${Math.round(performance.now() - start)} ms`);
+        }
+    }
+    catch (exception) {
+        const error_for_db = exception instanceof Error ? exception.message : exception;
+        logger.error(`Task [${task_name}] error`, error_for_db);
+        await set_document("nx-tasks", task_name, {
+            status: TaskStatus.failed,
+            completed: new Date(),
+            timestamp: new Date(),
+            error: error_for_db,
+        });
+    }
+};
+export const get_task_data = async (task_name) => {
+    const cached_data = cache_manager.getArrayData(task_name);
+    const cached_data_object = cache_manager.getObjectData(task_name, null);
+    if (cached_data.length > 0) {
+        return cached_data;
+    }
+    if (cached_data_object) {
+        return cached_data;
+    }
+    const task_data = await get_document_by_id_optional("nx-tasks", task_name);
+    if (typeof task_data?.data === "string" && task_data.data.startsWith("http")) {
+        const storage_data = await get_task_data_from_storage(task_name);
+        if (storage_data) {
+            const value = storage_data;
+            save_task_data_in_cache(task_name, storage_data);
+            return value;
+        }
+    }
+    const value = typeof task_data?.data === "object" ? task_data.data : null;
+    if (value) {
+        save_task_data_in_cache(task_name, value);
+    }
+    return value || [];
+};
+export const get_task_data_from_storage = async (task_name) => {
+    const bucket = admin.storage().bucket();
+    const file = bucket.file(`tasks_data/${task_name}.json`);
+    try {
+        const [contents] = await file.download();
+        return JSON.parse(contents.toString("utf-8"));
+    }
+    catch (error) {
+        logger.error("Task error reading file from Firebase Storage:", error);
+        return null;
+    }
+};
+export const keep_task_data_in_storage = async (task_name, data) => {
+    const bucket = admin.storage().bucket();
+    const file = bucket.file(`tasks_data/${task_name}.json`);
+    try {
+        if (typeof data !== "object") {
+            throw new Error("Only arrays or objects can be written");
+        }
+        const json_string = JSON.stringify(data, null);
+        await file.save(json_string, {
+            contentType: "application/json",
+        });
+        const [signed_url] = await file.getSignedUrl({
+            action: "read",
+            expires: Date.now() + 1000 * 60 * 60 * 24 * 7,
+        });
+        return signed_url;
+    }
+    catch (error) {
+        logger.error("Error writing file to Firebase Storage:", error);
+        return "";
+    }
+};

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,179 @@
+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() {
+        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();