nolo-cli 0.1.13 → 0.1.15

package/database/server/ensureDbOpen.ts

@@ -0,0 +1,12 @@
+export type DbWithOpenStatus = {
+  status?: string | null;
+  open(): Promise<unknown>;
+};
+
+export async function ensureDbOpen(db: DbWithOpenStatus) {
+  if (db.status === "open") {
+    return;
+  }
+
+  await db.open();
+}

package/database/server/fileRead.ts

@@ -0,0 +1,337 @@
+// 文件路径: database/server/fileRead.ts
+
+import { Request } from "bun";
+import {
+    getFileMetadataById,
+    getFileContentById,
+    hasFileTombstoneById,
+    saveBufferAsFile,
+    FileMetadata,
+} from "./fileService";
+
+const UPSTREAM_DB_BASE = process.env.FILE_UPSTREAM_DB_BASE || "";
+
+/**
+ * 从 Request.url 中解析 fileId
+ */
+const extractFileIdFromRequest = (req: Request): string | null => {
+    try {
+        const url = new URL(req.url);
+        const segments = url.pathname.split("/").filter(Boolean);
+        if (!segments.length) return null;
+        return segments[segments.length - 1] || null;
+    } catch {
+        return null;
+    }
+};
+
+const buildFileContentHeaders = (
+    metadata: FileMetadata,
+    contentLength = metadata.size
+): HeadersInit => {
+    const headers: Record<string, string> = {
+        "Content-Type": metadata.mimeType || "application/octet-stream",
+    };
+
+    if (Number.isFinite(contentLength) && contentLength >= 0) {
+        headers["Content-Length"] = String(contentLength);
+    }
+
+    return headers;
+};
+
+const fetchUpstreamMetadata = async (
+    fileId: string,
+    { logWhenUnavailable = false }: { logWhenUnavailable?: boolean } = {}
+): Promise<FileMetadata | null> => {
+    if (!UPSTREAM_DB_BASE) {
+        if (logWhenUnavailable) {
+            console.warn(
+                "[fileRead] FILE_UPSTREAM_DB_BASE is not set, skip upstream sync."
+            );
+        }
+        return null;
+    }
+
+    const metaUrl = `${UPSTREAM_DB_BASE}/file/metadata/${fileId}`;
+    console.debug("[fileRead] Fetching upstream metadata:", metaUrl);
+    const metaRes = await fetch(metaUrl, {
+        method: "GET",
+        headers: { accept: "application/json" },
+    });
+
+    if (!metaRes.ok) {
+        console.warn(
+            "[fileRead] Upstream metadata fetch failed:",
+            metaRes.status,
+            await metaRes.text().catch(() => "")
+        );
+        return null;
+    }
+
+    const upstreamMeta = (await metaRes.json()) as any;
+    if (!upstreamMeta || !upstreamMeta.id) {
+        console.warn(
+            "[fileRead] Upstream metadata invalid for fileId:",
+            fileId,
+            upstreamMeta
+        );
+        return null;
+    }
+
+    return upstreamMeta as FileMetadata;
+};
+
+/**
+ * 尝试从上游服务器拉取文件，并写入本地 Blob/FileMetadata。
+ *
+ * 成功时返回 { buffer, metadata }，失败时返回 null。
+ */
+const syncFileFromUpstream = async (
+    fileId: string
+): Promise<{ buffer: Buffer; metadata: FileMetadata } | null> => {
+    try {
+        if (await hasFileTombstoneById(fileId)) {
+            console.info("[fileRead] Skip upstream sync for tombstoned file:", fileId);
+            return null;
+        }
+
+        const upstreamMeta = await fetchUpstreamMetadata(fileId, {
+            logWhenUnavailable: true,
+        });
+        if (!upstreamMeta) {
+            return null;
+        }
+
+        const contentUrl = `${UPSTREAM_DB_BASE}/file/content/${fileId}`;
+        console.debug("[fileRead] Fetching upstream content:", contentUrl);
+        const contentRes = await fetch(contentUrl, {
+            method: "GET",
+        });
+
+        if (!contentRes.ok || !contentRes.body) {
+            console.warn(
+                "[fileRead] Upstream content fetch failed:",
+                contentRes.status,
+                await contentRes.text().catch(() => "")
+            );
+            return null;
+        }
+
+        const arrayBuffer = await contentRes.arrayBuffer();
+        const buffer = Buffer.from(arrayBuffer);
+
+        const tenantId = upstreamMeta.tenantId || "default";
+        const ownerDbKey =
+            upstreamMeta.ownerDbKey ?? upstreamMeta.dbKey ?? undefined;
+
+        const { metadata } = await saveBufferAsFile(buffer, {
+            tenantId,
+            originalName: upstreamMeta.originalName || "upstream-import",
+            mimeType: upstreamMeta.mimeType || "application/octet-stream",
+
+            ownerType: upstreamMeta.ownerType,
+            ownerId: upstreamMeta.ownerId,
+            uploadedBy: upstreamMeta.uploadedBy,
+
+            ownerDbKey,
+            source: upstreamMeta.source,
+            model: upstreamMeta.model,
+            prompt: upstreamMeta.prompt,
+            tags: upstreamMeta.tags,
+
+            clientMetadata: upstreamMeta,
+            clientProvidedId: upstreamMeta.id,
+        });
+
+        console.info(
+            "[fileRead] Synced file from upstream:",
+            fileId,
+            "tenantId=",
+            metadata.tenantId
+        );
+
+        return { buffer, metadata };
+    } catch (err) {
+        console.error(
+            "[fileRead] syncFileFromUpstream error for fileId=",
+            fileId,
+            err
+        );
+        return null;
+    }
+};
+
+/**
+ * GET /database/file/metadata/:id
+ */
+export const handleGetFileMetadata = async (
+    req: Request
+): Promise<Response> => {
+    const fileId = extractFileIdFromRequest(req);
+    if (!fileId) {
+        return new Response(JSON.stringify({ error: "Invalid file id" }), {
+            status: 400,
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+
+    try {
+        const metadata = await getFileMetadataById(fileId);
+        if (!metadata) {
+            if (await hasFileTombstoneById(fileId)) {
+                return new Response(JSON.stringify({ error: "File not found" }), {
+                    status: 404,
+                    headers: { "Content-Type": "application/json" },
+                });
+            }
+
+            const upstreamMetadata = await fetchUpstreamMetadata(fileId);
+            if (upstreamMetadata) {
+                return new Response(JSON.stringify(upstreamMetadata satisfies FileMetadata), {
+                    status: 200,
+                    headers: { "Content-Type": "application/json" },
+                });
+            }
+
+            return new Response(JSON.stringify({ error: "File not found" }), {
+                status: 404,
+                headers: { "Content-Type": "application/json" },
+            });
+        }
+
+        return new Response(JSON.stringify(metadata satisfies FileMetadata), {
+            status: 200,
+            headers: { "Content-Type": "application/json" },
+        });
+    } catch (error: any) {
+        console.error("[handleGetFileMetadata] Error:", error);
+        return new Response(
+            JSON.stringify({
+                error: "Failed to read file metadata",
+                details: error?.message || "Unknown error",
+            }),
+            {
+                status: 500,
+                headers: { "Content-Type": "application/json" },
+            }
+        );
+    }
+};
+
+const getLocalFileHead = async (
+    fileId: string
+): Promise<{ metadata: FileMetadata; contentLength: number }> => {
+    const metadata = await getFileMetadataById(fileId);
+    if (!metadata) {
+        throw new Error(`File not found: ${fileId}`);
+    }
+
+    const file = Bun.file(metadata.filePath);
+    const exists = await file.exists();
+    if (!exists) {
+        throw new Error(`File content missing on disk: ${fileId}`);
+    }
+
+    return {
+        metadata,
+        contentLength: metadata.size,
+    };
+};
+
+/**
+ * GET /database/file/content/:id
+ */
+export const handleGetFileContent = async (
+    req: Request
+): Promise<Response> => {
+    const fileId = extractFileIdFromRequest(req);
+    if (!fileId) {
+        return new Response(JSON.stringify({ error: "Invalid file id" }), {
+            status: 400,
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+
+    try {
+        const { buffer, metadata } = await getFileContentById(fileId);
+
+        return new Response(buffer, {
+            status: 200,
+            headers: buildFileContentHeaders(metadata, buffer.byteLength),
+        });
+    } catch (error: any) {
+        console.warn(
+            "[handleGetFileContent] Local read failed for",
+            fileId,
+            "error=",
+            error?.message
+        );
+
+        const upstreamResult = await syncFileFromUpstream(fileId);
+        if (upstreamResult) {
+            const { buffer, metadata } = upstreamResult;
+
+            return new Response(buffer, {
+                status: 200,
+                headers: buildFileContentHeaders(metadata, buffer.byteLength),
+            });
+        }
+
+        const message = error?.message || "Unknown error";
+        const status = /not found/i.test(message) ? 404 : 500;
+
+        return new Response(
+            JSON.stringify({
+                error: "Failed to read file content",
+                details: message,
+            }),
+            {
+                status,
+                headers: { "Content-Type": "application/json" },
+            }
+        );
+    }
+};
+
+export const handleHeadFileContent = async (
+    req: Request
+): Promise<Response> => {
+    const fileId = extractFileIdFromRequest(req);
+    if (!fileId) {
+        return new Response(null, { status: 400 });
+    }
+
+    let localError: any = null;
+    try {
+        const { metadata, contentLength } = await getLocalFileHead(fileId);
+        return new Response(null, {
+            status: 200,
+            headers: buildFileContentHeaders(metadata, contentLength),
+        });
+    } catch (error: any) {
+        localError = error;
+        console.warn(
+            "[handleHeadFileContent] Local head failed for",
+            fileId,
+            "error=",
+            error?.message
+        );
+    }
+
+    if (await hasFileTombstoneById(fileId)) {
+        return new Response(null, { status: 404 });
+    }
+
+    const upstreamMetadata = await fetchUpstreamMetadata(fileId);
+    if (upstreamMetadata) {
+        return new Response(null, {
+            status: 200,
+            headers: buildFileContentHeaders(upstreamMetadata),
+        });
+    }
+
+    const message = localError?.message || `File not found: ${fileId}`;
+    const status = /not found/i.test(message) ? 404 : 500;
+    return new Response(null, { status });
+};