akeyless-client-commons 1.1.7 → 1.1.9

package/dist/hooks/index.mjs

@@ -1,4 +1,12 @@
 // src/hooks/global.ts
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
     try {
         var info = gen[key](arg);
@@ -28,6 +36,25 @@ function _async_to_generator(fn) {
         });
     };
 }
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
 function _define_property(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
@@ -41,6 +68,33 @@ function _define_property(obj, key, value) {
     }
     return obj;
 }
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
 function _object_spread(target) {
     for(var i = 1; i < arguments.length; i++){
         var source = arguments[i] != null ? arguments[i] : {};
@@ -80,6 +134,17 @@ function _object_spread_props(target, source) {
     }
     return target;
 }
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
 function _ts_generator(thisArg, body) {
     var f, y, t, g, _ = {
         label: 0,
@@ -279,6 +344,50 @@ var simpleExtractData = function(doc2) {
         id: doc2.id
     });
 };
+var get_document_by_id = /*#__PURE__*/ function() {
+    var _ref = _async_to_generator(function(collection_path, doc_id) {
+        var doc_ref, doc_snap, error;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    _state.trys.push([
+                        0,
+                        2,
+                        ,
+                        3
+                    ]);
+                    doc_ref = doc(db, collection_path, doc_id);
+                    return [
+                        4,
+                        getDoc(doc_ref)
+                    ];
+                case 1:
+                    doc_snap = _state.sent();
+                    if (!doc_snap.exists()) {
+                        throw new Error("Document not found, document id: " + doc_id);
+                    }
+                    return [
+                        2,
+                        simpleExtractData(doc_snap)
+                    ];
+                case 2:
+                    error = _state.sent();
+                    console.error("Error from get_document_by_id", error);
+                    return [
+                        2,
+                        null
+                    ];
+                case 3:
+                    return [
+                        2
+                    ];
+            }
+        });
+    });
+    return function get_document_by_id(collection_path, doc_id) {
+        return _ref.apply(this, arguments);
+    };
+}();
 var snapshot = function(config, snapshotsFirstTime, settings) {
     var resolvePromise;
     var isResolved = false;
@@ -425,6 +534,277 @@ var biDomain = isLocal ? "http://localhost:9002/api/bi" : baseDomain + "/bi";
 var notificationsDomain = isLocal ? "http://localhost:9006/api/notifications" : baseDomain + "/notifications";
 var callCenterGeoDomain = isLocal ? "http://localhost:9007/api/call-center/geo" : baseDomain + "/call-center/geo";
 var callCenterEventsDomain = isLocal ? "http://localhost:9008/api/call-center/events" : baseDomain + "/call-center/events";
+// src/helpers/socket.ts
+import { io } from "socket.io-client";
+var SocketService = /*#__PURE__*/ function() {
+    "use strict";
+    function _SocketService() {
+        _class_call_check(this, _SocketService);
+        this.socket = null;
+        this.connectCallbacks = [];
+        this.disconnectCallbacks = [];
+    }
+    _create_class(_SocketService, [
+        {
+            /// Initialize the socket connection
+            key: "initSocket",
+            value: function initSocket() {
+                var _this = this;
+                if (!this.socket) {
+                    var SOCKET_SERVER_URL = "http://localhost:9009";
+                    var SOCKET_PATH = "/api/data-socket/connect";
+                    this.socket = io(SOCKET_SERVER_URL, {
+                        path: SOCKET_PATH,
+                        transports: [
+                            "websocket"
+                        ]
+                    });
+                    this.socket.on("connect", function() {
+                        var _this_socket;
+                        console.log("Socket connected:", (_this_socket = _this.socket) === null || _this_socket === void 0 ? void 0 : _this_socket.id);
+                        _this.connectCallbacks.forEach(function(cb) {
+                            return cb();
+                        });
+                    });
+                    this.socket.on("disconnect", function(reason) {
+                        console.log("Socket disconnected:", reason);
+                        _this.disconnectCallbacks.forEach(function(cb) {
+                            return cb();
+                        });
+                    });
+                    this.socket.on("connect_error", function(error) {
+                        console.error("Socket connection error:", error);
+                    });
+                }
+            }
+        },
+        {
+            /// get socket instance
+            key: "getSocketInstance",
+            value: function getSocketInstance() {
+                if (!this.socket) {
+                    this.initSocket();
+                }
+                if (!this.socket) {
+                    throw new Error("Socket not initialized");
+                }
+                if (!this.socket.connected) {
+                    this.socket.connect();
+                }
+                return this.socket;
+            }
+        },
+        {
+            /// subscribe to collections
+            key: "subscribeToCollections",
+            value: function subscribeToCollections(config) {
+                var s = this.getSocketInstance();
+                var collectionsNames = config.map(function(c) {
+                    return c.collectionName;
+                });
+                var eventHandlers = [];
+                config.forEach(function(configuration) {
+                    var collectionName = configuration.collectionName, onAdd = configuration.onAdd, onFirstTime = configuration.onFirstTime, onModify = configuration.onModify, onRemove = configuration.onRemove, extraParsers = configuration.extraParsers, conditions = configuration.conditions, orderBy2 = configuration.orderBy;
+                    s.on("initial:".concat(collectionName), onFirstTime);
+                    eventHandlers.push({
+                        eventName: "initial:".concat(collectionName),
+                        handler: onFirstTime
+                    });
+                    s.on("add:".concat(collectionName), onAdd);
+                    eventHandlers.push({
+                        eventName: "add:".concat(collectionName),
+                        handler: onAdd
+                    });
+                    s.on("update:".concat(collectionName), onModify);
+                    eventHandlers.push({
+                        eventName: "update:".concat(collectionName),
+                        handler: onModify
+                    });
+                    s.on("delete:".concat(collectionName), onRemove);
+                    eventHandlers.push({
+                        eventName: "delete:".concat(collectionName),
+                        handler: onRemove
+                    });
+                    extraParsers === null || extraParsers === void 0 ? void 0 : extraParsers.forEach(function(parsers) {
+                        var extraOnAdd = parsers.onAdd, extraOnFirstTime = parsers.onFirstTime, extraOnModify = parsers.onModify, extraOnRemove = parsers.onRemove;
+                        s.on("initial:".concat(collectionName), extraOnFirstTime);
+                        eventHandlers.push({
+                            eventName: "initial:".concat(collectionName),
+                            handler: extraOnFirstTime
+                        });
+                        s.on("add:".concat(collectionName), extraOnAdd);
+                        eventHandlers.push({
+                            eventName: "add:".concat(collectionName),
+                            handler: extraOnAdd
+                        });
+                        s.on("update:".concat(collectionName), extraOnModify);
+                        eventHandlers.push({
+                            eventName: "update:".concat(collectionName),
+                            handler: extraOnModify
+                        });
+                        s.on("delete:".concat(collectionName), extraOnRemove);
+                        eventHandlers.push({
+                            eventName: "delete:".concat(collectionName),
+                            handler: extraOnRemove
+                        });
+                    });
+                });
+                s.emit("subscribe_collections", collectionsNames, function(callback) {
+                    if (callback.success) {
+                        console.log("Successfully subscribed to: ".concat(collectionsNames.join(", ")));
+                    } else {
+                        console.error("Failed to subscribe to ".concat(config.join(", "), ": ").concat(callback.message));
+                    }
+                });
+                return function() {
+                    console.log("Cleaning up subscriptions for: ".concat(collectionsNames.join(", ")));
+                    s.emit("unsubscribe_collections", collectionsNames);
+                    eventHandlers.forEach(function(eh) {
+                        s.off(eh.eventName, eh.handler);
+                    });
+                };
+            }
+        },
+        {
+            /// set data
+            key: "setData",
+            value: function setData(payload) {
+                var s = this.getSocketInstance();
+                return new Promise(function(resolve, reject) {
+                    s.emit("set_data", payload, function(callback) {
+                        if (callback.success) {
+                            console.log("Data saved successfully:", payload);
+                            console.log("ack", callback);
+                            resolve(callback);
+                        } else {
+                            reject(new Error(callback.message || "Save operation failed"));
+                        }
+                    });
+                });
+            }
+        },
+        {
+            /// get data
+            key: "getCollectionData",
+            value: function getCollectionData(payload) {
+                var s = this.getSocketInstance();
+                s.emit("get_data", {
+                    collection_name: payload.collection_name
+                }, function(socketCallback) {
+                    if (socketCallback.success && socketCallback.data) {
+                        payload.callback(socketCallback.data);
+                    } else {
+                        payload.callback(payload.defaultValue);
+                    }
+                });
+            }
+        },
+        {
+            key: "getDocumentData",
+            value: function getDocumentData(payload) {
+                var s = this.getSocketInstance();
+                s.emit("get_data", {
+                    collection_name: payload.collection_name,
+                    key: payload.key
+                }, function(socketCallback) {
+                    if (socketCallback.success && socketCallback.data) {
+                        payload.callback(socketCallback.data);
+                    } else {
+                        payload.callback(payload.defaultValue);
+                    }
+                });
+            }
+        },
+        {
+            /// delete data
+            key: "deleteData",
+            value: function deleteData(payload) {
+                var s = this.getSocketInstance();
+                return new Promise(function(resolve, reject) {
+                    s.emit("delete_data", payload, function(callback) {
+                        if (callback.success) {
+                            console.log("Data deleted successfully:", payload);
+                            console.log("delete ack", callback);
+                            resolve(callback);
+                        } else {
+                            reject(new Error(callback.message || "Delete operation failed"));
+                        }
+                    });
+                });
+            }
+        },
+        {
+            key: "clearAllRedisData",
+            value: function clearAllRedisData() {
+                var s = this.getSocketInstance();
+                return new Promise(function(resolve, reject) {
+                    s.emit("clear_all_redis_data", function(ack) {
+                        if (ack.success) {
+                            resolve(ack);
+                        } else {
+                            reject(new Error(ack.message || "Clear all Redis data operation failed"));
+                        }
+                    });
+                });
+            }
+        },
+        {
+            /// connection management methods
+            key: "onConnect",
+            value: function onConnect(callback) {
+                var _this_socket;
+                this.connectCallbacks.push(callback);
+                if ((_this_socket = this.socket) === null || _this_socket === void 0 ? void 0 : _this_socket.connected) {
+                    callback();
+                }
+            }
+        },
+        {
+            key: "offConnect",
+            value: function offConnect(callback) {
+                this.connectCallbacks = this.connectCallbacks.filter(function(cb) {
+                    return cb !== callback;
+                });
+            }
+        },
+        {
+            key: "onDisconnect",
+            value: function onDisconnect(callback) {
+                this.disconnectCallbacks.push(callback);
+                if (this.socket && !this.socket.connected) {
+                    callback();
+                }
+            }
+        },
+        {
+            key: "offDisconnect",
+            value: function offDisconnect(callback) {
+                this.disconnectCallbacks = this.disconnectCallbacks.filter(function(cb) {
+                    return cb !== callback;
+                });
+            }
+        },
+        {
+            key: "isConnected",
+            value: function isConnected() {
+                var _this_socket;
+                return ((_this_socket = this.socket) === null || _this_socket === void 0 ? void 0 : _this_socket.connected) || false;
+            }
+        }
+    ], [
+        {
+            key: "getInstance",
+            value: function getInstance() {
+                if (!_SocketService.instance) {
+                    _SocketService.instance = new _SocketService();
+                }
+                return _SocketService.instance;
+            }
+        }
+    ]);
+    return _SocketService;
+}();
+var socketServiceInstance = SocketService.getInstance();
 // src/hooks/react.ts
 import { isEqual as isEqual2 } from "lodash";
 import { useEffect, useMemo, useRef } from "react";
@@ -549,5 +929,79 @@ var useSetUserCountry = function(setUserCountry, changLang) {
 };
 // src/hooks/WebWorker.ts
 import { useCallback as useCallback2, useEffect as useEffect3, useRef as useRef3 } from "react";
-export { useDeepCompareEffect, useDeepCompareMemo, useDocumentTitle, useSafeEffect, useSetUserCountry, useSnapshotBulk };
+// src/hooks/socket.ts
+import { useEffect as useEffect4, useState } from "react";
+var useSocketSubscription = function(config) {
+    var _useState = _sliced_to_array(useState(socketServiceInstance.isConnected()), 2), socketConnected = _useState[0], setSocketConnected = _useState[1];
+    useDeepCompareEffect(function() {
+        var cleanupSubscriptions;
+        if (socketConnected) {
+            cleanupSubscriptions = socketServiceInstance.subscribeToCollections(config);
+        }
+        var uiOnConnect = function() {
+            setSocketConnected(true);
+        };
+        var uiOnDisconnect = function() {
+            cleanupSubscriptions === null || cleanupSubscriptions === void 0 ? void 0 : cleanupSubscriptions();
+            setSocketConnected(false);
+        };
+        socketServiceInstance.onConnect(uiOnConnect);
+        socketServiceInstance.onDisconnect(uiOnDisconnect);
+        setSocketConnected(socketServiceInstance.isConnected());
+        return function() {
+            console.log("cleanupSubscriptions");
+            cleanupSubscriptions === null || cleanupSubscriptions === void 0 ? void 0 : cleanupSubscriptions();
+            socketServiceInstance.offConnect(uiOnConnect);
+            socketServiceInstance.offDisconnect(uiOnDisconnect);
+        };
+    }, [
+        socketConnected
+    ]);
+    return {
+        socketConnected: socketConnected
+    };
+};
+var useSmartSnapshot = function(configs, options) {
+    var _useState = _sliced_to_array(useState(null), 2), cacheCollectionsConfig = _useState[0], setCacheCollectionsConfig = _useState[1];
+    useEffect4(function() {
+        get_document_by_id("nx-settings", "cache_collections_config").then(function(res) {
+            return setCacheCollectionsConfig(res);
+        });
+        return function() {
+            return setCacheCollectionsConfig(null);
+        };
+    }, []);
+    var groupedConfig = useDeepCompareMemo(function() {
+        if (!cacheCollectionsConfig) {
+            return {
+                configForDb: [],
+                configForCache: []
+            };
+        }
+        var configForDb = [];
+        var configForCache = [];
+        configs.forEach(function(cfg) {
+            var collectionName = cfg.collectionName, _cfg_subscribeTo = cfg.subscribeTo, subscribeTo = _cfg_subscribeTo === void 0 ? "cache" : _cfg_subscribeTo;
+            if (subscribeTo === "cache" && cacheCollectionsConfig[collectionName]) {
+                configForCache.push(cfg);
+            } else {
+                configForDb.push(cfg);
+            }
+        });
+        return {
+            configForDb: configForDb,
+            configForCache: configForCache
+        };
+    }, [
+        configs,
+        cacheCollectionsConfig
+    ]);
+    useSnapshotBulk(groupedConfig.configForDb, options === null || options === void 0 ? void 0 : options.label, options === null || options === void 0 ? void 0 : options.settings);
+    useSocketSubscription(groupedConfig.configForCache);
+    return {
+        groupedConfig: groupedConfig,
+        socketConnected: socketServiceInstance.isConnected()
+    };
+};
+export { useDeepCompareEffect, useDeepCompareMemo, useDocumentTitle, useSafeEffect, useSetUserCountry, useSmartSnapshot, useSnapshotBulk, useSocketSubscription };
 //# sourceMappingURL=index.mjs.map

package/dist/types/index.d.mts

@@ -97,6 +97,8 @@ interface OnSnapshotConfig extends OnSnapshotParsers {
         fieldName: string;
         direction: "asc" | "desc";
     }[];
+    parseAs?: "object" | "array";
+    subscribeTo?: "cache" | "db";
 }
 interface OnSnapshotConfigDocument extends Omit<OnSnapshotParsers, "onAdd"> {
     collectionName: string;

package/dist/types/index.d.ts

@@ -97,6 +97,8 @@ interface OnSnapshotConfig extends OnSnapshotParsers {
         fieldName: string;
         direction: "asc" | "desc";
     }[];
+    parseAs?: "object" | "array";
+    subscribeTo?: "cache" | "db";
 }
 interface OnSnapshotConfigDocument extends Omit<OnSnapshotParsers, "onAdd"> {
     collectionName: string;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "akeyless-client-commons",
-    "version": "1.1.7",
+    "version": "1.1.9",
     "scripts": {
         "build": "tsup",
         "deploy": "npm run build && npm version patch --no-git-tag-version && npm publish",
@@ -16,7 +16,7 @@
         "@radix-ui/react-progress": "^1.1.1",
         "@radix-ui/react-slot": "^1.1.2",
         "@types/lodash": "^4.17.13",
-        "akeyless-types-commons": "^1.0.18",
+        "akeyless-types-commons": "^1.0.41",
         "assets": "^3.0.1",
         "axios": "^1.7.9",
         "class-variance-authority": "^0.7.0",
@@ -35,8 +35,10 @@
         "react-dom": "^18.3.1",
         "react-phone-number-input": "^3.4.10",
         "react-spinners": "^0.14.1",
+        "socket.io-client": "^4.8.1",
         "tailwind-merge": "^2.5.4",
         "tailwindcss-animate": "^1.0.7",
+        "types": "^0.1.1",
         "xregexp": "^5.1.1",
         "zustand": "^5.0.0"
     },