@hot-updater/cloudflare 0.36.7 → 1.0.0-rc.1

package/src/d1Sql.ts

@@ -0,0 +1,175 @@
+import type {
+  DatabaseStringComparisonMode,
+  DatabaseWhereConnector,
+  DatabaseWhereOperator,
+} from "@hot-updater/plugin-core/internal";
+
+export type D1Query = {
+  readonly sql: string;
+  readonly params: readonly string[];
+};
+
+type D1Predicate = {
+  readonly field: string;
+  readonly operator?: DatabaseWhereOperator;
+  readonly value: unknown;
+  readonly connector?: DatabaseWhereConnector;
+  readonly mode?: DatabaseStringComparisonMode;
+};
+
+type D1Sort = {
+  readonly field: string;
+  readonly direction: "asc" | "desc";
+  readonly nulls?: "first" | "last";
+};
+
+class InvalidD1PredicateError extends Error {
+  readonly name = "InvalidD1PredicateError";
+}
+
+const encodeD1Value = (value: unknown): string => {
+  const encoded = JSON.stringify(value);
+  if (encoded === undefined) {
+    throw new TypeError("D1 values must be JSON-serializable.");
+  }
+  return encoded;
+};
+
+const bind = (value: unknown): D1Query => ({
+  sql: "json_extract(?, '$')",
+  params: [encodeD1Value(value)],
+});
+
+const escapeLikePattern = (value: string): string =>
+  value.replaceAll("\\", "\\\\").replaceAll("%", "\\%").replaceAll("_", "\\_");
+
+const stringPredicate = (
+  condition: D1Predicate,
+  operator: "contains" | "ends_with" | "starts_with",
+): D1Query => {
+  if (typeof condition.value !== "string") {
+    throw new InvalidD1PredicateError();
+  }
+
+  if (condition.mode !== "insensitive") {
+    const parameter = bind(condition.value);
+    const column = `${condition.field} COLLATE BINARY`;
+    const value = `${parameter.sql} COLLATE BINARY`;
+    if (operator === "contains" || operator === "starts_with") {
+      return {
+        sql: `instr(${column}, ${value}) ${operator === "contains" ? "> 0" : "= 1"}`,
+        params: parameter.params,
+      };
+    }
+    return {
+      sql: `substr(${column}, length(${condition.field}) - length(${parameter.sql}) + 1) = ${value}`,
+      params: [...parameter.params, ...parameter.params],
+    };
+  }
+
+  const literal = escapeLikePattern(condition.value);
+  const pattern =
+    operator === "contains"
+      ? `%${literal}%`
+      : operator === "starts_with"
+        ? `${literal}%`
+        : `%${literal}`;
+  const parameter = bind(pattern);
+  return {
+    sql: `lower(${condition.field}) LIKE lower(${parameter.sql}) ESCAPE '\\'`,
+    params: parameter.params,
+  };
+};
+
+const predicate = (condition: D1Predicate): D1Query => {
+  const operator = condition.operator ?? "eq";
+  switch (operator) {
+    case "eq":
+    case "ne": {
+      if (condition.value === null) {
+        return {
+          sql: `${condition.field} IS ${operator === "ne" ? "NOT " : ""}NULL`,
+          params: [],
+        };
+      }
+      const parameter = bind(condition.value);
+      const insensitive =
+        "mode" in condition && condition.mode === "insensitive";
+      const column = insensitive
+        ? `lower(${condition.field})`
+        : condition.field;
+      const value = insensitive ? `lower(${parameter.sql})` : parameter.sql;
+      return {
+        sql: `${column} ${operator === "eq" ? "=" : "<>"} ${value}`,
+        params: parameter.params,
+      };
+    }
+    case "gt":
+    case "gte":
+    case "lt":
+    case "lte": {
+      const sqlOperator = {
+        gt: ">",
+        gte: ">=",
+        lt: "<",
+        lte: "<=",
+      }[operator];
+      const parameter = bind(condition.value);
+      return {
+        sql: `${condition.field} ${sqlOperator} ${parameter.sql}`,
+        params: parameter.params,
+      };
+    }
+    case "in":
+    case "not_in": {
+      if (!Array.isArray(condition.value)) {
+        throw new InvalidD1PredicateError();
+      }
+      if (condition.value.length === 0) {
+        return { sql: operator === "not_in" ? "1 = 1" : "1 = 0", params: [] };
+      }
+      return {
+        sql: `${condition.field} ${operator === "not_in" ? "NOT " : ""}IN (SELECT value FROM json_each(?))`,
+        params: [encodeD1Value(condition.value)],
+      };
+    }
+    case "contains":
+    case "starts_with":
+    case "ends_with":
+      return stringPredicate(condition, operator);
+  }
+};
+
+export const buildD1Where = (
+  where: readonly D1Predicate[] | undefined,
+): D1Query => {
+  const [first, ...rest] = where ?? [];
+  if (first === undefined) return { sql: "", params: [] };
+  const initial = predicate(first);
+  let sql = initial.sql;
+  const params = [...initial.params];
+  for (const condition of rest) {
+    const next = predicate(condition);
+    sql = `(${sql} ${condition.connector === "OR" ? "OR" : "AND"} ${next.sql})`;
+    params.push(...next.params);
+  }
+  return { sql: ` WHERE ${sql}`, params };
+};
+
+export const buildD1Order = (orderBy: readonly D1Sort[] | undefined): string =>
+  orderBy === undefined
+    ? ""
+    : ` ORDER BY ${orderBy
+        .map(
+          (clause) =>
+            `${clause.field} ${clause.direction.toUpperCase()}${
+              clause.nulls ? ` NULLS ${clause.nulls.toUpperCase()}` : ""
+            }`,
+        )
+        .join(", ")}`;
+
+export const d1Placeholders = (count: number): string =>
+  Array.from({ length: count }, () => "json_extract(?, '$')").join(", ");
+
+export const encodeD1Values = (values: readonly unknown[]): readonly string[] =>
+  values.map(encodeD1Value);

package/src/r2S3Storage.ts

@@ -1,6 +1,3 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-
 import {
   DeleteObjectCommand,
   GetObjectCommand,
@@ -9,189 +6,148 @@ import {
   type S3ClientConfig,
 } from "@aws-sdk/client-s3";
 import { Upload } from "@aws-sdk/lib-storage";
-import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
 import {
   createStorageKeyBuilder,
-  getContentType,
-  type NodeStorageProfile,
+  createStorageDownloadUrl,
+  createStoragePlugin,
+  createStorageUri,
   parseStorageUri,
-  type RuntimeStorageProfile,
+  type StoragePluginWith,
 } from "@hot-updater/plugin-core";
 
 export interface R2S3StorageConfig extends S3ClientConfig {
   accountId: string;
   bucketName: string;
   credentials: NonNullable<S3ClientConfig["credentials"]>;
-  /**
-   * Base path where bundles will be stored in the bucket
-   */
+  /** Base path where bundles will be stored in the bucket. */
   basePath?: string;
+  /** Required when this storage serves downloads through createHotUpdater. */
+  downloadUrlSigningKey?: string;
 }
 
-const ensureExpectedR2Bucket = (bucket: string, bucketName: string) => {
-  if (bucket !== bucketName) {
-    throw new Error(
-      `Bucket name mismatch: expected "${bucketName}", but found "${bucket}".`,
-    );
-  }
-};
-
-const isS3ObjectNotFoundError = (error: unknown) => {
-  if (error instanceof Error) {
-    return error.name === "NotFound" || error.name === "NoSuchKey";
+const isObjectNotFoundError = (error: unknown) => {
+  if (
+    error instanceof Error &&
+    (error.name === "NotFound" || error.name === "NoSuchKey")
+  ) {
+    return true;
   }
-
-  if (typeof error === "object" && error !== null && "$metadata" in error) {
-    return (
-      (error as { $metadata?: { httpStatusCode?: number } }).$metadata
-        ?.httpStatusCode === 404
-    );
-  }
-
-  return false;
+  return (
+    typeof error === "object" &&
+    error !== null &&
+    "$metadata" in error &&
+    (error as { $metadata?: { httpStatusCode?: number } }).$metadata
+      ?.httpStatusCode === 404
+  );
 };
 
-const createS3Client = (config: R2S3StorageConfig) => {
+export const createR2S3Storage = (
+  config: R2S3StorageConfig,
+): StoragePluginWith<"put" | "get" | "exists" | "delete"> => {
   const {
     accountId,
-    basePath: _basePath,
-    bucketName: _bucketName,
+    basePath,
+    bucketName,
+    downloadUrlSigningKey,
     endpoint,
     forcePathStyle,
     region,
     ...s3Config
   } = config;
-
-  return new S3Client({
+  const client = new S3Client({
     ...s3Config,
     endpoint: endpoint ?? `https://${accountId}.r2.cloudflarestorage.com`,
     forcePathStyle: forcePathStyle ?? true,
     region: region ?? "auto",
   });
-};
-
-export const createS3StorageProfile = (
-  config: R2S3StorageConfig,
-): NodeStorageProfile => {
-  const { bucketName } = config;
-  const client = createS3Client(config);
-  const getStorageKey = createStorageKeyBuilder(config.basePath);
-
-  return {
-    async delete(storageUri) {
-      const { bucket, key } = parseStorageUri(storageUri, "r2");
-      ensureExpectedR2Bucket(bucket, bucketName);
-
-      await client.send(
-        new DeleteObjectCommand({ Bucket: bucketName, Key: key }),
+  const getStorageKey = createStorageKeyBuilder(basePath);
+  const getDownloadUrl = downloadUrlSigningKey
+    ? createStorageDownloadUrl(downloadUrlSigningKey)
+    : undefined;
+
+  const parseAndValidate = (storageUri: string) => {
+    const parsed = parseStorageUri(storageUri, "r2");
+    if (parsed.bucket !== bucketName) {
+      throw new Error(
+        `Bucket name mismatch: expected "${bucketName}", but found "${parsed.bucket}".`,
       );
-    },
-    async upload(key, filePath) {
-      const Body = await fs.readFile(filePath);
-      const ContentType = getContentType(filePath);
-      const filename = path.basename(filePath);
-      const Key = getStorageKey(key, filename);
+    }
+    return parsed;
+  };
 
-      const upload = new Upload({
+  return createStoragePlugin({
+    name: "r2Storage",
+    protocol: "r2",
+    async put({ key, body, contentLength, contentType }) {
+      const storageKey = getStorageKey(key);
+      await new Upload({
         client,
         params: {
-          Body,
+          Body: body,
           Bucket: bucketName,
           CacheControl: "max-age=31536000",
-          ContentType,
-          Key,
+          ContentLength: contentLength,
+          ContentType: contentType,
+          Key: storageKey,
         },
-      });
-      await upload.done();
-
+      }).done();
       return {
-        storageUri: `r2://${bucketName}/${Key}`,
+        storageUri: createStorageUri({
+          protocol: "r2",
+          bucket: bucketName,
+          key: storageKey,
+        }),
       };
     },
-    async exists(storageUri: string) {
-      const { bucket, key } = parseStorageUri(storageUri, "r2");
-      ensureExpectedR2Bucket(bucket, bucketName);
-
+    async get({ storageUri }) {
+      const { key } = parseAndValidate(storageUri);
       try {
-        await client.send(
-          new HeadObjectCommand({ Bucket: bucketName, Key: key }),
+        const response = await client.send(
+          new GetObjectCommand({ Bucket: bucketName, Key: key }),
         );
-        return true;
-      } catch (error) {
-        if (isS3ObjectNotFoundError(error)) {
-          return false;
+        if (!response.Body) return { response: null };
+        const headers = new Headers();
+        if (response.ContentType)
+          headers.set("content-type", response.ContentType);
+        if (response.ContentLength !== undefined) {
+          headers.set("content-length", String(response.ContentLength));
         }
-
+        return {
+          response: new Response(response.Body.transformToWebStream(), {
+            headers,
+          }),
+        };
+      } catch (error) {
+        if (isObjectNotFoundError(error)) return { response: null };
         throw error;
       }
     },
-    async downloadFile(storageUri, filePath) {
-      const { bucket, key } = parseStorageUri(storageUri, "r2");
-      ensureExpectedR2Bucket(bucket, bucketName);
-
-      const response = await client.send(
-        new GetObjectCommand({ Bucket: bucketName, Key: key }),
-      );
-
-      if (!response.Body) {
-        throw new Error("R2 object body is empty");
-      }
-
-      await fs.mkdir(path.dirname(filePath), { recursive: true });
-      await fs.writeFile(filePath, await response.Body.transformToByteArray());
-    },
-  };
-};
-
-export const createS3RuntimeStorageProfile = (
-  config: R2S3StorageConfig,
-): RuntimeStorageProfile => {
-  const { bucketName } = config;
-  const client = createS3Client(config);
-
-  return {
-    async readText(storageUri) {
-      const { bucket, key } = parseStorageUri(storageUri, "r2");
-      ensureExpectedR2Bucket(bucket, bucketName);
-
+    ...(getDownloadUrl
+      ? {
+          async getDownloadUrl({ storageUri }: { storageUri: string }) {
+            parseAndValidate(storageUri);
+            return getDownloadUrl({ storageUri });
+          },
+        }
+      : {}),
+    async exists({ storageUri }) {
+      const { key } = parseAndValidate(storageUri);
       try {
-        const response = await client.send(
-          new GetObjectCommand({ Bucket: bucketName, Key: key }),
+        await client.send(
+          new HeadObjectCommand({ Bucket: bucketName, Key: key }),
         );
-
-        if (!response.Body) {
-          return null;
-        }
-
-        return response.Body.transformToString();
+        return { exists: true };
       } catch (error) {
-        if (isS3ObjectNotFoundError(error)) {
-          return null;
-        }
-
+        if (isObjectNotFoundError(error)) return { exists: false };
         throw error;
       }
     },
-    async getDownloadUrl(storageUri) {
-      const { bucket, key } = parseStorageUri(storageUri, "r2");
-      ensureExpectedR2Bucket(bucket, bucketName);
-
-      const command = new GetObjectCommand({ Bucket: bucketName, Key: key });
-      const signedUrl = await getSignedUrl(
-        client as unknown as Parameters<typeof getSignedUrl>[0],
-        command,
-        {
-          expiresIn: 3600,
-        },
+    async delete({ storageUri }) {
+      const { key } = parseAndValidate(storageUri);
+      await client.send(
+        new DeleteObjectCommand({ Bucket: bucketName, Key: key }),
       );
-
-      if (!signedUrl) {
-        throw new Error("Failed to presign R2 URL");
-      }
-
-      return {
-        fileUrl: signedUrl,
-      };
+      return { deleted: true };
     },
-  };
+  });
 };