@furystack/s3-blob-store 1.0.0

package/esm/s3-blob-store.unit.spec.js

@@ -0,0 +1,892 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { Readable } from 'node:stream';
+import { DeleteObjectCommand, GetObjectCommand, HeadObjectCommand, ListObjectsV2Command, PutBucketLifecycleConfigurationCommand, PutObjectCommand, S3Client, } from '@aws-sdk/client-s3';
+import { describe, expect, it, vi } from 'vitest';
+import { BlobStoreError } from '@furystack/blob-store';
+import { S3BlobStore } from './s3-blob-store.js';
+class FakeS3Client {
+    handlers;
+    sent = [];
+    lifecycleAttempts = 0;
+    constructor(handlers) {
+        this.handlers = handlers;
+    }
+    send = vi.fn(async (command) => {
+        this.sent.push({ name: command.constructor.name, input: command.input });
+        if (command.constructor.name === 'PutBucketLifecycleConfigurationCommand') {
+            this.lifecycleAttempts += 1;
+        }
+        const handler = this.handlers[command.constructor.name];
+        if (!handler) {
+            throw new Error(`No handler for ${command.constructor.name}`);
+        }
+        return handler(command.input);
+    });
+}
+const asClient = (fake) => fake;
+const makeNoSuchKey = () => {
+    const err = new Error('NoSuchKey');
+    err.name = 'NoSuchKey';
+    err.$metadata = { httpStatusCode: 404 };
+    return err;
+};
+const decode = (data) => new TextDecoder().decode(data);
+const collect = async (stream) => {
+    const reader = stream.getReader();
+    const chunks = [];
+    for (;;) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        chunks.push(value);
+    }
+    reader.releaseLock();
+    const total = chunks.reduce((acc, c) => acc + c.byteLength, 0);
+    const merged = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        merged.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return merged;
+};
+describe('S3BlobStore', () => {
+    describe('constructor', () => {
+        it('throws on missing bucket', () => {
+            expect(() => new S3BlobStore({ client: {}, bucket: '' })).toThrow(/non-empty `bucket`/);
+        });
+        it('defaults storeName to "s3"', () => {
+            const env_1 = { stack: [], error: void 0, hasError: false };
+            try {
+                const store = __addDisposableResource(env_1, new S3BlobStore({ client: {}, bucket: 'b' }), false);
+                expect(store.storeName).toBe('s3');
+            }
+            catch (e_1) {
+                env_1.error = e_1;
+                env_1.hasError = true;
+            }
+            finally {
+                __disposeResources(env_1);
+            }
+        });
+        it('honours a custom storeName', () => {
+            const env_2 = { stack: [], error: void 0, hasError: false };
+            try {
+                const store = __addDisposableResource(env_2, new S3BlobStore({ client: {}, bucket: 'b', name: 'tenant-a' }), false);
+                expect(store.storeName).toBe('tenant-a');
+            }
+            catch (e_2) {
+                env_2.error = e_2;
+                env_2.hasError = true;
+            }
+            finally {
+                __disposeResources(env_2);
+            }
+        });
+        it('declares S3-shaped capabilities', () => {
+            const env_3 = { stack: [], error: void 0, hasError: false };
+            try {
+                const store = __addDisposableResource(env_3, new S3BlobStore({ client: {}, bucket: 'b' }), false);
+                expect(store.capabilities).toMatchObject({
+                    presignedUrls: true,
+                    multipart: false,
+                    range: true,
+                    crossNodeAccessible: true,
+                });
+            }
+            catch (e_3) {
+                env_3.error = e_3;
+                env_3.hasError = true;
+            }
+            finally {
+                __disposeResources(env_3);
+            }
+        });
+    });
+    describe('put', () => {
+        it('runs an Upload + writes lifecycle on first put', async () => {
+            const env_4 = { stack: [], error: void 0, hasError: false };
+            try {
+                const fake = new FakeS3Client({
+                    PutBucketLifecycleConfigurationCommand: () => ({}),
+                    PutObjectCommand: () => ({ ETag: '"abc"' }),
+                    HeadObjectCommand: () => ({ ContentLength: 5 }),
+                });
+                const store = __addDisposableResource(env_4, new S3BlobStore({ client: asClient(fake), bucket: 'b' }), false);
+                const ref = await store.put('hello', Buffer.from('hello'), { contentType: 'text/plain' });
+                expect(ref.etag).toBe('abc');
+                expect(ref.contentLength).toBe(5);
+                expect(fake.lifecycleAttempts).toBe(1);
+            }
+            catch (e_4) {
+                env_4.error = e_4;
+                env_4.hasError = true;
+            }
+            finally {
+                __disposeResources(env_4);
+            }
+        });
+        it('only attempts lifecycle once', async () => {
+            const env_5 = { stack: [], error: void 0, hasError: false };
+            try {
+                const fake = new FakeS3Client({
+                    PutBucketLifecycleConfigurationCommand: () => ({}),
+                    PutObjectCommand: () => ({ ETag: '"x"' }),
+                    HeadObjectCommand: () => ({ ContentLength: 1 }),
+                });
+                const store = __addDisposableResource(env_5, new S3BlobStore({ client: asClient(fake), bucket: 'b' }), false);
+                await store.put('a', Buffer.from('x'));
+                await store.put('b', Buffer.from('x'));
+                expect(fake.lifecycleAttempts).toBe(1);
+            }
+            catch (e_5) {
+                env_5.error = e_5;
+                env_5.hasError = true;
+            }
+            finally {
+                __disposeResources(env_5);
+            }
+        });
+        it('skips lifecycle entirely when manageLifecycle: false', async () => {
+            const env_6 = { stack: [], error: void 0, hasError: false };
+            try {
+                const fake = new FakeS3Client({
+                    PutObjectCommand: () => ({ ETag: '"x"' }),
+                    HeadObjectCommand: () => ({ ContentLength: 1 }),
+                });
+                const store = __addDisposableResource(env_6, new S3BlobStore({ client: asClient(fake), bucket: 'b', manageLifecycle: false }), false);
+                await store.put('a', Buffer.from('x'));
+                expect(fake.lifecycleAttempts).toBe(0);
+            }
+            catch (e_6) {
+                env_6.error = e_6;
+                env_6.hasError = true;
+            }
+            finally {
+                __disposeResources(env_6);
+            }
+        });
+        it('reports lifecycle errors via onLifecycleError', async () => {
+            const env_7 = { stack: [], error: void 0, hasError: false };
+            try {
+                const onLifecycleError = vi.fn();
+                const fake = new FakeS3Client({
+                    PutBucketLifecycleConfigurationCommand: () => {
+                        throw new Error('AccessDenied');
+                    },
+                    PutObjectCommand: () => ({ ETag: '"x"' }),
+                    HeadObjectCommand: () => ({ ContentLength: 1 }),
+                });
+                const store = __addDisposableResource(env_7, new S3BlobStore({ client: asClient(fake), bucket: 'b', onLifecycleError }), false);
+                await store.put('a', Buffer.from('x'));
+                expect(onLifecycleError).toHaveBeenCalledOnce();
+            }
+            catch (e_7) {
+                env_7.error = e_7;
+                env_7.hasError = true;
+            }
+            finally {
+                __disposeResources(env_7);
+            }
+        });
+        it('wraps S3 upload failures as io-error', async () => {
+            const env_8 = { stack: [], error: void 0, hasError: false };
+            try {
+                const fake = new FakeS3Client({
+                    PutBucketLifecycleConfigurationCommand: () => ({}),
+                    PutObjectCommand: () => {
+                        throw new Error('s3 down');
+                    },
+                });
+                const store = __addDisposableResource(env_8, new S3BlobStore({ client: asClient(fake), bucket: 'b' }), false);
+                await expect(store.put('k', Buffer.from('x'))).rejects.toMatchObject({ code: 'io-error' });
+            }
+            catch (e_8) {
+                env_8.error = e_8;
+                env_8.hasError = true;
+            }
+            finally {
+                __disposeResources(env_8);
+            }
+        });
+        it('prepends keyPrefix on the wire and strips it on responses', async () => {
+            const env_9 = { stack: [], error: void 0, hasError: false };
+            try {
+                const fake = new FakeS3Client({
+                    PutBucketLifecycleConfigurationCommand: () => ({}),
+                    PutObjectCommand: () => ({ ETag: '"x"' }),
+                    HeadObjectCommand: () => ({ ContentLength: 3 }),
+                });
+                const store = __addDisposableResource(env_9, new S3BlobStore({ client: asClient(fake), bucket: 'b', keyPrefix: 'tenant-a/' }), false);
+                const ref = await store.put('docs/file', Buffer.from('xyz'));
+                expect(ref.key).toBe('docs/file');
+                const sentPut = fake.sent.find((s) => s.name === 'PutObjectCommand');
+                expect((sentPut?.input).Key).toBe('tenant-a/docs/file');
+            }
+            catch (e_9) {
+                env_9.error = e_9;
+                env_9.hasError = true;
+            }
+            finally {
+                __disposeResources(env_9);
+            }
+        });
+        it('forwards content type, length and metadata to the Upload', async () => {
+            const env_10 = { stack: [], error: void 0, hasError: false };
+            try {
+                const fake = new FakeS3Client({
+                    PutBucketLifecycleConfigurationCommand: () => ({}),
+                    PutObjectCommand: (input) => {
+                        expect(input).toMatchObject({
+                            ContentType: 'application/json',
+                            ContentLength: 4,
+                            Metadata: { tenant: 't1' },
+                        });
+                        return { ETag: '"x"' };
+                    },
+                });
+                const store = __addDisposableResource(env_10, new S3BlobStore({ client: asClient(fake), bucket: 'b' }), false);
+                const ref = await store.put('k', Buffer.from('abcd'), {
+                    contentType: 'application/json',
+                    contentLength: 4,
+                    metadata: { tenant: 't1' },
+                });
+                expect(ref.contentLength).toBe(4);
+            }
+            catch (e_10) {
+                env_10.error = e_10;
+                env_10.hasError = true;
+            }
+            finally {
+                __disposeResources(env_10);
+            }
+        });
+        it('tolerates HEAD failure when contentLength is unknown', async () => {
+            const env_11 = { stack: [], error: void 0, hasError: false };
+            try {
+                const fake = new FakeS3Client({
+                    PutBucketLifecycleConfigurationCommand: () => ({}),
+                    PutObjectCommand: () => ({ ETag: '"x"' }),
+                    HeadObjectCommand: () => {
+                        throw new Error('AccessDenied');
+                    },
+                });
+                const store = __addDisposableResource(env_11, new S3BlobStore({ client: asClient(fake), bucket: 'b' }), false);
+                const ref = await store.put('k', Buffer.from('x'));
+                expect(ref.contentLength).toBeUndefined();
+            }
+            catch (e_11) {
+                env_11.error = e_11;
+                env_11.hasError = true;
+            }
+            finally {
+                __disposeResources(env_11);
+            }
+        });
+    });
+    describe('get', () => {
+        it('returns a stream + headers', async () => {
+            const env_12 = { stack: [], error: void 0, hasError: false };
+            try {
+                const fake = new FakeS3Client({
+                    GetObjectCommand: () => ({
+                        Body: Readable.from([Buffer.from('payload')]),
+                        ContentType: 'text/plain',
+                        ContentLength: 7,
+                        ETag: '"deadbeef"',
+                    }),
+                });
+                const store = __addDisposableResource(env_12, new S3BlobStore({ client: asClient(fake), bucket: 'b', manageLifecycle: false }), false);
+                const result = await store.get('k');
+                expect(result.contentType).toBe('text/plain');
+                expect(result.etag).toBe('deadbeef');
+                expect(decode(await collect(result.stream))).toBe('payload');
+            }
+            catch (e_12) {
+                env_12.error = e_12;
+                env_12.hasError = true;
+            }
+            finally {
+                __disposeResources(env_12);
+            }
+        });
+        it('handles a Web ReadableStream body', async () => {
+            const env_13 = { stack: [], error: void 0, hasError: false };
+            try {
+                const fake = new FakeS3Client({
+                    GetObjectCommand: () => ({
+                        Body: new ReadableStream({
+                            start(c) {
+                                c.enqueue(new TextEncoder().encode('web'));
+                                c.close();
+                            },
+                        }),
+                        ContentLength: 3,
+                    }),
+                });
+                const store = __addDisposableResource(env_13, new S3BlobStore({ client: asClient(fake), bucket: 'b', manageLifecycle: false }), false);
+                const result = await store.get('k');
+                expect(decode(await collect(result.stream))).toBe('web');
+            }
+            catch (e_13) {
+                env_13.error = e_13;
+                env_13.hasError = true;
+            }
+            finally {
+                __disposeResources(env_13);
+            }
+        });
+        it('throws not-found when the underlying error is NoSuchKey', async () => {
+            const env_14 = { stack: [], error: void 0, hasError: false };
+            try {
+                const fake = new FakeS3Client({
+                    GetObjectCommand: () => {
+                        throw makeNoSuchKey();
+                    },
+                });
+                const store = __addDisposableResource(env_14, new S3BlobStore({ client: asClient(fake), bucket: 'b', manageLifecycle: false }), false);
+                await expect(store.get('k')).rejects.toMatchObject({ code: 'not-found' });
+            }
+            catch (e_14) {
+                env_14.error = e_14;
+                env_14.hasError = true;
+            }
+            finally {
+                __disposeResources(env_14);
+            }
+        });
+        it('wraps generic errors as io-error', async () => {
+            const env_15 = { stack: [], error: void 0, hasError: false };
+            try {
+                const fake = new FakeS3Client({
+                    GetObjectCommand: () => {
+                        throw new Error('TLS handshake');
+                    },
+                });
+                const store = __addDisposableResource(env_15, new S3BlobStore({ client: asClient(fake), bucket: 'b', manageLifecycle: false }), false);
+                await expect(store.get('k')).rejects.toMatchObject({ code: 'io-error' });
+            }
+            catch (e_15) {
+                env_15.error = e_15;
+                env_15.hasError = true;
+            }
+            finally {
+                __disposeResources(env_15);
+            }
+        });
+        it('throws io-error when S3 returns no body', async () => {
+            const env_16 = { stack: [], error: void 0, hasError: false };
+            try {
+                const fake = new FakeS3Client({
+                    GetObjectCommand: () => ({ Body: undefined }),
+                });
+                const store = __addDisposableResource(env_16, new S3BlobStore({ client: asClient(fake), bucket: 'b', manageLifecycle: false }), false);
+                await expect(store.get('k')).rejects.toMatchObject({ code: 'io-error' });
+            }
+            catch (e_16) {
+                env_16.error = e_16;
+                env_16.hasError = true;
+            }
+            finally {
+                __disposeResources(env_16);
+            }
+        });
+    });
+    describe('head', () => {
+        it('returns metadata', async () => {
+            const env_17 = { stack: [], error: void 0, hasError: false };
+            try {
+                const fake = new FakeS3Client({
+                    HeadObjectCommand: () => ({
+                        ContentType: 'text/plain',
+                        ContentLength: 5,
+                        ETag: '"v1"',
+                        LastModified: new Date('2026-01-01T00:00:00Z'),
+                        Metadata: { tenant: 't1' },
+                    }),
+                });
+                const store = __addDisposableResource(env_17, new S3BlobStore({ client: asClient(fake), bucket: 'b', manageLifecycle: false }), false);
+                const meta = await store.head('k');
+                expect(meta?.contentLength).toBe(5);
+                expect(meta?.etag).toBe('v1');
+                expect(meta?.customMetadata).toEqual({ tenant: 't1' });
+            }
+            catch (e_17) {
+                env_17.error = e_17;
+                env_17.hasError = true;
+            }
+            finally {
+                __disposeResources(env_17);
+            }
+        });
+        it('returns undefined on NoSuchKey', async () => {
+            const env_18 = { stack: [], error: void 0, hasError: false };
+            try {
+                const fake = new FakeS3Client({
+                    HeadObjectCommand: () => {
+                        throw makeNoSuchKey();
+                    },
+                });
+                const store = __addDisposableResource(env_18, new S3BlobStore({ client: asClient(fake), bucket: 'b', manageLifecycle: false }), false);
+                expect(await store.head('k')).toBeUndefined();
+            }
+            catch (e_18) {
+                env_18.error = e_18;
+                env_18.hasError = true;
+            }
+            finally {
+                __disposeResources(env_18);
+            }
+        });
+        it('wraps unexpected errors as io-error', async () => {
+            const env_19 = { stack: [], error: void 0, hasError: false };
+            try {
+                const fake = new FakeS3Client({
+                    HeadObjectCommand: () => {
+                        throw new Error('throttled');
+                    },
+                });
+                const store = __addDisposableResource(env_19, new S3BlobStore({ client: asClient(fake), bucket: 'b', manageLifecycle: false }), false);
+                await expect(store.head('k')).rejects.toMatchObject({ code: 'io-error' });
+            }
+            catch (e_19) {
+                env_19.error = e_19;
+                env_19.hasError = true;
+            }
+            finally {
+                __disposeResources(env_19);
+            }
+        });
+    });
+    describe('delete', () => {
+        it('issues DeleteObjectCommand', async () => {
+            const env_20 = { stack: [], error: void 0, hasError: false };
+            try {
+                const fake = new FakeS3Client({
+                    DeleteObjectCommand: () => ({}),
+                });
+                const store = __addDisposableResource(env_20, new S3BlobStore({ client: asClient(fake), bucket: 'b', manageLifecycle: false }), false);
+                await store.delete('k');
+                expect(fake.sent.find((s) => s.name === 'DeleteObjectCommand')).toBeDefined();
+            }
+            catch (e_20) {
+                env_20.error = e_20;
+                env_20.hasError = true;
+            }
+            finally {
+                __disposeResources(env_20);
+            }
+        });
+        it('is idempotent on NoSuchKey', async () => {
+            const env_21 = { stack: [], error: void 0, hasError: false };
+            try {
+                const fake = new FakeS3Client({
+                    DeleteObjectCommand: () => {
+                        throw makeNoSuchKey();
+                    },
+                });
+                const store = __addDisposableResource(env_21, new S3BlobStore({ client: asClient(fake), bucket: 'b', manageLifecycle: false }), false);
+                await expect(store.delete('k')).resolves.toBeUndefined();
+            }
+            catch (e_21) {
+                env_21.error = e_21;
+                env_21.hasError = true;
+            }
+            finally {
+                __disposeResources(env_21);
+            }
+        });
+        it('wraps unexpected errors as io-error', async () => {
+            const env_22 = { stack: [], error: void 0, hasError: false };
+            try {
+                const fake = new FakeS3Client({
+                    DeleteObjectCommand: () => {
+                        throw new Error('AccessDenied');
+                    },
+                });
+                const store = __addDisposableResource(env_22, new S3BlobStore({ client: asClient(fake), bucket: 'b', manageLifecycle: false }), false);
+                await expect(store.delete('k')).rejects.toMatchObject({ code: 'io-error' });
+            }
+            catch (e_22) {
+                env_22.error = e_22;
+                env_22.hasError = true;
+            }
+            finally {
+                __disposeResources(env_22);
+            }
+        });
+    });
+    describe('list', () => {
+        it('returns items + nextCursor', async () => {
+            const env_23 = { stack: [], error: void 0, hasError: false };
+            try {
+                const fake = new FakeS3Client({
+                    ListObjectsV2Command: () => ({
+                        Contents: [
+                            { Key: 'p/a', Size: 1, ETag: '"e1"', LastModified: new Date(0) },
+                            { Key: 'p/b', Size: 2 },
+                        ],
+                        NextContinuationToken: 'next-page',
+                    }),
+                });
+                const store = __addDisposableResource(env_23, new S3BlobStore({ client: asClient(fake), bucket: 'b', manageLifecycle: false }), false);
+                const result = await store.list('p/');
+                expect(result.items.map((i) => i.key)).toEqual(['p/a', 'p/b']);
+                expect(result.nextCursor).toBe('next-page');
+            }
+            catch (e_23) {
+                env_23.error = e_23;
+                env_23.hasError = true;
+            }
+            finally {
+                __disposeResources(env_23);
+            }
+        });
+        it('strips keyPrefix on returned keys', async () => {
+            const env_24 = { stack: [], error: void 0, hasError: false };
+            try {
+                const fake = new FakeS3Client({
+                    ListObjectsV2Command: () => ({
+                        Contents: [{ Key: 'tenant-a/p/a', Size: 1 }],
+                    }),
+                });
+                const store = __addDisposableResource(env_24, new S3BlobStore({
+                    client: asClient(fake),
+                    bucket: 'b',
+                    keyPrefix: 'tenant-a/',
+                    manageLifecycle: false,
+                }), false);
+                const result = await store.list('p/');
+                expect(result.items[0].key).toBe('p/a');
+            }
+            catch (e_24) {
+                env_24.error = e_24;
+                env_24.hasError = true;
+            }
+            finally {
+                __disposeResources(env_24);
+            }
+        });
+        it('rejects non-string prefix and bad limits', async () => {
+            const env_25 = { stack: [], error: void 0, hasError: false };
+            try {
+                const fake = new FakeS3Client({});
+                const store = __addDisposableResource(env_25, new S3BlobStore({ client: asClient(fake), bucket: 'b', manageLifecycle: false }), false);
+                await expect(store.list(42)).rejects.toMatchObject({ code: 'invalid-config' });
+                await expect(store.list('p', { limit: 0 })).rejects.toMatchObject({ code: 'invalid-config' });
+            }
+            catch (e_25) {
+                env_25.error = e_25;
+                env_25.hasError = true;
+            }
+            finally {
+                __disposeResources(env_25);
+            }
+        });
+        it('wraps S3 list failures as io-error', async () => {
+            const env_26 = { stack: [], error: void 0, hasError: false };
+            try {
+                const fake = new FakeS3Client({
+                    ListObjectsV2Command: () => {
+                        throw new Error('throttled');
+                    },
+                });
+                const store = __addDisposableResource(env_26, new S3BlobStore({ client: asClient(fake), bucket: 'b', manageLifecycle: false }), false);
+                await expect(store.list('')).rejects.toMatchObject({ code: 'io-error' });
+            }
+            catch (e_26) {
+                env_26.error = e_26;
+                env_26.hasError = true;
+            }
+            finally {
+                __disposeResources(env_26);
+            }
+        });
+        it('treats missing Contents as an empty page', async () => {
+            const env_27 = { stack: [], error: void 0, hasError: false };
+            try {
+                const fake = new FakeS3Client({
+                    ListObjectsV2Command: () => ({}),
+                });
+                const store = __addDisposableResource(env_27, new S3BlobStore({ client: asClient(fake), bucket: 'b', manageLifecycle: false }), false);
+                const result = await store.list('');
+                expect(result.items).toEqual([]);
+                expect(result.nextCursor).toBeUndefined();
+            }
+            catch (e_27) {
+                env_27.error = e_27;
+                env_27.hasError = true;
+            }
+            finally {
+                __disposeResources(env_27);
+            }
+        });
+        it('skips entries without a Key', async () => {
+            const env_28 = { stack: [], error: void 0, hasError: false };
+            try {
+                const fake = new FakeS3Client({
+                    ListObjectsV2Command: () => ({
+                        Contents: [{ Size: 1 }, { Key: 'k', Size: 2 }],
+                    }),
+                });
+                const store = __addDisposableResource(env_28, new S3BlobStore({ client: asClient(fake), bucket: 'b', manageLifecycle: false }), false);
+                const result = await store.list('');
+                expect(result.items.map((i) => i.key)).toEqual(['k']);
+            }
+            catch (e_28) {
+                env_28.error = e_28;
+                env_28.hasError = true;
+            }
+            finally {
+                __disposeResources(env_28);
+            }
+        });
+    });
+    describe('signed URLs', () => {
+        const realClient = () => new S3Client({
+            region: 'us-east-1',
+            endpoint: 'http://127.0.0.1:9000',
+            forcePathStyle: true,
+            credentials: { accessKeyId: 'AKIA0000', secretAccessKey: 'secret-key' },
+        });
+        it('mints a download URL pointing at the bucket + key', async () => {
+            const env_29 = { stack: [], error: void 0, hasError: false };
+            try {
+                const store = __addDisposableResource(env_29, new S3BlobStore({ client: realClient(), bucket: 'tests', manageLifecycle: false }), false);
+                const url = await store.getDownloadUrl('a/b', { ttlSec: 60 });
+                expect(url.startsWith('http')).toBe(true);
+                expect(url).toContain('tests/a/b');
+                expect(url).toContain('X-Amz-Signature=');
+            }
+            catch (e_29) {
+                env_29.error = e_29;
+                env_29.hasError = true;
+            }
+            finally {
+                __disposeResources(env_29);
+            }
+        });
+        it('mints an upload URL with method PUT', async () => {
+            const env_30 = { stack: [], error: void 0, hasError: false };
+            try {
+                const store = __addDisposableResource(env_30, new S3BlobStore({ client: realClient(), bucket: 'tests', manageLifecycle: false }), false);
+                const result = await store.getUploadUrl('upload/key', { ttlSec: 30, contentType: 'image/png', maxBytes: 1024 });
+                expect(result.method).toBe('PUT');
+                expect(result.url.startsWith('http')).toBe(true);
+                expect(result.url).toContain('tests/upload/key');
+            }
+            catch (e_30) {
+                env_30.error = e_30;
+                env_30.hasError = true;
+            }
+            finally {
+                __disposeResources(env_30);
+            }
+        });
+        it('rejects mid-disposal calls', async () => {
+            const store = new S3BlobStore({ client: realClient(), bucket: 'tests', manageLifecycle: false });
+            store[Symbol.dispose]();
+            await expect(store.getDownloadUrl('a', { ttlSec: 60 })).rejects.toMatchObject({ code: 'io-error' });
+            await expect(store.getUploadUrl('a', { ttlSec: 60 })).rejects.toMatchObject({ code: 'io-error' });
+        });
+    });
+    describe('S3BlobStore.bodyToBuffer', () => {
+        it('handles Uint8Array', async () => {
+            expect(await S3BlobStore.bodyToBuffer(new Uint8Array([1, 2]))).toEqual(new Uint8Array([1, 2]));
+        });
+        it('handles Buffer', async () => {
+            const out = await S3BlobStore.bodyToBuffer(Buffer.from([3, 4]));
+            expect(Array.from(out)).toEqual([3, 4]);
+        });
+        it('handles string', async () => {
+            expect(decode(await S3BlobStore.bodyToBuffer('abc'))).toBe('abc');
+        });
+        it('handles a Web ReadableStream', async () => {
+            const body = new ReadableStream({
+                start(c) {
+                    c.enqueue(new TextEncoder().encode('x'));
+                    c.close();
+                },
+            });
+            expect(decode(await S3BlobStore.bodyToBuffer(body))).toBe('x');
+        });
+        it('handles a Node Readable', async () => {
+            expect(decode(await S3BlobStore.bodyToBuffer(Readable.from([Buffer.from('node')])))).toBe('node');
+        });
+        it('throws on unsupported body shapes', async () => {
+            await expect(S3BlobStore.bodyToBuffer(123)).rejects.toThrow(BlobStoreError);
+        });
+    });
+    describe('verifying command construction', () => {
+        it('uses GetObjectCommand on get', async () => {
+            const env_31 = { stack: [], error: void 0, hasError: false };
+            try {
+                const fake = new FakeS3Client({
+                    GetObjectCommand: () => ({ Body: Readable.from([Buffer.from('x')]), ContentLength: 1 }),
+                });
+                const store = __addDisposableResource(env_31, new S3BlobStore({ client: asClient(fake), bucket: 'b', manageLifecycle: false }), false);
+                await store.get('k');
+                expect(fake.send.mock.calls[0][0]).toBeInstanceOf(GetObjectCommand);
+            }
+            catch (e_31) {
+                env_31.error = e_31;
+                env_31.hasError = true;
+            }
+            finally {
+                __disposeResources(env_31);
+            }
+        });
+        it('uses HeadObjectCommand on head', async () => {
+            const env_32 = { stack: [], error: void 0, hasError: false };
+            try {
+                const fake = new FakeS3Client({ HeadObjectCommand: () => ({ ContentLength: 0 }) });
+                const store = __addDisposableResource(env_32, new S3BlobStore({ client: asClient(fake), bucket: 'b', manageLifecycle: false }), false);
+                await store.head('k');
+                expect(fake.send.mock.calls[0][0]).toBeInstanceOf(HeadObjectCommand);
+            }
+            catch (e_32) {
+                env_32.error = e_32;
+                env_32.hasError = true;
+            }
+            finally {
+                __disposeResources(env_32);
+            }
+        });
+        it('uses DeleteObjectCommand on delete', async () => {
+            const env_33 = { stack: [], error: void 0, hasError: false };
+            try {
+                const fake = new FakeS3Client({ DeleteObjectCommand: () => ({}) });
+                const store = __addDisposableResource(env_33, new S3BlobStore({ client: asClient(fake), bucket: 'b', manageLifecycle: false }), false);
+                await store.delete('k');
+                expect(fake.send.mock.calls[0][0]).toBeInstanceOf(DeleteObjectCommand);
+            }
+            catch (e_33) {
+                env_33.error = e_33;
+                env_33.hasError = true;
+            }
+            finally {
+                __disposeResources(env_33);
+            }
+        });
+        it('uses ListObjectsV2Command on list', async () => {
+            const env_34 = { stack: [], error: void 0, hasError: false };
+            try {
+                const fake = new FakeS3Client({ ListObjectsV2Command: () => ({}) });
+                const store = __addDisposableResource(env_34, new S3BlobStore({ client: asClient(fake), bucket: 'b', manageLifecycle: false }), false);
+                await store.list('');
+                expect(fake.send.mock.calls[0][0]).toBeInstanceOf(ListObjectsV2Command);
+            }
+            catch (e_34) {
+                env_34.error = e_34;
+                env_34.hasError = true;
+            }
+            finally {
+                __disposeResources(env_34);
+            }
+        });
+        it('uses PutObjectCommand on put body (verified via Upload single-part path)', async () => {
+            const env_35 = { stack: [], error: void 0, hasError: false };
+            try {
+                const fake = new FakeS3Client({
+                    PutObjectCommand: () => ({ ETag: '"x"' }),
+                    HeadObjectCommand: () => ({ ContentLength: 1 }),
+                });
+                const store = __addDisposableResource(env_35, new S3BlobStore({ client: asClient(fake), bucket: 'b', manageLifecycle: false }), false);
+                await store.put('k', Buffer.from('x'));
+                const putCall = fake.send.mock.calls.find((c) => c[0] instanceof PutObjectCommand);
+                expect(putCall).toBeDefined();
+            }
+            catch (e_35) {
+                env_35.error = e_35;
+                env_35.hasError = true;
+            }
+            finally {
+                __disposeResources(env_35);
+            }
+        });
+        it('emits PutBucketLifecycleConfigurationCommand on first put', async () => {
+            const env_36 = { stack: [], error: void 0, hasError: false };
+            try {
+                const fake = new FakeS3Client({
+                    PutBucketLifecycleConfigurationCommand: () => ({}),
+                    PutObjectCommand: () => ({ ETag: '"x"' }),
+                    HeadObjectCommand: () => ({ ContentLength: 1 }),
+                });
+                const store = __addDisposableResource(env_36, new S3BlobStore({ client: asClient(fake), bucket: 'b' }), false);
+                await store.put('k', Buffer.from('x'));
+                const lifecycleCall = fake.send.mock.calls.find((c) => c[0] instanceof PutBucketLifecycleConfigurationCommand);
+                expect(lifecycleCall).toBeDefined();
+            }
+            catch (e_36) {
+                env_36.error = e_36;
+                env_36.hasError = true;
+            }
+            finally {
+                __disposeResources(env_36);
+            }
+        });
+    });
+    describe('disposal', () => {
+        it('rejects subsequent calls', async () => {
+            const store = new S3BlobStore({ client: {}, bucket: 'b' });
+            store[Symbol.dispose]();
+            await expect(store.put('k', Buffer.from('x'))).rejects.toMatchObject({ code: 'io-error' });
+            await expect(store.get('k')).rejects.toMatchObject({ code: 'io-error' });
+            await expect(store.head('k')).rejects.toMatchObject({ code: 'io-error' });
+            await expect(store.delete('k')).rejects.toMatchObject({ code: 'io-error' });
+            await expect(store.list('')).rejects.toMatchObject({ code: 'io-error' });
+        });
+    });
+});
+//# sourceMappingURL=s3-blob-store.unit.spec.js.map