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

package/hooks/useAccess.js

@@ -0,0 +1,321 @@
+"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;
+  });
+
+  // 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
+    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
+      };
+      accessCache.set(cacheKey, grantedState);
+      setLocalState(grantedState);
+      hasCheckedRef.current = true;
+      return;
+    }
+
+    // Check if we already have valid cached result
+    var 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);
+      };
+    }();
+    performCheck();
+  }, [checkComponentAccess, cacheKey]);
+
+  // Cleanup on unmount
+  (0, _react.useEffect)(function () {
+    return function () {
+      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 () {
+    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);
+      };
+    }();
+    performCheck();
+  }, [checkComponentAccess, cacheKey]);
+  return {
+    hasAccess: localState.hasAccess,
+    loading: localState.loading,
+    error: localState.error,
+    retry: retry,
+    // Expose cache key for debugging
+    cacheKey: cacheKey
+  };
+};
+
+// Utility function to clear all access cache (useful for logout)
+var clearAccessCache = exports.clearAccessCache = function 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;

package/hooks/useAppConfig.d.ts

@@ -0,0 +1,3 @@
+export declare const useAppConfig: () => {
+    getServiceDefinitionsData: (baseURL: string) => Promise<any>;
+};

package/hooks/useAppConfig.js

@@ -0,0 +1,42 @@
+"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);
+    };
+  }();
+  return {
+    getServiceDefinitionsData: getServiceDefinitionsData
+  };
+};

package/hooks/useAuth.d.ts

@@ -0,0 +1,55 @@
+import { LoginOptions } from "@wavemaker-ai/react-runtime/store/slices/authSlice";
+export declare const useAuth: () => {
+    isLoggedIn: boolean;
+    loggedInUser: import("@wavemaker-ai/react-runtime/store/slices/authSlice").LoggedInUserConfig;
+    securityConfig: any;
+    isPageLoading: boolean;
+    error: string;
+    login: (options: LoginOptions) => Promise<any>;
+    logout: (baseURL: string) => Promise<any>;
+    canAccessPage: (pageName: string) => Promise<any>;
+    hasAccessToWidget: (widgetRoles: string) => boolean;
+    getLoggedInUserDetails: (baseURL: string) => Promise<any>;
+    navigateToLandingPage: (options: {
+        baseUrl: string;
+        pageName: string;
+    }) => Promise<any>;
+};
+export declare const usePageAccess: (pageName: string) => {
+    hasAccess: boolean;
+    loading: boolean;
+};
+export declare const useWidgetAccess: (widgetRoles: string) => boolean;
+export declare const useAccess: (name: string, type: "PAGE" | "PARTIAL" | "PREFAB") => {
+    hasAccess: boolean;
+    loading: boolean;
+};
+/**
+ * Synchronous access checker for use outside of React components
+ * @param name - Name of the page or partial
+ * @param type - Type: 'PAGE' or 'PARTIAL'
+ * @param authState - Current auth state from Redux store
+ * @param appConfig - App configuration containing pages and partials
+ * @returns boolean indicating if access is granted
+ */
+export declare const checkAccessSync: (name: string, type: "PAGE" | "PARTIAL", authState: any, appConfig: any) => boolean;
+export declare const useLogin: () => {
+    loading: boolean;
+    error: string;
+    isLoggedIn: boolean;
+    handleLogin: (options: LoginOptions) => Promise<boolean>;
+    clearError: () => void;
+};
+export declare const useLogout: () => {
+    loading: boolean;
+    error: string;
+    handleLogout: (baseURL: string) => Promise<boolean>;
+    clearError: () => void;
+};
+export declare const useCurrentUser: () => {
+    user: import("@wavemaker-ai/react-runtime/store/slices/authSlice").LoggedInUserConfig;
+    isLoggedIn: boolean;
+    hasRole: (role: string) => boolean;
+    hasAnyRole: (roles: string[]) => boolean;
+    hasAllRoles: (roles: string[]) => boolean;
+};