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

package/src/r2WorkerStorage.spec.ts

@@ -1,73 +1,184 @@
-import type { RequestEnvContext } from "@hot-updater/plugin-core";
-import { describe, expect, it, vi } from "vitest";
+import { afterEach, describe, expect, it, vi } from "vitest";
 
-import {
-  type CloudflareWorkerStorageEnv,
-  r2WorkerStorage,
-} from "./r2WorkerStorage";
+import { r2WorkerStorage } from "./r2WorkerStorage";
 
-type TestContext = RequestEnvContext<CloudflareWorkerStorageEnv>;
+const createBucket = (
+  get: ReturnType<typeof vi.fn>,
+  overrides: Partial<R2Bucket> = {},
+) =>
+  ({
+    get,
+    head: vi.fn(),
+    put: vi.fn(),
+    delete: vi.fn(),
+    list: vi.fn(),
+    ...overrides,
+  }) as unknown as R2Bucket;
 
 describe("r2WorkerStorage", () => {
-  it("reads manifest text directly from the R2 binding", async () => {
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  it("reads bytes from the R2 binding captured by the implementation", async () => {
     const get = vi.fn(async (key: string) => ({
-      text: async () => `text:${key}`,
+      body: new Response(`text:${key}`).body,
+      httpEtag: '"etag"',
+      size: `text:${key}`.length,
+      writeHttpMetadata: vi.fn(),
     }));
     const storage = r2WorkerStorage({
-      jwtSecret: "secret",
-      publicBaseUrl: "https://assets.example.com",
-    })();
+      bucket: createBucket(get),
+      bucketName: "bundles",
+      downloadUrlSigningKey: "test-signing-key",
+    });
 
-    await expect(
-      storage.profiles.runtime.readText("r2://bundles/app/manifest.json", {
-        env: {
-          BUCKET: { get },
-          JWT_SECRET: "secret",
-        },
-        request: new Request("https://updates.example.com"),
-      } satisfies TestContext),
-    ).resolves.toBe("text:app/manifest.json");
+    const { response } = await storage.get({
+      storageUri: "r2://bundles/app/manifest.json",
+    });
+
+    expect(await response?.text()).toBe("text:app/manifest.json");
     expect(get).toHaveBeenCalledWith("app/manifest.json");
   });
 
-  it("decodes percent-encoded object keys before reading from R2", async () => {
-    const get = vi.fn(async (key: string) => ({
-      text: async () => `text:${key}`,
-    }));
+  it("rejects URIs owned by a different R2 binding", async () => {
+    const get = vi.fn();
     const storage = r2WorkerStorage({
-      jwtSecret: "secret",
-      publicBaseUrl: "https://assets.example.com",
-    })();
+      bucket: createBucket(get),
+      bucketName: "bundles",
+      downloadUrlSigningKey: "test-signing-key",
+    });
 
-    await storage.profiles.runtime.readText(
-      "r2://bundles/assets/bootsplash/logo-ios%402x.png",
-      {
-        env: {
-          BUCKET: { get },
-          JWT_SECRET: "secret",
-        },
-        request: new Request("https://updates.example.com"),
-      } satisfies TestContext,
+    await expect(
+      storage.get({ storageUri: "r2://other/app/manifest.json" }),
+    ).rejects.toThrow(
+      'Bucket name mismatch: expected "bundles", but found "other".',
     );
-
-    expect(get).toHaveBeenCalledWith("assets/bootsplash/logo-ios@2x.png");
+    expect(get).not.toHaveBeenCalled();
   });
 
-  it("fails fast when the R2 binding is missing", async () => {
+  it("writes and deletes the exact object key through the R2 binding", async () => {
+    let uploaded = "";
+    const put = vi.fn(async (_key: string, body: Uint8Array) => {
+      uploaded = new TextDecoder().decode(body);
+      return null;
+    });
+    const bucket = createBucket(vi.fn(), {
+      put: put as unknown as R2Bucket["put"],
+    });
     const storage = r2WorkerStorage({
-      jwtSecret: "secret",
-      publicBaseUrl: "https://assets.example.com",
-    })();
+      bucket,
+      bucketName: "bundles",
+      downloadUrlSigningKey: "test-signing-key",
+    });
 
+    await storage.put({
+      key: "releases/bundle.zip",
+      body: new Response("bundle").body!,
+      contentType: "application/zip",
+    });
     await expect(
-      storage.profiles.runtime.readText("r2://bundles/app/manifest.json", {
-        env: {
-          JWT_SECRET: "secret",
+      storage.delete({
+        storageUri: "r2://bundles/releases/bundle.zip",
+      }),
+    ).resolves.toEqual({
+      deleted: true,
+    });
+
+    expect(bucket.put).toHaveBeenCalledWith(
+      "releases/bundle.zip",
+      expect.any(Uint8Array),
+      {
+        httpMetadata: {
+          cacheControl: "max-age=31536000",
+          contentType: "application/zip",
         },
-        request: new Request("https://updates.example.com"),
-      } as TestContext),
-    ).rejects.toThrow(
-      "r2WorkerStorage requires env.BUCKET in the hot updater context.",
+      },
+    );
+    expect(uploaded).toBe("bundle");
+    expect(bucket.delete).toHaveBeenCalledWith("releases/bundle.zip");
+  });
+
+  it("round-trips reserved characters without changing the R2 binding key", async () => {
+    const bucket = createBucket(vi.fn());
+    const storage = r2WorkerStorage({
+      bucket,
+      bucketName: "bundles",
+      downloadUrlSigningKey: "test-signing-key",
+    });
+    const key = "릴리스 folder/logo@2x #100%/bundle.zip";
+
+    const uploaded = await storage.put({
+      key,
+      body: new Response("bundle").body!,
+      contentType: "application/zip",
+    });
+    expect(uploaded.storageUri).toContain("logo%402x");
+    await storage.delete({ storageUri: uploaded.storageUri });
+    await storage.delete({ storageUri: uploaded.storageUri });
+
+    expect(bucket.put).toHaveBeenCalledWith(
+      key,
+      expect.any(Uint8Array),
+      expect.any(Object),
+    );
+    expect(bucket.delete).toHaveBeenNthCalledWith(1, key);
+    expect(bucket.delete).toHaveBeenNthCalledWith(2, key);
+  });
+
+  it("uses a fixed-length stream when the upload length is known", async () => {
+    const expectedLengths: number[] = [];
+    class TestFixedLengthStream extends TransformStream<
+      Uint8Array,
+      Uint8Array
+    > {
+      constructor(expectedLength: number) {
+        super();
+        expectedLengths.push(expectedLength);
+      }
+    }
+    vi.stubGlobal("FixedLengthStream", TestFixedLengthStream);
+    let uploaded = "";
+    const put = vi.fn(
+      async (_key: string, body: ReadableStream<Uint8Array>) => {
+        uploaded = await new Response(body).text();
+        return null;
+      },
     );
+    const storage = r2WorkerStorage({
+      bucket: createBucket(vi.fn(), {
+        put: put as unknown as R2Bucket["put"],
+      }),
+      bucketName: "bundles",
+      downloadUrlSigningKey: "test-signing-key",
+    });
+
+    await storage.put({
+      key: "releases/bundle.zip",
+      body: new Response("bundle").body!,
+      contentLength: 6,
+      contentType: "application/zip",
+    });
+
+    expect(expectedLengths).toEqual([6]);
+    expect(uploaded).toBe("bundle");
+  });
+
+  it("returns a stable signed download path for private R2 objects", async () => {
+    const storage = r2WorkerStorage({
+      bucket: createBucket(vi.fn()),
+      bucketName: "bundles",
+      downloadUrlSigningKey: "test-signing-key",
+    });
+
+    const first = await storage.getDownloadUrl({
+      storageUri: "r2://bundles/releases/bundle.zip",
+    });
+    const second = await storage.getDownloadUrl({
+      storageUri: "r2://bundles/releases/bundle.zip",
+    });
+
+    expect(first).toEqual(second);
+    expect(first.url).toMatch(/^\/storage\//);
   });
 });

package/src/r2WorkerStorage.ts

@@ -1,127 +1,94 @@
-import { signToken } from "@hot-updater/js";
 import {
-  createRuntimeStoragePlugin,
-  decodeStorageObjectKey,
-  type HotUpdaterContext,
-  type RequestEnvContext,
+  createStorageKeyBuilder,
+  createStorageDownloadUrl,
+  createStoragePlugin,
+  createStorageUri,
+  parseStorageUri,
+  type StoragePluginWith,
 } from "@hot-updater/plugin-core";
 
-export interface CloudflareWorkerStorageEnv {
-  JWT_SECRET: string;
-  BUCKET: {
-    get: (key: string) => Promise<{ text: () => Promise<string> } | null>;
-  };
-}
-
-type ContextResolver<TContext, TValue> = (
-  context?: HotUpdaterContext<TContext>,
-) => TValue | Promise<TValue>;
-
-export interface CloudflareWorkerStorageConfig<
-  TContext extends RequestEnvContext<CloudflareWorkerStorageEnv>,
-> {
-  jwtSecret?: string | ContextResolver<TContext, string>;
-  publicBaseUrl: string | ContextResolver<TContext, string>;
+export interface CloudflareWorkerStorageConfig {
+  readonly bucket: R2Bucket;
+  readonly bucketName: string;
+  readonly basePath?: string;
+  readonly downloadUrlSigningKey: string;
 }
 
-const resolveContextValue = async <TContext, TValue>(
-  value: TValue | ContextResolver<TContext, TValue>,
-  context?: HotUpdaterContext<TContext>,
-) => {
-  return typeof value === "function"
-    ? await (value as ContextResolver<TContext, TValue>)(context)
-    : value;
-};
-
-const resolveJwtSecretFromContext = (
-  context?: RequestEnvContext<CloudflareWorkerStorageEnv>,
-) => {
-  const jwtSecret = context?.env?.JWT_SECRET;
-
-  if (!jwtSecret) {
-    throw new Error(
-      "r2WorkerStorage requires env.JWT_SECRET in the hot updater context.",
-    );
-  }
-
-  return jwtSecret;
-};
-
-const resolveR2BucketFromContext = (
-  context?: RequestEnvContext<CloudflareWorkerStorageEnv>,
-) => {
-  const bucket = context?.env?.BUCKET;
-
-  if (!bucket) {
-    throw new Error(
-      "r2WorkerStorage requires env.BUCKET in the hot updater context.",
-    );
-  }
-
-  return bucket;
-};
-
-const createPublicObjectPath = (storageUrl: URL) =>
-  `${storageUrl.host}${storageUrl.pathname}`;
-
-const createR2ObjectKey = (storageUrl: URL) =>
-  decodeStorageObjectKey(storageUrl.pathname.replace(/^\/+/, ""));
-
-export const r2WorkerStorage = <
-  TContext extends RequestEnvContext<CloudflareWorkerStorageEnv> =
-    RequestEnvContext<CloudflareWorkerStorageEnv>,
->(
-  config: CloudflareWorkerStorageConfig<TContext>,
-) => {
-  return createRuntimeStoragePlugin<
-    CloudflareWorkerStorageConfig<TContext>,
-    TContext
-  >({
-    name: "r2WorkerStorage",
-    supportedProtocol: "r2",
-    factory: (config) => ({
-      async readText(storageUri, context) {
-        const storageUrl = new URL(storageUri);
-
-        if (storageUrl.protocol !== "r2:") {
-          throw new Error("Invalid R2 storage URI protocol");
-        }
-
-        const bucket = resolveR2BucketFromContext(context);
-        const key = createR2ObjectKey(storageUrl);
-        const object = await bucket.get(key);
-        if (!object) {
-          return null;
-        }
-
-        return object.text();
-      },
-      async getDownloadUrl(storageUri, context) {
-        const storageUrl = new URL(storageUri);
-
-        if (storageUrl.protocol !== "r2:") {
-          throw new Error("Invalid R2 storage URI protocol");
-        }
+export const r2WorkerStorage = (
+  config: CloudflareWorkerStorageConfig,
+): StoragePluginWith<
+  "put" | "get" | "getDownloadUrl" | "exists" | "delete"
+> => {
+  const getStorageKey = createStorageKeyBuilder(config.basePath);
+  const getDownloadUrl = createStorageDownloadUrl(config.downloadUrlSigningKey);
+
+  const parseAndValidate = (storageUri: string) => {
+    const parsed = parseStorageUri(storageUri, "r2");
+    if (parsed.bucket !== config.bucketName) {
+      throw new Error(
+        `Bucket name mismatch: expected "${config.bucketName}", but found "${parsed.bucket}".`,
+      );
+    }
+    return parsed;
+  };
 
-        const key = createPublicObjectPath(storageUrl);
-        const [jwtSecret, publicBaseUrl] = await Promise.all([
-          resolveContextValue(
-            config.jwtSecret ?? resolveJwtSecretFromContext,
-            context,
+  return createStoragePlugin({
+    name: "r2Storage",
+    protocol: "r2",
+    async put({ key, body, contentLength, contentType }) {
+      const storageKey = getStorageKey(key);
+      const uploadOptions = {
+        httpMetadata: {
+          contentType,
+          cacheControl: "max-age=31536000",
+        },
+      };
+      if (contentLength === undefined) {
+        const bufferedBody = new Uint8Array(
+          await new Response(body).arrayBuffer(),
+        );
+        await config.bucket.put(storageKey, bufferedBody, uploadOptions);
+      } else {
+        const fixedLengthBody = new FixedLengthStream(contentLength);
+        await Promise.all([
+          body.pipeTo(fixedLengthBody.writable),
+          config.bucket.put(
+            storageKey,
+            fixedLengthBody.readable,
+            uploadOptions,
           ),
-          resolveContextValue(config.publicBaseUrl, context),
         ]);
-        const token = await signToken(key, jwtSecret);
-        const url = new URL(publicBaseUrl);
-
-        url.pathname = key;
-        url.search = "";
-        url.searchParams.set("token", token);
-
-        return {
-          fileUrl: url.toString(),
-        };
-      },
-    }),
-  })(config);
+      }
+      return {
+        storageUri: createStorageUri({
+          protocol: "r2",
+          bucket: config.bucketName,
+          key: storageKey,
+        }),
+      };
+    },
+    async get({ storageUri }) {
+      const { key } = parseAndValidate(storageUri);
+      const object = await config.bucket.get(key);
+      if (!object) return { response: null };
+      const headers = new Headers();
+      object.writeHttpMetadata(headers);
+      headers.set("etag", object.httpEtag);
+      headers.set("content-length", String(object.size));
+      return { response: new Response(object.body, { headers }) };
+    },
+    async getDownloadUrl({ storageUri }) {
+      parseAndValidate(storageUri);
+      return getDownloadUrl({ storageUri });
+    },
+    async exists({ storageUri }) {
+      const { key } = parseAndValidate(storageUri);
+      return { exists: (await config.bucket.head(key)) !== null };
+    },
+    async delete({ storageUri }) {
+      const { key } = parseAndValidate(storageUri);
+      await config.bucket.delete(key);
+      return { deleted: true };
+    },
+  });
 };

package/src/worker/d1Database.spec.ts

@@ -0,0 +1,33 @@
+import { expect, it } from "vitest";
+
+import { d1Database, type D1Like } from "./d1Database";
+
+const database: D1Like = {
+  prepare: () => ({
+    bind: () => ({
+      all: async () => ({
+        results: [{ id: "channel-production", name: "production" }],
+      }),
+    }),
+  }),
+  batch: async (statements) =>
+    Promise.all(statements.map((item) => item.all())),
+};
+
+it("uses the D1 binding supplied at the Worker composition boundary", async () => {
+  const plugin = d1Database(database);
+
+  expect(plugin.name).toBe("d1Database");
+  expect(Object.keys(plugin.models).sort()).toEqual([
+    "analytics",
+    "apiKeys",
+    "bundlePatches",
+    "bundles",
+    "channels",
+    "releaseCatalogs",
+    "releases",
+  ]);
+  await expect(plugin.models.channels.list({})).resolves.toEqual({
+    channels: [{ id: "channel-production", name: "production" }],
+  });
+});

package/src/worker/d1Database.ts

@@ -0,0 +1,52 @@
+import { createDatabasePlugin } from "@hot-updater/plugin-core";
+import { createDatabasePluginAdapter } from "@hot-updater/plugin-core/internal";
+
+import { createD1Implementation } from "../d1Implementation";
+
+type D1Result = {
+  readonly results?: readonly unknown[];
+};
+
+type D1BoundStatement = {
+  all: () => Promise<D1Result>;
+};
+
+type D1PreparedStatement = {
+  bind: (...values: readonly unknown[]) => D1BoundStatement;
+};
+
+export type D1Like = {
+  prepare(sql: string): D1PreparedStatement;
+  batch(statements: D1BoundStatement[]): Promise<readonly D1Result[]>;
+};
+
+export interface CloudflareWorkerDatabaseEnv {
+  readonly DB: D1Like;
+}
+
+export const d1Database = (database: D1Like) => {
+  const implementation = createD1Implementation({
+    async query(sql, params) {
+      const result = await database
+        .prepare(sql)
+        .bind(...params)
+        .all();
+      return result.results ?? [];
+    },
+    async batch(statements) {
+      const results = await database.batch(
+        statements.map(({ sql, params }) =>
+          database.prepare(sql).bind(...params),
+        ),
+      );
+      return results.map(({ results }) => results ?? []);
+    },
+  });
+  const adapter = createDatabasePluginAdapter("d1Database", implementation);
+  return createDatabasePlugin({
+    name: "d1Database",
+    models: adapter.models,
+    commit: adapter.commit,
+    ...(adapter.dispose ? { dispose: adapter.dispose } : {}),
+  });
+};

package/src/worker/index.ts

@@ -1,33 +1,5 @@
-export { verifyJwtSignedUrl } from "@hot-updater/js";
-
-import type { RequestEnvContext as BaseRequestEnvContext } from "@hot-updater/plugin-core";
-
-import {
-  type CloudflareWorkerDatabaseEnv,
-  d1WorkerDatabase,
-} from "../cloudflareWorkerDatabase";
-import {
+export { d1Database, type D1Like } from "./d1Database";
+export {
+  r2WorkerStorage as r2Storage,
   type CloudflareWorkerStorageConfig,
-  type CloudflareWorkerStorageEnv,
-  r2WorkerStorage,
 } from "../r2WorkerStorage";
-
-export type { CloudflareWorkerDatabaseEnv, CloudflareWorkerStorageEnv };
-
-export interface CloudflareWorkerRuntimeEnv
-  extends CloudflareWorkerDatabaseEnv, CloudflareWorkerStorageEnv {}
-
-export type RequestEnvContext<TEnv = CloudflareWorkerRuntimeEnv> =
-  BaseRequestEnvContext<TEnv>;
-
-export const d1Database = <
-  TContext extends RequestEnvContext<CloudflareWorkerRuntimeEnv> =
-    RequestEnvContext<CloudflareWorkerRuntimeEnv>,
->() => d1WorkerDatabase<TContext>();
-
-export const r2Storage = <
-  TContext extends RequestEnvContext<CloudflareWorkerRuntimeEnv> =
-    RequestEnvContext<CloudflareWorkerRuntimeEnv>,
->(
-  config: CloudflareWorkerStorageConfig<TContext>,
-) => r2WorkerStorage<TContext>(config);

package/worker/dist/README.md

@@ -1 +1 @@
-This folder contains the built output assets for the worker "hot-updater" generated at 2026-08-30T03:59:50.247Z.
+This folder contains the built output assets for the worker "hot-updater" generated at 2026-08-31T01:29:11.045Z.