@hot-updater/server 0.33.2 → 0.34.0

package/src/adapters/drizzleLazyDB.ts

@@ -0,0 +1,151 @@
+import type { DrizzleConfig } from "./drizzle";
+
+export type DrizzleTable = Record<string, unknown>;
+
+export type DrizzleDB = {
+  readonly _: { readonly fullSchema: Record<string, DrizzleTable> };
+  readonly $count: (table: DrizzleTable, where?: unknown) => Promise<number>;
+  readonly delete: (table: DrizzleTable) => {
+    where: (condition: unknown) => Promise<unknown>;
+  };
+  readonly insert: (table: DrizzleTable) => {
+    values: (value: unknown) => {
+      onConflictDoUpdate?: (args: unknown) => Promise<unknown>;
+      onDuplicateKeyUpdate?: (args: unknown) => Promise<unknown>;
+      execute?: () => Promise<unknown>;
+    };
+  };
+  readonly query: Record<
+    string,
+    {
+      findFirst: (
+        args?: unknown,
+      ) => Promise<Record<string, unknown> | undefined>;
+      findMany: (args?: unknown) => Promise<Record<string, unknown>[]>;
+    }
+  >;
+  readonly select: (fields?: unknown) => {
+    from: (table: DrizzleTable) => {
+      where?: (condition: unknown) => unknown;
+      orderBy?: (order: unknown) => unknown;
+      limit?: (limit: number) => unknown;
+      offset?: (offset: number) => Promise<Record<string, unknown>[]>;
+    };
+  };
+  readonly update: (table: DrizzleTable) => {
+    set: (values: unknown) => {
+      where: (condition: unknown) => Promise<unknown>;
+    };
+  };
+  readonly transaction?: <T>(
+    operation: (tx: DrizzleDB) => Promise<T>,
+  ) => Promise<T>;
+};
+
+const asDB = (db: unknown): DrizzleDB => {
+  const typed = db as DrizzleDB;
+  if (!typed._?.fullSchema) {
+    throw new Error(
+      "[hot-updater] Drizzle adapter requires query mode with schema.",
+    );
+  }
+  return typed;
+};
+
+const isDBFactory = (
+  db: DrizzleConfig["db"],
+): db is () => unknown | Promise<unknown> => typeof db === "function";
+
+export const createLazyDB = (config: DrizzleConfig): DrizzleDB => {
+  const dbSource = config.db;
+  if (!isDBFactory(dbSource)) return asDB(dbSource);
+
+  if (!config.schema) {
+    throw new Error(
+      "[hot-updater] Drizzle adapter requires schema when db is lazy.",
+    );
+  }
+
+  let resolvedDB: Promise<DrizzleDB> | undefined;
+  const getDB = async () => {
+    resolvedDB ??= Promise.resolve(dbSource()).then(asDB);
+    return resolvedDB;
+  };
+  const fullSchema = config.schema as Record<string, DrizzleTable>;
+  const runInserted = async (
+    table: DrizzleTable,
+    value: unknown,
+    operation: (
+      inserted: ReturnType<ReturnType<DrizzleDB["insert"]>["values"]>,
+    ) => Promise<unknown> | unknown,
+  ) => {
+    const db = await getDB();
+    return operation(db.insert(table).values(value));
+  };
+
+  return {
+    _: { fullSchema },
+    $count: async (table, where) => (await getDB()).$count(table, where),
+    delete: (table) => ({
+      where: async (condition) =>
+        (await getDB()).delete(table).where(condition),
+    }),
+    insert: (table) => ({
+      values: (value) => ({
+        execute: async () =>
+          runInserted(table, value, async (inserted) => {
+            if (typeof inserted.execute === "function") {
+              return inserted.execute();
+            }
+            return inserted;
+          }),
+        onConflictDoUpdate: async (args) =>
+          runInserted(table, value, async (inserted) => {
+            if (typeof inserted.onConflictDoUpdate !== "function") {
+              throw new Error(
+                "[hot-updater] Drizzle insert does not support onConflictDoUpdate.",
+              );
+            }
+            return inserted.onConflictDoUpdate(args);
+          }),
+        onDuplicateKeyUpdate: async (args) =>
+          runInserted(table, value, async (inserted) => {
+            if (typeof inserted.onDuplicateKeyUpdate !== "function") {
+              throw new Error(
+                "[hot-updater] Drizzle insert does not support onDuplicateKeyUpdate.",
+              );
+            }
+            return inserted.onDuplicateKeyUpdate(args);
+          }),
+      }),
+    }),
+    query: new Proxy(
+      {},
+      {
+        get: (_target, tableName) => ({
+          findFirst: async (args?: unknown) =>
+            (await getDB()).query[String(tableName)]?.findFirst(args),
+          findMany: async (args?: unknown) =>
+            (await getDB()).query[String(tableName)]?.findMany(args) ?? [],
+        }),
+      },
+    ) as DrizzleDB["query"],
+    select: (fields) => ({
+      from: (table) => ({
+        offset: async (offset) =>
+          (await getDB()).select(fields).from(table).offset?.(offset) ?? [],
+      }),
+    }),
+    update: (table) => ({
+      set: (values) => ({
+        where: async (condition) =>
+          (await getDB()).update(table).set(values).where(condition),
+      }),
+    }),
+    transaction: async (operation) => {
+      const db = await getDB();
+      if (typeof db.transaction !== "function") return operation(db);
+      return db.transaction(operation);
+    },
+  };
+};

package/src/adapters/kysely.spec.ts

@@ -0,0 +1,107 @@
+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 { createHotUpdater } from "../db";
+import {
+  HOT_UPDATER_SCHEMA_VERSION,
+  HOT_UPDATER_SETTINGS_TABLE,
+} from "../schema/types";
+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"],
+};
+
+describe("kyselyAdapter sqlite provider", () => {
+  const databases: PGlite[] = [];
+  const kyselyInstances: Kysely<object>[] = [];
+
+  afterEach(async () => {
+    for (const kysely of kyselyInstances.splice(0)) {
+      await kysely.destroy();
+    }
+    for (const db of databases.splice(0)) {
+      await db.close();
+    }
+  });
+
+  it("stores bundle JSON columns as text and round-trips them", async () => {
+    const db = new PGlite();
+    databases.push(db);
+    const kysely = new Kysely({ 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",
+      }),
+    });
+
+    await hotUpdater.insertBundle(sqliteJsonBundle);
+    const stored = await db.query<{
+      metadata: string;
+      target_cohorts: string;
+    }>("select metadata, target_cohorts from bundles where id = $1", [
+      sqliteJsonBundle.id,
+    ]);
+    const restored = await hotUpdater.getBundleById(sqliteJsonBundle.id);
+
+    expect(stored.rows[0]).toEqual({
+      metadata: JSON.stringify({ app_version: "1.0.0" }),
+      target_cohorts: JSON.stringify(["17", "qa-group"]),
+    });
+    expect(restored?.metadata).toEqual({ app_version: "1.0.0" });
+    expect(restored?.targetCohorts).toEqual(["17", "qa-group"]);
+  });
+});

package/src/adapters/kysely.ts

@@ -1,24 +1,359 @@
-import { kyselyAdapter as fumadbKyselyAdapter } from "fumadb/adapters/kysely";
+import { NIL_UUID } from "@hot-updater/core";
+import type {
+  Bundle,
+  DatabaseBundleQueryOptions,
+  DatabaseBundleQueryWhere,
+} from "@hot-updater/plugin-core";
+import {
+  calculatePagination,
+  createDatabasePlugin,
+  filterCompatibleAppVersions,
+  resolveUpdateInfoFromBundles,
+} from "@hot-updater/plugin-core";
+import type { Kysely, Transaction } from "kysely";
 
-import type { ORMDatabaseAdapter } from "../db/types";
+import {
+  bundleToPatchRows,
+  bundleToRow,
+  type BundlePatchRow,
+  type BundleRow,
+  rowToBundle,
+} from "../db/bundleRows";
+import { createKyselyMigrator } from "../db/fixedMigrator";
+import type {
+  DatabasePluginFactory,
+  ORMSQLProvider,
+  RelationMode,
+} from "../db/types";
 
-export type RelationMode = import("fumadb").RelationMode;
-export type SQLProvider = import("fumadb").SQLProvider;
+type KyselySQLProvider = Exclude<ORMSQLProvider, "mssql">;
 
-export interface KyselyConfig<TDatabase extends object = object> {
-  db: TDatabase;
-  provider: SQLProvider;
-  relationMode?: RelationMode;
+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> {
+  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;
+  return {
+    ...row,
+    metadata: JSON.stringify(row.metadata ?? {}),
+    target_cohorts:
+      row.target_cohorts === null || row.target_cohorts === undefined
+        ? null
+        : JSON.stringify(row.target_cohorts),
+  };
+};
+
+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: KyselyConfig<TDatabase>,
-): ORMDatabaseAdapter =>
-  Object.assign(
-    fumadbKyselyAdapter(
-      config as unknown as Parameters<typeof fumadbKyselyAdapter>[0],
-    ) as unknown as ORMDatabaseAdapter,
+  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,
+        }),
     },
   );
+};