@hot-updater/cloudflare 1.0.0-rc.18 → 1.0.0-rc.21

package/src/d1Database.spec.ts

@@ -1,190 +0,0 @@
-import type { DeployReleasePolicy } from "@hot-updater/plugin-core";
-import { createHotUpdater } from "@hot-updater/server";
-import { DatabaseConstraintError } from "@hot-updater/server/database";
-import {
-  createDatabaseCoreApi,
-  createMigrator,
-  generateSchema,
-} from "@hot-updater/server/db";
-import { definePlugin, defineTable } from "@hot-updater/server/plugins";
-import { beforeEach, expect, it, vi } from "vitest";
-
-import { createBundleFixture } from "../../../packages/test-utils/src/databaseTestFixtures";
-import { d1Database } from "./d1Database";
-import { createD1TestDatabase } from "./d1TestDatabase";
-
-type Body = {
-  readonly sql?: string;
-  readonly params?: readonly string[];
-  readonly batch?: readonly { sql: string; params: readonly string[] }[];
-};
-
-const state = vi.hoisted(() => ({
-  database: undefined as ReturnType<typeof createD1TestDatabase> | undefined,
-  bodies: [] as Body[],
-}));
-
-/** The REST API over `node:sqlite`, recording each request body. */
-vi.mock("cloudflare", () => ({
-  default: class MockCloudflare {
-    readonly d1 = {
-      database: {
-        query: async (_databaseId: string, body: Body) => {
-          state.bodies.push(body);
-          const result = state.database!.batch(
-            body.batch ?? [{ sql: body.sql!, params: body.params ?? [] }],
-          );
-          return {
-            async *iterPages() {
-              yield { result };
-            },
-          };
-        },
-      },
-    };
-  },
-}));
-
-const config = {
-  accountId: "account-id",
-  cloudflareApiToken: "api-token",
-  databaseId: "database-id",
-};
-
-/** Core's API over the REST database, as the CLI and console run it. */
-const core = () => createDatabaseCoreApi(d1Database(config));
-
-/** A plugin with one table. */
-const notes = definePlugin({
-  id: "notes",
-  schemaVersion: "1",
-  schema: {
-    notes: defineTable(
-      { id: { type: "string" }, text: { type: "string" } },
-      { key: ["id"] },
-    ),
-  },
-  init: ({ db }) => ({
-    api: {
-      add: (id: string, text: string) =>
-        db.transaction(async (tx) => {
-          tx.create("notes", { id, text });
-        }),
-      read: (id: string) => db.findOne("notes", { id }),
-    },
-  }),
-});
-
-const server = () =>
-  createHotUpdater({
-    database: d1Database(config),
-    plugins: [notes],
-    clientAccess: "public",
-  });
-
-const release: DeployReleasePolicy = {
-  channel: "production",
-  enabled: true,
-  fingerprintHash: null,
-  message: null,
-  shouldForceUpdate: false,
-  targetAppVersion: "1.0.0",
-};
-
-beforeEach(() => {
-  state.database = createD1TestDatabase();
-  state.bodies = [];
-});
-
-it("binds every value as JSON text and reads it back with json_extract", async () => {
-  const channel = await core().ensureChannel("production");
-  await expect(core().listChannels()).resolves.toEqual([channel]);
-  const statements = state.bodies.flatMap(
-    (body) => body.batch ?? [{ sql: body.sql!, params: body.params ?? [] }],
-  );
-  for (const { sql, params } of statements) {
-    expect(sql.match(/\?/gu)?.length ?? 0).toBe(
-      sql.match(/json_extract\(\?, '\$'\)/gu)?.length ?? 0,
-    );
-    for (const param of params) expect(() => JSON.parse(param)).not.toThrow();
-  }
-});
-
-it("sends a write as one batch: the guard row, each guard, the changes, then the failure", async () => {
-  await core().ensureChannel("production");
-  state.bodies = [];
-  const [deployed] = await core().deploy([
-    { bundle: createBundleFixture("1"), release },
-  ]);
-  const writes = state.bodies.filter((body) => body.batch !== undefined);
-  expect(writes).toHaveLength(1);
-  const sql = writes[0]!.batch!.map((statement) => statement.sql);
-  expect(sql[0]).toMatch(/^INSERT INTO "_hu_write"/u);
-  expect(sql.at(-2)).toMatch(/^SELECT "failed_op" FROM "_hu_write"/u);
-  expect(sql.at(-1)).toMatch(/^DELETE FROM "_hu_write"/u);
-  await expect(core().getRelease(deployed!.release!.id)).resolves.toEqual(
-    deployed!.release,
-  );
-});
-
-it("applies nothing when a guard fails", async () => {
-  const bundle = createBundleFixture("2");
-  // The patch's base bundle does not exist, so the guard on its row fails.
-  await expect(
-    core().deploy([
-      {
-        bundle: {
-          ...bundle,
-          patches: [
-            {
-              baseBundleId: createBundleFixture("1").id,
-              baseFileHash: "base-hash",
-              byteSize: 1,
-              patchFileHash: "patch-hash",
-              patchStorageUri: "storage://patches/2.patch",
-            },
-          ],
-        },
-        release,
-      },
-    ]),
-  ).rejects.toBeInstanceOf(DatabaseConstraintError);
-  await expect(core().getBundle(bundle.id)).resolves.toBeNull();
-  await expect(
-    core().listReleases({ limit: 10, filter: { kind: "all" } }),
-  ).resolves.toEqual([]);
-});
-
-it("generates a wrangler migration with a server's plugin tables", async () => {
-  const hotUpdater = server();
-  const migration = generateSchema(hotUpdater, "latest");
-  expect(migration.path).toMatch(/^migrations\/\d{14}_hot-updater\.sql$/u);
-  await expect(hotUpdater.api.notes.read("n1")).rejects.toThrow(
-    '"schema.notes" for d1Database is missing',
-  );
-
-  state.database!.db.exec(migration.code);
-  await hotUpdater.api.notes.add("n1", "hello");
-  await expect(hotUpdater.api.notes.read("n1")).resolves.toEqual({
-    id: "n1",
-    text: "hello",
-  });
-});
-
-it("migrates an empty database's tables, write guard included, through the API", async () => {
-  state.database = createD1TestDatabase([]);
-  const hotUpdater = server();
-  const result = await createMigrator(hotUpdater).migrateToLatest({
-    mode: "from-schema",
-    updateSettings: true,
-  });
-  await result.execute();
-
-  await hotUpdater.api.notes.add("n1", "hello");
-  const [deployed] = await hotUpdater.core.deploy([
-    { bundle: createBundleFixture("1"), release },
-  ]);
-  await expect(
-    hotUpdater.core.getRelease(deployed!.release!.id),
-  ).resolves.toEqual(deployed!.release);
-});

package/src/d1Schema.spec.ts

@@ -1,89 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { DatabaseSync, type SqliteValue } from "node:sqlite";
-
-import { toolingTargetOf } from "@hot-updater/server/database";
-import {
-  createDatabaseCoreApi,
-  HotUpdaterSchemaMigrationRequiredError,
-} from "@hot-updater/server/db";
-import { describe, expect, it } from "vitest";
-
-import { createBundleFixture } from "../../../packages/test-utils/src/databaseTestFixtures";
-import { createD1Database } from "./d1Executor";
-import { d1SchemaSql, d1SchemaStatements } from "./d1Schema";
-import { plugins } from "./plugins";
-
-/** The managed Worker's migration: core's tables and its plugins'. */
-const managedSql = () => d1SchemaSql(toolingTargetOf(plugins));
-
-const FILES = [
-  "plugins/cloudflare/sql/bundles.sql",
-  "plugins/cloudflare/worker/migrations/0001_hot-updater_1.0.0.sql",
-].map((file) => path.resolve(file));
-
-/** D1's API over `node:sqlite`: statements one at a time, batches in one transaction. */
-const sqliteD1 = (db: DatabaseSync) => {
-  const run = (sql: string, params: readonly unknown[]) => {
-    const statement = db.prepare(sql);
-    const values = params as SqliteValue[];
-    return statement.columns().length > 0
-      ? { rows: statement.all(...values), changes: 0 }
-      : { rows: [], changes: Number(statement.run(...values).changes) };
-  };
-  return createD1Database({
-    query: async ({ sql, params }) => run(sql, params),
-    batch: async (batch) => {
-      db.exec("BEGIN IMMEDIATE");
-      try {
-        const results = batch.map(({ sql, params }) => run(sql, params));
-        db.exec("COMMIT");
-        return results;
-      } catch (error) {
-        db.exec("ROLLBACK");
-        throw error;
-      }
-    },
-  });
-};
-
-describe("d1 schema", () => {
-  it("checks in exactly the generated schema as the SQL file and the first migration", async () => {
-    if (process.env.HOT_UPDATER_UPDATE_SQL === "1") {
-      for (const file of FILES) await fs.writeFile(file, managedSql());
-    }
-    // Regenerate with HOT_UPDATER_UPDATE_SQL=1 after the schema changes.
-    for (const file of FILES) {
-      expect(await fs.readFile(file, "utf8")).toBe(managedSql());
-    }
-  });
-
-  it("serves once the schema is applied, writing each change as one batch", async () => {
-    const db = new DatabaseSync(":memory:");
-    const core = createDatabaseCoreApi(sqliteD1(db));
-    await expect(core.listChannels()).rejects.toBeInstanceOf(
-      HotUpdaterSchemaMigrationRequiredError,
-    );
-    for (const statement of d1SchemaStatements()) db.exec(statement);
-    const [deployed] = await core.deploy([
-      {
-        bundle: createBundleFixture("1"),
-        release: {
-          channel: "production",
-          enabled: true,
-          fingerprintHash: null,
-          message: null,
-          shouldForceUpdate: false,
-          targetAppVersion: "1.0.0",
-        },
-      },
-    ]);
-    await expect(core.getRelease(deployed!.release!.id)).resolves.toEqual(
-      deployed!.release,
-    );
-    expect(db.prepare("SELECT COUNT(*) AS n FROM _hu_write").all()).toEqual([
-      { n: 0 },
-    ]);
-    db.close();
-  });
-});

package/src/d1TestDatabase.ts

@@ -1,38 +0,0 @@
-import { DatabaseSync, type SqliteValue } from "node:sqlite";
-
-import type { D1ResultLike } from "./d1Executor";
-import { d1SchemaStatements } from "./d1Schema";
-
-/** A D1 database over `node:sqlite`, answering as D1 does; migrated unless given other statements. */
-export const createD1TestDatabase = (
-  statements: readonly string[] = d1SchemaStatements(),
-) => {
-  const db = new DatabaseSync(":memory:");
-  for (const sql of statements) db.exec(sql);
-  const run = (sql: string, params: readonly unknown[]): D1ResultLike => {
-    const statement = db.prepare(sql);
-    const values = params as SqliteValue[];
-    return statement.columns().length > 0
-      ? { success: true, results: statement.all(...values), meta: {} }
-      : {
-          success: true,
-          results: [],
-          meta: { changes: Number(statement.run(...values).changes) },
-        };
-  };
-  /** Runs statements atomically, as `batch` does. */
-  const batch = (
-    statements: readonly { sql: string; params: readonly unknown[] }[],
-  ) => {
-    db.exec("BEGIN IMMEDIATE");
-    try {
-      const results = statements.map(({ sql, params }) => run(sql, params));
-      db.exec("COMMIT");
-      return results;
-    } catch (error) {
-      db.exec("ROLLBACK");
-      throw error;
-    }
-  };
-  return { db, run, batch };
-};

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".',
-    );
-  });
-});