@selfcommunity/react-core 0.7.0-alpha.0 → 0.7.0-alpha.10

package/lib/esm/hooks/useSCFetchCourse.js

@@ -46,6 +46,21 @@ export default function useSCFetchCourse({ id = null, course = null, cacheStrate
             return Promise.resolve(res.data);
         });
     }, []);
+    /**
+     * Refresh course
+     */
+    const refreshCourse = useMemo(() => () => {
+        fetchCourse(id)
+            .then((e) => {
+            setSCCourse(e);
+        })
+            .catch((err) => {
+            LRUCache.delete(__courseCacheKey);
+            setError(`Error on refresh course with id ${id}`);
+            Logger.error(SCOPE_SC_CORE, `Error on refresh course with id ${id}`);
+            Logger.error(SCOPE_SC_CORE, err.message);
+        });
+    }, [id, __courseCacheKey, setSCCourse]);
     /**
      * If id attempt to get the course by id
      */
@@ -74,20 +89,5 @@ export default function useSCFetchCourse({ id = null, course = null, cacheStrate
             setSCCourse(course);
         }
     }, [course, authUserId]);
-    /**
-     * Refreshes course data from the network
-     */
-    const refreshCourse = useCallback(() => {
-        if (id) {
-            fetchCourse(id)
-                .then((e) => {
-                setSCCourse(e);
-            })
-                .catch((err) => {
-                setError(`Failed to refresh course data: ${err.message}`);
-                Logger.error(SCOPE_SC_CORE, err.message);
-            });
-        }
-    }, [id, fetchCourse]);
     return { scCourse, setSCCourse, error, refreshCourse };
 }

package/lib/esm/hooks/useSCFetchEvent.d.ts

@@ -19,4 +19,5 @@ export default function useSCFetchEvent({ id, event, autoSubscribe, cacheStrateg
     scEvent: SCEventType;
     setSCEvent: (e: SCEventType) => void;
     error: string;
+    refreshEvent: () => () => void;
 };

package/lib/esm/hooks/useSCFetchEvent.js

@@ -66,6 +66,21 @@ export default function useSCFetchEvent({ id = null, event = null, autoSubscribe
             return Promise.resolve(res.data);
         });
     }, []);
+    /**
+     * Refresh event
+     */
+    const refreshEvent = useMemo(() => () => () => {
+        fetchEvent(id)
+            .then((e) => {
+            setSCEvent(e);
+        })
+            .catch((err) => {
+            LRUCache.delete(__eventCacheKey);
+            setError(`Error on refresh event with id ${id}`);
+            Logger.error(SCOPE_SC_CORE, `Error on refresh event with id ${id}`);
+            Logger.error(SCOPE_SC_CORE, err.message);
+        });
+    }, [id, setSCEvent, __eventCacheKey]);
     /**
      * If id attempt to get the event by id
      */
@@ -88,5 +103,5 @@ export default function useSCFetchEvent({ id = null, event = null, autoSubscribe
             setSCEvent(event);
         }
     }, [event, authUserId]);
-    return { scEvent, setSCEvent, error };
+    return { scEvent, setSCEvent, error, refreshEvent };
 }

package/lib/esm/hooks/useSCFetchGroup.d.ts

@@ -17,4 +17,5 @@ export default function useSCFetchGroup({ id, group, cacheStrategy, }: {
     scGroup: SCGroupType;
     setSCGroup: (group: SCGroupType) => void;
     error: string;
+    refreshGroup: () => void;
 };

package/lib/esm/hooks/useSCFetchGroup.js

@@ -45,6 +45,21 @@ export default function useSCFetchGroup({ id = null, group = null, cacheStrategy
             return Promise.resolve(res.data);
         });
     }, [__groupId]);
+    /**
+     * Refresh group
+     */
+    const refreshGroup = useMemo(() => () => {
+        fetchGroup()
+            .then((obj) => {
+            setSCGroup(obj);
+        })
+            .catch((err) => {
+            LRUCache.delete(__groupCacheKey);
+            setError(`Error on refresh group with id ${id}`);
+            Logger.error(SCOPE_SC_CORE, `Error on refresh group with id ${id}`);
+            Logger.error(SCOPE_SC_CORE, err.message);
+        });
+    }, [__groupCacheKey, setSCGroup]);
     /**
      * If id attempt to get the group by id
      */
@@ -67,5 +82,5 @@ export default function useSCFetchGroup({ id = null, group = null, cacheStrategy
             setSCGroup(group);
         }
     }, [group, authUserId]);
-    return { scGroup, setSCGroup, error };
+    return { scGroup, setSCGroup, error, refreshGroup };
 }

package/lib/esm/hooks/useSCFetchPaymentOrder.d.ts

@@ -0,0 +1,20 @@
+import { SCPaymentOrder } from '@selfcommunity/types';
+import { CacheStrategies } from '@selfcommunity/utils';
+/**
+ :::info
+ This custom hook is used to fetch a payment order.
+ :::
+ * @param object
+ * @param object.id
+ * @param object.paymentOrder
+ * @param object.cacheStrategy
+ */
+export default function useSCFetchPaymentOrder({ id, paymentOrder, cacheStrategy, }: {
+    id?: number | string;
+    paymentOrder?: SCPaymentOrder;
+    cacheStrategy?: CacheStrategies;
+}): {
+    scPaymentOrder: SCPaymentOrder;
+    setSCPaymentOrder: (c: SCPaymentOrder) => void;
+    error: string;
+};

package/lib/esm/hooks/useSCFetchPaymentOrder.js

@@ -0,0 +1,67 @@
+import { Endpoints, http } from '@selfcommunity/api-services';
+import { CacheStrategies, Logger, LRUCache } from '@selfcommunity/utils';
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import { useDeepCompareEffectNoCheck } from 'use-deep-compare-effect';
+import { useSCUser } from '../components/provider/SCUserProvider';
+import { getPaymentOrderObjectCacheKey } from '../constants/Cache';
+import { SCOPE_SC_CORE } from '../constants/Errors';
+/**
+ :::info
+ This custom hook is used to fetch a payment order.
+ :::
+ * @param object
+ * @param object.id
+ * @param object.paymentOrder
+ * @param object.cacheStrategy
+ */
+export default function useSCFetchPaymentOrder({ id = null, paymentOrder = null, cacheStrategy = CacheStrategies.NETWORK_ONLY, }) {
+    const __paymentOrderId = useMemo(() => (paymentOrder === null || paymentOrder === void 0 ? void 0 : paymentOrder.id) || id, [paymentOrder, id]);
+    // CONTEXT
+    const scUserContext = useSCUser();
+    const authUserId = useMemo(() => { var _a; return ((_a = scUserContext.user) === null || _a === void 0 ? void 0 : _a.id) || null; }, [scUserContext.user]);
+    // CACHE
+    const __paymentOrderCacheKey = useMemo(() => getPaymentOrderObjectCacheKey(__paymentOrderId), [__paymentOrderId]);
+    const [scPaymentOrder, setScPaymentOrder] = useState(cacheStrategy !== CacheStrategies.NETWORK_ONLY ? LRUCache.get(__paymentOrderCacheKey, paymentOrder) : null);
+    const [error, setError] = useState(null);
+    const setSCPaymentOrder = useCallback((c) => {
+        setScPaymentOrder(c);
+        LRUCache.set(__paymentOrderCacheKey, c);
+    }, [setScPaymentOrder, __paymentOrderCacheKey]);
+    /**
+     * Memoized fetch order
+     */
+    const fetchPaymentOrder = useMemo(() => (id) => {
+        return http
+            .request({
+            url: Endpoints.GetPaymentOrder.url({ id }),
+            method: Endpoints.GetPaymentOrder.method,
+        })
+            .then((res) => {
+            if (res.status >= 300) {
+                return Promise.reject(res);
+            }
+            return Promise.resolve(res.data);
+        });
+    }, []);
+    /**
+     * If id attempt to get the course by id
+     */
+    useEffect(() => {
+        if (id !== null && id !== undefined && !paymentOrder) {
+            fetchPaymentOrder(id)
+                .then((e) => {
+                setSCPaymentOrder(e);
+            })
+                .catch((err) => {
+                LRUCache.delete(__paymentOrderCacheKey);
+                Logger.error(SCOPE_SC_CORE, err.message);
+            });
+        }
+    }, [id, paymentOrder, authUserId]);
+    useDeepCompareEffectNoCheck(() => {
+        if (paymentOrder) {
+            setSCPaymentOrder(paymentOrder);
+        }
+    }, [paymentOrder, authUserId]);
+    return { scPaymentOrder, setSCPaymentOrder, error };
+}

package/lib/esm/hooks/useSCFetchPaymentProduct.d.ts

@@ -0,0 +1,20 @@
+import { SCPaymentProduct } from '@selfcommunity/types';
+import { CacheStrategies } from '@selfcommunity/utils';
+/**
+ :::info
+ This custom hook is used to fetch a payment product.
+ :::
+ * @param object
+ * @param object.id
+ * @param object.paymentProduct
+ * @param object.cacheStrategy
+ */
+export default function useSCFetchPaymentProduct({ id, paymentProduct, cacheStrategy, }: {
+    id?: number | string;
+    paymentProduct?: SCPaymentProduct;
+    cacheStrategy?: CacheStrategies;
+}): {
+    scPaymentProduct: SCPaymentProduct;
+    setSCPaymentProduct: (c: SCPaymentProduct) => void;
+    error: string;
+};

package/lib/esm/hooks/useSCFetchPaymentProduct.js

@@ -0,0 +1,67 @@
+import { Endpoints, http } from '@selfcommunity/api-services';
+import { CacheStrategies, Logger, LRUCache } from '@selfcommunity/utils';
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import { useDeepCompareEffectNoCheck } from 'use-deep-compare-effect';
+import { useSCUser } from '../components/provider/SCUserProvider';
+import { getPaymentProductObjectCacheKey } from '../constants/Cache';
+import { SCOPE_SC_CORE } from '../constants/Errors';
+/**
+ :::info
+ This custom hook is used to fetch a payment product.
+ :::
+ * @param object
+ * @param object.id
+ * @param object.paymentProduct
+ * @param object.cacheStrategy
+ */
+export default function useSCFetchPaymentProduct({ id = null, paymentProduct = null, cacheStrategy = CacheStrategies.NETWORK_ONLY, }) {
+    const __paymentProductId = useMemo(() => (paymentProduct === null || paymentProduct === void 0 ? void 0 : paymentProduct.id) || id, [paymentProduct, id]);
+    // CONTEXT
+    const scUserContext = useSCUser();
+    const authUserId = useMemo(() => { var _a; return ((_a = scUserContext.user) === null || _a === void 0 ? void 0 : _a.id) || null; }, [scUserContext.user]);
+    // CACHE
+    const __paymentProductCacheKey = useMemo(() => getPaymentProductObjectCacheKey(__paymentProductId), [__paymentProductId]);
+    const [scPaymentProduct, setScPaymentProduct] = useState(cacheStrategy !== CacheStrategies.NETWORK_ONLY ? LRUCache.get(__paymentProductCacheKey, paymentProduct) : null);
+    const [error, setError] = useState(null);
+    const setSCPaymentProduct = useCallback((c) => {
+        setScPaymentProduct(c);
+        LRUCache.set(__paymentProductCacheKey, c);
+    }, [setScPaymentProduct, __paymentProductCacheKey]);
+    /**
+     * Memoized fetch product
+     */
+    const fetchPaymentProduct = useMemo(() => (id) => {
+        return http
+            .request({
+            url: Endpoints.GetPaymentProduct.url({ id }),
+            method: Endpoints.GetPaymentProduct.method,
+        })
+            .then((res) => {
+            if (res.status >= 300) {
+                return Promise.reject(res);
+            }
+            return Promise.resolve(res.data);
+        });
+    }, []);
+    /**
+     * If id attempt to get the course by id
+     */
+    useEffect(() => {
+        if (id !== null && id !== undefined && !paymentProduct) {
+            fetchPaymentProduct(id)
+                .then((e) => {
+                setSCPaymentProduct(e);
+            })
+                .catch((err) => {
+                LRUCache.delete(__paymentProductCacheKey);
+                Logger.error(SCOPE_SC_CORE, err.message);
+            });
+        }
+    }, [id, paymentProduct, authUserId]);
+    useDeepCompareEffectNoCheck(() => {
+        if (paymentProduct) {
+            setSCPaymentProduct(paymentProduct);
+        }
+    }, [paymentProduct, authUserId]);
+    return { scPaymentProduct, setSCPaymentProduct, error };
+}

package/lib/esm/hooks/useSCFetchUsers.d.ts

@@ -0,0 +1,23 @@
+import { SCUserAutocompleteType } from '@selfcommunity/types';
+import { CacheStrategies } from '@selfcommunity/utils';
+/**
+ :::info
+ This custom hook is used to fetch users.
+ @param object.cacheStrategy
+
+ :::tip Context can be consumed in this way:
+
+ ```jsx
+ const {users, isLoading} = useSCFetchUsers();
+ ```
+ :::
+ * @param props
+ */
+declare const useSCFetchUsers: (props?: {
+    cacheStrategy?: CacheStrategies;
+    search?: string;
+}) => {
+    users: SCUserAutocompleteType[];
+    isLoading: boolean;
+};
+export default useSCFetchUsers;

package/lib/esm/hooks/useSCFetchUsers.js

@@ -0,0 +1,72 @@
+import { __awaiter } from "tslib";
+import { useEffect, useState } from 'react';
+import { SCOPE_SC_CORE } from '../constants/Errors';
+import { Endpoints, http } from '@selfcommunity/api-services';
+import { CacheStrategies, Logger, LRUCache } from '@selfcommunity/utils';
+import { getUserObjectCacheKey, getUsersObjectCacheKey } from '../constants/Cache';
+// Hydrate cache
+const hydrate = (ids) => {
+    if (!ids)
+        return null;
+    const users = ids.map((id) => {
+        const __userCacheKey = getUserObjectCacheKey(id);
+        return LRUCache.get(__userCacheKey);
+    });
+    if (users.filter((u) => !u).length > 0) {
+        return null; // revalidate cache
+    }
+    return users;
+};
+/**
+ :::info
+ This custom hook is used to fetch users.
+ @param object.cacheStrategy
+
+ :::tip Context can be consumed in this way:
+
+ ```jsx
+ const {users, isLoading} = useSCFetchUsers();
+ ```
+ :::
+ * @param props
+ */
+const useSCFetchUsers = (props) => {
+    const { cacheStrategy = CacheStrategies.CACHE_FIRST, search = '' } = props || {};
+    const __usersCacheKey = getUsersObjectCacheKey(search);
+    const cachedUsers = cacheStrategy !== CacheStrategies.NETWORK_ONLY ? hydrate(LRUCache.get(__usersCacheKey, null)) : null;
+    const [data, setData] = useState(cachedUsers !== null ? { users: cachedUsers, isLoading: false } : { users: [], isLoading: false });
+    const fetchUsers = (next = Endpoints.UserAutocomplete.url(), searchParam) => __awaiter(void 0, void 0, void 0, function* () {
+        const response = yield http.request({
+            url: next,
+            method: Endpoints.UserAutocomplete.method,
+            params: searchParam ? { search: searchParam } : undefined,
+        });
+        const data = response.data;
+        if (data.next) {
+            return data.results.concat(yield fetchUsers(data.next, searchParam));
+        }
+        return data.results;
+    });
+    useEffect(() => {
+        if (!search)
+            return;
+        if (cacheStrategy === CacheStrategies.CACHE_FIRST && cachedUsers)
+            return;
+        fetchUsers(undefined, search)
+            .then((data) => {
+            setData({ users: data, isLoading: false });
+            LRUCache.set(__usersCacheKey, data.map((u) => {
+                const __userCacheKey = getUserObjectCacheKey(u.id);
+                LRUCache.set(__userCacheKey, u);
+                return u.id;
+            }));
+        })
+            .catch((error) => {
+            console.error(error);
+            Logger.error(SCOPE_SC_CORE, 'Unable to retrieve users');
+            setData((prev) => (Object.assign(Object.assign({}, prev), { isLoading: false })));
+        });
+    }, [search]);
+    return data;
+};
+export default useSCFetchUsers;

package/lib/esm/hooks/useSCJoinedCoursesManager.d.ts

@@ -30,7 +30,7 @@ export default function useSCJoinedCoursesManager(user?: SCUserType): {
     isLoading: (v: number | {
         id: number;
     }) => boolean;
-    join: (course: SCCourseType, userId?: number) => Promise<any>;
+    join: (course: SCCourseType) => Promise<any>;
     leave: (course: SCCourseType) => Promise<any>;
     joinStatus: (course: SCCourseType) => string;
     refresh: () => void;

package/lib/esm/hooks/useSCJoinedCoursesManager.js

@@ -1,3 +1,4 @@
+import { __awaiter } from "tslib";
 import { useEffect, useMemo, useRef } from 'react';
 import { Endpoints, http } from '@selfcommunity/api-services';
 import { SCFeatureName, SCCoursePrivacyType, SCCourseJoinStatusType, SCNotificationTopicType, SCNotificationTypologyType, } from '@selfcommunity/types';
@@ -29,26 +30,19 @@ export default function useSCJoinedCoursesManager(user) {
     const authUserId = user ? user.id : null;
     const coursesEnabled = useMemo(() => preferences &&
         features &&
-        features.includes(SCFeatureName.TAGGING) &&
         features.includes(SCFeatureName.COURSE) &&
         CONFIGURATIONS_COURSES_ENABLED in preferences &&
         preferences[CONFIGURATIONS_COURSES_ENABLED].value, [preferences, features]);
     const notificationInvitedToJoinCourse = useRef(null);
-    const notificationRequestedToJoinCourse = useRef(null);
-    const notificationAcceptedToJoinCourse = useRef(null);
     const notificationAddedToCourse = useRef(null);
     /**
      * Subscribe to notification types user_follow, user_unfollow
      */
     useDeepCompareEffectNoCheck(() => {
         notificationInvitedToJoinCourse.current = PubSub.subscribe(`${SCNotificationTopicType.INTERACTION}.${SCNotificationTypologyType.USER_INVITED_TO_JOIN_COURSE}`, notificationSubscriber);
-        notificationRequestedToJoinCourse.current = PubSub.subscribe(`${SCNotificationTopicType.INTERACTION}.${SCNotificationTypologyType.USER_REQUESTED_TO_JOIN_COURSE}`, notificationSubscriber);
-        notificationAcceptedToJoinCourse.current = PubSub.subscribe(`${SCNotificationTopicType.INTERACTION}.${SCNotificationTypologyType.USER_ACCEPTED_TO_JOIN_COURSE}`, notificationSubscriber);
         notificationAddedToCourse.current = PubSub.subscribe(`${SCNotificationTopicType.INTERACTION}.${SCNotificationTypologyType.USER_ADDED_TO_COURSE}`, notificationSubscriber);
         return () => {
             PubSub.unsubscribe(notificationInvitedToJoinCourse.current);
-            PubSub.unsubscribe(notificationRequestedToJoinCourse.current);
-            PubSub.unsubscribe(notificationAcceptedToJoinCourse.current);
             PubSub.unsubscribe(notificationAddedToCourse.current);
         };
     }, [data]);
@@ -58,20 +52,20 @@ export default function useSCJoinedCoursesManager(user) {
      * @param dataMsg
      */
     const notificationSubscriber = (msg, dataMsg) => {
+        var _a;
         if (dataMsg.data.course !== undefined) {
             let _status;
             switch (SCNotificationMapping[dataMsg.data.activity_type]) {
                 case SCNotificationTypologyType.USER_INVITED_TO_JOIN_COURSE:
                     _status = SCCourseJoinStatusType.INVITED;
                     break;
-                case SCNotificationTypologyType.USER_REQUESTED_TO_JOIN_COURSE:
-                    _status = SCCourseJoinStatusType.REQUESTED;
-                    break;
-                case SCNotificationTypologyType.USER_ACCEPTED_TO_JOIN_COURSE:
-                    _status = SCCourseJoinStatusType.JOINED;
-                    break;
                 case SCNotificationTypologyType.USER_ADDED_TO_COURSE:
-                    _status = SCCourseJoinStatusType.JOINED;
+                    if (dataMsg.data.notification_obj.course && ((_a = dataMsg.data.notification_obj.course.paywalls) === null || _a === void 0 ? void 0 : _a.length)) {
+                        _status = SCCourseJoinStatusType.PAYMENT_WAITING;
+                    }
+                    else {
+                        _status = SCCourseJoinStatusType.JOINED;
+                    }
                     break;
             }
             updateCache([dataMsg.data.course]);
@@ -90,8 +84,8 @@ export default function useSCJoinedCoursesManager(user) {
             // Only if user is authenticated
             http
                 .request({
-                url: Endpoints.GetJoinedCourses.url(),
-                method: Endpoints.GetJoinedCourses.method,
+                url: Endpoints.GetUserJoinedCourses.url({ id: user.id }),
+                method: Endpoints.GetUserJoinedCourses.method,
             })
                 .then((res) => {
                 if (res.status >= 300) {
@@ -112,67 +106,42 @@ export default function useSCJoinedCoursesManager(user) {
      * Memoized join Course
      * Toggle action
      */
-    const join = useMemo(() => (course, userId) => {
+    const join = useMemo(() => (course) => __awaiter(this, void 0, void 0, function* () {
         setLoading(course.id);
-        if (userId) {
-            return http
-                .request({
-                url: Endpoints.InviteOrAcceptUsersToCourse.url({ id: course.id }),
-                method: Endpoints.InviteOrAcceptUsersToCourse.method,
-                data: { users: [userId] },
-            })
-                .then((res) => {
-                if (res.status >= 300) {
-                    return Promise.reject(res);
-                }
-                updateCache([course.id]);
-                setData((prev) => getDataUpdated(prev, course.id, SCCourseJoinStatusType.JOINED));
-                setUnLoading(course.id);
-                return Promise.resolve(res.data);
-            });
-        }
-        else {
-            return http
-                .request({
-                url: Endpoints.JoinOrAcceptInviteToCourse.url({ id: course.id }),
-                method: Endpoints.JoinOrAcceptInviteToCourse.method,
-            })
-                .then((res) => {
-                if (res.status >= 300) {
-                    return Promise.reject(res);
-                }
-                updateCache([course.id]);
-                setData((prev) => getDataUpdated(prev, course.id, course.privacy === SCCoursePrivacyType.PRIVATE && course.join_status !== SCCourseJoinStatusType.INVITED
-                    ? SCCourseJoinStatusType.REQUESTED
-                    : SCCourseJoinStatusType.JOINED));
-                setUnLoading(course.id);
-                return Promise.resolve(res.data);
-            });
+        const res = yield http.request({
+            url: Endpoints.JoinOrAcceptInviteToCourse.url({ id: course.id }),
+            method: Endpoints.JoinOrAcceptInviteToCourse.method,
+        });
+        if (res.status >= 300) {
+            return Promise.reject(res);
         }
-    }, [data, loading, cache]);
+        updateCache([course.id]);
+        setData((prev) => getDataUpdated(prev, course.id, course.privacy === SCCoursePrivacyType.PRIVATE && course.join_status !== SCCourseJoinStatusType.INVITED
+            ? SCCourseJoinStatusType.REQUESTED
+            : SCCourseJoinStatusType.JOINED));
+        setUnLoading(course.id);
+        return yield Promise.resolve(res.data);
+    }), [data, loading, cache]);
     /**
      * Memoized leave Course
      * Toggle action
      */
-    const leave = useMemo(() => (course) => {
-        if (course.join_status !== SCCourseJoinStatusType.REQUESTED) {
+    const leave = useMemo(() => (course) => __awaiter(this, void 0, void 0, function* () {
+        if (data[course.id] !== SCCourseJoinStatusType.REQUESTED) {
             setLoading(course.id);
-            return http
-                .request({
+            const res = yield http.request({
                 url: Endpoints.LeaveOrRemoveCourseRequest.url({ id: course.id }),
                 method: Endpoints.LeaveOrRemoveCourseRequest.method,
-            })
-                .then((res) => {
-                if (res.status >= 300) {
-                    return Promise.reject(res);
-                }
-                updateCache([course.id]);
-                setData((prev) => getDataUpdated(prev, course.id, null));
-                setUnLoading(course.id);
-                return Promise.resolve(res.data);
             });
+            if (res.status >= 300) {
+                return Promise.reject(res);
+            }
+            updateCache([course.id]);
+            setData((prev) => getDataUpdated(prev, course.id, null));
+            setUnLoading(course.id);
+            return yield Promise.resolve(res.data);
         }
-    }, [data, loading, cache]);
+    }), [data, loading, cache]);
     /**
      * Check the authenticated user subscription status to the course
      * Update the courses cached
@@ -248,7 +217,7 @@ export default function useSCJoinedCoursesManager(user) {
         if (cache.includes(course.id)) {
             return getCurrentCourseCacheStatus(course);
         }
-        if (authUserId) {
+        if (authUserId && course) {
             if ('join_status' in course) {
                 return getJoinStatus(course);
             }
@@ -257,7 +226,7 @@ export default function useSCJoinedCoursesManager(user) {
             }
         }
         return null;
-    }, [loading, cache, authUserId]);
+    }, [loading, cache, authUserId, getJoinStatus, getCurrentCourseCacheStatus]);
     /**
      * Empty cache on logout
      */

package/lib/esm/hooks/useSCPaymentsEnabled.d.ts

@@ -0,0 +1,18 @@
+/**
+ :::info
+ This custom hook is used to check if the payments are enabled
+ :::
+ :::tip How to use it:
+
+ Follow these steps:
+ ```jsx
+ 1. import useSCPaymentsEnabled from '@selfcommunity/react-core';
+ 2.	const {isPaymentsEnabled, stripePublicKey, stripeConnectedAccountId} = useSCPaymentsEnabled();
+ ```
+ :::
+ */
+export default function useSCPaymentsEnabled(): {
+    isPaymentsEnabled: any;
+    stripePublicKey: any;
+    stripeConnectedAccountId: any;
+};

package/lib/esm/hooks/useSCPaymentsEnabled.js

@@ -0,0 +1,31 @@
+import { useMemo } from 'react';
+import { SCFeatureName } from '@selfcommunity/types';
+import { useSCPreferences } from '../components/provider/SCPreferencesProvider';
+import * as SCPreferences from '../constants/Preferences';
+/**
+ :::info
+ This custom hook is used to check if the payments are enabled
+ :::
+ :::tip How to use it:
+
+ Follow these steps:
+ ```jsx
+ 1. import useSCPaymentsEnabled from '@selfcommunity/react-core';
+ 2.	const {isPaymentsEnabled, stripePublicKey, stripeConnectedAccountId} = useSCPaymentsEnabled();
+ ```
+ :::
+ */
+export default function useSCPaymentsEnabled() {
+    // CONTEXT
+    const { preferences, features } = useSCPreferences();
+    const isPaymentsEnabled = useMemo(() => preferences &&
+        features &&
+        features.includes(SCFeatureName.PAYMENTS) &&
+        SCPreferences.CONFIGURATIONS_PAYMENTS_ENABLED in preferences &&
+        preferences[SCPreferences.CONFIGURATIONS_PAYMENTS_ENABLED].value, [preferences]);
+    const stripePublicKey = useMemo(() => preferences && SCPreferences.STATIC_STRIPE_PUBLIC_KEY in preferences && preferences[SCPreferences.STATIC_STRIPE_PUBLIC_KEY].value, [preferences]);
+    const stripeConnectedAccountId = useMemo(() => preferences &&
+        SCPreferences.CONFIGURATIONS_STRIPE_CONNECTED_ACCOUNT_ID in preferences &&
+        preferences[SCPreferences.CONFIGURATIONS_STRIPE_CONNECTED_ACCOUNT_ID].value, [preferences]);
+    return { isPaymentsEnabled, stripePublicKey, stripeConnectedAccountId };
+}

package/lib/esm/hooks/useSCPreferenceEnabled.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Custom hook to check if a given preference is present and has a value.
+ * @param preference - full preference key (e.g., 'section.name')
+ * @returns boolean - true if the preference exists and has a value
+ */
+export default function useSCPreferenceEnabled(preference: string): boolean;

package/lib/esm/hooks/useSCPreferenceEnabled.js

@@ -0,0 +1,13 @@
+import { useMemo } from 'react';
+import { useSCPreferences } from '../components/provider/SCPreferencesProvider';
+/**
+ * Custom hook to check if a given preference is present and has a value.
+ * @param preference - full preference key (e.g., 'section.name')
+ * @returns boolean - true if the preference exists and has a value
+ */
+export default function useSCPreferenceEnabled(preference) {
+    const { preferences } = useSCPreferences();
+    return useMemo(() => {
+        return preferences && preference in preferences && preferences[preference].value;
+    }, [preferences, preference]);
+}