@oxyhq/services 5.21.6 → 5.22.0

package/src/ui/hooks/mutations/mutationFactory.ts

@@ -0,0 +1,215 @@
+/**
+ * Mutation Factory - Creates standardized mutations with optimistic updates
+ *
+ * This factory reduces boilerplate code for mutations that follow the common pattern:
+ * 1. Cancel outgoing queries
+ * 2. Snapshot previous data
+ * 3. Apply optimistic update
+ * 4. On error: rollback and show toast
+ * 5. On success: update cache, stores, and invalidate queries
+ */
+
+import { QueryClient, UseMutationOptions } from '@tanstack/react-query';
+import type { User } from '../../../models/interfaces';
+import { queryKeys, invalidateAccountQueries, invalidateUserQueries } from '../queries/queryKeys';
+import { toast } from '../../../lib/sonner';
+import { useAuthStore } from '../../stores/authStore';
+
+/**
+ * Configuration for creating a standard profile mutation
+ */
+export interface ProfileMutationConfig<TData, TVariables> {
+  /** The mutation function that makes the API call */
+  mutationFn: (variables: TVariables) => Promise<TData>;
+  /** Query keys to cancel before mutation */
+  cancelQueryKeys?: unknown[][];
+  /** Function to apply optimistic update to the user data */
+  optimisticUpdate?: (previousUser: User, variables: TVariables) => Partial<User>;
+  /** Error message to show on failure */
+  errorMessage?: string | ((error: Error) => string);
+  /** Success message to show (optional) */
+  successMessage?: string;
+  /** Whether to update authStore on success (default: true) */
+  updateAuthStore?: boolean;
+  /** Whether to invalidate user queries on success (default: true) */
+  invalidateUserQueries?: boolean;
+  /** Whether to invalidate account queries on success (default: true) */
+  invalidateAccountQueries?: boolean;
+  /** Custom onSuccess handler */
+  onSuccess?: (data: TData, variables: TVariables, queryClient: QueryClient) => void;
+}
+
+/**
+ * Creates a standard profile mutation with optimistic updates
+ *
+ * @example
+ * ```ts
+ * const updateProfile = createProfileMutation({
+ *   mutationFn: (updates) => oxyServices.updateProfile(updates),
+ *   optimisticUpdate: (user, updates) => updates,
+ *   errorMessage: 'Failed to update profile',
+ * });
+ * ```
+ */
+export function createProfileMutation<TVariables>(
+  config: ProfileMutationConfig<User, TVariables>,
+  queryClient: QueryClient,
+  activeSessionId: string | null
+): UseMutationOptions<User, Error, TVariables, { previousUser?: User }> {
+  const {
+    mutationFn,
+    cancelQueryKeys = [],
+    optimisticUpdate,
+    errorMessage = 'Operation failed',
+    successMessage,
+    updateAuthStore = true,
+    invalidateUserQueries: shouldInvalidateUserQueries = true,
+    invalidateAccountQueries: shouldInvalidateAccountQueries = true,
+    onSuccess: customOnSuccess,
+  } = config;
+
+  return {
+    mutationFn,
+
+    onMutate: async (variables) => {
+      // Cancel queries that might conflict
+      await queryClient.cancelQueries({ queryKey: queryKeys.accounts.current() });
+      for (const key of cancelQueryKeys) {
+        await queryClient.cancelQueries({ queryKey: key });
+      }
+
+      // Snapshot previous user data
+      const previousUser = queryClient.getQueryData<User>(queryKeys.accounts.current());
+
+      // Apply optimistic update if provided
+      if (previousUser && optimisticUpdate) {
+        const updates = optimisticUpdate(previousUser, variables);
+        const optimisticUser = { ...previousUser, ...updates };
+
+        queryClient.setQueryData<User>(queryKeys.accounts.current(), optimisticUser);
+
+        if (activeSessionId) {
+          queryClient.setQueryData<User>(queryKeys.users.profile(activeSessionId), optimisticUser);
+        }
+      }
+
+      return { previousUser };
+    },
+
+    onError: (error, _variables, context) => {
+      // Rollback optimistic update
+      if (context?.previousUser) {
+        queryClient.setQueryData(queryKeys.accounts.current(), context.previousUser);
+        if (activeSessionId) {
+          queryClient.setQueryData(queryKeys.users.profile(activeSessionId), context.previousUser);
+        }
+      }
+
+      // Show error toast
+      const message = typeof errorMessage === 'function'
+        ? errorMessage(error)
+        : (error instanceof Error ? error.message : errorMessage);
+      toast.error(message);
+    },
+
+    onSuccess: (data, variables) => {
+      // Update cache with server response
+      queryClient.setQueryData(queryKeys.accounts.current(), data);
+      if (activeSessionId) {
+        queryClient.setQueryData(queryKeys.users.profile(activeSessionId), data);
+      }
+
+      // Update authStore for immediate UI updates
+      if (updateAuthStore) {
+        useAuthStore.getState().setUser(data);
+      }
+
+      // Invalidate related queries
+      if (shouldInvalidateUserQueries) {
+        invalidateUserQueries(queryClient);
+      }
+      if (shouldInvalidateAccountQueries) {
+        invalidateAccountQueries(queryClient);
+      }
+
+      // Show success toast if configured
+      if (successMessage) {
+        toast.success(successMessage);
+      }
+
+      // Call custom onSuccess handler
+      if (customOnSuccess) {
+        customOnSuccess(data, variables, queryClient);
+      }
+    },
+  };
+}
+
+/**
+ * Configuration for creating a generic mutation (non-profile)
+ */
+export interface GenericMutationConfig<TData, TVariables, TContext> {
+  /** The mutation function */
+  mutationFn: (variables: TVariables) => Promise<TData>;
+  /** Query key for optimistic data */
+  queryKey: unknown[];
+  /** Function to create optimistic data */
+  optimisticData?: (previous: TData | undefined, variables: TVariables) => TData;
+  /** Error message */
+  errorMessage?: string;
+  /** Success message */
+  successMessage?: string;
+  /** Additional queries to invalidate on success */
+  invalidateQueries?: unknown[][];
+}
+
+/**
+ * Creates a generic mutation with optimistic updates
+ */
+export function createGenericMutation<TData, TVariables>(
+  config: GenericMutationConfig<TData, TVariables, { previous?: TData }>,
+  queryClient: QueryClient
+): UseMutationOptions<TData, Error, TVariables, { previous?: TData }> {
+  const {
+    mutationFn,
+    queryKey,
+    optimisticData,
+    errorMessage = 'Operation failed',
+    successMessage,
+    invalidateQueries = [],
+  } = config;
+
+  return {
+    mutationFn,
+
+    onMutate: async (variables) => {
+      await queryClient.cancelQueries({ queryKey });
+      const previous = queryClient.getQueryData<TData>(queryKey);
+
+      if (optimisticData) {
+        queryClient.setQueryData<TData>(queryKey, optimisticData(previous, variables));
+      }
+
+      return { previous };
+    },
+
+    onError: (error, _variables, context) => {
+      if (context?.previous !== undefined) {
+        queryClient.setQueryData(queryKey, context.previous);
+      }
+      toast.error(error instanceof Error ? error.message : errorMessage);
+    },
+
+    onSuccess: (data) => {
+      queryClient.setQueryData(queryKey, data);
+
+      for (const key of invalidateQueries) {
+        queryClient.invalidateQueries({ queryKey: key });
+      }
+
+      if (successMessage) {
+        toast.success(successMessage);
+      }
+    },
+  };
+}

package/src/ui/hooks/mutations/useAccountMutations.ts

@@ -5,6 +5,7 @@ import { useOxy } from '../../context/OxyContext';
 import { toast } from '../../../lib/sonner';
 import { refreshAvatarInStore } from '../../utils/avatarUtils';
 import { useAuthStore } from '../../stores/authStore';
+import { authenticatedApiCall } from '../../utils/authHelpers';
 
 /**
  * Update user profile with optimistic updates and offline queue support
@@ -15,38 +16,11 @@ export const useUpdateProfile = () => {
 
   return useMutation({
     mutationFn: async (updates: Partial<User>) => {
-      // Ensure we have a valid token before making the request
-      if (!oxyServices.hasValidToken() && activeSessionId) {
-        try {
-          // Try to get token for the session
-          await oxyServices.getTokenBySession(activeSessionId);
-        } catch (tokenError) {
-          // If getting token fails, might be an offline session - try syncing
-          const errorMessage = tokenError instanceof Error ? tokenError.message : String(tokenError);
-          if (errorMessage.includes('AUTH_REQUIRED_OFFLINE_SESSION') || errorMessage.includes('offline')) {
-            // Session sync should be handled by the app layer
-            throw new Error('Session needs to be synced. Please try again.');
-          } else {
-            throw tokenError;
-          }
-        }
-      }
-
-      try {
-        return await oxyServices.updateProfile(updates);
-      } catch (error: any) {
-        const errorMessage = error?.message || '';
-        const status = error?.status || error?.response?.status;
-        
-        // Handle authentication errors
-        if (status === 401 || errorMessage.includes('Authentication required') || errorMessage.includes('Invalid or missing authorization header')) {
-          // Session sync should be handled by the app layer
-          throw new Error('Authentication failed. Please sign in again.');
-        }
-        
-        // TanStack Query will automatically retry on network errors
-        throw error;
-      }
+      return authenticatedApiCall<User>(
+        oxyServices,
+        activeSessionId,
+        () => oxyServices.updateProfile(updates)
+      );
     },
     // Optimistic update
     onMutate: async (updates) => {
@@ -116,22 +90,7 @@ export const useUploadAvatar = () => {
 
   return useMutation({
     mutationFn: async (file: { uri: string; type?: string; name?: string; size?: number }) => {
-      // Ensure we have a valid token before making the request
-      if (!oxyServices.hasValidToken() && activeSessionId) {
-        try {
-          await oxyServices.getTokenBySession(activeSessionId);
-        } catch (tokenError) {
-          const errorMessage = tokenError instanceof Error ? tokenError.message : String(tokenError);
-          if (errorMessage.includes('AUTH_REQUIRED_OFFLINE_SESSION') || errorMessage.includes('offline')) {
-            // Session sync should be handled by the app layer
-            throw new Error('Session needs to be synced. Please try again.');
-          } else {
-            throw tokenError;
-          }
-        }
-      }
-
-      try {
+      return authenticatedApiCall<User>(oxyServices, activeSessionId, async () => {
         // Upload file first
         const uploadResult = await oxyServices.assetUpload(file as any, 'public');
         const fileId = uploadResult?.file?.id || uploadResult?.id || uploadResult;
@@ -142,19 +101,7 @@ export const useUploadAvatar = () => {
 
         // Update profile with file ID
         return await oxyServices.updateProfile({ avatar: fileId });
-      } catch (error: any) {
-        const errorMessage = error?.message || '';
-        const status = error?.status || error?.response?.status;
-        
-        // Handle authentication errors
-        if (status === 401 || errorMessage.includes('Authentication required') || errorMessage.includes('Invalid or missing authorization header')) {
-          // Session sync should be handled by the app layer
-          throw new Error('Authentication failed. Please sign in again.');
-        }
-        
-        // TanStack Query will automatically retry on network errors
-        throw error;
-      }
+      });
     },
     onMutate: async (file) => {
       await queryClient.cancelQueries({ queryKey: queryKeys.accounts.current() });
@@ -267,38 +214,11 @@ export const useUpdatePrivacySettings = () => {
         throw new Error('User ID is required');
       }
 
-      // Ensure we have a valid token before making the request
-      if (!oxyServices.hasValidToken() && activeSessionId) {
-        try {
-          // Try to get token for the session
-          await oxyServices.getTokenBySession(activeSessionId);
-        } catch (tokenError) {
-          // If getting token fails, might be an offline session - try syncing
-          const errorMessage = tokenError instanceof Error ? tokenError.message : String(tokenError);
-          if (errorMessage.includes('AUTH_REQUIRED_OFFLINE_SESSION') || errorMessage.includes('offline')) {
-            // Session sync should be handled by the app layer
-            throw new Error('Session needs to be synced. Please try again.');
-          } else {
-            throw tokenError;
-          }
-        }
-      }
-
-      try {
-        return await oxyServices.updatePrivacySettings(settings, targetUserId);
-      } catch (error: any) {
-        const errorMessage = error?.message || '';
-        const status = error?.status || error?.response?.status;
-        
-        // Handle authentication errors
-        if (status === 401 || errorMessage.includes('Authentication required') || errorMessage.includes('Invalid or missing authorization header')) {
-          // Session sync should be handled by the app layer
-          throw new Error('Authentication failed. Please sign in again.');
-        }
-        
-        // TanStack Query will automatically retry on network errors
-        throw error;
-      }
+      return authenticatedApiCall<Record<string, unknown>>(
+        oxyServices,
+        activeSessionId,
+        () => oxyServices.updatePrivacySettings(settings, targetUserId)
+      );
     },
     // Optimistic update
     onMutate: async ({ settings, userId }) => {
@@ -354,12 +274,12 @@ export const useUpdatePrivacySettings = () => {
       // Also update account query if it contains privacy settings
       const currentUser = queryClient.getQueryData<User>(queryKeys.accounts.current());
       if (currentUser) {
-        const updatedUser = {
+        const updatedUser: User = {
           ...currentUser,
-          privacySettings: data,
+          privacySettings: data as { [key: string]: unknown },
         };
         queryClient.setQueryData<User>(queryKeys.accounts.current(), updatedUser);
-        
+
         // Update authStore so frontend components see the changes immediately
         useAuthStore.getState().setUser(updatedUser);
       }
@@ -376,6 +296,25 @@ export const useUpdatePrivacySettings = () => {
   });
 };
 
+/** Uploaded file data structure from API */
+interface UploadedFile {
+  id: string;
+  originalName?: string;
+  sha256?: string;
+  mime?: string;
+  size?: number;
+  createdAt?: string;
+  metadata?: Record<string, unknown>;
+  variants?: Array<{ type: string; key: string; width?: number; height?: number; readyAt?: string; metadata?: Record<string, unknown> }>;
+}
+
+/** Upload result type that supports both single file and batch responses */
+interface UploadResult {
+  file?: UploadedFile;
+  files?: UploadedFile[];
+  id?: string;
+}
+
 /**
  * Upload file with authentication handling and progress tracking
  */
@@ -383,49 +322,22 @@ export const useUploadFile = () => {
   const { oxyServices, activeSessionId } = useOxy();
 
   return useMutation({
-    mutationFn: async ({ 
-      file, 
-      visibility, 
-      metadata, 
-      onProgress 
-    }: { 
-      file: File; 
-      visibility?: 'private' | 'public' | 'unlisted'; 
+    mutationFn: async ({
+      file,
+      visibility,
+      metadata,
+      onProgress
+    }: {
+      file: File;
+      visibility?: 'private' | 'public' | 'unlisted';
       metadata?: Record<string, any>;
       onProgress?: (progress: number) => void;
     }) => {
-      // Ensure we have a valid token before making the request
-      if (!oxyServices.hasValidToken() && activeSessionId) {
-        try {
-          // Try to get token for the session
-          await oxyServices.getTokenBySession(activeSessionId);
-        } catch (tokenError) {
-          // If getting token fails, might be an offline session - try syncing
-          const errorMessage = tokenError instanceof Error ? tokenError.message : String(tokenError);
-          if (errorMessage.includes('AUTH_REQUIRED_OFFLINE_SESSION') || errorMessage.includes('offline')) {
-            // Session sync should be handled by the app layer
-            throw new Error('Session needs to be synced. Please try again.');
-          } else {
-            throw tokenError;
-          }
-        }
-      }
-
-      try {
-        return await oxyServices.assetUpload(file as any, visibility, metadata, onProgress);
-      } catch (error: any) {
-        const errorMessage = error?.message || '';
-        const status = error?.status || error?.response?.status;
-        
-        // Handle authentication errors
-        if (status === 401 || errorMessage.includes('Authentication required') || errorMessage.includes('Invalid or missing authorization header')) {
-          // Session sync should be handled by the app layer
-          throw new Error('Authentication failed. Please sign in again.');
-        }
-        
-        // TanStack Query will automatically retry on network errors
-        throw error;
-      }
+      return authenticatedApiCall<UploadResult>(
+        oxyServices,
+        activeSessionId,
+        () => oxyServices.assetUpload(file as any, visibility, metadata, onProgress)
+      );
     },
   });
 };

package/src/ui/hooks/queries/useAccountQueries.ts

@@ -1,8 +1,8 @@
 import { useQuery, useQueries } from '@tanstack/react-query';
 import type { User } from '../../../models/interfaces';
-import type { OxyServices } from '../../../core';
 import { queryKeys } from './queryKeys';
 import { useOxy } from '../../context/OxyContext';
+import { authenticatedApiCall } from '../../utils/authHelpers';
 
 /**
  * Get user profile by session ID
@@ -138,38 +138,11 @@ export const usePrivacySettings = (userId?: string, options?: { enabled?: boolea
         throw new Error('User ID is required');
       }
 
-      // Ensure we have a valid token before making the request
-      if (!oxyServices.hasValidToken() && activeSessionId) {
-        try {
-          // Try to get token for the session
-          await oxyServices.getTokenBySession(activeSessionId);
-        } catch (tokenError) {
-          // If getting token fails, might be an offline session - try syncing
-          const errorMessage = tokenError instanceof Error ? tokenError.message : String(tokenError);
-          if (errorMessage.includes('AUTH_REQUIRED_OFFLINE_SESSION') || errorMessage.includes('offline')) {
-            // Session sync should be handled by the app layer (e.g., accounts app's useIdentity hook)
-            throw new Error('Session needs to be synced. Please try again.');
-          } else {
-            throw tokenError;
-          }
-        }
-      }
-
-      try {
-        return await oxyServices.getPrivacySettings(targetUserId);
-      } catch (error: any) {
-        const errorMessage = error?.message || '';
-        const status = error?.status || error?.response?.status;
-        
-        // Handle authentication errors
-        if (status === 401 || errorMessage.includes('Authentication required') || errorMessage.includes('Invalid or missing authorization header')) {
-          // Session sync should be handled by the app layer
-          throw new Error('Authentication failed. Please sign in again.');
-        }
-        
-        // TanStack Query will automatically retry on network errors
-        throw error;
-      }
+      return authenticatedApiCall(
+        oxyServices,
+        activeSessionId,
+        () => oxyServices.getPrivacySettings(targetUserId)
+      );
     },
     enabled: (options?.enabled !== false) && !!targetUserId,
     staleTime: 2 * 60 * 1000, // 2 minutes

package/src/ui/hooks/queries/useServicesQueries.ts

@@ -3,6 +3,7 @@ import type { ClientSession } from '../../../models/session';
 import { queryKeys } from './queryKeys';
 import { useOxy } from '../../context/OxyContext';
 import { fetchSessionsWithFallback, mapSessionsToClient } from '../../utils/sessionHelpers';
+import { authenticatedApiCall } from '../../utils/authHelpers';
 
 /**
  * Get all active sessions for the current user
@@ -94,38 +95,11 @@ export const useUserDevices = (options?: { enabled?: boolean }) => {
   return useQuery({
     queryKey: queryKeys.devices.list(),
     queryFn: async () => {
-      // Ensure we have a valid token before making the request
-      if (!oxyServices.hasValidToken() && activeSessionId) {
-        try {
-          // Try to get token for the session
-          await oxyServices.getTokenBySession(activeSessionId);
-        } catch (tokenError) {
-          // If getting token fails, might be an offline session - try syncing
-          const errorMessage = tokenError instanceof Error ? tokenError.message : String(tokenError);
-          if (errorMessage.includes('AUTH_REQUIRED_OFFLINE_SESSION') || errorMessage.includes('offline')) {
-            // Session sync should be handled by the app layer
-            throw new Error('Session needs to be synced. Please try again.');
-          } else {
-            throw tokenError;
-          }
-        }
-      }
-
-      try {
-        return await oxyServices.getUserDevices();
-      } catch (error: any) {
-        const errorMessage = error?.message || '';
-        const status = error?.status || error?.response?.status;
-        
-        // Handle authentication errors
-        if (status === 401 || errorMessage.includes('Authentication required') || errorMessage.includes('Invalid or missing authorization header')) {
-          // Session sync should be handled by the app layer
-          throw new Error('Authentication failed. Please sign in again.');
-        }
-        
-        // TanStack Query will automatically retry on network errors
-        throw error;
-      }
+      return authenticatedApiCall(
+        oxyServices,
+        activeSessionId,
+        () => oxyServices.getUserDevices()
+      );
     },
     enabled: (options?.enabled !== false) && isAuthenticated,
     staleTime: 5 * 60 * 1000,

package/src/ui/hooks/useFileFiltering.ts

@@ -0,0 +1,115 @@
+import { useMemo, useState, useCallback } from 'react';
+import type { FileMetadata } from '../../models/interfaces';
+
+export type ViewMode = 'all' | 'photos' | 'videos' | 'documents' | 'audio';
+export type SortBy = 'date' | 'size' | 'name' | 'type';
+export type SortOrder = 'asc' | 'desc';
+
+interface UseFileFilteringOptions {
+  files: FileMetadata[];
+  initialViewMode?: ViewMode;
+  initialSortBy?: SortBy;
+  initialSortOrder?: SortOrder;
+}
+
+interface UseFileFilteringReturn {
+  filteredFiles: FileMetadata[];
+  viewMode: ViewMode;
+  setViewMode: (mode: ViewMode) => void;
+  searchQuery: string;
+  setSearchQuery: (query: string) => void;
+  sortBy: SortBy;
+  setSortBy: (sort: SortBy) => void;
+  sortOrder: SortOrder;
+  setSortOrder: (order: SortOrder) => void;
+  toggleSortOrder: () => void;
+}
+
+/**
+ * Hook for file filtering, sorting, and search functionality
+ * Extracts common file management logic for reuse across components
+ */
+export function useFileFiltering({
+  files,
+  initialViewMode = 'all',
+  initialSortBy = 'date',
+  initialSortOrder = 'desc',
+}: UseFileFilteringOptions): UseFileFilteringReturn {
+  const [viewMode, setViewMode] = useState<ViewMode>(initialViewMode);
+  const [searchQuery, setSearchQuery] = useState('');
+  const [sortBy, setSortBy] = useState<SortBy>(initialSortBy);
+  const [sortOrder, setSortOrder] = useState<SortOrder>(initialSortOrder);
+
+  const toggleSortOrder = useCallback(() => {
+    setSortOrder((prev) => (prev === 'asc' ? 'desc' : 'asc'));
+  }, []);
+
+  const filteredFiles = useMemo(() => {
+    // Filter by view mode
+    let filteredByMode = files;
+    if (viewMode === 'photos') {
+      filteredByMode = files.filter((file) => file.contentType.startsWith('image/'));
+    } else if (viewMode === 'videos') {
+      filteredByMode = files.filter((file) => file.contentType.startsWith('video/'));
+    } else if (viewMode === 'documents') {
+      filteredByMode = files.filter(
+        (file) =>
+          file.contentType.includes('pdf') ||
+          file.contentType.includes('document') ||
+          file.contentType.includes('text') ||
+          file.contentType.includes('msword') ||
+          file.contentType.includes('excel') ||
+          file.contentType.includes('spreadsheet') ||
+          file.contentType.includes('presentation') ||
+          file.contentType.includes('powerpoint')
+      );
+    } else if (viewMode === 'audio') {
+      filteredByMode = files.filter((file) => file.contentType.startsWith('audio/'));
+    }
+
+    // Filter by search query
+    let filtered = filteredByMode;
+    if (searchQuery.trim()) {
+      const query = searchQuery.toLowerCase();
+      filtered = filteredByMode.filter(
+        (file) =>
+          file.filename.toLowerCase().includes(query) ||
+          file.contentType.toLowerCase().includes(query) ||
+          (file.metadata?.description &&
+            file.metadata.description.toLowerCase().includes(query))
+      );
+    }
+
+    // Sort files
+    const sorted = [...filtered].sort((a, b) => {
+      let comparison = 0;
+      if (sortBy === 'date') {
+        const dateA = new Date(a.uploadDate || 0).getTime();
+        const dateB = new Date(b.uploadDate || 0).getTime();
+        comparison = dateA - dateB;
+      } else if (sortBy === 'size') {
+        comparison = (a.length || 0) - (b.length || 0);
+      } else if (sortBy === 'name') {
+        comparison = (a.filename || '').localeCompare(b.filename || '');
+      } else if (sortBy === 'type') {
+        comparison = (a.contentType || '').localeCompare(b.contentType || '');
+      }
+      return sortOrder === 'asc' ? comparison : -comparison;
+    });
+
+    return sorted;
+  }, [files, searchQuery, viewMode, sortBy, sortOrder]);
+
+  return {
+    filteredFiles,
+    viewMode,
+    setViewMode,
+    searchQuery,
+    setSearchQuery,
+    sortBy,
+    setSortBy,
+    sortOrder,
+    setSortOrder,
+    toggleSortOrder,
+  };
+}