@hot-updater/cloudflare 1.0.0-rc.5 → 1.0.0

package/src/d1Sql.ts

@@ -1,175 +0,0 @@
-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/r2Storage.spec.ts

@@ -1,346 +0,0 @@
-import { Buffer } from "buffer";
-
-import {
-  DeleteObjectCommand,
-  GetObjectCommand,
-  HeadObjectCommand,
-  S3Client,
-} from "@aws-sdk/client-s3";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-import { r2Storage } from "./r2Storage";
-
-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: ReadableStream<Uint8Array>;
-      Bucket: string;
-      CacheControl?: string;
-      ContentLength?: number;
-      ContentType?: string;
-      Key: string;
-    };
-
-    constructor({
-      params,
-    }: {
-      params: {
-        Body: ReadableStream<Uint8Array>;
-        Bucket: string;
-        CacheControl?: string;
-        ContentLength?: number;
-        ContentType?: string;
-        Key: string;
-      };
-    }) {
-      this.params = params;
-      uploadedParams = params;
-    }
-
-    async done() {
-      fakeStore[this.params.Key] = Buffer.from(
-        await new Response(this.params.Body).arrayBuffer(),
-      );
-      return {
-        Bucket: this.params.Bucket,
-        Key: this.params.Key,
-      };
-    }
-  },
-}));
-
-describe("r2Storage", () => {
-  beforeEach(() => {
-    fakeStore = {};
-    deletedKeys = [];
-    uploadedParams = undefined;
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  const mockS3Client = () => {
-    return vi
-      .spyOn(S3Client.prototype, "send")
-      .mockImplementation(async (command: any) => {
-        if (command instanceof HeadObjectCommand) {
-          const key = command.input.Key!;
-          if (fakeStore[key]) {
-            return {};
-          }
-
-          const error = new Error("Not found");
-          error.name = "NotFound";
-          throw error;
-        }
-
-        if (command instanceof GetObjectCommand) {
-          const key = command.input.Key!;
-          const object = fakeStore[key];
-          if (!object) {
-            const error = new Error("No such key");
-            error.name = "NoSuchKey";
-            throw error;
-          }
-
-          return {
-            Body: {
-              transformToByteArray: async () => new Uint8Array(object),
-              transformToString: async () => object.toString("utf8"),
-              transformToWebStream: () => new Response(object).body!,
-            },
-          };
-        }
-
-        if (command instanceof DeleteObjectCommand) {
-          deletedKeys.push(command.input.Key!);
-          delete fakeStore[command.input.Key!];
-          return {};
-        }
-
-        throw new Error("Unsupported command");
-      });
-  };
-
-  it("uploads R2 objects through the S3 API when credentials are provided", async () => {
-    mockS3Client();
-
-    const storage = r2Storage({
-      accountId: "account-id",
-      bucketName: "test-bucket",
-      credentials: {
-        accessKeyId: "access-key-id",
-        secretAccessKey: "secret-access-key",
-      },
-    });
-
-    await expect(
-      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"].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 () => {
-    mockS3Client();
-    fakeStore["releases/bundle-1/manifest.json"] = Buffer.from(
-      JSON.stringify({
-        assets: {},
-        bundleId: "bundle-1",
-      }),
-    );
-
-    const storage = r2Storage({
-      accountId: "account-id",
-      bucketName: "test-bucket",
-      credentials: {
-        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(JSON.parse((await response?.text()) ?? "")).toEqual({
-      assets: {},
-      bundleId: "bundle-1",
-    });
-  });
-
-  it("checks R2 object existence through the S3 API", async () => {
-    mockS3Client();
-    fakeStore["releases/logo.png"] = Buffer.from("logo");
-
-    const storage = r2Storage({
-      accountId: "account-id",
-      bucketName: "test-bucket",
-      credentials: {
-        accessKeyId: "access-key-id",
-        secretAccessKey: "secret-access-key",
-      },
-    });
-
-    await expect(
-      storage.exists?.({ storageUri: "r2://test-bucket/releases/logo.png" }),
-    ).resolves.toEqual({ exists: true });
-    await expect(
-      storage.exists?.({ storageUri: "r2://test-bucket/releases/missing.png" }),
-    ).resolves.toEqual({ exists: false });
-  });
-
-  it("deletes R2 objects through the S3 API", async () => {
-    mockS3Client();
-    fakeStore["releases/logo.png"] = Buffer.from("logo");
-
-    const storage = r2Storage({
-      accountId: "account-id",
-      bucketName: "test-bucket",
-      credentials: {
-        accessKeyId: "access-key-id",
-        secretAccessKey: "secret-access-key",
-      },
-    });
-
-    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();
-  });
-
-  it("reads R2 text through the runtime S3 API when credentials are provided", async () => {
-    mockS3Client();
-    fakeStore["releases/bundle-1/manifest.json"] = Buffer.from(
-      JSON.stringify({
-        assets: {},
-        bundleId: "bundle-1",
-      }),
-    );
-
-    const storage = r2Storage({
-      accountId: "account-id",
-      bucketName: "test-bucket",
-      credentials: {
-        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.get?.({
-        storageUri: "r2://test-bucket/releases/missing.json",
-      }),
-    ).resolves.toEqual({ response: null });
-  });
-
-  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",
-      credentials: {
-        accessKeyId: "access-key-id",
-        secretAccessKey: "secret-access-key",
-      },
-    });
-
-    expect(Reflect.has(storage, "getDownloadUrl")).toBe(false);
-  });
-
-  it("adds a signed download URL operation when configured for a server", async () => {
-    mockS3Client();
-    const storage = r2Storage({
-      accountId: "account-id",
-      bucketName: "test-bucket",
-      credentials: {
-        accessKeyId: "access-key-id",
-        secretAccessKey: "secret-access-key",
-      },
-      downloadUrlSigningKey: "test-signing-key",
-    });
-
-    await expect(
-      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",
-      credentials: {
-        accessKeyId: "access-key-id",
-        secretAccessKey: "secret-access-key",
-      },
-    });
-
-    await expect(
-      storage.get?.({
-        storageUri: "r2://other-bucket/releases/bundle-1/manifest.json",
-      }),
-    ).rejects.toThrow(
-      'Bucket name mismatch: expected "test-bucket", but found "other-bucket".',
-    );
-  });
-});

package/src/r2WorkerStorage.spec.ts

@@ -1,184 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-import { r2WorkerStorage } from "./r2WorkerStorage";
-
-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", () => {
-  afterEach(() => {
-    vi.unstubAllGlobals();
-  });
-
-  it("reads bytes from the R2 binding captured by the implementation", async () => {
-    const get = vi.fn(async (key: string) => ({
-      body: new Response(`text:${key}`).body,
-      httpEtag: '"etag"',
-      size: `text:${key}`.length,
-      writeHttpMetadata: vi.fn(),
-    }));
-    const storage = r2WorkerStorage({
-      bucket: createBucket(get),
-      bucketName: "bundles",
-      downloadUrlSigningKey: "test-signing-key",
-    });
-
-    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("rejects URIs owned by a different R2 binding", async () => {
-    const get = vi.fn();
-    const storage = r2WorkerStorage({
-      bucket: createBucket(get),
-      bucketName: "bundles",
-      downloadUrlSigningKey: "test-signing-key",
-    });
-
-    await expect(
-      storage.get({ storageUri: "r2://other/app/manifest.json" }),
-    ).rejects.toThrow(
-      'Bucket name mismatch: expected "bundles", but found "other".',
-    );
-    expect(get).not.toHaveBeenCalled();
-  });
-
-  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({
-      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.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",
-        },
-      },
-    );
-    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\//);
-  });
-});