@oxy.so/services 11.2.0-oxy-one.3 → 11.2.0-oxy-one.5

package/src/ui/hooks/queryClient.ts

@@ -26,7 +26,11 @@ import type { PersistedClient } from '@tanstack/react-query-persist-client';
 import { isDev } from '@oxy.so/core';
 import type { StorageInterface } from '../utils/storageHelpers';
 import { accountQueryOwnership, type AccountQueriesConfig } from './accountQueryPersistence';
-import { PERSISTED_QUERY_PREFIXES, hydrateSnapshot, subscribeSnapshots } from './persistedQueryCache';
+import {
+  PERSISTED_QUERY_PREFIXES,
+  hydrateSnapshot,
+  subscribeSnapshots,
+} from './persistedQueryCache';
 
 const QUERY_CACHE_KEY = 'oxy_query_cache_v3';
 const QUERY_CACHE_MAX_AGE = 30 * 24 * 60 * 60 * 1000; // 30 days
@@ -35,8 +39,9 @@ const MAX_QUERY_RETRIES = 2;
 
 function statusOf(error: unknown): number | null {
   if (!error || typeof error !== 'object') return null;
-  const value = (error as { status?: unknown; response?: { status?: unknown } }).status
-    ?? (error as { response?: { status?: unknown } }).response?.status;
+  const value =
+    (error as { status?: unknown; response?: { status?: unknown } }).status ??
+    (error as { response?: { status?: unknown } }).response?.status;
   return typeof value === 'number' ? value : null;
 }
 
@@ -156,8 +161,7 @@ export const attachQueryPersistence = (
       isSharedQuery(query) && !(account?.ownsQuery(query) ?? false),
     // Every other mutation, whatever its status: paused ones are exactly the
     // ones that must survive a restart to replay when online.
-    shouldDehydrateMutation: (mutation: Mutation) =>
-      !(account?.ownsMutation(mutation) ?? false),
+    shouldDehydrateMutation: (mutation: Mutation) => !(account?.ownsMutation(mutation) ?? false),
   };
 
   let stopped = false;

package/src/ui/hooks/useAssets.ts

@@ -37,202 +37,208 @@ export const useAssets = () => {
     getAssetsByEntity,
     getAssetUsageCount,
     isAssetLinked,
-    reset
+    reset,
   } = useAssetStore();
 
   // Upload asset with progress tracking
-  const upload = useCallback(async (
-    file: File,
-    metadata?: AssetMetadata
-  ): Promise<UploadedAsset | null> => {
-    if (!oxyInstance) {
-      throw new Error('OxyServices instance not configured. Call setOxyAssetInstance first.');
-    }
+  const upload = useCallback(
+    async (file: File, metadata?: AssetMetadata): Promise<UploadedAsset | null> => {
+      if (!oxyInstance) {
+        throw new Error('OxyServices instance not configured. Call setOxyAssetInstance first.');
+      }
 
-    try {
-      clearErrors();
-      setUploading(true);
-      
-      const result = await oxyInstance.assets.upload(file, { metadata });
+      try {
+        clearErrors();
+        setUploading(true);
 
-      // Update progress with final status
-      if (result?.file) {
-        const fileId = result.file.id;
-        setUploadProgress(fileId, {
-          fileId,
-          uploaded: file.size,
-          total: file.size,
-          percentage: 100,
-          status: 'complete'
-        });
-        
-        // Remove progress after a short delay
-        setTimeout(() => {
-          removeUploadProgress(fileId);
-        }, 2000);
-      }
+        const result = await oxyInstance.assets.upload(file, { metadata });
 
-      // Add asset to store
-      if (result.file) {
-        mergeAsset(result.file);
-        return result.file;
+        // Update progress with final status
+        if (result?.file) {
+          const fileId = result.file.id;
+          setUploadProgress(fileId, {
+            fileId,
+            uploaded: file.size,
+            total: file.size,
+            percentage: 100,
+            status: 'complete',
+          });
+
+          // Remove progress after a short delay
+          setTimeout(() => {
+            removeUploadProgress(fileId);
+          }, 2000);
+        }
+
+        // Add asset to store
+        if (result.file) {
+          mergeAsset(result.file);
+          return result.file;
+        }
+
+        return null;
+      } catch (error: unknown) {
+        setUploadError((error instanceof Error ? error.message : null) || 'Upload failed');
+        throw error;
+      } finally {
+        setUploading(false);
       }
-      
-      return null;
-    } catch (error: unknown) {
-      setUploadError((error instanceof Error ? error.message : null) || 'Upload failed');
-      throw error;
-    } finally {
-      setUploading(false);
-    }
-  }, [
-    clearErrors, 
-    setUploading, 
-    setUploadProgress, 
-    removeUploadProgress, 
-    mergeAsset, 
-    setUploadError
-  ]);
+    },
+    [
+      clearErrors,
+      setUploading,
+      setUploadProgress,
+      removeUploadProgress,
+      mergeAsset,
+      setUploadError,
+    ],
+  );
 
   // Link asset to entity
-  const link = useCallback(async (
-    assetId: string, 
-    app: string, 
-    entityType: string, 
-    entityId: string
-  ): Promise<void> => {
-    if (!oxyInstance) {
-      throw new Error('OxyServices instance not configured. Call setOxyAssetInstance first.');
-    }
+  const link = useCallback(
+    async (assetId: string, app: string, entityType: string, entityId: string): Promise<void> => {
+      if (!oxyInstance) {
+        throw new Error('OxyServices instance not configured. Call setOxyAssetInstance first.');
+      }
 
-    try {
-      clearErrors();
-      setLinking(true);
-      
-      // Auto-detect visibility for avatars and profile banners
-      const visibility = (entityType === 'avatar' || entityType === 'profile-banner') 
-        ? 'public' as const
-        : undefined;
-      
-      const result = await oxyInstance.assets.link(assetId, { app, entityType, entityId }, { visibility });
-      
-      if (result.file) {
-        mergeAsset(result.file);
-      } else {
-        // If API doesn't return full file, update store optimistically
-        addLink(assetId, {
-          app,
-          entityType,
-          entityId,
-          createdBy: '', // Will be filled by server
-          createdAt: new Date().toISOString()
-        });
+      try {
+        clearErrors();
+        setLinking(true);
+
+        // Auto-detect visibility for avatars and profile banners
+        const visibility =
+          entityType === 'avatar' || entityType === 'profile-banner'
+            ? ('public' as const)
+            : undefined;
+
+        const result = await oxyInstance.assets.link(
+          assetId,
+          { app, entityType, entityId },
+          { visibility },
+        );
+
+        if (result.file) {
+          mergeAsset(result.file);
+        } else {
+          // If API doesn't return full file, update store optimistically
+          addLink(assetId, {
+            app,
+            entityType,
+            entityId,
+            createdBy: '', // Will be filled by server
+            createdAt: new Date().toISOString(),
+          });
+        }
+      } catch (error: unknown) {
+        setLinkError((error instanceof Error ? error.message : null) || 'Link failed');
+        throw error;
+      } finally {
+        setLinking(false);
       }
-    } catch (error: unknown) {
-      setLinkError((error instanceof Error ? error.message : null) || 'Link failed');
-      throw error;
-    } finally {
-      setLinking(false);
-    }
-  }, [clearErrors, setLinking, mergeAsset, addLink, setLinkError]);
+    },
+    [clearErrors, setLinking, mergeAsset, addLink, setLinkError],
+  );
 
   // Unlink asset from entity
-  const unlink = useCallback(async (
-    assetId: string, 
-    app: string, 
-    entityType: string, 
-    entityId: string
-  ): Promise<void> => {
-    if (!oxyInstance) {
-      throw new Error('OxyServices instance not configured. Call setOxyAssetInstance first.');
-    }
+  const unlink = useCallback(
+    async (assetId: string, app: string, entityType: string, entityId: string): Promise<void> => {
+      if (!oxyInstance) {
+        throw new Error('OxyServices instance not configured. Call setOxyAssetInstance first.');
+      }
 
-    try {
-      clearErrors();
-      setLinking(true);
-      
-      const result = await oxyInstance.assets.unlink(assetId, { app, entityType, entityId });
-      
-      if (result.file) {
-        mergeAsset(result.file);
-      } else {
-        // Update store optimistically
-        removeLink(assetId, app, entityType, entityId);
+      try {
+        clearErrors();
+        setLinking(true);
+
+        const result = await oxyInstance.assets.unlink(assetId, { app, entityType, entityId });
+
+        if (result.file) {
+          mergeAsset(result.file);
+        } else {
+          // Update store optimistically
+          removeLink(assetId, app, entityType, entityId);
+        }
+      } catch (error: unknown) {
+        setLinkError((error instanceof Error ? error.message : null) || 'Unlink failed');
+        throw error;
+      } finally {
+        setLinking(false);
       }
-    } catch (error: unknown) {
-      setLinkError((error instanceof Error ? error.message : null) || 'Unlink failed');
-      throw error;
-    } finally {
-      setLinking(false);
-    }
-  }, [clearErrors, setLinking, mergeAsset, removeLink, setLinkError]);
+    },
+    [clearErrors, setLinking, mergeAsset, removeLink, setLinkError],
+  );
 
   // Get asset URL
-  const getUrl = useCallback(async (
-    assetId: string, 
-    variant?: string, 
-    expiresIn?: number
-  ): Promise<string> => {
-    if (!oxyInstance) {
-      throw new Error('OxyServices instance not configured. Call setOxyAssetInstance first.');
-    }
+  const getUrl = useCallback(
+    async (assetId: string, variant?: string, expiresIn?: number): Promise<string> => {
+      if (!oxyInstance) {
+        throw new Error('OxyServices instance not configured. Call setOxyAssetInstance first.');
+      }
       return oxyInstance.assets.url(assetId, variant, expiresIn);
-  }, []);
+    },
+    [],
+  );
 
   // Get asset metadata
-  const getAsset = useCallback(async (assetId: string): Promise<AssetRecord> => {
-    if (!oxyInstance) {
-      throw new Error('OxyServices instance not configured. Call setOxyAssetInstance first.');
-    }
+  const getAsset = useCallback(
+    async (assetId: string): Promise<AssetRecord> => {
+      if (!oxyInstance) {
+        throw new Error('OxyServices instance not configured. Call setOxyAssetInstance first.');
+      }
       const result = await oxyInstance.assets.get(assetId);
       if (result.file) {
         mergeAsset(result.file);
         return result.file;
       }
       throw new Error('Asset not found');
-  }, [mergeAsset]);
+    },
+    [mergeAsset],
+  );
 
   // Delete asset
-  const deleteAsset = useCallback(async (
-    assetId: string, 
-    force = false
-  ): Promise<void> => {
-    if (!oxyInstance) {
-      throw new Error('OxyServices instance not configured. Call setOxyAssetInstance first.');
-    }
+  const deleteAsset = useCallback(
+    async (assetId: string, force = false): Promise<void> => {
+      if (!oxyInstance) {
+        throw new Error('OxyServices instance not configured. Call setOxyAssetInstance first.');
+      }
 
-    try {
-      clearErrors();
-      setDeleting(true);
-      
-      await oxyInstance.assets.delete(assetId, { force });
-      removeAsset(assetId);
-    } catch (error: unknown) {
-      setDeleteError((error instanceof Error ? error.message : null) || 'Delete failed');
-      throw error;
-    } finally {
-      setDeleting(false);
-    }
-  }, [clearErrors, setDeleting, removeAsset, setDeleteError]);
+      try {
+        clearErrors();
+        setDeleting(true);
+
+        await oxyInstance.assets.delete(assetId, { force });
+        removeAsset(assetId);
+      } catch (error: unknown) {
+        setDeleteError((error instanceof Error ? error.message : null) || 'Delete failed');
+        throw error;
+      } finally {
+        setDeleting(false);
+      }
+    },
+    [clearErrors, setDeleting, removeAsset, setDeleteError],
+  );
 
   // Restore asset from trash
-  const restore = useCallback(async (assetId: string): Promise<void> => {
-    if (!oxyInstance) {
-      throw new Error('OxyServices instance not configured. Call setOxyAssetInstance first.');
-    }
+  const restore = useCallback(
+    async (assetId: string): Promise<void> => {
+      if (!oxyInstance) {
+        throw new Error('OxyServices instance not configured. Call setOxyAssetInstance first.');
+      }
       const result = await oxyInstance.assets.restore(assetId);
       if (result.file) {
         mergeAsset(result.file);
       }
-  }, [mergeAsset]);
+    },
+    [mergeAsset],
+  );
 
   // Get variants
   const getVariants = useCallback(async (assetId: string): Promise<AssetVariant[]> => {
     if (!oxyInstance) {
       throw new Error('OxyServices instance not configured. Call setOxyAssetInstance first.');
     }
-      const { file } = await oxyInstance.assets.get(assetId);
-      return file?.variants ?? [];
+    const { file } = await oxyInstance.assets.get(assetId);
+    return file?.variants ?? [];
   }, []);
 
   return {
@@ -241,7 +247,7 @@ export const useAssets = () => {
     uploadProgress,
     loading,
     errors,
-    
+
     // Actions
     upload,
     link,
@@ -251,15 +257,15 @@ export const useAssets = () => {
     deleteAsset,
     restore,
     getVariants,
-    
+
     // Utility methods
     getAssetsByApp,
     getAssetsByEntity,
     getAssetUsageCount,
     isAssetLinked,
-    
+
     // Store management
     clearErrors,
-    reset
+    reset,
   };
-};
+};

package/src/ui/hooks/useAsyncAction.ts

@@ -2,31 +2,31 @@ import { useState, useCallback } from 'react';
 import { toast } from '@oxy.so/bloom/toast';
 
 interface UseAsyncActionOptions<T> {
-    /** Function to execute */
-    action: () => Promise<T>;
-    /** Success message to display */
-    successMessage?: string;
-    /** Error message to display (or function to get message from error) */
-    errorMessage?: string | ((error: unknown) => string);
-    /** Callback on success */
-    onSuccess?: (result: T) => void;
-    /** Callback on error */
-    onError?: (error: unknown) => void;
-    /** Show loading toast */
-    showLoadingToast?: boolean;
-    /** Loading message */
-    loadingMessage?: string;
+  /** Function to execute */
+  action: () => Promise<T>;
+  /** Success message to display */
+  successMessage?: string;
+  /** Error message to display (or function to get message from error) */
+  errorMessage?: string | ((error: unknown) => string);
+  /** Callback on success */
+  onSuccess?: (result: T) => void;
+  /** Callback on error */
+  onError?: (error: unknown) => void;
+  /** Show loading toast */
+  showLoadingToast?: boolean;
+  /** Loading message */
+  loadingMessage?: string;
 }
 
 interface UseAsyncActionReturn<T> {
-    /** Execute the action */
-    execute: () => Promise<T | undefined>;
-    /** Whether the action is currently executing */
-    isLoading: boolean;
-    /** The last error that occurred */
-    error: Error | null;
-    /** Reset the error state */
-    resetError: () => void;
+  /** Execute the action */
+  execute: () => Promise<T | undefined>;
+  /** Whether the action is currently executing */
+  isLoading: boolean;
+  /** The last error that occurred */
+  error: Error | null;
+  /** Reset the error state */
+  resetError: () => void;
 }
 
 /**
@@ -43,57 +43,58 @@ interface UseAsyncActionReturn<T> {
  * <Button onPress={execute} disabled={isLoading}>Save</Button>
  */
 export function useAsyncAction<T = void>(
-    options: UseAsyncActionOptions<T>
+  options: UseAsyncActionOptions<T>,
 ): UseAsyncActionReturn<T> {
-    const [isLoading, setIsLoading] = useState(false);
-    const [error, setError] = useState<Error | null>(null);
-
-    const execute = useCallback(async (): Promise<T | undefined> => {
-        const {
-            action,
-            successMessage,
-            errorMessage,
-            onSuccess,
-            onError,
-            showLoadingToast,
-            loadingMessage,
-        } = options;
-
-        setIsLoading(true);
-        setError(null);
-
-        if (showLoadingToast && loadingMessage) {
-            toast.info(loadingMessage);
-        }
-
-        try {
-            const result = await action();
-
-            if (successMessage) {
-                toast.success(successMessage);
-            }
-
-            onSuccess?.(result);
-            return result;
-        } catch (err: unknown) {
-            const message = typeof errorMessage === 'function'
-                ? errorMessage(err)
-                : errorMessage || (err instanceof Error ? err.message : null) || 'An error occurred';
-
-            toast.error(message);
-            setError(err instanceof Error ? err : new Error(message));
-            onError?.(err);
-            return undefined;
-        } finally {
-            setIsLoading(false);
-        }
-    }, [options]);
-
-    const resetError = useCallback(() => {
-        setError(null);
-    }, []);
-
-    return { execute, isLoading, error, resetError };
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  const execute = useCallback(async (): Promise<T | undefined> => {
+    const {
+      action,
+      successMessage,
+      errorMessage,
+      onSuccess,
+      onError,
+      showLoadingToast,
+      loadingMessage,
+    } = options;
+
+    setIsLoading(true);
+    setError(null);
+
+    if (showLoadingToast && loadingMessage) {
+      toast.info(loadingMessage);
+    }
+
+    try {
+      const result = await action();
+
+      if (successMessage) {
+        toast.success(successMessage);
+      }
+
+      onSuccess?.(result);
+      return result;
+    } catch (err: unknown) {
+      const message =
+        typeof errorMessage === 'function'
+          ? errorMessage(err)
+          : errorMessage || (err instanceof Error ? err.message : null) || 'An error occurred';
+
+      toast.error(message);
+      setError(err instanceof Error ? err : new Error(message));
+      onError?.(err);
+      return undefined;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [options]);
+
+  const resetError = useCallback(() => {
+    setError(null);
+  }, []);
+
+  return { execute, isLoading, error, resetError };
 }
 
 /**
@@ -101,29 +102,29 @@ export function useAsyncAction<T = void>(
  * Useful for one-off actions.
  */
 export async function executeWithToast<T>(
-    action: () => Promise<T>,
-    options?: {
-        successMessage?: string;
-        errorMessage?: string;
-        loadingMessage?: string;
-    }
+  action: () => Promise<T>,
+  options?: {
+    successMessage?: string;
+    errorMessage?: string;
+    loadingMessage?: string;
+  },
 ): Promise<T | undefined> {
-    const { successMessage, errorMessage, loadingMessage } = options || {};
+  const { successMessage, errorMessage, loadingMessage } = options || {};
 
-    if (loadingMessage) {
-        toast.info(loadingMessage);
-    }
+  if (loadingMessage) {
+    toast.info(loadingMessage);
+  }
 
-    try {
-        const result = await action();
-        if (successMessage) {
-            toast.success(successMessage);
-        }
-        return result;
-    } catch (err: unknown) {
-        toast.error(errorMessage || (err instanceof Error ? err.message : null) || 'An error occurred');
-        return undefined;
+  try {
+    const result = await action();
+    if (successMessage) {
+      toast.success(successMessage);
     }
+    return result;
+  } catch (err: unknown) {
+    toast.error(errorMessage || (err instanceof Error ? err.message : null) || 'An error occurred');
+    return undefined;
+  }
 }
 
 export default useAsyncAction;