akeyless-server-commons 1.0.200 → 1.0.204

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 };

package/dist/middlewares/global_mw.js

@@ -0,0 +1,119 @@
+import { json_failed } from "../helpers";
+import { logger } from "../managers";
+const validateParameter = (data, parameter, is_mandatory) => {
+    if (data[parameter.key] === undefined) {
+        if (is_mandatory) {
+            throw `missing mandatory parameter: ${parameter.key}`;
+        }
+        else {
+            return;
+        }
+    }
+    if (parameter.type === "array" && !Array.isArray(data[parameter.key])) {
+        throw `parameter ${parameter.key} must be of type: Array`;
+    }
+    if (typeof data[parameter.key] !== parameter.type && parameter.type !== "array") {
+        throw `parameter ${parameter.key} must be of type: ${parameter.type}`;
+    }
+    if (parameter.type === "string" && parameter.length && data[parameter.key].length < parameter.length) {
+        throw `parameter ${parameter.key} must be string and must have minimum length of: ${parameter.length}`;
+    }
+    const is_array = Array.isArray(data[parameter.key]);
+    if (is_array) {
+        if (parameter.length && data[parameter.key].length < parameter.length) {
+            throw `parameter ${parameter.key} must be array and must have minimum length of: ${parameter.length}`;
+        }
+        if (Array.isArray(parameter.array_types) && parameter.array_types.length > 0) {
+            data[parameter.key].forEach((item, index) => {
+                const item_type = typeof item;
+                if (!parameter.array_types.includes(item_type)) {
+                    throw `item at index ${index} in parameter ${parameter.key} must be of type: ${parameter.array_types.join(" | ")}`;
+                }
+            });
+        }
+    }
+    if (parameter.type === "object" && parameter.required_keys) {
+        const missingKeys = parameter.required_keys.filter((key) => data[parameter.key][key] === undefined);
+        if (missingKeys.length > 0) {
+            throw `parameter ${parameter.key} is missing required keys: ${missingKeys.join(", ")}`;
+        }
+        parameter.required_keys.forEach((key) => {
+            const value = data[parameter.key][key];
+            if ((typeof value === "string" || Array.isArray(value)) && value.length === 0) {
+                throw `parameter ${key} in ${parameter.key} must have some length `;
+            }
+        });
+    }
+};
+export const mandatory = ({ body, headers }) => {
+    return (req, res, next) => {
+        try {
+            const body_data = req.body;
+            const headers_data = req.headers;
+            if (body) {
+                body.forEach((parameter) => {
+                    validateParameter(body_data, parameter, true);
+                });
+            }
+            if (headers) {
+                headers.forEach((parameter) => {
+                    validateParameter(headers_data, parameter, true);
+                });
+            }
+            next();
+        }
+        catch (error) {
+            return res.send(json_failed(error));
+        }
+    };
+};
+export const optional = ({ body, headers }) => {
+    return (req, res, next) => {
+        try {
+            const body_data = req.body;
+            const headers_data = req.headers;
+            if (body) {
+                body.forEach((parameter) => {
+                    validateParameter(body_data, parameter, false);
+                });
+            }
+            if (headers) {
+                headers.forEach((parameter) => {
+                    validateParameter(headers_data, parameter, false);
+                });
+            }
+            next();
+        }
+        catch (error) {
+            return res.send(json_failed(error));
+        }
+    };
+};
+const is_gcp_request = (req) => {
+    const user_agent = req.get("user-agent")?.toLowerCase();
+    return !!(user_agent?.startsWith("googlehc") ||
+        user_agent?.startsWith("kube-probe") ||
+        user_agent?.startsWith("googlestackdrivermonitoring"));
+};
+export const request_logger = (log_requests) => {
+    return (req, res, next) => {
+        if (!log_requests?.gcp && is_gcp_request(req)) {
+            return next();
+        }
+        if (log_requests?.url || log_requests?.headers || log_requests?.query || log_requests?.body) {
+            logger.log(`${req.method} ${req.originalUrl}`);
+        }
+        if (log_requests?.headers) {
+            logger.log("Headers:", req.headers);
+        }
+        if (log_requests?.query) {
+            logger.log("Query:", req.query);
+        }
+        if (log_requests?.body) {
+            if (["POST", "PUT", "PATCH"].includes(req.method)) {
+                logger.log("Body:", req.body);
+            }
+        }
+        next();
+    };
+};

package/dist/middlewares/index.js

@@ -0,0 +1,4 @@
+export * from "./global_mw";
+export * from "./auth_mw";
+export * from "./error_handling";
+export * from "./trim_mw";

package/dist/middlewares/trim_mw.js

@@ -0,0 +1,7 @@
+import { trim_strings } from "../helpers";
+export const trim_body_middleware = () => (req, res, next) => {
+    if (req.body && typeof req.body === "object") {
+        req.body = trim_strings(req.body);
+    }
+    return next();
+};

package/dist/test.js

@@ -0,0 +1 @@
+"use strict";

package/dist/types/enums/global.js

@@ -0,0 +1,8 @@
+export var SimProvider;
+(function (SimProvider) {
+    SimProvider["partner"] = "partner";
+    SimProvider["pelephone"] = "pelephone";
+    SimProvider["celcom"] = "celcom";
+    SimProvider["monogoto"] = "monogoto";
+    SimProvider["unknown"] = "unknown";
+})(SimProvider || (SimProvider = {}));

package/dist/types/enums/index.js

@@ -0,0 +1 @@
+export * from "./global";

package/dist/types/helpers/boards_helpers.d.ts

@@ -0,0 +1,10 @@
+import { Car, TObject } from "akeyless-types-commons";
+interface BoardProviderWithBoardTypes {
+    board_provider: "erm" | "jimi" | "ruptela" | "servision" | "jimi_iothub";
+    board_types: string[];
+}
+export declare const extract_board_types_from_settings: (settings: TObject<any>) => BoardProviderWithBoardTypes[];
+export type BoardMakerResult = "erm" | "jimi" | "ruptela" | "servision" | "jimi_iothub";
+export declare const get_board_maker_by_board_type: (type: string) => BoardMakerResult;
+export declare const get_board_maker_by_car: (car: Car) => BoardMakerResult;
+export {};

package/dist/types/helpers/email_helpers.d.ts

@@ -0,0 +1,12 @@
+import { EmailData, EmailAttachment } from "../types";
+export declare const create_attachment_from_file: (file_path: string, filename?: string, disposition?: "attachment" | "inline") => Promise<EmailAttachment>;
+export declare const create_attachment_from_buffer: (buffer: Buffer | Uint8Array, filename: string, mime_type: string, disposition?: "attachment" | "inline") => EmailAttachment;
+export declare const create_attachment_from_url: (url: string, filename: string) => Promise<{
+    content: string;
+    filename: string;
+    type: string;
+    disposition: string;
+}>;
+export declare const send_email: (email_data: EmailData, options?: {
+    debug?: boolean;
+}) => Promise<void>;

package/dist/types/helpers/firebase_helpers.d.ts

@@ -0,0 +1,56 @@
+import firebase_admin from "firebase-admin";
+import { AddAuditRecord, ExtraSnapshotConfig, InitSnapshotsOptions, OnSnapshotCallback, OnSnapshotParsers, QueryDocument, QueryDocumentByConditions, QueryDocumentOptional, QueryDocuments, QueryDocumentsByConditions, Snapshot, SnapshotBulk, SnapshotBulkByNames } from "../types";
+import { DecodedIdToken } from "firebase-admin/auth";
+import { TObject } from "akeyless-types-commons";
+export declare const service_account_firebase: {
+    type: string;
+    project_id: string;
+    private_key_id: string;
+    private_key: string;
+    client_email: string;
+    client_id: string;
+    auth_uri: string;
+    token_uri: string;
+    auth_provider_x509_cert_url: string;
+    client_x509_cert_url: string;
+    universe_domain: string;
+};
+export declare const db: firebase_admin.firestore.Firestore;
+export declare const messaging: import("firebase-admin/messaging").Messaging;
+export declare const auth: import("firebase-admin/auth").Auth;
+export declare const storage: import("firebase-admin/lib/storage/storage").Storage;
+export declare const simple_extract_data: (doc: FirebaseFirestore.DocumentSnapshot) => TObject<any>;
+export declare const get_all_documents: (collection_path: string) => Promise<any[]>;
+export declare const query_documents: QueryDocuments;
+export declare const query_documents_by_conditions: QueryDocumentsByConditions;
+export declare const query_document_by_conditions: QueryDocumentByConditions;
+export declare const query_document: QueryDocument;
+export declare const query_document_optional: QueryDocumentOptional;
+export declare const get_document_by_id: (collection_path: string, doc_id: string) => Promise<TObject<any>>;
+export declare const get_document_by_id_optional: (collection_path: string, doc_id: string) => Promise<TObject<any> | null>;
+export declare const set_document: (collection_path: string, doc_id: string, data: {}, merge?: boolean) => Promise<void>;
+export declare const add_document: (collection_path: string, data: {}, include_id?: boolean, custom_id?: string) => Promise<string>;
+export declare const delete_document: (collection_path: string, doc_id: string) => Promise<void>;
+export declare const verify_token: (authorization: string | undefined, ignore_log?: boolean) => Promise<DecodedIdToken>;
+export declare const parse_add_update_as_object: OnSnapshotCallback;
+export declare const parse_delete_as_object: OnSnapshotCallback;
+export declare const parse_add_update_as_array: OnSnapshotCallback;
+export declare const parse_delete_as_array: OnSnapshotCallback;
+export declare const snapshot: Snapshot;
+export declare const init_snapshots: (options?: InitSnapshotsOptions) => Promise<void>;
+export declare const snapshot_bulk: SnapshotBulk;
+export declare const get_default_parsers: (parse_as: ExtraSnapshotConfig["parse_as"]) => OnSnapshotParsers;
+export declare const snapshot_bulk_by_names: SnapshotBulkByNames;
+export declare const add_audit_record: AddAuditRecord;
+export declare const add_nx_problem: (problem: string, key: string, details: TObject<any>) => Promise<void>;
+export interface SaveFileOptions {
+    content_type?: string;
+    content_disposition?: string;
+    cache_control?: string;
+    make_public?: boolean;
+    signed_url_ttl_ms?: number;
+    resumable?: boolean;
+}
+export declare const save_file_in_storage: (file_path: string, buffer: Buffer | Uint8Array, options?: SaveFileOptions) => Promise<string>;
+export declare const get_file_url_from_storage: (file_path: string) => Promise<string>;
+export declare const get_nx_settings: () => Promise<any>;

package/dist/types/helpers/global_helpers.d.ts

@@ -0,0 +1,16 @@
+import { JsonFailed, JsonOK, NxServiceNameMap } from "../types";
+import { Geo, LanguageOptions, TObject } from "akeyless-types-commons";
+import { AxiosRequestConfig } from "axios";
+export declare const init_env_variables: (required_vars?: string[]) => TObject<string>;
+export declare const json_ok: JsonOK<TObject<any> | TObject<any>[]>;
+export declare const json_failed: JsonFailed;
+export declare const parse_error: (error: any) => any;
+export declare const get_version: (packageJsonPath: string) => string;
+export declare const sleep: (ms?: number) => Promise<unknown>;
+export declare function get_nx_service_urls(env_name?: string): NxServiceNameMap;
+export declare const get_address_by_geo: ({ lat, lng }: Geo, currentLanguage: LanguageOptions) => Promise<string>;
+export declare const validate_and_cast: <T extends any>(variable: any, condition: Boolean) => variable is T;
+export declare const get_or_default: <T>(value: T | undefined, default_value: T | (() => T)) => T;
+export declare const trim_strings: <T>(input: any) => any;
+export declare const remove_nulls_and_undefined: (obj: Record<string, any>) => Record<string, any>;
+export declare const ignore_ssl_request: (config: AxiosRequestConfig) => Promise<import("axios").AxiosResponse<any, any>>;

package/dist/types/helpers/index.d.ts

@@ -0,0 +1,12 @@
+export * from "./global_helpers";
+export * from "./firebase_helpers";
+export * from "./start";
+export * from "./time_helpers";
+export * from "./login_helpers";
+export * from "./notification_helpers";
+export * from "./email_helpers";
+export * from "./phone_number_helpers";
+export * from "./tasks_helpers";
+export * from "./boards_helpers";
+export * from "./redis";
+export * from "./location_helpers";

package/dist/types/helpers/location_helpers.d.ts

@@ -0,0 +1,3 @@
+import { Geo } from "akeyless-types-commons";
+export declare const get_distance_in_meters_between_geo_points: (location1: Geo, location2: Geo) => number;
+export declare const get_location_url: (location: Geo) => string;

package/dist/types/helpers/login_helpers.d.ts

@@ -0,0 +1,4 @@
+import { NxUser, MobileAppUser } from "akeyless-types-commons";
+export declare const convert_to_short_phone_number: (phone_number: string) => string;
+export declare const get_user_by_identifier: (identifier: string, ignore_log?: boolean) => Promise<NxUser | null>;
+export declare const get_mobile_app_user_by_uid: (uid: string, ignore_log?: boolean) => Promise<MobileAppUser | null>;

package/dist/types/helpers/notification_helpers.d.ts

@@ -0,0 +1,11 @@
+import { EventFromDevice, TObject } from "akeyless-types-commons";
+export declare const send_sms: (recepient: string, text: string, entity_for_audit: string, details?: TObject<any>) => Promise<void>;
+export declare const push_event_to_mobile_users: (event: EventFromDevice) => Promise<void>;
+type FuncSendFcmMessage = (title: string, body: string, fcm_tokens: string[], custom_sound?: string) => Promise<{
+    success: boolean;
+    response: string;
+    success_count?: number;
+    failure_count?: number;
+}>;
+export declare const send_fcm_message: FuncSendFcmMessage;
+export {};

package/dist/types/helpers/phone_number_helpers.d.ts

@@ -0,0 +1,19 @@
+import { SimProvider } from "../types/enums";
+export declare const is_long_phone_number: (phone_number: string) => boolean;
+export declare const is_israel_long_phone_number: (phone_number: string) => boolean;
+export declare const is_thailand_long_phone_number: (phone_number: string) => boolean;
+export declare const is_international_phone_number: (phone_number: string) => boolean;
+export declare const is_iccid: (number: string) => boolean;
+export declare const convert_to_short_israel_phone: (international_number: string) => string;
+export declare const is_sim_provider_partner: (phone_number: string) => boolean;
+export declare const is_sim_provider_pelephone: (phone_number: string) => boolean;
+export declare const is_sim_provider_celcom: (phone_number: string) => boolean;
+export declare const is_sim_provider_monogoto: (phone_number: string) => boolean;
+export declare const get_sim_provider: (phone_number: string) => SimProvider;
+interface LongShortPhoneNumbers {
+    short_phone_number: string;
+    long_phone_number: string;
+    is_israeli: boolean;
+}
+export declare const long_short_phone_numbers: (phone_number: string) => LongShortPhoneNumbers;
+export {};

package/dist/types/helpers/redis/helpers.d.ts

@@ -0,0 +1,11 @@
+import { TObject } from "akeyless-types-commons";
+import { WhereCondition } from "../../types";
+export declare const redis_simple_extract_data: (raw: string) => TObject<any>;
+export declare const redis_get_all_documents: (collection_path: string) => Promise<TObject<any>[]>;
+export declare const redis_query_documents: (collection_path: string, field_name: string, operator: FirebaseFirestore.WhereFilterOp, value: any) => Promise<TObject<any>[]>;
+export declare const redis_query_documents_by_conditions: (collection_path: string, where_conditions: WhereCondition[]) => Promise<TObject<any>[]>;
+export declare const redis_query_document_by_conditions: (collection_path: string, where_conditions: WhereCondition[], ignore_logs?: boolean) => Promise<TObject<any>>;
+export declare const redis_query_document: (collection_path: string, field_name: string, operator: FirebaseFirestore.WhereFilterOp, value: any, ignore_log?: boolean) => Promise<TObject<any>>;
+export declare const redis_query_document_optional: (collection_path: string, field_name: string, operator: FirebaseFirestore.WhereFilterOp, value: any, ignore_log?: boolean) => Promise<TObject<any> | null>;
+export declare const redis_get_document_by_id: (collection_path: string, doc_id: string) => Promise<TObject<any>>;
+export declare const redis_get_document_by_id_optional: (collection_path: string, doc_id: string) => Promise<TObject<any> | null>;

package/dist/types/helpers/redis/index.d.ts

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

package/dist/types/helpers/redis/initialize.d.ts

@@ -0,0 +1,6 @@
+import Redis from "ioredis";
+export declare let redis_commander_connected: boolean;
+export declare let redis_listener_connected: boolean;
+export declare const init_redis: () => Promise<void>;
+export declare const get_redis_commander: () => Redis;
+export declare const get_redis_listener: () => Redis;

package/dist/types/helpers/redis/keys.d.ts

@@ -0,0 +1,5 @@
+import Redis from "ioredis";
+export declare const get_doc_key: (collection: string, doc_id: string) => string;
+export declare const get_collection_keys: (collection: string) => string;
+export declare const get_channel: (...args: string[]) => string;
+export declare const scan_redis_keys: (pattern: string, redis_publisher: Redis) => Promise<string[]>;

package/dist/types/helpers/redis/snapshot.d.ts

@@ -0,0 +1,2 @@
+import { OnSnapshotConfig } from "../../types";
+export declare const redis_snapshots_bulk: (configs: OnSnapshotConfig[]) => Promise<void>;

package/dist/types/helpers/start.d.ts

@@ -0,0 +1,4 @@
+import { Express } from "express";
+import { AppOptions, MainRouter } from "../types";
+export declare const start_server: (main_router: MainRouter, project_name: string, version: string, options?: AppOptions) => Promise<Express>;
+export declare const basic_init: (main_router: MainRouter, project_name: string, version: string, options?: AppOptions) => Promise<Express>;

package/dist/types/helpers/tasks_helpers.d.ts

@@ -0,0 +1,25 @@
+import { TObject } from "akeyless-types-commons";
+export declare enum TaskName {
+    send_reset_sms = "send_reset_sms",
+    collect_devices_health = "collect_devices_health",
+    collect_charge_locations = "collect_charge_locations",
+    collect_charge_cdrs = "collect_charge_cdrs",
+    auto_connect_to_call_center = "auto_connect_to_call_center",
+    make_erm_ev_events = "make_erm_ev_events",
+    collect_jimi_cars_odometer = "collect_jimi_cars_odometer"
+}
+export declare enum TaskStatus {
+    running = "running",
+    completed = "completed",
+    failed = "failed",
+    suspeneded = "suspeneded"
+}
+export type TaskSaveOptions = "storage" | "db" | "none";
+export interface ExecuteTaskOptions {
+    save_in?: TaskSaveOptions;
+    debug_logs?: boolean;
+}
+export declare const execute_task: <T = any>(source: string, task_name: TaskName, task: () => Promise<T>, options?: ExecuteTaskOptions) => Promise<void>;
+export declare const get_task_data: <T = any>(task_name: TaskName) => Promise<T>;
+export declare const get_task_data_from_storage: <T = any>(task_name: TaskName) => Promise<T | null>;
+export declare const keep_task_data_in_storage: (task_name: TaskName, data: any[] | TObject<any>) => Promise<string>;

package/dist/types/helpers/time_helpers.d.ts

@@ -0,0 +1,40 @@
+import { Timestamp } from "firebase-admin/firestore";
+import { firebase_timestamp } from "akeyless-types-commons";
+export declare function sort_by_timestamp(a: Timestamp, b: Timestamp, reverse?: boolean): number;
+export interface TimePassedByDate {
+    seconds_passed: number;
+    minutes_passed: number;
+    hours_passed: number;
+    days_passed: number;
+    time_passed_formatted_short: string;
+    time_passed_formatted_long: string;
+}
+export declare const calculate_time_passed: (datetime: Date) => TimePassedByDate;
+interface TimeToStringOptions {
+    format?: string;
+    fromFormat?: string;
+    tz?: string;
+    defaultReturnedValue?: string;
+    debug?: boolean;
+}
+export declare function any_datetime_to_string(firebaseTimestamp: Timestamp | Date | string | firebase_timestamp | number, options?: TimeToStringOptions): string;
+interface TimeToMillisOptions extends Omit<TimeToStringOptions, "defaultReturnedValue" | "format"> {
+    defaultReturnedValue?: number;
+}
+export declare function any_datetime_to_millis(firebaseTimestamp: Timestamp | Date | string | number | firebase_timestamp, options?: TimeToMillisOptions): number;
+/**
+ * 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 declare function timestamp_to_string(firebaseTimestamp: firebase_timestamp, format?: string): string;
+/**
+ * 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 declare function timestamp_to_millis(firebaseTimestamp: firebase_timestamp): number;
+export {};

package/dist/types/index.d.ts

@@ -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/types/index.js

@@ -0,0 +1,3 @@
+export * from './types';
+export * from './interfaces';
+export * from './enums';

package/dist/types/interfaces/index.js

@@ -0,0 +1,2 @@
+export * from './global';
+export * from './email';

package/dist/types/managers/cache_manager.d.ts

@@ -0,0 +1,12 @@
+export declare class CacheManager {
+    private static instance;
+    private data;
+    private constructor();
+    static getInstance(): CacheManager;
+    setArrayData(key: string, data: any[]): void;
+    getArrayData(key: string): any[];
+    setObjectData(key: string, data: any): void;
+    getObjectData(key: string, default_value?: any): any;
+    getObjectDataAsArray(key: string, default_value?: any): any[];
+}
+export declare const cache_manager: CacheManager;

package/dist/types/managers/index.d.ts

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

package/dist/types/managers/logger_manager.d.ts

@@ -0,0 +1,14 @@
+import { TObject } from "akeyless-types-commons";
+declare class LoggerManager {
+    private static instance;
+    private constructor();
+    static getInstance(): LoggerManager;
+    private get_date;
+    private is_gcp;
+    private emit;
+    log(msg: string, data?: TObject<any> | any[]): void;
+    error(msg: string, data?: any): void;
+    warn(msg: string, data?: any): void;
+}
+export declare const logger: LoggerManager;
+export {};

package/dist/types/managers/rabbitmq_manager.d.ts

@@ -0,0 +1,60 @@
+export type JsonValue = null | boolean | number | string | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export type EventHeaderValue = string | number | boolean;
+export interface RabbitEvent<T extends JsonValue = JsonValue> {
+    body: T;
+    event_id?: string;
+    created_at?: string;
+    redelivered: boolean;
+    headers: Record<string, unknown>;
+}
+export interface PushEventOptions {
+    /** RabbitMQ message time-to-live, in seconds. */
+    ttl_seconds?: number;
+    headers?: Record<string, EventHeaderValue>;
+}
+export interface SubscribeOptions {
+    /** Requeue messages when the handler throws or rejects. Defaults to true. */
+    requeue_on_error?: boolean;
+}
+export interface Subscription {
+    queue_name: string;
+    consumer_tag: string;
+    cancel(): Promise<void>;
+}
+export type EventHandler<T extends JsonValue = JsonValue> = (event: RabbitEvent<T>) => void | Promise<void>;
+/**
+ * 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 declare class RabbitManager {
+    readonly prefetch_count: number;
+    private connection;
+    private channel;
+    private connecting;
+    constructor();
+    connect(): Promise<void>;
+    close(): Promise<void>;
+    push_event<T extends JsonValue>(channel_name: string, payload: T, options?: PushEventOptions): Promise<string>;
+    private subscriptions;
+    subscribe_for_channel<T extends JsonValue>(channel_name: string, subscriber_name: string, handler: EventHandler<T>, options?: SubscribeOptions): Promise<Subscription>;
+    cancel_subscriptions(): Promise<void>;
+    pull_and_delete<T extends JsonValue>(channel_name: string, subscriber_name: string): Promise<RabbitEvent<T> | undefined>;
+    /**
+     * Diagnostic peek implemented as get + nack + requeue.
+     * It is not a reliable queue browser: the same event can repeat or move.
+     */
+    pull_and_leave<T extends JsonValue>(channel_name: string, subscriber_name: string): Promise<RabbitEvent<T> | undefined>;
+    private open_connection;
+    private get_channel;
+    private declare_exchange;
+    private declare_subscription;
+    private handle_message;
+    private to_event;
+    private validate_name;
+}
+export declare const rabbitmq: RabbitManager;

package/dist/types/managers/translation_manager.d.ts

@@ -0,0 +1,14 @@
+import { TObject } from "akeyless-types-commons";
+import { EntityOptions, LangOptions } from "../types";
+export declare class TranslationManager {
+    private static instance;
+    private data;
+    private constructor();
+    static getInstance(): TranslationManager;
+    setTranslationData(data: TObject<any>): void;
+    getTranslationData(): TObject<any>;
+    get_translation(scope: string, lang: string, entity: string, key: string): string;
+    get_sms(lang: LangOptions, entity: EntityOptions, key: string): string;
+    get_email(lang: LangOptions, entity: EntityOptions, key: string): string;
+}
+export declare const translation_manager: TranslationManager;

package/dist/types/middlewares/auth_mw.d.ts

@@ -0,0 +1,4 @@
+import { MW } from "../types";
+export declare const verify_user_auth: MW;
+export declare const nx_user_login: MW;
+export declare const client_login: MW;

package/dist/types/middlewares/error_handling.d.ts

@@ -0,0 +1,11 @@
+import { Request, Response, NextFunction } from "express";
+import { Service } from "../types";
+/**
+ * Utility to handle async errors
+ */
+declare const async_error_handler: (service: Service) => (req: Request, res: Response, next: NextFunction) => void;
+/**
+ * Global error-handling middleware.
+ */
+declare const error_handler: (err: Error, req: Request, res: Response, next: NextFunction) => void;
+export { error_handler, async_error_handler };