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

package/src/adapters/mongodb.integration.spec.ts

@@ -0,0 +1,210 @@
+import net from "node:net";
+import path from "node:path";
+
+import {
+  toInsightsInstallationRow,
+  type BundleEventRow,
+} from "@hot-updater/plugin-core";
+import { execa } from "execa";
+import { MongoClient } from "mongodb";
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from "vitest";
+
+import { createBundleEventRowFixture } from "../../../test-utils/src/databaseTestFixtures";
+import { mongoAdapter } from "./mongodb";
+
+const availablePort = (): Promise<number> =>
+  new Promise((resolve, reject) => {
+    const server = net.createServer();
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      if (address === null || typeof address === "string") {
+        server.close();
+        reject(new Error("Failed to allocate MongoDB test port"));
+        return;
+      }
+      server.close((error) => (error ? reject(error) : resolve(address.port)));
+    });
+  });
+
+describe("MongoDB native Insights transactions", () => {
+  let client: MongoClient;
+  let composeEnvironment: Record<string, string>;
+  const composeFile = path.resolve(
+    import.meta.dirname,
+    "../../../../examples-server/hono-mongodb/docker-compose.yml",
+  );
+  const compose = (args: string[]) =>
+    execa("docker", ["compose", "-f", composeFile, ...args], {
+      env: composeEnvironment,
+    });
+  const insights = () => mongoAdapter({ client }).models.insights;
+  const record = (event: BundleEventRow) =>
+    insights().record({
+      event,
+      installation: toInsightsInstallationRow(event),
+    });
+
+  beforeAll(async () => {
+    const port = await availablePort();
+    composeEnvironment = {
+      COMPOSE_PROJECT_NAME: `hot-updater-insights-${process.pid}`,
+      HOT_UPDATER_E2E_MONGODB_PORT: String(port),
+    };
+    await compose(["up", "-d", "--wait"]);
+    client = new MongoClient(
+      `mongodb://127.0.0.1:${port}/insights_native?replicaSet=rs0&directConnection=true`,
+    );
+    await client.connect();
+    const adapter = mongoAdapter({ client });
+    await (await adapter.createMigrator!().migrateToLatest()).execute();
+  }, 120_000);
+
+  beforeEach(async () => {
+    await client.db().collection("bundle_events").deleteMany({});
+    await client.db().collection("bundle_installations").deleteMany({});
+  });
+
+  afterAll(async () => {
+    await client?.close();
+    if (composeEnvironment) await compose(["down", "-v", "--remove-orphans"]);
+  }, 60_000);
+
+  it("rolls back both canonical changes after a native installation validation error", async () => {
+    const previous = {
+      ...createBundleEventRowFixture("801", 100),
+      user_id: "original",
+    };
+    await record(previous);
+    await client.db().command({
+      collMod: "bundle_installations",
+      validator: { user_id: { $ne: "reject" } },
+    });
+    const failed = {
+      ...createBundleEventRowFixture("802", 200),
+      install_id: previous.install_id,
+      user_id: "reject",
+    };
+    try {
+      await expect(record(failed)).rejects.toThrow();
+      expect(
+        await client.db().collection("bundle_events").countDocuments({}),
+      ).toBe(1);
+      await expect(
+        insights().findInstallations({ installId: previous.install_id }),
+      ).resolves.toEqual([toInsightsInstallationRow(previous)]);
+    } finally {
+      await client
+        .db()
+        .command({ collMod: "bundle_installations", validator: {} });
+    }
+    await record(failed);
+    await record(failed);
+    expect(
+      await client.db().collection("bundle_events").countDocuments({}),
+    ).toBe(2);
+    await expect(
+      insights().findInstallations({ installId: previous.install_id }),
+    ).resolves.toEqual([toInsightsInstallationRow(failed)]);
+  });
+
+  it("retries native conflicts without dropping events or letting duplicate IDs rewrite state", async () => {
+    const events = Array.from({ length: 12 }, (_, index) => ({
+      ...createBundleEventRowFixture(String(810 + index), 100),
+      install_id: "concurrent-installation",
+      user_id: index === 11 ? null : "old-user",
+    }));
+    await Promise.all(events.map(record));
+    const winner = events.at(-1)!;
+    await Promise.all(Array.from({ length: 4 }, () => record(winner)));
+    const conflictingDuplicate = {
+      ...events[0]!,
+      install_id: "different-installation",
+      received_at_ms: 1000,
+    };
+    await record(conflictingDuplicate);
+    expect(
+      await client.db().collection("bundle_events").countDocuments({}),
+    ).toBe(12);
+    await expect(
+      insights().findInstallations({ installId: winner.install_id }),
+    ).resolves.toEqual([toInsightsInstallationRow(winner)]);
+    await expect(
+      insights().findInstallations({
+        installId: conflictingDuplicate.install_id,
+      }),
+    ).resolves.toEqual([]);
+    await expect(
+      insights().findInstallations({ userId: "old-user", limit: 10 }),
+    ).resolves.toEqual([]);
+  });
+
+  it("accepts concurrent retries of a previously unseen event ID exactly once", async () => {
+    const event = createBundleEventRowFixture("825", 100);
+    await Promise.all(Array.from({ length: 12 }, () => record(event)));
+    expect(
+      await client.db().collection("bundle_events").countDocuments({}),
+    ).toBe(1);
+    await expect(
+      insights().findInstallations({ installId: event.install_id }),
+    ).resolves.toEqual([toInsightsInstallationRow(event)]);
+  });
+
+  it("uses raw recovery predicates consistently in native counts and indexed lists", async () => {
+    const applied = createBundleEventRowFixture("831", 100);
+    const recovered: BundleEventRow = {
+      ...createBundleEventRowFixture("832", 200),
+      type: "RECOVERED",
+      update_strategy: "appVersion",
+      install_id: applied.install_id,
+      from_bundle_id: applied.to_bundle_id,
+      to_bundle_id: applied.from_bundle_id!,
+    };
+    await record(applied);
+    await record(recovered);
+    const filter = {
+      type: "RECOVERED" as const,
+      platform: "ios" as const,
+      channel: "production",
+      fromBundleId: applied.to_bundle_id,
+    };
+    await expect(
+      insights().countEvents({ filter, sinceMs: 200, beforeReceivedAtMs: 201 }),
+    ).resolves.toBe(1);
+    await expect(
+      insights().listEvents({
+        filter: { kind: "bundle", ...filter },
+        sinceMs: 200,
+        beforeReceivedAtMs: 201,
+        limit: 10,
+      }),
+    ).resolves.toEqual([recovered]);
+    await expect(
+      insights().countEvents({ filter, sinceMs: 100, beforeReceivedAtMs: 200 }),
+    ).resolves.toBe(0);
+    await expect(
+      insights().countInstallations({
+        platform: "ios",
+        channel: "production",
+        bundleId: applied.to_bundle_id,
+        sinceMs: 0,
+      }),
+    ).resolves.toBe(0);
+    const explanation = await client
+      .db()
+      .collection("bundle_events")
+      .find({
+        type: "RECOVERED",
+        platform: "ios",
+        channel: "production",
+        from_bundle_id: applied.to_bundle_id,
+        received_at_ms: { $gte: 200, $lt: 201 },
+      })
+      .collation({ locale: "simple" })
+      .sort({ received_at_ms: -1, id: -1 })
+      .hint("bundle_events_from_bundle_idx")
+      .explain("executionStats");
+    expect(explanation.executionStats.nReturned).toBe(1);
+    expect(explanation.executionStats.totalKeysExamined).toBeLessThanOrEqual(2);
+  });
+});

package/src/adapters/mongodb.spec.ts

@@ -1,9 +1,13 @@
-import { createDatabaseClient } from "@hot-updater/plugin-core";
+import {
+  createDatabaseClient,
+  toInsightsInstallationRow,
+} from "@hot-updater/plugin-core";
 import { describe, expect, it } from "vitest";
 
 import {
   createBundlePatchRowFixture,
   createBundleRowFixture,
+  createBundleEventRowFixture,
 } from "../../../test-utils/src/databaseTestFixtures";
 import { setupDatabasePluginTestSuite } from "../../../test-utils/src/setupDatabasePluginTestSuite";
 import { mongoAdapter } from "./mongodb";
@@ -22,6 +26,70 @@ setupDatabasePluginTestSuite({
 });
 
 describe("mongoAdapter capabilities", () => {
+  it("records Insights atomically even without legacy catalog transactions enabled", async () => {
+    harness.reset();
+    const insights = mongoAdapter({ client: harness.client }).models.insights;
+    const event = createBundleEventRowFixture("981", 100);
+    const input = { event, installation: toInsightsInstallationRow(event) };
+    harness.failNextInstallationWrite();
+    await expect(insights.record(input)).rejects.toThrow(
+      "injected installation write failure",
+    );
+    await expect(
+      insights.listEvents({
+        filter: { kind: "all" },
+        beforeReceivedAtMs: 200,
+        limit: 10,
+      }),
+    ).resolves.toEqual([]);
+    await expect(
+      insights.findInstallations({ installId: event.install_id }),
+    ).resolves.toEqual([]);
+    await insights.record(input);
+    await insights.record(input);
+    await expect(
+      insights.listEvents({
+        filter: { kind: "all" },
+        beforeReceivedAtMs: 200,
+        limit: 10,
+      }),
+    ).resolves.toEqual([event]);
+    await expect(
+      insights.findInstallations({ installId: event.install_id }),
+    ).resolves.toEqual([input.installation]);
+  });
+
+  it("preserves all concurrent events while advancing one installation and clearing its user", async () => {
+    harness.reset();
+    const insights = mongoAdapter({ client: harness.client }).models.insights;
+    const events = ["990", "993", "991", "992"].map((suffix) => ({
+      ...createBundleEventRowFixture(suffix, 100),
+      install_id: "concurrent-installation",
+      user_id: suffix === "993" ? null : "previous-user",
+    }));
+    await Promise.all(
+      events.map((event) =>
+        insights.record({
+          event,
+          installation: toInsightsInstallationRow(event),
+        }),
+      ),
+    );
+    await expect(
+      insights.findInstallations({ installId: "concurrent-installation" }),
+    ).resolves.toEqual([toInsightsInstallationRow(events[1]!)]);
+    await expect(
+      insights.findInstallations({ userId: "previous-user", limit: 10 }),
+    ).resolves.toEqual([]);
+    await expect(
+      insights.listEvents({
+        filter: { kind: "all" },
+        beforeReceivedAtMs: 200,
+        limit: 10,
+      }),
+    ).resolves.toHaveLength(4);
+  });
+
   it("returns an adapter without an unsafe atomic-batch fallback", () => {
     const plugin = mongoAdapter({ client: harness.client });
     expect(plugin.name).toBe("mongodb");

package/src/adapters/mongodb.ts

@@ -1,10 +1,17 @@
-import { createDatabasePlugin } from "@hot-updater/plugin-core";
+import {
+  compareInsightsText,
+  createDatabasePlugin,
+} from "@hot-updater/plugin-core";
 import {
   createDatabasePluginAdapter,
   type DatabasePluginImplementation,
   type TransactionDatabasePluginImplementation,
 } from "@hot-updater/plugin-core/internal";
-import type { ClientSession, MongoClient } from "mongodb";
+import {
+  MongoServerError,
+  type ClientSession,
+  type MongoClient,
+} from "mongodb";
 
 import { createMongoMigrator } from "../db/fixedMigrator";
 import type { DatabaseAdapterWithCapabilities } from "../db/types";
@@ -14,6 +21,7 @@ import { createMongoWrites } from "./mongodbWrites";
 
 export interface MongoDBConfig {
   readonly client: MongoClient;
+  /** Enables atomic catalog commits. Insights always requires MongoDB 5+ on a replica set or sharded cluster. */
   readonly transactions?: boolean;
 }
 
@@ -23,6 +31,62 @@ const createMongoImplementation = (
 ): DatabasePluginImplementation => {
   const collections = createMongoCollections(client);
   return {
+    recordInsights: async (input) => {
+      const record = () =>
+        client.withSession((recordSession) =>
+          recordSession.withTransaction(
+            async () => {
+              const records = createMongoCollections(client);
+              const options = {
+                session: recordSession,
+                collation: { locale: "simple" },
+              };
+              const inserted = await records.bundleEvents.updateOne(
+                { id: input.event.id },
+                { $setOnInsert: input.event },
+                { ...options, upsert: true },
+              );
+              if (inserted.upsertedCount === 0) return;
+              const current = await records.bundleInstallations.findOne(
+                { install_id: input.installation.install_id },
+                options,
+              );
+              if (current === null) {
+                await records.bundleInstallations.insertOne(
+                  { ...input.installation },
+                  {
+                    session: recordSession,
+                  },
+                );
+              } else if (
+                input.installation.received_at_ms > current.received_at_ms ||
+                (input.installation.received_at_ms === current.received_at_ms &&
+                  compareInsightsText(input.installation.id, current.id) > 0)
+              ) {
+                await records.bundleInstallations.updateOne(
+                  { install_id: input.installation.install_id },
+                  { $set: input.installation },
+                  options,
+                );
+              }
+            },
+            {
+              readConcern: { level: "snapshot" },
+              readPreference: "primary",
+              writeConcern: { w: "majority" },
+            },
+          ),
+        );
+      try {
+        await record();
+      } catch (error) {
+        if (!(error instanceof MongoServerError) || error.code !== 11000)
+          throw error;
+        // A concurrent insert won a canonical key. Read that committed winner
+        // in a new transaction; some MongoDB versions do not retry E11000.
+        await record();
+      }
+    },
     ...createMongoWrites(collections, session),
     ...createMongoReads(collections, session),
   };

package/src/adapters/mongodbCollections.ts

@@ -1,5 +1,6 @@
 import type {
   BundleEventRow,
+  InsightsInstallationRow,
   BundlePatchRow,
   BundleRow,
   ChannelRow,
@@ -37,6 +38,7 @@ export type MongoCollections = {
   readonly bundles: Collection<MongoBundleDocument>;
   readonly bundlePatches: Collection<BundlePatchRow>;
   readonly bundleEvents: Collection<BundleEventRow>;
+  readonly bundleInstallations: Collection<InsightsInstallationRow>;
   readonly channels: Collection<ChannelRow>;
   readonly apiKeys: Collection<ApiKeyRow>;
   readonly releases: Collection<ReleaseRow>;
@@ -51,6 +53,9 @@ export const createMongoCollections = (
     bundles: database.collection<MongoBundleDocument>("bundles"),
     bundlePatches: database.collection<BundlePatchRow>("bundle_patches"),
     bundleEvents: database.collection<BundleEventRow>("bundle_events"),
+    bundleInstallations: database.collection<InsightsInstallationRow>(
+      "bundle_installations",
+    ),
     channels: database.collection<ChannelRow>("channels"),
     apiKeys: database.collection<ApiKeyRow>("api_keys"),
     releases: database.collection<ReleaseRow>("releases"),

package/src/adapters/mongodbQuery.ts

@@ -4,6 +4,7 @@ import type {
   BundlePatchRow,
   BundleRow,
   ChannelRow,
+  InsightsInstallationRow,
   ReleaseCatalogRow,
   ReleaseRow,
 } from "@hot-updater/plugin-core";
@@ -121,20 +122,39 @@ const predicate = (where: AnyDatabaseWhere): Document => {
 
 const createMongoWhereDocument = (
   where: readonly AnyDatabaseWhere[] | undefined,
+  toPredicate: (condition: AnyDatabaseWhere) => Document = predicate,
 ): Document => {
   const items = Array.isArray(where) ? where : [];
   const first = items[0];
   if (first === undefined) return {};
 
-  let result = predicate(first);
+  let result = toPredicate(first);
   for (const item of items.slice(1)) {
     result = {
-      [item.connector === "OR" ? "$or" : "$and"]: [result, predicate(item)],
+      [item.connector === "OR" ? "$or" : "$and"]: [result, toPredicate(item)],
     };
   }
   return result;
 };
 
+// Fixed Insights predicates use native fields so equality/range indexes apply.
+const insightsPredicate = (where: AnyDatabaseWhere): Document => {
+  if ("mode" in where && where.mode === "insensitive") return predicate(where);
+  switch (where.operator) {
+    case undefined:
+    case "eq":
+      return { [where.field]: { $eq: where.value } };
+    case "gt":
+    case "gte":
+    case "lt":
+    case "lte":
+    case "in":
+      return { [where.field]: { [`$${where.operator}`]: where.value } };
+    default:
+      return predicate(where);
+  }
+};
+
 export function createMongoBundleWhere(
   where: readonly DatabaseWhere<"bundles">[] | undefined,
 ): Filter<BundleRow>;
@@ -159,7 +179,16 @@ export function createMongoEventWhere(
 export function createMongoEventWhere(
   where: readonly DatabaseWhere<"bundle_events">[] | undefined,
 ): Document {
-  return createMongoWhereDocument(where);
+  return createMongoWhereDocument(where, insightsPredicate);
+}
+
+export function createMongoInstallationWhere(
+  where: readonly DatabaseWhere<"bundle_installations">[] | undefined,
+): Filter<InsightsInstallationRow>;
+export function createMongoInstallationWhere(
+  where: readonly DatabaseWhere<"bundle_installations">[] | undefined,
+): Document {
+  return createMongoWhereDocument(where, insightsPredicate);
 }
 
 export function createMongoApiKeyWhere(

package/src/adapters/mongodbReads.ts

@@ -19,6 +19,7 @@ import {
   createMongoChannelWhere,
   createMongoApiKeyWhere,
   createMongoEventWhere,
+  createMongoInstallationWhere,
   createMongoPatchWhere,
   createMongoReleaseCatalogWhere,
   createMongoReleaseWhere,
@@ -91,6 +92,8 @@ const findMongoRows = async (
         .find(createMongoEventWhere(input.where), {
           projection: WITHOUT_MONGO_ID,
           ...mongoSessionOptions(session),
+          collation: { locale: "simple" },
+          readPreference: "primary",
         })
         .skip(input.offset)
         .limit(input.limit);
@@ -100,6 +103,38 @@ const findMongoRows = async (
           .find(createMongoEventWhere(input.where), {
             projection: WITHOUT_MONGO_ID,
             ...mongoSessionOptions(session),
+            collation: { locale: "simple" },
+            readPreference: "primary",
+          })
+          .toArray();
+        return sortRowsByOrder(rows, rawOrderBy).slice(
+          input.offset,
+          input.offset + input.limit,
+        );
+      }
+      const sort = createMongoSort(input);
+      return sort === undefined
+        ? cursor.toArray()
+        : cursor.sort(sort).toArray();
+    }
+    case "bundle_installations": {
+      const cursor = collections.bundleInstallations
+        .find(createMongoInstallationWhere(input.where), {
+          projection: WITHOUT_MONGO_ID,
+          ...mongoSessionOptions(session),
+          collation: { locale: "simple" },
+          readPreference: "primary",
+        })
+        .skip(input.offset)
+        .limit(input.limit);
+      if (rawOrderBy === undefined) return cursor.toArray();
+      if (needsInMemoryOrder) {
+        const rows = await collections.bundleInstallations
+          .find(createMongoInstallationWhere(input.where), {
+            projection: WITHOUT_MONGO_ID,
+            ...mongoSessionOptions(session),
+            collation: { locale: "simple" },
+            readPreference: "primary",
           })
           .toArray();
         return sortRowsByOrder(rows, rawOrderBy).slice(
@@ -248,6 +283,30 @@ export const createMongoReads = (
           createMongoReleaseWhere(input.where),
           mongoSessionOptions(session),
         );
+      case "bundle_installations":
+        return collections.bundleInstallations.countDocuments(
+          createMongoInstallationWhere(input.where),
+          {
+            ...mongoSessionOptions(session),
+            collation: { locale: "simple" },
+            readPreference: "primary",
+            ...(session === undefined
+              ? { readConcern: { level: "snapshot" } }
+              : {}),
+          },
+        );
+      case "bundle_events":
+        return collections.bundleEvents.countDocuments(
+          createMongoEventWhere(input.where),
+          {
+            ...mongoSessionOptions(session),
+            collation: { locale: "simple" },
+            readPreference: "primary",
+            ...(session === undefined
+              ? { readConcern: { level: "snapshot" } }
+              : {}),
+          },
+        );
     }
   },
   findOne: async (input) => {
@@ -300,6 +359,16 @@ export const createMongoReads = (
             ...mongoSessionOptions(session),
           },
         );
+      case "bundle_installations":
+        return collections.bundleInstallations.findOne(
+          createMongoInstallationWhere(input.where),
+          {
+            projection: WITHOUT_MONGO_ID,
+            ...mongoSessionOptions(session),
+            collation: { locale: "simple" },
+            readPreference: "primary",
+          },
+        );
     }
   },
   findMany: (input) => {