@hot-updater/server 0.36.7 → 1.0.0-rc.0

package/src/adapters/kysely.spec.ts

@@ -1,107 +1,145 @@
 import { PGlite } from "@electric-sql/pglite";
-import type { Bundle } from "@hot-updater/core";
 import { Kysely } from "kysely";
 import { PGliteDialect } from "kysely-pglite-dialect";
-import { afterEach, describe, expect, it } from "vitest";
+import { describe, expect, it } from "vitest";
 
-import { createHotUpdater } from "../index";
 import {
-  HOT_UPDATER_SCHEMA_VERSION,
-  HOT_UPDATER_SETTINGS_TABLE,
-} from "../schema/types";
+  createBundlePatchRowFixture,
+  createBundleRowFixture,
+  createChannelRowFixture,
+} 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";
 
-const sqliteJsonBundle: Bundle = {
-  id: "00000000-0000-0000-0000-000000000901",
-  platform: "ios",
-  shouldForceUpdate: false,
-  enabled: true,
-  fileHash: "sqlite-json-hash",
-  gitCommitHash: null,
-  message: "sqlite json bundle",
-  channel: "production",
-  storageUri: "s3://bucket/sqlite-json.zip",
-  targetAppVersion: "1.0.0",
-  fingerprintHash: null,
-  metadata: { app_version: "1.0.0" },
-  targetCohorts: ["17", "qa-group"],
+class KyselyTestStateError extends Error {
+  readonly name = "KyselyTestStateError";
+}
+
+let client: PGlite | undefined;
+let database: Kysely<object> | undefined;
+
+const getClient = (): PGlite => {
+  if (client === undefined) throw new KyselyTestStateError();
+  return client;
 };
 
-describe("kyselyAdapter sqlite provider", () => {
-  const databases: PGlite[] = [];
-  const kyselyInstances: Kysely<object>[] = [];
+const getDatabase = (): Kysely<object> => {
+  if (database === undefined) throw new KyselyTestStateError();
+  return database;
+};
 
-  afterEach(async () => {
-    for (const kysely of kyselyInstances.splice(0)) {
-      await kysely.destroy();
-    }
-    for (const db of databases.splice(0)) {
-      await db.close();
-    }
-  });
+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);
+  },
+  dispose: async () => {
+    await getDatabase().destroy();
+    await getClient().close();
+    database = undefined;
+    client = undefined;
+  },
+});
 
-  it("stores bundle JSON columns as text and round-trips them", async () => {
-    const db = new PGlite();
-    databases.push(db);
-    const kysely = new Kysely<object>({ dialect: new PGliteDialect(db) });
-    kyselyInstances.push(kysely);
-    await db.exec(`
-      create table bundles (
-        id text primary key,
-        platform text not null,
-        should_force_update boolean not null,
-        enabled boolean not null,
-        file_hash text not null,
-        git_commit_hash text,
-        message text,
-        channel text not null,
-        storage_uri text not null,
-        target_app_version text,
-        fingerprint_hash text,
-        metadata text not null,
-        manifest_storage_uri text,
-        manifest_file_hash text,
-        asset_base_storage_uri text,
-        rollout_cohort_count integer not null,
-        target_cohorts text
-      );
-      create table bundle_patches (
-        id text primary key,
-        bundle_id text not null,
-        base_bundle_id text not null,
-        base_file_hash text not null,
-        patch_file_hash text not null,
-        patch_storage_uri text not null,
-        order_index integer not null
-      );
-      create table ${HOT_UPDATER_SETTINGS_TABLE} (
-        key text primary key,
-        value text not null
-      );
-      insert into ${HOT_UPDATER_SETTINGS_TABLE} (key, value)
-      values ('version', '${HOT_UPDATER_SCHEMA_VERSION}');
-    `);
-    const hotUpdater = createHotUpdater({
-      database: kyselyAdapter({
-        db: kysely,
-        provider: "sqlite",
-      }),
+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",
+      ),
+    );
+    const plugin = kyselyAdapter({ db: sqliteDatabase, provider: "sqlite" });
+    const row = {
+      ...createBundleRowFixture("901"),
+      metadata: { app_version: "1.0.0" },
+    };
 
-    await hotUpdater.insertBundle(sqliteJsonBundle);
-    const stored = await db.query<{
+    await plugin.commit({
+      changes: [{ model: "bundles", operation: "insert", row }],
+    });
+    const stored = await sqliteClient.query<{
       metadata: string;
-      target_cohorts: string;
-    }>("select metadata, target_cohorts from bundles where id = $1", [
-      sqliteJsonBundle.id,
-    ]);
-    const restored = await hotUpdater.getBundleById(sqliteJsonBundle.id);
+    }>("select metadata from bundles where id = $1", [row.id]);
 
     expect(stored.rows[0]).toEqual({
-      metadata: JSON.stringify({ app_version: "1.0.0" }),
-      target_cohorts: JSON.stringify(["17", "qa-group"]),
+      metadata: JSON.stringify(row.metadata),
+    });
+    await expect(plugin.models.bundles.findById(row.id)).resolves.toEqual(row);
+    await sqliteDatabase.destroy();
+    await sqliteClient.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",
     });
-    expect(restored?.metadata).toEqual({ app_version: "1.0.0" });
-    expect(restored?.targetCohorts).toEqual(["17", "qa-group"]);
+    const owner = createBundleRowFixture("952");
+    const patch = createBundlePatchRowFixture(
+      "missing-base",
+      owner.id,
+      "missing-base",
+    );
+    const channel = createChannelRowFixture();
+
+    try {
+      await expect(
+        plugin.commit({
+          changes: [
+            {
+              model: "channels",
+              operation: "insert",
+              row: channel,
+              onConflict: "ignore",
+            },
+            { model: "bundles", operation: "insert", row: owner },
+            {
+              model: "bundlePatches",
+              operation: "insert",
+              row: patch,
+            },
+          ],
+        }),
+      ).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: [],
+      });
+    } finally {
+      await softDatabase.destroy();
+      await softClient.close();
+    }
   });
 });

package/src/adapters/kysely.ts

@@ -1,359 +1,101 @@
-import { NIL_UUID } from "@hot-updater/core";
-import type {
-  Bundle,
-  DatabaseBundleQueryOptions,
-  DatabaseBundleQueryWhere,
-} from "@hot-updater/plugin-core";
+import { createDatabasePlugin } from "@hot-updater/plugin-core";
 import {
-  calculatePagination,
-  createDatabasePlugin,
-  filterCompatibleAppVersions,
-  resolveUpdateInfoFromBundles,
-} from "@hot-updater/plugin-core";
-import type { Kysely, Transaction } from "kysely";
+  createDatabasePluginAdapter,
+  type DatabasePluginImplementation,
+} from "@hot-updater/plugin-core/internal";
+import type { Kysely } from "kysely";
 
-import {
-  bundleToPatchRows,
-  bundleToRow,
-  type BundlePatchRow,
-  type BundleRow,
-  rowToBundle,
-} from "../db/bundleRows";
 import { createKyselyMigrator } from "../db/fixedMigrator";
 import type {
-  DatabasePluginFactory,
+  DatabaseAdapterWithCapabilities,
   ORMSQLProvider,
   RelationMode,
 } from "../db/types";
+import { createKyselyCrud } from "./kyselyCrud";
 
 type KyselySQLProvider = Exclude<ORMSQLProvider, "mssql">;
 
 export type { RelationMode, KyselySQLProvider as SQLProvider };
 
-interface Database {
-  readonly bundles: BundleRow;
-  readonly bundle_patches: BundlePatchRow;
-  readonly private_hot_updater_settings: {
-    readonly key: string;
-    readonly value: string;
-  };
-}
-
-export interface KyselyAdapterConfig<TDatabase extends object = Database> {
+export interface KyselyAdapterConfig<TDatabase extends object = object> {
   readonly db: Kysely<TDatabase>;
   readonly provider: KyselySQLProvider;
   readonly relationMode?: RelationMode;
 }
 
-const assertKyselySQLProvider: (
-  provider: ORMSQLProvider,
-) => asserts provider is KyselySQLProvider = (provider) => {
-  if (provider === "mssql") {
-    throw new Error("Kysely adapter does not support provider: mssql.");
-  }
-};
-
-const applyWhere = <T extends object>(
-  query: T,
-  where: DatabaseBundleQueryWhere | undefined,
-): T => {
-  let next = query as {
-    where: (column: string, op: string, value?: unknown) => unknown;
-  };
-  if (where?.channel !== undefined)
-    next = next.where("channel", "=", where.channel) as typeof next;
-  if (where?.platform !== undefined)
-    next = next.where("platform", "=", where.platform) as typeof next;
-  if (where?.enabled !== undefined)
-    next = next.where("enabled", "=", where.enabled) as typeof next;
-  if (where?.fingerprintHash !== undefined) {
-    next =
-      where.fingerprintHash === null
-        ? (next.where("fingerprint_hash", "is", null) as typeof next)
-        : (next.where(
-            "fingerprint_hash",
-            "=",
-            where.fingerprintHash,
-          ) as typeof next);
-  }
-  if (where?.targetAppVersion !== undefined) {
-    next =
-      where.targetAppVersion === null
-        ? (next.where("target_app_version", "is", null) as typeof next)
-        : (next.where(
-            "target_app_version",
-            "=",
-            where.targetAppVersion,
-          ) as typeof next);
-  }
-  if (where?.targetAppVersionIn) {
-    next = next.where(
-      "target_app_version",
-      "in",
-      where.targetAppVersionIn,
-    ) as typeof next;
-  }
-  if (where?.targetAppVersionNotNull) {
-    next = next.where("target_app_version", "is not", null) as typeof next;
-  }
-  if (where?.id?.eq) next = next.where("id", "=", where.id.eq) as typeof next;
-  if (where?.id?.gt) next = next.where("id", ">", where.id.gt) as typeof next;
-  if (where?.id?.gte)
-    next = next.where("id", ">=", where.id.gte) as typeof next;
-  if (where?.id?.lt) next = next.where("id", "<", where.id.lt) as typeof next;
-  if (where?.id?.lte)
-    next = next.where("id", "<=", where.id.lte) as typeof next;
-  if (where?.id?.in) next = next.where("id", "in", where.id.in) as typeof next;
-  return next as T;
-};
-
-const hasEmptySetFilter = (
-  where: DatabaseBundleQueryWhere | undefined,
-): boolean =>
-  where?.targetAppVersionIn?.length === 0 || where?.id?.in?.length === 0;
-
-const toProviderBundleRow = (
-  row: BundleRow,
-  provider: KyselySQLProvider,
-): BundleRow => {
-  if (provider !== "mysql" && provider !== "sqlite") return row;
+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 {
-    ...row,
-    metadata: JSON.stringify(row.metadata ?? {}),
-    target_cohorts:
-      row.target_cohorts === null || row.target_cohorts === undefined
-        ? null
-        : JSON.stringify(row.target_cohorts),
+    ...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),
+          ),
+        ),
   };
 };
 
-const createKyselyPlugin = createDatabasePlugin<KyselyAdapterConfig<Database>>({
-  name: "kysely",
-  factory: ({ db, provider }) => {
-    const fetchPatchMap = async (bundleIds: readonly string[]) => {
-      const patchMap = new Map<string, BundlePatchRow[]>();
-      if (bundleIds.length === 0) return patchMap;
-      const rows = await db
-        .selectFrom("bundle_patches")
-        .selectAll()
-        .where("bundle_id", "in", [...bundleIds])
-        .orderBy("order_index", "asc")
-        .execute();
-      for (const row of rows) {
-        const current = patchMap.get(row.bundle_id) ?? [];
-        current.push(row);
-        patchMap.set(row.bundle_id, current);
-      }
-      return patchMap;
-    };
-    const mapRowsToBundles = async (
-      rows: readonly BundleRow[],
-    ): Promise<Bundle[]> => {
-      const patchMap = await fetchPatchMap(rows.map((row) => row.id));
-      return rows.map((row) => rowToBundle(row, patchMap.get(row.id) ?? []));
-    };
-
-    const upsertBundle = async (
-      executor: Kysely<Database> | Transaction<Database>,
-      bundle: Bundle,
-    ) => {
-      const row = toProviderBundleRow(bundleToRow(bundle), provider);
-      const { id: _id, ...updateRow } = row;
-      if (provider === "mysql") {
-        await executor
-          .insertInto("bundles")
-          .values(row)
-          .onDuplicateKeyUpdate(updateRow)
-          .execute();
-      } else {
-        await executor
-          .insertInto("bundles")
-          .values(row)
-          .onConflict((oc) => oc.column("id").doUpdateSet(updateRow))
-          .execute();
-      }
-      await executor
-        .deleteFrom("bundle_patches")
-        .where("bundle_id", "=", bundle.id)
-        .execute();
-      const patches = bundleToPatchRows(bundle);
-      if (patches.length > 0) {
-        await executor.insertInto("bundle_patches").values(patches).execute();
-      }
-    };
-
-    return {
-      async getBundleById(bundleId) {
-        const row = await db
-          .selectFrom("bundles")
-          .selectAll()
-          .where("id", "=", bundleId)
-          .executeTakeFirst();
-        if (!row) return null;
-        const patchMap = await fetchPatchMap([bundleId]);
-        return rowToBundle(row, patchMap.get(bundleId) ?? []);
-      },
-      async getBundles(
-        options: DatabaseBundleQueryOptions & { offset?: number },
-      ) {
-        const offset = options.offset ?? 0;
-        if (hasEmptySetFilter(options.where)) {
-          return {
-            data: [],
-            pagination: calculatePagination(0, {
-              limit: options.limit,
-              offset,
-            }),
-          };
-        }
-        const orderBy = options.orderBy ?? { field: "id", direction: "desc" };
-        const countRow = await applyWhere(
-          db.selectFrom("bundles"),
-          options.where,
-        )
-          .select(db.fn.count<number>("id").as("total"))
-          .executeTakeFirst();
-        const total = Number(countRow?.total ?? 0);
-        const rows = await applyWhere(
-          db.selectFrom("bundles").selectAll(),
-          options.where,
-        )
-          .orderBy("id", orderBy.direction)
-          .limit(options.limit)
-          .offset(offset)
-          .execute();
-        const patchMap = await fetchPatchMap(rows.map((row) => row.id));
-        return {
-          data: rows.map((row) => rowToBundle(row, patchMap.get(row.id) ?? [])),
-          pagination: calculatePagination(total, {
-            limit: options.limit,
-            offset,
-          }),
-        };
-      },
-      async getUpdateInfo(args, context) {
-        if (args._updateStrategy === "appVersion") {
-          const channel = args.channel ?? "production";
-          const minBundleId = args.minBundleId ?? NIL_UUID;
-          const rows = await db
-            .selectFrom("bundles")
-            .select("target_app_version")
-            .where("enabled", "=", true)
-            .where("platform", "=", args.platform)
-            .where("channel", "=", channel)
-            .where("id", ">=", minBundleId)
-            .where("target_app_version", "is not", null)
-            .execute();
-
-          const targetAppVersions = Array.from(
-            new Set(
-              rows
-                .map((row) => row.target_app_version)
-                .filter(
-                  (value): value is string =>
-                    typeof value === "string" && value.length > 0,
-                ),
-            ),
-          );
-          const compatibleAppVersions = filterCompatibleAppVersions(
-            targetAppVersions,
-            args.appVersion,
-          );
-          const bundles =
-            compatibleAppVersions.length > 0
-              ? await db
-                  .selectFrom("bundles")
-                  .selectAll()
-                  .where("enabled", "=", true)
-                  .where("platform", "=", args.platform)
-                  .where("channel", "=", channel)
-                  .where("id", ">=", minBundleId)
-                  .where("target_app_version", "in", compatibleAppVersions)
-                  .orderBy("id", "desc")
-                  .execute()
-                  .then(mapRowsToBundles)
-              : [];
-
-          return resolveUpdateInfoFromBundles({
-            args: { ...args, channel, minBundleId },
-            bundles,
-            context,
-          });
-        }
-
-        const channel = args.channel ?? "production";
-        const minBundleId = args.minBundleId ?? NIL_UUID;
-        const rows = await db
-          .selectFrom("bundles")
-          .selectAll()
-          .where("enabled", "=", true)
-          .where("platform", "=", args.platform)
-          .where("channel", "=", channel)
-          .where("id", ">=", minBundleId)
-          .where("fingerprint_hash", "=", args.fingerprintHash)
-          .orderBy("id", "desc")
-          .execute();
-
-        return resolveUpdateInfoFromBundles({
-          args: { ...args, channel, minBundleId },
-          bundles: await mapRowsToBundles(rows),
-          context,
-        });
-      },
-      async getChannels() {
-        const rows = await db
-          .selectFrom("bundles")
-          .select("channel")
-          .orderBy("channel", "asc")
-          .execute();
-        return Array.from(new Set(rows.map((row) => row.channel)));
-      },
-      async commitBundle({ changedSets }) {
-        await db.transaction().execute(async (tx) => {
-          for (const change of changedSets) {
-            if (change.operation === "delete") {
-              await tx
-                .deleteFrom("bundle_patches")
-                .where("bundle_id", "=", change.data.id)
-                .execute();
-              await tx
-                .deleteFrom("bundle_patches")
-                .where("base_bundle_id", "=", change.data.id)
-                .execute();
-              await tx
-                .deleteFrom("bundles")
-                .where("id", "=", change.data.id)
-                .execute();
-              continue;
-            }
-            await upsertBundle(tx, change.data);
-          }
-        });
-      },
-    };
-  },
-});
-
 export const kyselyAdapter = <TDatabase extends object>(
   config: KyselyAdapterConfig<TDatabase>,
-): DatabasePluginFactory => {
-  assertKyselySQLProvider(config.provider);
-  return Object.assign(
-    createKyselyPlugin(config as unknown as KyselyAdapterConfig<Database>),
-    {
-      adapterName: "kysely",
-      provider: config.provider,
-      createMigrator: () =>
-        createKyselyMigrator({
-          db: config.db as unknown as Kysely<{
-            private_hot_updater_settings: {
-              key: string;
-              value: string;
-            };
-          }>,
-          provider: config.provider,
-          relationMode: config.relationMode,
-        }),
-    },
+): DatabaseAdapterWithCapabilities => {
+  const adapter = createDatabasePluginAdapter(
+    "kysely",
+    createImplementation<TDatabase>(config),
   );
+  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,
+      }),
+  });
 };