@chidchanun/bcp 0.1.23 → 0.1.25

package/packages/server/src/file-delivery.ts

@@ -0,0 +1,629 @@
+import path from "node:path";
+
+import {
+    StorageError,
+    type StorageAdapter,
+    type StorageObjectMetadata,
+} from "./storage.js";
+
+export interface StorageResponseOptions {
+    cacheControl?: string;
+    contentType?: string;
+    disposition?:
+        "inline" |
+        "attachment";
+    downloadName?: string;
+    headers?: HeadersInit;
+}
+
+interface ByteRange {
+    start: number;
+    end: number;
+}
+
+export async function createStorageResponse(
+    request: Request,
+    storage: StorageAdapter,
+    key: string,
+    options: StorageResponseOptions = {}
+): Promise<Response> {
+    const method =
+        request.method
+            .toUpperCase();
+
+    if (
+        method !== "GET" &&
+        method !== "HEAD"
+    ) {
+        return new Response(
+            "Method Not Allowed",
+            {
+                status: 405,
+                headers: {
+                    Allow:
+                        "GET, HEAD",
+                },
+            }
+        );
+    }
+
+    const metadata =
+        await storage.stat(
+            key
+        );
+
+    if (!metadata) {
+        return new Response(
+            "Not Found",
+            {
+                status: 404,
+            }
+        );
+    }
+
+    const baseHeaders =
+        createBaseHeaders(
+            metadata,
+            options
+        );
+
+    if (
+        isNotModified(
+            request,
+            metadata
+        )
+    ) {
+        stripEntityLengthHeaders(
+            baseHeaders
+        );
+
+        return new Response(
+            null,
+            {
+                status: 304,
+                headers:
+                    baseHeaders,
+            }
+        );
+    }
+
+    const rangeHeader =
+        request.headers.get(
+            "range"
+        );
+    const canUseRange =
+        rangeHeader !== null &&
+        ifRangeAllowsPartial(
+            request.headers.get(
+                "if-range"
+            ),
+            metadata
+        );
+
+    if (canUseRange) {
+        const range =
+            parseByteRange(
+                rangeHeader,
+                metadata.size
+            );
+
+        if (!range) {
+            baseHeaders.set(
+                "Content-Range",
+                `bytes */${metadata.size}`
+            );
+            baseHeaders.set(
+                "Content-Length",
+                "0"
+            );
+
+            return new Response(
+                null,
+                {
+                    status: 416,
+                    headers:
+                        baseHeaders,
+                }
+            );
+        }
+
+        const length =
+            range.end -
+            range.start +
+            1;
+
+        baseHeaders.set(
+            "Content-Range",
+            `bytes ${range.start}-${range.end}/${metadata.size}`
+        );
+        baseHeaders.set(
+            "Content-Length",
+            String(length)
+        );
+
+        const body =
+            method === "HEAD"
+                ? null
+                : toResponseBody(
+                    await storage.read(
+                        key,
+                        range
+                    )
+                );
+
+        return new Response(
+            body,
+            {
+                status: 206,
+                headers:
+                    baseHeaders,
+            }
+        );
+    }
+
+    baseHeaders.set(
+        "Content-Length",
+        String(
+            metadata.size
+        )
+    );
+
+    const body =
+        method === "HEAD"
+            ? null
+            : toResponseBody(
+                await storage.read(
+                    key
+                )
+            );
+
+    return new Response(
+        body,
+        {
+            status: 200,
+            headers:
+                baseHeaders,
+        }
+    );
+}
+
+function createBaseHeaders(
+    metadata: StorageObjectMetadata,
+    options: StorageResponseOptions
+): Headers {
+    const headers =
+        new Headers(
+            options.headers
+        );
+
+    headers.set(
+        "Accept-Ranges",
+        "bytes"
+    );
+    headers.set(
+        "Content-Type",
+        normalizeHeaderContentType(
+            options.contentType ??
+            metadata.contentType
+        )
+    );
+    headers.set(
+        "ETag",
+        metadata.etag
+    );
+    headers.set(
+        "Last-Modified",
+        metadata.lastModified
+            .toUTCString()
+    );
+    headers.set(
+        "Cache-Control",
+        normalizeCacheControl(
+            options.cacheControl
+        )
+    );
+
+    if (
+        options.downloadName !==
+            undefined ||
+        options.disposition !==
+            undefined
+    ) {
+        const disposition =
+            options.disposition ??
+            "attachment";
+        const fileName =
+            options.downloadName ??
+            path.basename(
+                metadata.key
+            );
+
+        headers.set(
+            "Content-Disposition",
+            createContentDisposition(
+                disposition,
+                fileName
+            )
+        );
+    }
+
+    return headers;
+}
+
+function isNotModified(
+    request: Request,
+    metadata: StorageObjectMetadata
+): boolean {
+    const ifNoneMatch =
+        request.headers.get(
+            "if-none-match"
+        );
+
+    if (ifNoneMatch) {
+        return etagListMatches(
+            ifNoneMatch,
+            metadata.etag
+        );
+    }
+
+    const ifModifiedSince =
+        request.headers.get(
+            "if-modified-since"
+        );
+
+    if (!ifModifiedSince) {
+        return false;
+    }
+
+    const timestamp =
+        Date.parse(
+            ifModifiedSince
+        );
+
+    if (
+        !Number.isFinite(
+            timestamp
+        )
+    ) {
+        return false;
+    }
+
+    return Math.trunc(
+        metadata.lastModified.getTime() /
+        1000
+    ) <=
+    Math.trunc(
+        timestamp /
+        1000
+    );
+}
+
+function ifRangeAllowsPartial(
+    value: string | null,
+    metadata: StorageObjectMetadata
+): boolean {
+    if (!value) {
+        return true;
+    }
+
+    const normalized =
+        value.trim();
+
+    if (
+        normalized.startsWith("\"") ||
+        normalized.startsWith(
+            "W/\""
+        )
+    ) {
+        return normalized ===
+            metadata.etag;
+    }
+
+    const timestamp =
+        Date.parse(
+            normalized
+        );
+
+    if (
+        !Number.isFinite(
+            timestamp
+        )
+    ) {
+        return false;
+    }
+
+    return metadata.lastModified
+        .getTime() <=
+        timestamp;
+}
+
+function parseByteRange(
+    value: string,
+    size: number
+): ByteRange | null {
+    if (
+        size <= 0 ||
+        !value
+            .toLowerCase()
+            .startsWith(
+                "bytes="
+            )
+    ) {
+        return null;
+    }
+
+    const raw =
+        value.slice(
+            "bytes=".length
+        )
+            .trim();
+
+    if (
+        raw.length === 0 ||
+        raw.includes(",")
+    ) {
+        return null;
+    }
+
+    const separator =
+        raw.indexOf("-");
+
+    if (separator < 0) {
+        return null;
+    }
+
+    const startText =
+        raw
+            .slice(
+                0,
+                separator
+            )
+            .trim();
+    const endText =
+        raw
+            .slice(
+                separator + 1
+            )
+            .trim();
+
+    if (
+        startText.length === 0
+    ) {
+        const suffixLength =
+            parseRangeInteger(
+                endText
+            );
+
+        if (
+            suffixLength === null ||
+            suffixLength <= 0
+        ) {
+            return null;
+        }
+
+        const length =
+            Math.min(
+                suffixLength,
+                size
+            );
+
+        return {
+            start:
+                size - length,
+            end:
+                size - 1,
+        };
+    }
+
+    const start =
+        parseRangeInteger(
+            startText
+        );
+
+    if (
+        start === null ||
+        start >= size
+    ) {
+        return null;
+    }
+
+    if (
+        endText.length === 0
+    ) {
+        return {
+            start,
+            end:
+                size - 1,
+        };
+    }
+
+    const requestedEnd =
+        parseRangeInteger(
+            endText
+        );
+
+    if (
+        requestedEnd === null ||
+        requestedEnd < start
+    ) {
+        return null;
+    }
+
+    return {
+        start,
+        end:
+            Math.min(
+                requestedEnd,
+                size - 1
+            ),
+    };
+}
+
+function parseRangeInteger(
+    value: string
+): number | null {
+    if (
+        !/^\d+$/.test(
+            value
+        )
+    ) {
+        return null;
+    }
+
+    const parsed =
+        Number(
+            value
+        );
+
+    return Number.isSafeInteger(
+        parsed
+    )
+        ? parsed
+        : null;
+}
+
+function etagListMatches(
+    value: string,
+    etag: string
+): boolean {
+    return value
+        .split(",")
+        .map(
+            (entry) =>
+                entry.trim()
+        )
+        .some(
+            (entry) =>
+                entry === "*" ||
+                entry === etag
+        );
+}
+
+function createContentDisposition(
+    disposition:
+        "inline" |
+        "attachment",
+    fileName: string
+): string {
+    const normalized =
+        path.basename(
+            fileName
+                .replace(
+                    /\\/g,
+                    "/"
+                )
+        )
+            .replace(
+                /[\u0000-\u001F\u007F]/g,
+                ""
+            )
+            .trim();
+    const safeName =
+        normalized ||
+        "download";
+    const asciiName =
+        safeName
+            .replace(
+                /[^\x20-\x7E]/g,
+                "_"
+            )
+            .replace(
+                /["\\]/g,
+                "_"
+            );
+    const encoded =
+        encodeURIComponent(
+            safeName
+        )
+            .replace(
+                /['()*]/g,
+                (character) =>
+                    `%${character
+                        .charCodeAt(0)
+                        .toString(16)
+                        .toUpperCase()}`
+            );
+
+    return `${disposition}; filename="${asciiName}"; filename*=UTF-8''${encoded}`;
+}
+
+function normalizeCacheControl(
+    value: string | undefined
+): string {
+    if (
+        value === undefined
+    ) {
+        return "private, max-age=0, must-revalidate";
+    }
+
+    const normalized =
+        value.trim();
+
+    if (
+        normalized.length === 0 ||
+        /[\r\n]/.test(
+            normalized
+        )
+    ) {
+        throw new TypeError(
+            "BCP Framework: file response cacheControl must be a non-empty header value."
+        );
+    }
+
+    return normalized;
+}
+
+function normalizeHeaderContentType(
+    value: string
+): string {
+    const normalized =
+        value.trim();
+
+    if (
+        normalized.length === 0 ||
+        /[\r\n]/.test(
+            normalized
+        )
+    ) {
+        return "application/octet-stream";
+    }
+
+    return normalized;
+}
+
+function stripEntityLengthHeaders(
+    headers: Headers
+): void {
+    headers.delete(
+        "Content-Length"
+    );
+    headers.delete(
+        "Content-Range"
+    );
+}
+
+function toResponseBody(
+    bytes: Uint8Array
+): ArrayBuffer {
+    const body =
+        new Uint8Array(
+            bytes.byteLength
+        );
+
+    body.set(
+        bytes
+    );
+
+    return body.buffer;
+}
+
+export function isStorageRangeError(
+    error: unknown
+): error is StorageError {
+    return (
+        error instanceof
+            StorageError &&
+        error.code ===
+            "RANGE_NOT_SATISFIABLE"
+    );
+}