Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/apps/api/src/storage.ts
T

253 lines
9.0 KiB
TypeScript

import { createHash, createHmac } from "node:crypto";
import {
StorageAdapterError,
createS3SignedUrlAdapter,
createS3StorageAdapter,
type CreateSignedDownloadUrlInput,
type S3StorageAdapterConfig,
type SignedDownloadSignerInput,
type SignedDownloadUrlResult,
type StorageAdapter,
type UploadBody,
} from "@toolctrl/storage";
import { getApiRuntimeConfig } from "./config.js";
/**
* Caches the per-config S3 storage adapter, signed-URL adapter and the per-day
* SigV4 signing key to avoid reconstructing them on every hot-path call.
*
* Cache key intentionally hashes the secret access key (never stores it raw)
* and includes endpoint/region/accessKeyId/forcePathStyle so a credential
* rotation transparently misses the cache and rebuilds the adapter.
*/
const storageAdapterCache = new Map<string, StorageAdapter>();
const signedUrlAdapterCache = new Map<string, ReturnType<typeof createS3SignedUrlAdapter>>();
const signingKeyCache = new Map<string, Buffer>();
function storageAdapterCacheKey(config: S3StorageAdapterConfig): string {
const secretFingerprint = createHash("sha256").update(config.secretAccessKey ?? "").digest("hex");
return createHash("sha256")
.update(
JSON.stringify({
endpoint: config.endpoint,
region: config.region,
bucket: config.bucket,
accessKeyId: config.accessKeyId,
sessionToken: config.sessionToken ?? null,
publicBaseUrl: config.publicBaseUrl ?? null,
forcePathStyle: config.forcePathStyle ?? null,
secretFingerprint,
}),
)
.digest("hex");
}
function getCachedStorageAdapter(config: S3StorageAdapterConfig): StorageAdapter {
const key = storageAdapterCacheKey(config);
let adapter = storageAdapterCache.get(key);
if (!adapter) {
adapter = createS3StorageAdapter(config);
storageAdapterCache.set(key, adapter);
}
return adapter;
}
function getCachedSignedUrlAdapter(config: S3StorageAdapterConfig) {
const key = storageAdapterCacheKey(config);
let adapter = signedUrlAdapterCache.get(key);
if (!adapter) {
adapter = createS3SignedUrlAdapter({
bucket: config.bucket,
downloadSigner: (signerInput) => createS3SignedGetUrl(config, signerInput),
uploadSigner: () => {
throw new StorageAdapterError("signed_upload_failed", "Signed upload URLs are not supported by the API storage helper.", {
operation: "createSignedUploadUrl",
bucket: config.bucket,
});
},
});
signedUrlAdapterCache.set(key, adapter);
}
return adapter;
}
/** Test-only: drop cached adapters and signing keys. */
export function resetStorageCachesForTests() {
storageAdapterCache.clear();
signedUrlAdapterCache.clear();
signingKeyCache.clear();
}
/** Test-only: inspect cache sizes for assertions. */
export function storageCacheStatsForTests() {
return {
adapters: storageAdapterCache.size,
signedUrlAdapters: signedUrlAdapterCache.size,
signingKeys: signingKeyCache.size,
};
}
function createStorageAdapterConfig(bucket: string): S3StorageAdapterConfig {
const { storage } = getApiRuntimeConfig();
return {
endpoint: storage.endpoint ?? "",
region: storage.region ?? "",
bucket,
accessKeyId: storage.accessKeyId ?? "",
secretAccessKey: storage.secretAccessKey ?? "",
sessionToken: storage.sessionToken,
publicBaseUrl: storage.publicBaseUrl,
forcePathStyle: storage.forcePathStyle === undefined ? undefined : storage.forcePathStyle.toLowerCase() === "true",
};
}
export async function createStorageFile(
bucketId: string,
path: string,
file: UploadBody,
contentType?: string,
): Promise<{
id: string;
publicUrl: string | null;
}> {
const adapter = getCachedStorageAdapter(createStorageAdapterConfig(bucketId));
const createdFile = await adapter.putObject({
key: path,
body: file,
contentType,
});
return {
id: createdFile.key,
publicUrl: createdFile.publicUrl,
};
}
export type CreateStorageSignedDownloadUrlInput = CreateSignedDownloadUrlInput;
export type StorageSignedDownloadUrlResult = Pick<SignedDownloadUrlResult, "url" | "method" | "expiresAt" | "expiresInSeconds" | "headers">;
export async function createStorageSignedDownloadUrl(
bucketId: string,
input: CreateStorageSignedDownloadUrlInput,
): Promise<StorageSignedDownloadUrlResult> {
const adapterConfig = createStorageAdapterConfig(bucketId);
const adapter = getCachedSignedUrlAdapter(adapterConfig);
const result = await adapter.createSignedDownloadUrl(input);
return {
url: result.url,
method: result.method,
expiresAt: result.expiresAt,
expiresInSeconds: result.expiresInSeconds,
headers: result.headers,
};
}
function createS3SignedGetUrl(config: S3StorageAdapterConfig, input: SignedDownloadSignerInput): string {
const missingFields = ["endpoint", "region", "bucket", "accessKeyId", "secretAccessKey"].filter((field) => !isPresent(config[field as keyof S3StorageAdapterConfig]));
if (missingFields.length > 0) {
throw new StorageAdapterError("config_missing", `Missing signed URL storage configuration: ${missingFields.join(", ")}`, {
operation: "createStorageSignedDownloadUrl",
bucket: isPresent(config.bucket) ? config.bucket : undefined,
key: input.key,
missingFields,
});
}
const endpoint = new URL(config.endpoint);
const bucketSegment = encodePathSegment(config.bucket);
const keyPath = input.key.split("/").map(encodePathSegment).join("/");
const pathname = config.forcePathStyle ? `${trimTrailingSlash(endpoint.pathname)}/${bucketSegment}/${keyPath}` : `${trimTrailingSlash(endpoint.pathname)}/${keyPath}`;
const host = config.forcePathStyle ? endpoint.host : `${config.bucket}.${endpoint.host}`;
const url = new URL(endpoint.toString());
url.host = host;
url.pathname = pathname;
url.search = "";
if (input.responseContentType) {
url.searchParams.set("response-content-type", input.responseContentType);
}
if (input.responseContentDisposition) {
url.searchParams.set("response-content-disposition", input.responseContentDisposition);
}
const now = new Date();
const amzDate = toAmzDate(now);
const dateStamp = amzDate.slice(0, 8);
const credentialScope = `${dateStamp}/${config.region}/s3/aws4_request`;
const signedHeaders = "host";
url.searchParams.set("X-Amz-Algorithm", "AWS4-HMAC-SHA256");
url.searchParams.set("X-Amz-Credential", `${config.accessKeyId}/${credentialScope}`);
url.searchParams.set("X-Amz-Date", amzDate);
url.searchParams.set("X-Amz-Expires", String(input.expiresInSeconds));
url.searchParams.set("X-Amz-SignedHeaders", signedHeaders);
if (config.sessionToken) {
url.searchParams.set("X-Amz-Security-Token", config.sessionToken);
}
const canonicalQuery = canonicalizeSearchParams(url.searchParams);
const canonicalRequest = ["GET", url.pathname, canonicalQuery, `host:${host}\n`, signedHeaders, "UNSIGNED-PAYLOAD"].join("\n");
const stringToSign = ["AWS4-HMAC-SHA256", amzDate, credentialScope, sha256Hex(canonicalRequest)].join("\n");
const signature = hmacHex(getSigningKey(config.secretAccessKey, dateStamp, config.region), stringToSign);
url.searchParams.set("X-Amz-Signature", signature);
return url.toString();
}
function canonicalizeSearchParams(params: URLSearchParams): string {
return [...params.entries()]
.sort(([leftKey, leftValue], [rightKey, rightValue]) => leftKey.localeCompare(rightKey) || leftValue.localeCompare(rightValue))
.map(([key, value]) => `${encodeRfc3986(key)}=${encodeRfc3986(value)}`)
.join("&");
}
function getSigningKey(secretAccessKey: string, dateStamp: string, region: string): Buffer {
const secretFingerprint = createHash("sha256").update(secretAccessKey).digest("hex");
const cacheKey = `${secretFingerprint}:${region}:${dateStamp}`;
const cached = signingKeyCache.get(cacheKey);
if (cached) {
return cached;
}
const dateKey = hmacBuffer(`AWS4${secretAccessKey}`, dateStamp);
const regionKey = hmacBuffer(dateKey, region);
const serviceKey = hmacBuffer(regionKey, "s3");
const signingKey = hmacBuffer(serviceKey, "aws4_request");
signingKeyCache.set(cacheKey, signingKey);
return signingKey;
}
function hmacBuffer(key: string | Buffer, value: string): Buffer {
return createHmac("sha256", key).update(value).digest();
}
function hmacHex(key: string | Buffer, value: string): string {
return createHmac("sha256", key).update(value).digest("hex");
}
function sha256Hex(value: string): string {
return createHash("sha256").update(value).digest("hex");
}
function toAmzDate(date: Date): string {
return date.toISOString().replace(/[:-]|\.\d{3}/g, "");
}
function encodePathSegment(segment: string): string {
return encodeRfc3986(segment);
}
function encodeRfc3986(value: string): string {
return encodeURIComponent(value).replace(/[!'()*]/g, (character) => `%${character.charCodeAt(0).toString(16).toUpperCase()}`);
}
function trimTrailingSlash(pathname: string): string {
return pathname.replace(/\/+$/, "");
}
function isPresent(value: unknown): value is string {
return typeof value === "string" && value.trim().length > 0;
}