akeyless-server-commons 1.0.206 → 1.0.207

package/dist/helpers/postponed_actions.js

@@ -1,358 +0,0 @@
-import { FieldValue, Timestamp } from "firebase-admin/firestore";
-import { db } from "./firebase_helpers";
-import { logger } from "../managers";
-const POSTPONED_ACTIONS_COLLECTION = "nx-postponed-actions";
-export var PostponedActionStatus;
-(function (PostponedActionStatus) {
-    PostponedActionStatus["pending"] = "pending";
-    PostponedActionStatus["processing"] = "processing";
-    PostponedActionStatus["completed"] = "completed";
-    PostponedActionStatus["cancelled"] = "cancelled";
-    PostponedActionStatus["failed"] = "failed";
-})(PostponedActionStatus || (PostponedActionStatus = {}));
-const get_ref = (key) => {
-    if (!key.trim()) {
-        throw new Error("postponed action key must not be empty");
-    }
-    if (key.includes("/")) {
-        throw new Error("postponed action key must not contain '/'");
-    }
-    return db.collection(POSTPONED_ACTIONS_COLLECTION).doc(key);
-};
-export const resolve_postponed_action_time = (value, now = new Date()) => {
-    if (value instanceof Date || typeof value === "string") {
-        const date = value instanceof Date ? new Date(value.getTime()) : new Date(value);
-        if (!Number.isFinite(date.getTime())) {
-            throw new Error("execute_at must be a valid date");
-        }
-        return date;
-    }
-    const { minutes = 0, hours = 0 } = value;
-    if (!Number.isFinite(minutes) || !Number.isFinite(hours) || minutes < 0 || hours < 0 || minutes + hours <= 0) {
-        throw new Error("relative execute_at must contain positive finite minutes or hours");
-    }
-    return new Date(now.getTime() + (minutes + hours * 60) * 60_000);
-};
-const validate_text = (value, field_name) => {
-    if (!value.trim()) {
-        throw new Error(`postponed action ${field_name} must not be empty`);
-    }
-};
-const validate_details = (details) => {
-    if (!details || Array.isArray(details) || typeof details !== "object") {
-        throw new Error("postponed action details must be a JSON object");
-    }
-    try {
-        JSON.stringify(details, (_key, value) => {
-            if (value === undefined || typeof value === "bigint" || typeof value === "function" || typeof value === "symbol") {
-                throw new Error("unsupported JSON value");
-            }
-            if (typeof value === "number" && !Number.isFinite(value)) {
-                throw new Error("JSON numbers must be finite");
-            }
-            return value;
-        });
-    }
-    catch (error) {
-        throw new Error("postponed action details must be JSON serializable", { cause: error });
-    }
-};
-const timestamp_to_date = (value, field_name) => {
-    if (value instanceof Timestamp)
-        return value.toDate();
-    if (value instanceof Date)
-        return value;
-    throw new Error(`postponed action has invalid ${field_name}`);
-};
-const optional_timestamp_to_date = (value, field_name) => {
-    return value === undefined ? undefined : timestamp_to_date(value, field_name);
-};
-const to_postponed_action = (snapshot) => {
-    const value = snapshot.data();
-    if (!snapshot.exists || !value) {
-        throw new Error(`postponed action '${snapshot.id}' does not exist`);
-    }
-    return {
-        key: snapshot.id,
-        details: value.details,
-        action_type: value.action_type,
-        description: value.description,
-        execute_at: timestamp_to_date(value.execute_at, "execute_at"),
-        status: value.status,
-        attempt_count: typeof value.attempt_count === "number" ? value.attempt_count : 0,
-        created_at: timestamp_to_date(value.created_at, "created_at"),
-        updated_at: timestamp_to_date(value.updated_at, "updated_at"),
-        started_at: optional_timestamp_to_date(value.started_at, "started_at"),
-        completed_at: optional_timestamp_to_date(value.completed_at, "completed_at"),
-        cancelled_at: optional_timestamp_to_date(value.cancelled_at, "cancelled_at"),
-        failed_at: optional_timestamp_to_date(value.failed_at, "failed_at"),
-        error: typeof value.error === "string" ? value.error : undefined,
-    };
-};
-const assert_status = (key, actual, allowed) => {
-    if (!allowed.includes(actual)) {
-        throw new Error(`postponed action '${key}' has status '${String(actual)}'; expected ${allowed.join(" or ")}`);
-    }
-};
-const get_postponed_action_core = async (key) => {
-    const snapshot = await get_ref(key).get();
-    return snapshot.exists ? to_postponed_action(snapshot) : null;
-};
-const add_postponed_action_core = async (input) => {
-    validate_details(input.details);
-    validate_text(input.action_type, "action_type");
-    validate_text(input.description, "description");
-    const ref = get_ref(input.key);
-    const execute_at = resolve_postponed_action_time(input.execute_at);
-    const now = new Date();
-    return db.runTransaction(async (transaction) => {
-        const snapshot = await transaction.get(ref);
-        if (snapshot.exists) {
-            assert_status(input.key, snapshot.get("status"), [PostponedActionStatus.pending]);
-            transaction.update(ref, {
-                details: input.details,
-                action_type: input.action_type,
-                description: input.description,
-                execute_at,
-                updated_at: now,
-            });
-            return {
-                ...to_postponed_action(snapshot),
-                details: input.details,
-                action_type: input.action_type,
-                description: input.description,
-                execute_at,
-                updated_at: now,
-            };
-        }
-        const action = {
-            key: input.key,
-            details: input.details,
-            action_type: input.action_type,
-            description: input.description,
-            execute_at,
-            status: PostponedActionStatus.pending,
-            attempt_count: 0,
-            created_at: now,
-            updated_at: now,
-        };
-        transaction.create(ref, action);
-        return action;
-    });
-};
-const update_postponed_action_core = async (key, input) => {
-    if (input.details === undefined && input.action_type === undefined && input.description === undefined && input.execute_at === undefined) {
-        throw new Error("postponed action update must contain details, action_type, description or execute_at");
-    }
-    if (input.details !== undefined)
-        validate_details(input.details);
-    if (input.action_type !== undefined)
-        validate_text(input.action_type, "action_type");
-    if (input.description !== undefined)
-        validate_text(input.description, "description");
-    const ref = get_ref(key);
-    await db.runTransaction(async (transaction) => {
-        const snapshot = await transaction.get(ref);
-        if (!snapshot.exists)
-            throw new Error(`postponed action '${key}' does not exist`);
-        assert_status(key, snapshot.get("status"), [PostponedActionStatus.pending]);
-        transaction.update(ref, {
-            ...(input.details === undefined ? {} : { details: input.details }),
-            ...(input.action_type === undefined ? {} : { action_type: input.action_type }),
-            ...(input.description === undefined ? {} : { description: input.description }),
-            ...(input.execute_at === undefined ? {} : { execute_at: resolve_postponed_action_time(input.execute_at) }),
-            updated_at: new Date(),
-        });
-    });
-};
-const repostpone_postponed_action_core = async (key, execute_at) => {
-    const ref = get_ref(key);
-    await db.runTransaction(async (transaction) => {
-        const snapshot = await transaction.get(ref);
-        if (!snapshot.exists)
-            throw new Error(`postponed action '${key}' does not exist`);
-        assert_status(key, snapshot.get("status"), [
-            PostponedActionStatus.pending,
-            PostponedActionStatus.completed,
-            PostponedActionStatus.cancelled,
-            PostponedActionStatus.failed,
-        ]);
-        transaction.update(ref, {
-            execute_at: resolve_postponed_action_time(execute_at),
-            status: PostponedActionStatus.pending,
-            updated_at: new Date(),
-            started_at: FieldValue.delete(),
-            completed_at: FieldValue.delete(),
-            cancelled_at: FieldValue.delete(),
-            failed_at: FieldValue.delete(),
-            error: FieldValue.delete(),
-        });
-    });
-};
-const cancel_postponed_action_core = async (key) => {
-    const ref = get_ref(key);
-    await db.runTransaction(async (transaction) => {
-        const snapshot = await transaction.get(ref);
-        if (!snapshot.exists)
-            throw new Error(`postponed action '${key}' does not exist`);
-        assert_status(key, snapshot.get("status"), [PostponedActionStatus.pending]);
-        const now = new Date();
-        transaction.update(ref, { status: PostponedActionStatus.cancelled, cancelled_at: now, updated_at: now });
-    });
-};
-const complete_postponed_action_core = async (key) => {
-    const ref = get_ref(key);
-    await db.runTransaction(async (transaction) => {
-        const snapshot = await transaction.get(ref);
-        if (!snapshot.exists)
-            throw new Error(`postponed action '${key}' does not exist`);
-        assert_status(key, snapshot.get("status"), [PostponedActionStatus.processing]);
-        const now = new Date();
-        transaction.update(ref, { status: PostponedActionStatus.completed, completed_at: now, updated_at: now });
-    });
-};
-const fail_postponed_action_core = async (key, error) => {
-    const ref = get_ref(key);
-    await db.runTransaction(async (transaction) => {
-        const snapshot = await transaction.get(ref);
-        if (!snapshot.exists)
-            throw new Error(`postponed action '${key}' does not exist`);
-        assert_status(key, snapshot.get("status"), [PostponedActionStatus.processing]);
-        const now = new Date();
-        transaction.update(ref, {
-            status: PostponedActionStatus.failed,
-            failed_at: now,
-            updated_at: now,
-            error: error instanceof Error ? error.message : String(error),
-        });
-    });
-    logger.error(`[PostponedActions] action '${key}' failed`, error);
-};
-const delete_postponed_action_core = async (key) => {
-    await get_ref(key).delete();
-};
-const claim_postponed_action_core = async (key, action_type, now = new Date()) => {
-    validate_text(action_type, "action_type");
-    const ref = get_ref(key);
-    return db.runTransaction(async (transaction) => {
-        const snapshot = await transaction.get(ref);
-        if (!snapshot.exists || snapshot.get("status") !== PostponedActionStatus.pending || snapshot.get("action_type") !== action_type) {
-            return null;
-        }
-        const action = to_postponed_action(snapshot);
-        if (action.execute_at.getTime() > now.getTime())
-            return null;
-        const claimed = {
-            ...action,
-            status: PostponedActionStatus.processing,
-            attempt_count: action.attempt_count + 1,
-            started_at: now,
-            updated_at: now,
-        };
-        transaction.update(ref, {
-            status: claimed.status,
-            attempt_count: claimed.attempt_count,
-            started_at: now,
-            updated_at: now,
-        });
-        return claimed;
-    });
-};
-const claim_due_postponed_actions_core = async (action_type, limit = 100, now = new Date()) => {
-    validate_text(action_type, "action_type");
-    if (!Number.isInteger(limit) || limit <= 0) {
-        throw new Error("limit must be a positive integer");
-    }
-    const snapshot = await db
-        .collection(POSTPONED_ACTIONS_COLLECTION)
-        .where("action_type", "==", action_type)
-        .where("status", "==", PostponedActionStatus.pending)
-        .where("execute_at", "<=", now)
-        .orderBy("execute_at")
-        .limit(limit)
-        .get();
-    const claimed = await Promise.all(snapshot.docs.map((document) => claim_postponed_action_core(document.id, action_type, now)));
-    return claimed.filter((action) => action !== null);
-};
-const with_error_logging = (operation, action, get_key) => {
-    return async (...args) => {
-        try {
-            return await action(...args);
-        }
-        catch (error) {
-            const key = get_key?.(...args);
-            logger.error(`[PostponedActions] ${operation} failed${key ? ` for '${key}'` : ""}`, error);
-            throw error;
-        }
-    };
-};
-export const get_postponed_action = with_error_logging("get", get_postponed_action_core, (key) => key);
-export const add_postponed_action = with_error_logging("add", add_postponed_action_core, (input) => input.key);
-export const update_postponed_action = with_error_logging("update", update_postponed_action_core, (key) => key);
-export const repostpone_postponed_action = with_error_logging("repostpone", repostpone_postponed_action_core, (key) => key);
-export const cancel_postponed_action = with_error_logging("cancel", cancel_postponed_action_core, (key) => key);
-export const complete_postponed_action = with_error_logging("complete", complete_postponed_action_core, (key) => key);
-export const fail_postponed_action = with_error_logging("mark as failed", fail_postponed_action_core, (key) => key);
-export const delete_postponed_action = with_error_logging("delete", delete_postponed_action_core, (key) => key);
-export const claim_postponed_action = with_error_logging("claim", claim_postponed_action_core, (key) => key);
-export const claim_due_postponed_actions = with_error_logging("claim due", claim_due_postponed_actions_core);
-/**
- * @example Add an action for a specific date and time.
- * ```ts
- * await postponed_actions.add({
- *     key: "subscription:123:expire",
- *     action_type: "subscription_expiration",
- *     description: "Expire subscription 123",
- *     details: { subscription_id: "123", notify_customer: true },
- *     execute_at: new Date("2026-08-01T12:00:00Z"),
- * });
- * ```
- *
- * @example Add an action relative to the current time. Adding the same key
- * updates the pending action.
- * ```ts
- * await postponed_actions.add({
- *     key: "invoice:456:reminder",
- *     action_type: "invoice_reminder",
- *     description: "Send invoice 456 reminder",
- *     details: { invoice_id: "456" },
- *     execute_at: { hours: 2, minutes: 30 },
- * });
- * ```
- *
- * @example Update, repostpone, or cancel a pending action.
- * ```ts
- * await postponed_actions.update("invoice:456:reminder", {
- *     description: "Send the final invoice reminder",
- *     execute_at: { minutes: 15 },
- * });
- * await postponed_actions.repostpone("invoice:456:reminder", { hours: 1 });
- * await postponed_actions.cancel("invoice:456:reminder");
- * ```
- *
- * @example Claim and execute due actions. Claiming is atomic, so concurrent
- * workers cannot claim the same action.
- * ```ts
- * const actions = await postponed_actions.claim_due("invoice_reminder", 25);
- * for (const action of actions) {
- *     try {
- *         await execute_action(action.details);
- *         await postponed_actions.complete(action.key);
- *     } catch (error) {
- *         await postponed_actions.fail(action.key, error);
- *     }
- * }
- * ```
- */
-export const postponed_actions = {
-    get: get_postponed_action,
-    add: add_postponed_action,
-    update: update_postponed_action,
-    repostpone: repostpone_postponed_action,
-    cancel: cancel_postponed_action,
-    complete: complete_postponed_action,
-    fail: fail_postponed_action,
-    delete: delete_postponed_action,
-    claim: claim_postponed_action,
-    claim_due: claim_due_postponed_actions,
-};

package/dist/helpers/redis/helpers.js

@@ -1,215 +0,0 @@
-import { logger } from "../../managers";
-import { get_redis_commander, redis_commander_connected } from "./initialize";
-import { get_doc_key, get_collection_keys, scan_redis_keys } from "./keys";
-import { get_nx_settings, get_all_documents, query_documents, query_documents_by_conditions, query_document_by_conditions, query_document, query_document_optional, get_document_by_id, get_document_by_id_optional, } from "../firebase_helpers";
-const should_use_redis = async (collection_path) => {
-    if (!redis_commander_connected) {
-        logger.warn(`⚠️ Redis commander not connected, falling back to Firebase for collection: "${collection_path}"`);
-        return false;
-    }
-    try {
-        const nx_settings = await get_nx_settings();
-        const cache_collections_config = nx_settings.cache_collections_config || {};
-        const config = cache_collections_config[collection_path];
-        if (!config) {
-            logger.warn(`⚠️ Collection "${collection_path}" not found in cache_collections_config, falling back to Firebase`);
-            return false;
-        }
-    }
-    catch {
-        logger.warn(`⚠️ Failed to validate Redis config for collection: "${collection_path}", falling back to Firebase`);
-        return false;
-    }
-    return true;
-};
-const parse_redis_value = (raw) => {
-    const parsed = JSON.parse(raw);
-    return parsed.data ?? parsed;
-};
-const get_all_collection_docs = async (collection_path) => {
-    const commander = get_redis_commander();
-    const keys = await scan_redis_keys(get_collection_keys(collection_path), commander);
-    if (keys.length === 0)
-        return [];
-    const values = await commander.mget(keys);
-    return values.filter(Boolean).map((v) => {
-        const data = parse_redis_value(v);
-        const key = keys[values.indexOf(v)];
-        /// example key: "nx-users(collection):123(doc_id)"
-        const id = key.split(":").slice(1).join(":");
-        return { ...data, id };
-    });
-};
-const apply_operator = (doc_value, operator, value) => {
-    switch (operator) {
-        case "==":
-            return doc_value === value;
-        case "!=":
-            return doc_value !== value;
-        case "<":
-            return doc_value < value;
-        case "<=":
-            return doc_value <= value;
-        case ">":
-            return doc_value > value;
-        case ">=":
-            return doc_value >= value;
-        case "in":
-            return Array.isArray(value) && value.includes(doc_value);
-        case "not-in":
-            return Array.isArray(value) && !value.includes(doc_value);
-        case "array-contains":
-            return Array.isArray(doc_value) && doc_value.includes(value);
-        case "array-contains-any":
-            return Array.isArray(doc_value) && Array.isArray(value) && value.some((v) => doc_value.includes(v));
-        default:
-            return false;
-    }
-};
-const filter_by_condition = (docs, field_name, operator, value) => {
-    return docs.filter((doc) => apply_operator(doc[field_name], operator, value));
-};
-const filter_by_conditions = (docs, conditions) => {
-    return conditions.reduce((filtered, { field_name, operator, value }) => {
-        return filter_by_condition(filtered, field_name, operator, value);
-    }, docs);
-};
-// ── extract ──
-export const redis_simple_extract_data = (raw) => {
-    const data = parse_redis_value(raw);
-    return data;
-};
-// ── documents ──
-export const redis_get_all_documents = async (collection_path) => {
-    if (!(await should_use_redis(collection_path))) {
-        return get_all_documents(collection_path);
-    }
-    try {
-        return await get_all_collection_docs(collection_path);
-    }
-    catch (error) {
-        logger.error("Error fetching documents from Redis:", error);
-        throw error;
-    }
-};
-export const redis_query_documents = async (collection_path, field_name, operator, value) => {
-    if (!(await should_use_redis(collection_path))) {
-        return query_documents(collection_path, field_name, operator, value);
-    }
-    try {
-        const all_docs = await get_all_collection_docs(collection_path);
-        return filter_by_condition(all_docs, field_name, operator, value);
-    }
-    catch (error) {
-        logger.error(`Error querying documents from Redis: ${collection_path} - ${field_name} - ${operator} - ${value} `, error);
-        throw error;
-    }
-};
-export const redis_query_documents_by_conditions = async (collection_path, where_conditions) => {
-    if (!(await should_use_redis(collection_path))) {
-        return query_documents_by_conditions(collection_path, where_conditions);
-    }
-    try {
-        const all_docs = await get_all_collection_docs(collection_path);
-        return filter_by_conditions(all_docs, where_conditions);
-    }
-    catch (error) {
-        logger.error(`Error querying documents from Redis: ${collection_path} - ${JSON.stringify(where_conditions)} `, error);
-        throw error;
-    }
-};
-export const redis_query_document_by_conditions = async (collection_path, where_conditions, ignore_logs = false) => {
-    if (!(await should_use_redis(collection_path))) {
-        return query_document_by_conditions(collection_path, where_conditions, !ignore_logs);
-    }
-    try {
-        const all_docs = await get_all_collection_docs(collection_path);
-        const documents = filter_by_conditions(all_docs, where_conditions);
-        if (!documents[0]) {
-            throw "no data returned from Redis";
-        }
-        return documents[0];
-    }
-    catch (error) {
-        if (!ignore_logs) {
-            logger.error(`Error querying document from Redis: ${collection_path} - ${JSON.stringify(where_conditions)} `, error);
-        }
-        throw error;
-    }
-};
-// ── document ──
-export const redis_query_document = async (collection_path, field_name, operator, value, ignore_log = false) => {
-    if (!(await should_use_redis(collection_path))) {
-        return query_document(collection_path, field_name, operator, value, ignore_log);
-    }
-    try {
-        const all_docs = await get_all_collection_docs(collection_path);
-        const documents = filter_by_condition(all_docs, field_name, operator, value);
-        const base_error = `collection: ${collection_path}, field_name: ${field_name}, operator: ${operator}, value:${value}`;
-        if (documents.length < 1) {
-            throw `[Redis] No data to return from: ${base_error}`;
-        }
-        if (documents.length > 1) {
-            throw `[Redis] Multiple documents found in: ${base_error}`;
-        }
-        return documents[0];
-    }
-    catch (error) {
-        if (!ignore_log) {
-            logger.error("Error querying document from Redis: " + JSON.stringify({ collection_path, field_name, operator, value }), error);
-        }
-        throw error;
-    }
-};
-export const redis_query_document_optional = async (collection_path, field_name, operator, value, ignore_log = true) => {
-    if (!(await should_use_redis(collection_path))) {
-        return query_document_optional(collection_path, field_name, operator, value, ignore_log);
-    }
-    try {
-        const all_docs = await get_all_collection_docs(collection_path);
-        const documents = filter_by_condition(all_docs, field_name, operator, value);
-        return documents[0] || null;
-    }
-    catch (error) {
-        if (!ignore_log) {
-            logger.error("Error querying optional document from Redis: " + JSON.stringify({ collection_path, field_name, operator, value }), error);
-        }
-        return null;
-    }
-};
-export const redis_get_document_by_id = async (collection_path, doc_id) => {
-    if (!(await should_use_redis(collection_path))) {
-        return get_document_by_id(collection_path, doc_id);
-    }
-    try {
-        const commander = get_redis_commander();
-        const key = get_doc_key(collection_path, doc_id);
-        const raw = await commander.get(key);
-        if (!raw) {
-            throw "Document not found in Redis, document id: " + doc_id;
-        }
-        return redis_simple_extract_data(raw);
-    }
-    catch (error) {
-        logger.error("error from redis_get_document_by_id", error);
-        throw error;
-    }
-};
-export const redis_get_document_by_id_optional = async (collection_path, doc_id) => {
-    if (!(await should_use_redis(collection_path))) {
-        return get_document_by_id_optional(collection_path, doc_id);
-    }
-    try {
-        const commander = get_redis_commander();
-        const key = get_doc_key(collection_path, doc_id);
-        const raw = await commander.get(key);
-        if (!raw) {
-            return null;
-        }
-        return redis_simple_extract_data(raw);
-    }
-    catch (error) {
-        logger.error("error from redis_get_document_by_id_optional", error);
-        return null;
-    }
-};

package/dist/helpers/redis/index.js

@@ -1,4 +0,0 @@
-export * from "./initialize";
-export * from "./keys";
-export * from "./snapshot";
-export * from "./helpers";