@scality/data-browser-library 1.0.0-preview.11

package/dist/hooks/factories/useCreateS3LoginHook.js

@@ -0,0 +1,22 @@
+import { useMutation } from "@tanstack/react-query";
+import { ListBucketsCommand } from "@aws-sdk/client-s3";
+import { createS3OperationError } from "../../utils/errorHandling.js";
+import { createS3Client } from "../../utils/s3Client.js";
+function useCreateS3LoginHook(_Command, operationName) {
+    return (options)=>useMutation({
+            mutationFn: async (params)=>{
+                try {
+                    const loginS3Client = createS3Client(params);
+                    await loginS3Client.send(new ListBucketsCommand({}));
+                    return {
+                        config: params,
+                        authenticated: true
+                    };
+                } catch (error) {
+                    throw createS3OperationError(error, operationName);
+                }
+            },
+            ...options
+        });
+}
+export { useCreateS3LoginHook };

package/dist/hooks/factories/useCreateS3MutationHook.d.ts

@@ -0,0 +1,5 @@
+import { UseMutationOptions, UseMutationResult } from "@tanstack/react-query";
+import { EnhancedS3Error } from "../../utils/errorHandling";
+import { S3Client } from "@aws-sdk/client-s3";
+export declare function useCreateS3MutationHook<TInput extends object, TOutput>(Command: new (input: TInput) => any, operationName: string, invalidationKeys?: string[]): (options?: Omit<UseMutationOptions<TOutput, EnhancedS3Error, TInput>, "mutationFn">) => UseMutationResult<TOutput, EnhancedS3Error, TInput>;
+export declare function useCreateS3FunctionMutationHook<TInput, TOutput>(operation: (s3Client: S3Client, input: TInput) => Promise<TOutput>, invalidationKeys?: string[]): (options?: Omit<UseMutationOptions<TOutput, EnhancedS3Error, TInput>, "mutationFn">) => UseMutationResult<TOutput, EnhancedS3Error, TInput>;

package/dist/hooks/factories/useCreateS3MutationHook.js

@@ -0,0 +1,50 @@
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { useS3Client } from "../useS3Client.js";
+import { createS3OperationError } from "../../utils/errorHandling.js";
+function useCreateS3MutationHook(Command, operationName, invalidationKeys) {
+    return (options)=>{
+        const s3Client = useS3Client();
+        const queryClient = useQueryClient();
+        return useMutation({
+            mutationFn: async (params)=>{
+                try {
+                    const command = new Command(params);
+                    return await s3Client.send(command);
+                } catch (error) {
+                    const bucketName = "Bucket" in params ? params.Bucket : void 0;
+                    throw createS3OperationError(error, operationName, bucketName);
+                }
+            },
+            onSuccess: (_data, _variables)=>{
+                if (invalidationKeys) invalidationKeys.forEach((key)=>{
+                    queryClient.invalidateQueries({
+                        queryKey: [
+                            key
+                        ]
+                    });
+                });
+            },
+            ...options
+        });
+    };
+}
+function useCreateS3FunctionMutationHook(operation, invalidationKeys) {
+    return (options)=>{
+        const s3Client = useS3Client();
+        const queryClient = useQueryClient();
+        return useMutation({
+            mutationFn: async (params)=>operation(s3Client, params),
+            onSuccess: (_data, _variables)=>{
+                if (invalidationKeys) invalidationKeys.forEach((key)=>{
+                    queryClient.invalidateQueries({
+                        queryKey: [
+                            key
+                        ]
+                    });
+                });
+            },
+            ...options
+        });
+    };
+}
+export { useCreateS3FunctionMutationHook, useCreateS3MutationHook };

package/dist/hooks/factories/useCreateS3QueryHook.d.ts

@@ -0,0 +1,3 @@
+import { QueryKey, UseQueryOptions, UseQueryResult } from "@tanstack/react-query";
+import { EnhancedS3Error } from "../../utils/errorHandling";
+export declare function useCreateS3QueryHook<TInput extends object, TOutput>(Command: new (input: TInput) => any, operationName: string): (params?: TInput, options?: Omit<UseQueryOptions<TOutput, EnhancedS3Error, TOutput, QueryKey>, "queryKey" | "queryFn">) => UseQueryResult<TOutput, EnhancedS3Error>;

package/dist/hooks/factories/useCreateS3QueryHook.js

@@ -0,0 +1,51 @@
+import { useQuery } from "@tanstack/react-query";
+import { useS3Client } from "../useS3Client.js";
+import { createS3OperationError, isNotFoundError, shouldRetryError } from "../../utils/errorHandling.js";
+function getEmptyConfigForOperation(operationName) {
+    switch(operationName){
+        case "GetBucketLifecycleConfiguration":
+            return {
+                Rules: []
+            };
+        case "GetBucketReplication":
+            return {
+                ReplicationConfiguration: {
+                    Rules: [],
+                    Role: ""
+                }
+            };
+        default:
+            return null;
+    }
+}
+function useCreateS3QueryHook(Command, operationName) {
+    return (params, options)=>{
+        const queryKey = [
+            operationName,
+            params
+        ];
+        const s3Client = useS3Client();
+        return useQuery({
+            queryKey,
+            queryFn: async ({ signal })=>{
+                try {
+                    const command = new Command(params || {});
+                    return await s3Client.send(command, {
+                        abortSignal: signal
+                    });
+                } catch (error) {
+                    const bucketName = params && "Bucket" in params ? params.Bucket : void 0;
+                    if (isNotFoundError(error)) {
+                        const emptyConfig = getEmptyConfigForOperation(operationName);
+                        if (null !== emptyConfig) return emptyConfig;
+                    }
+                    throw createS3OperationError(error, operationName, bucketName);
+                }
+            },
+            retry: options?.retry ?? ((failureCount, error)=>shouldRetryError(error, failureCount)),
+            enabled: params ? Object.values(params).every((p)=>void 0 !== p) : true,
+            ...options
+        });
+    };
+}
+export { useCreateS3QueryHook };

package/dist/hooks/index.d.ts

@@ -0,0 +1,13 @@
+export { useS3Client } from "./useS3Client";
+export type { LoginConfig, LoginMutationResult } from "./useLoginMutation";
+export { useLoginMutation } from "./loginOperations";
+export { useIsBucketEmpty } from "./useIsBucketEmpty";
+export { useEmptyBucket } from "./useEmptyBucket";
+export { useDeleteBucketConfigRule } from "./useDeleteBucketConfigRule";
+export { useTableRowSelection } from "./useTableRowSelection";
+export { useISVBucketStatus } from "./useISVBucketDetection";
+export { useBatchObjectLegalHold } from "./useBatchObjectLegalHold";
+export { useBuckets, useGetBucketLocation, useCreateBucket, useDeleteBucket, } from "./bucketOperations";
+export { useGetBucketAcl, useSetBucketAcl, useGetBucketPolicy, useSetBucketPolicy, useDeleteBucketPolicy, useGetBucketVersioning, useSetBucketVersioning, useGetBucketCors, useSetBucketCors, useDeleteBucketCors, useGetBucketLifecycle, useSetBucketLifecycle, useDeleteBucketLifecycle, useGetBucketNotification, useSetBucketNotification, useGetBucketEncryption, useSetBucketEncryption, useGetBucketTagging, useSetBucketTagging, useDeleteBucketTagging, useGetBucketObjectLockConfiguration, useSetBucketObjectLockConfiguration, useGetBucketReplication, useSetBucketReplication, useDeleteBucketReplication, } from "./bucketConfiguration";
+export { useListObjects, useListObjectVersions, useObjectMetadata, useObjectRetention, useGetObject, usePutObject, useCreateFolder, useUploadObjects, useDeleteObject, useDeleteObjects, useCopyObject, useSetObjectRetention, useObjectLegalHold, useSetObjectLegalHold, useObjectTagging, useSetObjectTagging, useDeleteObjectTagging, useObjectAcl, useSetObjectAcl, useGetObjectAttributes, useGetObjectTorrent, useRestoreObject, useSelectObjectContent, useListMultipartUploads, useSearchObjects, useSearchObjectsVersions, } from "./objectOperations";
+export { useGetPresignedDownload, useGetPresignedUpload, useGetPresignedPost, } from "./presignedOperations";

package/dist/hooks/index.js

@@ -0,0 +1,13 @@
+import { useS3Client } from "./useS3Client.js";
+import { useLoginMutation } from "./loginOperations.js";
+import { useIsBucketEmpty } from "./useIsBucketEmpty.js";
+import { useEmptyBucket } from "./useEmptyBucket.js";
+import { useDeleteBucketConfigRule } from "./useDeleteBucketConfigRule.js";
+import { useTableRowSelection } from "./useTableRowSelection.js";
+import { useISVBucketStatus } from "./useISVBucketDetection.js";
+import { useBatchObjectLegalHold } from "./useBatchObjectLegalHold.js";
+import { useBuckets, useCreateBucket, useDeleteBucket, useGetBucketLocation } from "./bucketOperations.js";
+import { useDeleteBucketCors, useDeleteBucketLifecycle, useDeleteBucketPolicy, useDeleteBucketReplication, useDeleteBucketTagging, useGetBucketAcl, useGetBucketCors, useGetBucketEncryption, useGetBucketLifecycle, useGetBucketNotification, useGetBucketObjectLockConfiguration, useGetBucketPolicy, useGetBucketReplication, useGetBucketTagging, useGetBucketVersioning, useSetBucketAcl, useSetBucketCors, useSetBucketEncryption, useSetBucketLifecycle, useSetBucketNotification, useSetBucketObjectLockConfiguration, useSetBucketPolicy, useSetBucketReplication, useSetBucketTagging, useSetBucketVersioning } from "./bucketConfiguration.js";
+import { useCopyObject, useCreateFolder, useDeleteObject, useDeleteObjectTagging, useDeleteObjects, useGetObject, useGetObjectAttributes, useGetObjectTorrent, useListMultipartUploads, useListObjectVersions, useListObjects, useObjectAcl, useObjectLegalHold, useObjectMetadata, useObjectRetention, useObjectTagging, usePutObject, useRestoreObject, useSearchObjects, useSearchObjectsVersions, useSelectObjectContent, useSetObjectAcl, useSetObjectLegalHold, useSetObjectRetention, useSetObjectTagging, useUploadObjects } from "./objectOperations.js";
+import { useGetPresignedDownload, useGetPresignedPost, useGetPresignedUpload } from "./presignedOperations.js";
+export { useBatchObjectLegalHold, useBuckets, useCopyObject, useCreateBucket, useCreateFolder, useDeleteBucket, useDeleteBucketConfigRule, useDeleteBucketCors, useDeleteBucketLifecycle, useDeleteBucketPolicy, useDeleteBucketReplication, useDeleteBucketTagging, useDeleteObject, useDeleteObjectTagging, useDeleteObjects, useEmptyBucket, useGetBucketAcl, useGetBucketCors, useGetBucketEncryption, useGetBucketLifecycle, useGetBucketLocation, useGetBucketNotification, useGetBucketObjectLockConfiguration, useGetBucketPolicy, useGetBucketReplication, useGetBucketTagging, useGetBucketVersioning, useGetObject, useGetObjectAttributes, useGetObjectTorrent, useGetPresignedDownload, useGetPresignedPost, useGetPresignedUpload, useISVBucketStatus, useIsBucketEmpty, useListMultipartUploads, useListObjectVersions, useListObjects, useLoginMutation, useObjectAcl, useObjectLegalHold, useObjectMetadata, useObjectRetention, useObjectTagging, usePutObject, useRestoreObject, useS3Client, useSearchObjects, useSearchObjectsVersions, useSelectObjectContent, useSetBucketAcl, useSetBucketCors, useSetBucketEncryption, useSetBucketLifecycle, useSetBucketNotification, useSetBucketObjectLockConfiguration, useSetBucketPolicy, useSetBucketReplication, useSetBucketTagging, useSetBucketVersioning, useSetObjectAcl, useSetObjectLegalHold, useSetObjectRetention, useSetObjectTagging, useTableRowSelection, useUploadObjects };

package/dist/hooks/loginOperations.d.ts

@@ -0,0 +1,21 @@
+/**
+ * S3 Login Authentication Operations
+ *
+ * This file contains hooks for S3 authentication operations.
+ * Uses the factory pattern for consistency with other S3 operations.
+ */
+import { S3BrowserConfig, S3Credentials } from "../types";
+export type LoginConfig = S3BrowserConfig & {
+    credentials: S3Credentials;
+};
+export interface LoginMutationResult {
+    config: LoginConfig;
+    authenticated: boolean;
+}
+/**
+ * Hook for S3 authentication using react-query mutation.
+ *
+ * Validates credentials and establishes S3 session by attempting to list buckets.
+ * Creates its own S3 client with the provided credentials for authentication.
+ */
+export declare const useLoginMutation: (options?: Omit<import("@tanstack/react-query").UseMutationOptions<LoginMutationResult, import("..").EnhancedS3Error, LoginConfig, unknown>, "mutationFn"> | undefined) => import("@tanstack/react-query").UseMutationResult<LoginMutationResult, import("..").EnhancedS3Error, LoginConfig>;

package/dist/hooks/loginOperations.js

@@ -0,0 +1,9 @@
+import { useCreateS3LoginHook } from "./factories/index.js";
+class LoginAuthenticationCommand {
+    input;
+    constructor(input){
+        this.input = input;
+    }
+}
+const useLoginMutation = useCreateS3LoginHook(LoginAuthenticationCommand, "S3 Authentication");
+export { useLoginMutation };

package/dist/hooks/objectOperations.d.ts

@@ -0,0 +1,190 @@
+/**
+ * S3 Object Operations
+ *
+ * This file contains hooks for managing S3 objects including
+ * metadata retrieval, uploads, downloads, deletion, and object-level
+ * configurations like retention and legal hold.
+ */
+import { CopyObjectCommandInput, CopyObjectCommandOutput, DeleteObjectCommandInput, DeleteObjectCommandOutput, DeleteObjectsCommandInput, DeleteObjectsCommandOutput, DeleteObjectTaggingCommandInput, DeleteObjectTaggingCommandOutput, GetObjectAclCommandInput, GetObjectAclCommandOutput, GetObjectAttributesCommandInput, GetObjectAttributesCommandOutput, GetObjectCommandInput, GetObjectCommandOutput, GetObjectLegalHoldCommandInput, GetObjectLegalHoldCommandOutput, GetObjectRetentionCommandInput, GetObjectRetentionCommandOutput, GetObjectTaggingCommandInput, GetObjectTaggingCommandOutput, GetObjectTorrentCommandInput, GetObjectTorrentCommandOutput, HeadObjectCommandInput, HeadObjectCommandOutput, ListMultipartUploadsCommandInput, ListMultipartUploadsCommandOutput, ListObjectsV2CommandInput, ListObjectVersionsCommandInput, PutObjectAclCommandInput, PutObjectAclCommandOutput, PutObjectCommandInput, PutObjectCommandOutput, PutObjectLegalHoldCommandInput, PutObjectLegalHoldCommandOutput, PutObjectRetentionCommandInput, PutObjectRetentionCommandOutput, PutObjectTaggingCommandInput, PutObjectTaggingCommandOutput, RestoreObjectCommandInput, RestoreObjectCommandOutput, SelectObjectContentCommandInput, SelectObjectContentCommandOutput } from "@aws-sdk/client-s3";
+import { SearchObjectsV2CommandInput, SearchObjectsVersionCommandInput } from "@scality/zenkoclient";
+/**
+ * Hook for listing S3 objects with infinite scroll support
+ *
+ * Provides paginated listing of objects in an S3 bucket with support for
+ * prefix filtering and infinite scroll. Returns both objects and common prefixes.
+ */
+export declare const useListObjects: (params: ListObjectsV2CommandInput, options?: Partial<import("@tanstack/react-query").UseInfiniteQueryOptions<any, import("..").EnhancedS3Error, any, (string | ListObjectsV2CommandInput)[], string | undefined>> | undefined) => import("@tanstack/react-query").UseInfiniteQueryResult<any, import("..").EnhancedS3Error>;
+/**
+ * Hook for listing S3 object versions with infinite scroll support
+ *
+ * Provides paginated listing of all versions for objects in an S3 bucket.
+ * Combines both object versions and delete markers in chronological order.
+ */
+export declare const useListObjectVersions: (params: ListObjectVersionsCommandInput, options?: Partial<import("@tanstack/react-query").UseInfiniteQueryOptions<any, import("..").EnhancedS3Error, any, (string | ListObjectVersionsCommandInput)[], string | undefined>> | undefined) => import("@tanstack/react-query").UseInfiniteQueryResult<any, import("..").EnhancedS3Error>;
+/**
+ * Hook for searching S3 objects with infinite scroll support
+ *
+ * Provides paginated search of objects in an S3 bucket using SQL-like query syntax.
+ * Supports advanced filtering and pattern matching on object keys and metadata.
+ */
+export declare const useSearchObjects: (params: SearchObjectsV2CommandInput, options?: Partial<import("@tanstack/react-query").UseInfiniteQueryOptions<any, import("..").EnhancedS3Error, any, (string | SearchObjectsV2CommandInput)[], string | undefined>> | undefined) => import("@tanstack/react-query").UseInfiniteQueryResult<any, import("..").EnhancedS3Error>;
+/**
+ * Hook for searching S3 object versions with infinite scroll support
+ *
+ * Provides paginated search of object versions in an S3 bucket using SQL-like query syntax.
+ * Supports advanced filtering and pattern matching on object keys and metadata across all versions.
+ */
+export declare const useSearchObjectsVersions: (params: SearchObjectsVersionCommandInput, options?: Partial<import("@tanstack/react-query").UseInfiniteQueryOptions<any, import("..").EnhancedS3Error, any, (string | SearchObjectsVersionCommandInput)[], string | undefined>> | undefined) => import("@tanstack/react-query").UseInfiniteQueryResult<any, import("..").EnhancedS3Error>;
+/**
+ * Hook for retrieving S3 object metadata
+ *
+ * Fetches metadata about an S3 object without downloading the object content.
+ * Returns information like content type, size, last modified date, etc.
+ */
+export declare const useObjectMetadata: (params?: HeadObjectCommandInput | undefined, options?: Omit<import("@tanstack/react-query").UseQueryOptions<HeadObjectCommandOutput, import("..").EnhancedS3Error, HeadObjectCommandOutput, readonly unknown[]>, "queryKey" | "queryFn"> | undefined) => import("@tanstack/react-query").UseQueryResult<HeadObjectCommandOutput, import("..").EnhancedS3Error>;
+/**
+ * Hook for downloading S3 object content
+ *
+ * Retrieves the full content of an S3 object. Use with caution for large files
+ * as it loads the entire object into memory.
+ */
+export declare const useGetObject: (params?: GetObjectCommandInput | undefined, options?: Omit<import("@tanstack/react-query").UseQueryOptions<GetObjectCommandOutput, import("..").EnhancedS3Error, GetObjectCommandOutput, readonly unknown[]>, "queryKey" | "queryFn"> | undefined) => import("@tanstack/react-query").UseQueryResult<GetObjectCommandOutput, import("..").EnhancedS3Error>;
+/**
+ * Hook for uploading objects to S3
+ *
+ * Uploads a new object or overwrites an existing object in S3.
+ * Automatically invalidates object listings after successful upload.
+ */
+export declare const usePutObject: (options?: Omit<import("@tanstack/react-query").UseMutationOptions<PutObjectCommandOutput, import("..").EnhancedS3Error, PutObjectCommandInput, unknown>, "mutationFn"> | undefined) => import("@tanstack/react-query").UseMutationResult<PutObjectCommandOutput, import("..").EnhancedS3Error, PutObjectCommandInput>;
+/**
+ * Hook for creating folders in S3
+ *
+ * Creates a folder (empty object with trailing slash) in S3.
+ * This is an alias for usePutObject with specific folder semantics.
+ */
+export declare const useCreateFolder: (options?: Omit<import("@tanstack/react-query").UseMutationOptions<PutObjectCommandOutput, import("..").EnhancedS3Error, PutObjectCommandInput, unknown>, "mutationFn"> | undefined) => import("@tanstack/react-query").UseMutationResult<PutObjectCommandOutput, import("..").EnhancedS3Error, PutObjectCommandInput>;
+/**
+ * Hook for uploading objects to S3
+ *
+ * Uploads a new object or overwrites an existing object in S3.
+ * This is an alias for usePutObject with upload semantics.
+ */
+export declare const useUploadObjects: (options?: Omit<import("@tanstack/react-query").UseMutationOptions<PutObjectCommandOutput, import("..").EnhancedS3Error, PutObjectCommandInput, unknown>, "mutationFn"> | undefined) => import("@tanstack/react-query").UseMutationResult<PutObjectCommandOutput, import("..").EnhancedS3Error, PutObjectCommandInput>;
+/**
+ * Hook for deleting a single S3 object
+ *
+ * Deletes a specific object from S3. For versioned buckets, this creates
+ * a delete marker unless a specific version is targeted.
+ */
+export declare const useDeleteObject: (options?: Omit<import("@tanstack/react-query").UseMutationOptions<DeleteObjectCommandOutput, import("..").EnhancedS3Error, DeleteObjectCommandInput, unknown>, "mutationFn"> | undefined) => import("@tanstack/react-query").UseMutationResult<DeleteObjectCommandOutput, import("..").EnhancedS3Error, DeleteObjectCommandInput>;
+/**
+ * Hook for deleting multiple S3 objects
+ *
+ * Efficiently deletes up to 1000 objects in a single request.
+ * Automatically invalidates object listings after successful deletion.
+ */
+export declare const useDeleteObjects: (options?: Omit<import("@tanstack/react-query").UseMutationOptions<DeleteObjectsCommandOutput, import("..").EnhancedS3Error, DeleteObjectsCommandInput, unknown>, "mutationFn"> | undefined) => import("@tanstack/react-query").UseMutationResult<DeleteObjectsCommandOutput, import("..").EnhancedS3Error, DeleteObjectsCommandInput>;
+/**
+ * Hook for copying S3 objects
+ *
+ * Copies an object from one location to another within S3.
+ * Can copy between buckets and modify metadata during copy.
+ */
+export declare const useCopyObject: (options?: Omit<import("@tanstack/react-query").UseMutationOptions<CopyObjectCommandOutput, import("..").EnhancedS3Error, CopyObjectCommandInput, unknown>, "mutationFn"> | undefined) => import("@tanstack/react-query").UseMutationResult<CopyObjectCommandOutput, import("..").EnhancedS3Error, CopyObjectCommandInput>;
+/**
+ * Hook for retrieving S3 object retention settings
+ *
+ * Fetches the retention configuration for an object in a bucket with
+ * Object Lock enabled. Returns retention mode and retain until date.
+ */
+export declare const useObjectRetention: (params?: GetObjectRetentionCommandInput | undefined, options?: Omit<import("@tanstack/react-query").UseQueryOptions<GetObjectRetentionCommandOutput, import("..").EnhancedS3Error, GetObjectRetentionCommandOutput, readonly unknown[]>, "queryKey" | "queryFn"> | undefined) => import("@tanstack/react-query").UseQueryResult<GetObjectRetentionCommandOutput, import("..").EnhancedS3Error>;
+/**
+ * Hook for setting S3 object retention
+ *
+ * Sets or updates the retention configuration for an object.
+ * Only works on buckets with Object Lock enabled.
+ */
+export declare const useSetObjectRetention: (options?: Omit<import("@tanstack/react-query").UseMutationOptions<PutObjectRetentionCommandOutput, import("..").EnhancedS3Error, PutObjectRetentionCommandInput, unknown>, "mutationFn"> | undefined) => import("@tanstack/react-query").UseMutationResult<PutObjectRetentionCommandOutput, import("..").EnhancedS3Error, PutObjectRetentionCommandInput>;
+/**
+ * Hook for retrieving S3 object legal hold status
+ *
+ * Fetches the legal hold status for an object in a bucket with
+ * Object Lock enabled. Returns whether legal hold is on or off.
+ */
+export declare const useObjectLegalHold: (params?: GetObjectLegalHoldCommandInput | undefined, options?: Omit<import("@tanstack/react-query").UseQueryOptions<GetObjectLegalHoldCommandOutput, import("..").EnhancedS3Error, GetObjectLegalHoldCommandOutput, readonly unknown[]>, "queryKey" | "queryFn"> | undefined) => import("@tanstack/react-query").UseQueryResult<GetObjectLegalHoldCommandOutput, import("..").EnhancedS3Error>;
+/**
+ * Hook for setting S3 object legal hold
+ *
+ * Enables or disables legal hold on an object. Legal hold prevents
+ * object deletion regardless of retention settings.
+ */
+export declare const useSetObjectLegalHold: (options?: Omit<import("@tanstack/react-query").UseMutationOptions<PutObjectLegalHoldCommandOutput, import("..").EnhancedS3Error, PutObjectLegalHoldCommandInput, unknown>, "mutationFn"> | undefined) => import("@tanstack/react-query").UseMutationResult<PutObjectLegalHoldCommandOutput, import("..").EnhancedS3Error, PutObjectLegalHoldCommandInput>;
+/**
+ * Hook for retrieving S3 object tags
+ *
+ * Fetches the tag set associated with an object. Tags are key-value
+ * pairs used for object categorization and management.
+ */
+export declare const useObjectTagging: (params?: GetObjectTaggingCommandInput | undefined, options?: Omit<import("@tanstack/react-query").UseQueryOptions<GetObjectTaggingCommandOutput, import("..").EnhancedS3Error, GetObjectTaggingCommandOutput, readonly unknown[]>, "queryKey" | "queryFn"> | undefined) => import("@tanstack/react-query").UseQueryResult<GetObjectTaggingCommandOutput, import("..").EnhancedS3Error>;
+/**
+ * Hook for setting S3 object tags
+ *
+ * Sets or replaces the tag set for an object. Existing tags are
+ * completely replaced by the new tag set.
+ */
+export declare const useSetObjectTagging: (options?: Omit<import("@tanstack/react-query").UseMutationOptions<PutObjectTaggingCommandOutput, import("..").EnhancedS3Error, PutObjectTaggingCommandInput, unknown>, "mutationFn"> | undefined) => import("@tanstack/react-query").UseMutationResult<PutObjectTaggingCommandOutput, import("..").EnhancedS3Error, PutObjectTaggingCommandInput>;
+/**
+ * Hook for deleting S3 object tags
+ *
+ * Removes all tags from an object. This operation cannot be undone.
+ */
+export declare const useDeleteObjectTagging: (options?: Omit<import("@tanstack/react-query").UseMutationOptions<DeleteObjectTaggingCommandOutput, import("..").EnhancedS3Error, DeleteObjectTaggingCommandInput, unknown>, "mutationFn"> | undefined) => import("@tanstack/react-query").UseMutationResult<DeleteObjectTaggingCommandOutput, import("..").EnhancedS3Error, DeleteObjectTaggingCommandInput>;
+/**
+ * Hook for retrieving S3 object ACL
+ *
+ * Fetches the access control list for a specific object.
+ * Returns information about object permissions and grantees.
+ */
+export declare const useObjectAcl: (params?: GetObjectAclCommandInput | undefined, options?: Omit<import("@tanstack/react-query").UseQueryOptions<GetObjectAclCommandOutput, import("..").EnhancedS3Error, GetObjectAclCommandOutput, readonly unknown[]>, "queryKey" | "queryFn"> | undefined) => import("@tanstack/react-query").UseQueryResult<GetObjectAclCommandOutput, import("..").EnhancedS3Error>;
+/**
+ * Hook for setting S3 object ACL
+ *
+ * Sets the access control list for a specific object.
+ * Can use predefined ACLs or specify custom grants.
+ */
+export declare const useSetObjectAcl: (options?: Omit<import("@tanstack/react-query").UseMutationOptions<PutObjectAclCommandOutput, import("..").EnhancedS3Error, PutObjectAclCommandInput, unknown>, "mutationFn"> | undefined) => import("@tanstack/react-query").UseMutationResult<PutObjectAclCommandOutput, import("..").EnhancedS3Error, PutObjectAclCommandInput>;
+/**
+ * Hook for retrieving S3 object attributes
+ *
+ * Fetches specific attributes of an object such as checksum, object parts,
+ * storage class, and object size without downloading the object content.
+ */
+export declare const useGetObjectAttributes: (params?: GetObjectAttributesCommandInput | undefined, options?: Omit<import("@tanstack/react-query").UseQueryOptions<GetObjectAttributesCommandOutput, import("..").EnhancedS3Error, GetObjectAttributesCommandOutput, readonly unknown[]>, "queryKey" | "queryFn"> | undefined) => import("@tanstack/react-query").UseQueryResult<GetObjectAttributesCommandOutput, import("..").EnhancedS3Error>;
+/**
+ * Hook for retrieving S3 object torrent
+ *
+ * Returns torrent files for an object in S3. This allows BitTorrent clients
+ * to retrieve the object using the BitTorrent protocol.
+ */
+export declare const useGetObjectTorrent: (params?: GetObjectTorrentCommandInput | undefined, options?: Omit<import("@tanstack/react-query").UseQueryOptions<GetObjectTorrentCommandOutput, import("..").EnhancedS3Error, GetObjectTorrentCommandOutput, readonly unknown[]>, "queryKey" | "queryFn"> | undefined) => import("@tanstack/react-query").UseQueryResult<GetObjectTorrentCommandOutput, import("..").EnhancedS3Error>;
+/**
+ * Hook for restoring archived S3 objects
+ *
+ * Initiates restoration of an archived object from Glacier or Deep Archive
+ * storage classes. Restored objects are temporarily available in S3.
+ */
+export declare const useRestoreObject: (options?: Omit<import("@tanstack/react-query").UseMutationOptions<RestoreObjectCommandOutput, import("..").EnhancedS3Error, RestoreObjectCommandInput, unknown>, "mutationFn"> | undefined) => import("@tanstack/react-query").UseMutationResult<RestoreObjectCommandOutput, import("..").EnhancedS3Error, RestoreObjectCommandInput>;
+/**
+ * Hook for selecting object content with SQL
+ *
+ * Enables SQL-like queries on S3 objects (CSV, JSON, Parquet) to retrieve
+ * only the subset of data that you need, reducing transfer costs.
+ */
+export declare const useSelectObjectContent: (params?: SelectObjectContentCommandInput | undefined, options?: Omit<import("@tanstack/react-query").UseQueryOptions<SelectObjectContentCommandOutput, import("..").EnhancedS3Error, SelectObjectContentCommandOutput, readonly unknown[]>, "queryKey" | "queryFn"> | undefined) => import("@tanstack/react-query").UseQueryResult<SelectObjectContentCommandOutput, import("..").EnhancedS3Error>;
+/**
+ * Hook for listing multipart uploads with infinite scroll support
+ *
+ * Provides paginated listing of incomplete multipart uploads in an S3 bucket.
+ * Useful for monitoring and managing ongoing uploads.
+ */
+export declare const useListMultipartUploads: (params: ListMultipartUploadsCommandInput, options?: Partial<import("@tanstack/react-query").UseInfiniteQueryOptions<ListMultipartUploadsCommandOutput, import("..").EnhancedS3Error, ListMultipartUploadsCommandOutput, (string | ListMultipartUploadsCommandInput)[], string | undefined>> | undefined) => import("@tanstack/react-query").UseInfiniteQueryResult<ListMultipartUploadsCommandOutput, import("..").EnhancedS3Error>;

package/dist/hooks/objectOperations.js

@@ -0,0 +1,67 @@
+import { CopyObjectCommand, DeleteObjectCommand, DeleteObjectTaggingCommand, DeleteObjectsCommand, GetObjectAclCommand, GetObjectAttributesCommand, GetObjectCommand, GetObjectLegalHoldCommand, GetObjectRetentionCommand, GetObjectTaggingCommand, GetObjectTorrentCommand, HeadObjectCommand, ListMultipartUploadsCommand, ListObjectVersionsCommand, ListObjectsV2Command, PutObjectAclCommand, PutObjectCommand, PutObjectLegalHoldCommand, PutObjectRetentionCommand, PutObjectTaggingCommand, RestoreObjectCommand, SelectObjectContentCommand } from "@aws-sdk/client-s3";
+import { useCreateS3InfiniteQueryHook } from "./factories/useCreateS3InfiniteQueryHook.js";
+import { useCreateS3MutationHook } from "./factories/useCreateS3MutationHook.js";
+import { useCreateS3QueryHook } from "./factories/useCreateS3QueryHook.js";
+import { SearchObjectsV2Command, SearchObjectsVersionCommand } from "@scality/zenkoclient";
+const useListObjects = useCreateS3InfiniteQueryHook(ListObjectsV2Command, "ListObjects");
+const useListObjectVersions = useCreateS3InfiniteQueryHook(ListObjectVersionsCommand, "ListObjectVersions");
+const useSearchObjects = useCreateS3InfiniteQueryHook(SearchObjectsV2Command, "SearchObjects");
+const useSearchObjectsVersions = useCreateS3InfiniteQueryHook(SearchObjectsVersionCommand, "SearchObjectsVersions");
+const useObjectMetadata = useCreateS3QueryHook(HeadObjectCommand, "HeadObject");
+const useGetObject = useCreateS3QueryHook(GetObjectCommand, "GetObject");
+const usePutObject = useCreateS3MutationHook(PutObjectCommand, "PutObject", [
+    "ListObjects",
+    "SearchObjects"
+]);
+const useCreateFolder = useCreateS3MutationHook(PutObjectCommand, "PutObject", [
+    "ListObjects",
+    "SearchObjects"
+]);
+const useUploadObjects = useCreateS3MutationHook(PutObjectCommand, "PutObject", [
+    "ListObjects",
+    "SearchObjects"
+]);
+const useDeleteObject = useCreateS3MutationHook(DeleteObjectCommand, "DeleteObject", [
+    "ListObjects",
+    "SearchObjects"
+]);
+const useDeleteObjects = useCreateS3MutationHook(DeleteObjectsCommand, "DeleteObjects", [
+    "ListObjects",
+    "ListObjectVersions",
+    "SearchObjects",
+    "SearchObjectsVersions"
+]);
+const useCopyObject = useCreateS3MutationHook(CopyObjectCommand, "CopyObject", [
+    "ListObjects",
+    "SearchObjects",
+    "HeadObject"
+]);
+const useObjectRetention = useCreateS3QueryHook(GetObjectRetentionCommand, "GetObjectRetention");
+const useSetObjectRetention = useCreateS3MutationHook(PutObjectRetentionCommand, "PutObjectRetention", [
+    "GetObjectRetention"
+]);
+const useObjectLegalHold = useCreateS3QueryHook(GetObjectLegalHoldCommand, "GetObjectLegalHold");
+const useSetObjectLegalHold = useCreateS3MutationHook(PutObjectLegalHoldCommand, "PutObjectLegalHold", [
+    "GetObjectLegalHold",
+    "BatchObjectLegalHold"
+]);
+const useObjectTagging = useCreateS3QueryHook(GetObjectTaggingCommand, "GetObjectTagging");
+const useSetObjectTagging = useCreateS3MutationHook(PutObjectTaggingCommand, "PutObjectTagging", [
+    "GetObjectTagging"
+]);
+const useDeleteObjectTagging = useCreateS3MutationHook(DeleteObjectTaggingCommand, "DeleteObjectTagging", [
+    "GetObjectTagging"
+]);
+const useObjectAcl = useCreateS3QueryHook(GetObjectAclCommand, "GetObjectAcl");
+const useSetObjectAcl = useCreateS3MutationHook(PutObjectAclCommand, "PutObjectAcl", [
+    "GetObjectAcl"
+]);
+const useGetObjectAttributes = useCreateS3QueryHook(GetObjectAttributesCommand, "GetObjectAttributes");
+const useGetObjectTorrent = useCreateS3QueryHook(GetObjectTorrentCommand, "GetObjectTorrent");
+const useRestoreObject = useCreateS3MutationHook(RestoreObjectCommand, "RestoreObject", [
+    "HeadObject",
+    "ListObjects"
+]);
+const useSelectObjectContent = useCreateS3QueryHook(SelectObjectContentCommand, "SelectObjectContent");
+const useListMultipartUploads = useCreateS3InfiniteQueryHook(ListMultipartUploadsCommand, "ListMultipartUploads");
+export { useCopyObject, useCreateFolder, useDeleteObject, useDeleteObjectTagging, useDeleteObjects, useGetObject, useGetObjectAttributes, useGetObjectTorrent, useListMultipartUploads, useListObjectVersions, useListObjects, useObjectAcl, useObjectLegalHold, useObjectMetadata, useObjectRetention, useObjectTagging, usePutObject, useRestoreObject, useSearchObjects, useSearchObjectsVersions, useSelectObjectContent, useSetObjectAcl, useSetObjectLegalHold, useSetObjectRetention, useSetObjectTagging, useUploadObjects };

package/dist/hooks/presignedOperations.d.ts

@@ -0,0 +1,73 @@
+/**
+ * S3 Presigned URL Operations
+ *
+ * This file contains hooks for the three core presigned URL operations:
+ * 1. Get Presigned URL (Download)
+ * 2. Get Presigned POST
+ * 3. Get Presigned Upload (PUT)
+ */
+import { PresignedPostOptions, PresignedPost } from "@aws-sdk/s3-presigned-post";
+import { GetObjectCommandInput, PutObjectCommandInput } from "@aws-sdk/client-s3";
+/**
+ * Hook for getting presigned download URLs
+ *
+ * Generates presigned URLs for downloading S3 objects.
+ * Supports custom expiration times and response headers.
+ */
+export declare const useGetPresignedDownload: (options?: Omit<import("@tanstack/react-query").UseMutationOptions<{
+    Url: string;
+    ExpiresAt: Date;
+    Bucket: string;
+    Key: string;
+    VersionId?: string;
+}, import("../utils/errorHandling").EnhancedS3Error, GetObjectCommandInput & {
+    expiresIn?: number;
+}, unknown>, "mutationFn"> | undefined) => import("@tanstack/react-query").UseMutationResult<{
+    Url: string;
+    ExpiresAt: Date;
+    Bucket: string;
+    Key: string;
+    VersionId?: string;
+}, import("../utils/errorHandling").EnhancedS3Error, GetObjectCommandInput & {
+    expiresIn?: number;
+}>;
+/**
+ * Hook for getting presigned upload URLs
+ *
+ * Generates presigned URLs for uploading objects to S3 using PUT method.
+ * Supports content type specification, content length limits, and custom metadata.
+ */
+export declare const useGetPresignedUpload: (options?: Omit<import("@tanstack/react-query").UseMutationOptions<{
+    Url: string;
+    ExpiresAt: Date;
+    Bucket: string;
+    Key: string;
+}, import("../utils/errorHandling").EnhancedS3Error, PutObjectCommandInput & {
+    expiresIn?: number;
+}, unknown>, "mutationFn"> | undefined) => import("@tanstack/react-query").UseMutationResult<{
+    Url: string;
+    ExpiresAt: Date;
+    Bucket: string;
+    Key: string;
+}, import("../utils/errorHandling").EnhancedS3Error, PutObjectCommandInput & {
+    expiresIn?: number;
+}>;
+/**
+ * Hook for getting presigned POST configurations
+ *
+ * Generates presigned POST data for browser-based file uploads.
+ * Returns both the POST URL and form fields required for direct uploads to S3.
+ */
+export declare const useGetPresignedPost: (options?: Omit<import("@tanstack/react-query").UseMutationOptions<PresignedPost & {
+    ExpiresAt: Date;
+}, import("../utils/errorHandling").EnhancedS3Error, {
+    Bucket: string;
+    Key: string;
+    expiresIn?: number;
+} & Omit<PresignedPostOptions, "Expires" | "Bucket" | "Key">, unknown>, "mutationFn"> | undefined) => import("@tanstack/react-query").UseMutationResult<PresignedPost & {
+    ExpiresAt: Date;
+}, import("../utils/errorHandling").EnhancedS3Error, {
+    Bucket: string;
+    Key: string;
+    expiresIn?: number;
+} & Omit<PresignedPostOptions, "Expires" | "Bucket" | "Key">>;

package/dist/hooks/presignedOperations.js

@@ -0,0 +1,72 @@
+import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
+import { createPresignedPost } from "@aws-sdk/s3-presigned-post";
+import { GetObjectCommand, PutObjectCommand } from "@aws-sdk/client-s3";
+import { createS3OperationError } from "../utils/errorHandling.js";
+import { useCreateS3FunctionMutationHook } from "./factories/index.js";
+const generatePresignedDownloadUrl = async (client, config)=>{
+    try {
+        const { Bucket, Key, expiresIn = 3600, ...awsOptions } = config;
+        const command = new GetObjectCommand({
+            Bucket,
+            Key,
+            ...awsOptions
+        });
+        const url = await getSignedUrl(client, command, {
+            expiresIn
+        });
+        const expiresAt = new Date(Date.now() + 1000 * expiresIn);
+        return {
+            Url: url,
+            ExpiresAt: expiresAt,
+            Bucket: Bucket,
+            Key: Key,
+            VersionId: config.VersionId
+        };
+    } catch (error) {
+        throw createS3OperationError(error, "GeneratePresignedDownload", config.Bucket, config.Key);
+    }
+};
+const generatePresignedUploadUrl = async (client, config)=>{
+    try {
+        const { Bucket, Key, expiresIn = 3600, ...awsOptions } = config;
+        const command = new PutObjectCommand({
+            Bucket,
+            Key,
+            ...awsOptions
+        });
+        const url = await getSignedUrl(client, command, {
+            expiresIn
+        });
+        const expiresAt = new Date(Date.now() + 1000 * expiresIn);
+        return {
+            Url: url,
+            ExpiresAt: expiresAt,
+            Bucket: Bucket,
+            Key: Key
+        };
+    } catch (error) {
+        throw createS3OperationError(error, "GeneratePresignedUpload", config.Bucket, config.Key);
+    }
+};
+const generatePresignedPost = async (client, config)=>{
+    try {
+        const { Bucket, Key, expiresIn = 3600, ...awsOptions } = config;
+        const presignedPost = await createPresignedPost(client, {
+            Bucket,
+            Key,
+            Expires: expiresIn,
+            ...awsOptions
+        });
+        const expiresAt = new Date(Date.now() + 1000 * expiresIn);
+        return {
+            ...presignedPost,
+            ExpiresAt: expiresAt
+        };
+    } catch (error) {
+        throw createS3OperationError(error, "GeneratePresignedPost", config.Bucket, config.Key);
+    }
+};
+const useGetPresignedDownload = useCreateS3FunctionMutationHook(generatePresignedDownloadUrl);
+const useGetPresignedUpload = useCreateS3FunctionMutationHook(generatePresignedUploadUrl);
+const useGetPresignedPost = useCreateS3FunctionMutationHook(generatePresignedPost);
+export { useGetPresignedDownload, useGetPresignedPost, useGetPresignedUpload };

package/dist/hooks/useBatchObjectLegalHold.d.ts

@@ -0,0 +1,11 @@
+interface ObjectIdentifier {
+    Key: string;
+    VersionId?: string;
+}
+interface LegalHoldStatus {
+    key: string;
+    versionId?: string;
+    isLegalHoldEnabled: boolean;
+}
+export declare const useBatchObjectLegalHold: (bucketName: string, objects: ObjectIdentifier[], enabled?: boolean) => import("@tanstack/react-query").UseQueryResult<Record<string, LegalHoldStatus>, Error>;
+export {};