akeyless-server-commons 1.0.187 → 1.0.191

package/dist/helpers/firebase_helpers.js

@@ -0,0 +1,576 @@
+import { performance } from "perf_hooks";
+import firebase_admin from "firebase-admin";
+import { cache_manager, logger, translation_manager } from "../managers";
+import dotenv from "dotenv";
+import { init_env_variables } from "./global_helpers";
+import { Timestamp } from "firebase-admin/firestore";
+import { redis_snapshots_bulk } from "./redis";
+dotenv.config();
+// initial firebase
+const required_env_vars = [
+    "type",
+    "project_id",
+    "private_key_id",
+    "private_key",
+    "client_email",
+    "client_id",
+    "auth_uri",
+    "token_uri",
+    "auth_provider_x509_cert_url",
+    "client_x509_cert_url",
+    "universe_domain",
+];
+const env_data = init_env_variables(required_env_vars);
+export const service_account_firebase = {
+    type: env_data.type,
+    project_id: env_data.project_id,
+    private_key_id: env_data.private_key_id,
+    private_key: env_data.private_key.replace(/\\n/g, "\n"),
+    client_email: env_data.client_email,
+    client_id: env_data.client_id,
+    auth_uri: env_data.auth_uri,
+    token_uri: env_data.token_uri,
+    auth_provider_x509_cert_url: env_data.auth_provider_x509_cert_url,
+    client_x509_cert_url: env_data.client_x509_cert_url,
+    universe_domain: env_data.universe_domain,
+};
+firebase_admin.initializeApp({
+    credential: firebase_admin.credential.cert(service_account_firebase),
+    storageBucket: `${service_account_firebase.project_id}.appspot.com`,
+});
+export const db = firebase_admin.firestore();
+export const messaging = firebase_admin.messaging();
+export const auth = firebase_admin.auth();
+export const storage = firebase_admin.storage();
+/// extract
+export const simple_extract_data = (doc) => {
+    const doc_data = doc.data();
+    return {
+        ...doc_data,
+        id: doc.id,
+    };
+};
+/// documents
+export const get_all_documents = async (collection_path) => {
+    try {
+        const snapshot = await db.collection(collection_path).get();
+        const documents = snapshot.docs.flatMap((doc) => {
+            return simple_extract_data(doc);
+        });
+        return documents;
+    }
+    catch (error) {
+        logger.error("Error fetching documents:", error);
+        throw error;
+    }
+};
+export const query_documents = async (collection_path, field_name, operator, value) => {
+    try {
+        const querySnapshot = await db.collection(collection_path).where(field_name, operator, value).get();
+        const documentsData = querySnapshot.docs;
+        const documents = documentsData.flatMap((doc) => simple_extract_data(doc));
+        return documents;
+    }
+    catch (error) {
+        logger.error(`Error querying documents: ${collection_path} - ${field_name} - ${operator} - ${value} `, error);
+        throw error;
+    }
+};
+export const query_documents_by_conditions = async (collection_path, where_conditions) => {
+    try {
+        let query = db.collection(collection_path);
+        where_conditions.forEach((condition) => {
+            query = query.where(condition.field_name, condition.operator, condition.value);
+        });
+        const querySnapshot = await query.get();
+        const documentsData = querySnapshot.docs;
+        const documents = documentsData.flatMap((doc) => simple_extract_data(doc));
+        return documents;
+    }
+    catch (error) {
+        logger.error(`Error querying documents: ${collection_path} - ${JSON.stringify(where_conditions)} `, error);
+        throw error;
+    }
+};
+export const query_document_by_conditions = async (collection_path, where_conditions, log = true) => {
+    try {
+        let query = db.collection(collection_path);
+        where_conditions.forEach((condition) => {
+            query = query.where(condition.field_name, condition.operator, condition.value);
+        });
+        const querySnapshot = await query.get();
+        const documentsData = querySnapshot.docs;
+        const documents = documentsData.flatMap((doc) => simple_extract_data(doc));
+        if (!documents[0]) {
+            throw "no data returned from DB";
+        }
+        return documents[0];
+    }
+    catch (error) {
+        if (log) {
+            logger.error(`Error querying documents: ${collection_path} - ${JSON.stringify(where_conditions)} `, error);
+        }
+        throw error;
+    }
+};
+/// document
+export const query_document = async (collection_path, field_name, operator, value, ignore_log = false) => {
+    try {
+        const querySnapshot = await db.collection(collection_path).where(field_name, operator, value).get();
+        const documentsData = querySnapshot.docs;
+        const documents = documentsData.flatMap((doc) => simple_extract_data(doc));
+        if (documents.length < 1) {
+            throw `No data to return from: collection: ${collection_path}, field_name: ${field_name}, operator: ${operator}, value:${value}`;
+        }
+        return documents[0];
+    }
+    catch (error) {
+        if (!ignore_log) {
+            logger.error("Error querying document: " + JSON.stringify({ collection_path, field_name, operator, value }), error);
+        }
+        throw error;
+    }
+};
+export const query_document_optional = async (collection_path, field_name, operator, value, ignore_log = true) => {
+    try {
+        const querySnapshot = await db.collection(collection_path).where(field_name, operator, value).get();
+        const documentsData = querySnapshot.docs;
+        const documents = documentsData.flatMap((doc) => simple_extract_data(doc));
+        return documents[0] || null;
+    }
+    catch (error) {
+        if (!ignore_log) {
+            logger.error("Error querying optional document: " + JSON.stringify({ collection_path, field_name, operator, value }), error);
+        }
+        return null;
+    }
+};
+export const get_document_by_id = async (collection_path, doc_id) => {
+    try {
+        const docRef = db.collection(collection_path).doc(doc_id);
+        const doc = await docRef.get();
+        if (!doc.exists) {
+            throw "Document not found, document id: " + doc_id;
+        }
+        return simple_extract_data(doc);
+    }
+    catch (error) {
+        logger.error("error from get_document_by_id", error);
+        throw error;
+    }
+};
+export const get_document_by_id_optional = async (collection_path, doc_id) => {
+    try {
+        const docRef = db.collection(collection_path).doc(doc_id);
+        const doc = await docRef.get();
+        if (!doc.exists) {
+            throw "Document not found, document id: " + doc_id;
+        }
+        return simple_extract_data(doc);
+    }
+    catch (error) {
+        logger.error("error from get_document_by_id_optional", error);
+        return null;
+    }
+};
+export const set_document = async (collection_path, doc_id, data, merge = true) => {
+    try {
+        await db
+            .collection(collection_path)
+            .doc(doc_id)
+            .set({ ...data }, { merge });
+    }
+    catch (error) {
+        logger.error(`failed to create document by id: ${doc_id} in collection: ${collection_path}`, error);
+        throw `failed to create document by id ${doc_id} in collection ${collection_path}`;
+    }
+};
+export const add_document = async (collection_path, data, include_id = false, custom_id) => {
+    try {
+        const new_document = custom_id ? db.collection(collection_path).doc(custom_id) : db.collection(collection_path).doc();
+        const update = include_id ? { ...data, id: new_document.id } : data;
+        await new_document.set(update);
+        return new_document.id;
+    }
+    catch (error) {
+        logger.error(`failed to create document in collection: ${collection_path}`, error);
+        throw `failed to create document in collection ${collection_path}`;
+    }
+};
+export const delete_document = async (collection_path, doc_id) => {
+    try {
+        await db.collection(collection_path).doc(doc_id).delete();
+    }
+    catch (error) {
+        throw `Failed to delete document with id ${doc_id} from collection ${collection_path}`;
+    }
+};
+/// token
+export const verify_token = async (authorization) => {
+    try {
+        if (!authorization) {
+            throw "Authorization token is required";
+        }
+        if (!authorization.toLowerCase().startsWith("bearer")) {
+            throw "Invalid authorization token";
+        }
+        const token = authorization.split(/bearer\s+(.+)/i)[1];
+        if (!token) {
+            throw "validation error: Token not found";
+        }
+        const res = await firebase_admin.auth().verifyIdToken(token);
+        if (!res) {
+            throw "User not found";
+        }
+        return res;
+    }
+    catch (error) {
+        logger.error("error from verify_token", error);
+        throw error;
+    }
+};
+/// parsers
+const parse_add_update_translations = (documents) => {
+    const data = translation_manager.getTranslationData();
+    documents.forEach((doc) => {
+        data[doc.id] = doc;
+        delete data[doc.id].id;
+    });
+    translation_manager.setTranslationData(data);
+};
+const parse_delete_translations = (documents) => {
+    const data = translation_manager.getTranslationData();
+    documents.forEach((doc) => {
+        if (data[doc.id]) {
+            delete data[doc.id];
+        }
+    });
+    translation_manager.setTranslationData(data);
+};
+const parse_add_update_settings = (documents, name_for_cache) => {
+    const data = cache_manager.getObjectData(name_for_cache, {});
+    documents.forEach((doc) => {
+        data[doc.id] = doc;
+    });
+    cache_manager.setObjectData(name_for_cache, data);
+};
+const parse_delete_settings = (documents, name_for_cache) => {
+    const data = cache_manager.getObjectData(name_for_cache, {});
+    documents.forEach((doc) => {
+        if (data[doc.id]) {
+            delete data[doc.id];
+        }
+    });
+    cache_manager.setObjectData(name_for_cache, data);
+};
+export const parse_add_update_as_object = (documents, config) => {
+    const { collection_name, cache_name = collection_name, doc_key_property = "id" } = config;
+    const data = cache_manager.getObjectData(cache_name, {});
+    documents.forEach((doc) => {
+        data[doc[doc_key_property]] = doc;
+    });
+    cache_manager.setObjectData(cache_name, data);
+};
+export const parse_delete_as_object = (documents, config) => {
+    const { collection_name, cache_name = collection_name, doc_key_property = "id" } = config;
+    const data = cache_manager.getObjectData(cache_name, {});
+    documents.forEach((doc) => {
+        if (data[doc[doc_key_property]]) {
+            delete data[doc[doc_key_property]];
+        }
+    });
+    cache_manager.setObjectData(cache_name, data);
+};
+export const parse_add_update_as_array = (documents, config) => {
+    const { on_remove, collection_name, cache_name = collection_name } = config;
+    on_remove?.(documents, config);
+    const existing_array = cache_manager.getArrayData(cache_name);
+    const updated_array = [...existing_array, ...documents];
+    cache_manager.setArrayData(cache_name, updated_array);
+};
+export const parse_delete_as_array = (documents, config) => {
+    const { collection_name, cache_name = collection_name } = config;
+    const existing_array = cache_manager.getArrayData(cache_name);
+    const keys_to_delete = documents.map((doc) => doc.id);
+    const updated_array = existing_array.filter((doc) => !keys_to_delete.includes(doc.id));
+    cache_manager.setArrayData(cache_name, updated_array);
+};
+/// snapshots
+let snapshots_first_time = [];
+export const snapshot = (config) => {
+    const { collection_name, cache_name = collection_name, conditions, debug } = config;
+    return new Promise((resolve) => {
+        let q = db.collection(collection_name);
+        if (conditions) {
+            conditions.forEach((condition) => {
+                const { field_name, operator, value } = condition;
+                q = q.where(field_name, operator, value);
+            });
+        }
+        let attempt = 0;
+        let unsubscribe = null;
+        // 🔒 CRITICAL: prevent startup deadlock
+        let resolved = false;
+        const safe_resolve = () => {
+            if (resolved)
+                return;
+            resolved = true;
+            resolve();
+        };
+        const start = () => {
+            unsubscribe = q.onSnapshot((snapshot) => {
+                if (!snapshots_first_time.includes(cache_name)) {
+                    snapshots_first_time.push(cache_name);
+                    const documents = snapshot.docs.flatMap((doc) => simple_extract_data(doc));
+                    if (debug?.on_first_time) {
+                        logger.log(`${cache_name} => Firebase snapshot on first time: `, debug.on_first_time === "documents" ? documents : { length: documents.length });
+                    }
+                    config.on_first_time?.(documents, config);
+                    config.extra_parsers?.forEach((extra_parser) => {
+                        if (debug?.extra_parsers?.on_first_time) {
+                            logger.log(`${cache_name} => Firebase snapshot extra parsers on first time: `, debug.extra_parsers.on_first_time === "documents" ? documents : { length: documents.length });
+                        }
+                        extra_parser.on_first_time?.(documents, config);
+                    });
+                    safe_resolve(); // ✅ boot can continue
+                    return;
+                }
+                const get_docs_from_snapshot = (action) => {
+                    return snapshot
+                        .docChanges()
+                        .filter((change) => change.type === action)
+                        .map((change) => simple_extract_data(change.doc));
+                };
+                const [added, modified, removed] = [
+                    get_docs_from_snapshot("added"),
+                    get_docs_from_snapshot("modified"),
+                    get_docs_from_snapshot("removed"),
+                ];
+                if (added.length) {
+                    if (debug?.on_add) {
+                        logger.log(`${cache_name} => Firebase snapshot on add: `, added);
+                    }
+                    config.on_add?.(added, config);
+                }
+                if (modified.length) {
+                    if (debug?.on_modify) {
+                        logger.log(`${cache_name} => Firebase snapshot on modify: `, modified);
+                    }
+                    config.on_modify?.(modified, config);
+                }
+                if (removed.length) {
+                    if (debug?.on_remove) {
+                        logger.log(`${cache_name} => Firebase snapshot on remove: `, removed);
+                    }
+                    config.on_remove?.(removed, config);
+                }
+                config.extra_parsers?.forEach((extra_parser) => {
+                    if (added.length) {
+                        if (debug?.extra_parsers?.on_add) {
+                            logger.log(`${cache_name} => Firebase snapshot extra parsers on add: `, added);
+                        }
+                        extra_parser.on_add?.(added, config);
+                    }
+                    if (modified.length) {
+                        if (debug?.extra_parsers?.on_modify) {
+                            logger.log(`${cache_name} => Firebase snapshot extra parsers on modify: `, modified);
+                        }
+                        extra_parser.on_modify?.(modified, config);
+                    }
+                    if (removed.length) {
+                        if (debug?.extra_parsers?.on_remove) {
+                            logger.log(`${cache_name} => Firebase snapshot extra parsers on remove: `, removed);
+                        }
+                        extra_parser.on_remove?.(removed, config);
+                    }
+                });
+            }, (error) => {
+                logger.error(`Error listening to collection: ${config.collection_name}`, error);
+                // 🚑 DO NOT BLOCK BOOT
+                safe_resolve();
+                try {
+                    unsubscribe?.();
+                }
+                catch { }
+                unsubscribe = null;
+                const delay_ms = Math.min(30000, 500 * 2 ** attempt++);
+                setTimeout(() => {
+                    start();
+                }, delay_ms);
+            });
+        };
+        start();
+    });
+};
+export const init_snapshots = async (options) => {
+    const { subscription_type = "firebase", debug } = options || {};
+    await snapshot_bulk_by_names([
+        "nx-settings",
+        "settings",
+        {
+            collection_name: "nx-translations",
+            extra_parsers: [
+                {
+                    on_first_time: parse_add_update_translations,
+                    on_add: parse_add_update_translations,
+                    on_modify: parse_add_update_translations,
+                    on_remove: parse_delete_translations,
+                },
+            ],
+        },
+    ], {
+        subscription_type,
+        debug,
+        parse_as: "object",
+        label: "Common snapshots",
+    });
+};
+export const snapshot_bulk = async (snapshots, label) => {
+    const start = performance.now();
+    logger.log(`==> ${label || "custom snapshots"} started... `);
+    await Promise.all(snapshots);
+    logger.log(`==> ${label || "custom snapshots"} ended. It took ${(performance.now() - start).toFixed(2)} ms`);
+};
+const get_default_parsers_as_array = () => {
+    return {
+        on_first_time: parse_add_update_as_array,
+        on_add: parse_add_update_as_array,
+        on_modify: parse_add_update_as_array,
+        on_remove: parse_delete_as_array,
+    };
+};
+const get_default_parsers_as_object = () => {
+    return {
+        on_first_time: parse_add_update_as_object,
+        on_add: parse_add_update_as_object,
+        on_modify: parse_add_update_as_object,
+        on_remove: parse_delete_as_object,
+    };
+};
+export const get_default_parsers = (parse_as) => {
+    if (parse_as === "array") {
+        return get_default_parsers_as_array();
+    }
+    else {
+        return get_default_parsers_as_object();
+    }
+};
+export const snapshot_bulk_by_names = async (params, options) => {
+    const { label = "snapshot_bulk_by_names", subscription_type = "firebase", debug, parse_as = "array", doc_key_property = "id" } = options || {};
+    const start = performance.now();
+    logger.log(`==> Snapshots ${label} => [${subscription_type}] started... `);
+    const uniq_collections = new Set();
+    const redis_configs = [];
+    const firebase_promises = [];
+    for (const param of params) {
+        const name = typeof param === "string" ? param : param.cache_name || param.collection_name;
+        if (uniq_collections.has(name)) {
+            continue;
+        }
+        uniq_collections.add(name);
+        const config = typeof param === "string"
+            ? {
+                collection_name: param,
+                subscription_type,
+                doc_key_property,
+                debug,
+                ...get_default_parsers(parse_as),
+            }
+            : {
+                collection_name: param.collection_name,
+                extra_parsers: param.extra_parsers,
+                conditions: param.conditions,
+                cache_name: param.cache_name,
+                doc_key_property: param.doc_key_property || doc_key_property,
+                subscription_type: param.subscription_type || subscription_type,
+                debug: param.debug || debug,
+                //   parse_as: param.parse_as,
+                ...get_default_parsers(param.parse_as || parse_as),
+            };
+        if (config.subscription_type === "redis") {
+            redis_configs.push(config);
+        }
+        else {
+            firebase_promises.push(snapshot(config));
+        }
+    }
+    await redis_snapshots_bulk(redis_configs);
+    await Promise.all(firebase_promises);
+    logger.log(`==> Snapshots ${label} => [${subscription_type}] ended. It took ${(performance.now() - start).toFixed(2)} ms`);
+};
+export const add_audit_record = async (action, entity, details, user) => {
+    const data = {
+        action,
+        entity,
+        details,
+        datetime: Timestamp.now(),
+        user: user || null,
+    };
+    try {
+        await db.collection("nx-audit").add(data);
+    }
+    catch (error) {
+        throw { msg: "unable to add audit record", data };
+    }
+};
+export const save_file_in_storage = async (file_path, buffer, options = {}) => {
+    try {
+        const bucket = storage.bucket();
+        const normalized_path = file_path.replace(/^\/+/, "");
+        const file = bucket.file(normalized_path);
+        const metadata = {
+            contentType: options.content_type,
+            cacheControl: options.cache_control,
+            contentDisposition: options.content_disposition,
+        };
+        await file.save(buffer, {
+            metadata,
+            resumable: options.resumable ?? false,
+        });
+        if (options.make_public ?? true) {
+            await file.makePublic();
+        }
+        const [url] = await file.getSignedUrl({
+            action: "read",
+            expires: Date.now() + (options.signed_url_ttl_ms ?? 1000 * 60 * 60 * 24 * 7),
+        });
+        return url;
+    }
+    catch (error) {
+        logger.error("error from save_file_in_storage", { error: error?.message || error });
+        throw error;
+    }
+};
+export const get_file_url_from_storage = async (file_path) => {
+    try {
+        const bucket = storage.bucket();
+        const normalized_path = file_path.replace(/^\/+/, "");
+        const file = bucket.file(normalized_path);
+        const [exists] = await file.exists();
+        if (!exists) {
+            throw new Error("file not exist");
+        }
+        const [url] = await file.getSignedUrl({
+            action: "read",
+            expires: Date.now() + 1000 * 60 * 60 * 24 * 7,
+        });
+        return url;
+    }
+    catch (error) {
+        logger.error(`error from get_file_url_from_storage, file_path: ${file_path}`, error);
+        throw error;
+    }
+};
+export const get_nx_settings = async () => {
+    const cache = cache_manager.getObjectData("nx-settings");
+    if (cache) {
+        return cache;
+    }
+    const docs = await get_all_documents("nx-settings");
+    const nx_settings = {};
+    docs.forEach((doc) => {
+        nx_settings[doc.id] = doc;
+    });
+    cache_manager.setObjectData("nx-settings", nx_settings);
+    return nx_settings;
+};