@iblai/web-utils 1.2.8 → 1.2.9

package/dist/index.js

@@ -2774,22 +2774,22 @@ async function getUserName(storageService) {
  * @param storageService - Storage service to access localStorage
  * @returns boolean indicating if token has expired
  */
-async function isJwtTokenExpired(storageService) {
+async function isDmTokenExpired(storageService) {
     try {
         const dmTokenExpires = await storageService.getItem(LOCAL_STORAGE_KEYS.DM_TOKEN_EXPIRES);
         if (!dmTokenExpires) {
-            return false; // not expired if dm_token_expires not found
+            return true;
         }
         const expiryTime = new Date(dmTokenExpires).getTime();
         const currentTime = Date.now();
         if (currentTime >= expiryTime) {
-            console.warn("[AuthProvider] JWT token has expired");
+            console.warn("[AuthProvider] DM token has expired");
             return true;
         }
         return false;
     }
     catch (error) {
-        console.error("[AuthProvider] Error checking JWT token expiry:", error);
+        console.error("[AuthProvider] Error checking DM token expiry:", error);
         return true; // Treat as expired on error
     }
 }
@@ -3008,12 +3008,12 @@ function useAuthProvider({ middleware = new Map(), onAuthSuccess, onAuthFailure,
             }
             // Check JWT token expiry and force logout for protected routes
             if (isProtectedRoute && storageService) {
-                const jwtExpired = await isJwtTokenExpired(storageService);
-                if (jwtExpired) {
-                    console.log("[auth-redirect] JWT token has expired, forcing logout");
+                const dmTokenExpired = await isDmTokenExpired(storageService);
+                if (dmTokenExpired) {
+                    console.log("[auth-redirect] DM token has expired, forcing logout");
                     // Clear all auth-related storage keys
                     clearAuthCookies();
-                    const reason = "JWT token expired";
+                    const reason = "DM token expired";
                     onAuthFailure === null || onAuthFailure === void 0 ? void 0 : onAuthFailure(reason);
                     safeRedirectToAuthSpa(undefined, undefined, true);
                     return;
@@ -13611,6 +13611,7 @@ const buildEndpointFromService = (service, serviceFn) => {
                 return { data };
             }
             catch (err) {
+                console.error('[data-layer] API error:', JSON.stringify(err, Object.getOwnPropertyNames(err)));
                 if (Object.prototype.hasOwnProperty.call(Config.httpErrorHandlers, err === null || err === void 0 ? void 0 : err.status)) {
                     Config.httpErrorHandlers[err === null || err === void 0 ? void 0 : err.status]({ ...((err === null || err === void 0 ? void 0 : err.data) || {}) });
                 }
@@ -13681,7 +13682,7 @@ const invokeHttpErrorHandler = (status, error) => {
     }
 };
 /** HTTP status codes that should not be retried (e.g., 402 Payment Required). */
-const NON_RETRYABLE_STATUS_CODES = [402];
+const NON_RETRYABLE_STATUS_CODES = [402, 401];
 /**
  * Wraps a base query to skip retries for non-retryable HTTP status codes.
  * Uses `retry.fail()` to immediately bail out of the retry loop.
@@ -13736,7 +13737,6 @@ const iblFetchBaseQuery = async (args, api, extraOptions) => {
             error: e,
         }));
         // Extract status from error and invoke HTTP error handlers
-        console.log('[MONETIZATION e]', { e });
         const err = e;
         const errorStatus = typeof e === 'object' && e !== null && 'status' in e
             ? e.status
@@ -14419,7 +14419,7 @@ createApi({
 });
 
 const featureTags = {
-    PLATFORM_USERS: "PLATFORM_USERS",
+    PLATFORM_USERS: 'PLATFORM_USERS',
 };
 
 createApi({
@@ -14731,10 +14731,10 @@ createApi({
                     credentials: 'omit',
                 });
                 if (!response.ok) {
-                    const error = new Error('Failed to fetch RBAC group details');
-                    error.status = response.status;
-                    error.body = await response.text();
-                    throw error;
+                    throw Object.assign(new Error('Failed to fetch RBAC group details'), {
+                        status: response.status,
+                        body: await response.text(),
+                    });
                 }
                 return response.json();
             }),
@@ -14768,10 +14768,10 @@ createApi({
                     credentials: 'omit',
                 });
                 if (!response.ok) {
-                    const error = new Error('Failed to fetch RBAC policy details');
-                    error.status = response.status;
-                    error.body = await response.text();
-                    throw error;
+                    throw Object.assign(new Error('Failed to fetch RBAC policy details'), {
+                        status: response.status,
+                        body: await response.text(),
+                    });
                 }
                 return response.json();
             }),
@@ -14809,15 +14809,33 @@ createApi({
                     credentials: 'omit',
                 });
                 if (!response.ok) {
-                    const error = new Error('Failed to fetch RBAC role details');
-                    error.status = response.status;
-                    error.body = await response.text();
-                    throw error;
+                    throw Object.assign(new Error('Failed to fetch RBAC role details'), {
+                        status: response.status,
+                        body: await response.text(),
+                    });
                 }
                 return response.json();
             }),
             providesTags: ['RbacRoles'],
         }),
+        getDepartmentMemberCheck: builder.query({
+            ...buildEndpointFromService(SERVICES.DM, async (args) => {
+                const queryParams = new URLSearchParams({ platform_key: args.platform_key });
+                const url = `${iblaiApi.OpenAPI.BASE}/api/core/departments/members/check/?${queryParams.toString()}`;
+                const response = await fetch(url, {
+                    method: 'GET',
+                    headers: iblaiApi.OpenAPI.HEADERS,
+                    credentials: 'omit',
+                });
+                if (!response.ok) {
+                    throw Object.assign(new Error('Failed to fetch department member check'), {
+                        status: response.status,
+                        body: await response.text(),
+                    });
+                }
+                return response.json();
+            }),
+        }),
         getRbacMentorAccessList: builder.query({
             ...buildEndpointFromDmService(iblaiApi.CoreService.coreRbacMentorAccessList),
         }),
@@ -16092,6 +16110,7 @@ createApi({
         'catalog-roles',
         'catalog-invitations-course',
         'catalog-invitations-program',
+        'user-assigned-programs',
     ],
     endpoints: (builder) => ({
         getUserReportedSkills: builder.query({
@@ -16199,15 +16218,56 @@ createApi({
                     credentials: 'omit',
                 });
                 if (!response.ok) {
-                    const error = new Error('Failed to fetch program invitations');
-                    error.status = response.status;
-                    error.body = await response.text();
-                    throw error;
+                    throw Object.assign(new Error('Failed to fetch program invitations'), {
+                        status: response.status,
+                        body: await response.text(),
+                    });
                 }
                 return response.json();
             }),
             providesTags: ['catalog-invitations-program'],
         }),
+        getUserCatalogPathways: builder.query({
+            ...buildEndpointFromService(SERVICES.DM, async (args) => {
+                const params = new URLSearchParams({
+                    username: args.username,
+                    platform_key: args.platform_key,
+                });
+                const url = `${iblaiApi.OpenAPI.BASE}/api/catalog/pathways/?${params.toString()}`;
+                const response = await fetch(url, {
+                    method: 'GET',
+                    headers: iblaiApi.OpenAPI.HEADERS,
+                    credentials: 'omit',
+                });
+                if (!response.ok) {
+                    throw Object.assign(new Error('Failed to fetch user catalog pathways'), {
+                        status: response.status,
+                        body: await response.text(),
+                    });
+                }
+                return response.json();
+            }),
+            providesTags: ['user-catalog-pathways'],
+        }),
+        getAssignedPrograms: builder.query({
+            ...buildEndpointFromService(SERVICES.DM, async (args) => {
+                const params = new URLSearchParams({ user_id: String(args.user_id) });
+                const url = `${iblaiApi.OpenAPI.BASE}/api/catalog/suggestions/program/user/?${params.toString()}`;
+                const response = await fetch(url, {
+                    method: 'GET',
+                    headers: iblaiApi.OpenAPI.HEADERS,
+                    credentials: 'omit',
+                });
+                if (!response.ok) {
+                    throw Object.assign(new Error('Failed to fetch assigned programs'), {
+                        status: response.status,
+                        body: await response.text(),
+                    });
+                }
+                return response.json();
+            }),
+            providesTags: ['user-assigned-programs'],
+        }),
     }),
 });
 
@@ -16229,6 +16289,114 @@ createApi({
     }),
 });
 
+createApi({
+    reducerPath: 'coursesApiSlice',
+    baseQuery: iblFetchBaseQuery,
+    tagTypes: ['user-enrolled-courses', 'user-assigned-courses'],
+    endpoints: (builder) => ({
+        getUserEnrolledCourses: builder.query({
+            query: ({ username, query }) => {
+                const params = new URLSearchParams();
+                params.set('username', username);
+                if (query) {
+                    for (const [k, v] of Object.entries(query)) {
+                        if (v !== undefined && v !== null)
+                            params.set(k, String(v));
+                    }
+                }
+                return {
+                    url: `/api/catalog/enrollment/courses/search/?${params.toString()}`,
+                    service: SERVICES.DM,
+                    method: 'GET',
+                };
+            },
+            providesTags: ['user-enrolled-courses'],
+        }),
+        getUserAssignedCourses: builder.query({
+            query: ({ user_id, query }) => {
+                const params = new URLSearchParams();
+                params.set('user_id', String(user_id));
+                if (query) {
+                    for (const [k, v] of Object.entries(query)) {
+                        if (v !== undefined && v !== null)
+                            params.set(k, String(v));
+                    }
+                }
+                return {
+                    url: `/api/catalog/suggestions/course/user/?${params.toString()}`,
+                    service: SERVICES.DM,
+                    method: 'GET',
+                };
+            },
+            providesTags: ['user-assigned-courses'],
+        }),
+    }),
+});
+
+createApi({
+    reducerPath: 'courseMetadataApiSlice',
+    baseQuery: iblFetchBaseQuery,
+    endpoints: (builder) => ({
+        getCourseMetaData: builder.query({
+            query: ({ courseKey }) => ({
+                url: `/api/ibl/v1/course_metadata?course_key=${encodeURIComponent(courseKey)}`,
+                service: SERVICES.LMS,
+                method: 'GET',
+            }),
+        }),
+        getCourseCompletionOutlines: builder.query({
+            query: ({ courseKey }) => ({
+                url: `/api/ibl/completion/course_outline/${courseKey}?course_id=${encodeURIComponent(courseKey)}`,
+                service: SERVICES.LMS,
+                method: 'GET',
+            }),
+        }),
+        getCourseEligibility: builder.query({
+            query: ({ courseKey }) => ({
+                url: `/api/ibl/enrollment/enroll_status?course_id=${encodeURIComponent(courseKey)}`,
+                service: SERVICES.LMS,
+                method: 'GET',
+            }),
+        }),
+        createCourseEnrollment: builder.mutation({
+            query: (body) => ({
+                url: `/api/enrollment/v1/enrollment`,
+                service: SERVICES.LMS,
+                method: 'POST',
+                body,
+            }),
+        }),
+        getCourseProgress: builder.query({
+            query: ({ courseKey }) => ({
+                url: `/api/course_home/progress/${courseKey}`,
+                service: SERVICES.LMS,
+                method: 'GET',
+            }),
+        }),
+        getCourseCompletion: builder.query({
+            query: ({ courseKey, userID }) => ({
+                url: `/api/catalog/milestones/completions/course/manage/?course_id=${courseKey}&user_id=${userID}`,
+                service: SERVICES.DM,
+                method: 'GET',
+            }),
+        }),
+    }),
+});
+
+createApi({
+    reducerPath: 'edxSsoApiSlice',
+    baseQuery: iblFetchBaseQuery,
+    endpoints: (builder) => ({
+        getEdxSSOToken: builder.query({
+            query: ({ username, redirectUrl }) => ({
+                url: `/ibl/ai/sso/backend/edx/sso-auth-token/generate?username=${encodeURIComponent(username)}&redirect_url=${encodeURIComponent(redirectUrl)}`,
+                service: SERVICES.LMS,
+                method: 'GET',
+            }),
+        }),
+    }),
+});
+
 createApi({
     reducerPath: 'searchApiSlice',
     baseQuery: iblFakeBaseQuery,
@@ -16902,6 +17070,7 @@ const MEMORY_QUERY_KEYS = {
     MEMSEARCH_MENTOR_MEMORIES: () => ['MEMSEARCH_MENTOR_MEMORIES'],
     MEMSEARCH_MEMORY_CATEGORIES: () => ['MEMSEARCH_MEMORY_CATEGORIES'],
     MEMSEARCH_PLATFORM_CONFIG: () => ['MEMSEARCH_PLATFORM_CONFIG'],
+    MEMSEARCH_STATUS: () => ['MEMSEARCH_STATUS'],
 };
 const MEMSEARCH_ENDPOINTS = {
     // User Memory Settings
@@ -16969,6 +17138,11 @@ const MEMSEARCH_ENDPOINTS = {
         service: SERVICES.AXD,
         path: (org, userId) => `/api/ai-mentor/orgs/${org}/users/${userId}/memsearch-config/`,
     },
+    // Memsearch Status (available to students and admins)
+    GET_MEMSEARCH_STATUS: {
+        service: SERVICES.AXD,
+        path: (org, userId) => `/api/ai-mentor/orgs/${org}/users/${userId}/memsearch-status/`,
+    },
 };
 
 createApi({
@@ -16979,6 +17153,7 @@ createApi({
         ...MEMORY_QUERY_KEYS.MEMSEARCH_MENTOR_MEMORIES(),
         ...MEMORY_QUERY_KEYS.MEMSEARCH_MEMORY_CATEGORIES(),
         ...MEMORY_QUERY_KEYS.MEMSEARCH_PLATFORM_CONFIG(),
+        ...MEMORY_QUERY_KEYS.MEMSEARCH_STATUS(),
     ],
     baseQuery: iblFetchBaseQuery,
     endpoints: (builder) => ({
@@ -17111,6 +17286,14 @@ createApi({
             }),
             invalidatesTags: MEMORY_QUERY_KEYS.MEMSEARCH_PLATFORM_CONFIG(),
         }),
+        // Memsearch Status (student + admin accessible)
+        getMemsearchStatus: builder.query({
+            query: (args) => ({
+                url: MEMSEARCH_ENDPOINTS.GET_MEMSEARCH_STATUS.path(args.org, args.userId),
+                service: MEMSEARCH_ENDPOINTS.GET_MEMSEARCH_STATUS.service,
+            }),
+            providesTags: MEMORY_QUERY_KEYS.MEMSEARCH_STATUS(),
+        }),
     }),
 });
 
@@ -18091,6 +18274,33 @@ createApi({
     }),
 });
 
+const AUDIT_LOGS_REDUCER_PATH = 'auditLogsApiSlice';
+const AUDIT_LOGS_QUERY_KEYS = {
+    GET_AUDIT_LOGS: () => ['AUDIT_LOGS'],
+};
+const AUDIT_LOGS_ENDPOINTS = {
+    GET_AUDIT_LOGS: {
+        service: SERVICES.AXD,
+        path: (org, userId) => `/api/ai-mentor/orgs/${org}/users/${userId}/mentors/audit-logs/`,
+    },
+};
+
+createApi({
+    reducerPath: AUDIT_LOGS_REDUCER_PATH,
+    tagTypes: [...AUDIT_LOGS_QUERY_KEYS.GET_AUDIT_LOGS()],
+    baseQuery: iblFetchBaseQuery,
+    endpoints: (builder) => ({
+        getAuditLogs: builder.query({
+            query: (args) => ({
+                url: AUDIT_LOGS_ENDPOINTS.GET_AUDIT_LOGS.path(args.org, args.userId),
+                service: AUDIT_LOGS_ENDPOINTS.GET_AUDIT_LOGS.service,
+                params: args.params,
+            }),
+            providesTags: AUDIT_LOGS_QUERY_KEYS.GET_AUDIT_LOGS(),
+        }),
+    }),
+});
+
 function useMentorSettings({ mentorId, tenantKey, username, isPublicRoute, }) {
     var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
     const isLoggedIn = username !== ANONYMOUS_USERNAME;