@hot-updater/server 0.33.1 → 0.34.0

package/dist/schema/v0_31_0.mjs

@@ -1,48 +1,80 @@
-import { column, idColumn, schema, table } from "../node_modules/.pnpm/fumadb@0.2.2_mongodb@6.20.0_@aws-sdk_credential-providers@3.1066.0_socks@2.8.9__prisma@_ee79457f0e32f18f0beb5c2db02e4f73/node_modules/fumadb/dist/chunk-ZEQMAIFI.mjs";
-import "../node_modules/.pnpm/fumadb@0.2.2_mongodb@6.20.0_@aws-sdk_credential-providers@3.1066.0_socks@2.8.9__prisma@_ee79457f0e32f18f0beb5c2db02e4f73/node_modules/fumadb/dist/schema/index.mjs";
+import { HOT_UPDATER_SETTINGS_TABLE } from "./types.mjs";
+import { bool, check, column, foreignKey, idColumn, index, integer, json, relation, schema, stringColumn, table, uuid, varchar } from "./dsl.mjs";
+import { createSettingsTable } from "./settings.mjs";
 //#region src/schema/v0_31_0.ts
+const bundlesV031 = table("bundles", {
+	id: idColumn("id", "uuid"),
+	platform: stringColumn("platform"),
+	should_force_update: bool("should_force_update"),
+	enabled: bool("enabled"),
+	file_hash: stringColumn("file_hash"),
+	git_commit_hash: stringColumn("git_commit_hash").nullable(),
+	message: stringColumn("message").nullable(),
+	channel: stringColumn("channel").defaultTo("production"),
+	storage_uri: stringColumn("storage_uri"),
+	target_app_version: stringColumn("target_app_version").nullable(),
+	fingerprint_hash: stringColumn("fingerprint_hash").nullable(),
+	metadata: json("metadata").defaultTo({}),
+	rollout_cohort_count: integer("rollout_cohort_count").defaultTo(1e3),
+	target_cohorts: json("target_cohorts").nullable(),
+	manifest_storage_uri: stringColumn("manifest_storage_uri").nullable(),
+	manifest_file_hash: stringColumn("manifest_file_hash").nullable(),
+	asset_base_storage_uri: stringColumn("asset_base_storage_uri").nullable()
+}, {
+	indexes: [
+		index("bundles_target_app_version_idx", ["target_app_version"]),
+		index("bundles_fingerprint_hash_idx", ["fingerprint_hash"]),
+		index("bundles_channel_idx", ["channel"]),
+		index("bundles_platform_idx", ["platform"], ["mongodb"]),
+		index("bundles_rollout_idx", ["rollout_cohort_count"])
+	],
+	checks: [check({
+		name: "check_version_or_fingerprint",
+		expression: "(target_app_version is not null) or (fingerprint_hash is not null)",
+		sqliteInline: true
+	}), check({
+		name: "bundles_rollout_cohort_count_check",
+		expression: "rollout_cohort_count >= 0 and rollout_cohort_count <= 1000",
+		sqliteInline: true
+	})]
+});
+const bundlePatchesV031 = table("bundle_patches", {
+	id: idColumn("id", varchar(255)),
+	bundle_id: uuid("bundle_id"),
+	base_bundle_id: uuid("base_bundle_id"),
+	base_file_hash: column("base_file_hash", "string"),
+	patch_file_hash: column("patch_file_hash", "string"),
+	patch_storage_uri: column("patch_storage_uri", "string"),
+	order_index: integer("order_index").defaultTo(0)
+}, {
+	indexes: [index("bundle_patches_bundle_id_idx", ["bundle_id"]), index("bundle_patches_base_bundle_id_idx", ["base_bundle_id"])],
+	foreignKeys: [foreignKey("bundle_patches_bundle_id_fk", ["bundle_id"], "bundles", ["id"]), foreignKey("bundle_patches_base_bundle_id_fk", ["base_bundle_id"], "bundles", ["id"])],
+	relations: [relation({
+		name: "bundle",
+		fieldName: "patches",
+		targetFieldName: "bundle",
+		relationName: "bundle_patches_bundles_patches",
+		columns: ["bundle_id"],
+		referencedTable: "bundles",
+		referencedColumns: ["id"]
+	}), relation({
+		name: "baseBundle",
+		fieldName: "baseForPatches",
+		targetFieldName: "baseBundle",
+		relationName: "bundle_patches_bundles_baseForPatches",
+		columns: ["base_bundle_id"],
+		referencedTable: "bundles",
+		referencedColumns: ["id"]
+	})]
+});
 const v0_31_0 = schema({
 	version: "0.31.0",
-	tables: {
-		bundles: table("bundles", {
-			id: idColumn("id", "uuid"),
-			platform: column("platform", "string"),
-			should_force_update: column("should_force_update", "bool"),
-			enabled: column("enabled", "bool"),
-			file_hash: column("file_hash", "string"),
-			git_commit_hash: column("git_commit_hash", "string").nullable(),
-			message: column("message", "string").nullable(),
-			channel: column("channel", "string").defaultTo("production"),
-			storage_uri: column("storage_uri", "string"),
-			target_app_version: column("target_app_version", "string").nullable(),
-			fingerprint_hash: column("fingerprint_hash", "string").nullable(),
-			metadata: column("metadata", "json"),
-			manifest_storage_uri: column("manifest_storage_uri", "string").nullable(),
-			manifest_file_hash: column("manifest_file_hash", "string").nullable(),
-			asset_base_storage_uri: column("asset_base_storage_uri", "string").nullable(),
-			rollout_cohort_count: column("rollout_cohort_count", "integer").defaultTo(1e3),
-			target_cohorts: column("target_cohorts", "json").nullable()
-		}),
-		bundle_patches: table("bundle_patches", {
-			id: idColumn("id", "varchar(255)"),
-			bundle_id: column("bundle_id", "uuid"),
-			base_bundle_id: column("base_bundle_id", "uuid"),
-			base_file_hash: column("base_file_hash", "string"),
-			patch_file_hash: column("patch_file_hash", "string"),
-			patch_storage_uri: column("patch_storage_uri", "string"),
-			order_index: column("order_index", "integer").defaultTo(0)
-		})
-	},
-	relations: { bundle_patches: (builder) => ({
-		bundle: builder.one("bundles", ["bundle_id", "id"]).imply("patches").foreignKey({
-			name: "bundle_patches_bundle_id_fk",
-			onDelete: "CASCADE"
-		}),
-		baseBundle: builder.one("bundles", ["base_bundle_id", "id"]).imply("baseForPatches").foreignKey({
-			name: "bundle_patches_base_bundle_id_fk",
-			onDelete: "CASCADE"
-		})
-	}) }
+	settingsTable: HOT_UPDATER_SETTINGS_TABLE,
+	tables: [
+		bundlesV031,
+		bundlePatchesV031,
+		createSettingsTable("0.31.0")
+	]
 });
 //#endregion
-export { v0_31_0 };
+export { bundlePatchesV031, bundlesV031, v0_31_0 };

package/dist/version.cjs

@@ -1,4 +1,4 @@
 //#region src/version.ts
-const HOT_UPDATER_SERVER_VERSION = require("./packages/server/package.cjs").version;
+const HOT_UPDATER_SERVER_VERSION = require("./package.cjs").version;
 //#endregion
 exports.HOT_UPDATER_SERVER_VERSION = HOT_UPDATER_SERVER_VERSION;

package/dist/version.mjs

@@ -1,4 +1,4 @@
-import { version } from "./packages/server/package.mjs";
+import { version } from "./package.mjs";
 //#region src/version.ts
 const HOT_UPDATER_SERVER_VERSION = version;
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hot-updater/server",
-  "version": "0.33.1",
+  "version": "0.34.0",
   "type": "module",
   "description": "React Native OTA solution for self-hosted",
   "sideEffects": false,
@@ -53,32 +53,46 @@
     "access": "public"
   },
   "dependencies": {
-    "fumadb": "0.2.2",
-    "kysely": "0.28.17",
-    "mongodb": "6.20.0",
     "rou3": "0.7.9",
     "semver": "^7.7.2",
-    "@hot-updater/core": "0.33.1",
-    "@hot-updater/plugin-core": "0.33.1",
-    "@hot-updater/bsdiff": "0.33.1",
-    "@hot-updater/js": "0.33.1"
+    "@hot-updater/bsdiff": "0.34.0",
+    "@hot-updater/core": "0.34.0",
+    "@hot-updater/js": "0.34.0",
+    "@hot-updater/plugin-core": "0.34.0"
+  },
+  "peerDependencies": {
+    "@prisma/client": "*",
+    "drizzle-orm": "*",
+    "kysely": "*",
+    "mongodb": "*"
+  },
+  "peerDependenciesMeta": {
+    "@prisma/client": {
+      "optional": true
+    },
+    "drizzle-orm": {
+      "optional": true
+    },
+    "kysely": {
+      "optional": true
+    },
+    "mongodb": {
+      "optional": true
+    }
   },
   "devDependencies": {
     "@electric-sql/pglite": "0.4.1",
     "@types/node": "^20",
     "@types/semver": "^7.5.8",
+    "drizzle-orm": "0.45.2",
     "execa": "9.5.2",
+    "kysely": "0.28.17",
     "kysely-pglite-dialect": "1.2.0",
+    "mongodb": "6.20.0",
     "msw": "^2.7.0",
     "uuidv7": "^1.0.2",
-    "@hot-updater/standalone": "0.33.1",
-    "@hot-updater/test-utils": "0.33.1"
-  },
-  "inlinedDependencies": {
-    "@noble/hashes": "1.8.0",
-    "@paralleldrive/cuid2": "2.3.1",
-    "drizzle-orm": "0.45.2",
-    "fumadb": "0.2.2"
+    "@hot-updater/standalone": "0.34.0",
+    "@hot-updater/test-utils": "0.34.0"
   },
   "scripts": {
     "build": "tsdown",

package/src/adapters/drizzle.spec.ts

@@ -0,0 +1,75 @@
+import { describe, expect, it, vi } from "vitest";
+
+import { createHotUpdater } from "../db";
+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 = hotUpdater.generateSchema("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",
+    }),
+  });
+};