@hot-updater/cloudflare 0.28.0 → 0.29.0

package/src/d1Database.ts

@@ -0,0 +1,366 @@
+import {
+  DEFAULT_ROLLOUT_COHORT_COUNT,
+  type SnakeCaseBundle,
+} from "@hot-updater/core";
+import type {
+  Bundle,
+  DatabaseBundleQueryOrder,
+  DatabaseBundleQueryWhere,
+  PaginationOptions,
+} from "@hot-updater/plugin-core";
+import {
+  calculatePagination,
+  createDatabasePlugin,
+} from "@hot-updater/plugin-core";
+import Cloudflare from "cloudflare";
+import minify from "pg-minify";
+
+export interface D1DatabaseConfig {
+  databaseId: string;
+  accountId: string;
+  cloudflareApiToken: string;
+}
+
+// Helper interfaces for clarity
+type QueryConditions = DatabaseBundleQueryWhere;
+
+interface BuildQueryResult {
+  sql: string;
+  params: any[];
+}
+
+async function resolvePage<T>(singlePage: any): Promise<T[]> {
+  const results: T[] = [];
+  for await (const page of singlePage.iterPages()) {
+    const data = page.result.flatMap((r: any) => r.results);
+    results.push(...(data as T[]));
+  }
+  return results;
+}
+
+// Helper function to build WHERE clause
+function buildWhereClause(conditions: QueryConditions): BuildQueryResult {
+  const clauses: string[] = [];
+  const params: any[] = [];
+
+  if (conditions.channel) {
+    clauses.push("channel = ?");
+    params.push(conditions.channel);
+  }
+
+  if (conditions.platform) {
+    clauses.push("platform = ?");
+    params.push(conditions.platform);
+  }
+
+  if (conditions.enabled !== undefined) {
+    clauses.push("enabled = ?");
+    params.push(conditions.enabled ? 1 : 0);
+  }
+
+  if (conditions.id?.in) {
+    if (conditions.id.in.length === 0) {
+      clauses.push("1 = 0");
+    } else {
+      clauses.push(`id IN (${conditions.id.in.map(() => "?").join(", ")})`);
+      params.push(...conditions.id.in);
+    }
+  }
+
+  if (conditions.id?.eq) {
+    clauses.push("id = ?");
+    params.push(conditions.id.eq);
+  }
+
+  if (conditions.id?.gt) {
+    clauses.push("id > ?");
+    params.push(conditions.id.gt);
+  }
+
+  if (conditions.id?.gte) {
+    clauses.push("id >= ?");
+    params.push(conditions.id.gte);
+  }
+
+  if (conditions.id?.lt) {
+    clauses.push("id < ?");
+    params.push(conditions.id.lt);
+  }
+
+  if (conditions.id?.lte) {
+    clauses.push("id <= ?");
+    params.push(conditions.id.lte);
+  }
+
+  if (conditions.targetAppVersionNotNull) {
+    clauses.push("target_app_version IS NOT NULL");
+  }
+
+  if (conditions.targetAppVersion !== undefined) {
+    if (conditions.targetAppVersion === null) {
+      clauses.push("target_app_version IS NULL");
+    } else {
+      clauses.push("target_app_version = ?");
+      params.push(conditions.targetAppVersion);
+    }
+  }
+
+  if (conditions.targetAppVersionIn) {
+    if (conditions.targetAppVersionIn.length === 0) {
+      clauses.push("1 = 0");
+    } else {
+      clauses.push(
+        `target_app_version IN (${conditions.targetAppVersionIn
+          .map(() => "?")
+          .join(", ")})`,
+      );
+      params.push(...conditions.targetAppVersionIn);
+    }
+  }
+
+  if (conditions.fingerprintHash !== undefined) {
+    if (conditions.fingerprintHash === null) {
+      clauses.push("fingerprint_hash IS NULL");
+    } else {
+      clauses.push("fingerprint_hash = ?");
+      params.push(conditions.fingerprintHash);
+    }
+  }
+
+  const whereClause =
+    clauses.length > 0 ? ` WHERE ${clauses.join(" AND ")}` : "";
+
+  return { sql: whereClause, params };
+}
+
+function parseTargetCohorts(value: unknown): string[] | null {
+  if (!value) return null;
+  if (Array.isArray(value)) {
+    return value.filter((v): v is string => typeof v === "string");
+  }
+  if (typeof value === "string") {
+    try {
+      const parsed = JSON.parse(value) as unknown;
+      if (Array.isArray(parsed)) {
+        return parsed.filter((v): v is string => typeof v === "string");
+      }
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+
+// Helper function to transform snake_case row to Bundle
+function transformRowToBundle(row: SnakeCaseBundle): Bundle {
+  return {
+    id: row.id,
+    channel: row.channel,
+    enabled: Boolean(row.enabled),
+    shouldForceUpdate: Boolean(row.should_force_update),
+    fileHash: row.file_hash,
+    gitCommitHash: row.git_commit_hash,
+    message: row.message,
+    platform: row.platform,
+    targetAppVersion: row.target_app_version,
+    storageUri: row.storage_uri,
+    fingerprintHash: row.fingerprint_hash,
+    metadata: row?.metadata ? JSON.parse(row?.metadata as string) : {},
+    rolloutCohortCount:
+      (row.rollout_cohort_count as number | null) ??
+      DEFAULT_ROLLOUT_COHORT_COUNT,
+    targetCohorts: parseTargetCohorts(row.target_cohorts as unknown),
+  };
+}
+
+export const d1Database = createDatabasePlugin<D1DatabaseConfig>({
+  name: "d1Database",
+  factory: (config) => {
+    let bundles: Bundle[] = [];
+    const cf = new Cloudflare({
+      apiToken: config.cloudflareApiToken,
+    });
+
+    // Helper function to get total count
+    async function getTotalCount(conditions: QueryConditions): Promise<number> {
+      const { sql: whereClause, params } = buildWhereClause(conditions);
+      const countSql = minify(
+        `SELECT COUNT(*) as total FROM bundles${whereClause}`,
+      );
+
+      const countResult = await cf.d1.database.query(config.databaseId, {
+        account_id: config.accountId,
+        sql: countSql,
+        params,
+      });
+
+      const rows = await resolvePage<{ total: number }>(countResult);
+      return rows[0]?.total || 0;
+    }
+
+    // Helper function to get paginated bundles
+    async function getPaginatedBundles(
+      conditions: QueryConditions,
+      limit: number,
+      offset: number,
+      orderBy?: DatabaseBundleQueryOrder,
+    ): Promise<Bundle[]> {
+      const { sql: whereClause, params } = buildWhereClause(conditions);
+      const orderBySql =
+        orderBy?.direction === "asc" ? "ORDER BY id ASC" : "ORDER BY id DESC";
+
+      // Build the complete query
+      const sql = minify(`
+      SELECT * FROM bundles
+      ${whereClause}
+      ${orderBySql}
+      LIMIT ?
+      OFFSET ?
+    `);
+
+      // Add pagination params
+      params.push(limit, offset);
+
+      const result = await cf.d1.database.query(config.databaseId, {
+        account_id: config.accountId,
+        sql,
+        params,
+      });
+
+      const rows = await resolvePage<SnakeCaseBundle>(result);
+      return rows.map(transformRowToBundle);
+    }
+
+    return {
+      async getBundleById(bundleId) {
+        const found = bundles.find((b) => b.id === bundleId);
+        if (found) {
+          return found;
+        }
+
+        const sql = minify(/* sql */ `
+          SELECT * FROM bundles WHERE id = ? LIMIT 1`);
+        const singlePage = await cf.d1.database.query(config.databaseId, {
+          account_id: config.accountId,
+          sql,
+          params: [bundleId],
+        });
+
+        const rows = await resolvePage<SnakeCaseBundle>(singlePage);
+
+        if (rows.length === 0) {
+          return null;
+        }
+
+        return transformRowToBundle(rows[0]);
+      },
+
+      async getBundles(options) {
+        const { where = {}, limit, offset, orderBy } = options;
+
+        // 1. Get total count for pagination
+        const totalCount = await getTotalCount(where);
+
+        // 2. Get paginated bundles
+        bundles = await getPaginatedBundles(where, limit, offset, orderBy);
+
+        // 3. Calculate pagination metadata
+        const paginationOptions: PaginationOptions = { limit, offset };
+        const pagination = calculatePagination(totalCount, paginationOptions);
+
+        return {
+          data: bundles,
+          pagination,
+        };
+      },
+
+      async getChannels() {
+        const sql = minify(/* sql */ `
+          SELECT channel FROM bundles GROUP BY channel
+        `);
+        const singlePage = await cf.d1.database.query(config.databaseId, {
+          account_id: config.accountId,
+          sql,
+          params: [],
+        });
+
+        const rows = await resolvePage<{ channel: string }>(singlePage);
+        return rows.map((row) => row.channel);
+      },
+
+      async commitBundle({ changedSets }) {
+        if (changedSets.length === 0) {
+          return;
+        }
+
+        // Process each operation sequentially
+        for (const op of changedSets) {
+          if (op.operation === "delete") {
+            // Handle delete operation
+            const deleteSql = minify(/* sql */ `
+              DELETE FROM bundles WHERE id = ?
+            `);
+
+            await cf.d1.database.query(config.databaseId, {
+              account_id: config.accountId,
+              sql: deleteSql,
+              params: [op.data.id],
+            });
+
+            // Update local bundles array
+            bundles = bundles.filter((b) => b.id !== op.data.id);
+          } else if (op.operation === "insert" || op.operation === "update") {
+            // Handle insert and update operations
+            const bundle = op.data;
+            const upsertSql = minify(/* sql */ `
+              INSERT OR REPLACE INTO bundles (
+                id,
+                channel,
+                enabled,
+                should_force_update,
+                file_hash,
+                git_commit_hash,
+                message,
+                platform,
+                target_app_version,
+                storage_uri,
+                fingerprint_hash,
+                metadata,
+                rollout_cohort_count,
+                target_cohorts
+              )
+              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            `);
+
+            const params = [
+              bundle.id,
+              bundle.channel,
+              bundle.enabled ? 1 : 0,
+              bundle.shouldForceUpdate ? 1 : 0,
+              bundle.fileHash,
+              bundle.gitCommitHash || null,
+              bundle.message || null,
+              bundle.platform,
+              bundle.targetAppVersion,
+              bundle.storageUri,
+              bundle.fingerprintHash,
+              bundle.metadata
+                ? JSON.stringify(bundle.metadata)
+                : JSON.stringify({}),
+              bundle.rolloutCohortCount ?? DEFAULT_ROLLOUT_COHORT_COUNT,
+              bundle.targetCohorts
+                ? JSON.stringify(bundle.targetCohorts)
+                : null,
+            ];
+
+            await cf.d1.database.query(config.databaseId, {
+              account_id: config.accountId,
+              sql: upsertSql,
+              params: params as string[],
+            });
+          }
+        }
+      },
+    };
+  },
+});

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from "./d1Database";
+export * from "./r2Storage";

package/src/r2Storage.ts

@@ -0,0 +1,129 @@
+import {
+  createStorageKeyBuilder,
+  createStoragePlugin,
+  getContentType,
+  parseStorageUri,
+} from "@hot-updater/plugin-core";
+import { ExecaError } from "execa";
+
+import path from "path";
+import { createWrangler } from "./utils/createWrangler";
+
+export interface R2StorageConfig {
+  cloudflareApiToken: string;
+  accountId: string;
+  bucketName: string;
+  /**
+   * Base path where bundles will be stored in the bucket
+   */
+  basePath?: string;
+}
+
+/**
+ * Cloudflare R2 storage plugin for Hot Updater.
+ *
+ * Note: This plugin does not support `getDownloadUrl()`.
+ * If you need download URL generation, use `s3Storage` from `@hot-updater/aws` instead,
+ * which is fully compatible with Cloudflare R2.
+ *
+ * @example
+ * ```typescript
+ * // Using s3Storage with Cloudflare R2 for download URL support
+ * import { s3Storage } from "@hot-updater/aws";
+ *
+ * s3Storage({
+ *   region: "auto",
+ *   endpoint: "https://YOUR_ACCOUNT_ID.r2.cloudflarestorage.com",
+ *   credentials: {
+ *     accessKeyId: "YOUR_ACCESS_KEY_ID",
+ *     secretAccessKey: "YOUR_SECRET_ACCESS_KEY",
+ *   },
+ *   bucketName: "YOUR_BUCKET_NAME",
+ * })
+ * ```
+ */
+export const r2Storage = createStoragePlugin<R2StorageConfig>({
+  name: "r2Storage",
+  supportedProtocol: "r2",
+  factory: (config) => {
+    const { bucketName, cloudflareApiToken, accountId } = config;
+    const wrangler = createWrangler({
+      accountId,
+      cloudflareApiToken: cloudflareApiToken,
+      cwd: process.cwd(),
+    });
+
+    const getStorageKey = createStorageKeyBuilder(config.basePath);
+
+    return {
+      async delete(storageUri) {
+        const { bucket, key } = parseStorageUri(storageUri, "r2");
+        if (bucket !== bucketName) {
+          throw new Error(
+            `Bucket name mismatch: expected "${bucketName}", but found "${bucket}".`,
+          );
+        }
+
+        try {
+          await wrangler(
+            "r2",
+            "object",
+            "delete",
+            [bucketName, key].join("/"),
+            "--remote",
+          );
+        } catch {
+          throw new Error("Can not delete bundle");
+        }
+      },
+      async upload(key, filePath) {
+        const contentType = getContentType(filePath);
+
+        const filename = path.basename(filePath);
+
+        const Key = getStorageKey(key, filename);
+        try {
+          const { stderr, exitCode } = await wrangler(
+            "r2",
+            "object",
+            "put",
+            [bucketName, Key].join("/"),
+            "--file",
+            filePath,
+            "--content-type",
+            contentType,
+            "--remote",
+          );
+          if (exitCode !== 0 && stderr) {
+            throw new Error(stderr);
+          }
+        } catch (error) {
+          if (error instanceof ExecaError) {
+            throw new Error(error.stderr || error.stdout);
+          }
+
+          throw error;
+        }
+
+        return {
+          storageUri: `r2://${bucketName}/${Key}`,
+        };
+      },
+      async getDownloadUrl() {
+        throw new Error(
+          "`r2Storage` does not support `getDownloadUrl()`. Use `s3Storage` from `@hot-updater/aws` instead (compatible with Cloudflare R2).\n\n" +
+            "Example:\n" +
+            "s3Storage({\n" +
+            "  region: 'auto',\n" +
+            "  endpoint: 'https://YOUR_ACCOUNT_ID.r2.cloudflarestorage.com',\n" +
+            "  credentials: {\n" +
+            "    accessKeyId: 'YOUR_ACCESS_KEY_ID',\n" +
+            "    secretAccessKey: 'YOUR_SECRET_ACCESS_KEY',\n" +
+            "  },\n" +
+            "  bucketName: 'YOUR_BUCKET_NAME',\n" +
+            "})",
+        );
+      },
+    };
+  },
+});

package/src/r2WorkerStorage.ts

@@ -0,0 +1,94 @@
+import { signToken } from "@hot-updater/js";
+import type {
+  HotUpdaterContext,
+  RequestEnvContext,
+  StoragePlugin,
+} from "@hot-updater/plugin-core";
+
+export interface CloudflareWorkerStorageEnv {
+  JWT_SECRET: string;
+}
+
+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>;
+}
+
+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;
+};
+
+export const r2WorkerStorage = <
+  TContext extends
+    RequestEnvContext<CloudflareWorkerStorageEnv> = RequestEnvContext<CloudflareWorkerStorageEnv>,
+>(
+  config: CloudflareWorkerStorageConfig<TContext>,
+) => {
+  return (): StoragePlugin<TContext> => {
+    return {
+      name: "r2WorkerStorage",
+      supportedProtocol: "r2",
+      async upload() {
+        throw new Error(
+          "r2WorkerStorage does not support upload() in the worker runtime.",
+        );
+      },
+      async delete() {
+        throw new Error(
+          "r2WorkerStorage does not support delete() in the worker runtime.",
+        );
+      },
+      async getDownloadUrl(storageUri, context) {
+        const storageUrl = new URL(storageUri);
+
+        if (storageUrl.protocol !== "r2:") {
+          throw new Error("Invalid R2 storage URI protocol");
+        }
+
+        const key = `${storageUrl.host}${storageUrl.pathname}`;
+        const [jwtSecret, publicBaseUrl] = await Promise.all([
+          resolveContextValue(
+            config.jwtSecret ?? resolveJwtSecretFromContext,
+            context,
+          ),
+          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(),
+        };
+      },
+    };
+  };
+};

package/src/utils/createWrangler.ts

@@ -0,0 +1,27 @@
+import { execa } from "execa";
+
+export const createWrangler = ({
+  stdio,
+  accountId,
+
+  cloudflareApiToken,
+  cwd,
+}: {
+  stdio?: "inherit" | "pipe" | "ignore" | "overlapped";
+  accountId: string;
+  cloudflareApiToken: string;
+  cwd: string;
+}) => {
+  const $ = execa({
+    stdio,
+    extendsEnv: true,
+    shell: stdio === "inherit",
+    cwd,
+    env: {
+      CLOUDFLARE_ACCOUNT_ID: accountId,
+      CLOUDFLARE_API_TOKEN: cloudflareApiToken,
+    },
+  });
+
+  return (...command: string[]) => $("npx", ["wrangler", ...command]);
+};

package/src/worker/index.ts

@@ -0,0 +1,33 @@
+export { verifyJwtSignedUrl } from "@hot-updater/js";
+
+import type { RequestEnvContext as BaseRequestEnvContext } from "@hot-updater/plugin-core";
+import {
+  type CloudflareWorkerDatabaseEnv,
+  d1WorkerDatabase,
+} from "../cloudflareWorkerDatabase";
+import {
+  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-03-20T20:22:00.562Z.
+This folder contains the built output assets for the worker "hot-updater" generated at 2026-04-02T18:21:23.609Z.