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

package/dist/hooks/factories/__tests__/useCreateS3LoginHook.test.js

@@ -0,0 +1,166 @@
+import { renderHook, waitFor } from "@testing-library/react";
+import { useCreateS3LoginHook } from "../useCreateS3LoginHook.js";
+import { createS3Client } from "../../../utils/s3Client.js";
+import { createS3OperationError } from "../../../utils/errorHandling.js";
+import { createQueryWrapper, validateFactoryHook, validateHookResult } from "../../../test/testUtils.js";
+jest.mock("../../../utils/s3Client");
+jest.mock("../../../utils/errorHandling");
+const mockCreateS3Client = createS3Client;
+const mockCreateS3OperationError = createS3OperationError;
+class MockLoginCommand {
+    input;
+    constructor(input){
+        this.input = input;
+    }
+}
+const mockS3Client = {
+    send: jest.fn()
+};
+describe("useCreateS3LoginHook - Login Factory Specific", ()=>{
+    const mockLoginConfig = {
+        endpoint: "https://s3.amazonaws.com",
+        region: "us-east-1",
+        forcePathStyle: false,
+        credentials: {
+            accessKeyId: "test-access-key",
+            secretAccessKey: "test-secret-key"
+        }
+    };
+    beforeEach(()=>{
+        jest.clearAllMocks();
+        mockCreateS3Client.mockReturnValue(mockS3Client);
+    });
+    it("should create a functioning login mutation hook", ()=>{
+        const useLoginMutation = useCreateS3LoginHook(MockLoginCommand, "S3 Authentication");
+        validateFactoryHook(useLoginMutation, "S3 Authentication");
+        const { result } = renderHook(()=>useLoginMutation(), {
+            wrapper: createQueryWrapper()
+        });
+        validateHookResult(result.current, "mutation");
+    });
+    it("should authenticate successfully with valid credentials", async ()=>{
+        mockS3Client.send.mockResolvedValueOnce({});
+        const useLoginMutation = useCreateS3LoginHook(MockLoginCommand, "S3 Authentication");
+        const { result } = renderHook(()=>useLoginMutation(), {
+            wrapper: createQueryWrapper()
+        });
+        result.current.mutate(mockLoginConfig);
+        await waitFor(()=>{
+            expect(result.current.isSuccess).toBe(true);
+        });
+        expect(result.current.data).toEqual({
+            config: mockLoginConfig,
+            authenticated: true
+        });
+        expect(mockCreateS3Client).toHaveBeenCalledWith(mockLoginConfig);
+    });
+    it("should handle authentication failure", async ()=>{
+        const mockError = new Error("Access Denied");
+        const enhancedError = new Error("Enhanced S3 Authentication Error");
+        mockS3Client.send.mockRejectedValueOnce(mockError);
+        mockCreateS3OperationError.mockReturnValueOnce(enhancedError);
+        const useLoginMutation = useCreateS3LoginHook(MockLoginCommand, "S3 Authentication");
+        const { result } = renderHook(()=>useLoginMutation(), {
+            wrapper: createQueryWrapper()
+        });
+        result.current.mutate(mockLoginConfig);
+        await waitFor(()=>{
+            expect(result.current.isError).toBe(true);
+        });
+        expect(result.current.error).toBe(enhancedError);
+        expect(mockCreateS3OperationError).toHaveBeenCalledWith(mockError, "S3 Authentication");
+    });
+    it("should create its own S3 client instead of using context client", async ()=>{
+        mockS3Client.send.mockResolvedValueOnce({});
+        const useLoginMutation = useCreateS3LoginHook(MockLoginCommand, "S3 Authentication");
+        const { result } = renderHook(()=>useLoginMutation(), {
+            wrapper: createQueryWrapper()
+        });
+        result.current.mutate(mockLoginConfig);
+        await waitFor(()=>{
+            expect(result.current.isSuccess).toBe(true);
+        });
+        expect(mockCreateS3Client).toHaveBeenCalledWith(mockLoginConfig);
+        expect(mockCreateS3Client).toHaveBeenCalledTimes(1);
+    });
+    it("should handle mutation callbacks correctly", async ()=>{
+        const onSuccess = jest.fn();
+        const onError = jest.fn();
+        const onSettled = jest.fn();
+        mockS3Client.send.mockResolvedValueOnce({});
+        const useLoginMutation = useCreateS3LoginHook(MockLoginCommand, "S3 Authentication");
+        const { result } = renderHook(()=>useLoginMutation({
+                onSuccess,
+                onError,
+                onSettled
+            }), {
+            wrapper: createQueryWrapper()
+        });
+        result.current.mutate(mockLoginConfig);
+        await waitFor(()=>{
+            expect(result.current.isSuccess).toBe(true);
+        });
+        const expectedResult = {
+            config: mockLoginConfig,
+            authenticated: true
+        };
+        expect(onSuccess).toHaveBeenCalledWith(expectedResult, mockLoginConfig, void 0, expect.any(Object));
+        expect(onError).not.toHaveBeenCalled();
+        expect(onSettled).toHaveBeenCalledWith(expectedResult, null, mockLoginConfig, void 0, expect.any(Object));
+    });
+    it("should handle network errors during authentication", async ()=>{
+        const networkError = new Error("Network timeout");
+        const enhancedError = new Error("Enhanced Network Error");
+        mockS3Client.send.mockRejectedValueOnce(networkError);
+        mockCreateS3OperationError.mockReturnValueOnce(enhancedError);
+        const useLoginMutation = useCreateS3LoginHook(MockLoginCommand, "S3 Authentication");
+        const { result } = renderHook(()=>useLoginMutation(), {
+            wrapper: createQueryWrapper()
+        });
+        result.current.mutate(mockLoginConfig);
+        await waitFor(()=>{
+            expect(result.current.isError).toBe(true);
+        });
+        expect(result.current.error).toBe(enhancedError);
+        expect(mockCreateS3OperationError).toHaveBeenCalledWith(networkError, "S3 Authentication");
+    });
+    it("should work with credentials containing session token", async ()=>{
+        const configWithToken = {
+            ...mockLoginConfig,
+            credentials: {
+                ...mockLoginConfig.credentials,
+                sessionToken: "test-session-token"
+            }
+        };
+        mockS3Client.send.mockResolvedValueOnce({});
+        const useLoginMutation = useCreateS3LoginHook(MockLoginCommand, "S3 Authentication");
+        const { result } = renderHook(()=>useLoginMutation(), {
+            wrapper: createQueryWrapper()
+        });
+        result.current.mutate(configWithToken);
+        await waitFor(()=>{
+            expect(result.current.isSuccess).toBe(true);
+        });
+        expect(mockCreateS3Client).toHaveBeenCalledWith(configWithToken);
+        expect(result.current.data).toEqual({
+            config: configWithToken,
+            authenticated: true
+        });
+    });
+    it("should handle custom endpoint configurations", async ()=>{
+        const customEndpointConfig = {
+            ...mockLoginConfig,
+            endpoint: "https://custom-s3.example.com"
+        };
+        mockS3Client.send.mockResolvedValueOnce({});
+        const useLoginMutation = useCreateS3LoginHook(MockLoginCommand, "S3 Authentication");
+        const { result } = renderHook(()=>useLoginMutation(), {
+            wrapper: createQueryWrapper()
+        });
+        result.current.mutate(customEndpointConfig);
+        await waitFor(()=>{
+            expect(result.current.isSuccess).toBe(true);
+        });
+        expect(mockCreateS3Client).toHaveBeenCalledWith(customEndpointConfig);
+    });
+});

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

@@ -0,0 +1 @@
+export {};

package/dist/hooks/factories/__tests__/useCreateS3MutationHook.test.js

@@ -0,0 +1,200 @@
+import { renderHook, waitFor } from "@testing-library/react";
+import { useCreateS3MutationHook } from "../useCreateS3MutationHook.js";
+import { useS3Client } from "../../useS3Client.js";
+import { createS3OperationError } from "../../../utils/errorHandling.js";
+import { createQueryWrapper, validateFactoryHook, validateHookResult } from "../../../test/testUtils.js";
+jest.mock("../../useS3Client");
+jest.mock("../../../utils/errorHandling");
+const mockUseS3Client = useS3Client;
+const mockCreateS3OperationError = createS3OperationError;
+class MockCommand {
+    input;
+    constructor(input){
+        this.input = input;
+    }
+}
+const mockS3Client = {
+    send: jest.fn()
+};
+describe("useCreateS3MutationHook - Factory Specific", ()=>{
+    beforeEach(()=>{
+        jest.clearAllMocks();
+        mockUseS3Client.mockReturnValue(mockS3Client);
+    });
+    it("should create a functioning mutation hook", ()=>{
+        const useMutation = useCreateS3MutationHook(MockCommand, "testMutation");
+        validateFactoryHook(useMutation, "testMutation");
+        const { result } = renderHook(()=>useMutation(), {
+            wrapper: createQueryWrapper()
+        });
+        validateHookResult(result.current, "mutation");
+    });
+    it("should accept invalidation keys parameter", ()=>{
+        const useMutation = useCreateS3MutationHook(MockCommand, "testMutation", [
+            "ListObjects",
+            "TestQuery"
+        ]);
+        validateFactoryHook(useMutation, "testMutation");
+        const { result } = renderHook(()=>useMutation(), {
+            wrapper: createQueryWrapper()
+        });
+        validateHookResult(result.current, "mutation");
+    });
+    it("should execute mutation successfully", async ()=>{
+        const mockResponse = {
+            success: true,
+            key: "uploaded-file.txt"
+        };
+        mockS3Client.send.mockResolvedValue(mockResponse);
+        const useMutation = useCreateS3MutationHook(MockCommand, "PutObject");
+        const { result } = renderHook(()=>useMutation(), {
+            wrapper: createQueryWrapper()
+        });
+        result.current.mutate({
+            Bucket: "test-bucket",
+            Key: "test-file.txt",
+            Body: "content"
+        });
+        await waitFor(()=>{
+            expect(result.current.isSuccess).toBe(true);
+        });
+        expect(result.current.data).toEqual(mockResponse);
+        expect(mockS3Client.send).toHaveBeenCalledWith(expect.objectContaining({
+            input: {
+                Bucket: "test-bucket",
+                Key: "test-file.txt",
+                Body: "content"
+            }
+        }));
+    });
+    it("should handle mutation errors with proper context", async ()=>{
+        const mockError = new Error("Access Denied");
+        const enhancedError = new Error("Enhanced Access Denied");
+        mockS3Client.send.mockRejectedValue(mockError);
+        mockCreateS3OperationError.mockReturnValue(enhancedError);
+        const useMutation = useCreateS3MutationHook(MockCommand, "PutObject");
+        const { result } = renderHook(()=>useMutation(), {
+            wrapper: createQueryWrapper()
+        });
+        result.current.mutate({
+            Bucket: "test-bucket",
+            Key: "test-file.txt"
+        });
+        await waitFor(()=>{
+            expect(result.current.isError).toBe(true);
+        });
+        expect(result.current.error).toBe(enhancedError);
+        expect(mockCreateS3OperationError).toHaveBeenCalledWith(mockError, "PutObject", "test-bucket");
+    });
+    it("should handle mutation callbacks correctly", async ()=>{
+        const mockResponse = {
+            success: true
+        };
+        const onSuccess = jest.fn();
+        const onError = jest.fn();
+        const onSettled = jest.fn();
+        mockS3Client.send.mockResolvedValue(mockResponse);
+        const useMutation = useCreateS3MutationHook(MockCommand, "PutObject");
+        const { result } = renderHook(()=>useMutation({
+                onSuccess,
+                onError,
+                onSettled
+            }), {
+            wrapper: createQueryWrapper()
+        });
+        const variables = {
+            Bucket: "test-bucket",
+            Key: "test-file.txt"
+        };
+        result.current.mutate(variables);
+        await waitFor(()=>{
+            expect(result.current.isSuccess).toBe(true);
+        });
+        expect(onSuccess).toHaveBeenCalledWith(mockResponse, variables, void 0, expect.any(Object));
+        expect(onError).not.toHaveBeenCalled();
+        expect(onSettled).toHaveBeenCalledWith(mockResponse, null, variables, void 0, expect.any(Object));
+    });
+    it("should handle mutation with invalidation keys", async ()=>{
+        const mockResponse = {
+            success: true
+        };
+        mockS3Client.send.mockResolvedValue(mockResponse);
+        const useMutation = useCreateS3MutationHook(MockCommand, "PutObject", [
+            "ListObjects",
+            "TestQuery"
+        ]);
+        const { result } = renderHook(()=>useMutation(), {
+            wrapper: createQueryWrapper()
+        });
+        result.current.mutate({
+            Bucket: "test-bucket",
+            Key: "test-file.txt"
+        });
+        await waitFor(()=>{
+            expect(result.current.isSuccess).toBe(true);
+        });
+        expect(result.current.data).toEqual(mockResponse);
+    });
+    it("should handle concurrent mutations correctly", async ()=>{
+        const mockResponse1 = {
+            success: true,
+            id: 1
+        };
+        const mockResponse2 = {
+            success: true,
+            id: 2
+        };
+        let callCount = 0;
+        mockS3Client.send.mockImplementation(()=>{
+            callCount++;
+            return Promise.resolve(1 === callCount ? mockResponse1 : mockResponse2);
+        });
+        const useMutation = useCreateS3MutationHook(MockCommand, "PutObject");
+        const { result: result1 } = renderHook(()=>useMutation(), {
+            wrapper: createQueryWrapper()
+        });
+        const { result: result2 } = renderHook(()=>useMutation(), {
+            wrapper: createQueryWrapper()
+        });
+        result1.current.mutate({
+            Bucket: "test-bucket",
+            Key: "file1.txt"
+        });
+        result2.current.mutate({
+            Bucket: "test-bucket",
+            Key: "file2.txt"
+        });
+        await waitFor(()=>{
+            expect(result1.current.isSuccess).toBe(true);
+            expect(result2.current.isSuccess).toBe(true);
+        });
+        expect(result1.current.data).toEqual(mockResponse1);
+        expect(result2.current.data).toEqual(mockResponse2);
+        expect(mockS3Client.send).toHaveBeenCalledTimes(2);
+    });
+    it("should pass command correctly for mutations", async ()=>{
+        let capturedCommand;
+        mockS3Client.send.mockImplementation((command)=>{
+            capturedCommand = command;
+            return Promise.resolve({
+                success: true
+            });
+        });
+        const useMutation = useCreateS3MutationHook(MockCommand, "PutObject");
+        const { result } = renderHook(()=>useMutation(), {
+            wrapper: createQueryWrapper()
+        });
+        result.current.mutate({
+            Bucket: "test-bucket",
+            Key: "test-file.txt"
+        });
+        await waitFor(()=>{
+            expect(result.current.isSuccess).toBe(true);
+        });
+        expect(capturedCommand).toBeInstanceOf(MockCommand);
+        expect(capturedCommand.input).toEqual({
+            Bucket: "test-bucket",
+            Key: "test-file.txt"
+        });
+    });
+});

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

@@ -0,0 +1 @@
+export {};

package/dist/hooks/factories/__tests__/useCreateS3QueryHook.test.js

@@ -0,0 +1,179 @@
+import { renderHook, waitFor } from "@testing-library/react";
+import { useCreateS3QueryHook } from "../useCreateS3QueryHook.js";
+import { useS3Client } from "../../useS3Client.js";
+import { createS3OperationError, isNotFoundError } from "../../../utils/errorHandling.js";
+import { createQueryWrapper, validateFactoryHook, validateHookResult } from "../../../test/testUtils.js";
+jest.mock("../../useS3Client");
+jest.mock("../../../utils/errorHandling");
+const mockUseS3Client = useS3Client;
+const mockCreateS3OperationError = createS3OperationError;
+const mockIsNotFoundError = isNotFoundError;
+class MockCommand {
+    input;
+    constructor(input){
+        this.input = input;
+    }
+}
+const mockS3Client = {
+    send: jest.fn()
+};
+describe("useCreateS3QueryHook - Factory Specific", ()=>{
+    beforeEach(()=>{
+        jest.clearAllMocks();
+        mockUseS3Client.mockReturnValue(mockS3Client);
+    });
+    it("should create a functioning query hook", ()=>{
+        const useTestQuery = useCreateS3QueryHook(MockCommand, "testOperation");
+        validateFactoryHook(useTestQuery, "testOperation");
+        const { result } = renderHook(()=>useTestQuery({
+                testParam: "value"
+            }), {
+            wrapper: createQueryWrapper()
+        });
+        validateHookResult(result.current, "query");
+    });
+    it("should accept and forward query options correctly", ()=>{
+        const useTestQuery = useCreateS3QueryHook(MockCommand, "testOperation");
+        const customOptions = {
+            enabled: false,
+            staleTime: 5000,
+            refetchOnWindowFocus: false
+        };
+        const { result } = renderHook(()=>useTestQuery({
+                testParam: "value"
+            }, customOptions), {
+            wrapper: createQueryWrapper()
+        });
+        expect(result.current.fetchStatus).toBe("idle");
+        expect(result.current.isLoading).toBe(false);
+    });
+    it("should handle successful query execution", async ()=>{
+        const mockResponse = {
+            data: "test-response",
+            status: "success"
+        };
+        mockS3Client.send.mockResolvedValue(mockResponse);
+        const useTestQuery = useCreateS3QueryHook(MockCommand, "testOperation");
+        const { result } = renderHook(()=>useTestQuery({
+                Bucket: "test-bucket",
+                Key: "test-key"
+            }), {
+            wrapper: createQueryWrapper()
+        });
+        await waitFor(()=>{
+            expect(result.current.isSuccess).toBe(true);
+        });
+        expect(result.current.data).toEqual(mockResponse);
+        expect(mockS3Client.send).toHaveBeenCalledWith(expect.any(MockCommand), expect.objectContaining({
+            abortSignal: expect.any(AbortSignal)
+        }));
+    });
+    it("should handle query errors with proper context", async ()=>{
+        const mockError = new Error("S3 Service Error");
+        const enhancedError = new Error("Enhanced S3 Service Error");
+        mockS3Client.send.mockRejectedValue(mockError);
+        mockCreateS3OperationError.mockReturnValue(enhancedError);
+        const useTestQuery = useCreateS3QueryHook(MockCommand, "testOperation");
+        const { result } = renderHook(()=>useTestQuery({
+                Bucket: "test-bucket",
+                Key: "test-key"
+            }), {
+            wrapper: createQueryWrapper()
+        });
+        await waitFor(()=>{
+            expect(result.current.isError).toBe(true);
+        });
+        expect(result.current.error).toBe(enhancedError);
+        expect(mockCreateS3OperationError).toHaveBeenCalledWith(mockError, "testOperation", "test-bucket");
+    });
+    it("should handle parameter validation correctly", ()=>{
+        const useTestQuery = useCreateS3QueryHook(MockCommand, "testOperation");
+        const { result: invalidResult } = renderHook(()=>useTestQuery({
+                Bucket: "test",
+                Key: void 0
+            }), {
+            wrapper: createQueryWrapper()
+        });
+        expect(invalidResult.current.fetchStatus).toBe("idle");
+        const { result: validResult } = renderHook(()=>useTestQuery({
+                Bucket: "test",
+                Key: "valid-key"
+            }), {
+            wrapper: createQueryWrapper()
+        });
+        expect(validResult.current.fetchStatus).not.toBe("idle");
+    });
+    it("should handle empty string parameters correctly", ()=>{
+        const useTestQuery = useCreateS3QueryHook(MockCommand, "testOperation");
+        const { result: emptyResult } = renderHook(()=>useTestQuery({
+                Bucket: "test",
+                Key: ""
+            }), {
+            wrapper: createQueryWrapper()
+        });
+        expect(emptyResult.current.fetchStatus).not.toBe("idle");
+    });
+    it("should pass AbortSignal correctly to S3 client", async ()=>{
+        let capturedAbortSignal;
+        mockS3Client.send.mockImplementation((_command, options)=>{
+            capturedAbortSignal = options?.abortSignal;
+            return Promise.resolve({
+                success: true
+            });
+        });
+        const useTestQuery = useCreateS3QueryHook(MockCommand, "testOperation");
+        const { result } = renderHook(()=>useTestQuery({
+                Bucket: "test",
+                Key: "test"
+            }), {
+            wrapper: createQueryWrapper()
+        });
+        await waitFor(()=>{
+            expect(result.current.isSuccess).toBe(true);
+        });
+        expect(capturedAbortSignal).toBeInstanceOf(AbortSignal);
+        expect(capturedAbortSignal?.aborted).toBe(false);
+    });
+    it("should return empty config for supported operations when NOT_FOUND error occurs", async ()=>{
+        const error = new Error("Configuration does not exist");
+        error.name = "NoSuchConfiguration";
+        error.$metadata = {
+            httpStatusCode: 404
+        };
+        mockS3Client.send.mockRejectedValueOnce(error);
+        mockIsNotFoundError.mockReturnValueOnce(true);
+        const useTestQuery = useCreateS3QueryHook(MockCommand, "GetBucketLifecycleConfiguration");
+        const { result } = renderHook(()=>useTestQuery({
+                Bucket: "test-bucket"
+            }), {
+            wrapper: createQueryWrapper()
+        });
+        await waitFor(()=>{
+            expect(result.current.isSuccess).toBe(true);
+        });
+        expect(result.current.data).toBeDefined();
+        expect(mockIsNotFoundError).toHaveBeenCalledWith(error);
+    });
+    it("should throw error when NOT_FOUND occurs for unsupported operations", async ()=>{
+        const error = new Error("Bucket not found");
+        error.name = "NoSuchBucket";
+        error.$metadata = {
+            httpStatusCode: 404
+        };
+        const enhancedError = new Error("Enhanced error");
+        mockS3Client.send.mockRejectedValueOnce(error);
+        mockIsNotFoundError.mockReturnValueOnce(true);
+        mockCreateS3OperationError.mockReturnValueOnce(enhancedError);
+        const useTestQuery = useCreateS3QueryHook(MockCommand, "GetBucketAcl");
+        const { result } = renderHook(()=>useTestQuery({
+                Bucket: "test-bucket"
+            }), {
+            wrapper: createQueryWrapper()
+        });
+        await waitFor(()=>{
+            expect(result.current.isError).toBe(true);
+        });
+        expect(result.current.error).toBe(enhancedError);
+        expect(mockIsNotFoundError).toHaveBeenCalledWith(error);
+    });
+});

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

@@ -0,0 +1,18 @@
+/**
+ * S3 Hook Factory Functions
+ *
+ * These factory functions provide a standardized way to create React Query hooks
+ * for S3 operations, eliminating code duplication and ensuring consistent patterns
+ * across all S3 hooks.
+ *
+ * The factories handle:
+ * - Standard error handling with EnhancedS3Error
+ * - Consistent query key patterns
+ * - Automatic query invalidation for mutations
+ * - AbortSignal support for cancellation
+ * - Bucket/object context extraction for errors
+ */
+export { useCreateS3QueryHook } from "./useCreateS3QueryHook";
+export { useCreateS3MutationHook, useCreateS3FunctionMutationHook, } from "./useCreateS3MutationHook";
+export { useCreateS3InfiniteQueryHook } from "./useCreateS3InfiniteQueryHook";
+export { useCreateS3LoginHook } from "./useCreateS3LoginHook";

package/dist/hooks/factories/index.js

@@ -0,0 +1,5 @@
+import { useCreateS3QueryHook } from "./useCreateS3QueryHook.js";
+import { useCreateS3FunctionMutationHook, useCreateS3MutationHook } from "./useCreateS3MutationHook.js";
+import { useCreateS3InfiniteQueryHook } from "./useCreateS3InfiniteQueryHook.js";
+import { useCreateS3LoginHook } from "./useCreateS3LoginHook.js";
+export { useCreateS3FunctionMutationHook, useCreateS3InfiniteQueryHook, useCreateS3LoginHook, useCreateS3MutationHook, useCreateS3QueryHook };

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

@@ -0,0 +1,13 @@
+import { UseInfiniteQueryOptions, UseInfiniteQueryResult } from "@tanstack/react-query";
+import { EnhancedS3Error } from "../../utils/errorHandling";
+/**
+ * Factory function for creating S3 infinite query hooks
+ *
+ * This factory handles S3 operations that return paginated results and need
+ * infinite scroll support. It automatically handles:
+ * - Error handling with enhanced S3 errors
+ * - Standard query key patterns
+ * - AbortSignal support for cancellation
+ * - Pagination parameters and logic
+ */
+export declare function useCreateS3InfiniteQueryHook<TInput extends object, TOutput>(Command: new (input: TInput) => any, operationName: string): (params: TInput, options?: Partial<UseInfiniteQueryOptions<TOutput, EnhancedS3Error, TOutput, (string | TInput)[], string | undefined>>) => UseInfiniteQueryResult<TOutput, EnhancedS3Error>;

package/dist/hooks/factories/useCreateS3InfiniteQueryHook.js

@@ -0,0 +1,76 @@
+import { useInfiniteQuery } from "@tanstack/react-query";
+import { useS3Client } from "../useS3Client.js";
+import { createS3OperationError, shouldRetryError } from "../../utils/errorHandling.js";
+function useCreateS3InfiniteQueryHook(Command, operationName) {
+    return (params, options)=>{
+        const s3Client = useS3Client();
+        const queryOptions = {
+            queryKey: [
+                operationName,
+                params
+            ],
+            queryFn: async ({ pageParam, signal })=>{
+                try {
+                    const command = new Command({
+                        ...params,
+                        ...pageParam ? getPaginationParams(operationName, pageParam) : {}
+                    });
+                    const response = await s3Client.send(command, {
+                        abortSignal: signal
+                    });
+                    return response;
+                } catch (error) {
+                    const bucketName = "Bucket" in params ? params.Bucket : void 0;
+                    throw createS3OperationError(error, operationName, bucketName);
+                }
+            },
+            retry: options?.retry ?? ((failureCount, error)=>shouldRetryError(error, failureCount)),
+            initialPageParam: void 0,
+            getNextPageParam: (lastPage)=>getNextPageToken(operationName, lastPage),
+            enabled: params ? Object.entries(params).every(([key, value])=>{
+                if ("Prefix" === key) return void 0 !== value;
+                return void 0 !== value && "" !== value;
+            }) : true,
+            ...options
+        };
+        return useInfiniteQuery(queryOptions);
+    };
+}
+function getPaginationParams(operationName, pageParam) {
+    switch(operationName){
+        case "ListObjects":
+            return {
+                ContinuationToken: pageParam
+            };
+        case "ListObjectVersions":
+            if (pageParam.includes("|")) {
+                const [keyMarker, versionIdMarker] = pageParam.split("|");
+                return {
+                    ...keyMarker && "" !== keyMarker ? {
+                        KeyMarker: keyMarker
+                    } : {},
+                    ...versionIdMarker && "" !== versionIdMarker ? {
+                        VersionIdMarker: versionIdMarker
+                    } : {}
+                };
+            }
+            return {
+                KeyMarker: pageParam
+            };
+        default:
+            return {
+                ContinuationToken: pageParam
+            };
+    }
+}
+function getNextPageToken(operationName, lastPage) {
+    switch(operationName){
+        case "ListObjects":
+            return lastPage.IsTruncated ? lastPage.NextContinuationToken : void 0;
+        case "ListObjectVersions":
+            return lastPage.IsTruncated && (lastPage.NextKeyMarker || lastPage.NextVersionIdMarker) ? `${lastPage.NextKeyMarker || ""}|${lastPage.NextVersionIdMarker || ""}` : void 0;
+        default:
+            return lastPage.IsTruncated ? lastPage.NextContinuationToken : void 0;
+    }
+}
+export { useCreateS3InfiniteQueryHook };

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

@@ -0,0 +1,8 @@
+import { UseMutationOptions, UseMutationResult } from "@tanstack/react-query";
+import { EnhancedS3Error } from "../../utils/errorHandling";
+/**
+ * Factory function for creating S3 login mutation hooks
+ * This factory handles the special authentication case where we need
+ * to create a new S3 client with the provided credentials
+ */
+export declare function useCreateS3LoginHook<TInput extends object, TOutput>(_Command: new (input: TInput) => any, operationName: string): (options?: Omit<UseMutationOptions<TOutput, EnhancedS3Error, TInput>, "mutationFn">) => UseMutationResult<TOutput, EnhancedS3Error, TInput>;