fix: ensure useSubscriptions and useEnterpriseCourseEnrollments uses queryOptions.select from args

src/components/app/data/constants.js

@@ -65,6 +65,7 @@ export const ASSIGNMENT_TYPES = {
   EXPIRED: 'expired',
   ERRORED: 'errored',
   EXPIRING: 'expiring',
+  REVERSED: 'reversed',
 };
 
 // When the start date is before this number of days before today, display the alternate start date (fixed to today).

src/components/app/data/hooks/useEnterpriseCourseEnrollments.js

@@ -30,41 +30,90 @@ export const transformAllEnrollmentsByStatus = ({
 /**
  * Retrieves the relevant enterprise course enrollments, subsidy requests (e.g., license
  * requests), and content assignments for the active enterprise customer user.
+ * @param {Types.UseQueryOptions} queryOptions The query options.
  * @returns {Types.UseQueryResult} The query results.
  */
 export default function useEnterpriseCourseEnrollments(queryOptions = {}) {
-  const isEnabled = queryOptions.enabled;
+  const {
+    enrollmentQueryOptions = {},
+    licenseRequestQueryOptions = {},
+    couponCodeRequestQueryOptions = {},
+    contentAssignmentQueryOptions = {},
+  } = queryOptions;
+  const { select: selectEnrollment, ...enrollmentQueryOptionsRest } = enrollmentQueryOptions;
+  const { select: selectLicenseRequest, ...licenseRequestQueryOptionsRest } = licenseRequestQueryOptions;
+  const { select: selectCouponCodeRequest, ...couponCodeRequestQueryOptionsRest } = couponCodeRequestQueryOptions;
+  const { select: selectContentAssignment, ...contentAssignmentQueryOptionsRest } = contentAssignmentQueryOptions;
+
   const { data: enterpriseCustomer } = useEnterpriseCustomer();
-  const bffQueryFallback = {
-    ...queryEnterpriseCourseEnrollments(enterpriseCustomer.uuid),
-    ...queryOptions,
-    select: (data) => data.map(transformCourseEnrollment),
-    enabled: isEnabled,
-  };
+
   const { data: enterpriseCourseEnrollments } = useBFF({
     bffQueryOptions: {
       ...queryOptions,
-      select: (data) => data.enterpriseCourseEnrollments.map(transformCourseEnrollment),
-      enabled: isEnabled,
+      select: (data) => {
+        const transformedData = data.enterpriseCourseEnrollments.map(transformCourseEnrollment);
+        if (selectEnrollment) {
+          return selectEnrollment({
+            original: data,
+            transformed: transformedData,
+          });
+        }
+        return transformedData;
+      },
+      ...enrollmentQueryOptionsRest,
+    },
+    fallbackQueryConfig: {
+      ...queryEnterpriseCourseEnrollments(enterpriseCustomer.uuid),
+      ...queryOptions,
+      select: (data) => {
+        const transformedData = data.map(transformCourseEnrollment);
+        if (selectEnrollment) {
+          return selectEnrollment({
+            original: data,
+            transformed: transformedData,
+          });
+        }
+        return transformedData;
+      },
+      ...enrollmentQueryOptionsRest,
     },
-    fallbackQueryConfig: bffQueryFallback,
   });
+
   const { data: { requests } } = useBrowseAndRequest({
     subscriptionLicensesQueryOptions: {
-      select: (data) => data.map((subsidyRequest) => transformSubsidyRequest({
-        subsidyRequest,
-        slug: enterpriseCustomer.slug,
-      })),
-      enabled: isEnabled,
+      select: (data) => {
+        const transformedData = data.map((subsidyRequest) => transformSubsidyRequest({
+          subsidyRequest,
+          slug: enterpriseCustomer.slug,
+        }));
+        if (selectLicenseRequest) {
+          return selectLicenseRequest({
+            original: data,
+            transformed: transformedData,
+          });
+        }
+        return transformedData;
+      },
+      ...licenseRequestQueryOptionsRest,
     },
     couponCodesQueryOptions: {
-      select: (data) => data.map((subsidyRequest) => transformSubsidyRequest({
-        subsidyRequest,
-        slug: enterpriseCustomer.slug,
-      })),
-      enabled: isEnabled,
+      select: (data) => {
+        const transformedData = data.map((subsidyRequest) => transformSubsidyRequest({
+          subsidyRequest,
+          slug: enterpriseCustomer.slug,
+        }));
+        if (selectCouponCodeRequest) {
+          return selectCouponCodeRequest({
+            original: data,
+            transformed: transformedData,
+          });
+        }
+        return transformedData;
+      },
+      ...couponCodeRequestQueryOptionsRest,
     },
   });
+
   const { data: contentAssignments } = useRedeemablePolicies({
     select: (data) => {
       const { learnerContentAssignments } = data;
@@ -78,10 +127,17 @@ export default function useEnterpriseCourseEnrollments(queryOptions = {}) {
           enterpriseCustomer.slug,
         ));
       });
+      if (selectContentAssignment) {
+        return selectContentAssignment({
+          original: data,
+          transformed: transformedAssignments,
+        });
+      }
       return transformedAssignments;
     },
-    enabled: isEnabled,
+    ...contentAssignmentQueryOptionsRest,
   });
+
   // TODO: Talk about how we don't have access to weeksToComplete on the dashboard page.
   const allEnrollmentsByStatus = useMemo(() => transformAllEnrollmentsByStatus({
     enterpriseCourseEnrollments,

src/components/app/data/hooks/useEnterpriseCourseEnrollments.test.jsx

@@ -30,7 +30,7 @@ jest.mock('./useBFF');
 
 const mockEnterpriseCustomer = enterpriseCustomerFactory();
 const mockAuthenticatedUser = authenticatedUserFactory();
-const mockCourseEnrollments = {
+const mockCourseEnrollment = {
   displayName: 'Education',
   micromastersTitle: 'Demo in higher education',
   courseRunUrl: 'test-course-url',
@@ -114,6 +114,16 @@ const mockRedeemablePolicies = {
   },
 };
 
+const expectedTransformedRequests = (request) => ({
+  courseRunId: request.courseId,
+  title: request.courseTitle,
+  orgName: request.coursePartners?.map(partner => partner.name).join(', '),
+  courseRunStatus: COURSE_STATUSES.requested,
+  linkToCourse: `${mockEnterpriseCustomer.slug}/course/${request.courseId}`,
+  created: request.created,
+  notifications: [],
+});
+
 describe('useEnterpriseCourseEnrollments', () => {
   const Wrapper = ({ children }) => (
     <QueryClientProvider client={queryClient()}>
@@ -125,35 +135,28 @@ describe('useEnterpriseCourseEnrollments', () => {
   beforeEach(() => {
     jest.clearAllMocks();
     useEnterpriseCustomer.mockReturnValue({ data: mockEnterpriseCustomer });
-    fetchEnterpriseCourseEnrollments.mockResolvedValue([mockCourseEnrollments]);
+    fetchEnterpriseCourseEnrollments.mockResolvedValue([mockCourseEnrollment]);
     fetchBrowseAndRequestConfiguration.mockResolvedValue(mockBrowseAndRequestConfiguration);
     fetchLicenseRequests.mockResolvedValue([mockLicenseRequests]);
     fetchCouponCodeRequests.mockResolvedValue([mockCouponCodeRequests]);
     fetchRedeemablePolicies.mockResolvedValue(mockRedeemablePolicies);
-    useBFF.mockReturnValue({ data: [mockCourseEnrollments].map(transformCourseEnrollment) });
+    useBFF.mockReturnValue({ data: [mockCourseEnrollment].map(transformCourseEnrollment) });
   });
-  it('should return transformed return values from course enrollments API', async () => {
-    const { result, waitForNextUpdate } = renderHook(() => useEnterpriseCourseEnrollments(), { wrapper: Wrapper });
-    await waitForNextUpdate();
-    const expectedEnterpriseCourseEnrollments = {
-      title: mockCourseEnrollments.displayName,
-      microMastersTitle: mockCourseEnrollments.micromastersTitle,
-      linkToCourse: mockCourseEnrollments.courseRunUrl,
-      linkToCertificate: mockCourseEnrollments.certificateDownloadUrl,
-      hasEmailsEnabled: mockCourseEnrollments.emailsEnabled,
-      notifications: mockCourseEnrollments.dueDates,
-      canUnenroll: canUnenrollCourseEnrollment(mockCourseEnrollments),
+
+  it.each([
+    { hasQueryOptions: false },
+    { hasQueryOptions: true },
+  ])('should return transformed enrollments data (%s)', async ({ hasQueryOptions }) => {
+    const expectedEnterpriseCourseEnrollments = [{
+      title: mockCourseEnrollment.displayName,
+      microMastersTitle: mockCourseEnrollment.micromastersTitle,
+      linkToCourse: mockCourseEnrollment.courseRunUrl,
+      linkToCertificate: mockCourseEnrollment.certificateDownloadUrl,
+      hasEmailsEnabled: mockCourseEnrollment.emailsEnabled,
+      notifications: mockCourseEnrollment.dueDates,
+      canUnenroll: canUnenrollCourseEnrollment(mockCourseEnrollment),
       isCourseAssigned: false,
-    };
-    const expectedTransformedRequests = (request) => ({
-      courseRunId: request.courseId,
-      title: request.courseTitle,
-      orgName: request.coursePartners?.map(partner => partner.name).join(', '),
-      courseRunStatus: COURSE_STATUSES.requested,
-      linkToCourse: `${mockEnterpriseCustomer.slug}/course/${request.courseId}`,
-      created: request.created,
-      notifications: [],
-    });
+    }];
     const expectedRequests = {
       couponCodes: [expectedTransformedRequests(mockCouponCodeRequests)],
       subscriptionLicenses: [expectedTransformedRequests(mockLicenseRequests)],
@@ -177,7 +180,7 @@ describe('useEnterpriseCourseEnrollments', () => {
       uuid: mockContentAssignment.uuid,
       learnerAcknowledged: mockContentAssignment.learnerAcknowledged,
     };
-    const expectedContentAssignment = {
+    const expectedContentAssignmentData = {
       acceptedAssignments: [],
       allocatedAssignments: [expectedTransformedLearnerContentAssignment],
       assignmentsForDisplay: [expectedTransformedLearnerContentAssignment],
@@ -187,15 +190,64 @@ describe('useEnterpriseCourseEnrollments', () => {
       expiredAssignments: [],
     };
 
+    const mockSelectEnrollment = jest.fn().mockReturnValue(expectedEnterpriseCourseEnrollments);
+    const mockSelectLicenseRequest = jest.fn().mockReturnValue(expectedRequests.subscriptionLicenses);
+    const mockSelectCouponCodeRequest = jest.fn().mockReturnValue(expectedRequests.couponCodes);
+    const mockSelectContentAssignment = jest.fn().mockReturnValue(expectedContentAssignmentData);
+    const mockQueryOptions = {
+      enrollmentQueryOptions: { select: mockSelectEnrollment },
+      licenseRequestQueryOptions: { select: mockSelectLicenseRequest },
+      couponCodeRequestQueryOptions: { select: mockSelectCouponCodeRequest },
+      contentAssignmentQueryOptions: { select: mockSelectContentAssignment },
+    };
+    const queryOptions = hasQueryOptions ? mockQueryOptions : undefined;
+    const { result, waitForNextUpdate } = renderHook(
+      () => {
+        if (hasQueryOptions) {
+          return useEnterpriseCourseEnrollments(queryOptions);
+        }
+        return useEnterpriseCourseEnrollments();
+      },
+      { wrapper: Wrapper },
+    );
+    await waitForNextUpdate();
+
+    // Call the mocked useBFF's input select functions
+    const useBFFArgs = useBFF.mock.calls[0][0];
+    const { select: selectBFFQuery } = useBFFArgs.bffQueryOptions;
+    const { select: selectFallbackBFFQuery } = useBFFArgs.fallbackQueryConfig;
+    selectBFFQuery({ enterpriseCourseEnrollments: [mockCourseEnrollment] });
+    selectFallbackBFFQuery([mockCourseEnrollment]);
+
+    // Assert that passed select fn query options were called with the correct arguments
+    if (hasQueryOptions) {
+      expect(mockSelectLicenseRequest).toHaveBeenCalledWith({
+        original: [mockLicenseRequests],
+        transformed: expectedRequests.subscriptionLicenses,
+      });
+      expect(mockSelectCouponCodeRequest).toHaveBeenCalledWith({
+        original: [mockCouponCodeRequests],
+        transformed: expectedRequests.couponCodes,
+      });
+      expect(mockSelectContentAssignment).toHaveBeenCalledWith({
+        original: mockRedeemablePolicies,
+        transformed: expectedContentAssignmentData,
+      });
+      expect(mockSelectEnrollment).toHaveBeenCalledWith({
+        original: [mockCourseEnrollment],
+        transformed: expectedEnterpriseCourseEnrollments,
+      });
+    }
+
     const expectedTransformedAllEnrollmentsByStatus = transformAllEnrollmentsByStatus({
-      enterpriseCourseEnrollments: [expectedEnterpriseCourseEnrollments],
+      enterpriseCourseEnrollments: expectedEnterpriseCourseEnrollments,
       requests: expectedRequests,
-      contentAssignments: expectedContentAssignment,
+      contentAssignments: expectedContentAssignmentData,
     });
 
     expect(result.current.data.allEnrollmentsByStatus).toEqual(expectedTransformedAllEnrollmentsByStatus);
-    expect(result.current.data.enterpriseCourseEnrollments).toEqual([expectedEnterpriseCourseEnrollments]);
-    expect(result.current.data.contentAssignments).toEqual(expectedContentAssignment);
+    expect(result.current.data.enterpriseCourseEnrollments).toEqual(expectedEnterpriseCourseEnrollments);
+    expect(result.current.data.contentAssignments).toEqual(expectedContentAssignmentData);
     expect(result.current.data.requests).toEqual(expectedRequests);
   });
 });

src/components/app/data/hooks/useSubscriptions.js

@@ -10,12 +10,28 @@ import { transformSubscriptionsData } from '../services';
  */
 export default function useSubscriptions(queryOptions = {}) {
   const { data: enterpriseCustomer } = useEnterpriseCustomer();
+  const { select, ...queryOptionsRest } = queryOptions;
+
   return useBFF({
     bffQueryOptions: {
-      select: (data) => transformSubscriptionsData(
-        data?.enterpriseCustomerUserSubsidies?.subscriptions,
-        { isBFFData: true },
-      ),
+      ...queryOptionsRest,
+      select: (data) => {
+        const transformedData = transformSubscriptionsData(
+          data?.enterpriseCustomerUserSubsidies?.subscriptions,
+          { isBFFData: true },
+        );
+
+        // When custom `select` function is provided in `queryOptions`, call it with original and transformed data.
+        if (select) {
+          return select({
+            original: data,
+            transformed: transformedData,
+          });
+        }
+
+        // Otherwise, return the transformed data.
+        return transformedData;
+      },
     },
     fallbackQueryConfig: {
       ...querySubscriptions(enterpriseCustomer.uuid),