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

package/src/adapters/kysely.spec.ts

@@ -1,145 +1,240 @@
+import { DatabaseSync, type SqliteValue } from "node:sqlite";
+
 import { PGlite } from "@electric-sql/pglite";
-import { Kysely } from "kysely";
+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 {
-  createBundlePatchRowFixture,
-  createBundleRowFixture,
-  createChannelRowFixture,
+  createBundleEventRowFixture,
+  createBundleFixture,
 } from "../../../test-utils/src/databaseTestFixtures";
-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 { kyselyAdapter } from "./kysely";
+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 { builtInSchema } from "../db/builtInDatabase";
+import type { ToolingDatabase } from "../db/types";
+import { createHotUpdater } from "../index";
+import { createInsightsModel, insights } from "../plugins/insights";
+import { kyselyAdapter, type SQLProvider } from "./kysely";
 
-class KyselyTestStateError extends Error {
-  readonly name = "KyselyTestStateError";
-}
+/** Every data table the migration creates; the settings rows stay. */
+const dataTables = builtInSchema.tables.flatMap((table) => [
+  table.name,
+  ...table.indexes
+    .filter((index) => isMultiIndex(table, index))
+    .map((index) => `${table.name}__${index.name}`),
+]);
 
-let client: PGlite | undefined;
-let database: Kysely<object> | undefined;
+/** 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 getClient = (): PGlite => {
-  if (client === undefined) throw new KyselyTestStateError();
-  return client;
-};
+const migrate = async (database: ToolingDatabase) =>
+  (await database.createMigrator!().migrateToLatest()).execute();
 
-const getDatabase = (): Kysely<object> => {
-  if (database === undefined) throw new KyselyTestStateError();
-  return database;
-};
+/** The Insights plugin's model over a database, on the server's tables. */
+const insightsOf = (database: ToolingDatabase) =>
+  createInsightsModel(
+    createDatabasePluginApis(database, [insights()]).insights,
+  );
 
-setupDatabasePluginTestSuite({
-  name: "kyselyAdapter PostgreSQL",
-  migrate: async () => {
-    client = new PGlite();
-    database = new Kysely<object>({ dialect: new PGliteDialect(client) });
-    await client.exec(DATABASE_PLUGIN_TEST_SCHEMA_SQL);
-  },
-  createPlugin: (): DatabaseAdapterWithCapabilities =>
-    kyselyAdapter({ db: getDatabase(), provider: "postgresql" }),
-  reset: async () => {
-    await getClient().exec(DATABASE_PLUGIN_TEST_RESET_SQL);
+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(),
+    };
   },
-  dispose: async () => {
-    await getDatabase().destroy();
-    await getClient().close();
-    database = undefined;
-    client = undefined;
+  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>;
 
-describe("kyselyAdapter SQLite JSON storage", () => {
-  it("round-trips JSON values through text columns", async () => {
-    const sqliteClient = new PGlite();
-    const sqliteDatabase = new Kysely<object>({
-      dialect: new PGliteDialect(sqliteClient),
-    });
-    await sqliteClient.exec(
-      DATABASE_PLUGIN_TEST_SCHEMA_SQL.replace(
-        "metadata jsonb not null default '{}'::jsonb",
-        "metadata text not null",
+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,
       ),
-    );
-    const plugin = kyselyAdapter({ db: sqliteDatabase, provider: "sqlite" });
-    const row = {
-      ...createBundleRowFixture("901"),
-      metadata: { app_version: "1.0.0" },
-    };
+    createInsightsModel: 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;
+    },
+  });
+}
 
-    await plugin.commit({
-      changes: [{ model: "bundles", operation: "insert", row }],
-    });
-    const stored = await sqliteClient.query<{
-      metadata: string;
-    }>("select metadata from bundles where id = $1", [row.id]);
+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(builtInSchema.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();
+    }
+  });
 
-    expect(stored.rows[0]).toEqual({
-      metadata: JSON.stringify(row.metadata),
-    });
-    await expect(plugin.models.bundles.findById(row.id)).resolves.toEqual(row);
-    await sqliteDatabase.destroy();
-    await sqliteClient.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();
+    }
   });
-});
 
-describe("kyselyAdapter soft relations", () => {
-  it("rejects an orphan patch and rolls back its owner row", async () => {
-    const softClient = new PGlite();
-    const softDatabase = new Kysely<object>({
-      dialect: new PGliteDialect(softClient),
-    });
-    await softClient.exec(
-      DATABASE_PLUGIN_TEST_SCHEMA_SQL.replaceAll(
-        " references bundles(id) on delete cascade",
-        "",
-      ),
-    );
-    const plugin = kyselyAdapter({
-      db: softDatabase,
-      provider: "postgresql",
-      relationMode: "fumadb",
-    });
-    const owner = createBundleRowFixture("952");
-    const patch = createBundlePatchRowFixture(
-      "missing-base",
-      owner.id,
-      "missing-base",
-    );
-    const channel = createChannelRowFixture();
+  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(
-        plugin.commit({
-          changes: [
-            {
-              model: "channels",
-              operation: "insert",
-              row: channel,
-              onConflict: "ignore",
+        core.deploy([
+          {
+            bundle: {
+              ...owner,
+              patches: [
+                {
+                  baseBundleId: "missing-base",
+                  baseFileHash: "base-hash",
+                  byteSize: 1,
+                  patchFileHash: "patch-hash",
+                  patchStorageUri: "storage://patches/952.patch",
+                },
+              ],
             },
-            { model: "bundles", operation: "insert", row: owner },
-            {
-              model: "bundlePatches",
-              operation: "insert",
-              row: patch,
+            release: {
+              channel: "production",
+              enabled: false,
+              fingerprintHash: null,
+              message: null,
+              shouldForceUpdate: false,
+              targetAppVersion: "*",
             },
-          ],
-        }),
-      ).rejects.toThrow("bundle_patches.base_bundle_id.foreign-key");
-      await expect(
-        plugin.models.bundles.findById(owner.id),
-      ).resolves.toBeNull();
-      await expect(plugin.models.channels.list({})).resolves.toEqual({
-        channels: [],
-      });
+          },
+        ]),
+      ).rejects.toBeInstanceOf(DatabaseConstraintError);
+      await expect(core.getBundle(owner.id)).resolves.toBeNull();
     } finally {
-      await softDatabase.destroy();
-      await softClient.close();
+      await db.destroy();
+      await close();
     }
   });
 });

package/src/adapters/kysely.ts

@@ -1,101 +1,46 @@
-import { createDatabasePlugin } from "@hot-updater/plugin-core";
-import {
-  createDatabasePluginAdapter,
-  type DatabasePluginImplementation,
-} from "@hot-updater/plugin-core/internal";
 import type { Kysely } from "kysely";
 
-import { createKyselyMigrator } from "../db/fixedMigrator";
-import type {
-  DatabaseAdapterWithCapabilities,
-  ORMSQLProvider,
-  RelationMode,
-} from "../db/types";
-import { createKyselyCrud } from "./kyselyCrud";
+import { createSqlAdapter } from "../database/sql/sqlAdapter";
+import { builtInTarget, createEngineDatabase } from "../db/builtInDatabase";
+import { createEngineSqlMigrator } from "../db/engineSqlMigrator";
+import type { ORMSQLProvider, ToolingDatabase } from "../db/types";
+import { kyselyExecutor } from "./kyselyExecutor";
+import { checkSqlProvider } from "./sqlProviders";
 
-type KyselySQLProvider = Exclude<ORMSQLProvider, "mssql">;
+export { kyselyExecutor } from "./kyselyExecutor";
 
-export type { RelationMode, KyselySQLProvider as SQLProvider };
+export type { ORMSQLProvider as SQLProvider };
 
 export interface KyselyAdapterConfig<TDatabase extends object = object> {
   readonly db: Kysely<TDatabase>;
-  readonly provider: KyselySQLProvider;
-  readonly relationMode?: RelationMode;
+  readonly provider: ORMSQLProvider;
 }
 
-const createImplementation = <TDatabase extends object>(
-  config: KyselyAdapterConfig<TDatabase>,
-): DatabasePluginImplementation => {
-  const db = config.db;
-  const relationMode = config.relationMode ?? "foreign-keys";
-  const crud = createKyselyCrud(db, config.provider, relationMode);
-  return {
-    ...crud,
-    deleteChannel: (input) =>
-      db
-        .transaction()
-        .execute((transaction) =>
-          createKyselyCrud(
-            transaction,
-            config.provider,
-            relationMode,
-          ).deleteChannel(input),
-        ),
-    create: (input) =>
-      db
-        .transaction()
-        .execute((transaction) =>
-          createKyselyCrud(transaction, config.provider, relationMode).create(
-            input,
-          ),
-        ),
-    update: (input) =>
-      db
-        .transaction()
-        .execute((transaction) =>
-          createKyselyCrud(transaction, config.provider, relationMode).update(
-            input,
-          ),
-        ),
-    delete: (input) =>
-      db
-        .transaction()
-        .execute((transaction) =>
-          createKyselyCrud(transaction, config.provider, relationMode).delete(
-            input,
-          ),
-        ),
-    transaction: (callback) =>
-      db
-        .transaction()
-        .execute((transaction) =>
-          callback(
-            createKyselyCrud(transaction, config.provider, relationMode),
-          ),
-        ),
-  };
-};
-
+/**
+ * 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>,
-): DatabaseAdapterWithCapabilities => {
-  const adapter = createDatabasePluginAdapter(
-    "kysely",
-    createImplementation<TDatabase>(config),
+): ToolingDatabase => {
+  const provider = checkSqlProvider("kyselyAdapter", config.provider);
+  const executor = kyselyExecutor(
+    config.db as unknown as Kysely<object>,
+    provider,
   );
-  const plugin = createDatabasePlugin({
-    name: "kysely",
-    models: adapter.models,
-    commit: adapter.commit,
-  });
-  return Object.assign(plugin, {
-    adapterName: "kysely",
-    provider: config.provider,
-    createMigrator: () =>
-      createKyselyMigrator({
-        db: config.db,
-        provider: config.provider,
-        relationMode: config.relationMode,
+  return {
+    ...createEngineDatabase({
+      name: "kysely",
+      adapter: createSqlAdapter({ executor }),
+    }),
+    provider,
+    createMigrator: ({ schema, settings } = builtInTarget) =>
+      createEngineSqlMigrator({
+        adapterName: "kysely",
+        executor,
+        schema,
+        settings,
       }),
-  });
+  };
 };

package/src/adapters/kyselyExecutor.ts

@@ -0,0 +1,53 @@
+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))),
+});