@hot-updater/server 0.33.2 → 0.35.0

package/src/adapters/drizzle.spec.ts

@@ -0,0 +1,76 @@
+import { describe, expect, it, vi } from "vitest";
+
+import { generateSchema } from "../db";
+import { createHotUpdater } from "../index";
+import { drizzleAdapter } from "./drizzle";
+
+describe("drizzleAdapter", () => {
+  it("generates schema without resolving a lazy runtime database", () => {
+    const getDB = vi.fn(() => {
+      throw new Error("runtime database should not be opened");
+    });
+
+    const hotUpdater = createHotUpdater({
+      database: drizzleAdapter({
+        db: getDB,
+        provider: "postgresql",
+      }),
+    });
+
+    const schema = generateSchema(hotUpdater, "latest");
+
+    expect(schema.path).toBe("hot-updater-schema.ts");
+    expect(schema.code).toContain("pgTable");
+    expect(getDB).not.toHaveBeenCalled();
+  });
+
+  it("resolves a lazy runtime database only when a database operation runs", async () => {
+    const bundles = { channel: "channel" };
+    const bundlePatches = { bundle_id: "bundle_id" };
+    const db = {
+      _: { fullSchema: { bundle_patches: bundlePatches, bundles } },
+      $count: vi.fn(),
+      delete: vi.fn(),
+      insert: vi.fn(),
+      query: {
+        bundle_patches: {
+          findMany: vi.fn(),
+        },
+        bundles: {
+          findFirst: vi.fn(),
+          findMany: vi.fn(async () => [{ channel: "production" }]),
+        },
+      },
+      select: vi.fn(),
+      update: vi.fn(),
+    };
+    const getDB = vi.fn(async () => db);
+
+    const plugin = drizzleAdapter({
+      db: getDB,
+      provider: "postgresql",
+      schema: { bundle_patches: bundlePatches, bundles },
+    })();
+
+    expect(getDB).not.toHaveBeenCalled();
+
+    await expect(plugin.getChannels()).resolves.toEqual(["production"]);
+    expect(getDB).toHaveBeenCalledOnce();
+  });
+
+  it("requires schema for lazy runtime database configs", async () => {
+    const getDB = vi.fn(() => {
+      throw new Error("runtime database should not be opened");
+    });
+
+    const plugin = drizzleAdapter({
+      db: getDB,
+      provider: "postgresql",
+    })();
+
+    await expect(plugin.getChannels()).rejects.toThrow(
+      "[hot-updater] Drizzle adapter requires schema when db is lazy.",
+    );
+    expect(getDB).not.toHaveBeenCalled();
+  });
+});

package/src/adapters/drizzle.ts

@@ -1,15 +1,331 @@
-import { drizzleAdapter as fumadbDrizzleAdapter } from "fumadb/adapters/drizzle";
+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 {
+  and,
+  asc,
+  desc,
+  eq,
+  gt,
+  gte,
+  inArray,
+  isNotNull,
+  isNull,
+  lt,
+  lte,
+} from "drizzle-orm";
+import type { SQLWrapper } from "drizzle-orm";
 
-import type { ORMDatabaseAdapter } from "../db/types";
+import {
+  bundleToPatchRows,
+  bundleToRow,
+  type BundlePatchRow,
+  type BundleRow,
+  rowToBundle,
+} from "../db/bundleRows";
+import {
+  getHotUpdaterSchemaVersion,
+  hotUpdaterSchema,
+} from "../db/schema/registry";
+import { generateDrizzleSchema } from "../db/schemaGenerators";
+import type {
+  DatabasePluginFactory,
+  ORMProvider,
+  ORMSQLProvider,
+  SchemaGenerator,
+} from "../db/types";
+import {
+  createLazyDB,
+  type DrizzleDB,
+  type DrizzleTable,
+} from "./drizzleLazyDB";
 
-export type DrizzleConfig = Parameters<typeof fumadbDrizzleAdapter>[0];
+export interface DrizzleConfig {
+  readonly db: unknown | (() => unknown | Promise<unknown>);
+  readonly provider: Exclude<ORMProvider, "cockroachdb" | "mongodb" | "mssql">;
+  readonly schema?: Record<string, unknown>;
+}
 
-export const drizzleAdapter = (config: DrizzleConfig): ORMDatabaseAdapter =>
-  Object.assign(
-    fumadbDrizzleAdapter(
-      config as unknown as Parameters<typeof fumadbDrizzleAdapter>[0],
-    ) as unknown as ORMDatabaseAdapter,
-    {
-      provider: config.provider,
-    },
-  );
+const getTable = (db: DrizzleDB, name: string) => {
+  const table = db._.fullSchema[name];
+  if (!table) throw new Error(`Drizzle schema is missing table "${name}".`);
+  return table;
+};
+
+const column = (table: DrizzleTable, name: string): SQLWrapper =>
+  table[name] as SQLWrapper;
+
+const buildWhere = (
+  table: DrizzleTable,
+  where: DatabaseBundleQueryWhere | undefined,
+) => {
+  const conditions = [];
+  if (where?.channel !== undefined)
+    conditions.push(eq(column(table, "channel"), where.channel));
+  if (where?.platform !== undefined)
+    conditions.push(eq(column(table, "platform"), where.platform));
+  if (where?.enabled !== undefined)
+    conditions.push(eq(column(table, "enabled"), where.enabled));
+  if (where?.fingerprintHash !== undefined) {
+    conditions.push(
+      where.fingerprintHash === null
+        ? isNull(column(table, "fingerprint_hash"))
+        : eq(column(table, "fingerprint_hash"), where.fingerprintHash),
+    );
+  }
+  if (where?.targetAppVersion !== undefined) {
+    conditions.push(
+      where.targetAppVersion === null
+        ? isNull(column(table, "target_app_version"))
+        : eq(column(table, "target_app_version"), where.targetAppVersion),
+    );
+  }
+  if (where?.targetAppVersionIn) {
+    conditions.push(
+      inArray(column(table, "target_app_version"), where.targetAppVersionIn),
+    );
+  }
+  if (where?.targetAppVersionNotNull) {
+    conditions.push(isNotNull(column(table, "target_app_version")));
+  }
+  if (where?.id?.eq) conditions.push(eq(column(table, "id"), where.id.eq));
+  if (where?.id?.gt) conditions.push(gt(column(table, "id"), where.id.gt));
+  if (where?.id?.gte) conditions.push(gte(column(table, "id"), where.id.gte));
+  if (where?.id?.lt) conditions.push(lt(column(table, "id"), where.id.lt));
+  if (where?.id?.lte) conditions.push(lte(column(table, "id"), where.id.lte));
+  if (where?.id?.in) conditions.push(inArray(column(table, "id"), where.id.in));
+  return conditions.length > 0 ? and(...conditions) : undefined;
+};
+
+const createDrizzlePlugin = createDatabasePlugin<DrizzleConfig>({
+  name: "drizzle",
+  factory: (config) => {
+    const db = createLazyDB(config);
+    const bundles = getTable(db, "bundles");
+    const patches = getTable(db, "bundle_patches");
+    const runInTransaction = async <T>(
+      operation: (activeDB: DrizzleDB) => Promise<T>,
+    ) => {
+      if (typeof db.transaction !== "function") return operation(db);
+      return db.transaction(operation);
+    };
+    const fetchPatchMap = async (bundleIds: readonly string[]) => {
+      const patchMap = new Map<string, BundlePatchRow[]>();
+      if (bundleIds.length === 0) return patchMap;
+      const rows = await db.query["bundle_patches"]?.findMany({
+        where: inArray(column(patches, "bundle_id"), [...bundleIds]),
+        orderBy: [asc(column(patches, "order_index"))],
+      });
+      for (const row of rows ?? []) {
+        const patch = row as BundlePatchRow;
+        const current = patchMap.get(patch.bundle_id) ?? [];
+        current.push(patch);
+        patchMap.set(patch.bundle_id, current);
+      }
+      return patchMap;
+    };
+    const mapRowsToBundles = async (
+      rows: readonly Record<string, unknown>[],
+    ): Promise<Bundle[]> => {
+      const patchMap = await fetchPatchMap(
+        rows.map((row) => String(row["id"])),
+      );
+      return rows.map((row) =>
+        rowToBundle(row as BundleRow, patchMap.get(String(row["id"])) ?? []),
+      );
+    };
+    const upsertBundle = async (activeDB: DrizzleDB, bundle: Bundle) => {
+      const row = bundleToRow(bundle);
+      const current = await activeDB.query["bundles"]?.findFirst({
+        where: eq(column(bundles, "id"), bundle.id),
+      });
+      if (current) {
+        await activeDB
+          .update(bundles)
+          .set(row)
+          .where(eq(column(bundles, "id"), bundle.id));
+      } else {
+        const inserted = activeDB.insert(bundles).values(row);
+        if (inserted.execute) await inserted.execute();
+        else await inserted;
+      }
+      await activeDB
+        .delete(patches)
+        .where(eq(column(patches, "bundle_id"), bundle.id));
+      const patchRows = bundleToPatchRows(bundle);
+      if (patchRows.length > 0) {
+        const inserted = activeDB.insert(patches).values(patchRows);
+        if (inserted.execute) await inserted.execute();
+        else await inserted;
+      }
+    };
+    return {
+      async getBundleById(bundleId) {
+        const row = await db.query["bundles"]?.findFirst({
+          where: eq(column(bundles, "id"), bundleId),
+        });
+        if (!row) return null;
+        const patchMap = await fetchPatchMap([bundleId]);
+        return rowToBundle(row as BundleRow, patchMap.get(bundleId) ?? []);
+      },
+      async getBundles(
+        options: DatabaseBundleQueryOptions & { offset?: number },
+      ) {
+        const offset = options.offset ?? 0;
+        const orderBy = options.orderBy ?? { field: "id", direction: "desc" };
+        const where = buildWhere(bundles, options.where);
+        const total = await db.$count(bundles, where);
+        const rows = await db.query["bundles"]?.findMany({
+          where,
+          orderBy: [
+            orderBy.direction === "asc"
+              ? asc(column(bundles, "id"))
+              : desc(column(bundles, "id")),
+          ],
+          limit: options.limit,
+          offset,
+        });
+        const dataRows = rows ?? [];
+        const patchMap = await fetchPatchMap(
+          dataRows.map((row) => String(row["id"])),
+        );
+        return {
+          data: dataRows.map((row) =>
+            rowToBundle(
+              row as BundleRow,
+              patchMap.get(String(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.query["bundles"]?.findMany({
+            columns: { target_app_version: true },
+            where: buildWhere(bundles, {
+              enabled: true,
+              platform: args.platform,
+              channel,
+              id: { gte: minBundleId },
+              targetAppVersionNotNull: true,
+            }),
+          });
+
+          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 updateRows =
+            compatibleAppVersions.length > 0
+              ? await db.query["bundles"]?.findMany({
+                  where: buildWhere(bundles, {
+                    enabled: true,
+                    platform: args.platform,
+                    channel,
+                    id: { gte: minBundleId },
+                    targetAppVersionIn: compatibleAppVersions,
+                  }),
+                  orderBy: [desc(column(bundles, "id"))],
+                })
+              : [];
+
+          return resolveUpdateInfoFromBundles({
+            args: { ...args, channel, minBundleId },
+            bundles: await mapRowsToBundles(updateRows ?? []),
+            context,
+          });
+        }
+
+        const channel = args.channel ?? "production";
+        const minBundleId = args.minBundleId ?? NIL_UUID;
+        const rows = await db.query["bundles"]?.findMany({
+          where: buildWhere(bundles, {
+            enabled: true,
+            platform: args.platform,
+            channel,
+            id: { gte: minBundleId },
+            fingerprintHash: args.fingerprintHash,
+          }),
+          orderBy: [desc(column(bundles, "id"))],
+        });
+
+        return resolveUpdateInfoFromBundles({
+          args: { ...args, channel, minBundleId },
+          bundles: await mapRowsToBundles(rows ?? []),
+          context,
+        });
+      },
+      async getChannels() {
+        const rows = await db.query["bundles"]?.findMany({
+          columns: { channel: true },
+          orderBy: [asc(column(bundles, "channel"))],
+        });
+        return Array.from(
+          new Set((rows ?? []).map((row) => String(row["channel"]))),
+        );
+      },
+      async commitBundle({ changedSets }) {
+        await runInTransaction(async (activeDB) => {
+          for (const change of changedSets) {
+            if (change.operation === "delete") {
+              await activeDB
+                .delete(patches)
+                .where(eq(column(patches, "bundle_id"), change.data.id));
+              await activeDB
+                .delete(patches)
+                .where(eq(column(patches, "base_bundle_id"), change.data.id));
+              await activeDB
+                .delete(bundles)
+                .where(eq(column(bundles, "id"), change.data.id));
+              continue;
+            }
+            await upsertBundle(activeDB, change.data);
+          }
+        });
+      },
+    };
+  },
+});
+
+export const drizzleAdapter = (
+  config: DrizzleConfig,
+): DatabasePluginFactory => {
+  return Object.assign(createDrizzlePlugin(config), {
+    adapterName: "drizzle",
+    provider: config.provider,
+    generateSchema: (version: Parameters<SchemaGenerator>[0]) => ({
+      code: generateDrizzleSchema(
+        config.provider as ORMSQLProvider,
+        version === "latest"
+          ? hotUpdaterSchema
+          : getHotUpdaterSchemaVersion(version),
+      ),
+      path: "hot-updater-schema.ts",
+    }),
+  });
+};

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 "../index";
+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"]);
+  });
+});