@hot-updater/cloudflare 0.36.6 → 1.0.0-rc.0

package/src/r2Storage.spec.ts

@@ -1,5 +1,4 @@
 import { Buffer } from "buffer";
-import fs from "fs/promises";
 
 import {
   DeleteObjectCommand,
@@ -7,25 +6,32 @@ import {
   HeadObjectCommand,
   S3Client,
 } from "@aws-sdk/client-s3";
-import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
-import { ExecaError } from "execa";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
 import { r2Storage } from "./r2Storage";
 
-const { wrangler } = vi.hoisted(() => ({
-  wrangler: vi.fn(),
-}));
-
 let fakeStore: Record<string, Buffer> = {};
 let deletedKeys: string[] = [];
+let uploadedParams:
+  | {
+      Body: ReadableStream<Uint8Array>;
+      Bucket: string;
+      CacheControl?: string;
+      ContentLength?: number;
+      ContentType?: string;
+      Key: string;
+    }
+  | undefined;
+
+const createBody = (value: string) => new Response(value).body!;
 
 vi.mock("@aws-sdk/lib-storage", () => ({
   Upload: class {
     params: {
-      Body: Buffer;
+      Body: ReadableStream<Uint8Array>;
       Bucket: string;
       CacheControl?: string;
+      ContentLength?: number;
       ContentType?: string;
       Key: string;
     };
@@ -34,18 +40,22 @@ vi.mock("@aws-sdk/lib-storage", () => ({
       params,
     }: {
       params: {
-        Body: Buffer;
+        Body: ReadableStream<Uint8Array>;
         Bucket: string;
         CacheControl?: string;
+        ContentLength?: number;
         ContentType?: string;
         Key: string;
       };
     }) {
       this.params = params;
+      uploadedParams = params;
     }
 
     async done() {
-      fakeStore[this.params.Key] = this.params.Body;
+      fakeStore[this.params.Key] = Buffer.from(
+        await new Response(this.params.Body).arrayBuffer(),
+      );
       return {
         Bucket: this.params.Bucket,
         Key: this.params.Key,
@@ -54,27 +64,11 @@ vi.mock("@aws-sdk/lib-storage", () => ({
   },
 }));
 
-vi.mock("@aws-sdk/s3-request-presigner", () => ({
-  getSignedUrl: vi.fn(async () => "https://signed-r2.example.com/object"),
-}));
-
-vi.mock("./utils/createWrangler", () => ({
-  createWrangler: vi.fn(() => wrangler),
-}));
-
-const createExecaError = (message: string) =>
-  Object.assign(Object.create(ExecaError.prototype), {
-    message,
-    shortMessage: message,
-    stderr: message,
-    stdout: "",
-  }) as ExecaError;
-
 describe("r2Storage", () => {
   beforeEach(() => {
     fakeStore = {};
     deletedKeys = [];
-    wrangler.mockReset();
+    uploadedParams = undefined;
   });
 
   afterEach(() => {
@@ -109,6 +103,7 @@ describe("r2Storage", () => {
             Body: {
               transformToByteArray: async () => new Uint8Array(object),
               transformToString: async () => object.toString("utf8"),
+              transformToWebStream: () => new Response(object).body!,
             },
           };
         }
@@ -133,21 +128,55 @@ describe("r2Storage", () => {
         accessKeyId: "access-key-id",
         secretAccessKey: "secret-access-key",
       },
-    })();
-
-    const filePath = "/tmp/hot-updater-r2-upload.txt";
-    await fs.writeFile(filePath, "hello r2");
+    });
 
     await expect(
-      storage.profiles.node.upload("releases/bundle-1", filePath),
+      storage.put?.({
+        key: "releases/bundle-1/hot-updater-r2-upload.txt",
+        body: createBody("hello r2"),
+        contentLength: 8,
+        contentType: "text/plain",
+      }),
     ).resolves.toEqual({
       storageUri:
         "r2://test-bucket/releases/bundle-1/hot-updater-r2-upload.txt",
     });
-    expect(fakeStore["releases/bundle-1/hot-updater-r2-upload.txt"]).toEqual(
-      Buffer.from("hello r2"),
-    );
-    expect(wrangler).not.toHaveBeenCalled();
+    expect(
+      fakeStore["releases/bundle-1/hot-updater-r2-upload.txt"].toString(),
+    ).toBe("hello r2");
+    expect(uploadedParams).toMatchObject({
+      ContentLength: 8,
+      ContentType: "text/plain",
+    });
+  });
+
+  it("round-trips spaces, Unicode, fragments, and percent signs in S3 keys", async () => {
+    mockS3Client();
+    const storage = r2Storage({
+      accountId: "account-id",
+      bucketName: "test-bucket",
+      credentials: {
+        accessKeyId: "access-key-id",
+        secretAccessKey: "secret-access-key",
+      },
+    });
+    const key = "릴리스 folder/logo@2x #100%/bundle.zip";
+
+    const uploaded = await storage.put?.({
+      key,
+      body: createBody("bundle"),
+      contentLength: 6,
+      contentType: "application/zip",
+    });
+    expect(uploaded?.storageUri).toContain("logo%402x");
+    expect(uploaded?.storageUri).not.toContain("#100%");
+    await expect(
+      storage.get?.({ storageUri: uploaded!.storageUri }),
+    ).resolves.toEqual({ response: expect.any(Response) });
+    await storage.delete?.({ storageUri: uploaded!.storageUri });
+    await storage.delete?.({ storageUri: uploaded!.storageUri });
+
+    expect(deletedKeys).toEqual([key, key]);
   });
 
   it("downloads R2 objects through the S3 API when credentials are provided", async () => {
@@ -166,21 +195,16 @@ describe("r2Storage", () => {
         accessKeyId: "access-key-id",
         secretAccessKey: "secret-access-key",
       },
-    })();
-
-    const downloadPath = "/tmp/hot-updater-test-manifest.json";
-    await fs.rm(downloadPath, { force: true });
+    });
 
-    await storage.profiles.node.downloadFile(
-      "r2://test-bucket/releases/bundle-1/manifest.json",
-      downloadPath,
-    );
+    const { response } = (await storage.get?.({
+      storageUri: "r2://test-bucket/releases/bundle-1/manifest.json",
+    })) ?? { response: null };
 
-    expect(JSON.parse(await fs.readFile(downloadPath, "utf8"))).toEqual({
+    expect(JSON.parse((await response?.text()) ?? "")).toEqual({
       assets: {},
       bundleId: "bundle-1",
     });
-    expect(wrangler).not.toHaveBeenCalled();
   });
 
   it("checks R2 object existence through the S3 API", async () => {
@@ -194,14 +218,14 @@ describe("r2Storage", () => {
         accessKeyId: "access-key-id",
         secretAccessKey: "secret-access-key",
       },
-    })();
+    });
 
     await expect(
-      storage.profiles.node.exists("r2://test-bucket/releases/logo.png"),
-    ).resolves.toBe(true);
+      storage.exists?.({ storageUri: "r2://test-bucket/releases/logo.png" }),
+    ).resolves.toEqual({ exists: true });
     await expect(
-      storage.profiles.node.exists("r2://test-bucket/releases/missing.png"),
-    ).resolves.toBe(false);
+      storage.exists?.({ storageUri: "r2://test-bucket/releases/missing.png" }),
+    ).resolves.toEqual({ exists: false });
   });
 
   it("deletes R2 objects through the S3 API", async () => {
@@ -215,13 +239,18 @@ describe("r2Storage", () => {
         accessKeyId: "access-key-id",
         secretAccessKey: "secret-access-key",
       },
-    })();
+    });
 
-    await storage.profiles.node.delete("r2://test-bucket/releases/logo.png");
+    await expect(
+      storage.delete?.({
+        storageUri: "r2://test-bucket/releases/logo.png",
+      }),
+    ).resolves.toEqual({
+      deleted: true,
+    });
 
     expect(deletedKeys).toEqual(["releases/logo.png"]);
     expect(fakeStore["releases/logo.png"]).toBeUndefined();
-    expect(wrangler).not.toHaveBeenCalled();
   });
 
   it("reads R2 text through the runtime S3 API when credentials are provided", async () => {
@@ -240,22 +269,29 @@ describe("r2Storage", () => {
         accessKeyId: "access-key-id",
         secretAccessKey: "secret-access-key",
       },
-    })();
+    });
 
+    const { response } = (await storage.get?.({
+      storageUri: "r2://test-bucket/releases/bundle-1/manifest.json",
+    })) ?? { response: null };
+    expect(await response?.text()).toBe('{"assets":{},"bundleId":"bundle-1"}');
     await expect(
-      storage.profiles.runtime.readText(
-        "r2://test-bucket/releases/bundle-1/manifest.json",
-      ),
-    ).resolves.toBe('{"assets":{},"bundleId":"bundle-1"}');
-    await expect(
-      storage.profiles.runtime.readText(
-        "r2://test-bucket/releases/missing.json",
-      ),
-    ).resolves.toBeNull();
+      storage.get?.({
+        storageUri: "r2://test-bucket/releases/missing.json",
+      }),
+    ).resolves.toEqual({ response: null });
   });
 
-  it("creates signed R2 download URLs through the runtime S3 API", async () => {
-    mockS3Client();
+  it("rejects configs without S3 credentials", () => {
+    expect(() =>
+      r2Storage({
+        accountId: "account-id",
+        bucketName: "test-bucket",
+      } as never),
+    ).toThrow("r2Storage requires S3-compatible credentials");
+  });
+
+  it("does not add getDownloadUrl to a deploy-only configuration", () => {
     const storage = r2Storage({
       accountId: "account-id",
       bucketName: "test-bucket",
@@ -263,23 +299,12 @@ describe("r2Storage", () => {
         accessKeyId: "access-key-id",
         secretAccessKey: "secret-access-key",
       },
-    })();
-
-    await expect(
-      storage.profiles.runtime.getDownloadUrl(
-        "r2://test-bucket/releases/bundle-1/index.bundle",
-      ),
-    ).resolves.toEqual({
-      fileUrl: "https://signed-r2.example.com/object",
     });
-    expect(getSignedUrl).toHaveBeenCalledWith(
-      expect.any(S3Client),
-      expect.any(GetObjectCommand),
-      { expiresIn: 3600 },
-    );
+
+    expect(Reflect.has(storage, "getDownloadUrl")).toBe(false);
   });
 
-  it("decodes percent-encoded keys before signing through the S3 API", async () => {
+  it("adds a signed download URL operation when configured for a server", async () => {
     mockS3Client();
     const storage = r2Storage({
       accountId: "account-id",
@@ -288,157 +313,34 @@ describe("r2Storage", () => {
         accessKeyId: "access-key-id",
         secretAccessKey: "secret-access-key",
       },
-    })();
-
-    await storage.profiles.runtime.getDownloadUrl(
-      "r2://test-bucket/releases/logo%402x.png",
-    );
-
-    const command = vi.mocked(getSignedUrl).mock.calls.at(-1)?.[1];
-    expect(command).toBeInstanceOf(GetObjectCommand);
-    expect((command as GetObjectCommand).input.Key).toBe(
-      "releases/logo@2x.png",
-    );
-  });
-
-  it("falls back to wrangler without S3 credentials", async () => {
-    wrangler.mockImplementation(async (...args: string[]) => {
-      const fileIndex = args.indexOf("--file");
-      const downloadPath = args[fileIndex + 1];
-
-      await fs.writeFile(
-        downloadPath,
-        JSON.stringify({
-          bundleId: "bundle-1",
-          assets: {},
-        }),
-      );
-
-      return {
-        exitCode: 0,
-        stderr: "",
-      };
+      downloadUrlSigningKey: "test-signing-key",
     });
 
-    const storage = r2Storage({
-      accountId: "account-id",
-      bucketName: "test-bucket",
-      cloudflareApiToken: "api-token",
-    })();
-
-    const downloadPath = "/tmp/hot-updater-test-manifest.json";
-    await fs.rm(downloadPath, { force: true });
-
-    await storage.profiles.node.downloadFile(
-      "r2://test-bucket/releases/bundle-1/manifest.json",
-      downloadPath,
-    );
-
-    expect(JSON.parse(await fs.readFile(downloadPath, "utf8"))).toEqual({
-      bundleId: "bundle-1",
-      assets: {},
-    });
-    expect(wrangler).toHaveBeenCalledWith(
-      "r2",
-      "object",
-      "get",
-      "test-bucket/releases/bundle-1/manifest.json",
-      "--file",
-      downloadPath,
-      "--remote",
-    );
-  });
-
-  it("keeps the deprecated wrangler path node-only at runtime", async () => {
-    const storage = r2Storage({
-      accountId: "account-id",
-      bucketName: "test-bucket",
-      cloudflareApiToken: "api-token",
-    })();
-
     await expect(
-      storage.profiles.runtime.readText(
-        "r2://test-bucket/releases/bundle-1/manifest.json",
-      ),
-    ).rejects.toThrow("r2Storage runtime profile requires R2 S3 credentials.");
+      storage.getDownloadUrl?.({
+        storageUri: "r2://test-bucket/releases/bundle.zip",
+      }),
+    ).resolves.toEqual({
+      url: expect.stringMatching(/^\/storage\//),
+    });
   });
 
   it("rejects downloads from a different bucket", async () => {
     const storage = r2Storage({
       accountId: "account-id",
       bucketName: "test-bucket",
-      cloudflareApiToken: "api-token",
-    })();
+      credentials: {
+        accessKeyId: "access-key-id",
+        secretAccessKey: "secret-access-key",
+      },
+    });
 
     await expect(
-      storage.profiles.node.downloadFile(
-        "r2://other-bucket/releases/bundle-1/manifest.json",
-        "/tmp/hot-updater-test-manifest.json",
-      ),
+      storage.get?.({
+        storageUri: "r2://other-bucket/releases/bundle-1/manifest.json",
+      }),
     ).rejects.toThrow(
       'Bucket name mismatch: expected "test-bucket", but found "other-bucket".',
     );
-    expect(wrangler).not.toHaveBeenCalled();
-  });
-
-  it("returns false when the R2 object does not exist", async () => {
-    wrangler.mockRejectedValueOnce(createExecaError("object not found"));
-
-    const storage = r2Storage({
-      accountId: "account-id",
-      bucketName: "test-bucket",
-      cloudflareApiToken: "api-token",
-    })();
-
-    await expect(
-      storage.profiles.node.exists("r2://test-bucket/releases/logo.png"),
-    ).resolves.toBe(false);
-    expect(wrangler).toHaveBeenCalledWith(
-      "r2",
-      "object",
-      "get",
-      "test-bucket/releases/logo.png",
-      "--file",
-      expect.any(String),
-      "--remote",
-    );
-  });
-
-  it("decodes percent-encoded keys before using Wrangler", async () => {
-    wrangler.mockResolvedValueOnce({ exitCode: 0, stderr: "" });
-    const storage = r2Storage({
-      accountId: "account-id",
-      bucketName: "test-bucket",
-      cloudflareApiToken: "api-token",
-    })();
-
-    await storage.profiles.node.exists(
-      "r2://test-bucket/releases/logo%402x.png",
-    );
-
-    expect(wrangler).toHaveBeenCalledWith(
-      "r2",
-      "object",
-      "get",
-      "test-bucket/releases/logo@2x.png",
-      "--file",
-      expect.any(String),
-      "--remote",
-    );
-  });
-
-  it("rethrows non-missing R2 existence errors", async () => {
-    const error = createExecaError("Authentication failed");
-    wrangler.mockRejectedValueOnce(error);
-
-    const storage = r2Storage({
-      accountId: "account-id",
-      bucketName: "test-bucket",
-      cloudflareApiToken: "api-token",
-    })();
-
-    await expect(
-      storage.profiles.node.exists("r2://test-bucket/releases/logo.png"),
-    ).rejects.toBe(error);
   });
 });

package/src/r2Storage.ts

@@ -1,66 +1,18 @@
-import {
-  createUniversalStoragePlugin,
-  type StoragePluginHooks,
-  type UniversalStoragePlugin,
-} from "@hot-updater/plugin-core";
+import type { StoragePluginWith } from "@hot-updater/plugin-core";
 
-import {
-  createS3RuntimeStorageProfile,
-  createS3StorageProfile,
-  type R2S3StorageConfig,
-} from "./r2S3Storage";
-import {
-  createWranglerRuntimeStorageProfile,
-  createWranglerStorageProfile,
-  type R2WranglerStorageConfig,
-} from "./r2WranglerStorage";
+import { createR2S3Storage, type R2S3StorageConfig } from "./r2S3Storage";
 
-export type R2StorageConfig = R2S3StorageConfig | R2WranglerStorageConfig;
+export type R2StorageConfig = R2S3StorageConfig;
+export type { R2S3StorageConfig };
 
-export type { R2S3StorageConfig, R2WranglerStorageConfig };
+export const r2Storage = (
+  config: R2S3StorageConfig,
+): StoragePluginWith<"put" | "get" | "exists" | "delete"> => {
+  if (!config.credentials) {
+    throw new Error(
+      "r2Storage requires S3-compatible credentials. The Wrangler fallback was removed.",
+    );
+  }
 
-const hasS3Credentials = (
-  config: R2StorageConfig,
-): config is R2S3StorageConfig => {
-  return Boolean(config.credentials);
+  return createR2S3Storage(config);
 };
-
-/**
- * Cloudflare R2 storage plugin for Hot Updater.
- */
-interface R2Storage {
-  (
-    config: R2S3StorageConfig,
-    hooks?: StoragePluginHooks,
-  ): () => UniversalStoragePlugin;
-  /**
-   * @deprecated `cloudflareApiToken` uses the Wrangler CLI for R2 operations,
-   * which is slower than direct S3-compatible API access. Create R2
-   * S3-compatible credentials in the Cloudflare dashboard and pass them with
-   * `r2Storage({ credentials })` instead.
-   */
-  (
-    config: R2WranglerStorageConfig,
-    hooks?: StoragePluginHooks,
-  ): () => UniversalStoragePlugin;
-}
-
-const createR2StoragePlugin = createUniversalStoragePlugin<R2StorageConfig>({
-  name: "r2Storage",
-  supportedProtocol: "r2",
-  factory: (config) => {
-    if (hasS3Credentials(config)) {
-      return {
-        node: createS3StorageProfile(config),
-        runtime: createS3RuntimeStorageProfile(config),
-      };
-    }
-
-    return {
-      node: createWranglerStorageProfile(config),
-      runtime: createWranglerRuntimeStorageProfile(),
-    };
-  },
-});
-
-export const r2Storage: R2Storage = createR2StoragePlugin;