create-windy 0.5.2 → 0.6.1

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

@@ -17,6 +17,9 @@ export class InMemoryUploadRepository implements UploadRepository {
   async createSession(input: NewUploadSession) {
     const session: UploadSession = {
       ...input,
+      authorizationBinding: input.authorizationBinding
+        ? { ...input.authorizationBinding }
+        : undefined,
       receivedByteSize: 0,
       nextPartNumber: 0,
       status: "uploading",
@@ -83,6 +86,19 @@ export class InMemoryUploadRepository implements UploadRepository {
     return true;
   }
 
+  async beginAbortSession(id: string, ownerId: string, updatedAt: string) {
+    const session = this.sessions.get(id);
+    if (
+      !session ||
+      session.ownerId !== ownerId ||
+      session.status !== "uploading"
+    )
+      return false;
+    session.status = "aborting";
+    session.updatedAt = updatedAt;
+    return true;
+  }
+
   async abortSession(id: string, ownerId: string, updatedAt: string) {
     const session = this.sessions.get(id);
     if (
@@ -96,6 +112,58 @@ export class InMemoryUploadRepository implements UploadRepository {
     return true;
   }
 
+  async finalizeAbortSession(id: string, ownerId: string, updatedAt: string) {
+    const session = this.sessions.get(id);
+    if (
+      !session ||
+      session.ownerId !== ownerId ||
+      session.status !== "aborting" ||
+      session.fileId ||
+      [...this.parts.values()].some((part) => part.sessionId === id)
+    ) {
+      return false;
+    }
+    session.status = "aborted";
+    session.updatedAt = updatedAt;
+    return true;
+  }
+
+  async beginPurgeCompletedSession(
+    id: string,
+    ownerId: string,
+    fileId: string,
+    updatedAt: string,
+  ) {
+    const session = this.sessions.get(id);
+    if (
+      !session ||
+      session.ownerId !== ownerId ||
+      session.fileId !== fileId ||
+      session.status !== "completed"
+    ) {
+      return false;
+    }
+    session.status = "aborting";
+    session.updatedAt = updatedAt;
+    return true;
+  }
+
+  async deletePurgedSession(id: string, ownerId: string, fileId: string) {
+    const session = this.sessions.get(id);
+    if (
+      !session ||
+      session.ownerId !== ownerId ||
+      session.fileId !== fileId ||
+      session.status !== "aborting" ||
+      this.files.has(fileId) ||
+      [...this.parts.values()].some((part) => part.sessionId === id)
+    ) {
+      return false;
+    }
+    this.sessions.delete(id);
+    return true;
+  }
+
   async getFile(id: string) {
     const value = this.files.get(id);
     return value ? { ...value } : undefined;
@@ -104,7 +172,10 @@ export class InMemoryUploadRepository implements UploadRepository {
   async listExpiredSessions(now: string, limit: number) {
     return [...this.sessions.values()]
       .filter(
-        (session) => session.status !== "completed" && session.expiresAt <= now,
+        (session) =>
+          session.status !== "completed" &&
+          !(session.status === "aborting" && session.fileId) &&
+          session.expiresAt <= now,
       )
       .slice(0, limit)
       .map(cloneSession);
@@ -117,9 +188,38 @@ export class InMemoryUploadRepository implements UploadRepository {
       .map((file) => ({ ...file }));
   }
 
+  async claimExpiredSession(id: string, now: string) {
+    const session = this.sessions.get(id);
+    if (
+      !session ||
+      session.status === "completed" ||
+      (session.status === "aborting" && session.fileId) ||
+      session.expiresAt > now
+    ) {
+      return false;
+    }
+    session.status = "expired";
+    session.updatedAt = now;
+    return true;
+  }
+
+  async deleteClaimedSession(id: string) {
+    const session = this.sessions.get(id);
+    if (!session || session.status !== "expired") return false;
+    this.sessions.delete(id);
+    await this.deleteParts(id);
+    return true;
+  }
+
   async listArtifactRefs() {
     return [
-      ...[...this.parts.values()].map((part) => part.artifactRef),
+      ...[...this.parts.values()]
+        .filter(
+          (part) =>
+            this.sessions.get(part.sessionId)?.status === "uploading" ||
+            this.sessions.get(part.sessionId)?.status === "aborting",
+        )
+        .map((part) => part.artifactRef),
       ...[...this.files.values()].map((file) => file.artifactRef),
     ] as ArtifactRef[];
   }
@@ -147,6 +247,9 @@ function partKey(sessionId: string, partNumber: number) {
 function cloneSession(value: UploadSession): UploadSession {
   return {
     ...value,
+    authorizationBinding: value.authorizationBinding
+      ? { ...value.authorizationBinding }
+      : undefined,
     expectedContentHash: value.expectedContentHash
       ? { ...value.expectedContentHash }
       : undefined,

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

@@ -66,6 +66,49 @@ describe("LocalFileBlobStore", () => {
     expect(await store.open(fixedRef)).toBeUndefined();
   });
 
+  test("大小溢出会以原始错误取消并解锁来源流", async () => {
+    const root = await temporaryRoot();
+    const store = new LocalFileBlobStore({ root, createRef: () => fixedRef });
+    const source = trackedOverflowStream();
+    let failure: unknown;
+
+    try {
+      await store.put({ body: source.body, expectedByteSize: 1 });
+    } catch (error) {
+      failure = error;
+    }
+
+    expect(failure).toMatchObject({ code: "SIZE_MISMATCH" });
+    expect(source.cancelReason()).toBe(failure);
+    expect(source.body.locked).toBe(false);
+  });
+
+  test("来源 I/O 与摘要错误保持原始失败并解锁流", async () => {
+    const root = await temporaryRoot();
+    const store = new LocalFileBlobStore({ root, createRef: () => fixedRef });
+    const ioFailure = new Error("source I/O failed");
+    const failedBody = new ReadableStream<Uint8Array>({
+      start(controller) {
+        controller.error(ioFailure);
+      },
+    });
+    await expect(store.put({ body: failedBody })).rejects.toBe(ioFailure);
+    expect(failedBody.locked).toBe(false);
+
+    const hashBody = bytes("hello");
+    let hashFailure: unknown;
+    try {
+      await store.put({
+        body: hashBody,
+        expectedContentHash: sha256ContentHash("0".repeat(64)),
+      });
+    } catch (error) {
+      hashFailure = error;
+    }
+    expect(hashFailure).toMatchObject({ code: "HASH_MISMATCH" });
+    expect(hashBody.locked).toBe(false);
+  });
+
   test("inspect 重新校验实际文件并拒绝同尺寸外部篡改", async () => {
     const root = await temporaryRoot();
     const store = new LocalFileBlobStore({ root, createRef: () => fixedRef });
@@ -156,6 +199,21 @@ function bytes(value: string) {
   });
 }
 
+function trackedOverflowStream() {
+  let cancelValue: unknown;
+  let index = 0;
+  const body = new ReadableStream<Uint8Array>({
+    pull(controller) {
+      controller.enqueue(Uint8Array.of(index));
+      index += 1;
+    },
+    cancel(reason) {
+      cancelValue = reason;
+    },
+  });
+  return { body, cancelReason: () => cancelValue };
+}
+
 async function digest(stream: ReadableStream<Uint8Array>) {
   const hash = createHash("sha256");
   const reader = stream.getReader();

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

@@ -19,6 +19,10 @@ import {
   type StoredBlob,
 } from "./blob-store.js";
 import { createSha256Accumulator, sha256ContentHash } from "./content-hash.js";
+import {
+  validateExpectedSize,
+  writeLocalBlob,
+} from "./local-file-blob-writer.js";
 
 export interface LocalFileBlobStoreOptions {
   root: string;
@@ -48,7 +52,7 @@ export class LocalFileBlobStore implements BlobStore {
     );
 
     try {
-      const stored = await this.writeBody(temporaryBlob, ref, input);
+      const stored = await writeLocalBlob(temporaryBlob, ref, input, this.now);
       await rename(temporaryBlob, paths.blob);
       await writeDurably(temporaryMetadata, `${JSON.stringify(stored)}\n`);
       await rename(temporaryMetadata, paths.metadata);
@@ -115,55 +119,6 @@ export class LocalFileBlobStore implements BlobStore {
     return existed;
   }
 
-  private async writeBody(
-    path: string,
-    ref: ArtifactRef,
-    input: PutBlobInput,
-  ): Promise<StoredBlob> {
-    const handle = await open(path, "wx", 0o600);
-    const reader = input.body.getReader();
-    const hash = createSha256Accumulator();
-    let byteSize = 0;
-    try {
-      while (true) {
-        const result = await reader.read();
-        if (result.done) break;
-        byteSize += result.value.byteLength;
-        if (
-          input.expectedByteSize !== undefined &&
-          byteSize > input.expectedByteSize
-        ) {
-          throw sizeMismatch(input.expectedByteSize, byteSize);
-        }
-        hash.update(result.value);
-        await writeAll(handle, result.value);
-      }
-      await handle.sync();
-    } finally {
-      reader.releaseLock();
-      await handle.close();
-    }
-    if (
-      input.expectedByteSize !== undefined &&
-      byteSize !== input.expectedByteSize
-    ) {
-      throw sizeMismatch(input.expectedByteSize, byteSize);
-    }
-    const contentHash = hash.digest();
-    if (
-      input.expectedContentHash &&
-      input.expectedContentHash.value !== contentHash.value
-    ) {
-      throw new BlobStoreError("HASH_MISMATCH", "Blob SHA-256 与声明不一致");
-    }
-    return {
-      ref,
-      byteSize,
-      contentHash,
-      createdAt: this.now().toISOString(),
-    };
-  }
-
   private paths(ref: ArtifactRef) {
     const safeRef = artifactRef(ref);
     const directory = join(this.options.root, "blobs", safeRef.slice(5, 7));
@@ -253,14 +208,6 @@ function randomArtifactRef(): ArtifactRef {
   return artifactRef(`blob_${randomUUID().replaceAll("-", "")}`);
 }
 
-async function writeAll(handle: FileHandle, chunk: Uint8Array): Promise<void> {
-  let offset = 0;
-  while (offset < chunk.byteLength) {
-    const result = await handle.write(chunk, offset, chunk.byteLength - offset);
-    offset += result.bytesWritten;
-  }
-}
-
 async function writeDurably(path: string, content: string): Promise<void> {
   const handle = await open(path, "wx", 0o600);
   try {
@@ -318,19 +265,6 @@ function parseMetadata(raw: string, expectedRef: ArtifactRef): StoredBlob {
   }
 }
 
-function validateExpectedSize(value: number | undefined): void {
-  if (value !== undefined && (!Number.isSafeInteger(value) || value < 0)) {
-    throw new BlobStoreError("SIZE_MISMATCH", "Blob 声明大小无效");
-  }
-}
-
-function sizeMismatch(expected: number, actual: number): BlobStoreError {
-  return new BlobStoreError(
-    "SIZE_MISMATCH",
-    `Blob 大小与声明不一致：expected=${expected}, actual=${actual}`,
-  );
-}
-
 function corruptMetadata(ref: ArtifactRef): BlobStoreError {
   return new BlobStoreError("CORRUPT_BLOB_METADATA", `Blob 元数据损坏：${ref}`);
 }

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

@@ -0,0 +1,96 @@
+import { open, type FileHandle } from "node:fs/promises";
+import {
+  BlobStoreError,
+  type ArtifactRef,
+  type PutBlobInput,
+  type StoredBlob,
+} from "./blob-store.js";
+import { createSha256Accumulator } from "./content-hash.js";
+
+export function validateExpectedSize(value: number | undefined): void {
+  if (value !== undefined && (!Number.isSafeInteger(value) || value < 0)) {
+    throw new BlobStoreError("SIZE_MISMATCH", "Blob 声明大小无效");
+  }
+}
+
+export async function writeLocalBlob(
+  path: string,
+  ref: ArtifactRef,
+  input: PutBlobInput,
+  now: () => Date,
+): Promise<StoredBlob> {
+  const handle = await open(path, "wx", 0o600);
+  const reader = input.body.getReader();
+  const hash = createSha256Accumulator();
+  let byteSize = 0;
+  let primaryError: unknown;
+  let stored: StoredBlob | undefined;
+  try {
+    while (true) {
+      const result = await reader.read();
+      if (result.done) break;
+      byteSize += result.value.byteLength;
+      if (
+        input.expectedByteSize !== undefined &&
+        byteSize > input.expectedByteSize
+      ) {
+        throw sizeMismatch(input.expectedByteSize, byteSize);
+      }
+      hash.update(result.value);
+      await writeAll(handle, result.value);
+    }
+    await handle.sync();
+    if (
+      input.expectedByteSize !== undefined &&
+      byteSize !== input.expectedByteSize
+    ) {
+      throw sizeMismatch(input.expectedByteSize, byteSize);
+    }
+    const contentHash = hash.digest();
+    if (
+      input.expectedContentHash &&
+      input.expectedContentHash.value !== contentHash.value
+    ) {
+      throw new BlobStoreError("HASH_MISMATCH", "Blob SHA-256 与声明不一致");
+    }
+    stored = {
+      ref,
+      byteSize,
+      contentHash,
+      createdAt: now().toISOString(),
+    };
+  } catch (error) {
+    primaryError = error;
+    await reader.cancel(error).catch(() => undefined);
+  }
+  let cleanupError: unknown;
+  try {
+    reader.releaseLock();
+  } catch (error) {
+    cleanupError = error;
+  }
+  try {
+    await handle.close();
+  } catch (error) {
+    cleanupError ??= error;
+  }
+  if (primaryError !== undefined) throw primaryError;
+  if (cleanupError !== undefined) throw cleanupError;
+  if (!stored) throw new Error("本地 Blob 写入未返回结果");
+  return stored;
+}
+
+async function writeAll(handle: FileHandle, chunk: Uint8Array): Promise<void> {
+  let offset = 0;
+  while (offset < chunk.byteLength) {
+    const result = await handle.write(chunk, offset, chunk.byteLength - offset);
+    offset += result.bytesWritten;
+  }
+}
+
+function sizeMismatch(expected: number, actual: number): BlobStoreError {
+  return new BlobStoreError(
+    "SIZE_MISMATCH",
+    `Blob 大小与声明不一致：expected=${expected}, actual=${actual}`,
+  );
+}

package/template/packages/storage/src/upload-abort-recovery.test.ts

@@ -0,0 +1,234 @@
+import { createHash } from "node:crypto";
+import { describe, expect, test } from "bun:test";
+import type { ArtifactRef, BlobStore } from "./blob-store.js";
+import { InMemoryUploadRepository } from "./in-memory-upload-repository.js";
+import { MemoryBlobStore } from "./memory-blob-store.js";
+import { UploadService } from "./upload-service.js";
+import type { UploadPolicy } from "./upload-types.js";
+
+const policy: UploadPolicy = {
+  purpose: "module.output",
+  maxByteSize: 1024,
+  maxPartByteSize: 512,
+  sessionTtlMs: 60_000,
+  allowedTypes: { "text/plain": ["txt"] },
+  signature: "none",
+};
+
+describe("UploadService abort 可重放清理", () => {
+  test("Blob 删除失败保留 aborting 与分片事实，重放完成清理", async () => {
+    const repository = new InMemoryUploadRepository();
+    const base = new MemoryBlobStore();
+    let failedRef: ArtifactRef | undefined;
+    const blobStore: BlobStore = {
+      put: (input) => base.put(input),
+      inspect: (ref) => base.inspect(ref),
+      open: (ref) => base.open(ref),
+      async delete(ref) {
+        if (!failedRef) {
+          failedRef = ref;
+          throw new Error("injected blob cleanup failure");
+        }
+        return base.delete(ref);
+      },
+    };
+    const service = createService(repository, blobStore);
+    const session = await seedPart(service);
+
+    await expect(service.abort(session.id, "owner")).rejects.toThrow(
+      "injected blob cleanup failure",
+    );
+    expect(await repository.getSession(session.id)).toMatchObject({
+      status: "aborting",
+    });
+    expect(await repository.listParts(session.id)).toHaveLength(1);
+    expect(base.size).toBe(1);
+
+    const restarted = createService(repository, blobStore);
+    await restarted.abort(session.id, "owner");
+    await restarted.abort(session.id, "owner");
+    expect(await repository.getSession(session.id)).toMatchObject({
+      status: "aborted",
+    });
+    expect(await repository.listParts(session.id)).toEqual([]);
+    expect(base.size).toBe(0);
+  });
+
+  test("分片行删除失败后重放可从已删除 Blob 继续 finalization", async () => {
+    const repository = new FailingPartDeleteRepository();
+    const blobStore = new MemoryBlobStore();
+    const service = createService(repository, blobStore);
+    const session = await seedPart(service);
+    repository.failNextDelete();
+
+    await expect(service.abort(session.id, "owner")).rejects.toThrow(
+      "injected row cleanup failure",
+    );
+    expect(await repository.getSession(session.id)).toMatchObject({
+      status: "aborting",
+    });
+    expect(await repository.listParts(session.id)).toHaveLength(1);
+    expect(blobStore.size).toBe(0);
+
+    await service.abort(session.id, "owner");
+    expect(await repository.getSession(session.id)).toMatchObject({
+      status: "aborted",
+    });
+    expect(await repository.listParts(session.id)).toEqual([]);
+  });
+
+  test("兼容历史 aborted 残留时仍继续清理而非直接成功", async () => {
+    const repository = new LegacyAbortedRepository();
+    const blobStore = new MemoryBlobStore();
+    const service = createService(repository, blobStore);
+    const session = await seedPart(service);
+    repository.projectAsLegacyAborted(session.id);
+
+    await service.abort(session.id, "owner");
+
+    expect(await repository.listParts(session.id)).toEqual([]);
+    expect(blobStore.size).toBe(0);
+  });
+
+  test("begin 后取消停在 aborting，新 Service 可继续完成", async () => {
+    const controller = new AbortController();
+    const repository = new CancellingAbortRepository(controller);
+    const blobStore = new MemoryBlobStore();
+    const service = createService(repository, blobStore);
+    const session = await seedPart(service);
+
+    await expect(
+      service.abort(session.id, "owner", controller.signal),
+    ).rejects.toMatchObject({ code: "UPLOAD_CANCELLED" });
+    expect(await repository.getSession(session.id)).toMatchObject({
+      status: "aborting",
+    });
+    expect(await repository.listParts(session.id)).toHaveLength(1);
+
+    await createService(repository, blobStore).abort(session.id, "owner");
+    expect(await repository.getSession(session.id)).toMatchObject({
+      status: "aborted",
+    });
+    expect(blobStore.size).toBe(0);
+  });
+
+  test("aborting 故障态仍由 TTL cleanup 清除", async () => {
+    let now = new Date("2026-07-31T00:00:00.000Z");
+    const repository = new InMemoryUploadRepository();
+    const base = new MemoryBlobStore();
+    let fail = true;
+    const blobStore: BlobStore = {
+      put: (input) => base.put(input),
+      inspect: (ref) => base.inspect(ref),
+      open: (ref) => base.open(ref),
+      async delete(ref) {
+        if (fail) {
+          fail = false;
+          throw new Error("injected abort cleanup failure");
+        }
+        return base.delete(ref);
+      },
+    };
+    const service = new UploadService({
+      repository,
+      blobStore,
+      policies: [policy],
+      now: () => now,
+    });
+    const session = await seedPart(service);
+    await expect(service.abort(session.id, "owner")).rejects.toThrow(
+      "injected abort cleanup failure",
+    );
+    now = new Date("2026-07-31T00:02:00.000Z");
+
+    await expect(service.cleanupExpired()).resolves.toMatchObject({
+      sessions: 1,
+      blobs: 1,
+    });
+    expect(await repository.getSession(session.id)).toBeUndefined();
+    expect(base.size).toBe(0);
+  });
+});
+
+class FailingPartDeleteRepository extends InMemoryUploadRepository {
+  private shouldFail = false;
+
+  failNextDelete() {
+    this.shouldFail = true;
+  }
+
+  override async deleteParts(sessionId: string) {
+    if (this.shouldFail) {
+      this.shouldFail = false;
+      throw new Error("injected row cleanup failure");
+    }
+    await super.deleteParts(sessionId);
+  }
+}
+
+class LegacyAbortedRepository extends InMemoryUploadRepository {
+  private legacyAbortedId?: string;
+
+  projectAsLegacyAborted(sessionId: string) {
+    this.legacyAbortedId = sessionId;
+  }
+
+  override async getSession(id: string) {
+    const session = await super.getSession(id);
+    return session && id === this.legacyAbortedId
+      ? { ...session, status: "aborted" as const }
+      : session;
+  }
+}
+
+class CancellingAbortRepository extends InMemoryUploadRepository {
+  constructor(private readonly controller: AbortController) {
+    super();
+  }
+
+  override async beginAbortSession(
+    id: string,
+    ownerId: string,
+    updatedAt: string,
+  ) {
+    const started = await super.beginAbortSession(id, ownerId, updatedAt);
+    if (started) this.controller.abort("injected lease loss");
+    return started;
+  }
+}
+
+function createService(
+  repository: InMemoryUploadRepository,
+  blobStore: BlobStore,
+) {
+  return new UploadService({
+    repository,
+    blobStore,
+    policies: [policy],
+  });
+}
+
+async function seedPart(service: UploadService) {
+  const value = new TextEncoder().encode("abc");
+  const session = await service.create({
+    ownerId: "owner",
+    purpose: policy.purpose,
+    filename: "result.txt",
+    mimeType: "text/plain",
+    expectedByteSize: value.byteLength,
+  });
+  await service.appendPart({
+    sessionId: session.id,
+    ownerId: "owner",
+    partNumber: 0,
+    byteOffset: 0,
+    byteSize: value.byteLength,
+    sha256: digest(value),
+    body: new Blob([value]).stream(),
+  });
+  return session;
+}
+
+function digest(value: Uint8Array) {
+  return createHash("sha256").update(value).digest("hex");
+}