@remit/storage-service 0.0.12 → 0.0.14

package/dist/backends/filesystem.d.ts

@@ -0,0 +1,12 @@
+import type { StorageService } from "../storage.js";
+/**
+ * Where a minted upload URL points, and what signs it. Absent on a process that
+ * only reads storage; a mint then fails loud rather than handing out a URL
+ * nothing can verify.
+ */
+export interface FilesystemUploadUrlConfig {
+    /** Public origin of the deployment serving the upload route. */
+    origin: string;
+    signingSecret: string;
+}
+export declare const createFilesystemStorageService: (basePath: string, uploadUrls?: FilesystemUploadUrlConfig) => StorageService;

package/dist/backends/filesystem.js

@@ -0,0 +1,296 @@
+import { createWriteStream } from "node:fs";
+import { mkdir, readdir, readFile, rm, stat, unlink, writeFile, } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { promisify } from "node:util";
+import { createGunzip, gunzipSync, gzip } from "node:zlib";
+import { ContentEncoding, StorageType } from "@remit/domain-enums";
+import { UPLOAD_ROUTE_PREFIX, UPLOAD_URL_SIGNING_LABEL, } from "../outbox-upload-url.js";
+import { signStoragePath } from "../signed-path.js";
+import { buildBodyPartKey, buildDeduplicatedKey, buildExportArchiveKey, buildMessageBodyKey, buildOutboxAttachmentKey, buildOutboxAttachmentPrefix, buildParsedBodyKey, computeChecksum, isStorageNotFoundError, } from "../storage.js";
+const gzipAsync = promisify(gzip);
+export const createFilesystemStorageService = (basePath, uploadUrls) => {
+    const storeInternal = async (params) => {
+        const { key, content, compress = true } = params;
+        const checksumSha256 = computeChecksum(content);
+        const contentEncoding = compress
+            ? ContentEncoding.Gzip
+            : ContentEncoding.None;
+        const body = compress ? await gzipAsync(content) : content;
+        const fullPath = join(basePath, key);
+        await mkdir(dirname(fullPath), { recursive: true });
+        await writeFile(fullPath, body);
+        return {
+            uri: `file://${fullPath}`,
+            storageType: StorageType.Filesystem,
+            storageLocation: basePath,
+            storageKey: key,
+            sizeBytes: body.length,
+            checksumSha256,
+            contentEncoding,
+        };
+    };
+    const storeMessageBody = (params) => {
+        const { accountConfigId, accountId, messageId, content } = params;
+        return storeInternal({
+            key: buildMessageBodyKey(accountConfigId, accountId, messageId),
+            content,
+        });
+    };
+    const storeBodyPart = (params) => {
+        const { accountConfigId, accountId, messageId, partPath, content } = params;
+        return storeInternal({
+            key: buildBodyPartKey(accountConfigId, accountId, messageId, partPath),
+            content,
+        });
+    };
+    const bodyPartExists = (accountConfigId, accountId, messageId, partPath) => {
+        const key = buildBodyPartKey(accountConfigId, accountId, messageId, partPath);
+        const fullPath = join(basePath, key);
+        return stat(fullPath)
+            .then(() => true)
+            .catch(() => false);
+    };
+    const retrieveBodyPart = async (accountConfigId, accountId, messageId, partPath) => {
+        const key = buildBodyPartKey(accountConfigId, accountId, messageId, partPath);
+        const fullPath = join(basePath, key);
+        const buffer = await readFile(fullPath).catch((error) => {
+            if (isStorageNotFoundError(error))
+                return null;
+            throw error;
+        });
+        if (!buffer)
+            return null;
+        return buffer[0] === 0x1f && buffer[1] === 0x8b
+            ? gunzipSync(buffer)
+            : buffer;
+    };
+    const storeOutboxAttachment = (params) => {
+        const { accountConfigId, accountId, outboxMessageId, outboxAttachmentId, content, } = params;
+        return storeInternal({
+            key: buildOutboxAttachmentKey(accountConfigId, accountId, outboxMessageId, outboxAttachmentId),
+            content,
+            compress: false,
+        });
+    };
+    const listOutboxAttachments = async (accountConfigId, accountId, outboxMessageId) => {
+        const prefix = buildOutboxAttachmentPrefix(accountConfigId, accountId, outboxMessageId);
+        const entries = await readdir(join(basePath, prefix)).catch((error) => {
+            if (isStorageNotFoundError(error))
+                return [];
+            throw error;
+        });
+        const items = [];
+        for (const name of entries) {
+            const { size } = await stat(join(basePath, prefix, name));
+            items.push({
+                outboxAttachmentId: name,
+                key: `${prefix}${name}`,
+                sizeBytes: size,
+            });
+        }
+        return items;
+    };
+    const listOutboxDraftsWithAttachments = async (accountConfigId, accountId) => {
+        // An account that has never held an attachment has no directory, and
+        // that is genuinely nothing to do. A storage root that is not there at
+        // all is a different thing entirely — a process that cannot see the
+        // volume it is meant to be collecting from — and it must not read as an
+        // empty answer. Unmounted, the sweep would report every account swept
+        // and collect nothing, forever.
+        const rootExists = await stat(basePath)
+            .then(() => true)
+            .catch((error) => {
+            if (isStorageNotFoundError(error))
+                return false;
+            throw error;
+        });
+        if (!rootExists) {
+            throw new Error(`storage root ${basePath} does not exist; this process cannot see the storage it was asked to read`);
+        }
+        const root = join(basePath, `accounts/${accountConfigId}/${accountId}/outbox`);
+        const entries = await readdir(root, { withFileTypes: true }).catch((error) => {
+            if (isStorageNotFoundError(error))
+                return [];
+            throw error;
+        });
+        return entries
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => entry.name);
+    };
+    const deleteOutboxAttachment = async (accountConfigId, accountId, outboxMessageId, outboxAttachmentId) => {
+        const prefix = buildOutboxAttachmentPrefix(accountConfigId, accountId, outboxMessageId);
+        const entries = await readdir(join(basePath, prefix)).catch((error) => {
+            if (isStorageNotFoundError(error))
+                return [];
+            throw error;
+        });
+        for (const name of entries) {
+            if (name !== outboxAttachmentId)
+                continue;
+            await rm(join(basePath, prefix, name), { force: true });
+        }
+    };
+    const statOutboxAttachment = async (accountConfigId, accountId, outboxMessageId, outboxAttachmentId) => {
+        const fullPath = join(basePath, buildOutboxAttachmentKey(accountConfigId, accountId, outboxMessageId, outboxAttachmentId));
+        const stats = await stat(fullPath).catch((error) => {
+            if (isStorageNotFoundError(error))
+                return null;
+            throw error;
+        });
+        return stats ? { sizeBytes: stats.size } : null;
+    };
+    const retrieveOutboxAttachment = (accountConfigId, accountId, outboxMessageId, outboxAttachmentId) => readFile(join(basePath, buildOutboxAttachmentKey(accountConfigId, accountId, outboxMessageId, outboxAttachmentId))).catch((error) => {
+        if (isStorageNotFoundError(error))
+            return null;
+        throw error;
+    });
+    // This backend has no presigned anything, so the URL addresses the
+    // deployment's own upload route. Its authority is the same HMAC the read side
+    // uses on /content, under the write label, covering the storage key, the
+    // expiry and the exact byte count — a URL for one attachment, for a while,
+    // for one size.
+    const createOutboxAttachmentUploadUrl = async (params) => {
+        if (!uploadUrls) {
+            throw new Error("the filesystem storage backend cannot mint an upload URL without an origin and a signing secret");
+        }
+        const key = buildOutboxAttachmentKey(params.accountConfigId, params.accountId, params.outboxMessageId, params.outboxAttachmentId);
+        const sig = signStoragePath(uploadUrls.signingSecret, UPLOAD_URL_SIGNING_LABEL, key, [params.expiresAt, params.sizeBytes]);
+        const origin = uploadUrls.origin.replace(/\/+$/, "");
+        const query = new URLSearchParams({
+            exp: String(params.expiresAt),
+            max: String(params.sizeBytes),
+            sig,
+        });
+        return {
+            uploadUrl: `${origin}${UPLOAD_ROUTE_PREFIX}${key}?${query.toString()}`,
+        };
+    };
+    const deleteOutboxAttachments = async (accountConfigId, accountId, outboxMessageId) => {
+        const dirPath = join(basePath, buildOutboxAttachmentPrefix(accountConfigId, accountId, outboxMessageId));
+        await rm(dirPath, { recursive: true, force: true });
+    };
+    const storeDeduplicated = (params) => {
+        const { accountConfigId, accountId, content } = params;
+        const checksumSha256 = computeChecksum(content);
+        return storeInternal({
+            key: buildDeduplicatedKey(accountConfigId, accountId, checksumSha256),
+            content,
+        });
+    };
+    const storeParsedBody = (params) => {
+        const { accountConfigId, accountId, messageId, parsed } = params;
+        const content = Buffer.from(JSON.stringify(parsed), "utf8");
+        return storeInternal({
+            key: buildParsedBodyKey(accountConfigId, accountId, messageId),
+            content,
+        });
+    };
+    const retrieveParsedBody = async (accountConfigId, accountId, messageId) => {
+        const key = buildParsedBodyKey(accountConfigId, accountId, messageId);
+        const fullPath = join(basePath, key);
+        const buffer = await readFile(fullPath).catch((error) => {
+            if (isStorageNotFoundError(error))
+                return null;
+            throw error;
+        });
+        if (!buffer)
+            return null;
+        const decoded = buffer[0] === 0x1f && buffer[1] === 0x8b ? gunzipSync(buffer) : buffer;
+        return JSON.parse(decoded.toString("utf8"));
+    };
+    // Resolve path from URI, handling both absolute and relative paths
+    // Note: URIs like file://.remit/storage/... parse incorrectly - '.remit' becomes hostname
+    // We reconstruct the original path by combining hostname + pathname
+    const resolvePathFromUri = (uri) => {
+        const url = new URL(uri);
+        const hostname = url.hostname;
+        const pathname = url.pathname;
+        // If hostname exists, it was part of a relative path (e.g., file://.remit/... -> hostname='.remit')
+        if (hostname) {
+            const relativePath = hostname + pathname;
+            return resolve(relativePath);
+        }
+        // Absolute path (file:///absolute/path)
+        return pathname;
+    };
+    const retrieve = async (uri) => {
+        const fullPath = resolvePathFromUri(uri);
+        const buffer = await readFile(fullPath);
+        if (buffer[0] === 0x1f && buffer[1] === 0x8b) {
+            return gunzipSync(buffer);
+        }
+        return buffer;
+    };
+    const exists = async (uri) => {
+        const fullPath = resolvePathFromUri(uri);
+        return stat(fullPath)
+            .then(() => true)
+            .catch(() => false);
+    };
+    const del = async (uri) => {
+        const fullPath = resolvePathFromUri(uri);
+        await unlink(fullPath);
+    };
+    return {
+        storeMessageBody,
+        storeBodyPart,
+        bodyPartExists,
+        retrieveBodyPart,
+        storeOutboxAttachment,
+        listOutboxAttachments,
+        listOutboxDraftsWithAttachments,
+        deleteOutboxAttachments,
+        deleteOutboxAttachment,
+        statOutboxAttachment,
+        retrieveOutboxAttachment,
+        createOutboxAttachmentUploadUrl,
+        storeDeduplicated,
+        storeParsedBody,
+        retrieveParsedBody,
+        retrieveMessageBody: async (accountConfigId, accountId, messageId) => {
+            const key = buildMessageBodyKey(accountConfigId, accountId, messageId);
+            const fullPath = join(basePath, key);
+            const buffer = await readFile(fullPath).catch((error) => {
+                if (isStorageNotFoundError(error))
+                    return null;
+                throw error;
+            });
+            if (!buffer)
+                return null;
+            if (buffer[0] === 0x1f && buffer[1] === 0x8b) {
+                return gunzipSync(buffer);
+            }
+            return buffer;
+        },
+        retrieveMessageBodyStream: async (accountConfigId, accountId, messageId) => {
+            const key = buildMessageBodyKey(accountConfigId, accountId, messageId);
+            const fullPath = join(basePath, key);
+            const buffer = await readFile(fullPath).catch((error) => {
+                if (isStorageNotFoundError(error))
+                    return null;
+                throw error;
+            });
+            if (!buffer)
+                return null;
+            if (buffer[0] === 0x1f && buffer[1] === 0x8b) {
+                return Readable.from(buffer).pipe(createGunzip());
+            }
+            return Readable.from(buffer);
+        },
+        retrieve,
+        exists,
+        delete: del,
+        storeExportArchiveStream: async (accountConfigId, exportRequestId, body) => {
+            const key = buildExportArchiveKey(accountConfigId, exportRequestId);
+            const fullPath = join(basePath, key);
+            await mkdir(dirname(fullPath), { recursive: true });
+            await pipeline(body, createWriteStream(fullPath));
+            return key;
+        },
+        getPresignedDownloadUrl: (_key, _expiresInSeconds) => {
+            throw new Error("getPresignedDownloadUrl is not supported on the filesystem backend");
+        },
+    };
+};

package/dist/backends/s3.d.ts

@@ -0,0 +1,3 @@
+import { type S3Client } from "@aws-sdk/client-s3";
+import type { StorageService } from "../storage.js";
+export declare const createS3StorageService: (client: S3Client, bucketName: string) => StorageService;

package/dist/backends/s3.js

@@ -0,0 +1,370 @@
+import { promisify } from "node:util";
+import { createGunzip, gunzipSync, gzip } from "node:zlib";
+import { DeleteObjectCommand, DeleteObjectsCommand, GetObjectCommand, HeadObjectCommand, ListObjectsV2Command, PutObjectCommand, } from "@aws-sdk/client-s3";
+import { Upload } from "@aws-sdk/lib-storage";
+import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
+import { ContentEncoding, StorageType } from "@remit/domain-enums";
+import { buildBodyPartKey, buildDeduplicatedKey, buildExportArchiveKey, buildMessageBodyKey, buildOutboxAttachmentKey, buildOutboxAttachmentPrefix, buildParsedBodyKey, computeChecksum, isStorageNotFoundError, } from "../storage.js";
+import { parseStorageUri } from "../uri.js";
+const gzipAsync = promisify(gzip);
+export const createS3StorageService = (client, bucketName) => {
+    const storeInternal = async (params) => {
+        const { key, content, contentType, compress = true } = params;
+        const contentChecksumSha256 = computeChecksum(content);
+        const contentEncoding = compress
+            ? ContentEncoding.Gzip
+            : ContentEncoding.None;
+        const body = compress ? await gzipAsync(content) : content;
+        await client.send(new PutObjectCommand({
+            Bucket: bucketName,
+            Key: key,
+            Body: body,
+            ContentType: contentType,
+            ContentEncoding: compress ? "gzip" : undefined,
+        }));
+        return {
+            uri: `s3://${bucketName}/${key}`,
+            storageType: StorageType.S3,
+            storageLocation: bucketName,
+            storageKey: key,
+            sizeBytes: body.length,
+            checksumSha256: contentChecksumSha256,
+            contentEncoding,
+        };
+    };
+    const storeMessageBody = (params) => {
+        const { accountConfigId, accountId, messageId, content } = params;
+        return storeInternal({
+            key: buildMessageBodyKey(accountConfigId, accountId, messageId),
+            content,
+            contentType: "message/rfc822",
+        });
+    };
+    const storeBodyPart = (params) => {
+        const { accountConfigId, accountId, messageId, partPath, content, contentType, } = params;
+        return storeInternal({
+            key: buildBodyPartKey(accountConfigId, accountId, messageId, partPath),
+            content,
+            contentType,
+        });
+    };
+    const bodyPartExists = (accountConfigId, accountId, messageId, partPath) => {
+        const key = buildBodyPartKey(accountConfigId, accountId, messageId, partPath);
+        return client
+            .send(new HeadObjectCommand({ Bucket: bucketName, Key: key }))
+            .then(() => true)
+            .catch(() => false);
+    };
+    const retrieveBodyPart = async (accountConfigId, accountId, messageId, partPath) => {
+        const key = buildBodyPartKey(accountConfigId, accountId, messageId, partPath);
+        const response = await client
+            .send(new GetObjectCommand({ Bucket: bucketName, Key: key }))
+            .catch((error) => {
+            if (isStorageNotFoundError(error))
+                return null;
+            throw error;
+        });
+        if (!response)
+            return null;
+        if (!response.Body) {
+            throw new Error(`Empty response body for body part: ${key}`);
+        }
+        const body = await response.Body.transformToByteArray();
+        const buffer = Buffer.from(body);
+        return response.ContentEncoding === "gzip" ? gunzipSync(buffer) : buffer;
+    };
+    const storeOutboxAttachment = (params) => {
+        const { accountConfigId, accountId, outboxMessageId, outboxAttachmentId, content, } = params;
+        // `application/octet-stream` rather than the uploader's declared type:
+        // the object is only ever read back to build a MIME part, and a stored
+        // `text/html` would be a type any future signed-URL read path could be
+        // tricked into serving from the content origin.
+        return storeInternal({
+            key: buildOutboxAttachmentKey(accountConfigId, accountId, outboxMessageId, outboxAttachmentId),
+            content,
+            contentType: "application/octet-stream",
+            compress: false,
+        });
+    };
+    const listOutboxAttachments = async (accountConfigId, accountId, outboxMessageId) => {
+        const prefix = buildOutboxAttachmentPrefix(accountConfigId, accountId, outboxMessageId);
+        const items = [];
+        let continuationToken;
+        do {
+            const response = await client.send(new ListObjectsV2Command({
+                Bucket: bucketName,
+                Prefix: prefix,
+                ContinuationToken: continuationToken,
+            }));
+            for (const object of response.Contents ?? []) {
+                if (!object.Key)
+                    continue;
+                items.push({
+                    outboxAttachmentId: object.Key.slice(prefix.length),
+                    key: object.Key,
+                    sizeBytes: object.Size ?? 0,
+                });
+            }
+            continuationToken = response.IsTruncated
+                ? response.NextContinuationToken
+                : undefined;
+        } while (continuationToken);
+        return items;
+    };
+    const listOutboxDraftsWithAttachments = async (accountConfigId, accountId) => {
+        const root = `accounts/${accountConfigId}/${accountId}/outbox/`;
+        const drafts = new Set();
+        let continuationToken;
+        // Delimited listing: S3 answers with the directory-like prefixes rather
+        // than every object under them, so this stays one call per page of
+        // drafts instead of one per object.
+        do {
+            const response = await client.send(new ListObjectsV2Command({
+                Bucket: bucketName,
+                Prefix: root,
+                Delimiter: "/",
+                ContinuationToken: continuationToken,
+            }));
+            for (const entry of response.CommonPrefixes ?? []) {
+                if (!entry.Prefix)
+                    continue;
+                drafts.add(entry.Prefix.slice(root.length).replace(/\/$/, ""));
+            }
+            continuationToken = response.IsTruncated
+                ? response.NextContinuationToken
+                : undefined;
+        } while (continuationToken);
+        return [...drafts];
+    };
+    const deleteOutboxAttachment = async (accountConfigId, accountId, outboxMessageId, outboxAttachmentId) => {
+        const prefix = buildOutboxAttachmentPrefix(accountConfigId, accountId, outboxMessageId);
+        await client.send(new DeleteObjectCommand({
+            Bucket: bucketName,
+            Key: `${prefix}${outboxAttachmentId}`,
+        }));
+    };
+    const statOutboxAttachment = async (accountConfigId, accountId, outboxMessageId, outboxAttachmentId) => {
+        const head = await client
+            .send(new HeadObjectCommand({
+            Bucket: bucketName,
+            Key: buildOutboxAttachmentKey(accountConfigId, accountId, outboxMessageId, outboxAttachmentId),
+        }))
+            .catch((error) => {
+            if (isStorageNotFoundError(error))
+                return null;
+            // A HEAD on a missing key answers 404 with no NoSuchKey code, so the
+            // SDK's NotFound is the same absence.
+            if (error?.name === "NotFound")
+                return null;
+            throw error;
+        });
+        if (!head)
+            return null;
+        return { sizeBytes: head.ContentLength ?? 0 };
+    };
+    const retrieveOutboxAttachment = async (accountConfigId, accountId, outboxMessageId, outboxAttachmentId) => {
+        const key = buildOutboxAttachmentKey(accountConfigId, accountId, outboxMessageId, outboxAttachmentId);
+        const response = await client
+            .send(new GetObjectCommand({ Bucket: bucketName, Key: key }))
+            .catch((error) => {
+            if (isStorageNotFoundError(error))
+                return null;
+            throw error;
+        });
+        if (!response)
+            return null;
+        if (!response.Body) {
+            throw new Error(`Empty response body for outbox attachment: ${key}`);
+        }
+        const bytes = await response.Body.transformToByteArray();
+        return Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    };
+    // The browser PUTs straight to the bucket and these bytes never touch the
+    // API. `ContentLength` on the command hoists `content-length` into
+    // X-Amz-SignedHeaders, so S3 recomputes the signature over the length it was
+    // sent: a request declaring any other size fails the signature check, and a
+    // PUT is read for exactly that many bytes. The size is bound by S3 itself,
+    // not by anything downstream trusting the client.
+    const createOutboxAttachmentUploadUrl = async (params) => {
+        const expiresIn = Math.max(1, params.expiresAt - Math.floor(Date.now() / 1000));
+        const uploadUrl = await getSignedUrl(client, new PutObjectCommand({
+            Bucket: bucketName,
+            Key: buildOutboxAttachmentKey(params.accountConfigId, params.accountId, params.outboxMessageId, params.outboxAttachmentId),
+            ContentLength: params.sizeBytes,
+        }), { expiresIn });
+        return { uploadUrl };
+    };
+    const deleteOutboxAttachments = async (accountConfigId, accountId, outboxMessageId) => {
+        const prefix = buildOutboxAttachmentPrefix(accountConfigId, accountId, outboxMessageId);
+        let continuationToken;
+        do {
+            const response = await client.send(new ListObjectsV2Command({
+                Bucket: bucketName,
+                Prefix: prefix,
+                ContinuationToken: continuationToken,
+            }));
+            const keys = (response.Contents ?? [])
+                .map((object) => object.Key)
+                .filter((key) => typeof key === "string");
+            if (keys.length > 0) {
+                await client.send(new DeleteObjectsCommand({
+                    Bucket: bucketName,
+                    Delete: { Objects: keys.map((Key) => ({ Key })) },
+                }));
+            }
+            continuationToken = response.IsTruncated
+                ? response.NextContinuationToken
+                : undefined;
+        } while (continuationToken);
+    };
+    const storeDeduplicated = (params) => {
+        const { accountConfigId, accountId, content, contentType } = params;
+        const checksumSha256 = computeChecksum(content);
+        return storeInternal({
+            key: buildDeduplicatedKey(accountConfigId, accountId, checksumSha256),
+            content,
+            contentType,
+        });
+    };
+    const storeParsedBody = (params) => {
+        const { accountConfigId, accountId, messageId, parsed } = params;
+        const content = Buffer.from(JSON.stringify(parsed), "utf8");
+        return storeInternal({
+            key: buildParsedBodyKey(accountConfigId, accountId, messageId),
+            content,
+            contentType: "application/json",
+        });
+    };
+    const retrieveParsedBody = async (accountConfigId, accountId, messageId) => {
+        const key = buildParsedBodyKey(accountConfigId, accountId, messageId);
+        const response = await client
+            .send(new GetObjectCommand({ Bucket: bucketName, Key: key }))
+            .catch((error) => {
+            if (isStorageNotFoundError(error))
+                return null;
+            throw error;
+        });
+        if (!response)
+            return null;
+        if (!response.Body) {
+            throw new Error(`Empty response body for parsed body: ${key}`);
+        }
+        const body = await response.Body.transformToByteArray();
+        const buffer = Buffer.from(body);
+        const decoded = response.ContentEncoding === "gzip" ? gunzipSync(buffer) : buffer;
+        return JSON.parse(decoded.toString("utf8"));
+    };
+    const retrieve = async (uri) => {
+        const { storageKey } = parseStorageUri(uri);
+        const response = await client.send(new GetObjectCommand({
+            Bucket: bucketName,
+            Key: storageKey,
+        }));
+        if (!response.Body) {
+            throw new Error(`Empty response body for: ${uri}`);
+        }
+        const body = await response.Body.transformToByteArray();
+        const buffer = Buffer.from(body);
+        if (response.ContentEncoding === "gzip") {
+            return gunzipSync(buffer);
+        }
+        return buffer;
+    };
+    const retrieveMessageBody = async (accountConfigId, accountId, messageId) => {
+        const key = buildMessageBodyKey(accountConfigId, accountId, messageId);
+        const response = await client
+            .send(new GetObjectCommand({ Bucket: bucketName, Key: key }))
+            .catch((error) => {
+            if (isStorageNotFoundError(error))
+                return null;
+            throw error;
+        });
+        if (!response)
+            return null;
+        if (!response.Body) {
+            throw new Error(`Empty response body for message body: ${key}`);
+        }
+        const body = await response.Body.transformToByteArray();
+        const buffer = Buffer.from(body);
+        return response.ContentEncoding === "gzip" ? gunzipSync(buffer) : buffer;
+    };
+    const retrieveMessageBodyStream = async (accountConfigId, accountId, messageId) => {
+        const key = buildMessageBodyKey(accountConfigId, accountId, messageId);
+        const response = await client
+            .send(new GetObjectCommand({ Bucket: bucketName, Key: key }))
+            .catch((error) => {
+            if (isStorageNotFoundError(error))
+                return null;
+            throw error;
+        });
+        if (!response)
+            return null;
+        if (!response.Body) {
+            throw new Error(`Empty response body for message body: ${key}`);
+        }
+        const source = response.Body;
+        if (response.ContentEncoding === "gzip") {
+            return source.pipe(createGunzip());
+        }
+        return source;
+    };
+    const exists = async (uri) => {
+        const { storageKey } = parseStorageUri(uri);
+        return client
+            .send(new HeadObjectCommand({
+            Bucket: bucketName,
+            Key: storageKey,
+        }))
+            .then(() => true)
+            .catch(() => false);
+    };
+    const del = async (uri) => {
+        const { storageKey } = parseStorageUri(uri);
+        await client.send(new DeleteObjectCommand({
+            Bucket: bucketName,
+            Key: storageKey,
+        }));
+    };
+    const storeExportArchiveStream = async (accountConfigId, exportRequestId, body) => {
+        const key = buildExportArchiveKey(accountConfigId, exportRequestId);
+        const upload = new Upload({
+            client,
+            params: {
+                Bucket: bucketName,
+                Key: key,
+                Body: body,
+                ContentType: "application/zip",
+            },
+        });
+        await upload.done().catch(async (error) => {
+            await upload.abort().catch(() => { });
+            throw error;
+        });
+        return key;
+    };
+    const getPresignedDownloadUrl = (key, expiresInSeconds) => getSignedUrl(client, new GetObjectCommand({ Bucket: bucketName, Key: key }), { expiresIn: expiresInSeconds });
+    return {
+        storeMessageBody,
+        storeBodyPart,
+        bodyPartExists,
+        retrieveBodyPart,
+        storeOutboxAttachment,
+        listOutboxAttachments,
+        listOutboxDraftsWithAttachments,
+        deleteOutboxAttachments,
+        deleteOutboxAttachment,
+        statOutboxAttachment,
+        retrieveOutboxAttachment,
+        createOutboxAttachmentUploadUrl,
+        storeDeduplicated,
+        storeParsedBody,
+        retrieveParsedBody,
+        retrieveMessageBody,
+        retrieveMessageBodyStream,
+        retrieve,
+        exists,
+        delete: del,
+        storeExportArchiveStream,
+        getPresignedDownloadUrl,
+    };
+};

package/dist/filesystem.js

@@ -0,0 +1 @@
+export { createFilesystemStorageService } from "./backends/filesystem.js";