@wavemaker-ai/react-runtime 1.0.0-rc.309 → 1.0.0-rc.314

package/hooks/useAccess.js

@@ -1,321 +1,145 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.useAccess = exports.preloadAccess = exports["default"] = exports.clearAccessCache = void 0;
-var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
-var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
-var _react = require("react");
-var _store = require("@wavemaker-ai/react-runtime/store");
-var _authSlice = require("../store/slices/authSlice");
-// Global cache for access results to prevent duplicate checks
-var accessCache = new Map();
-var pendingChecks = new Map();
-var useAccess = exports.useAccess = function useAccess(options) {
-  var componentName = options.componentName,
-    type = options.type,
-    _options$enabled = options.enabled,
-    enabled = _options$enabled === void 0 ? true : _options$enabled;
-  var dispatch = (0, _store.useAppDispatch)();
-
-  // Get security config from store
-  var isSecurityEnabled = (0, _store.useAppSelector)(function (state) {
-    var _state$auth$securityC;
-    return (_state$auth$securityC = state.auth.securityConfig) === null || _state$auth$securityC === void 0 ? void 0 : _state$auth$securityC.isSecurityEnabled;
+import { useState, useEffect, useRef, useCallback } from "react";
+import { useAppDispatch, useAppSelector } from "../store";
+import { checkAccess } from "../store/slices/authSlice";
+const accessCache = /* @__PURE__ */ new Map();
+const pendingChecks = /* @__PURE__ */ new Map();
+const useAccess = (options) => {
+  const { componentName, type, enabled = true } = options;
+  const dispatch = useAppDispatch();
+  const isSecurityEnabled = useAppSelector(
+    (state) => {
+      var _a;
+      return (_a = state.auth.securityConfig) == null ? void 0 : _a.isSecurityEnabled;
+    }
+  );
+  const cacheKey = `${type}_${componentName}`;
+  const [localState, setLocalState] = useState(() => {
+    var _a, _b, _c;
+    const cached = accessCache.get(cacheKey);
+    const defaultAccess = !isSecurityEnabled ? true : false;
+    return {
+      hasAccess: (_a = cached == null ? void 0 : cached.hasAccess) != null ? _a : defaultAccess,
+      loading: (_b = cached == null ? void 0 : cached.loading) != null ? _b : isSecurityEnabled ? true : false,
+      error: (_c = cached == null ? void 0 : cached.error) != null ? _c : null
+    };
   });
-
-  // Create a unique key for this component
-  var cacheKey = "".concat(type, "_").concat(componentName);
-
-  // Local state for this component
-  var _useState = (0, _react.useState)(function () {
-      var _cached$hasAccess, _cached$loading, _cached$error;
-      // Check if we already have cached result
-      var cached = accessCache.get(cacheKey);
-
-      // If security is disabled, default to access granted
-      var defaultAccess = !isSecurityEnabled ? true : false;
-      return {
-        hasAccess: (_cached$hasAccess = cached === null || cached === void 0 ? void 0 : cached.hasAccess) !== null && _cached$hasAccess !== void 0 ? _cached$hasAccess : defaultAccess,
-        loading: (_cached$loading = cached === null || cached === void 0 ? void 0 : cached.loading) !== null && _cached$loading !== void 0 ? _cached$loading : isSecurityEnabled ? true : false,
-        error: (_cached$error = cached === null || cached === void 0 ? void 0 : cached.error) !== null && _cached$error !== void 0 ? _cached$error : null
-      };
-    }),
-    localState = _useState[0],
-    setLocalState = _useState[1];
-  var mountedRef = (0, _react.useRef)(true);
-  var hasCheckedRef = (0, _react.useRef)(false);
-
-  // Memoized access check function
-  var checkComponentAccess = (0, _react.useCallback)(/*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee() {
-    var checkPromise, result;
-    return _regenerator["default"].wrap(function _callee$(_context) {
-      while (1) switch (_context.prev = _context.next) {
-        case 0:
-          if (isSecurityEnabled) {
-            _context.next = 2;
-            break;
-          }
-          return _context.abrupt("return", true);
-        case 2:
-          if (enabled) {
-            _context.next = 4;
-            break;
-          }
-          return _context.abrupt("return", true);
-        case 4:
-          if (!pendingChecks.has(cacheKey)) {
-            _context.next = 6;
-            break;
-          }
-          return _context.abrupt("return", pendingChecks.get(cacheKey));
-        case 6:
-          // Create new access check promise
-          checkPromise = dispatch((0, _authSlice.checkAccess)({
-            name: componentName,
-            type: type
-          })).unwrap(); // Store the pending promise
-          pendingChecks.set(cacheKey, checkPromise);
-          _context.prev = 8;
-          _context.next = 11;
-          return checkPromise;
-        case 11:
-          result = _context.sent;
-          return _context.abrupt("return", result);
-        case 15:
-          _context.prev = 15;
-          _context.t0 = _context["catch"](8);
-          return _context.abrupt("return", false);
-        case 18:
-          _context.prev = 18;
-          // Remove from pending checks
-          pendingChecks["delete"](cacheKey);
-          return _context.finish(18);
-        case 21:
-        case "end":
-          return _context.stop();
-      }
-    }, _callee, null, [[8, 15, 18, 21]]);
-  })), [dispatch, componentName, type, isSecurityEnabled, enabled, cacheKey]);
-
-  // Effect to perform access check
-  (0, _react.useEffect)(function () {
-    // Don't check if component is unmounted
+  const mountedRef = useRef(true);
+  const hasCheckedRef = useRef(false);
+  const checkComponentAccess = useCallback(async () => {
+    if (!isSecurityEnabled) {
+      return true;
+    }
+    if (!enabled) {
+      return true;
+    }
+    if (pendingChecks.has(cacheKey)) {
+      return pendingChecks.get(cacheKey);
+    }
+    const checkPromise = dispatch(checkAccess({ name: componentName, type })).unwrap();
+    pendingChecks.set(cacheKey, checkPromise);
+    try {
+      const result = await checkPromise;
+      return result;
+    } catch (error) {
+      return false;
+    } finally {
+      pendingChecks.delete(cacheKey);
+    }
+  }, [dispatch, componentName, type, isSecurityEnabled, enabled, cacheKey]);
+  useEffect(() => {
     if (!mountedRef.current) return;
-
-    // Don't check multiple times
     if (hasCheckedRef.current) return;
-
-    // Skip access check entirely when security is disabled
     if (!isSecurityEnabled) {
-      var grantedState = {
-        hasAccess: true,
-        loading: false,
-        error: null
-      };
+      const grantedState = { hasAccess: true, loading: false, error: null };
       accessCache.set(cacheKey, grantedState);
       setLocalState(grantedState);
       hasCheckedRef.current = true;
       return;
     }
-
-    // Check if we already have valid cached result
-    var cached = accessCache.get(cacheKey);
+    const cached = accessCache.get(cacheKey);
     if (cached && !cached.loading) {
       setLocalState(cached);
       hasCheckedRef.current = true;
       return;
     }
-
-    // Start access check
-    var performCheck = /*#__PURE__*/function () {
-      var _ref2 = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee2() {
-        var loadingState, hasAccess, resultState, errorState;
-        return _regenerator["default"].wrap(function _callee2$(_context2) {
-          while (1) switch (_context2.prev = _context2.next) {
-            case 0:
-              if (mountedRef.current) {
-                _context2.next = 2;
-                break;
-              }
-              return _context2.abrupt("return");
-            case 2:
-              // Update cache and local state to loading
-              loadingState = {
-                hasAccess: false,
-                loading: true,
-                error: null
-              };
-              accessCache.set(cacheKey, loadingState);
-              setLocalState(loadingState);
-              _context2.prev = 5;
-              _context2.next = 8;
-              return checkComponentAccess();
-            case 8:
-              hasAccess = _context2.sent;
-              if (mountedRef.current) {
-                _context2.next = 11;
-                break;
-              }
-              return _context2.abrupt("return");
-            case 11:
-              // Update cache and local state with result
-              resultState = {
-                hasAccess: hasAccess,
-                loading: false,
-                error: null
-              };
-              accessCache.set(cacheKey, resultState);
-              setLocalState(resultState);
-              hasCheckedRef.current = true;
-              _context2.next = 25;
-              break;
-            case 17:
-              _context2.prev = 17;
-              _context2.t0 = _context2["catch"](5);
-              if (mountedRef.current) {
-                _context2.next = 21;
-                break;
-              }
-              return _context2.abrupt("return");
-            case 21:
-              // Update cache and local state with error
-              errorState = {
-                hasAccess: false,
-                loading: false,
-                error: _context2.t0
-              };
-              accessCache.set(cacheKey, errorState);
-              setLocalState(errorState);
-              hasCheckedRef.current = true;
-            case 25:
-            case "end":
-              return _context2.stop();
-          }
-        }, _callee2, null, [[5, 17]]);
-      }));
-      return function performCheck() {
-        return _ref2.apply(this, arguments);
-      };
-    }();
+    const performCheck = async () => {
+      if (!mountedRef.current) return;
+      const loadingState = { hasAccess: false, loading: true, error: null };
+      accessCache.set(cacheKey, loadingState);
+      setLocalState(loadingState);
+      try {
+        const hasAccess = await checkComponentAccess();
+        if (!mountedRef.current) return;
+        const resultState = { hasAccess, loading: false, error: null };
+        accessCache.set(cacheKey, resultState);
+        setLocalState(resultState);
+        hasCheckedRef.current = true;
+      } catch (error) {
+        if (!mountedRef.current) return;
+        const errorState = { hasAccess: false, loading: false, error };
+        accessCache.set(cacheKey, errorState);
+        setLocalState(errorState);
+        hasCheckedRef.current = true;
+      }
+    };
     performCheck();
   }, [checkComponentAccess, cacheKey]);
-
-  // Cleanup on unmount
-  (0, _react.useEffect)(function () {
-    return function () {
+  useEffect(() => {
+    return () => {
       mountedRef.current = false;
-      // Optionally clear cache entry on unmount to free memory
-      // accessCache.delete(cacheKey);
-      // pendingChecks.delete(cacheKey);
     };
   }, [cacheKey]);
-
-  // Retry function for manual retry
-  var retry = (0, _react.useCallback)(function () {
+  const retry = useCallback(() => {
     hasCheckedRef.current = false;
-    accessCache["delete"](cacheKey);
-    pendingChecks["delete"](cacheKey);
-
-    // Trigger re-check
-    var performCheck = /*#__PURE__*/function () {
-      var _ref3 = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee3() {
-        var loadingState, hasAccess, resultState, errorState;
-        return _regenerator["default"].wrap(function _callee3$(_context3) {
-          while (1) switch (_context3.prev = _context3.next) {
-            case 0:
-              loadingState = {
-                hasAccess: false,
-                loading: true,
-                error: null
-              };
-              accessCache.set(cacheKey, loadingState);
-              setLocalState(loadingState);
-              _context3.prev = 3;
-              _context3.next = 6;
-              return checkComponentAccess();
-            case 6:
-              hasAccess = _context3.sent;
-              resultState = {
-                hasAccess: hasAccess,
-                loading: false,
-                error: null
-              };
-              accessCache.set(cacheKey, resultState);
-              setLocalState(resultState);
-              hasCheckedRef.current = true;
-              _context3.next = 19;
-              break;
-            case 13:
-              _context3.prev = 13;
-              _context3.t0 = _context3["catch"](3);
-              errorState = {
-                hasAccess: false,
-                loading: false,
-                error: _context3.t0
-              };
-              accessCache.set(cacheKey, errorState);
-              setLocalState(errorState);
-              hasCheckedRef.current = true;
-            case 19:
-            case "end":
-              return _context3.stop();
-          }
-        }, _callee3, null, [[3, 13]]);
-      }));
-      return function performCheck() {
-        return _ref3.apply(this, arguments);
-      };
-    }();
+    accessCache.delete(cacheKey);
+    pendingChecks.delete(cacheKey);
+    const performCheck = async () => {
+      const loadingState = { hasAccess: false, loading: true, error: null };
+      accessCache.set(cacheKey, loadingState);
+      setLocalState(loadingState);
+      try {
+        const hasAccess = await checkComponentAccess();
+        const resultState = { hasAccess, loading: false, error: null };
+        accessCache.set(cacheKey, resultState);
+        setLocalState(resultState);
+        hasCheckedRef.current = true;
+      } catch (error) {
+        const errorState = { hasAccess: false, loading: false, error };
+        accessCache.set(cacheKey, errorState);
+        setLocalState(errorState);
+        hasCheckedRef.current = true;
+      }
+    };
     performCheck();
   }, [checkComponentAccess, cacheKey]);
   return {
     hasAccess: localState.hasAccess,
     loading: localState.loading,
     error: localState.error,
-    retry: retry,
+    retry,
     // Expose cache key for debugging
-    cacheKey: cacheKey
+    cacheKey
   };
 };
-
-// Utility function to clear all access cache (useful for logout)
-var clearAccessCache = exports.clearAccessCache = function clearAccessCache() {
+const clearAccessCache = () => {
   accessCache.clear();
   pendingChecks.clear();
 };
-
-// Utility function to preload access for multiple components
-var preloadAccess = exports.preloadAccess = /*#__PURE__*/function () {
-  var _ref4 = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee4(components, dispatch) {
-    var promises;
-    return _regenerator["default"].wrap(function _callee4$(_context4) {
-      while (1) switch (_context4.prev = _context4.next) {
-        case 0:
-          promises = components.map(function (_ref5) {
-            var _accessCache$get;
-            var name = _ref5.name,
-              type = _ref5.type;
-            var cacheKey = "".concat(type, "_").concat(name);
-            if (!accessCache.has(cacheKey)) {
-              return dispatch((0, _authSlice.checkAccess)({
-                name: name,
-                type: type
-              })).unwrap();
-            }
-            return Promise.resolve((_accessCache$get = accessCache.get(cacheKey)) === null || _accessCache$get === void 0 ? void 0 : _accessCache$get.hasAccess);
-          });
-          return _context4.abrupt("return", Promise.allSettled(promises));
-        case 2:
-        case "end":
-          return _context4.stop();
-      }
-    }, _callee4);
-  }));
-  return function preloadAccess(_x, _x2) {
-    return _ref4.apply(this, arguments);
-  };
-}();
-var _default = exports["default"] = useAccess;
+const preloadAccess = async (components, dispatch) => {
+  const promises = components.map(({ name, type }) => {
+    var _a;
+    const cacheKey = `${type}_${name}`;
+    if (!accessCache.has(cacheKey)) {
+      return dispatch(checkAccess({ name, type })).unwrap();
+    }
+    return Promise.resolve((_a = accessCache.get(cacheKey)) == null ? void 0 : _a.hasAccess);
+  });
+  return Promise.allSettled(promises);
+};
+var useAccess_default = useAccess;
+export {
+  clearAccessCache,
+  useAccess_default as default,
+  preloadAccess,
+  useAccess
+};

package/hooks/useAppConfig.js

@@ -1,42 +1,17 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.useAppConfig = void 0;
-var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
-var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
-var _store = require("../store");
-var _appConfigSlice = require("@wavemaker-ai/react-runtime/store/slices/appConfigSlice");
-var useAppConfig = exports.useAppConfig = function useAppConfig() {
-  var dispatch = (0, _store.useAppDispatch)();
-  var getServiceDefinitionsData = /*#__PURE__*/function () {
-    var _ref = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee(baseURL) {
-      return _regenerator["default"].wrap(function _callee$(_context) {
-        while (1) switch (_context.prev = _context.next) {
-          case 0:
-            if (baseURL) {
-              _context.next = 2;
-              break;
-            }
-            return _context.abrupt("return", Promise.resolve({}));
-          case 2:
-            _context.next = 4;
-            return dispatch((0, _appConfigSlice.getServiceDefinitions)(baseURL)).unwrap();
-          case 4:
-            return _context.abrupt("return", _context.sent);
-          case 5:
-          case "end":
-            return _context.stop();
-        }
-      }, _callee);
-    }));
-    return function getServiceDefinitionsData(_x) {
-      return _ref.apply(this, arguments);
-    };
-  }();
+import { useAppDispatch } from "../store";
+import { getServiceDefinitions } from "../store/slices/appConfigSlice";
+const useAppConfig = () => {
+  const dispatch = useAppDispatch();
+  const getServiceDefinitionsData = async (baseURL) => {
+    if (!baseURL) {
+      return Promise.resolve({});
+    }
+    return await dispatch(getServiceDefinitions(baseURL)).unwrap();
+  };
   return {
-    getServiceDefinitionsData: getServiceDefinitionsData
+    getServiceDefinitionsData
   };
-};
+};
+export {
+  useAppConfig
+};