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

package/src/adapters/drizzle.spec.ts

@@ -1,314 +0,0 @@
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { DatabaseSync, type SqliteValue } from "node:sqlite";
-import { pathToFileURL } from "node:url";
-
-import { PGlite } from "@electric-sql/pglite";
-import {
-  setupDatabaseTestSuite,
-  startHttpTestServer,
-} from "@hot-updater/test-utils";
-import { createClient } from "@libsql/client";
-import type { SQL } from "drizzle-orm";
-import { drizzle as libsql } from "drizzle-orm/libsql";
-import { drizzle as pglite } from "drizzle-orm/pglite";
-import { SQLiteSyncDialect } from "drizzle-orm/sqlite-core";
-import { afterAll, 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 { createSqlAdapter } from "../database/sql/sqlAdapter";
-import { isMultiIndex, quoteSql } from "../database/sql/sqlSchema";
-import { toolingTargetOf } from "../db/coreDatabase";
-import { generateEngineSql } from "../db/engineSql";
-import type { ToolingDatabase } from "../db/types";
-import { createHotUpdater } from "../index";
-import { createInsightsModel, insights } from "../plugins/insights";
-import { insightsTestSuite } from "../plugins/insights/testing";
-import {
-  drizzleAdapter,
-  DrizzleTransactionUnsupportedError,
-  type DrizzleProvider,
-} from "./drizzle";
-import { drizzleExecutor } from "./drizzleExecutor";
-
-/** What the suites run: core and the Insights plugin. */
-const target = toolingTargetOf([insights()]);
-
-/** Every data table; the settings rows stay across tests. */
-const dataTables = target.schema.tables.flatMap((table) => [
-  table.name,
-  ...table.indexes
-    .filter((index) => isMultiIndex(table, index))
-    .map((index) => `${table.name}__${index.name}`),
-]);
-
-const temporaryDirectory = mkdtemp(
-  path.join(os.tmpdir(), "hot-updater-drizzle-"),
-);
-afterAll(async () =>
-  rm(await temporaryDirectory, { recursive: true, force: true }),
-);
-let files = 0;
-const temporaryFile = async () =>
-  `file:${path.join(await temporaryDirectory, `${(files += 1)}.db`)}`;
-/** A libSQL file in WAL mode, so reads never wait on a committing writer. */
-const libsqlFile = async () => {
-  const client = createClient({ url: await temporaryFile() });
-  await client.execute("PRAGMA journal_mode = WAL");
-  return client;
-};
-
-const engineSql = (dialect: "postgresql" | "sqlite") =>
-  generateEngineSql(dialect, target.schema, target.settings);
-
-const backends = {
-  postgresql: async () => {
-    const client = new PGlite();
-    await client.exec(engineSql("postgresql").join(";\n"));
-    return {
-      db: pglite(client),
-      exec: (sql: string) => client.exec(sql).then(() => undefined),
-      close: () => client.close(),
-    };
-  },
-  sqlite: async () => {
-    // A file: each libSQL transaction opens a connection, and `:memory:` would be a new database.
-    const client = await libsqlFile();
-    await client.executeMultiple(engineSql("sqlite").join(";\n"));
-    return {
-      db: libsql(client),
-      exec: (sql: string) => client.executeMultiple(sql),
-      close: async () => client.close(),
-    };
-  },
-} as const;
-
-for (const provider of ["postgresql", "sqlite"] as const) {
-  let backend: Awaited<ReturnType<(typeof backends)[typeof provider]>>;
-  setupDatabaseTestSuite({
-    createHttpClient: (options) =>
-      startHttpTestServer(
-        createHotUpdater({
-          ...options,
-          plugins: [insights()],
-          clientAccess: "public",
-        }).handlers,
-      ),
-    plugins: [
-      insightsTestSuite({
-        createModel: (database) =>
-          createInsightsModel(
-            createDatabasePluginApis(database, [insights()]).insights,
-          ),
-      }),
-    ],
-    name: `drizzleAdapter (${provider})`,
-    migrate: async () => {
-      backend = await backends[provider]();
-    },
-    createDatabase: () => drizzleAdapter({ 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: () => backend.close(),
-  });
-}
-
-/** A sync Drizzle SQLite database as better-sqlite3's driver answers: over `node:sqlite`. */
-const syncSqlite = (database: DatabaseSync) => {
-  const dialect = new SQLiteSyncDialect();
-  const prepare = (query: SQL) => {
-    const { sql, params } = dialect.sqlToQuery(query);
-    return {
-      statement: database.prepare(sql),
-      params: params as SqliteValue[],
-    };
-  };
-  return {
-    resultKind: "sync" as const,
-    all: (query: SQL) => {
-      const { statement, params } = prepare(query);
-      return statement.all(...params);
-    },
-    run: (query: SQL) => {
-      const { statement, params } = prepare(query);
-      return statement.run(...params);
-    },
-  };
-};
-
-const policy = {
-  channel: "production",
-  enabled: true,
-  fingerprintHash: null,
-  message: null,
-  shouldForceUpdate: false,
-  targetAppVersion: "1.0.0",
-};
-
-/** Deploys bundle "1" through core on the database. */
-const seed = async (database: ToolingDatabase) => {
-  const core = createInProcessCoreApi(database.adapter);
-  const bundle = createBundleFixture("1");
-  const [result] = await core.deploy([{ bundle, release: policy }]);
-  return { core, bundle, release: result!.release! };
-};
-
-describe("drizzleAdapter drivers", () => {
-  it("runs a sync SQLite driver one statement at a time, with BEGIN IMMEDIATE transactions", async () => {
-    const database = new DatabaseSync(":memory:");
-    database.exec(engineSql("sqlite").join(";\n"));
-    const { core, bundle } = await seed(
-      drizzleAdapter({ db: syncSqlite(database), provider: "sqlite" }),
-    );
-    const deploys = Array.from({ length: 8 }, (_, n) =>
-      core.deploy([
-        { bundle: createBundleFixture(String(100 + n)), release: policy },
-      ]),
-    );
-    await expect(Promise.all(deploys)).resolves.toHaveLength(8);
-    await expect(core.getBundle(bundle.id)).resolves.toMatchObject({
-      bundle: { id: bundle.id },
-    });
-    await expect(core.countBundles()).resolves.toBe(9);
-    database.close();
-  });
-
-  it("refuses a driver without interactive transactions on first use, naming the supported ones", async () => {
-    const client = new PGlite();
-    await client.exec(engineSql("postgresql").join(";\n"));
-    const db = pglite(client);
-    const withoutTransactions = {
-      execute: db.execute.bind(db),
-      transaction: () => {
-        throw new Error("No transactions support in neon-http driver");
-      },
-    };
-    const database = drizzleAdapter({
-      db: withoutTransactions,
-      provider: "postgresql",
-    });
-    const read = await createInProcessCoreApi(database.adapter)
-      .listChannels()
-      .catch((caught: unknown) => caught);
-    expect(read).toBeInstanceOf(DrizzleTransactionUnsupportedError);
-    expect(String(read)).toContain("better-sqlite3");
-    // Past the fence, a deploy reads in its transaction before it writes,
-    // so it stops there, before anything is sent.
-    const write = await createInProcessCoreApi(
-      createSqlAdapter({
-        executor: drizzleExecutor(withoutTransactions, "postgresql"),
-      }),
-    )
-      .deploy([{ bundle: createBundleFixture("2"), release: policy }])
-      .catch((caught: unknown) => caught);
-    expect(write).toBeInstanceOf(DrizzleTransactionUnsupportedError);
-    await client.close();
-  });
-
-  it("resolves a lazy database on first use", async () => {
-    let resolved = 0;
-    const database = drizzleAdapter({
-      db: async () => {
-        resolved += 1;
-        return (await backends.sqlite()).db;
-      },
-      provider: "sqlite",
-    });
-    expect(resolved).toBe(0);
-    const { core } = await seed(database);
-    await core.listChannels();
-    expect(resolved).toBe(1);
-  });
-});
-
-describe("drizzleAdapter schema and migrations", () => {
-  const directory = mkdtemp(path.join(import.meta.dirname, ".drizzle-"));
-  afterAll(async () => rm(await directory, { recursive: true, force: true }));
-
-  /** The generated schema file, loaded as drizzle-kit loads it. */
-  const load = async (provider: DrizzleProvider) => {
-    const schema = drizzleAdapter({
-      db: {},
-      provider,
-    }).generateSchema!("latest");
-    const file = path.join(await directory, `${provider}.ts`);
-    await writeFile(file, schema.code);
-    expect(schema.path).toBe("hot-updater-schema.ts");
-    return (await import(pathToFileURL(file).href)) as Record<string, unknown>;
-  };
-
-  it.each(["postgresql", "sqlite"] as const)(
-    "applies the generated %s schema with drizzle-kit, writes the settings with db migrate, and serves behind the fence",
-    async (provider) => {
-      const kit = await import("drizzle-kit/api");
-      const imports = await load(provider);
-      const statements =
-        provider === "postgresql"
-          ? await kit.generateMigration(
-              kit.generateDrizzleJson({}),
-              kit.generateDrizzleJson(imports),
-            )
-          : await kit.generateSQLiteMigration(
-              await kit.generateSQLiteDrizzleJson({}),
-              await kit.generateSQLiteDrizzleJson(imports),
-            );
-      const client =
-        provider === "postgresql" ? new PGlite() : await libsqlFile();
-      const run = async (sql: string) =>
-        client instanceof PGlite
-          ? client.exec(sql).then(() => undefined)
-          : client.executeMultiple(sql);
-      for (const statement of statements) await run(statement);
-      const db = client instanceof PGlite ? pglite(client) : libsql(client);
-      const database = drizzleAdapter({ db, provider });
-
-      await expect(
-        createInProcessCoreApi(database.adapter).listChannels(),
-      ).rejects.toBeInstanceOf(HotUpdaterSchemaMigrationRequiredError);
-      const migrator = database.createMigrator!();
-      const pending = await migrator.migrateToLatest();
-      expect(pending.operations).toEqual([
-        expect.objectContaining({ type: "custom" }),
-      ]);
-      await pending.execute();
-      await expect(migrator.migrateToLatest()).resolves.toMatchObject({
-        operations: [],
-      });
-      await expect(migrator.getVersion()).resolves.toBe("1.0.0");
-      const { core, release } = await seed(database);
-      await expect(core.getRelease(release.id)).resolves.toEqual(release);
-      await (client instanceof PGlite ? client.close() : client.close());
-    },
-  );
-
-  it("asks for the ORM's tables first, and refuses a database from before the engine", async () => {
-    const empty = await libsqlFile();
-    await expect(
-      drizzleAdapter({ db: libsql(empty), provider: "sqlite" })
-        .createMigrator!().migrateToLatest(),
-    ).rejects.toThrow("drizzle-kit push");
-
-    const legacy = await libsqlFile();
-    await legacy.executeMultiple(
-      "CREATE TABLE private_hot_updater_settings (key TEXT PRIMARY KEY, value TEXT NOT NULL); INSERT INTO private_hot_updater_settings VALUES ('schema.core', '1.0.0');",
-    );
-    await expect(
-      drizzleAdapter({ db: libsql(legacy), provider: "sqlite" })
-        .createMigrator!().migrateToLatest(),
-    ).rejects.toMatchObject({
-      setting: { key: "schema.engine", expected: "1", found: null },
-    });
-    empty.close();
-    legacy.close();
-  });
-});

package/src/adapters/drizzle.ts

@@ -1,64 +0,0 @@
-import { createSqlAdapter } from "../database/sql/sqlAdapter";
-import {
-  coreSettings,
-  coreTarget,
-  createEngineDatabase,
-} from "../db/coreDatabase";
-import { generateDrizzleEngineSchema } from "../db/engineDrizzleSchema";
-import { createSettingsMigrator } from "../db/settingsMigrator";
-import type {
-  ORMSQLProvider,
-  SchemaGenerator,
-  ToolingDatabase,
-} from "../db/types";
-import { drizzleExecutor } from "./drizzleExecutor";
-import { checkSqlProvider } from "./sqlProviders";
-
-export {
-  DrizzleTransactionUnsupportedError,
-  SUPPORTED_DRIZZLE_DRIVERS,
-} from "./drizzleExecutor";
-
-export type DrizzleProvider = ORMSQLProvider;
-
-export interface DrizzleConfig {
-  /** A Drizzle database, or a function that returns one on first use. */
-  readonly db: unknown | (() => unknown | Promise<unknown>);
-  readonly provider: DrizzleProvider;
-  /** Ignored: Hot Updater reads through SQL; the schema file is for drizzle-kit. */
-  readonly schema?: Record<string, unknown>;
-}
-
-/**
- * Hot Updater's database on a Drizzle instance: the storage engine through the
- * shared SQL core, fenced by the schema settings. `db generate` writes the
- * Drizzle schema drizzle-kit applies; `db migrate` then writes the settings
- * rows the fence checks.
- */
-export const drizzleAdapter = (config: DrizzleConfig): ToolingDatabase => {
-  const provider = checkSqlProvider("drizzleAdapter", config.provider);
-  const executor = drizzleExecutor(config.db, provider);
-  return {
-    ...createEngineDatabase({
-      name: "drizzle",
-      adapter: createSqlAdapter({ executor }),
-    }),
-    provider,
-    generateSchema: ((version, _name, { schema } = coreTarget) => {
-      if (version !== "latest" && version !== coreSettings["schema.core"]) {
-        throw new Error(`Invalid version ${version}`);
-      }
-      return {
-        code: generateDrizzleEngineSchema(provider, schema),
-        path: "hot-updater-schema.ts",
-      };
-    }) satisfies SchemaGenerator,
-    createMigrator: ({ settings } = coreTarget) =>
-      createSettingsMigrator({
-        adapterName: "drizzle",
-        executor,
-        settings,
-        applyTables: "`drizzle-kit push` (or your drizzle-kit migrations)",
-      }),
-  };
-};

package/src/adapters/drizzleExecutor.ts

@@ -1,166 +0,0 @@
-import { sql, type SQL } from "drizzle-orm";
-
-import type {
-  SqlConnection,
-  SqlDialect,
-  SqlExecutor,
-  SqlResult,
-  SqlStatement,
-} from "../database/sql/sqlAdapter";
-
-/** The members of a Drizzle database or transaction the executor uses. */
-interface DrizzleRunner {
-  execute?(query: SQL): Promise<unknown>;
-  all?(query: SQL): unknown;
-  run?(query: SQL): unknown;
-  transaction?(fn: (tx: DrizzleRunner) => Promise<unknown>): unknown;
-  /** SQLite drivers: `sync` for better-sqlite3 and bun:sqlite. */
-  readonly resultKind?: "sync" | "async";
-}
-
-export const SUPPORTED_DRIZZLE_DRIVERS =
-  "node-postgres, postgres-js, PGlite, or Neon over WebSockets for PostgreSQL; mysql2 for MySQL; libSQL, better-sqlite3, or bun:sqlite for SQLite";
-
-export class DrizzleTransactionUnsupportedError extends Error {
-  readonly name = "DrizzleTransactionUnsupportedError";
-  constructor(cause: unknown) {
-    super(
-      `This Drizzle driver cannot run interactive transactions, which Hot Updater needs. Use ${SUPPORTED_DRIZZLE_DRIVERS}.`,
-      { cause },
-    );
-  }
-}
-
-/** The SQL core's statement as Drizzle SQL, each placeholder bound as a parameter. */
-const toSql = (dialect: SqlDialect, { sql: text, params }: SqlStatement) => {
-  const pattern = dialect === "postgresql" ? /\$(\d+)/gu : /\?/gu;
-  const chunks: SQL[] = [];
-  let last = 0;
-  let next = 0;
-  for (const match of text.matchAll(pattern)) {
-    chunks.push(sql.raw(text.slice(last, match.index)));
-    const position = dialect === "postgresql" ? Number(match[1]) - 1 : next++;
-    chunks.push(sql`${sql.param(params[position])}`);
-    last = match.index + match[0].length;
-  }
-  chunks.push(sql.raw(text.slice(last)));
-  return sql.join(chunks);
-};
-
-const over = (dialect: SqlDialect, runner: DrizzleRunner): SqlConnection => ({
-  async execute(statement): Promise<SqlResult> {
-    const query = toSql(dialect, statement);
-    if (dialect === "sqlite") {
-      return /^\s*SELECT\b/iu.test(statement.sql)
-        ? {
-            rows: (await runner.all!(query)) as Record<string, unknown>[],
-            changes: 0,
-          }
-        : { rows: [], changes: changesOf(await runner.run!(query)) };
-    }
-    const result = await runner.execute!(query);
-    // mysql2 answers [rows or header, fields]; postgres-js answers the rows.
-    const value =
-      dialect === "mysql" && Array.isArray(result) ? result[0] : result;
-    const rows = Array.isArray(value)
-      ? value
-      : ((value as { rows?: unknown[] }).rows ?? []);
-    return {
-      rows: rows as Record<string, unknown>[],
-      changes:
-        Array.isArray(value) && dialect === "mysql" ? 0 : changesOf(value),
-    };
-  },
-});
-
-const changesOf = (result: unknown): number => {
-  const record = (result ?? {}) as Record<string, unknown>;
-  const meta = record.meta as Record<string, unknown> | undefined;
-  return Number(
-    record.rowCount ??
-      record.affectedRows ??
-      record.rowsAffected ??
-      record.changes ??
-      record.count ??
-      meta?.changes ??
-      0,
-  );
-};
-
-/**
- * The SQL core's executor over a Drizzle database, or a function that
- * returns one. Async drivers run Drizzle's transactions; sync SQLite drivers
- * run one statement at a time, beginning transactions with BEGIN IMMEDIATE.
- * First use checks that the driver can run a transaction at all.
- */
-export const drizzleExecutor = (
-  source: unknown,
-  dialect: SqlDialect,
-): SqlExecutor => {
-  const isSync = (runner: DrizzleRunner) =>
-    dialect === "sqlite" && runner.resultKind === "sync";
-  let ready: Promise<DrizzleRunner> | undefined;
-  const resolve = () => {
-    ready ??= (async () => {
-      const runner = (await (typeof source === "function"
-        ? (source as () => unknown)()
-        : source)) as DrizzleRunner;
-      if (isSync(runner)) return runner;
-      let started = false;
-      try {
-        if (typeof runner.transaction !== "function") {
-          throw new TypeError("The Drizzle database has no transaction().");
-        }
-        await runner.transaction(async () => {
-          started = true;
-        });
-      } catch (error) {
-        if (!started) throw new DrizzleTransactionUnsupportedError(error);
-        throw error;
-      }
-      return runner;
-    })();
-    // A failed check runs again next time.
-    ready.catch(() => {
-      ready = undefined;
-    });
-    return ready;
-  };
-  // Sync drivers share one connection: nothing may interleave a transaction.
-  let queue: Promise<unknown> = Promise.resolve();
-  const serial = <T>(task: () => Promise<T>) => {
-    const result = queue.then(task);
-    queue = result.catch(() => undefined);
-    return result;
-  };
-  return {
-    dialect,
-    async execute(statement) {
-      const runner = await resolve();
-      const run = () => over(dialect, runner).execute(statement);
-      return isSync(runner) ? serial(run) : run();
-    },
-    async transaction(fn) {
-      const runner = await resolve();
-      if (!isSync(runner)) {
-        return (await runner.transaction!((tx) =>
-          fn(over(dialect, tx)),
-        )) as Awaited<ReturnType<typeof fn>>;
-      }
-      return serial(async () => {
-        const connection = over(dialect, runner);
-        const raw = (text: string) =>
-          connection.execute({ sql: text, params: [] });
-        await raw("BEGIN IMMEDIATE");
-        try {
-          const result = await fn(connection);
-          await raw("COMMIT");
-          return result;
-        } catch (error) {
-          await raw("ROLLBACK").catch(() => undefined);
-          throw error;
-        }
-      });
-    },
-  };
-};

package/src/adapters/kysely.conformance.integration.spec.ts

@@ -1,36 +0,0 @@
-import { PGlite } from "@electric-sql/pglite";
-import { setupDatabaseAdapterConformanceSuite } from "@hot-updater/test-utils";
-import { Kysely } from "kysely";
-import { PGliteDialect } from "kysely-pglite-dialect";
-
-import { SETTINGS_TABLE } from "../database/fence";
-import { createTableStatements } from "../database/sql/sqlSchema";
-import { coreSettings } from "../db/coreDatabase";
-import { settingsStatements } from "../db/engineSql";
-import { kyselyAdapter } from "./kysely";
-
-/**
- * The adapter `kyselyAdapter` returns, schema fence included, on a new PGlite
- * per test that holds the conformance tables and the settings rows the fence
- * checks. PostgreSQL has no cap on one write and no native pages.
- */
-setupDatabaseAdapterConformanceSuite({
-  name: "kysely (PGlite)",
-  createAdapter: async ({ tables }) => {
-    const client = new PGlite();
-    await client.exec(
-      [
-        ...createTableStatements("postgresql", [...tables, SETTINGS_TABLE]),
-        ...settingsStatements("postgresql", coreSettings),
-      ].join(";\n"),
-    );
-    const db = new Kysely<object>({ dialect: new PGliteDialect(client) });
-    return {
-      adapter: kyselyAdapter({ db, provider: "postgresql" }).adapter,
-      cleanup: async () => {
-        await db.destroy();
-        await client.close();
-      },
-    };
-  },
-});

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

@@ -1,44 +0,0 @@
-import { PGlite } from "@electric-sql/pglite";
-import {
-  postgresRowsExamined,
-  setupReadBudgetTestSuite,
-} from "@hot-updater/test-utils";
-import { Kysely } from "kysely";
-import { PGliteDialect } from "kysely-pglite-dialect";
-
-import { createSqlAdapter } from "../database/sql/sqlAdapter";
-import { readBudgetServer } from "../readBudgets.testFixtures";
-import { kyselyAdapter } from "./kysely";
-import { kyselyExecutor } from "./kyselyExecutor";
-
-/**
- * `kyselyAdapter`'s composition without its schema fence: the SQL core over
- * the Kysely executor on PGlite, on the tables its migrator creates for core
- * and the plugins the suite measures.
- */
-setupReadBudgetTestSuite({
-  name: "kysely (PGlite)",
-  server: readBudgetServer,
-  createAdapter: async () => {
-    const client = new PGlite();
-    const db = new Kysely<object>({ dialect: new PGliteDialect(client) });
-    const target = readBudgetServer.toolingTargetOf(readBudgetServer.plugins);
-    const migrator = kyselyAdapter({ db, provider: "postgresql" })
-      .createMigrator!(target);
-    await (await migrator.migrateToLatest()).execute();
-    const reads = postgresRowsExamined(
-      async (sql, params) =>
-        (await client.query<Record<string, unknown>>(sql, [...params])).rows,
-    );
-    return {
-      adapter: createSqlAdapter({
-        executor: reads.wrap(kyselyExecutor(db, "postgresql")),
-      }),
-      examined: reads.examined,
-      cleanup: async () => {
-        await db.destroy();
-        await client.close();
-      },
-    };
-  },
-});