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

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) => {

package/src/adapters/mongodbTestClient.ts

@@ -12,6 +12,7 @@ type Tables = {
   bundle_patches: MongoTestRow[];
   bundles: MongoTestRow[];
   bundle_events: MongoTestRow[];
+  bundle_installations: MongoTestRow[];
   channels: MongoTestRow[];
   api_keys: MongoTestRow[];
   releases: MongoTestRow[];
@@ -25,6 +26,7 @@ type UpdateInput =
 type MongoTestHooks = {
   beforeBundlePatchInsert?: () => Promise<void>;
   failNextBundleTombstone: boolean;
+  failNextInstallationWrite: boolean;
   operationCount: number;
 };
 
@@ -149,11 +151,24 @@ const createCollection = (
   },
   insertOne: async (row: MongoTestRow): Promise<void> => {
     hooks.operationCount += 1;
+    if (model === "bundle_installations" && hooks.failNextInstallationWrite) {
+      hooks.failNextInstallationWrite = false;
+      throw new MongoTestConstraintError("injected installation write failure");
+    }
     if (model === "bundle_patches") await hooks.beforeBundlePatchInsert?.();
-    const key = "id" in row ? row.id : row.scope_key;
+    const key =
+      model === "bundle_installations" && "install_id" in row
+        ? row.install_id
+        : "id" in row
+          ? row.id
+          : row.scope_key;
     if (
       tables[model].some((candidate) =>
-        "id" in candidate ? candidate.id === key : candidate.scope_key === key,
+        model === "bundle_installations" && "install_id" in candidate
+          ? candidate.install_id === key
+          : "id" in candidate
+            ? candidate.id === key
+            : candidate.scope_key === key,
       )
     ) {
       throw new MongoTestConstraintError("duplicate id");
@@ -197,6 +212,10 @@ const createCollection = (
     options?: { readonly upsert?: boolean },
   ): Promise<{ matchedCount: number; upsertedCount: number }> => {
     hooks.operationCount += 1;
+    if (model === "bundle_installations" && hooks.failNextInstallationWrite) {
+      hooks.failNextInstallationWrite = false;
+      throw new MongoTestConstraintError("injected installation write failure");
+    }
     const index = tables[model].findIndex((row) =>
       matchesMongoTestFilter(row, filter),
     );
@@ -211,12 +230,18 @@ const createCollection = (
     }
     if (options?.upsert === true && "$setOnInsert" in update) {
       const key =
-        "id" in update.$setOnInsert
-          ? update.$setOnInsert.id
-          : update.$setOnInsert.scope_key;
+        model === "bundle_installations" && "install_id" in update.$setOnInsert
+          ? update.$setOnInsert.install_id
+          : "id" in update.$setOnInsert
+            ? update.$setOnInsert.id
+            : update.$setOnInsert.scope_key;
       if (
         tables[model].some((row) =>
-          "id" in row ? row.id === key : row.scope_key === key,
+          model === "bundle_installations" && "install_id" in row
+            ? row.install_id === key
+            : "id" in row
+              ? row.id === key
+              : row.scope_key === key,
         )
       ) {
         throw new MongoTestConstraintError("duplicate id");
@@ -237,6 +262,8 @@ const createDatabase = (tables: Tables, hooks: MongoTestHooks) => ({
         return createCollection(tables, "bundle_patches", hooks);
       case "bundle_events":
         return createCollection(tables, "bundle_events", hooks);
+      case "bundle_installations":
+        return createCollection(tables, "bundle_installations", hooks);
       case "channels":
         return createCollection(tables, "channels", hooks);
       case "api_keys":
@@ -256,6 +283,7 @@ export const createMongoTestHarness = () => {
     bundle_patches: [],
     bundles: [],
     bundle_events: [],
+    bundle_installations: [],
     channels: [],
     api_keys: [],
     releases: [],
@@ -263,6 +291,7 @@ export const createMongoTestHarness = () => {
   };
   const hooks: MongoTestHooks = {
     failNextBundleTombstone: false,
+    failNextInstallationWrite: false,
     operationCount: 0,
   };
   let activeTables = tables;
@@ -290,6 +319,7 @@ export const createMongoTestHarness = () => {
             tables.bundle_patches = staged.bundle_patches;
             tables.bundles = staged.bundles;
             tables.bundle_events = staged.bundle_events;
+            tables.bundle_installations = staged.bundle_installations;
             tables.channels = staged.channels;
             tables.api_keys = staged.api_keys;
             tables.releases = staged.releases;
@@ -309,11 +339,13 @@ export const createMongoTestHarness = () => {
     close: () => client.close(),
     reset: (): void => {
       hooks.failNextBundleTombstone = false;
+      hooks.failNextInstallationWrite = false;
       hooks.operationCount = 0;
       transactionQueue = Promise.resolve();
       tables.bundle_patches = [];
       tables.bundles = [];
       tables.bundle_events = [];
+      tables.bundle_installations = [];
       tables.channels = [];
       tables.api_keys = [];
       tables.releases = [];
@@ -328,6 +360,9 @@ export const createMongoTestHarness = () => {
     failNextBundleTombstone: (): void => {
       hooks.failNextBundleTombstone = true;
     },
+    failNextInstallationWrite: (): void => {
+      hooks.failNextInstallationWrite = true;
+    },
     setBundleField: (id: string, field: string, value: unknown): void => {
       const row = tables.bundles.find(
         (candidate) => "id" in candidate && candidate.id === id,

package/src/adapters/mongodbTestFilter.ts

@@ -1,5 +1,6 @@
 import type {
   BundleEventRow,
+  InsightsInstallationRow,
   BundlePatchRow,
   BundleRow,
   ChannelRow,
@@ -10,6 +11,7 @@ import type {
 
 export type MongoTestRow =
   | BundleEventRow
+  | InsightsInstallationRow
   | BundlePatchRow
   | BundleRow
   | ChannelRow
@@ -28,7 +30,7 @@ const compare = (left: unknown, right: unknown): number => {
     return left - right;
   }
   if (typeof left === "string" && typeof right === "string") {
-    return left.localeCompare(right);
+    return Buffer.compare(Buffer.from(left), Buffer.from(right));
   }
   return 0;
 };
@@ -100,6 +102,7 @@ const resolveExpression = (row: MongoTestRow, expression: unknown): unknown => {
 
 const matchesField = (current: unknown, condition: unknown): boolean => {
   if (!isRecord(condition)) return Object.is(current, condition);
+  if ("$eq" in condition) return Object.is(current, condition["$eq"]);
   if (typeof condition["$exists"] === "boolean") {
     return condition["$exists"] ? current !== undefined : current === undefined;
   }

package/src/adapters/mongodbWrites.ts

@@ -11,10 +11,12 @@ import {
   MongoAdapterConstraintError,
   mongoSessionOptions,
   WITHOUT_INTERNAL_FIELDS,
+  WITHOUT_MONGO_ID,
 } from "./mongodbCollections";
 import {
   createMongoBundleWhere,
   createMongoChannelWhere,
+  createMongoInstallationWhere,
   createMongoApiKeyWhere,
   createMongoPatchWhere,
   createMongoReleaseCatalogWhere,
@@ -116,6 +118,20 @@ export const createMongoWrites = (
           mongoSessionOptions(session),
         );
         return input.data;
+      case "bundle_installations":
+        if (input.onConflict === "ignore") {
+          await collections.bundleInstallations.updateOne(
+            { install_id: input.data.install_id },
+            { $setOnInsert: input.data },
+            { upsert: true, ...mongoSessionOptions(session) },
+          );
+          return input.data;
+        }
+        await collections.bundleInstallations.insertOne(
+          input.data,
+          mongoSessionOptions(session),
+        );
+        return input.data;
       case "releases":
         await collections.releases.insertOne(
           input.data,
@@ -159,6 +175,17 @@ export const createMongoWrites = (
     }
   },
   update: async (input) => {
+    if (input.model === "bundle_installations") {
+      return collections.bundleInstallations.findOneAndUpdate(
+        createMongoInstallationWhere(input.where),
+        { $set: input.update },
+        {
+          projection: WITHOUT_MONGO_ID,
+          returnDocument: "after",
+          ...mongoSessionOptions(session),
+        },
+      );
+    }
     if (input.model === "api_keys") {
       return collections.apiKeys.findOneAndUpdate(
         createMongoApiKeyWhere(input.where),

package/src/adapters/prisma.spec.ts

@@ -1,5 +1,7 @@
+import { toInsightsInstallationRow } from "@hot-updater/plugin-core";
 import { describe, expect, expectTypeOf, it } from "vitest";
 
+import { createBundleEventRowFixture } from "../../../test-utils/src/databaseTestFixtures";
 import { setupDatabasePluginTestSuite } from "../../../test-utils/src/setupDatabasePluginTestSuite";
 import { prismaAdapter, type PrismaConfig } from "./prisma";
 import { createPrismaTestHarness } from "./prismaTestClient";
@@ -34,6 +36,101 @@ const productionChannel = {
 } as const;
 
 describe("prismaAdapter capabilities", () => {
+  it("rejects every SQL Server Insights operation before touching the database", async () => {
+    const plugin = prismaAdapter({ prisma: {}, provider: "mssql" });
+    expect(plugin.generateSchema?.("latest").code).not.toContain(
+      "bundle_events_to_bundle_idx",
+    );
+    expect(plugin.generateSchema?.("latest").code).toContain(
+      "releases_scope_order_idx",
+    );
+    const event = createBundleEventRowFixture("707", 100);
+    const filter = {
+      platform: "ios" as const,
+      channel: "production",
+      type: "UPDATE_APPLIED" as const,
+      toBundleId: event.to_bundle_id,
+    };
+    const calls = [
+      plugin.models.insights.record({
+        event,
+        installation: toInsightsInstallationRow(event),
+      }),
+      plugin.models.insights.listEvents({
+        filter: { kind: "all" },
+        beforeReceivedAtMs: 101,
+        limit: 10,
+      }),
+      plugin.models.insights.findInstallations({ installId: event.install_id }),
+      plugin.models.insights.countInstallations({
+        platform: "ios",
+        channel: "production",
+        sinceMs: 0,
+      }),
+      plugin.models.insights.countEvents({
+        filter,
+        sinceMs: 0,
+        beforeReceivedAtMs: 101,
+      }),
+    ];
+    for (const call of calls)
+      await expect(call).rejects.toThrow("SQL Server Insights is unsupported");
+  });
+  it("requires callback transactions before recording Insights", async () => {
+    const { $transaction: _transaction, ...client } = harness.client;
+    const plugin = prismaAdapter({ prisma: client, provider: "postgresql" });
+    const event = createBundleEventRowFixture("704", 100);
+    await expect(
+      plugin.models.insights.record({
+        event,
+        installation: toInsightsInstallationRow(event),
+      }),
+    ).rejects.toThrow("Insights recording requires callback transactions");
+  });
+
+  it("rolls back event insertion on an installation write failure", async () => {
+    const isolated = createPrismaTestHarness();
+    const event = createBundleEventRowFixture("705", 100);
+    const input = { event, installation: toInsightsInstallationRow(event) };
+    const client = {
+      ...isolated.client,
+      $transaction: <TResult>(
+        callback: (transaction: object) => Promise<TResult>,
+      ) =>
+        isolated.client.$transaction((transaction) =>
+          callback({
+            ...transaction,
+            bundle_installations: {
+              ...Reflect.get(transaction, "bundle_installations"),
+              create: async () => {
+                throw new Error("injected snapshot failure");
+              },
+            },
+          }),
+        ),
+    };
+    const plugin = prismaAdapter({ prisma: client, provider: "postgresql" });
+    await expect(plugin.models.insights.record(input)).rejects.toThrow(
+      "injected snapshot failure",
+    );
+    const working = prismaAdapter({
+      prisma: isolated.client,
+      provider: "postgresql",
+    });
+    await expect(
+      working.models.insights.listEvents({
+        filter: { kind: "all" },
+        beforeReceivedAtMs: 101,
+        limit: 10,
+      }),
+    ).resolves.toEqual([]);
+    await working.models.insights.record(input);
+    await expect(
+      working.models.insights.findInstallations({
+        installId: event.install_id,
+      }),
+    ).resolves.toEqual([input.installation]);
+  });
   it("excludes MongoDB from the public configuration", () => {
     expectTypeOf<"mongodb">().not.toMatchTypeOf<PrismaConfig["provider"]>();
   });