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

package/src/adapters/drizzle.spec.ts

@@ -1,237 +1,306 @@
+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 {
-  boolean,
-  doublePrecision,
-  integer,
-  jsonb,
-  pgTable,
-  text,
-  varchar,
-} from "drizzle-orm/pg-core";
-import { drizzle } from "drizzle-orm/pglite";
-import { describe, expect, it, vi } from "vitest";
-
-import { setupDatabasePluginTestSuite } from "../../../test-utils/src/setupDatabasePluginTestSuite";
-import type { DatabaseAdapterWithCapabilities } from "../db/types";
-import {
-  DATABASE_PLUGIN_TEST_RESET_SQL,
-  DATABASE_PLUGIN_TEST_SCHEMA_SQL,
-} from "./databasePluginTestDatabase";
-import { drizzleAdapter } from "./drizzle";
-
-const bundles = pgTable("bundles", {
-  id: text("id").primaryKey(),
-  platform: text("platform").notNull(),
-  file_hash: text("file_hash").notNull(),
-  git_commit_hash: text("git_commit_hash"),
-  storage_uri: text("storage_uri").notNull(),
-  archive_byte_size: doublePrecision("archive_byte_size").notNull(),
-  metadata: jsonb("metadata").notNull(),
-  manifest_storage_uri: text("manifest_storage_uri"),
-  manifest_file_hash: text("manifest_file_hash"),
-  asset_base_storage_uri: text("asset_base_storage_uri"),
-});
-const channels = pgTable("channels", {
-  id: text("id").primaryKey(),
-  name: text("name").notNull().unique(),
-});
-const releases = pgTable("releases", {
-  id: text("id").primaryKey(),
-  revision: integer("revision").notNull(),
-  scope_key: text("scope_key").notNull(),
-  channel_id: text("channel_id").notNull(),
-  platform: text("platform").notNull(),
-  kind: text("kind").notNull(),
-  bundle_id: text("bundle_id"),
-  strategy: text("strategy").notNull(),
-  target_app_version: text("target_app_version"),
-  fingerprint_hash: text("fingerprint_hash"),
-  enabled: boolean("enabled").notNull(),
-  should_force_update: boolean("should_force_update").notNull(),
-  message: text("message"),
-  rollout_cohort_count: integer("rollout_cohort_count").notNull(),
-  target_cohorts: jsonb("target_cohorts").notNull(),
-  operation: text("operation").notNull(),
-  source_release_id: text("source_release_id"),
-  created_at_ms: integer("created_at_ms").notNull(),
-  updated_at_ms: integer("updated_at_ms").notNull(),
-});
-const releaseCatalogs = pgTable("release_catalogs", {
-  scope_key: text("scope_key").primaryKey(),
-  catalog_id: text("catalog_id").notNull(),
-  strategy: text("strategy").notNull(),
-  channel_id: text("channel_id").notNull(),
-  channel_key: text("channel_key").notNull(),
-  platform: text("platform").notNull(),
-  fingerprint_hash: text("fingerprint_hash"),
-  generation: integer("generation").notNull(),
-  payload: text("payload").notNull(),
-  catalog_hash: text("catalog_hash").notNull(),
-  byte_size: integer("byte_size").notNull(),
-  is_tombstone: boolean("is_tombstone").notNull(),
-  updated_at_ms: integer("updated_at_ms").notNull(),
-});
-const bundlePatches = pgTable("bundle_patches", {
-  id: varchar("id", { length: 255 }).primaryKey(),
-  bundle_id: text("bundle_id").notNull(),
-  base_bundle_id: text("base_bundle_id").notNull(),
-  base_file_hash: text("base_file_hash").notNull(),
-  patch_file_hash: text("patch_file_hash").notNull(),
-  patch_storage_uri: text("patch_storage_uri").notNull(),
-  byte_size: doublePrecision("byte_size").notNull(),
-  order_index: integer("order_index").notNull(),
-});
-const bundleEvents = pgTable("bundle_events", {
-  id: text("id").primaryKey(),
-  type: text("type").notNull(),
-  install_id: text("install_id").notNull(),
-  user_id: text("user_id"),
-  username: text("username"),
-  from_release_id: text("from_release_id"),
-  from_bundle_id: text("from_bundle_id"),
-  to_release_id: text("to_release_id"),
-  to_bundle_id: text("to_bundle_id").notNull(),
-  platform: text("platform").notNull(),
-  app_version: text("app_version").notNull(),
-  channel: text("channel").notNull(),
-  cohort: text("cohort").notNull(),
-  update_strategy: text("update_strategy"),
-  fingerprint_hash: text("fingerprint_hash"),
-  sdk_version: text("sdk_version"),
-  received_at_ms: integer("received_at_ms").notNull(),
-});
-const apiKeys = pgTable("api_keys", {
-  id: text("id").primaryKey(),
-  hash: text("hash").notNull().unique(),
-  name: text("name").notNull(),
-  prefix: text("prefix").notNull(),
-  role: text("role").notNull(),
-  created_at_ms: integer("created_at_ms").notNull(),
-  revoked_at_ms: integer("revoked_at_ms"),
-});
-const schema = {
-  bundle_events: bundleEvents,
-  bundle_patches: bundlePatches,
-  bundles,
-  channels,
-  api_keys: apiKeys,
-  release_catalogs: releaseCatalogs,
-  releases,
-};
+  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";
 
-class DrizzleTestStateError extends Error {
-  readonly name = "DrizzleTestStateError";
-}
+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 { builtInSchema, builtInSettings } from "../db/builtInDatabase";
+import { generateEngineSql } from "../db/engineSql";
+import type { ToolingDatabase } from "../db/types";
+import { createHotUpdater } from "../index";
+import { createInsightsModel, insights } from "../plugins/insights";
+import {
+  drizzleAdapter,
+  DrizzleTransactionUnsupportedError,
+  type DrizzleProvider,
+} from "./drizzle";
+import { drizzleExecutor } from "./drizzleExecutor";
 
-let client: PGlite | undefined;
-let database: ReturnType<typeof drizzle<typeof schema>> | undefined;
+/** Every data table; the settings rows stay across tests. */
+const dataTables = builtInSchema.tables.flatMap((table) => [
+  table.name,
+  ...table.indexes
+    .filter((index) => isMultiIndex(table, index))
+    .map((index) => `${table.name}__${index.name}`),
+]);
 
-const getClient = (): PGlite => {
-  if (client === undefined) throw new DrizzleTestStateError();
+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 getDatabase = (): ReturnType<typeof drizzle<typeof schema>> => {
-  if (database === undefined) throw new DrizzleTestStateError();
-  return database;
-};
+const engineSql = (dialect: "postgresql" | "sqlite") =>
+  generateEngineSql(dialect, builtInSchema, builtInSettings);
 
-setupDatabasePluginTestSuite({
-  name: "drizzleAdapter PostgreSQL",
-  migrate: async () => {
-    client = new PGlite();
-    await client.exec(DATABASE_PLUGIN_TEST_SCHEMA_SQL);
-    database = drizzle(client, { schema });
-  },
-  createPlugin: (): DatabaseAdapterWithCapabilities =>
-    drizzleAdapter({ db: getDatabase(), provider: "postgresql" }),
-  reset: async () => {
-    await getClient().exec(DATABASE_PLUGIN_TEST_RESET_SQL);
+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(),
+    };
   },
-  dispose: async () => {
-    await getClient().close();
-    database = undefined;
-    client = undefined;
+  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;
 
-describe("drizzleAdapter schema requirements", () => {
-  it("does not resolve a lazy database while generating a schema", () => {
-    const getDB = vi.fn(() => {
-      throw new DrizzleTestStateError();
-    });
-    const plugin = drizzleAdapter({
-      db: getDB,
-      provider: "postgresql",
-      schema,
-    });
-
-    const generated = plugin.generateSchema?.("latest");
-
-    expect(generated?.code).toContain("pgTable");
-    expect(getDB).not.toHaveBeenCalled();
+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,
+      ),
+    createInsightsModel: (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(),
   });
+}
 
-  it("resolves a lazy database on the first database operation", async () => {
-    const lazyClient = new PGlite();
-    await lazyClient.exec(DATABASE_PLUGIN_TEST_SCHEMA_SQL);
-    const lazyDatabase = drizzle(lazyClient, { schema });
-    const getDB = vi.fn(async () => lazyDatabase);
-    const plugin = drizzleAdapter({
-      db: getDB,
-      provider: "postgresql",
-      schema,
-    });
+/** 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);
+    },
+  };
+};
 
-    try {
-      expect(getDB).not.toHaveBeenCalled();
-      await expect(plugin.models.channels.list({})).resolves.toEqual({
-        channels: [],
-      });
-      expect(getDB).toHaveBeenCalledOnce();
-    } finally {
-      await lazyClient.close();
-    }
-  });
+const policy = {
+  channel: "production",
+  enabled: true,
+  fingerprintHash: null,
+  message: null,
+  shouldForceUpdate: false,
+  targetAppVersion: "1.0.0",
+};
 
-  it("rejects a lazy database without a schema on first use", () => {
-    const getDB = vi.fn(() => {
-      throw new DrizzleTestStateError();
-    });
-    const plugin = drizzleAdapter({ db: getDB, provider: "postgresql" });
+/** 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! };
+};
 
-    expect(() => plugin.models.channels.list({})).toThrow(
-      "[hot-updater] Drizzle adapter requires schema when db is lazy.",
+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 },
+      ]),
     );
-    expect(getDB).not.toHaveBeenCalled();
+    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("rejects an invalid lazy database schema on first use", () => {
-    const getDB = vi.fn(() => {
-      throw new DrizzleTestStateError();
-    });
-    const plugin = drizzleAdapter({
-      db: getDB,
+  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",
-      schema: { ...schema, bundles: null },
     });
-
-    expect(() => plugin.models.channels.list({})).toThrow(
-      '[hot-updater] Drizzle schema table "bundles" is invalid.',
-    );
-    expect(getDB).not.toHaveBeenCalled();
+    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("requires all fixed table objects on first use", () => {
-    const incompleteSchema = { bundles };
-    const plugin = drizzleAdapter({
-      db: () => getDatabase(),
-      provider: "postgresql",
-      schema: incompleteSchema,
+  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>;
+  };
 
-    expect(() => plugin.models.channels.list({})).toThrow(
-      'Drizzle schema is missing table "bundle_patches".',
+  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();
   });
 });