@orchestrator-ui/orchestrator-ui-components 8.9.3 → 9.0.0

package/src/rtk/endpoints/subscriptionListMutation.spec.ts

@@ -0,0 +1,80 @@
+import { configureStore } from '@reduxjs/toolkit';
+
+import { orchestratorApi } from '@/rtk/api';
+import { EntityKind, PaginatedSearchResults } from '@/types';
+
+// Importing the endpoint modules injects them into orchestratorApi
+import './search';
+import './subscriptionDetail';
+import './subscriptionListMutation';
+
+const SUBSCRIPTION_ID = 'sub-1';
+const OTHER_SUBSCRIPTION_ID = 'sub-2';
+
+// The injected endpoints are not part of orchestratorApi's static type, hence the casts below
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const api = orchestratorApi as any;
+
+const searchResponse = (note: string): PaginatedSearchResults => ({
+  data: [SUBSCRIPTION_ID, OTHER_SUBSCRIPTION_ID].map((id) => ({
+    entity_id: id,
+    entity_type: EntityKind.SUBSCRIPTION,
+    entity_title: id,
+    score: 1,
+    perfect_match: 1,
+    response_columns: { 'subscription.subscription_id': id, 'subscription.note': note },
+  })),
+  cursor: null,
+  page_info: { has_next_page: false, next_page_cursor: null },
+  search_metadata: { search_type: null, description: null },
+});
+
+const getSearchPayload = (query: string) => ({
+  query,
+  limit: 10,
+  entity_type: EntityKind.SUBSCRIPTION,
+  response_columns: [],
+});
+
+const getNotesFromSearchCache = (state: unknown, payload: object): string[] =>
+  api.endpoints.search
+    .select(payload)(state)
+    .data.data.map(
+      ({ response_columns }: PaginatedSearchResults['data'][number]) => response_columns['subscription.note'],
+    );
+
+describe('updateSubscriptionNoteOptimistic', () => {
+  it('patches the note in every cached search result set and in the detail cache', async () => {
+    const store = configureStore({
+      reducer: { [orchestratorApi.reducerPath]: orchestratorApi.reducer },
+      middleware: (getDefaultMiddleware) => getDefaultMiddleware().concat(orchestratorApi.middleware),
+    });
+    const firstSearch = getSearchPayload('first');
+    const secondSearch = getSearchPayload('second');
+    const detailArgs = { subscriptionId: SUBSCRIPTION_ID };
+
+    // upsertQueryData resolves asynchronously through the query thunk
+    await Promise.all([
+      store.dispatch(api.util.upsertQueryData('search', firstSearch, searchResponse('old'))),
+      store.dispatch(api.util.upsertQueryData('search', secondSearch, searchResponse('old'))),
+      store.dispatch(
+        api.util.upsertQueryData('getSubscriptionDetail', detailArgs, {
+          subscription: { subscriptionId: SUBSCRIPTION_ID, note: 'old' },
+          pageInfo: {},
+        }),
+      ),
+    ]);
+
+    await store.dispatch(
+      api.endpoints.updateSubscriptionNoteOptimistic.initiate({
+        subscriptionId: SUBSCRIPTION_ID,
+        note: 'new',
+      }),
+    );
+
+    const state = store.getState();
+    expect(getNotesFromSearchCache(state, firstSearch)).toEqual(['new', 'old']);
+    expect(getNotesFromSearchCache(state, secondSearch)).toEqual(['new', 'old']);
+    expect(api.endpoints.getSubscriptionDetail.select(detailArgs)(state).data.subscription.note).toBe('new');
+  });
+});

package/src/rtk/endpoints/subscriptionListMutation.ts

@@ -1,74 +1,93 @@
-import { SubscriptionListItem } from '@/components/WfoSubscriptionsList';
 import { SubscriptionDetailResponse, SubscriptionListResponse, orchestratorApi } from '@/rtk';
-import { GraphqlQueryVariables } from '@/types';
+import { PaginatedSearchResults } from '@/types';
+
+const SEARCH_NOTE_COLUMN = 'subscription.note';
+const SEARCH_ID_COLUMN = 'subscription.subscription_id';
+
+// The note edit is rendered by both the GraphQL based lists (surf NMS pages) and the search based
+// subscriptions list, whose cached responses have a different shape. The draft is inspected
+// instead of typed per caller so the note edit needs no knowledge of the query behind it.
+const patchNoteInListDraft = (
+  draft: SubscriptionListResponse | PaginatedSearchResults,
+  subscriptionId: string,
+  note: string,
+) => {
+  if ('subscriptions' in draft) {
+    const subscription = draft.subscriptions.find((item) => item.subscriptionId === subscriptionId);
+    if (subscription) {
+      subscription.note = note;
+    }
+    return;
+  }
+  const searchResult = draft.data?.find(
+    ({ response_columns }) => response_columns[SEARCH_ID_COLUMN] === subscriptionId,
+  );
+  if (searchResult) {
+    searchResult.response_columns[SEARCH_NOTE_COLUMN] = note;
+  }
+};
+
+const SEARCH_ENDPOINT_NAME = 'search';
 
 const subscriptionListMutationApi = orchestratorApi.injectEndpoints({
   endpoints: (builder) => ({
-    emptyQuery: builder.query<SubscriptionListResponse, GraphqlQueryVariables<SubscriptionListItem>>({
-      query: () => ({}),
-    }),
-    emptyDetailQuery: builder.query<SubscriptionDetailResponse, { subscriptionId: string }>({ query: () => ({}) }),
     updateSubscriptionNoteOptimistic: builder.mutation<
       { mockResponse: boolean },
       {
-        queryName: string;
         subscriptionId: string;
-        graphQlQueryVariables: GraphqlQueryVariables<SubscriptionListItem>;
         note: string;
+        // Cache key of a GraphQL list query showing the note (surf NMS pages). The search based
+        // subscriptions list needs no key: every cached search result set is patched.
+        listQuery?: { queryName: string; queryVariables: object };
       }
     >({
       queryFn: async () => ({ data: { mockResponse: true } }),
-      async onQueryStarted(
-        { queryName, subscriptionId, graphQlQueryVariables, ...patch },
-        { dispatch, queryFulfilled },
-      ) {
-        const patchResult = dispatch(
-          subscriptionListMutationApi.util.updateQueryData(
-            // @ts-expect-error - Suggest ts ignore because of the type mismatch between emptyQuery and queryName
-            queryName,
-            graphQlQueryVariables,
-            (draft: SubscriptionListResponse) => {
-              const subscription = draft.subscriptions.find((item) => item.subscriptionId === subscriptionId);
-              if (subscription) {
-                subscription.note = patch.note;
-              }
-            },
-          ),
-        );
-        try {
-          await queryFulfilled;
-        } catch {
-          patchResult.undo();
-        }
-      },
-    }),
-    updateSubscriptionDetailNoteOptimistic: builder.mutation<
-      { mockResponse: boolean },
-      { queryName: string; subscriptionId: string; note: string }
-    >({
-      queryFn: async () => ({ data: { mockResponse: true } }),
-      async onQueryStarted({ queryName, subscriptionId, ...patch }, { dispatch, queryFulfilled }) {
-        const patchResult = dispatch(
-          subscriptionListMutationApi.util.updateQueryData(
-            // @ts-expect-error - Suggest ts ignore because of the type mismatch between emptyDetailQuery and queryName
-            queryName,
-            { subscriptionId: subscriptionId },
-            (draft: SubscriptionDetailResponse) => {
-              if (draft) {
-                draft.subscription.note = patch.note;
-              }
-            },
+      // Patches the detail cache, all cached search result sets and the optional GraphQL list so
+      // the note stays consistent when navigating between pages. updateQueryData is a no-op for
+      // a cache entry that does not exist, and patching the same entry twice is harmless.
+      async onQueryStarted({ subscriptionId, note, listQuery }, { dispatch, getState, queryFulfilled }) {
+        const patchList = (queryName: string, queryVariables: object) =>
+          dispatch(
+            subscriptionListMutationApi.util.updateQueryData(
+              // @ts-expect-error - queryName is a runtime string, not a known endpoint name
+              queryName,
+              queryVariables,
+              (draft: SubscriptionListResponse | PaginatedSearchResults) =>
+                patchNoteInListDraft(draft, subscriptionId, note),
+            ),
+          );
+
+        const cachedSearchArgs = subscriptionListMutationApi.util.selectCachedArgsForQuery(
+          getState(),
+          // @ts-expect-error - search is injected by another slice, unknown to this one
+          SEARCH_ENDPOINT_NAME,
+        ) as object[];
+
+        const patchResults = [
+          dispatch(
+            subscriptionListMutationApi.util.updateQueryData(
+              // @ts-expect-error - getSubscriptionDetail is injected by another slice, unknown to this one
+              'getSubscriptionDetail',
+              { subscriptionId },
+              (draft: SubscriptionDetailResponse) => {
+                if (draft?.subscription) {
+                  draft.subscription.note = note;
+                }
+              },
+            ),
           ),
-        );
+          ...cachedSearchArgs.map((searchArgs) => patchList(SEARCH_ENDPOINT_NAME, searchArgs)),
+          ...(listQuery ? [patchList(listQuery.queryName, listQuery.queryVariables)] : []),
+        ];
+
         try {
           await queryFulfilled;
         } catch {
-          patchResult.undo();
+          patchResults.forEach((patchResult) => patchResult.undo());
         }
       },
     }),
   }),
 });
 
-export const { useUpdateSubscriptionNoteOptimisticMutation, useUpdateSubscriptionDetailNoteOptimisticMutation } =
-  subscriptionListMutationApi;
+export const { useUpdateSubscriptionNoteOptimisticMutation } = subscriptionListMutationApi;

package/src/rtk/utils.spec.ts

@@ -1,4 +1,4 @@
-import { stripUndefined } from '@/rtk/utils';
+import { mapRtkErrorToWfoError, stripUndefined } from '@/rtk/utils';
 
 describe('stripUndefined', () => {
   it('should remove properties with undefined values', () => {
@@ -82,3 +82,32 @@ describe('stripUndefined', () => {
     expect(result).toEqual(obj);
   });
 });
+
+describe('mapRtkErrorToWfoError', () => {
+  it('should return the detail of a rejected request', () => {
+    const detail =
+      '1 validation error for SelectQuery\n  Value error, Hybrid retriever requested but no query text provided.';
+
+    expect(mapRtkErrorToWfoError({ status: 422, data: { detail } })).toEqual([{ extensions: {}, message: detail }]);
+  });
+
+  it('should fall back to the status code when the response body has no detail', () => {
+    expect(mapRtkErrorToWfoError({ status: 500, data: {} })).toEqual([{ extensions: {}, message: '500' }]);
+  });
+
+  it('should fall back to the status code when the detail is not a string', () => {
+    const error = { status: 422, data: { detail: [{ loc: ['body', 'query'], msg: 'field required' }] } };
+
+    expect(mapRtkErrorToWfoError(error)).toEqual([{ extensions: {}, message: '422' }]);
+  });
+
+  it('should return the message of a serialized error', () => {
+    expect(mapRtkErrorToWfoError({ name: 'AbortError', message: 'Aborted' })).toEqual([
+      { extensions: {}, message: 'Aborted' },
+    ]);
+  });
+
+  it('should return undefined when there is no error', () => {
+    expect(mapRtkErrorToWfoError(undefined)).toBeUndefined();
+  });
+});

package/src/rtk/utils.ts

@@ -58,10 +58,11 @@ export const mapRtkErrorToWfoError = (
       };
     });
   } else if (error && 'status' in error && error.status !== undefined) {
+    const detail = isRecord(error.data) && typeof error.data.detail === 'string' ? error.data.detail : undefined;
     return [
       {
         extensions: {},
-        message: String(error.status),
+        message: detail || String(error.status),
       },
     ];
   } else if (isSerializedError(error)) {

package/src/types/search.ts

@@ -217,7 +217,6 @@ export type FieldToOperatorMap = Map<string, string[]>;
 
 export type WfoQueryBuilderContext = {
   onFieldSelected: (field: string, operators: string[], pathInfo?: PathInfo) => void;
-  prefilledFieldOptions: FieldToOperatorMap;
   fieldPathInfoMap: Map<string, PathInfo>;
   useAdvancedNestedSearch: boolean;
 };

package/src/types/types.ts

@@ -475,8 +475,6 @@ export type Subscription = {
   metadata: object;
 };
 
-export type SubscriptionSummary = Pick<Subscription, 'subscriptionId' | 'description' | 'startDate'>;
-
 export type SubscriptionDropdownOption = {
   description: Subscription['description'];
   subscriptionId: Subscription['subscriptionId'];

package/src/utils/getDefaultTableConfig.ts

@@ -97,12 +97,7 @@ export const getDefaultTableConfig = <T>(storageKey: string) => {
       return getTableConfig<T>(completedTasksColumns as (keyof T)[]);
     }
     case SUBSCRIPTIONS_TABLE_LOCAL_STORAGE_KEY: {
-      const subscriptionColumns: (keyof SubscriptionListItem)[] = [
-        'productName',
-        'customerId',
-        'customerFullname',
-        'metadata',
-      ];
+      const subscriptionColumns: (keyof SubscriptionListItem)[] = ['productName', 'customerFullname', 'metadata'];
       return getTableConfig<T>(subscriptionColumns as (keyof T)[]);
     }
     default:

package/src/utils/getQueryParams.ts

@@ -5,6 +5,7 @@ export enum WfoQueryParams {
   SORT_BY = 'sortBy',
   FILTER_BY = 'filterBy',
   QUERY_STRING = 'queryString',
+  FILTER_STRING = 'filterString',
 }
 
 export const getUrlWithQueryParams = (url: string, params: Partial<Record<WfoQueryParams, string>>) => {

package/src/components/WfoSubscriptionsList/WfoSubscriptionsList.tsx

@@ -1,243 +0,0 @@
-import React, { FC } from 'react';
-
-import { useTranslations } from 'next-intl';
-import Link from 'next/link';
-import { useRouter } from 'next/router';
-
-import {
-  ColumnType,
-  FilterQuery,
-  PATH_SUBSCRIPTIONS,
-  Pagination,
-  WfoAdvancedTable,
-  WfoAdvancedTableColumnConfig,
-  WfoDateTime,
-  WfoInlineJson,
-  WfoInsyncIcon,
-  WfoJsonCodeBlock,
-  WfoSubscriptionActions,
-  WfoSubscriptionNoteEdit,
-  WfoSubscriptionStatusBadge,
-  getPageIndexChangeHandler,
-  getPageSizeChangeHandler,
-} from '@/components';
-import {
-  SubscriptionListItem,
-  mapGraphQlSubscriptionsResultToPageInfo,
-  mapGraphQlSubscriptionsResultToSubscriptionListItems,
-} from '@/components';
-import { mapSortableAndFilterableValuesToTableColumnConfig } from '@/components/WfoTable/WfoTable/utils';
-import { DataDisplayParams, useShowToastMessage } from '@/hooks';
-import { useGetSubscriptionListQuery, useLazyGetSubscriptionListQuery } from '@/rtk/endpoints/subscriptionList';
-import { mapRtkErrorToWfoError } from '@/rtk/utils';
-import { GraphqlQueryVariables, SortOrder } from '@/types';
-import { getQueryVariablesForExport, getTypedFieldFromObject, parseDateToLocaleDateTimeString } from '@/utils';
-import { csvDownloadHandler, getCsvFileNameWithDate } from '@/utils/csvDownload';
-
-import {
-  DEFAULT_PAGE_SIZES,
-  SUBSCRIPTIONS_TABLE_LOCAL_STORAGE_KEY,
-  TableColumnKeys,
-  WfoDataSorting,
-  WfoFirstPartUUID,
-  getDataSortHandler,
-  getQueryStringHandler,
-} from '../WfoTable';
-
-export type WfoSubscriptionsListProps = {
-  alwaysOnFilters?: FilterQuery<SubscriptionListItem>[];
-  dataDisplayParams: DataDisplayParams<SubscriptionListItem>;
-  setDataDisplayParam: <DisplayParamKey extends keyof DataDisplayParams<SubscriptionListItem>>(
-    prop: DisplayParamKey,
-    value: DataDisplayParams<SubscriptionListItem>[DisplayParamKey],
-  ) => void;
-  hiddenColumns: TableColumnKeys<SubscriptionListItem> | undefined;
-};
-
-export const WfoSubscriptionsList: FC<WfoSubscriptionsListProps> = ({
-  alwaysOnFilters,
-  dataDisplayParams,
-  setDataDisplayParam,
-  hiddenColumns,
-}) => {
-  const router = useRouter();
-  const t = useTranslations('subscriptions.index');
-  const tError = useTranslations('errors');
-  const { showToastMessage } = useShowToastMessage();
-
-  const { sortBy, queryString, pageIndex, pageSize } = dataDisplayParams;
-
-  const graphqlQueryVariables: GraphqlQueryVariables<SubscriptionListItem> = {
-    first: pageSize,
-    after: pageIndex * pageSize,
-    sortBy,
-    filterBy: alwaysOnFilters,
-    query: queryString || undefined,
-  };
-
-  const { data, isFetching, error, endpointName } = useGetSubscriptionListQuery(graphqlQueryVariables);
-
-  const subscriptionList = mapGraphQlSubscriptionsResultToSubscriptionListItems(data);
-
-  const tableColumnConfig: WfoAdvancedTableColumnConfig<SubscriptionListItem> = {
-    actions: {
-      columnType: ColumnType.CONTROL,
-      width: '50px',
-      renderControl: (row) => <WfoSubscriptionActions compactMode={true} subscriptionId={row.subscriptionId} />,
-    },
-    subscriptionId: {
-      columnType: ColumnType.DATA,
-      label: t('id'),
-      width: '100px',
-      renderData: (value) => <WfoFirstPartUUID UUID={value} />,
-      renderDetails: (value) => value,
-      renderTooltip: (value) => value,
-    },
-    description: {
-      columnType: ColumnType.DATA,
-      label: t('description'),
-      width: '500px',
-      renderData: (value, record) => <Link href={`/subscriptions/${record.subscriptionId}`}>{value}</Link>,
-      renderTooltip: (value) => value,
-    },
-    status: {
-      columnType: ColumnType.DATA,
-      label: t('status'),
-      width: '120px',
-      renderData: (value) => <WfoSubscriptionStatusBadge status={value} />,
-    },
-    insync: {
-      columnType: ColumnType.DATA,
-      label: t('insync'),
-      width: '75px',
-      renderData: (value) => <WfoInsyncIcon inSync={value} />,
-    },
-    productName: {
-      columnType: ColumnType.DATA,
-      width: '260px',
-      label: t('product'),
-    },
-    tag: {
-      columnType: ColumnType.DATA,
-      label: t('tag'),
-      width: '100px',
-    },
-    customerId: {
-      columnType: ColumnType.DATA,
-      label: t('customerId'),
-      width: '100px',
-    },
-    customerFullname: {
-      columnType: ColumnType.DATA,
-      label: t('customerFullname'),
-    },
-    customerShortcode: {
-      columnType: ColumnType.DATA,
-      label: t('customerShortcode'),
-      width: '150px',
-    },
-    startDate: {
-      columnType: ColumnType.DATA,
-      label: t('startDate'),
-      width: '100px',
-      renderData: (value) => <WfoDateTime dateOrIsoString={value} />,
-      renderDetails: parseDateToLocaleDateTimeString,
-      clipboardText: parseDateToLocaleDateTimeString,
-      renderTooltip: (cellValue) => cellValue?.toString(),
-    },
-    endDate: {
-      columnType: ColumnType.DATA,
-      label: t('endDate'),
-      width: '100px',
-      renderData: (value) => <WfoDateTime dateOrIsoString={value} />,
-      renderDetails: parseDateToLocaleDateTimeString,
-      clipboardText: parseDateToLocaleDateTimeString,
-      renderTooltip: (cellValue) => cellValue?.toString(),
-    },
-    note: {
-      columnType: ColumnType.DATA,
-      label: t('note'),
-      width: '300px',
-      renderData: (cellValue, row) => {
-        return (
-          <WfoSubscriptionNoteEdit
-            onlyShowOnHover={true}
-            endpointName={endpointName}
-            queryVariables={graphqlQueryVariables}
-            subscriptionId={row.subscriptionId}
-            note={cellValue}
-          />
-        );
-      },
-    },
-    metadata: {
-      columnType: ColumnType.DATA,
-      label: t('metadata'),
-      width: '100px',
-      renderData: (value) => <WfoInlineJson data={value} />,
-      renderDetails: (value) => value && <WfoJsonCodeBlock data={value} isBasicStyle />,
-      renderTooltip: (value) => value && <WfoJsonCodeBlock data={value} isBasicStyle={false} />,
-    },
-  };
-
-  const [getSubscriptionListTrigger, { isFetching: isFetchingCsv }] = useLazyGetSubscriptionListQuery();
-  const getSubscriptionListForExport = () =>
-    getSubscriptionListTrigger(getQueryVariablesForExport(graphqlQueryVariables)).unwrap();
-
-  const sortedColumnId = getTypedFieldFromObject(sortBy?.field, tableColumnConfig);
-  if (!sortedColumnId) {
-    router.replace(PATH_SUBSCRIPTIONS);
-    return null;
-  }
-
-  const dataSorting: WfoDataSorting<SubscriptionListItem> = {
-    field: sortedColumnId,
-    sortOrder: dataDisplayParams.sortBy?.order ?? SortOrder.ASC,
-  };
-  const { totalItems, sortFields, filterFields } = data?.pageInfo ?? {};
-
-  const pageChange = getPageIndexChangeHandler<SubscriptionListItem>(setDataDisplayParam);
-  const pageSizeChange = getPageSizeChangeHandler<SubscriptionListItem>(setDataDisplayParam);
-  const updateQuery = getQueryStringHandler<SubscriptionListItem>(setDataDisplayParam);
-  const updateSorting = getDataSortHandler<SubscriptionListItem>(setDataDisplayParam);
-
-  const pagination: Pagination = {
-    pageIndex: dataDisplayParams.pageIndex,
-    pageSize: dataDisplayParams.pageSize,
-    pageSizeOptions: DEFAULT_PAGE_SIZES,
-    totalItemCount: totalItems ?? 0,
-    onChangePage: pageChange,
-    onChangeItemsPerPage: pageSizeChange,
-  };
-
-  const exportData = csvDownloadHandler(
-    getSubscriptionListForExport,
-    mapGraphQlSubscriptionsResultToSubscriptionListItems,
-    mapGraphQlSubscriptionsResultToPageInfo,
-    Object.keys(tableColumnConfig),
-    getCsvFileNameWithDate('Subscriptions'),
-    showToastMessage,
-    tError,
-  );
-
-  const tableConfig = mapSortableAndFilterableValuesToTableColumnConfig(tableColumnConfig, sortFields, filterFields);
-
-  return (
-    <WfoAdvancedTable
-      queryString={dataDisplayParams.queryString}
-      onUpdateQueryString={updateQuery}
-      data={subscriptionList}
-      tableColumnConfig={tableConfig}
-      defaultHiddenColumns={hiddenColumns}
-      dataSorting={[dataSorting]}
-      isLoading={isFetching}
-      localStorageKey={SUBSCRIPTIONS_TABLE_LOCAL_STORAGE_KEY}
-      detailModalTitle={'Details - Subscription'}
-      pagination={pagination}
-      error={mapRtkErrorToWfoError(error)}
-      onUpdateDataSorting={updateSorting}
-      onExportData={exportData}
-      exportDataIsLoading={isFetchingCsv}
-    />
-  );
-};

package/src/components/WfoSubscriptionsList/subscriptionResultMappers.ts

@@ -1,49 +0,0 @@
-import { SubscriptionListResponse } from '@/rtk/endpoints/subscriptionList';
-import { Subscription } from '@/types';
-import { parseDate } from '@/utils';
-
-export type SubscriptionListItem = Pick<
-  Subscription,
-  'subscriptionId' | 'description' | 'status' | 'insync' | 'note'
-> & {
-  startDate: Date | null;
-  endDate: Date | null;
-  productName: string;
-  tag: string | null;
-  customerFullname: string;
-  customerShortcode: string;
-  customerId: string;
-  metadata: object | null;
-};
-
-export const mapGraphQlSubscriptionsResultToPageInfo = (graphqlResponse: SubscriptionListResponse) =>
-  graphqlResponse.pageInfo;
-
-export const mapGraphQlSubscriptionsResultToSubscriptionListItems = (
-  graphqlResponse: SubscriptionListResponse | undefined,
-): SubscriptionListItem[] => {
-  if (!graphqlResponse) return [];
-  return graphqlResponse.subscriptions.map((subscription) => {
-    const { description, insync, product, startDate, endDate, status, subscriptionId, note, customer, metadata } =
-      subscription;
-
-    const { name: productName, tag } = product;
-    const { fullname: customerFullname, shortcode: customerShortcode, customerId } = customer;
-
-    return {
-      subscriptionId,
-      description,
-      status,
-      insync,
-      startDate: parseDate(startDate),
-      endDate: parseDate(endDate),
-      note,
-      productName,
-      tag,
-      customerFullname,
-      customerShortcode,
-      customerId,
-      metadata: Object.keys(metadata).length > 0 ? metadata : null,
-    };
-  });
-};