feat: info, exists and upload with metadat

Vinzent03 · Vinzent03 · commit b0795f32ef3a · 2024-09-04T11:56:20.000+02:00
diff --git a/packages/storage_client/lib/src/fetch.dart b/packages/storage_client/lib/src/fetch.dart
@@ -25,8 +25,12 @@ class Fetch {
     return MediaType.parse(mime ?? 'application/octet-stream');
   }
 
-  StorageException _handleError(dynamic error, StackTrace stack) {
-    if (error is http.Response) {
+  StorageException _handleError(
+    dynamic error,
+    StackTrace stack,
+    FetchOptions? options,
+  ) {
+    if (error is http.Response && !(options?.noResolveJson == true)) {
       try {
         final data = json.decode(error.body) as Map<String, dynamic>;
         return StorageException.fromJson(data, '${error.statusCode}');
@@ -70,7 +74,7 @@ class Fetch {
     return _handleResponse(streamedResponse, options);
   }
 
-  Future<dynamic> _handleMultipartRequest(
+  Future<dynamic> _handleFileRequest(
     String method,
     String url,
     File file,
@@ -79,7 +83,6 @@ class Fetch {
     int retryAttempts,
     StorageRetryController? retryController,
   ) async {
-    final headers = options?.headers ?? {};
     final contentType = fileOptions.contentType != null
         ? MediaType.parse(fileOptions.contentType!)
         : _parseMediaType(file.path);
@@ -89,28 +92,15 @@ class Fetch {
       filename: file.path,
       contentType: contentType,
     );
-    final request = http.MultipartRequest(method, Uri.parse(url))
-      ..headers.addAll(headers)
-      ..files.add(multipartFile)
-      ..fields['cacheControl'] = fileOptions.cacheControl
-      ..headers['x-upsert'] = fileOptions.upsert.toString();
-
-    final http.StreamedResponse streamedResponse;
-    final r = RetryOptions(maxAttempts: (retryAttempts + 1));
-    streamedResponse = await r.retry<http.StreamedResponse>(
-      () async {
-        if (httpClient != null) {
-          return httpClient!.send(request);
-        } else {
-          return request.send();
-        }
-      },
-      retryIf: (error) =>
-          retryController?.cancelled != true &&
-          (error is ClientException || error is TimeoutException),
+    return _handleMultipartRequest(
+      method,
+      url,
+      multipartFile,
+      fileOptions,
+      options,
+      retryAttempts,
+      retryController,
     );
-
-    return _handleResponse(streamedResponse, options);
   }
 
   Future<dynamic> _handleBinaryFileRequest(
@@ -122,7 +112,6 @@ class Fetch {
     int retryAttempts,
     StorageRetryController? retryController,
   ) async {
-    final headers = options?.headers ?? {};
     final contentType = fileOptions.contentType != null
         ? MediaType.parse(fileOptions.contentType!)
         : _parseMediaType(url);
@@ -133,11 +122,38 @@ class Fetch {
       filename: '',
       contentType: contentType,
     );
+    return _handleMultipartRequest(
+      method,
+      url,
+      multipartFile,
+      fileOptions,
+      options,
+      retryAttempts,
+      retryController,
+    );
+  }
+
+  Future<dynamic> _handleMultipartRequest(
+    String method,
+    String url,
+    MultipartFile multipartFile,
+    FileOptions fileOptions,
+    FetchOptions? options,
+    int retryAttempts,
+    StorageRetryController? retryController,
+  ) async {
+    final headers = options?.headers ?? {};
     final request = http.MultipartRequest(method, Uri.parse(url))
       ..headers.addAll(headers)
       ..files.add(multipartFile)
       ..fields['cacheControl'] = fileOptions.cacheControl
       ..headers['x-upsert'] = fileOptions.upsert.toString();
+    if (fileOptions.metadata != null) {
+      request.fields['metadata'] = json.encode(fileOptions.metadata);
+    }
+    if (fileOptions.headers != null) {
+      request.headers.addAll(fileOptions.headers!);
+    }
 
     final http.StreamedResponse streamedResponse;
     final r = RetryOptions(maxAttempts: (retryAttempts + 1));
@@ -170,10 +186,19 @@ class Fetch {
         return jsonBody;
       }
     } else {
-      throw _handleError(response, StackTrace.current);
+      throw _handleError(response, StackTrace.current, options);
     }
   }
 
+  Future<dynamic> head(String url, {FetchOptions? options}) async {
+    return _handleRequest(
+      'HEAD',
+      url,
+      null,
+      FetchOptions(headers: options?.headers, noResolveJson: true),
+    );
+  }
+
   Future<dynamic> get(String url, {FetchOptions? options}) async {
     return _handleRequest('GET', url, null, options);
   }
@@ -210,7 +235,7 @@ class Fetch {
     required int retryAttempts,
     required StorageRetryController? retryController,
   }) async {
-    return _handleMultipartRequest('POST', url, file, fileOptions, options,
+    return _handleFileRequest('POST', url, file, fileOptions, options,
         retryAttempts, retryController);
   }
 
@@ -222,7 +247,7 @@ class Fetch {
     required int retryAttempts,
     required StorageRetryController? retryController,
   }) async {
-    return _handleMultipartRequest(
+    return _handleFileRequest(
       'PUT',
       url,
       file,
diff --git a/packages/storage_client/lib/src/storage_file_api.dart b/packages/storage_client/lib/src/storage_file_api.dart
@@ -397,6 +397,29 @@ class StorageFileApi {
     return response as Uint8List;
   }
 
+  /// Retrieves the details of an existing file
+  Future<FileObjectV2> info(String path) async {
+    final finalPath = _getFinalPath(path);
+    final options = FetchOptions(headers: headers);
+    final response = await _storageFetch.get(
+      '$url/object/info/$finalPath',
+      options: options,
+    );
+    final fileObjects = FileObjectV2.fromJson(response);
+    return fileObjects;
+  }
+
+  /// Checks the existence of a file
+  Future<bool> exists(String path) async {
+    final finalPath = _getFinalPath(path);
+    final options = FetchOptions(headers: headers);
+    final response = await _storageFetch.head(
+      '$url/object/$finalPath',
+      options: options,
+    );
+    return true;
+  }
+
   /// Retrieve URLs for assets in public buckets
   ///
   /// [path] is the file path to be downloaded, including the current file name.
@@ -458,6 +481,7 @@ class StorageFileApi {
       body,
       options: options,
     );
+    print(response[0]);
     final fileObjects = List<FileObject>.from(
       (response as List).map(
         (item) => FileObject.fromJson(item),
diff --git a/packages/storage_client/lib/src/types.dart b/packages/storage_client/lib/src/types.dart
@@ -75,6 +75,53 @@ class FileObject {
             json['buckets'] != null ? Bucket.fromJson(json['buckets']) : null;
 }
 
+class FileObjectV2 {
+  final String id;
+  final String version;
+  final String name;
+  final String? bucketId;
+  final String? updatedAt;
+  final String createdAt;
+  final String? lastAccessedAt;
+  final int? size;
+  final String? cacheControl;
+  final String? contentType;
+  final String? etag;
+  final String? lastModified;
+  final Map<String, dynamic>? metadata;
+
+  const FileObjectV2({
+    required this.id,
+    required this.version,
+    required this.name,
+    required this.bucketId,
+    required this.updatedAt,
+    required this.createdAt,
+    required this.lastAccessedAt,
+    required this.size,
+    required this.cacheControl,
+    required this.contentType,
+    required this.etag,
+    required this.lastModified,
+    required this.metadata,
+  });
+
+  FileObjectV2.fromJson(Map<String, dynamic> json)
+      : id = json['id'] as String,
+        version = json['version'] as String,
+        name = json['name'] as String,
+        bucketId = json['bucket_id'] as String?,
+        updatedAt = json['updated_at'] as String?,
+        createdAt = json['created_at'] as String,
+        lastAccessedAt = json['last_accessed_at'] as String?,
+        size = json['size'] as int?,
+        cacheControl = json['cache_control'] as String?,
+        contentType = json['content_type'] as String?,
+        etag = json['etag'] as String?,
+        lastModified = json['last_modified'] as String?,
+        metadata = json['metadata'] as Map<String, dynamic>?;
+}
+
 /// [public] The visibility of the bucket. Public buckets don't require an
 /// authorization token to download objects, but still require a valid token for
 /// all other operations. By default, buckets are private.
@@ -115,10 +162,20 @@ class FileOptions {
   /// Throws a FormatError if the media type is invalid.
   final String? contentType;
 
+  /// The metadata option is an object that allows you to store additional
+  /// information about the file. This information can be used to filter and
+  /// search for files.
+  final Map<String, dynamic>? metadata;
+
+  /// Optionally add extra headers.
+  final Map<String, String>? headers;
+
   const FileOptions({
     this.cacheControl = '3600',
     this.upsert = false,
     this.contentType,
+    this.metadata,
+    this.headers,
   });
 }
 
diff --git a/packages/storage_client/test/basic_test.dart b/packages/storage_client/test/basic_test.dart
@@ -36,7 +36,7 @@ void main() {
   late SupabaseStorageClient client;
   late CustomHttpClient customHttpClient = CustomHttpClient();
 
-  group('Client with default http client', () {
+  group('Client with custom http client', () {
     setUp(() {
       // init SupabaseClient with test url & test key
       client = SupabaseStorageClient(
diff --git a/packages/storage_client/test/client_test.dart b/packages/storage_client/test/client_test.dart
@@ -389,4 +389,32 @@ void main() {
       await storage.from(newBucketName).copy(uploadPath, "$uploadPath 2");
     });
   });
+
+  test('upload with custom metadata', () async {
+    final metadata = {
+      'custom': 'metadata',
+      'second': 'second',
+      'third': 'third',
+    };
+    final path = "$uploadPath-metadata";
+    await storage.from(newBucketName).upload(
+          path,
+          file,
+          fileOptions: FileOptions(
+            metadata: metadata,
+          ),
+        );
+
+    final updateRes = await storage.from(newBucketName).info(path);
+    expect(updateRes.metadata, metadata);
+  });
+
+  test('check if object exists', () async {
+    await storage.from(newBucketName).upload(uploadPath, file);
+    final res = await storage.from(newBucketName).exists(uploadPath);
+    expect(res, true);
+
+    final res2 = await storage.from(newBucketName).exists('not-exist');
+    expect(res2, false);
+  });
 }
