@umituz/react-native-filesystem 1.0.0 → 1.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-filesystem",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "Domain-Driven Design filesystem utilities for React Native apps with build-time module loading and runtime file operations",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/domain/entities/File.ts

@@ -131,4 +131,92 @@ export class FileUtils {
       .join('/')
       .replace(/\/+/g, '/');
   }
+
+  /**
+   * Get filename from filepath
+   */
+  static getFileName(filepath: string): string {
+    return filepath.split('/').pop() || '';
+  }
+
+  /**
+   * Get MIME type from filename
+   */
+  static getMimeType(filename: string): string {
+    const ext = this.getFileExtension(filename).toLowerCase().replace('.', '');
+    
+    const mimeTypes: Record<string, string> = {
+      // Images
+      jpg: 'image/jpeg',
+      jpeg: 'image/jpeg',
+      png: 'image/png',
+      gif: 'image/gif',
+      webp: 'image/webp',
+      svg: 'image/svg+xml',
+      
+      // Documents
+      pdf: 'application/pdf',
+      doc: 'application/msword',
+      docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+      xls: 'application/vnd.ms-excel',
+      xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+      
+      // Text
+      txt: 'text/plain',
+      csv: 'text/csv',
+      json: 'application/json',
+      
+      // Video
+      mp4: 'video/mp4',
+      mov: 'video/quicktime',
+      avi: 'video/x-msvideo',
+      mkv: 'video/x-matroska',
+      webm: 'video/webm',
+      
+      // Audio
+      mp3: 'audio/mpeg',
+      wav: 'audio/wav',
+      m4a: 'audio/mp4',
+      ogg: 'audio/ogg',
+      flac: 'audio/flac',
+    };
+    
+    return mimeTypes[ext] || 'application/octet-stream';
+  }
+
+  /**
+   * Check if file is an image
+   */
+  static isImageFile(filename: string): boolean {
+    const ext = this.getFileExtension(filename).toLowerCase().replace('.', '');
+    return ['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg'].includes(ext);
+  }
+
+  /**
+   * Check if file is a video
+   */
+  static isVideoFile(filename: string): boolean {
+    const ext = this.getFileExtension(filename).toLowerCase().replace('.', '');
+    return ['mp4', 'mov', 'avi', 'mkv', 'webm'].includes(ext);
+  }
+
+  /**
+   * Check if file is an audio file
+   */
+  static isAudioFile(filename: string): boolean {
+    const ext = this.getFileExtension(filename).toLowerCase().replace('.', '');
+    return ['mp3', 'wav', 'm4a', 'ogg', 'flac'].includes(ext);
+  }
+
+  /**
+   * Generate filename with prefix (alternative to generateUniqueFilename)
+   */
+  static generateFileName(originalName: string, prefix?: string): string {
+    const timestamp = Date.now();
+    const random = Math.random().toString(36).substring(2, 9);
+    const ext = this.getFileExtension(originalName);
+    const baseName = prefix ? `${prefix}_` : '';
+
+    return `${baseName}${timestamp}_${random}${ext}`;
+  }
 }

package/src/infrastructure/services/FileSystemService.ts

@@ -1,265 +1,160 @@
 /**
- * Filesystem Domain - FileSystem Service
- *
- * Service for runtime file operations using expo-file-system.
- * Provides abstraction layer for file read/write/delete operations on device.
- *
- * @domain filesystem
- * @layer infrastructure/services
+ * FileSystem Service
+ * Single Responsibility: Facade for all file system operations
+ * 
+ * This is a facade that delegates to specialized services
+ * following Single Responsibility Principle
  */
 
-import * as FileSystem from 'expo-file-system';
-import type { FileInfo, FileOperationResult, DirectoryType, FileEncoding } from '../../domain/entities/File';
-import { FileUtils } from '../../domain/entities/File';
+import { readFile, readFileAsBase64 } from "./file-reader.service";
+import { writeFile } from "./file-writer.service";
+import { deleteFile, copyFile, moveFile } from "./file-manager.service";
+import {
+  createDirectory,
+  listDirectory,
+  getDirectoryPath,
+  getDocumentDirectory,
+  getCacheDirectory,
+} from "./directory.service";
+import { getFileInfo, fileExists, getFileSize } from "./file-info.service";
+import { downloadFile } from "./download.service";
+import { clearCache, getDirectorySize } from "./cache.service";
+import { generateFilePath } from "./file-path.service";
+import type {
+  FileInfo,
+  FileOperationResult,
+  DirectoryType,
+  FileEncoding,
+} from "../../domain/entities/File";
+import { copyFile as copyFileOp } from "./file-manager.service";
+import { FileUtils } from "../../domain/entities/File";
 
 /**
- * FileSystem service for device file operations
- *
- * CENTRAL PLACE FOR ALL FILE OPERATIONS
- * - Reading/writing files
- * - Directory management
- * - File downloads
- * - Cache management
- *
- * Used by other domains (media, etc.) for file operations
+ * FileSystem Service - Facade for all file operations
+ * Delegates to specialized services following SOLID principles
  */
 export class FileSystemService {
-  /**
-   * Get file information
-   */
-  static async getFileInfo(uri: string): Promise<FileInfo | null> {
-    try {
-      const info = await FileSystem.getInfoAsync(uri);
-
-      if (!info.exists) {
-        return null;
-      }
-
-      return {
-        uri,
-        name: uri.split('/').pop() || '',
-        size: info.size || 0,
-        exists: info.exists,
-        isDirectory: info.isDirectory || false,
-        modificationTime: info.modificationTime || 0,
-      };
-    } catch (error) {
-      return null;
-    }
+  // File Reading
+  static async readFile(
+    uri: string,
+    encoding: FileEncoding = "utf8",
+  ): Promise<string | null> {
+    return readFile(uri, encoding);
   }
 
-  /**
-   * Read file as string
-   */
-  static async readFile(uri: string, encoding: FileEncoding = 'utf8'): Promise<string | null> {
-    try {
-      const content = await FileSystem.readAsStringAsync(uri, { encoding });
-      return content;
-    } catch (error) {
-      return null;
-    }
+  static async readFileAsBase64(uri: string): Promise<string | null> {
+    return readFileAsBase64(uri);
   }
 
-  /**
-   * Write string to file
-   */
-  static async writeFile(uri: string, content: string, encoding: FileEncoding = 'utf8'): Promise<FileOperationResult> {
-    try {
-      await FileSystem.writeAsStringAsync(uri, content, { encoding });
-      return { success: true, uri };
-    } catch (error) {
-      return { success: false, error: error instanceof Error ? error.message : 'Unknown error' };
-    }
+  // File Writing
+  static async writeFile(
+    uri: string,
+    content: string,
+    encoding: FileEncoding = "utf8",
+  ): Promise<FileOperationResult> {
+    return writeFile(uri, content, encoding);
   }
 
-  /**
-   * Delete file or directory
-   */
+  // File Management
   static async deleteFile(uri: string): Promise<boolean> {
-    try {
-      await FileSystem.deleteAsync(uri, { idempotent: true });
-      return true;
-    } catch (error) {
-      return false;
-    }
+    return deleteFile(uri);
   }
 
-  /**
-   * Copy file
-   */
-  static async copyFile(sourceUri: string, destinationUri: string): Promise<FileOperationResult> {
-    try {
-      await FileSystem.copyAsync({
-        from: sourceUri,
-        to: destinationUri,
-      });
-      return { success: true, uri: destinationUri };
-    } catch (error) {
-      return { success: false, error: error instanceof Error ? error.message : 'Unknown error' };
-    }
+  static async copyFile(
+    sourceUri: string,
+    destinationUri: string,
+  ): Promise<FileOperationResult> {
+    return copyFileOp(sourceUri, destinationUri);
   }
 
-  /**
-   * Move file
-   */
-  static async moveFile(sourceUri: string, destinationUri: string): Promise<FileOperationResult> {
-    try {
-      await FileSystem.moveAsync({
-        from: sourceUri,
-        to: destinationUri,
-      });
-      return { success: true, uri: destinationUri };
-    } catch (error) {
-      return { success: false, error: error instanceof Error ? error.message : 'Unknown error' };
-    }
+  static async moveFile(
+    sourceUri: string,
+    destinationUri: string,
+  ): Promise<FileOperationResult> {
+    return moveFile(sourceUri, destinationUri);
   }
 
-  /**
-   * Create directory
-   */
+  // Directory Operations
   static async createDirectory(uri: string): Promise<boolean> {
-    try {
-      await FileSystem.makeDirectoryAsync(uri, { intermediates: true });
-      return true;
-    } catch (error) {
-      return false;
-    }
+    return createDirectory(uri);
   }
 
-  /**
-   * List directory contents
-   */
   static async listDirectory(uri: string): Promise<string[]> {
-    try {
-      const files = await FileSystem.readDirectoryAsync(uri);
-      return files;
-    } catch (error) {
-      return [];
-    }
-  }
-
-  /**
-   * Check if file exists
-   */
-  static async exists(uri: string): Promise<boolean> {
-    try {
-      const info = await FileSystem.getInfoAsync(uri);
-      return info.exists;
-    } catch (error) {
-      return false;
-    }
+    return listDirectory(uri);
   }
 
-  /**
-   * Get directory path by type
-   */
   static getDirectoryPath(type: DirectoryType): string {
-    switch (type) {
-      case 'documentDirectory':
-        return FileSystem.documentDirectory || '';
-      case 'cacheDirectory':
-        return FileSystem.cacheDirectory || '';
-      default:
-        return '';
-    }
+    return getDirectoryPath(type);
   }
 
-  /**
-   * Get document directory path
-   */
   static getDocumentDirectory(): string {
-    return FileSystemService.getDirectoryPath('documentDirectory');
+    return getDocumentDirectory();
   }
 
-  /**
-   * Get cache directory path
-   */
   static getCacheDirectory(): string {
-    return FileSystemService.getDirectoryPath('cacheDirectory');
+    return getCacheDirectory();
   }
 
-  /**
-   * Generate unique file path in specified directory
-   */
-  static generateFilePath(filename: string, directory: DirectoryType = 'documentDirectory'): string {
-    const dirPath = FileSystemService.getDirectoryPath(directory);
-    const uniqueFilename = FileUtils.generateUniqueFilename(filename);
-    return FileUtils.joinPaths(dirPath, uniqueFilename);
+  // File Information
+  static async getFileInfo(uri: string): Promise<FileInfo | null> {
+    return getFileInfo(uri);
   }
 
-  /**
-   * Download file from URL
-   */
-  static async downloadFile(url: string, destinationUri?: string): Promise<FileOperationResult> {
-    try {
-      const destination = destinationUri || FileSystemService.generateFilePath('download');
-      const result = await FileSystem.downloadAsync(url, destination);
-      return { success: true, uri: result.uri };
-    } catch (error) {
-      return { success: false, error: error instanceof Error ? error.message : 'Download failed' };
-    }
+  static async exists(uri: string): Promise<boolean> {
+    return fileExists(uri);
   }
 
-  /**
-   * Get file size
-   */
   static async getFileSize(uri: string): Promise<number> {
-    const info = await FileSystemService.getFileInfo(uri);
-    return info?.size || 0;
+    return getFileSize(uri);
   }
 
-  /**
-   * Clear cache directory
-   */
-  static async clearCache(): Promise<boolean> {
-    try {
-      const cacheDir = FileSystemService.getCacheDirectory();
-      if (!cacheDir) return false;
-
-      const files = await FileSystemService.listDirectory(cacheDir);
-      await Promise.all(
-        files.map(file => FileSystemService.deleteFile(FileUtils.joinPaths(cacheDir, file)))
-      );
-      return true;
-    } catch (error) {
-      return false;
-    }
+  // Downloads
+  static async downloadFile(
+    url: string,
+    destinationUri?: string,
+  ): Promise<FileOperationResult> {
+    return downloadFile(url, destinationUri);
   }
 
-  /**
-   * Get total size of directory
-   */
-  static async getDirectorySize(uri: string): Promise<number> {
-    try {
-      const files = await FileSystemService.listDirectory(uri);
-      const sizes = await Promise.all(
-        files.map(async file => {
-          const filePath = FileUtils.joinPaths(uri, file);
-          const info = await FileSystemService.getFileInfo(filePath);
-          return info?.size || 0;
-        })
-      );
-      return sizes.reduce((total, size) => total + size, 0);
-    } catch (error) {
-      return 0;
-    }
-  }
-
-  /**
-   * Copy file to cache directory
-   */
-  static async copyToCache(sourceUri: string, filename?: string): Promise<FileOperationResult> {
-    const name = filename || sourceUri.split('/').pop() || 'file';
-    const destinationUri = FileSystemService.generateFilePath(name, 'cacheDirectory');
-    return FileSystemService.copyFile(sourceUri, destinationUri);
+  // Cache Management
+  static async clearCache(): Promise<boolean> {
+    return clearCache();
   }
 
-  /**
-   * Copy file to document directory
-   */
-  static async copyToDocuments(sourceUri: string, filename?: string): Promise<FileOperationResult> {
-    const name = filename || sourceUri.split('/').pop() || 'file';
-    const destinationUri = FileSystemService.generateFilePath(name, 'documentDirectory');
-    return FileSystemService.copyFile(sourceUri, destinationUri);
+  static async getDirectorySize(uri: string): Promise<number> {
+    return getDirectorySize(uri);
+  }
+
+  // File Path Generation
+  static generateFilePath(
+    filename: string,
+    directory: DirectoryType = "documentDirectory",
+  ): string {
+    return generateFilePath(filename, directory);
+  }
+
+  // Convenience methods (delegates to other services)
+  static async copyToCache(
+    sourceUri: string,
+    filename?: string,
+  ): Promise<FileOperationResult> {
+    const name = filename || sourceUri.split("/").pop() || "file";
+    const destinationUri = FileUtils.joinPaths(
+      getDirectoryPath("cacheDirectory"),
+      FileUtils.generateUniqueFilename(name),
+    );
+    return copyFileOp(sourceUri, destinationUri);
+  }
+
+  static async copyToDocuments(
+    sourceUri: string,
+    filename?: string,
+  ): Promise<FileOperationResult> {
+    const name = filename || sourceUri.split("/").pop() || "file";
+    const destinationUri = FileUtils.joinPaths(
+      getDirectoryPath("documentDirectory"),
+      FileUtils.generateUniqueFilename(name),
+    );
+    return copyFileOp(sourceUri, destinationUri);
   }
 }

package/src/infrastructure/services/cache.service.ts

@@ -0,0 +1,47 @@
+/**
+ * Cache Service
+ * Single Responsibility: Manage cache directory operations
+ */
+
+import { getCacheDirectory, listDirectory } from "./directory.service";
+import { deleteFile } from "./file-manager.service";
+import { getFileInfo } from "./file-info.service";
+import { FileUtils } from "../../domain/entities/File";
+
+/**
+ * Clear cache directory
+ */
+export async function clearCache(): Promise<boolean> {
+  try {
+    const cacheDir = getCacheDirectory();
+    if (!cacheDir) return false;
+
+    const files = await listDirectory(cacheDir);
+    await Promise.all(
+      files.map((file) => deleteFile(FileUtils.joinPaths(cacheDir, file))),
+    );
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+/**
+ * Get total size of directory
+ */
+export async function getDirectorySize(uri: string): Promise<number> {
+  try {
+    const files = await listDirectory(uri);
+    const sizes = await Promise.all(
+      files.map(async (file) => {
+        const filePath = FileUtils.joinPaths(uri, file);
+        const info = await getFileInfo(filePath);
+        return info?.size || 0;
+      }),
+    );
+    return sizes.reduce((total, size) => total + size, 0);
+  } catch (error) {
+    return 0;
+  }
+}
+

package/src/infrastructure/services/directory.service.ts

@@ -0,0 +1,60 @@
+/**
+ * Directory Service
+ * Single Responsibility: Manage directory operations
+ */
+
+import * as FileSystem from "expo-file-system";
+import type { DirectoryType } from "../../domain/entities/File";
+
+/**
+ * Create directory
+ */
+export async function createDirectory(uri: string): Promise<boolean> {
+  try {
+    await FileSystem.makeDirectoryAsync(uri, { intermediates: true });
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+/**
+ * List directory contents
+ */
+export async function listDirectory(uri: string): Promise<string[]> {
+  try {
+    const files = await FileSystem.readDirectoryAsync(uri);
+    return files;
+  } catch (error) {
+    return [];
+  }
+}
+
+/**
+ * Get directory path by type
+ */
+export function getDirectoryPath(type: DirectoryType): string {
+  switch (type) {
+    case "documentDirectory":
+      return FileSystem.documentDirectory || "";
+    case "cacheDirectory":
+      return FileSystem.cacheDirectory || "";
+    default:
+      return "";
+  }
+}
+
+/**
+ * Get document directory path
+ */
+export function getDocumentDirectory(): string {
+  return getDirectoryPath("documentDirectory");
+}
+
+/**
+ * Get cache directory path
+ */
+export function getCacheDirectory(): string {
+  return getDirectoryPath("cacheDirectory");
+}
+

package/src/infrastructure/services/download.service.ts

@@ -0,0 +1,35 @@
+/**
+ * Download Service
+ * Single Responsibility: Download files from URLs
+ */
+
+import * as FileSystem from "expo-file-system";
+import type { FileOperationResult } from "../../domain/entities/File";
+import { getDirectoryPath } from "./directory.service";
+import { FileUtils } from "../../domain/entities/File";
+
+/**
+ * Download file from URL
+ */
+export async function downloadFile(
+  url: string,
+  destinationUri?: string,
+): Promise<FileOperationResult> {
+  try {
+    const destination =
+      destinationUri ||
+      FileUtils.joinPaths(
+        getDirectoryPath("documentDirectory"),
+        FileUtils.generateUniqueFilename("download"),
+      );
+
+    const result = await FileSystem.downloadAsync(url, destination);
+    return { success: true, uri: result.uri };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Download failed",
+    };
+  }
+}
+

package/src/infrastructure/services/file-info.service.ts

@@ -0,0 +1,52 @@
+/**
+ * File Info Service
+ * Single Responsibility: Get file information and metadata
+ */
+
+import * as FileSystem from "expo-file-system";
+import type { FileInfo } from "../../domain/entities/File";
+
+/**
+ * Get file information
+ */
+export async function getFileInfo(uri: string): Promise<FileInfo | null> {
+  try {
+    const info = await FileSystem.getInfoAsync(uri);
+
+    if (!info.exists) {
+      return null;
+    }
+
+    return {
+      uri,
+      name: uri.split("/").pop() || "",
+      size: info.size || 0,
+      exists: info.exists,
+      isDirectory: info.isDirectory || false,
+      modificationTime: info.modificationTime || 0,
+    };
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Check if file exists
+ */
+export async function fileExists(uri: string): Promise<boolean> {
+  try {
+    const info = await FileSystem.getInfoAsync(uri);
+    return info.exists;
+  } catch (error) {
+    return false;
+  }
+}
+
+/**
+ * Get file size
+ */
+export async function getFileSize(uri: string): Promise<number> {
+  const info = await getFileInfo(uri);
+  return info?.size || 0;
+}
+

package/src/infrastructure/services/file-manager.service.ts

@@ -0,0 +1,62 @@
+/**
+ * File Manager Service
+ * Single Responsibility: Manage file operations (delete, copy, move)
+ */
+
+import * as FileSystem from "expo-file-system";
+import type { FileOperationResult } from "../../domain/entities/File";
+
+/**
+ * Delete file or directory
+ */
+export async function deleteFile(uri: string): Promise<boolean> {
+  try {
+    await FileSystem.deleteAsync(uri, { idempotent: true });
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+/**
+ * Copy file
+ */
+export async function copyFile(
+  sourceUri: string,
+  destinationUri: string,
+): Promise<FileOperationResult> {
+  try {
+    await FileSystem.copyAsync({
+      from: sourceUri,
+      to: destinationUri,
+    });
+    return { success: true, uri: destinationUri };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown error",
+    };
+  }
+}
+
+/**
+ * Move file
+ */
+export async function moveFile(
+  sourceUri: string,
+  destinationUri: string,
+): Promise<FileOperationResult> {
+  try {
+    await FileSystem.moveAsync({
+      from: sourceUri,
+      to: destinationUri,
+    });
+    return { success: true, uri: destinationUri };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown error",
+    };
+  }
+}
+

package/src/infrastructure/services/file-path.service.ts

@@ -0,0 +1,22 @@
+/**
+ * File Path Service
+ * Single Responsibility: Generate and manage file paths
+ */
+
+import type { DirectoryType } from "../../domain/entities/File";
+import { getDirectoryPath } from "./directory.service";
+import { FileUtils } from "../../domain/entities/File";
+
+/**
+ * Generate unique file path in specified directory
+ */
+export function generateFilePath(
+  filename: string,
+  directory: DirectoryType = "documentDirectory",
+): string {
+  const dirPath = getDirectoryPath(directory);
+  const uniqueFilename = FileUtils.generateUniqueFilename(filename);
+  return FileUtils.joinPaths(dirPath, uniqueFilename);
+}
+
+

package/src/infrastructure/services/file-reader.service.ts

@@ -0,0 +1,38 @@
+/**
+ * File Reader Service
+ * Single Responsibility: Read files from device storage
+ */
+
+import * as FileSystem from "expo-file-system";
+import type { FileEncoding } from "../../domain/entities/File";
+
+/**
+ * Read file as string with encoding
+ */
+export async function readFile(
+  uri: string,
+  encoding: FileEncoding = "utf8",
+): Promise<string | null> {
+  try {
+    const encodingType =
+      encoding === "base64"
+        ? FileSystem.EncodingType.Base64
+        : FileSystem.EncodingType.UTF8;
+
+    const content = await FileSystem.readAsStringAsync(uri, {
+      encoding: encodingType,
+    });
+    return content;
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Read file as base64 string
+ */
+export async function readFileAsBase64(uri: string): Promise<string | null> {
+  return readFile(uri, "base64");
+}
+
+

package/src/infrastructure/services/file-writer.service.ts

@@ -0,0 +1,32 @@
+/**
+ * File Writer Service
+ * Single Responsibility: Write files to device storage
+ */
+
+import * as FileSystem from "expo-file-system";
+import type { FileEncoding, FileOperationResult } from "../../domain/entities/File";
+
+/**
+ * Write string to file
+ */
+export async function writeFile(
+  uri: string,
+  content: string,
+  encoding: FileEncoding = "utf8",
+): Promise<FileOperationResult> {
+  try {
+    const encodingType =
+      encoding === "base64"
+        ? FileSystem.EncodingType.Base64
+        : FileSystem.EncodingType.UTF8;
+
+    await FileSystem.writeAsStringAsync(uri, content, { encoding: encodingType });
+    return { success: true, uri };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown error",
+    };
+  }
+}
+