@hot-updater/server 1.0.0-rc.1 → 1.0.0-rc.16

package/src/calculatePagination.ts

@@ -1,34 +0,0 @@
-import type { PaginationInfo, PaginationOptions } from "./types";
-
-/**
- * Calculate pagination information based on total count, limit, and offset
- */
-export function calculatePagination(
-  total: number,
-  options: PaginationOptions,
-): PaginationInfo {
-  const { limit, offset } = options;
-
-  if (total === 0) {
-    return {
-      total: 0,
-      hasNextPage: false,
-      hasPreviousPage: false,
-      currentPage: 1,
-      totalPages: 0,
-    };
-  }
-
-  const currentPage = Math.floor(offset / limit) + 1;
-  const totalPages = Math.ceil(total / limit);
-  const hasNextPage = offset + limit < total;
-  const hasPreviousPage = offset > 0;
-
-  return {
-    total,
-    hasNextPage,
-    hasPreviousPage,
-    currentPage,
-    totalPages,
-  };
-}

package/src/db/databasePluginCore.spec.ts

@@ -1,62 +0,0 @@
-import { type DatabasePlugin } from "@hot-updater/plugin-core";
-import { describe, expect, it, vi } from "vitest";
-
-import { createInMemoryDatabasePlugin } from "../../../test-utils/test/inMemoryDatabasePlugin";
-import { createDatabasePluginCore } from "./databasePluginCore";
-import {
-  currentBundle,
-  resolveFileUrl,
-} from "./databasePluginCore.testFixtures";
-
-describe("createDatabasePluginCore", () => {
-  it("runs the schema readiness guard before a low plugin operation", async () => {
-    const plugin: DatabasePlugin = createInMemoryDatabasePlugin();
-    const beforeOperation = vi.fn(async () => {});
-    const core = createDatabasePluginCore(plugin, resolveFileUrl, {
-      beforeOperation,
-    });
-
-    await core.api.getChannels();
-
-    expect(beforeOperation).toHaveBeenCalledOnce();
-  });
-
-  it("inserts an artifact without synthesizing a Release", async () => {
-    const plugin: DatabasePlugin = createInMemoryDatabasePlugin();
-    const core = createDatabasePluginCore(plugin, resolveFileUrl);
-
-    await core.api.insertBundle(currentBundle);
-
-    await expect(
-      core.api.getBundleById(currentBundle.id),
-    ).resolves.toMatchObject(currentBundle);
-    await expect(
-      plugin.models.releases.findMany({
-        bundleId: currentBundle.id,
-        limit: 10,
-      }),
-    ).resolves.toEqual([]);
-  });
-
-  it("updates an artifact without requiring or mutating a Release", async () => {
-    const plugin: DatabasePlugin = createInMemoryDatabasePlugin();
-    const core = createDatabasePluginCore(plugin, resolveFileUrl);
-    await core.api.insertBundle(currentBundle);
-    await core.api.updateBundleById(currentBundle.id, {
-      storageUri: `r2://bucket/bundles/${currentBundle.id}/updated.zip`,
-    });
-
-    await expect(
-      core.api.getBundleById(currentBundle.id),
-    ).resolves.toMatchObject({
-      id: currentBundle.id,
-      storageUri: `r2://bucket/bundles/${currentBundle.id}/updated.zip`,
-    });
-    await expect(
-      plugin.models.releases.findMany({
-        bundleId: currentBundle.id,
-        limit: 10,
-      }),
-    ).resolves.toEqual([]);
-  });
-});

package/src/db/databasePluginCore.testFixtures.ts

@@ -1,76 +0,0 @@
-import type { Bundle } from "@hot-updater/core";
-import {
-  createDatabaseClient,
-  type DatabasePlugin,
-} from "@hot-updater/plugin-core";
-
-export const currentBundle: Bundle = {
-  id: "00000000-0000-0000-0000-000000000001",
-  fileHash: "current-archive-hash",
-  gitCommitHash: null,
-  platform: "ios",
-  storageUri:
-    "r2://bucket/bundles/00000000-0000-0000-0000-000000000001/archive.zip",
-  archiveByteSize: 3_000_000_001,
-  manifestStorageUri:
-    "r2://bucket/bundles/00000000-0000-0000-0000-000000000001/manifest.json",
-  manifestFileHash: "sig:current-manifest",
-  assetBaseStorageUri: "r2://bucket/assets",
-};
-
-export const targetBundle: Bundle = {
-  ...currentBundle,
-  id: "00000000-0000-0000-0000-000000000002",
-  fileHash: "target-archive-hash",
-  storageUri:
-    "r2://bucket/bundles/00000000-0000-0000-0000-000000000002/archive.zip",
-  manifestStorageUri:
-    "r2://bucket/bundles/00000000-0000-0000-0000-000000000002/manifest.json",
-  manifestFileHash: "sig:target-manifest",
-  assetBaseStorageUri: "r2://bucket/assets",
-  patches: [
-    {
-      baseBundleId: currentBundle.id,
-      baseFileHash: "current-bundle-hash",
-      patchFileHash: "patch-hash",
-      patchStorageUri:
-        "r2://bucket/bundles/00000000-0000-0000-0000-000000000002/patches/00000000-0000-0000-0000-000000000001/index.ios.bundle.bsdiff",
-      byteSize: 3_000_000_002,
-    },
-  ],
-};
-
-export const resolveFileUrl = async (storageUri: string | null) => {
-  if (!storageUri) return null;
-  const url = new URL(storageUri);
-  return `https://assets.example.com/${url.host}${url.pathname}`;
-};
-
-export const seedBundles = async (plugin: DatabasePlugin): Promise<void> => {
-  const client = createDatabaseClient(plugin);
-  await client.insertBundle(currentBundle);
-  await client.insertBundle(targetBundle);
-};
-
-export const manifests = new Map<string, string>([
-  [
-    currentBundle.manifestStorageUri ?? "",
-    JSON.stringify({
-      bundleId: currentBundle.id,
-      assets: {
-        "index.ios.bundle": { fileHash: "current-bundle-hash" },
-        "shared.png": { fileHash: "shared-hash" },
-      },
-    }),
-  ],
-  [
-    targetBundle.manifestStorageUri ?? "",
-    JSON.stringify({
-      bundleId: targetBundle.id,
-      assets: {
-        "index.ios.bundle": { fileHash: "target-bundle-hash" },
-        "shared.png": { fileHash: "shared-hash" },
-      },
-    }),
-  ],
-]);

package/src/db/databasePluginCore.ts

@@ -1,185 +0,0 @@
-import type { Bundle } from "@hot-updater/core";
-import { decodeChannelKey } from "@hot-updater/core";
-import {
-  type ChannelRow,
-  createDatabaseClient,
-  deleteRelease as deleteReleasePolicy,
-  preflightReleasePolicy as preflightReleasePolicyMutation,
-  rebuildReleaseCatalog as rebuildReleaseCatalogProjection,
-  updateReleasePolicy as updateReleasePolicyMutation,
-} from "@hot-updater/plugin-core";
-
-import {
-  createArtifactResolver,
-  createReleaseCatalogReader,
-} from "./releaseCatalog";
-import type { DatabaseAPI, DatabasePlugin } from "./types";
-
-export function createDatabasePluginCore(
-  database: DatabasePlugin,
-  resolveFileUrl: (storageUri: string | null) => Promise<string | null>,
-  options?: {
-    beforeOperation?: () => Promise<void>;
-    readStorageText?: (storageUri: string) => Promise<string | null>;
-  },
-): {
-  api: DatabaseAPI;
-  adapterName: string;
-  createMigrator: () => never;
-  generateSchema: () => never;
-} {
-  const client = createDatabaseClient(database);
-  const beforeOperation = options?.beforeOperation;
-  const getReleaseCatalog = createReleaseCatalogReader(database);
-  const getArtifact = createArtifactResolver({
-    database,
-    readStorageText: options?.readStorageText,
-    resolveFileUrl,
-  });
-  const api: DatabaseAPI = {
-    async getBundleById(id: string): Promise<Bundle | null> {
-      await beforeOperation?.();
-      return client.getBundleById(id);
-    },
-
-    async getReleaseCatalog(input) {
-      await beforeOperation?.();
-      return getReleaseCatalog(input);
-    },
-
-    async getArtifactInfo(targetBundleId, currentBundleId) {
-      await beforeOperation?.();
-      return getArtifact(targetBundleId, currentBundleId);
-    },
-
-    async getReleaseById(id) {
-      await beforeOperation?.();
-      return database.models.releases.findById(id);
-    },
-
-    async getReleasesByScope(input) {
-      await beforeOperation?.();
-      return database.models.releases.findManyByScope({
-        ...input,
-        consistency: "strong",
-      });
-    },
-
-    async getReleases(input) {
-      await beforeOperation?.();
-      return database.models.releases.findMany(input);
-    },
-
-    async getReleaseCatalogByScopeKey(scopeKey) {
-      await beforeOperation?.();
-      return database.models.releaseCatalogs.findByScopeKey(scopeKey);
-    },
-
-    async getReleaseCatalogs(input) {
-      await beforeOperation?.();
-      return database.models.releaseCatalogs.findMany(input);
-    },
-
-    async updateReleasePolicy(input) {
-      await beforeOperation?.();
-      return updateReleasePolicyMutation({ database, ...input });
-    },
-
-    async preflightReleasePolicy(input) {
-      await beforeOperation?.();
-      return preflightReleasePolicyMutation({ database, ...input });
-    },
-
-    async deleteRelease(input) {
-      await beforeOperation?.();
-      return deleteReleasePolicy({ database, ...input });
-    },
-
-    async rebuildReleaseCatalog(scopeKey) {
-      await beforeOperation?.();
-      const catalog =
-        await database.models.releaseCatalogs.findByScopeKey(scopeKey);
-      if (catalog === null) {
-        throw new Error(`Release catalog "${scopeKey}" was not found.`);
-      }
-      return rebuildReleaseCatalogProjection({
-        database,
-        scope: {
-          channelId: catalog.channel_id,
-          channelName: decodeChannelKey(catalog.channel_key),
-          fingerprintHash: catalog.fingerprint_hash,
-          platform: catalog.platform,
-          scopeKey: catalog.scope_key,
-          strategy: catalog.strategy,
-        },
-      });
-    },
-
-    async commitDatabase(input) {
-      await beforeOperation?.();
-      return database.commit(input);
-    },
-
-    async getChannels(): Promise<readonly ChannelRow[]> {
-      await beforeOperation?.();
-      return client.getChannels();
-    },
-
-    async insertChannel(input) {
-      await beforeOperation?.();
-      return database.models.channels.insert(input);
-    },
-
-    async deleteChannel(input) {
-      await beforeOperation?.();
-      return database.models.channels.delete(input);
-    },
-
-    async getBundles(options) {
-      await beforeOperation?.();
-      return client.getBundles(options);
-    },
-
-    async insertBundle(bundle: Bundle): Promise<void> {
-      await beforeOperation?.();
-      await client.insertBundle(bundle);
-    },
-
-    async insertBundles(bundles: readonly Bundle[]): Promise<void> {
-      await beforeOperation?.();
-      await client.mutate(async (transaction) => {
-        for (const bundle of bundles) {
-          await transaction.insertBundle(bundle);
-        }
-      });
-    },
-
-    async updateBundleById(
-      bundleId: string,
-      update: Partial<Bundle>,
-    ): Promise<void> {
-      await beforeOperation?.();
-      await client.updateBundleById(bundleId, update);
-    },
-
-    async deleteBundleById(bundleId: string): Promise<void> {
-      await beforeOperation?.();
-      await client.deleteBundleById(bundleId);
-    },
-  };
-
-  return {
-    api,
-    adapterName: database.name,
-    createMigrator: () => {
-      throw new Error(
-        "createMigrator is only available for Kysely/MongoDB database plugins.",
-      );
-    },
-    generateSchema: () => {
-      throw new Error(
-        "generateSchema is only available for Drizzle/Prisma database plugins.",
-      );
-    },
-  };
-}

package/src/db/databasePluginUpdateCheck.bench.ts

@@ -1,107 +0,0 @@
-import {
-  createReleaseCatalogScopeKey,
-  encodeChannelKey,
-  RELEASE_CATALOG_FALLBACK_POLICY,
-  RELEASE_CATALOG_SCHEMA_VERSION,
-} from "@hot-updater/core";
-import {
-  createDatabasePlugin,
-  type CompiledReleaseCatalog,
-  type ReleaseCatalogRow,
-} from "@hot-updater/plugin-core";
-import { createDatabasePluginAdapter } from "@hot-updater/plugin-core/internal";
-import { bench, describe } from "vitest";
-
-import { createHotUpdater } from "../index";
-
-const CATALOG_ID = "bench";
-const CHANNEL_KEY = encodeChannelKey("production");
-const SCOPE_KEY = createReleaseCatalogScopeKey({
-  channelKey: CHANNEL_KEY,
-  platform: "ios",
-  strategy: "APP_VERSION",
-});
-const PAYLOAD = JSON.stringify({
-  fallbackPolicy: RELEASE_CATALOG_FALLBACK_POLICY,
-  releaseDescriptors: [],
-  schemaVersion: RELEASE_CATALOG_SCHEMA_VERSION,
-  segments: [],
-  strategy: "APP_VERSION",
-} satisfies CompiledReleaseCatalog);
-const CATALOG: ReleaseCatalogRow = {
-  catalog_id: CATALOG_ID,
-  byte_size: Buffer.byteLength(PAYLOAD),
-  catalog_hash: `sha256:${"0".repeat(64)}`,
-  channel_id: "channel-production",
-  channel_key: CHANNEL_KEY,
-  fingerprint_hash: null,
-  generation: 1,
-  is_tombstone: false,
-  payload: PAYLOAD,
-  platform: "ios",
-  scope_key: SCOPE_KEY,
-  strategy: "APP_VERSION",
-  updated_at_ms: 1,
-};
-
-class BenchmarkMutationError extends Error {
-  readonly name = "BenchmarkMutationError";
-
-  constructor() {
-    super("The Release Catalog benchmark plugin is read-only.");
-  }
-}
-
-const name = "release-catalog-benchmark";
-const adapter = createDatabasePluginAdapter(name, {
-  async count() {
-    return 0;
-  },
-  async create() {
-    throw new BenchmarkMutationError();
-  },
-  async delete() {
-    throw new BenchmarkMutationError();
-  },
-  async deleteChannel() {
-    throw new BenchmarkMutationError();
-  },
-  async findMany() {
-    return [];
-  },
-  async findOne(input) {
-    return input.model === "release_catalogs" ? CATALOG : null;
-  },
-  async insertChannel() {
-    throw new BenchmarkMutationError();
-  },
-  async update() {
-    throw new BenchmarkMutationError();
-  },
-});
-const database = createDatabasePlugin({
-  name,
-  commit: adapter.commit,
-  models: adapter.models,
-});
-const hotUpdater = createHotUpdater({
-  database,
-  clientAccess: { type: "public" },
-});
-const url =
-  `https://updates.example.com/release-catalogs/app-version/` +
-  `ios/${CHANNEL_KEY}/1.0.0`;
-
-describe("database plugin update check benchmark", () => {
-  bench(
-    "fixed-model plugin paged update check",
-    async () => {
-      const response = await hotUpdater.handlers.client(new Request(url));
-      if (response.status !== 200) {
-        throw new Error(`Expected 200 response, received ${response.status}.`);
-      }
-      await response.text();
-    },
-    { iterations: 20, warmupIterations: 5 },
-  );
-});

package/src/db/fixedMigrator.spec.ts

@@ -1,231 +0,0 @@
-import { DatabaseSync, type SqliteValue } from "node:sqlite";
-
-import { PGlite } from "@electric-sql/pglite";
-import { Kysely, SqliteDialect } from "kysely";
-import { PGliteDialect } from "kysely-pglite-dialect";
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-import { createInMemoryDatabasePlugin } from "../../../test-utils/test/inMemoryDatabasePlugin";
-import { createDatabasePluginCore } from "./databasePluginCore";
-import { createKyselyMigrator } from "./fixedMigrator";
-import { createSchemaReadinessChecker } from "./schemaReadiness";
-
-interface SettingsDatabase {
-  readonly private_hot_updater_settings: {
-    readonly key: string;
-    readonly value: string;
-  };
-}
-
-const createNodeSqliteKysely = (
-  database: DatabaseSync,
-): Kysely<SettingsDatabase> =>
-  new Kysely<SettingsDatabase>({
-    dialect: new SqliteDialect({
-      database: {
-        close: () => database.close(),
-        prepare: (sqlText) => {
-          const statement = database.prepare(sqlText);
-          return {
-            reader: statement.columns().length > 0,
-            all: (parameters) =>
-              statement.all(...(parameters as SqliteValue[])),
-            run: (parameters) => {
-              const result = statement.run(...(parameters as SqliteValue[]));
-              return {
-                changes: result.changes,
-                lastInsertRowid: result.lastInsertRowid,
-              };
-            },
-            iterate: (parameters) =>
-              statement.iterate(...(parameters as SqliteValue[])),
-          };
-        },
-      },
-    }),
-  });
-
-describe("Kysely migrator", () => {
-  const databases: PGlite[] = [];
-  const kyselyInstances: Kysely<SettingsDatabase>[] = [];
-
-  afterEach(async () => {
-    await Promise.all(kyselyInstances.splice(0).map((db) => db.destroy()));
-    await Promise.all(databases.splice(0).map((db) => db.close()));
-  });
-
-  it("creates schema 1.0.0 from an empty database", async () => {
-    const database = new PGlite();
-    databases.push(database);
-    const kysely = new Kysely<SettingsDatabase>({
-      dialect: new PGliteDialect(database),
-    });
-    kyselyInstances.push(kysely);
-    const migrator = createKyselyMigrator({
-      db: kysely,
-      provider: "postgresql",
-    });
-
-    await expect(migrator.getVersion()).resolves.toBeUndefined();
-    const result = await migrator.migrateToLatest({
-      mode: "from-schema",
-      updateSettings: true,
-    });
-    expect(result.operations.length).toBeGreaterThan(0);
-    await result.execute();
-
-    await expect(migrator.getVersion()).resolves.toBe("1.0.0");
-    const tables = await database.query<{ tablename: string }>(`
-      select tablename from pg_tables
-      where schemaname = 'public'
-      order by tablename
-    `);
-    expect(tables.rows.map(({ tablename }) => tablename)).toEqual(
-      expect.arrayContaining([
-        "bundles",
-        "bundle_patches",
-        "channels",
-        "releases",
-        "release_catalogs",
-        "bundle_events",
-        "api_keys",
-        "private_hot_updater_settings",
-      ]),
-    );
-  });
-
-  it("is a no-op when schema.core is already 1.0.0", async () => {
-    const database = new PGlite();
-    databases.push(database);
-    const kysely = new Kysely<SettingsDatabase>({
-      dialect: new PGliteDialect(database),
-    });
-    kyselyInstances.push(kysely);
-    const migrator = createKyselyMigrator({
-      db: kysely,
-      provider: "postgresql",
-    });
-    await (
-      await migrator.migrateToLatest({
-        mode: "from-schema",
-        updateSettings: true,
-      })
-    ).execute();
-
-    const result = await migrator.migrateToLatest({ mode: "from-schema" });
-    expect(result.operations).toEqual([]);
-    expect(result.getSQL?.()).toBe("");
-  });
-
-  it("ignores a leftover version marker when schema.core is 1.0.0", async () => {
-    const database = new PGlite();
-    databases.push(database);
-    const kysely = new Kysely<SettingsDatabase>({
-      dialect: new PGliteDialect(database),
-    });
-    kyselyInstances.push(kysely);
-    const migrator = createKyselyMigrator({
-      db: kysely,
-      provider: "postgresql",
-    });
-    await (
-      await migrator.migrateToLatest({
-        mode: "from-schema",
-        updateSettings: true,
-      })
-    ).execute();
-    await database.exec(`
-      insert into private_hot_updater_settings (key, value)
-      values ('version', '0.36.0')
-      on conflict (key) do update set value = excluded.value
-    `);
-
-    await expect(migrator.getVersion()).resolves.toBe("1.0.0");
-    await expect(
-      migrator.migrateToLatest({ mode: "from-schema" }),
-    ).resolves.toMatchObject({ operations: [] });
-  });
-
-  it.each(["0.21.0", "0.36.0", "0.38.0", "0.39.0"])(
-    "rejects in-place upgrade from schema %s",
-    async (version) => {
-      const database = new PGlite();
-      databases.push(database);
-      const kysely = new Kysely<SettingsDatabase>({
-        dialect: new PGliteDialect(database),
-      });
-      kyselyInstances.push(kysely);
-      await database.exec(`
-        create table private_hot_updater_settings (
-          key text primary key,
-          value text not null
-        );
-        insert into private_hot_updater_settings (key, value)
-        values ('schema.core', '${version}');
-      `);
-      const migrator = createKyselyMigrator({
-        db: kysely,
-        provider: "postgresql",
-      });
-
-      await expect(
-        migrator.migrateToLatest({ mode: "from-schema" }),
-      ).rejects.toThrow(`Hot Updater v1 cannot migrate schema ${version}`);
-    },
-  );
-
-  it("rejects a corrupt schema.core value", async () => {
-    const database = new DatabaseSync(":memory:");
-    database.exec(`
-      create table private_hot_updater_settings (
-        key text primary key,
-        value text not null
-      );
-    `);
-    database
-      .prepare(
-        "insert into private_hot_updater_settings (key, value) values (?, ?)",
-      )
-      .run("schema.core", new Uint8Array([0xff]));
-    const kysely = createNodeSqliteKysely(database);
-    kyselyInstances.push(kysely);
-    const migrator = createKyselyMigrator({ db: kysely, provider: "sqlite" });
-
-    await expect(migrator.getVersion()).rejects.toThrow(
-      "Invalid Hot Updater schema setting: schema.core",
-    );
-  });
-
-  it("blocks v0 schema readiness before reading bundle data", async () => {
-    const database = new DatabaseSync(":memory:");
-    database.exec(`
-      create table private_hot_updater_settings (
-        key text primary key,
-        value text not null
-      );
-    `);
-    database
-      .prepare(
-        "insert into private_hot_updater_settings (key, value) values (?, ?)",
-      )
-      .run("schema.core", "0.36.0");
-    const kysely = createNodeSqliteKysely(database);
-    kyselyInstances.push(kysely);
-    const migrator = createKyselyMigrator({
-      db: kysely,
-      provider: "sqlite",
-    });
-    const plugin = createInMemoryDatabasePlugin();
-    const count = vi.spyOn(plugin.models.bundles, "count");
-    const findMany = vi.spyOn(plugin.models.bundles, "findMany");
-    const core = createDatabasePluginCore(plugin, async () => null, {
-      beforeOperation: createSchemaReadinessChecker("v0-sql", () => migrator),
-    });
-
-    await expect(core.api.getBundles({ limit: 1 })).rejects.toThrow(
-      "Hot Updater v1 cannot migrate schema 0.36.0",
-    );
-    expect(count).not.toHaveBeenCalled();
-    expect(findMany).not.toHaveBeenCalled();
-  });
-});