@uploadista/data-store-s3 0.0.3

package/dist/services/__mocks__/s3-client-mock.service.d.ts

@@ -0,0 +1,44 @@
+import { Effect, Layer } from "effect";
+import { S3ClientService } from "../s3-client.service";
+export interface MockS3Config {
+    simulateLatency?: number;
+    errorRate?: number;
+    uploadFailureRate?: number;
+    maxObjectSize?: number;
+    enableErrorInjection?: boolean;
+}
+interface MockStorage {
+    objects: Map<string, Uint8Array>;
+    multipartUploads: Map<string, {
+        uploadId: string;
+        parts: Map<number, {
+            etag: string;
+            data: Uint8Array;
+        }>;
+        metadata: {
+            contentType?: string;
+            cacheControl?: string;
+            key: string;
+            bucket: string;
+        };
+    }>;
+    incompleteParts: Map<string, Uint8Array>;
+}
+interface MockMetrics {
+    operationCounts: Map<string, number>;
+    lastOperation?: string;
+    totalBytesUploaded: number;
+    totalBytesDownloaded: number;
+}
+export interface MockS3TestMethods {
+    readonly setConfig: (config: Partial<MockS3Config>) => Effect.Effect<void>;
+    readonly clearStorage: () => Effect.Effect<void>;
+    readonly injectError: (operation: string, error: Error) => Effect.Effect<void>;
+    readonly clearError: (operation: string) => Effect.Effect<void>;
+    readonly getMetrics: () => Effect.Effect<MockMetrics>;
+    readonly getStorage: () => Effect.Effect<MockStorage>;
+}
+export declare const makeMockS3ClientService: (bucket: string, initialConfig?: MockS3Config) => Effect.Effect<S3ClientService["Type"] & MockS3TestMethods, never>;
+export declare const MockS3ClientLayer: (bucket: string, config?: MockS3Config) => Layer.Layer<S3ClientService, never, never>;
+export {};
+//# sourceMappingURL=s3-client-mock.service.d.ts.map

package/dist/services/__mocks__/s3-client-mock.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"s3-client-mock.service.d.ts","sourceRoot":"","sources":["../../../src/services/__mocks__/s3-client-mock.service.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,KAAK,EAAO,MAAM,QAAQ,CAAC;AAE5C,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAGvD,MAAM,WAAW,YAAY;IAC3B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC;AAGD,UAAU,WAAW;IACnB,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IACjC,gBAAgB,EAAE,GAAG,CACnB,MAAM,EACN;QACE,QAAQ,EAAE,MAAM,CAAC;QACjB,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,UAAU,CAAA;SAAE,CAAC,CAAC;QACvD,QAAQ,EAAE;YACR,WAAW,CAAC,EAAE,MAAM,CAAC;YACrB,YAAY,CAAC,EAAE,MAAM,CAAC;YACtB,GAAG,EAAE,MAAM,CAAC;YACZ,MAAM,EAAE,MAAM,CAAC;SAChB,CAAC;KACH,CACF,CAAC;IACF,eAAe,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;CAC1C;AAGD,UAAU,WAAW;IACnB,eAAe,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,oBAAoB,EAAE,MAAM,CAAC;CAC9B;AAGD,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,SAAS,EAAE,CAAC,MAAM,EAAE,OAAO,CAAC,YAAY,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAC3E,QAAQ,CAAC,YAAY,EAAE,MAAM,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IACjD,QAAQ,CAAC,WAAW,EAAE,CACpB,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,KAAK,KACT,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IACzB,QAAQ,CAAC,UAAU,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAChE,QAAQ,CAAC,UAAU,EAAE,MAAM,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;IACtD,QAAQ,CAAC,UAAU,EAAE,MAAM,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;CACvD;AAED,eAAO,MAAM,uBAAuB,GAClC,QAAQ,MAAM,EACd,gBAAe,YAAiB,KAC/B,MAAM,CAAC,MAAM,CAAC,eAAe,CAAC,MAAM,CAAC,GAAG,iBAAiB,EAAE,KAAK,CA8hBlE,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,QAAQ,MAAM,EAAE,SAAS,YAAY,+CACC,CAAC"}

package/dist/services/__mocks__/s3-client-mock.service.js

@@ -0,0 +1,379 @@
+import { UploadistaError } from "@uploadista/core/errors";
+import { Effect, Layer, Ref } from "effect";
+import { S3ClientService } from "../s3-client.service";
+export const makeMockS3ClientService = (bucket, initialConfig = {}) => {
+    return Effect.gen(function* () {
+        const storageRef = yield* Ref.make({
+            objects: new Map(),
+            multipartUploads: new Map(),
+            incompleteParts: new Map(),
+        });
+        const metricsRef = yield* Ref.make({
+            operationCounts: new Map(),
+            totalBytesUploaded: 0,
+            totalBytesDownloaded: 0,
+        });
+        const configRef = yield* Ref.make(initialConfig);
+        const errorInjectionRef = yield* Ref.make(new Map());
+        const simulateLatency = () => Effect.gen(function* () {
+            const config = yield* Ref.get(configRef);
+            if (config.simulateLatency && config.simulateLatency > 0) {
+                yield* Effect.sleep(`${config.simulateLatency} millis`);
+            }
+        });
+        const recordOperation = (operation) => Effect.gen(function* () {
+            yield* Ref.update(metricsRef, (metrics) => ({
+                ...metrics,
+                lastOperation: operation,
+                operationCounts: new Map([
+                    ...metrics.operationCounts,
+                    [operation, (metrics.operationCounts.get(operation) || 0) + 1],
+                ]),
+            }));
+        });
+        const checkForInjectedError = (operation) => Effect.gen(function* () {
+            const errorMap = yield* Ref.get(errorInjectionRef);
+            const error = errorMap.get(operation);
+            if (error) {
+                // Don't remove the error - let it persist for retries
+                // Tests should clear errors explicitly when done
+                yield* Effect.fail(UploadistaError.fromCode("FILE_WRITE_ERROR", error));
+            }
+        });
+        const maybeInjectRandomError = (operation) => Effect.gen(function* () {
+            const config = yield* Ref.get(configRef);
+            if (config.errorRate && Math.random() < config.errorRate) {
+                yield* Effect.fail(UploadistaError.fromCode("FILE_WRITE_ERROR", new Error(`Random error in ${operation}`)));
+            }
+        });
+        const generateETag = (data) => {
+            // Simple hash for ETag simulation
+            let hash = 0;
+            for (let i = 0; i < data.length; i++) {
+                hash = ((hash << 5) - hash + data[i]) & 0xffffffff;
+            }
+            return `"${Math.abs(hash).toString(16)}"`;
+        };
+        const generateUploadId = () => {
+            return `upload-${Date.now()}-${Math.random().toString(36).substring(2)}`;
+        };
+        // Implementation of service methods
+        const setConfig = (config) => Ref.update(configRef, (current) => ({ ...current, ...config }));
+        const clearStorage = () => Effect.gen(function* () {
+            yield* Ref.set(storageRef, {
+                objects: new Map(),
+                multipartUploads: new Map(),
+                incompleteParts: new Map(),
+            });
+            // Also clear injected errors
+            yield* Ref.set(errorInjectionRef, new Map());
+            // Reset metrics
+            yield* Ref.set(metricsRef, {
+                operationCounts: new Map(),
+                totalBytesUploaded: 0,
+                totalBytesDownloaded: 0,
+            });
+        });
+        const injectError = (operation, error) => Ref.update(errorInjectionRef, (map) => new Map([...map, [operation, error]]));
+        const clearError = (operation) => Ref.update(errorInjectionRef, (map) => {
+            const newMap = new Map(map);
+            newMap.delete(operation);
+            return newMap;
+        });
+        const getMetrics = () => Ref.get(metricsRef);
+        const getObject = (key) => Effect.gen(function* () {
+            yield* simulateLatency();
+            yield* recordOperation("getObject");
+            yield* checkForInjectedError("getObject");
+            yield* maybeInjectRandomError("getObject");
+            const storage = yield* Ref.get(storageRef);
+            const data = storage.objects.get(key);
+            if (!data) {
+                yield* Effect.fail(UploadistaError.fromCode("FILE_NOT_FOUND", new Error(`Object not found: ${key}`)));
+                return new ReadableStream(); // Never reached but helps TypeScript
+            }
+            yield* Ref.update(metricsRef, (metrics) => ({
+                ...metrics,
+                totalBytesDownloaded: metrics.totalBytesDownloaded + data.length,
+            }));
+            // Convert Uint8Array to ReadableStream
+            return new ReadableStream({
+                start(controller) {
+                    controller.enqueue(data);
+                    controller.close();
+                },
+            });
+        });
+        const headObject = (key) => Effect.gen(function* () {
+            yield* simulateLatency();
+            yield* recordOperation("headObject");
+            yield* checkForInjectedError("headObject");
+            const storage = yield* Ref.get(storageRef);
+            const data = storage.objects.get(key);
+            return data?.length;
+        });
+        const putObject = (key, body) => Effect.gen(function* () {
+            yield* simulateLatency();
+            yield* recordOperation("putObject");
+            yield* checkForInjectedError("putObject");
+            yield* maybeInjectRandomError("putObject");
+            const config = yield* Ref.get(configRef);
+            if (config.maxObjectSize && body.length > config.maxObjectSize) {
+                yield* Effect.fail(UploadistaError.fromCode("FILE_WRITE_ERROR", new Error(`Object size ${body.length} exceeds maximum ${config.maxObjectSize}`)));
+            }
+            yield* Ref.update(storageRef, (storage) => ({
+                ...storage,
+                objects: new Map([...storage.objects, [key, body]]),
+            }));
+            yield* Ref.update(metricsRef, (metrics) => ({
+                ...metrics,
+                totalBytesUploaded: metrics.totalBytesUploaded + body.length,
+            }));
+            return generateETag(body);
+        });
+        const deleteObject = (key) => Effect.gen(function* () {
+            yield* simulateLatency();
+            yield* recordOperation("deleteObject");
+            yield* checkForInjectedError("deleteObject");
+            yield* Ref.update(storageRef, (storage) => {
+                const newObjects = new Map(storage.objects);
+                newObjects.delete(key);
+                return { ...storage, objects: newObjects };
+            });
+        });
+        const deleteObjects = (keys) => Effect.gen(function* () {
+            yield* simulateLatency();
+            yield* recordOperation("deleteObjects");
+            yield* checkForInjectedError("deleteObjects");
+            yield* Ref.update(storageRef, (storage) => {
+                const newObjects = new Map(storage.objects);
+                for (const key of keys) {
+                    newObjects.delete(key);
+                }
+                return { ...storage, objects: newObjects };
+            });
+            return {
+                $metadata: {},
+                Deleted: keys.map((key) => ({ Key: key })),
+                Errors: [],
+            };
+        });
+        const createMultipartUpload = (context) => Effect.gen(function* () {
+            yield* simulateLatency();
+            yield* recordOperation("createMultipartUpload");
+            yield* checkForInjectedError("createMultipartUpload");
+            const uploadId = generateUploadId();
+            yield* Ref.update(storageRef, (storage) => ({
+                ...storage,
+                multipartUploads: new Map([
+                    ...storage.multipartUploads,
+                    [
+                        uploadId,
+                        {
+                            uploadId,
+                            parts: new Map(),
+                            metadata: {
+                                contentType: context.contentType,
+                                cacheControl: context.cacheControl,
+                                key: context.key,
+                                bucket: context.bucket,
+                            },
+                        },
+                    ],
+                ]),
+            }));
+            return {
+                uploadId,
+                bucket: context.bucket,
+                key: context.key,
+            };
+        });
+        const uploadPart = (context) => Effect.gen(function* () {
+            yield* simulateLatency();
+            yield* recordOperation("uploadPart");
+            yield* checkForInjectedError("uploadPart");
+            const config = yield* Ref.get(configRef);
+            if (config.uploadFailureRate &&
+                Math.random() < config.uploadFailureRate) {
+                yield* Effect.fail(UploadistaError.fromCode("FILE_WRITE_ERROR", new Error(`Upload failed for part ${context.partNumber}`)));
+            }
+            const storage = yield* Ref.get(storageRef);
+            const upload = storage.multipartUploads.get(context.uploadId);
+            if (!upload) {
+                return yield* Effect.fail(UploadistaError.fromCode("FILE_NOT_FOUND", new Error(`Upload not found: ${context.uploadId}`)));
+            }
+            const etag = generateETag(context.data);
+            upload.parts.set(context.partNumber, {
+                etag,
+                data: context.data,
+            });
+            yield* Ref.update(metricsRef, (metrics) => ({
+                ...metrics,
+                totalBytesUploaded: metrics.totalBytesUploaded + context.data.length,
+            }));
+            return etag;
+        });
+        const completeMultipartUpload = (context, parts) => Effect.gen(function* () {
+            yield* simulateLatency();
+            yield* recordOperation("completeMultipartUpload");
+            yield* checkForInjectedError("completeMultipartUpload");
+            const storage = yield* Ref.get(storageRef);
+            const upload = storage.multipartUploads.get(context.uploadId);
+            if (!upload) {
+                yield* Effect.fail(UploadistaError.fromCode("FILE_NOT_FOUND", new Error(`Upload not found: ${context.uploadId}`)));
+                return; // This will never execute but helps TypeScript
+            }
+            // Validate all parts are present
+            for (const part of parts) {
+                if (!part.PartNumber || !upload.parts.has(part.PartNumber)) {
+                    yield* Effect.fail(UploadistaError.fromCode("FILE_WRITE_ERROR", new Error(`Part ${part.PartNumber} not found`)));
+                }
+            }
+            // Combine all parts into final object
+            const sortedParts = parts
+                .sort((a, b) => (a.PartNumber || 0) - (b.PartNumber || 0))
+                .map((part) => {
+                const partData = upload.parts.get(part.PartNumber || 0);
+                if (!partData)
+                    throw new Error(`Part ${part.PartNumber} not found`);
+                return partData.data;
+            });
+            const totalLength = sortedParts.reduce((sum, part) => sum + part.length, 0);
+            const combinedData = new Uint8Array(totalLength);
+            let offset = 0;
+            for (const part of sortedParts) {
+                combinedData.set(part, offset);
+                offset += part.length;
+            }
+            // Store the final object
+            yield* Ref.update(storageRef, (storage) => ({
+                ...storage,
+                objects: new Map([...storage.objects, [context.key, combinedData]]),
+                multipartUploads: new Map([...storage.multipartUploads].filter(([id]) => id !== context.uploadId)),
+            }));
+            return `https://${context.bucket}.s3.amazonaws.com/${context.key}`;
+        });
+        const abortMultipartUpload = (context) => Effect.gen(function* () {
+            yield* simulateLatency();
+            yield* recordOperation("abortMultipartUpload");
+            yield* checkForInjectedError("abortMultipartUpload");
+            yield* Ref.update(storageRef, (storage) => ({
+                ...storage,
+                multipartUploads: new Map([...storage.multipartUploads].filter(([id]) => id !== context.uploadId)),
+            }));
+        });
+        const listParts = (context) => Effect.gen(function* () {
+            yield* simulateLatency();
+            yield* recordOperation("listParts");
+            yield* checkForInjectedError("listParts");
+            const storage = yield* Ref.get(storageRef);
+            const upload = storage.multipartUploads.get(context.uploadId);
+            if (!upload) {
+                return yield* Effect.fail(UploadistaError.fromCode("FILE_NOT_FOUND", new Error(`Upload not found: ${context.uploadId}`)));
+            }
+            const parts = Array.from(upload.parts.entries())
+                .map(([partNumber, part]) => ({
+                PartNumber: partNumber,
+                ETag: part.etag,
+                Size: part.data.length,
+            }))
+                .sort((a, b) => (a.PartNumber || 0) - (b.PartNumber || 0));
+            return {
+                parts,
+                isTruncated: false,
+                nextPartNumberMarker: undefined,
+            };
+        });
+        const listMultipartUploads = (_keyMarker, _uploadIdMarker) => Effect.gen(function* () {
+            yield* simulateLatency();
+            yield* recordOperation("listMultipartUploads");
+            yield* checkForInjectedError("listMultipartUploads");
+            const storage = yield* Ref.get(storageRef);
+            const uploads = Array.from(storage.multipartUploads.values()).map((upload) => ({
+                Key: upload.metadata.key,
+                UploadId: upload.uploadId,
+                Initiated: new Date(),
+            }));
+            return {
+                Uploads: uploads,
+                IsTruncated: false,
+            };
+        });
+        const getIncompletePart = (id) => Effect.gen(function* () {
+            yield* simulateLatency();
+            yield* recordOperation("getIncompletePart");
+            const storage = yield* Ref.get(storageRef);
+            const data = storage.incompleteParts.get(`${id}.part`);
+            if (!data) {
+                return undefined;
+            }
+            return new ReadableStream({
+                start(controller) {
+                    controller.enqueue(data);
+                    controller.close();
+                },
+            });
+        });
+        const getIncompletePartSize = (id) => Effect.gen(function* () {
+            yield* simulateLatency();
+            yield* recordOperation("getIncompletePartSize");
+            const storage = yield* Ref.get(storageRef);
+            const data = storage.incompleteParts.get(`${id}.part`);
+            return data?.length;
+        });
+        const putIncompletePart = (id, data) => Effect.gen(function* () {
+            yield* simulateLatency();
+            yield* recordOperation("putIncompletePart");
+            yield* checkForInjectedError("putIncompletePart");
+            yield* Ref.update(storageRef, (storage) => ({
+                ...storage,
+                incompleteParts: new Map([
+                    ...storage.incompleteParts,
+                    [`${id}.part`, data],
+                ]),
+            }));
+            yield* Ref.update(metricsRef, (metrics) => ({
+                ...metrics,
+                totalBytesUploaded: metrics.totalBytesUploaded + data.length,
+            }));
+            return generateETag(data);
+        });
+        const deleteIncompletePart = (id) => Effect.gen(function* () {
+            yield* simulateLatency();
+            yield* recordOperation("deleteIncompletePart");
+            yield* Ref.update(storageRef, (storage) => {
+                const newIncompleteParts = new Map(storage.incompleteParts);
+                newIncompleteParts.delete(`${id}.part`);
+                return { ...storage, incompleteParts: newIncompleteParts };
+            });
+        });
+        const getStorage = () => Ref.get(storageRef);
+        return {
+            bucket,
+            // S3ClientService methods
+            getObject,
+            headObject,
+            putObject,
+            deleteObject,
+            deleteObjects,
+            createMultipartUpload,
+            uploadPart,
+            completeMultipartUpload,
+            abortMultipartUpload,
+            listParts,
+            listMultipartUploads,
+            getIncompletePart,
+            getIncompletePartSize,
+            putIncompletePart,
+            deleteIncompletePart,
+            // Mock-specific test methods
+            setConfig,
+            clearStorage,
+            injectError,
+            clearError,
+            getMetrics,
+            getStorage,
+        };
+    });
+};
+export const MockS3ClientLayer = (bucket, config) => Layer.effect(S3ClientService, makeMockS3ClientService(bucket, config));

package/dist/services/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./s3-client.service";
+//# sourceMappingURL=index.d.ts.map

package/dist/services/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/services/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC"}

package/dist/services/index.js

@@ -0,0 +1 @@
+export * from "./s3-client.service";

package/dist/services/s3-client.service.d.ts

@@ -0,0 +1,68 @@
+import type AWS from "@aws-sdk/client-s3";
+import type { S3ClientConfig } from "@aws-sdk/client-s3";
+import type { UploadistaError } from "@uploadista/core/errors";
+import { Context, Effect, Layer } from "effect";
+import type { MultipartUploadInfo, S3OperationContext } from "../types";
+declare const S3ClientService_base: Context.TagClass<S3ClientService, "S3ClientService", {
+    readonly bucket: string;
+    readonly getObject: (key: string) => Effect.Effect<ReadableStream, UploadistaError>;
+    readonly headObject: (key: string) => Effect.Effect<number | undefined, UploadistaError>;
+    readonly putObject: (key: string, body: Uint8Array) => Effect.Effect<string, UploadistaError>;
+    readonly deleteObject: (key: string) => Effect.Effect<void, UploadistaError>;
+    readonly deleteObjects: (keys: string[]) => Effect.Effect<AWS.DeleteObjectsCommandOutput, UploadistaError>;
+    readonly createMultipartUpload: (context: S3OperationContext) => Effect.Effect<MultipartUploadInfo, UploadistaError>;
+    readonly uploadPart: (context: S3OperationContext & {
+        partNumber: number;
+        data: Uint8Array;
+    }) => Effect.Effect<string, UploadistaError>;
+    readonly completeMultipartUpload: (context: S3OperationContext, parts: Array<AWS.Part>) => Effect.Effect<string | undefined, UploadistaError>;
+    readonly abortMultipartUpload: (context: S3OperationContext) => Effect.Effect<void, UploadistaError>;
+    readonly listParts: (context: S3OperationContext & {
+        partNumberMarker?: string;
+    }) => Effect.Effect<{
+        parts: AWS.Part[];
+        isTruncated: boolean;
+        nextPartNumberMarker?: string;
+    }, UploadistaError>;
+    readonly listMultipartUploads: (keyMarker?: string, uploadIdMarker?: string) => Effect.Effect<AWS.ListMultipartUploadsCommandOutput, UploadistaError>;
+    readonly getIncompletePart: (id: string) => Effect.Effect<ReadableStream | undefined, UploadistaError>;
+    readonly getIncompletePartSize: (id: string) => Effect.Effect<number | undefined, UploadistaError>;
+    readonly putIncompletePart: (id: string, data: Uint8Array) => Effect.Effect<string, UploadistaError>;
+    readonly deleteIncompletePart: (id: string) => Effect.Effect<void, UploadistaError>;
+}>;
+export declare class S3ClientService extends S3ClientService_base {
+}
+export declare const makeS3ClientService: (s3ClientConfig: S3ClientConfig, bucket: string) => {
+    bucket: string;
+    getObject: (key: string) => Effect.Effect<ReadableStream<any>, UploadistaError, never>;
+    headObject: (key: string) => Effect.Effect<number | undefined, UploadistaError, never>;
+    putObject: (key: string, body: Uint8Array) => Effect.Effect<string, UploadistaError, never>;
+    deleteObject: (key: string) => Effect.Effect<void, UploadistaError, never>;
+    deleteObjects: (keys: string[]) => Effect.Effect<AWS.DeleteObjectsCommandOutput, UploadistaError, never>;
+    createMultipartUpload: (context: S3OperationContext) => Effect.Effect<{
+        uploadId: string;
+        bucket: string;
+        key: string;
+    }, UploadistaError, never>;
+    uploadPart: (context: S3OperationContext & {
+        partNumber: number;
+        data: Uint8Array;
+    }) => Effect.Effect<string, UploadistaError, never>;
+    completeMultipartUpload: (context: S3OperationContext, parts: Array<AWS.Part>) => Effect.Effect<string | undefined, UploadistaError, never>;
+    abortMultipartUpload: (context: S3OperationContext) => Effect.Effect<void, UploadistaError, never>;
+    listParts: (context: S3OperationContext & {
+        partNumberMarker?: string;
+    }) => Effect.Effect<{
+        parts: AWS.Part[];
+        isTruncated: boolean;
+        nextPartNumberMarker: string | undefined;
+    }, UploadistaError, never>;
+    listMultipartUploads: (keyMarker?: string, uploadIdMarker?: string) => Effect.Effect<AWS.ListMultipartUploadsCommandOutput, UploadistaError, never>;
+    getIncompletePart: (id: string) => Effect.Effect<ReadableStream<any> | undefined, UploadistaError, never>;
+    getIncompletePartSize: (id: string) => Effect.Effect<number | undefined, UploadistaError, never>;
+    putIncompletePart: (id: string, data: Uint8Array) => Effect.Effect<string, UploadistaError, never>;
+    deleteIncompletePart: (id: string) => Effect.Effect<void, UploadistaError, never>;
+};
+export declare const S3ClientLayer: (s3ClientConfig: S3ClientConfig, bucket: string) => Layer.Layer<S3ClientService, never, never>;
+export {};
+//# sourceMappingURL=s3-client.service.d.ts.map

package/dist/services/s3-client.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"s3-client.service.d.ts","sourceRoot":"","sources":["../../src/services/s3-client.service.ts"],"names":[],"mappings":"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"}