create-windy 0.1.0

package/template/packages/storage/src/file-service.test.ts

@@ -0,0 +1,100 @@
+import { createHash } from "node:crypto";
+import { describe, expect, test } from "bun:test";
+import { FileService } from "./file-service.js";
+import { InMemoryUploadRepository } from "./in-memory-upload-repository.js";
+import { MemoryBlobStore } from "./memory-blob-store.js";
+import { UploadService } from "./upload-service.js";
+
+const policy = {
+  purpose: "document",
+  maxByteSize: 1024,
+  maxPartByteSize: 1024,
+  sessionTtlMs: 60_000,
+  allowedTypes: { "text/plain": ["txt"] },
+  signature: "none" as const,
+};
+
+describe("FileService", () => {
+  test("文件过期后 Owner 和 manage 都不能继续下载", async () => {
+    const clock = new Clock(new Date("2026-07-16T00:00:00.000Z"));
+    const fixture = createFixture(clock);
+    const file = await upload(fixture, new Date("2026-07-16T00:01:00.000Z"));
+
+    expect(
+      await new Response(
+        (await fixture.files.open(file.id, "owner")).body,
+      ).text(),
+    ).toBe("hello");
+    clock.advance(60_000);
+    await expect(fixture.files.open(file.id, "owner")).rejects.toMatchObject({
+      code: "FILE_EXPIRED",
+    });
+    await expect(
+      fixture.files.open(file.id, "manager", true),
+    ).rejects.toMatchObject({
+      code: "FILE_EXPIRED",
+    });
+  });
+
+  test("元数据存在但底层 Blob 缺失时返回明确不可用错误", async () => {
+    const fixture = createFixture(
+      new Clock(new Date("2026-07-16T00:00:00.000Z")),
+    );
+    const file = await upload(fixture);
+    await fixture.blobStore.delete(file.artifactRef);
+
+    await expect(fixture.files.open(file.id, "owner")).rejects.toMatchObject({
+      code: "FILE_CONTENT_MISSING",
+    });
+  });
+});
+
+function createFixture(clock: Clock) {
+  const repository = new InMemoryUploadRepository();
+  const blobStore = new MemoryBlobStore();
+  return {
+    blobStore,
+    uploads: new UploadService({
+      repository,
+      blobStore,
+      policies: [policy],
+      now: clock.now,
+    }),
+    files: new FileService(repository, blobStore, clock.now),
+  };
+}
+
+async function upload(
+  fixture: ReturnType<typeof createFixture>,
+  fileExpiresAt?: Date,
+) {
+  const bytes = new TextEncoder().encode("hello");
+  const digest = createHash("sha256").update(bytes).digest("hex");
+  const session = await fixture.uploads.create({
+    ownerId: "owner",
+    purpose: "document",
+    filename: "hello.txt",
+    mimeType: "text/plain",
+    expectedByteSize: bytes.byteLength,
+    expectedSha256: digest,
+    fileExpiresAt,
+  });
+  await fixture.uploads.appendPart({
+    sessionId: session.id,
+    ownerId: "owner",
+    partNumber: 0,
+    byteOffset: 0,
+    byteSize: bytes.byteLength,
+    sha256: digest,
+    body: new Blob([bytes]).stream(),
+  });
+  return fixture.uploads.complete(session.id, "owner");
+}
+
+class Clock {
+  constructor(private value: Date) {}
+  readonly now = () => new Date(this.value);
+  advance(milliseconds: number) {
+    this.value = new Date(this.value.getTime() + milliseconds);
+  }
+}

package/template/packages/storage/src/file-service.ts

@@ -0,0 +1,59 @@
+import type { BlobStore } from "./blob-store.js";
+import type { UploadRepository } from "./upload-repository.js";
+import {
+  UploadError,
+  type FileMetadata,
+  type OpenedFile,
+} from "./upload-types.js";
+
+export class FileService {
+  constructor(
+    private readonly repository: UploadRepository,
+    private readonly blobStore: BlobStore,
+    private readonly now: () => Date = () => new Date(),
+  ) {}
+
+  async open(
+    fileId: string,
+    ownerId: string,
+    allowManage = false,
+  ): Promise<OpenedFile> {
+    const file = await this.requireAvailable(fileId);
+    if (file.ownerId !== ownerId && !allowManage) {
+      throw new UploadError("UPLOAD_FORBIDDEN", "无权访问该文件");
+    }
+    return this.openStored(file);
+  }
+
+  async openPublic(
+    fileId: string,
+    requiredPurpose: string,
+  ): Promise<OpenedFile> {
+    const file = await this.requireAvailable(fileId);
+    if (file.purpose !== requiredPurpose) {
+      throw new UploadError("FILE_NOT_FOUND", "文件不存在");
+    }
+    return this.openStored(file);
+  }
+
+  private async requireAvailable(id: string) {
+    const file = await this.repository.getFile(id);
+    if (!file) throw new UploadError("FILE_NOT_FOUND", "文件不存在");
+    if (file.expiresAt && file.expiresAt <= this.now().toISOString()) {
+      throw new UploadError("FILE_EXPIRED", "文件已过期");
+    }
+    return file;
+  }
+
+  private async openStored(file: FileMetadata): Promise<OpenedFile> {
+    const blob = await this.blobStore.open(file.artifactRef);
+    if (
+      !blob ||
+      blob.byteSize !== file.byteSize ||
+      blob.contentHash.value !== file.contentHash.value
+    ) {
+      throw new UploadError("FILE_CONTENT_MISSING", "文件内容不可用");
+    }
+    return { ...file, body: blob.body };
+  }
+}

package/template/packages/storage/src/in-memory-upload-repository.ts

@@ -0,0 +1,154 @@
+import type { ArtifactRef } from "./blob-store.js";
+import type {
+  NewUploadSession,
+  UploadRepository,
+} from "./upload-repository.js";
+import type {
+  FileMetadata,
+  UploadPart,
+  UploadSession,
+} from "./upload-types.js";
+
+export class InMemoryUploadRepository implements UploadRepository {
+  private readonly sessions = new Map<string, UploadSession>();
+  private readonly parts = new Map<string, UploadPart>();
+  private readonly files = new Map<string, FileMetadata>();
+
+  async createSession(input: NewUploadSession) {
+    const session: UploadSession = {
+      ...input,
+      receivedByteSize: 0,
+      nextPartNumber: 0,
+      status: "uploading",
+      updatedAt: input.createdAt,
+    };
+    this.sessions.set(session.id, session);
+    return cloneSession(session);
+  }
+
+  async getSession(id: string) {
+    const value = this.sessions.get(id);
+    return value ? cloneSession(value) : undefined;
+  }
+
+  async getPart(sessionId: string, partNumber: number) {
+    const value = this.parts.get(partKey(sessionId, partNumber));
+    return value ? { ...value } : undefined;
+  }
+
+  async listParts(sessionId: string) {
+    return [...this.parts.values()]
+      .filter((part) => part.sessionId === sessionId)
+      .sort((a, b) => a.partNumber - b.partNumber)
+      .map((part) => ({ ...part }));
+  }
+
+  async commitPart(part: UploadPart, expectedReceivedByteSize: number) {
+    const session = this.sessions.get(part.sessionId);
+    if (
+      !session ||
+      session.status !== "uploading" ||
+      session.receivedByteSize !== expectedReceivedByteSize ||
+      session.nextPartNumber !== part.partNumber
+    ) {
+      return false;
+    }
+    this.parts.set(partKey(part.sessionId, part.partNumber), { ...part });
+    session.receivedByteSize += part.byteSize;
+    session.nextPartNumber += 1;
+    session.updatedAt = part.createdAt;
+    return true;
+  }
+
+  async completeSession(
+    sessionId: string,
+    expectedReceivedByteSize: number,
+    file: FileMetadata,
+    updatedAt: string,
+  ) {
+    const session = this.sessions.get(sessionId);
+    if (
+      !session ||
+      session.status !== "uploading" ||
+      session.receivedByteSize !== expectedReceivedByteSize
+    ) {
+      return false;
+    }
+    this.files.set(file.id, { ...file });
+    Object.assign(session, {
+      status: "completed",
+      fileId: file.id,
+      updatedAt,
+    });
+    return true;
+  }
+
+  async abortSession(id: string, ownerId: string, updatedAt: string) {
+    const session = this.sessions.get(id);
+    if (
+      !session ||
+      session.ownerId !== ownerId ||
+      session.status !== "uploading"
+    )
+      return false;
+    session.status = "aborted";
+    session.updatedAt = updatedAt;
+    return true;
+  }
+
+  async getFile(id: string) {
+    const value = this.files.get(id);
+    return value ? { ...value } : undefined;
+  }
+
+  async listExpiredSessions(now: string, limit: number) {
+    return [...this.sessions.values()]
+      .filter(
+        (session) => session.status !== "completed" && session.expiresAt <= now,
+      )
+      .slice(0, limit)
+      .map(cloneSession);
+  }
+
+  async listExpiredFiles(now: string, limit: number) {
+    return [...this.files.values()]
+      .filter((file) => file.expiresAt && file.expiresAt <= now)
+      .slice(0, limit)
+      .map((file) => ({ ...file }));
+  }
+
+  async listArtifactRefs() {
+    return [
+      ...[...this.parts.values()].map((part) => part.artifactRef),
+      ...[...this.files.values()].map((file) => file.artifactRef),
+    ] as ArtifactRef[];
+  }
+
+  async deleteSession(id: string) {
+    this.sessions.delete(id);
+    await this.deleteParts(id);
+  }
+
+  async deleteParts(id: string) {
+    for (const [key, part] of this.parts) {
+      if (part.sessionId === id) this.parts.delete(key);
+    }
+  }
+
+  async deleteFile(id: string) {
+    this.files.delete(id);
+  }
+}
+
+function partKey(sessionId: string, partNumber: number) {
+  return `${sessionId}:${partNumber}`;
+}
+
+function cloneSession(value: UploadSession): UploadSession {
+  return {
+    ...value,
+    expectedContentHash: value.expectedContentHash
+      ? { ...value.expectedContentHash }
+      : undefined,
+  };
+}

package/template/packages/storage/src/local-file-blob-store.test.ts

@@ -0,0 +1,175 @@
+import { createHash } from "node:crypto";
+import { mkdtemp, readdir, rename, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, test } from "bun:test";
+import { artifactRef, BlobStoreError } from "./blob-store.js";
+import { sha256ContentHash } from "./content-hash.js";
+import { LocalFileBlobStore } from "./local-file-blob-store.js";
+import { LocalFileBlobMaintenance } from "./local-file-maintenance.js";
+
+const roots: string[] = [];
+const fixedRef = artifactRef("blob_0123456789abcdef0123456789abcdef");
+
+afterEach(async () => {
+  await Promise.all(
+    roots.splice(0).map((root) => rm(root, { recursive: true, force: true })),
+  );
+});
+
+describe("LocalFileBlobStore", () => {
+  test("分块写入、计算 SHA-256 并以流读取大 Blob", async () => {
+    const root = await temporaryRoot();
+    const store = new LocalFileBlobStore({
+      root,
+      createRef: () => fixedRef,
+      now: () => new Date("2026-07-16T00:00:00.000Z"),
+    });
+    const chunk = new Uint8Array(64 * 1024).fill(7);
+    const chunkCount = 128;
+    const expected = createHash("sha256");
+    for (let index = 0; index < chunkCount; index += 1) expected.update(chunk);
+    const expectedHash = sha256ContentHash(expected.digest("hex"));
+
+    const stored = await store.put({
+      body: repeatedStream(chunk, chunkCount),
+      expectedByteSize: chunk.byteLength * chunkCount,
+      expectedContentHash: expectedHash,
+    });
+
+    expect(stored).toEqual({
+      ref: fixedRef,
+      byteSize: 8 * 1024 * 1024,
+      contentHash: expectedHash,
+      createdAt: "2026-07-16T00:00:00.000Z",
+    });
+    const opened = await store.open(fixedRef);
+    expect(opened?.body).toBeInstanceOf(ReadableStream);
+    expect(await digest(opened!.body)).toBe(stored.contentHash.value);
+  });
+
+  test("大小或摘要不符时拒绝且清理临时文件", async () => {
+    const root = await temporaryRoot();
+    const store = new LocalFileBlobStore({ root, createRef: () => fixedRef });
+
+    await expect(
+      store.put({ body: bytes("hello"), expectedByteSize: 4 }),
+    ).rejects.toMatchObject({ code: "SIZE_MISMATCH" });
+    await expect(
+      store.put({
+        body: bytes("hello"),
+        expectedContentHash: sha256ContentHash("0".repeat(64)),
+      }),
+    ).rejects.toMatchObject({ code: "HASH_MISMATCH" });
+
+    expect(await readdir(join(root, ".tmp"))).toEqual([]);
+    expect(await store.open(fixedRef)).toBeUndefined();
+  });
+
+  test("inspect 重新校验实际文件并拒绝同尺寸外部篡改", async () => {
+    const root = await temporaryRoot();
+    const store = new LocalFileBlobStore({ root, createRef: () => fixedRef });
+    const stored = await store.put({ body: bytes("original") });
+
+    expect(await store.inspect(fixedRef)).toEqual(stored);
+    await writeFile(join(root, "blobs", "01", `${fixedRef}.blob`), "tampered");
+
+    await expect(store.inspect(fixedRef)).rejects.toMatchObject({
+      code: "CORRUPT_BLOB_METADATA",
+    });
+    await expect(store.open(fixedRef)).rejects.toMatchObject({
+      code: "CORRUPT_BLOB_METADATA",
+    });
+  });
+
+  test("open 校验与流读取绑定同一文件描述符", async () => {
+    const root = await temporaryRoot();
+    const store = new LocalFileBlobStore({ root, createRef: () => fixedRef });
+    await store.put({ body: bytes("verified") });
+    const opened = await store.open(fixedRef);
+    const blobPath = join(root, "blobs", "01", `${fixedRef}.blob`);
+    const replacement = join(root, "replacement.blob");
+    await writeFile(replacement, "attacker");
+    await rename(replacement, blobPath);
+
+    expect(await new Response(opened!.body).text()).toBe("verified");
+    await expect(store.open(fixedRef)).rejects.toMatchObject({
+      code: "CORRUPT_BLOB_METADATA",
+    });
+  });
+
+  test("引用不可路径穿越且删除同时移除内容和元数据", async () => {
+    expect(() => artifactRef("../../etc/passwd")).toThrow(BlobStoreError);
+    const root = await temporaryRoot();
+    const store = new LocalFileBlobStore({ root, createRef: () => fixedRef });
+    await store.put({ body: bytes("delete-me") });
+
+    expect(await store.delete(fixedRef)).toBe(true);
+    expect(await store.delete(fixedRef)).toBe(false);
+    expect(await store.inspect(fixedRef)).toBeUndefined();
+    expect(await store.open(fixedRef)).toBeUndefined();
+  });
+
+  test("孤儿清理保留数据库仍引用的 Blob", async () => {
+    const root = await temporaryRoot();
+    const referenced = artifactRef("blob_11111111111111111111111111111111");
+    const orphan = artifactRef("blob_22222222222222222222222222222222");
+    const refs = [referenced, orphan];
+    const store = new LocalFileBlobStore({
+      root,
+      createRef: () => refs.shift()!,
+    });
+    await store.put({ body: bytes("keep") });
+    await store.put({ body: bytes("remove") });
+
+    const maintenance = new LocalFileBlobMaintenance(root);
+    expect(
+      await maintenance.cleanupOrphans({
+        referencedRefs: new Set([referenced]),
+        olderThan: new Date(Date.now() + 1_000),
+        limit: 10,
+      }),
+    ).toBe(1);
+    expect(await store.open(referenced)).toBeDefined();
+    expect(await store.open(orphan)).toBeUndefined();
+  });
+});
+
+function repeatedStream(chunk: Uint8Array, count: number) {
+  let emitted = 0;
+  return new ReadableStream<Uint8Array>({
+    pull(controller) {
+      if (emitted >= count) return controller.close();
+      emitted += 1;
+      controller.enqueue(chunk);
+    },
+  });
+}
+
+function bytes(value: string) {
+  const encoded = new TextEncoder().encode(value);
+  return new ReadableStream<Uint8Array>({
+    start(controller) {
+      controller.enqueue(encoded);
+      controller.close();
+    },
+  });
+}
+
+async function digest(stream: ReadableStream<Uint8Array>) {
+  const hash = createHash("sha256");
+  const reader = stream.getReader();
+  while (true) {
+    const result = await reader.read();
+    if (result.done) break;
+    hash.update(result.value);
+  }
+  reader.releaseLock();
+  return hash.digest("hex");
+}
+
+async function temporaryRoot() {
+  const root = await mkdtemp(join(tmpdir(), "windy-blob-store-"));
+  roots.push(root);
+  return root;
+}