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

package/src/adapters/kysely.spec.ts

@@ -1,244 +0,0 @@
-import { DatabaseSync, type SqliteValue } from "node:sqlite";
-
-import { PGlite } from "@electric-sql/pglite";
-import {
-  setupDatabaseTestSuite,
-  startHttpTestServer,
-} from "@hot-updater/test-utils";
-import { Kysely, SqliteDialect } from "kysely";
-import { PGliteDialect } from "kysely-pglite-dialect";
-import { describe, expect, it } from "vitest";
-
-import { createBundleFixture } from "../../../test-utils/src/databaseTestFixtures";
-import { createDatabasePluginApis } from "../assembly/databasePlugins";
-import { createInProcessCoreApi } from "../core/api";
-import { DatabaseConstraintError } from "../database/errors";
-import { HotUpdaterSchemaMigrationRequiredError } from "../database/fence";
-import { isMultiIndex, quoteSql } from "../database/sql/sqlSchema";
-import { coreSchema, toolingTargetOf } from "../db/coreDatabase";
-import type { ToolingDatabase } from "../db/types";
-import { createHotUpdater } from "../index";
-import { createInsightsModel, insights } from "../plugins/insights";
-import {
-  createBundleEventRowFixture,
-  insightsTestSuite,
-} from "../plugins/insights/testing";
-import { kyselyAdapter, type SQLProvider } from "./kysely";
-
-/** What the suites run: core and the Insights plugin. */
-const target = toolingTargetOf([insights()]);
-
-/** Every data table the migration creates; the settings rows stay. */
-const dataTables = target.schema.tables.flatMap((table) => [
-  table.name,
-  ...table.indexes
-    .filter((index) => isMultiIndex(table, index))
-    .map((index) => `${table.name}__${index.name}`),
-]);
-
-/** Kysely over `node:sqlite`, as Kysely's SQLite dialect expects. */
-const sqliteKysely = (database: DatabaseSync) =>
-  new Kysely<object>({
-    dialect: new SqliteDialect({
-      database: {
-        close: () => database.close(),
-        prepare: (query) => {
-          const statement = database.prepare(query);
-          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[])),
-          };
-        },
-      },
-    }),
-  });
-
-const migrate = async (database: ToolingDatabase) =>
-  (await database.createMigrator!(target).migrateToLatest()).execute();
-
-/** The Insights plugin's model over a database, on the server's tables. */
-const insightsOf = (database: ToolingDatabase) =>
-  createInsightsModel(
-    createDatabasePluginApis(database, [insights()]).insights,
-  );
-
-const backends = {
-  postgresql: () => {
-    const client = new PGlite();
-    return {
-      db: new Kysely<object>({ dialect: new PGliteDialect(client) }),
-      exec: (sql: string) => client.exec(sql).then(() => undefined),
-      close: () => client.close(),
-    };
-  },
-  sqlite: () => {
-    const database = new DatabaseSync(":memory:");
-    return {
-      db: sqliteKysely(database),
-      exec: async (sql: string) => database.exec(sql),
-      close: async () => undefined,
-    };
-  },
-} satisfies Record<Exclude<SQLProvider, "mysql">, () => unknown>;
-
-for (const provider of ["postgresql", "sqlite"] as const) {
-  let backend: ReturnType<(typeof backends)[typeof provider]> | undefined;
-  setupDatabaseTestSuite({
-    createHttpClient: (options) =>
-      startHttpTestServer(
-        createHotUpdater({
-          ...options,
-          plugins: [insights()],
-          clientAccess: "public",
-        }).handlers,
-      ),
-    plugins: [insightsTestSuite({ createModel: insightsOf })],
-    name: `kyselyAdapter (${provider})`,
-    migrate: async () => {
-      backend = backends[provider]();
-      await migrate(kyselyAdapter({ db: backend.db, provider }));
-    },
-    createDatabase: () => kyselyAdapter({ db: backend!.db, provider }),
-    reset: async () => {
-      const quote = (name: string) => quoteSql(provider, name);
-      await backend!.exec(
-        provider === "postgresql"
-          ? `TRUNCATE ${dataTables.map(quote).join(", ")} CASCADE`
-          : dataTables.map((name) => `DELETE FROM ${quote(name)};`).join(""),
-      );
-    },
-    dispose: async () => {
-      await backend!.db.destroy();
-      await backend!.close();
-      backend = undefined;
-    },
-  });
-}
-
-describe("kyselyAdapter migrations and fence", () => {
-  it("migrates once, answers nothing to migrate afterwards, and serves behind the fence", async () => {
-    const { db, close } = backends.postgresql();
-    const database = kyselyAdapter({ db, provider: "postgresql" });
-    const core = createInProcessCoreApi(database.adapter);
-    const migrator = database.createMigrator!();
-    try {
-      await expect(core.listChannels()).rejects.toBeInstanceOf(
-        HotUpdaterSchemaMigrationRequiredError,
-      );
-      await expect(migrator.getVersion()).resolves.toBeUndefined();
-      const pending = await migrator.migrateToLatest();
-      expect(pending.getSQL?.()).toContain(
-        'CREATE TABLE IF NOT EXISTS "bundles"',
-      );
-      expect(
-        pending.operations.filter(({ type }) => type === "create-table"),
-      ).toHaveLength(coreSchema.tables.length);
-      await pending.execute();
-      await expect(migrator.getVersion()).resolves.toBe("1.0.0");
-      await expect(migrator.migrateToLatest()).resolves.toMatchObject({
-        operations: [],
-      });
-      await expect(core.listChannels()).resolves.toEqual([]);
-    } finally {
-      await db.destroy();
-      await close();
-    }
-  });
-
-  it("refuses to migrate a database from before the storage engine", async () => {
-    const { db, exec, close } = backends.postgresql();
-    try {
-      await exec(
-        `CREATE TABLE private_hot_updater_settings (key varchar(255) PRIMARY KEY, value varchar(255) NOT NULL, _v bigint NOT NULL DEFAULT 0);
-         INSERT INTO private_hot_updater_settings (key, value) VALUES ('schema.core', '1.0.0');`,
-      );
-      const migrator = kyselyAdapter({
-        db,
-        provider: "postgresql",
-      }).createMigrator!();
-      await expect(migrator.migrateToLatest()).rejects.toMatchObject({
-        setting: { key: "schema.engine", expected: "1", found: null },
-      });
-    } finally {
-      await db.destroy();
-      await close();
-    }
-  });
-
-  it("rolls back a failed event write whole and accepts the retry", async () => {
-    const { db, exec, close } = backends.postgresql();
-    const database = kyselyAdapter({ db, provider: "postgresql" });
-    const model = insightsOf(database);
-    try {
-      await migrate(database);
-      await exec(
-        "ALTER TABLE bundle_events ADD CONSTRAINT reject_event CHECK (install_id <> 'install-703')",
-      );
-      const event = createBundleEventRowFixture("703", 100);
-      await expect(model.recordEvent({ event })).rejects.toThrow();
-      await expect(
-        model.findLatestEvents({ installId: event.install_id }),
-      ).resolves.toEqual([]);
-      await exec("ALTER TABLE bundle_events DROP CONSTRAINT reject_event");
-      await model.recordEvent({ event });
-      await expect(
-        model.findLatestEvents({ installId: event.install_id }),
-      ).resolves.toEqual([event]);
-    } finally {
-      await db.destroy();
-      await close();
-    }
-  });
-
-  it("keeps references without database foreign keys", async () => {
-    const { db, close } = backends.postgresql();
-    const database = kyselyAdapter({ db, provider: "postgresql" });
-    const core = createInProcessCoreApi(database.adapter);
-    try {
-      const pending = await database.createMigrator!().migrateToLatest();
-      expect(pending.getSQL?.()).not.toContain("FOREIGN KEY");
-      await pending.execute();
-      const owner = createBundleFixture("952");
-      await expect(
-        core.deploy([
-          {
-            bundle: {
-              ...owner,
-              patches: [
-                {
-                  baseBundleId: "missing-base",
-                  baseFileHash: "base-hash",
-                  byteSize: 1,
-                  patchFileHash: "patch-hash",
-                  patchStorageUri: "storage://patches/952.patch",
-                },
-              ],
-            },
-            release: {
-              channel: "production",
-              enabled: false,
-              fingerprintHash: null,
-              message: null,
-              shouldForceUpdate: false,
-              targetAppVersion: "*",
-            },
-          },
-        ]),
-      ).rejects.toBeInstanceOf(DatabaseConstraintError);
-      await expect(core.getBundle(owner.id)).resolves.toBeNull();
-    } finally {
-      await db.destroy();
-      await close();
-    }
-  });
-});

package/src/adapters/kysely.ts

@@ -1,46 +0,0 @@
-import type { Kysely } from "kysely";
-
-import { createSqlAdapter } from "../database/sql/sqlAdapter";
-import { coreTarget, createEngineDatabase } from "../db/coreDatabase";
-import { createEngineSqlMigrator } from "../db/engineSqlMigrator";
-import type { ORMSQLProvider, ToolingDatabase } from "../db/types";
-import { kyselyExecutor } from "./kyselyExecutor";
-import { checkSqlProvider } from "./sqlProviders";
-
-export { kyselyExecutor } from "./kyselyExecutor";
-
-export type { ORMSQLProvider as SQLProvider };
-
-export interface KyselyAdapterConfig<TDatabase extends object = object> {
-  readonly db: Kysely<TDatabase>;
-  readonly provider: ORMSQLProvider;
-}
-
-/**
- * Hot Updater's database on a Kysely instance: the storage engine through the
- * shared SQL core, fenced by the schema settings. `db migrate` and
- * `db generate --sql` apply the engine's SQL schema.
- */
-export const kyselyAdapter = <TDatabase extends object>(
-  config: KyselyAdapterConfig<TDatabase>,
-): ToolingDatabase => {
-  const provider = checkSqlProvider("kyselyAdapter", config.provider);
-  const executor = kyselyExecutor(
-    config.db as unknown as Kysely<object>,
-    provider,
-  );
-  return {
-    ...createEngineDatabase({
-      name: "kysely",
-      adapter: createSqlAdapter({ executor }),
-    }),
-    provider,
-    createMigrator: ({ schema, settings } = coreTarget) =>
-      createEngineSqlMigrator({
-        adapterName: "kysely",
-        executor,
-        schema,
-        settings,
-      }),
-  };
-};

package/src/adapters/kyselyExecutor.ts

@@ -1,53 +0,0 @@
-import { CompiledQuery, type Kysely, type QueryResult } from "kysely";
-
-import type {
-  SqlConnection,
-  SqlDialect,
-  SqlExecutor,
-} from "../database/sql/sqlAdapter";
-
-interface QueryRunner {
-  executeQuery<R>(query: CompiledQuery<R>): Promise<QueryResult<R>>;
-}
-
-const over = (runner: QueryRunner): SqlConnection => ({
-  async execute({ sql, params }) {
-    const result = await runner.executeQuery<Record<string, unknown>>(
-      CompiledQuery.raw(sql, [...params]),
-    );
-    return {
-      rows: result.rows,
-      changes: Number(result.numAffectedRows ?? 0n),
-    };
-  },
-});
-
-const raw = (runner: QueryRunner, sql: string) =>
-  runner.executeQuery(CompiledQuery.raw(sql));
-
-/**
- * The SQL core's executor over a Kysely instance: statements run as raw
- * compiled queries. SQLite transactions begin with BEGIN IMMEDIATE on one
- * connection; other dialects use Kysely's transactions.
- */
-export const kyselyExecutor = (
-  db: Kysely<object>,
-  dialect: SqlDialect,
-): SqlExecutor => ({
-  dialect,
-  ...over(db),
-  transaction: (fn) =>
-    dialect === "sqlite"
-      ? db.connection().execute(async (connection) => {
-          await raw(connection, "BEGIN IMMEDIATE");
-          try {
-            const result = await fn(over(connection));
-            await raw(connection, "COMMIT");
-            return result;
-          } catch (error) {
-            await raw(connection, "ROLLBACK").catch(() => undefined);
-            throw error;
-          }
-        })
-      : db.transaction().execute((transaction) => fn(over(transaction))),
-});

package/src/adapters/mongodb.integration.spec.ts

@@ -1,271 +0,0 @@
-import net from "node:net";
-import path from "node:path";
-
-import type { PhysicalTable } from "@hot-updater/plugin-core/internal";
-import {
-  conformanceExpiring,
-  setupDatabaseAdapterConformanceSuite,
-  setupDatabaseTestSuite,
-  startHttpTestServer,
-} from "@hot-updater/test-utils";
-import { assertDockerComposeAvailable } from "@hot-updater/test-utils/node";
-import { execa } from "execa";
-import { MongoClient } from "mongodb";
-import { afterAll, beforeAll, describe, expect, it } from "vitest";
-
-import { createBundleFixture } from "../../../test-utils/src/databaseTestFixtures";
-import { createDatabasePluginApis } from "../assembly/databasePlugins";
-import { createInProcessCoreApi } from "../core/api";
-import { HotUpdaterSchemaMigrationRequiredError } from "../database/fence";
-import { toolingTargetOf } from "../db/coreDatabase";
-import { createHotUpdater } from "../index";
-import { createInsightsModel, insights } from "../plugins/insights";
-import { insightsTestSuite } from "../plugins/insights/testing";
-import { mongoAdapter } from "./mongodb";
-import { createMongoAdapter } from "./mongodbAdapter";
-
-assertDockerComposeAvailable(
-  "MongoDB integration tests need Docker Compose and a running Docker daemon.",
-);
-
-const availablePort = () =>
-  new Promise<number>((resolve, reject) => {
-    const server = net.createServer();
-    server.once("error", reject);
-    server.listen(0, "127.0.0.1", () => {
-      const address = server.address();
-      if (address === null || typeof address === "string") {
-        reject(new Error("Failed to allocate a MongoDB test port"));
-        return;
-      }
-      server.close((error) => (error ? reject(error) : resolve(address.port)));
-    });
-  });
-
-const composeFile = path.resolve(
-  import.meta.dirname,
-  "../../../../examples-server/hono-mongodb/docker-compose.yml",
-);
-let environment: Record<string, string> | undefined;
-const compose = (args: readonly string[]) =>
-  execa("docker", ["compose", "-f", composeFile, ...args], {
-    env: environment,
-  });
-
-let port: number;
-const clients: MongoClient[] = [];
-/** A client whose default database is `name`, on the replica set. */
-const connect = async (name: string) => {
-  const client = new MongoClient(
-    `mongodb://127.0.0.1:${port}/${name}?replicaSet=rs0&directConnection=true`,
-  );
-  await client.connect();
-  clients.push(client);
-  return client;
-};
-
-let engine: MongoClient;
-let suiteClient: MongoClient;
-
-beforeAll(async () => {
-  port = await availablePort();
-  environment = {
-    COMPOSE_PROJECT_NAME: `hot-updater-mongo-engine-${process.pid}`,
-    HOT_UPDATER_E2E_MONGODB_PORT: String(port),
-  };
-  await compose(["up", "-d", "--wait"]);
-  engine = await connect("engine");
-  suiteClient = await connect("suite");
-}, 180_000);
-
-afterAll(async () => {
-  await Promise.all(clients.map((client) => client.close()));
-  if (environment) await compose(["down", "-v", "--remove-orphans"]);
-}, 60_000);
-
-let tests = 0;
-setupDatabaseAdapterConformanceSuite({
-  name: "mongodb (replica set)",
-  maxOps: 50,
-  retention: "ttl",
-  createAdapter: async ({ tables, nativePageSize }) => {
-    tests += 1;
-    const adapter = createMongoAdapter({
-      client: engine,
-      tablePrefix: `t${tests}_`,
-      maxOps: 50,
-      ...(nativePageSize === undefined ? {} : { batchSize: nativePageSize }),
-    });
-    await adapter.migrations!.apply(tables);
-    return { adapter };
-  },
-});
-
-/** What the suite runs: core and the Insights plugin. */
-const suiteTarget = toolingTargetOf([insights()]);
-
-setupDatabaseTestSuite({
-  createHttpClient: (options) =>
-    startHttpTestServer(
-      createHotUpdater({
-        ...options,
-        plugins: [insights()],
-        clientAccess: "public",
-      }).handlers,
-    ),
-  plugins: [
-    insightsTestSuite({
-      createModel: (database) =>
-        createInsightsModel(
-          createDatabasePluginApis(database, [insights()]).insights,
-        ),
-    }),
-  ],
-  name: "mongoAdapter (replica set)",
-  migrate: async () => {
-    const migrator = mongoAdapter({ client: suiteClient }).createMigrator!(
-      suiteTarget,
-    );
-    await (await migrator.migrateToLatest()).execute();
-  },
-  createDatabase: () => mongoAdapter({ client: suiteClient }),
-  reset: async () => {
-    for (const table of suiteTarget.schema.tables) {
-      await suiteClient.db().collection(table.name).deleteMany({});
-    }
-  },
-  dispose: () => undefined,
-});
-
-describe("mongoAdapter retention", () => {
-  it("stamps each row with retention with _expireAt, which a TTL index deletes by", async () => {
-    const client = await connect("retention");
-    const adapter = createMongoAdapter({ client });
-    const counted: PhysicalTable = {
-      name: "counted",
-      columns: [
-        { name: "bucket", type: "integer", nullable: false },
-        { name: "hits", type: "integer", nullable: false },
-        { name: "_v", type: "integer", nullable: false },
-      ],
-      key: ["bucket"],
-      indexes: [],
-      retention: { column: "bucket", ms: 1_000 },
-    };
-    await adapter.migrations!.apply([conformanceExpiring, counted]);
-    const expireAt = async (table: string, _id: unknown) =>
-      (
-        await client
-          .db()
-          .collection(table)
-          .findOne({ _id } as never)
-      )?._expireAt;
-    const row = (id: string, at: number | null) => ({
-      id,
-      grp: "g",
-      at,
-      tags: ["t"],
-      _v: 0,
-    });
-
-    expect(
-      await adapter.write([
-        { type: "insert", table: conformanceExpiring, row: row("a", 5_000) },
-        { type: "insert", table: conformanceExpiring, row: row("b", null) },
-        {
-          type: "increment",
-          table: counted,
-          key: [7_000],
-          by: { hits: 1 },
-          init: { bucket: 7_000, hits: 0, _v: 0 },
-        },
-      ]),
-    ).toEqual({ ok: true });
-    expect(await expireAt(conformanceExpiring.name, "a")).toEqual(
-      new Date(6_000),
-    );
-    expect(await expireAt(conformanceExpiring.name, "b")).toBeNull();
-    expect(await expireAt(counted.name, 7_000)).toEqual(new Date(8_000));
-
-    // A patch that moves the retention column moves the expiry with it.
-    await adapter.write([
-      {
-        type: "patch",
-        table: conformanceExpiring,
-        key: ["a"],
-        set: { at: 9_000 },
-        guard: { v: 0 },
-        previous: row("a", 5_000),
-      },
-    ]);
-    expect(await expireAt(conformanceExpiring.name, "a")).toEqual(
-      new Date(10_000),
-    );
-    const [found] = await adapter.get(conformanceExpiring, [["a"]]);
-    expect(found).not.toHaveProperty("_expireAt");
-    expect(
-      await client.db().collection(conformanceExpiring.name).indexes(),
-    ).toContainEqual(
-      expect.objectContaining({
-        name: "_expireAt",
-        key: { _expireAt: 1 },
-        expireAfterSeconds: 0,
-      }),
-    );
-  });
-});
-
-describe("mongoAdapter migrations", () => {
-  it("serves behind the fence only after db migrate, then has nothing to migrate", async () => {
-    const client = await connect("fenced");
-    const database = mongoAdapter({ client });
-    const core = createInProcessCoreApi(database.adapter);
-    await expect(core.listChannels()).rejects.toBeInstanceOf(
-      HotUpdaterSchemaMigrationRequiredError,
-    );
-    const migrator = database.createMigrator!();
-    await (await migrator.migrateToLatest()).execute();
-    await expect(migrator.migrateToLatest()).resolves.toMatchObject({
-      operations: [],
-    });
-    await expect(migrator.getVersion()).resolves.toBe("1.0.0");
-
-    const [result] = await core.deploy([
-      {
-        bundle: createBundleFixture("1"),
-        release: {
-          channel: "production",
-          enabled: true,
-          fingerprintHash: null,
-          message: null,
-          shouldForceUpdate: false,
-          targetAppVersion: "1.0.0",
-        },
-      },
-    ]);
-    const release = result!.release!;
-    await expect(core.getRelease(release.id)).resolves.toEqual(release);
-  });
-
-  it("refuses a v0 database and a database from before the engine", async () => {
-    const v0 = await connect("v0");
-    await v0
-      .db()
-      .collection("private_hot_updater_settings")
-      .insertOne({ key: "version", value: "0.21.0" });
-    await expect(
-      mongoAdapter({ client: v0 }).createMigrator!().migrateToLatest(),
-    ).rejects.toThrow("cannot migrate schema 0.21.0 in place");
-
-    const rc = await connect("rc");
-    await rc
-      .db()
-      .collection("private_hot_updater_settings")
-      .insertOne({ key: "schema.core", value: "1.0.0" });
-    await expect(
-      mongoAdapter({ client: rc }).createMigrator!().migrateToLatest(),
-    ).rejects.toMatchObject({
-      setting: { key: "schema.engine", expected: "1", found: null },
-    });
-  });
-});

package/src/adapters/mongodb.readBudgets.integration.spec.ts

@@ -1,61 +0,0 @@
-import path from "node:path";
-
-import { setupReadBudgetTestSuite } from "@hot-updater/test-utils";
-import {
-  assertDockerComposeAvailable,
-  findOpenPort,
-} from "@hot-updater/test-utils/node";
-import { execa } from "execa";
-import { MongoClient } from "mongodb";
-import { afterAll, beforeAll } from "vitest";
-
-import { readBudgetServer } from "../readBudgets.testFixtures";
-import { createMongoAdapter } from "./mongodbAdapter";
-
-assertDockerComposeAvailable(
-  "MongoDB read-budget tests need Docker Compose and a running Docker daemon.",
-);
-
-const composeFile = path.resolve(
-  import.meta.dirname,
-  "../../../../examples-server/hono-mongodb/docker-compose.yml",
-);
-let environment: Record<string, string> | undefined;
-const compose = (args: readonly string[]) =>
-  execa("docker", ["compose", "-f", composeFile, ...args], {
-    env: environment,
-  });
-
-let client: MongoClient;
-
-beforeAll(async () => {
-  const port = await findOpenPort();
-  environment = {
-    COMPOSE_PROJECT_NAME: `hot-updater-mongo-budgets-${process.pid}`,
-    HOT_UPDATER_E2E_MONGODB_PORT: String(port),
-  };
-  await compose(["up", "-d", "--wait"]);
-  client = new MongoClient(
-    `mongodb://127.0.0.1:${port}/budgets?replicaSet=rs0&directConnection=true`,
-  );
-  await client.connect();
-}, 180_000);
-
-afterAll(async () => {
-  await client?.close();
-  if (environment) await compose(["down", "-v", "--remove-orphans"]);
-}, 60_000);
-
-/**
- * `mongoAdapter`'s composition without its schema fence: the MongoDB adapter
- * on the replica set, reading in batches as small as the suite's pages.
- */
-setupReadBudgetTestSuite({
-  name: "mongodb (replica set)",
-  server: readBudgetServer,
-  createAdapter: async ({ tables, nativePageSize }) => {
-    const adapter = createMongoAdapter({ client, batchSize: nativePageSize });
-    await adapter.migrations!.apply(tables);
-    return { adapter };
-  },
-});