@remit/storage-service 0.0.12 → 0.0.14

package/dist/storage.js

@@ -0,0 +1,219 @@
+import { createHash } from "node:crypto";
+import { Readable } from "node:stream";
+import { ContentEncoding, StorageType } from "@remit/domain-enums";
+// Path builders - centralized path formatting per RFC 011 + #224.
+// The outer segment is `accountConfigId` (Cognito-derived tenant scope) so
+// the edge can verify cross-tenant isolation at the URL prefix without
+// loading any database record. The inner `accountId` distinguishes between
+// multiple IMAP-account records owned by the same tenant.
+export const buildMessageBodyKey = (accountConfigId, accountId, messageId) => `accounts/${accountConfigId}/${accountId}/messages/${messageId}/body.eml`;
+export const buildParsedBodyKey = (accountConfigId, accountId, messageId) => `accounts/${accountConfigId}/${accountId}/messages/${messageId}/parsed.json.gz`;
+export const buildBodyPartKey = (accountConfigId, accountId, messageId, partPath) => `accounts/${accountConfigId}/${accountId}/messages/${messageId}/parts/${partPath}`;
+export const buildOutboxAttachmentPrefix = (accountConfigId, accountId, outboxMessageId) => `accounts/${accountConfigId}/${accountId}/outbox/${outboxMessageId}/attachments/`;
+export const buildOutboxAttachmentKey = (accountConfigId, accountId, outboxMessageId, outboxAttachmentId) => `${buildOutboxAttachmentPrefix(accountConfigId, accountId, outboxMessageId)}${outboxAttachmentId}`;
+// Every segment is a generated id, so the shape is closed rather than
+// "anything without a slash": `..` matches `[^/]+` and the write side joins
+// this key onto a filesystem root. The read side has `resolveContentPath` for
+// the same reason (#310 review P1) — a signature should not be the only thing
+// standing between a URL and the storage root.
+const OUTBOX_ATTACHMENT_KEY = /^accounts\/([A-Za-z0-9_-]+)\/([A-Za-z0-9_-]+)\/outbox\/([A-Za-z0-9_-]+)\/attachments\/([A-Za-z0-9_-]+)$/;
+/**
+ * Read the ids back out of an attachment key — the inverse of
+ * `buildOutboxAttachmentKey`, for the upload route, which is handed a path and
+ * has to work out what it addresses. Returns null on anything else, including a
+ * reservation key: bytes are never written to one.
+ */
+export const parseOutboxAttachmentKey = (storageKey) => {
+    const match = storageKey.match(OUTBOX_ATTACHMENT_KEY);
+    if (!match)
+        return null;
+    return {
+        accountConfigId: match[1],
+        accountId: match[2],
+        outboxMessageId: match[3],
+        outboxAttachmentId: match[4],
+    };
+};
+export const buildDeduplicatedKey = (accountConfigId, accountId, checksumSha256) => `accounts/${accountConfigId}/${accountId}/dedup/${checksumSha256.slice(0, 2)}/${checksumSha256}`;
+/**
+ * Parse the account/message ids out of a `/content/*` storage key such as
+ * `accounts/{accountConfigId}/{accountId}/messages/{messageId}/parts/1.2`
+ * (the inverse of `buildMessageBodyKey`/`buildParsedBodyKey`/`buildBodyPartKey`
+ * above). Returns null when the shape doesn't match.
+ */
+export const parseContentStorageKey = (storageKey) => {
+    const match = storageKey.match(/^accounts\/([^/]+)\/([^/]+)\/messages\/([^/]+)\//);
+    if (!match)
+        return null;
+    return {
+        accountConfigId: match[1],
+        accountId: match[2],
+        messageId: match[3],
+    };
+};
+export const computeChecksum = (content) => createHash("sha256").update(content).digest("hex");
+export const buildExportArchiveKey = (accountConfigId, exportRequestId) => `exports/${accountConfigId}/${exportRequestId}/export.zip`;
+export const isStorageNotFoundError = (error) => {
+    if (typeof error !== "object" || error === null)
+        return false;
+    const obj = error;
+    if (obj.name === "NoSuchKey")
+        return true;
+    if (obj.Code === "NoSuchKey")
+        return true;
+    if (obj.code === "ENOENT")
+        return true;
+    return false;
+};
+export const createMockStorageService = () => {
+    const storage = new Map();
+    const storeInternal = (key, content) => {
+        const checksumSha256 = computeChecksum(content);
+        const uri = `mock://${key}`;
+        storage.set(uri, content);
+        return {
+            uri,
+            storageType: StorageType.Filesystem,
+            storageLocation: "mock",
+            storageKey: key,
+            sizeBytes: content.length,
+            checksumSha256,
+            contentEncoding: ContentEncoding.None,
+        };
+    };
+    const storeMessageBody = async (params) => {
+        const { accountConfigId, accountId, messageId, content } = params;
+        return storeInternal(buildMessageBodyKey(accountConfigId, accountId, messageId), content);
+    };
+    const storeBodyPart = async (params) => {
+        const { accountConfigId, accountId, messageId, partPath, content } = params;
+        return storeInternal(buildBodyPartKey(accountConfigId, accountId, messageId, partPath), content);
+    };
+    const storeOutboxAttachment = async (params) => {
+        const { accountConfigId, accountId, outboxMessageId, outboxAttachmentId, content, } = params;
+        return storeInternal(buildOutboxAttachmentKey(accountConfigId, accountId, outboxMessageId, outboxAttachmentId), content);
+    };
+    const listOutboxAttachments = async (accountConfigId, accountId, outboxMessageId) => {
+        const prefix = `mock://${buildOutboxAttachmentPrefix(accountConfigId, accountId, outboxMessageId)}`;
+        const items = [];
+        for (const [uri, content] of storage.entries()) {
+            if (!uri.startsWith(prefix))
+                continue;
+            items.push({
+                outboxAttachmentId: uri.slice(prefix.length),
+                key: uri.slice("mock://".length),
+                sizeBytes: content.length,
+            });
+        }
+        return items;
+    };
+    const listOutboxDraftsWithAttachments = async (accountConfigId, accountId) => {
+        const root = `mock://accounts/${accountConfigId}/${accountId}/outbox/`;
+        const drafts = new Set();
+        for (const uri of storage.keys()) {
+            if (!uri.startsWith(root))
+                continue;
+            const rest = uri.slice(root.length);
+            const slash = rest.indexOf("/");
+            if (slash > 0)
+                drafts.add(rest.slice(0, slash));
+        }
+        return [...drafts];
+    };
+    const deleteOutboxAttachment = async (accountConfigId, accountId, outboxMessageId, outboxAttachmentId) => {
+        storage.delete(`mock://${buildOutboxAttachmentKey(accountConfigId, accountId, outboxMessageId, outboxAttachmentId)}`);
+    };
+    const statOutboxAttachment = async (accountConfigId, accountId, outboxMessageId, outboxAttachmentId) => {
+        const content = storage.get(`mock://${buildOutboxAttachmentKey(accountConfigId, accountId, outboxMessageId, outboxAttachmentId)}`);
+        return content ? { sizeBytes: content.length } : null;
+    };
+    const retrieveOutboxAttachment = async (accountConfigId, accountId, outboxMessageId, outboxAttachmentId) => storage.get(`mock://${buildOutboxAttachmentKey(accountConfigId, accountId, outboxMessageId, outboxAttachmentId)}`) ?? null;
+    const createOutboxAttachmentUploadUrl = async (params) => ({
+        uploadUrl: `mock://upload/${buildOutboxAttachmentKey(params.accountConfigId, params.accountId, params.outboxMessageId, params.outboxAttachmentId)}?max=${params.sizeBytes}&exp=${params.expiresAt}`,
+    });
+    const deleteOutboxAttachments = async (accountConfigId, accountId, outboxMessageId) => {
+        const prefix = `mock://${buildOutboxAttachmentPrefix(accountConfigId, accountId, outboxMessageId)}`;
+        for (const uri of [...storage.keys()]) {
+            if (uri.startsWith(prefix))
+                storage.delete(uri);
+        }
+    };
+    const storeDeduplicated = async (params) => {
+        const { accountConfigId, accountId, content } = params;
+        const checksumSha256 = computeChecksum(content);
+        return storeInternal(buildDeduplicatedKey(accountConfigId, accountId, checksumSha256), content);
+    };
+    const storeParsedBody = async (params) => {
+        const { accountConfigId, accountId, messageId, parsed } = params;
+        const content = Buffer.from(JSON.stringify(parsed), "utf8");
+        return storeInternal(buildParsedBodyKey(accountConfigId, accountId, messageId), content);
+    };
+    const retrieveParsedBody = async (accountConfigId, accountId, messageId) => {
+        const uri = `mock://${buildParsedBodyKey(accountConfigId, accountId, messageId)}`;
+        const content = storage.get(uri);
+        if (!content)
+            return null;
+        return JSON.parse(content.toString("utf8"));
+    };
+    const retrieveBodyPart = async (accountConfigId, accountId, messageId, partPath) => {
+        const uri = `mock://${buildBodyPartKey(accountConfigId, accountId, messageId, partPath)}`;
+        return storage.get(uri) ?? null;
+    };
+    const retrieveMessageBody = async (accountConfigId, accountId, messageId) => {
+        const uri = `mock://${buildMessageBodyKey(accountConfigId, accountId, messageId)}`;
+        return storage.get(uri) ?? null;
+    };
+    const retrieveMessageBodyStream = async (accountConfigId, accountId, messageId) => {
+        const uri = `mock://${buildMessageBodyKey(accountConfigId, accountId, messageId)}`;
+        const content = storage.get(uri);
+        if (!content)
+            return null;
+        return Readable.from(content);
+    };
+    const bodyPartExists = async (accountConfigId, accountId, messageId, partPath) => {
+        const uri = `mock://${buildBodyPartKey(accountConfigId, accountId, messageId, partPath)}`;
+        return storage.has(uri);
+    };
+    return {
+        storeMessageBody,
+        storeBodyPart,
+        bodyPartExists,
+        retrieveBodyPart,
+        storeOutboxAttachment,
+        listOutboxAttachments,
+        listOutboxDraftsWithAttachments,
+        deleteOutboxAttachments,
+        deleteOutboxAttachment,
+        statOutboxAttachment,
+        retrieveOutboxAttachment,
+        createOutboxAttachmentUploadUrl,
+        storeDeduplicated,
+        storeParsedBody,
+        retrieveParsedBody,
+        retrieveMessageBody,
+        retrieveMessageBodyStream,
+        retrieve: async (uri) => {
+            const content = storage.get(uri);
+            if (!content) {
+                throw Object.assign(new Error(`Not found: ${uri}`), {
+                    name: "NoSuchKey",
+                });
+            }
+            return content;
+        },
+        exists: async (uri) => storage.has(uri),
+        delete: async (uri) => {
+            storage.delete(uri);
+        },
+        storeExportArchiveStream: async (accountConfigId, exportRequestId, body) => {
+            const key = buildExportArchiveKey(accountConfigId, exportRequestId);
+            const chunks = [];
+            for await (const chunk of body) {
+                chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+            }
+            storage.set(`mock://${key}`, Buffer.concat(chunks));
+            return key;
+        },
+        getPresignedDownloadUrl: async (key, _expiresInSeconds) => `mock://presigned/${key}`,
+    };
+};

package/dist/uri.d.ts

@@ -0,0 +1,9 @@
+import { StorageType } from "@remit/domain-enums";
+export type StorageTypeValue = (typeof StorageType)[keyof typeof StorageType];
+export interface ParsedStorageUri {
+    storageType: StorageTypeValue;
+    storageLocation: string;
+    storageKey: string;
+}
+export declare const parseStorageUri: (uri: string) => ParsedStorageUri;
+export declare const buildStorageUri: (storageType: StorageTypeValue, storageLocation: string, storageKey: string) => string;

package/dist/uri.js

@@ -0,0 +1,28 @@
+import { StorageType } from "@remit/domain-enums";
+export const parseStorageUri = (uri) => {
+    const url = new URL(uri);
+    if (url.protocol === "s3:") {
+        return {
+            storageType: StorageType.S3,
+            storageLocation: url.hostname,
+            storageKey: url.pathname.slice(1),
+        };
+    }
+    if (url.protocol === "file:") {
+        return {
+            storageType: StorageType.Filesystem,
+            storageLocation: "",
+            storageKey: url.pathname,
+        };
+    }
+    throw new Error(`Unsupported storage URI scheme: ${url.protocol}`);
+};
+export const buildStorageUri = (storageType, storageLocation, storageKey) => {
+    if (storageType === StorageType.S3) {
+        return `s3://${storageLocation}/${storageKey}`;
+    }
+    if (storageType === StorageType.Filesystem) {
+        return `file://${storageLocation}/${storageKey}`;
+    }
+    throw new Error(`Unsupported storage type: ${storageType}`);
+};

package/package.json

@@ -1,48 +1,53 @@
 {
-  "name": "@remit/storage-service",
-  "version": "0.0.12",
-  "type": "module",
-  "main": "src/index.ts",
-  "types": "src/index.ts",
-  "exports": {
-    ".": {
-      "types": "./src/index.ts",
-      "default": "./src/index.ts"
-    },
-    "./filesystem": {
-      "types": "./src/filesystem.ts",
-      "default": "./src/filesystem.ts"
-    },
-    "./s3": {
-      "types": "./src/s3.ts",
-      "default": "./src/s3.ts"
-    },
-    "./signed-path": {
-      "types": "./src/signed-path.ts",
-      "default": "./src/signed-path.ts"
-    }
-  },
-  "scripts": {
-    "test:typecheck": "tsgo --noEmit",
-    "test:run": "node $NODE_TEST_FLAGS --env-file=../../localhost-test-unit.env --import tsx --experimental-test-coverage --test-coverage-include='src/**' --test-coverage-exclude='src/**/*.test.ts' --test-coverage-exclude='src/**/*.test.tsx' --test-coverage-lines=87 --test 'src/**/*.test.ts'",
-    "test": "npm run test:typecheck && npm run test:run"
-  },
-  "dependencies": {
-    "@aws-sdk/client-s3": "*",
-    "@aws-sdk/lib-storage": "*",
-    "@aws-sdk/s3-request-presigner": "*",
-    "@remit/domain-enums": "*"
-  },
-  "devDependencies": {
-    "aws-sdk-client-mock": "*"
-  },
-  "license": "MIT",
-  "publishConfig": {
-    "access": "public"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/remit-mail/reader.git",
-    "directory": "packages/storage-service"
-  }
+	"name": "@remit/storage-service",
+	"version": "0.0.14",
+	"type": "module",
+	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"default": "./dist/index.js"
+		},
+		"./filesystem": {
+			"types": "./dist/filesystem.d.ts",
+			"default": "./dist/filesystem.js"
+		},
+		"./s3": {
+			"types": "./dist/s3.d.ts",
+			"default": "./dist/s3.js"
+		},
+		"./signed-path": {
+			"types": "./dist/signed-path.d.ts",
+			"default": "./dist/signed-path.js"
+		}
+	},
+	"scripts": {
+		"prepack": "node ../../npm-scripts/pack-dist.mjs prepack",
+		"postpack": "node ../../npm-scripts/pack-dist.mjs postpack",
+		"test:typecheck": "tsgo --noEmit",
+		"test:run": "node $NODE_TEST_FLAGS --env-file=../../localhost-test-unit.env --import tsx --experimental-test-coverage --test-coverage-include='src/**' --test-coverage-exclude='src/**/*.test.ts' --test-coverage-exclude='src/**/*.test.tsx' --test-coverage-lines=87 --test 'src/**/*.test.ts'",
+		"test": "npm run test:typecheck && npm run test:run"
+	},
+	"dependencies": {
+		"@aws-sdk/client-s3": "^3.1090.0",
+		"@aws-sdk/lib-storage": "^3.1090.0",
+		"@aws-sdk/s3-request-presigner": "^3.1090.0",
+		"@remit/domain-enums": "*"
+	},
+	"devDependencies": {
+		"aws-sdk-client-mock": "*"
+	},
+	"license": "MIT",
+	"publishConfig": {
+		"access": "public"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/remit-mail/reader.git",
+		"directory": "packages/storage-service"
+	},
+	"files": [
+		"dist"
+	]
 }