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

package/src/adapters/drizzleLazyDB.ts

@@ -3,6 +3,7 @@ import type {
   BundlePatchRow,
   ChannelRow,
   ApiKeyRow,
+  InsightsInstallationRow,
   ReleaseCatalogRow,
 } from "@hot-updater/plugin-core";
 
@@ -13,10 +14,14 @@ export type DrizzleTable = Record<string, unknown>;
 
 type DrizzleMutation = {
   readonly execute: () => Promise<unknown>;
+  readonly all?: () => unknown[];
+  readonly run?: () => unknown;
 };
 
 export type DrizzleInsertMutation = DrizzleMutation & {
-  readonly onConflictDoNothing?: () => DrizzleMutation;
+  readonly onDuplicateKeyUpdate?: (config: { set: object }) => DrizzleMutation;
+  readonly onConflictDoNothing?: () => DrizzleInsertMutation;
+  readonly returning?: (fields: Record<string, unknown>) => DrizzleMutation;
 };
 
 type DrizzleInsertBuilder = {
@@ -30,6 +35,7 @@ type DrizzleQuery<TRow> = {
 };
 
 export type DrizzleDB = {
+  readonly resultKind?: "sync" | "async";
   readonly _: { readonly fullSchema: Record<string, DrizzleTable> };
   readonly $count: (table: DrizzleTable, where?: unknown) => Promise<number>;
   readonly delete: (table: DrizzleTable) => {
@@ -41,6 +47,7 @@ export type DrizzleDB = {
     readonly channels: DrizzleQuery<ChannelRow>;
     readonly bundle_patches: DrizzleQuery<BundlePatchRow>;
     readonly bundle_events: DrizzleQuery<BundleEventRow>;
+    readonly bundle_installations: DrizzleQuery<InsightsInstallationRow>;
     readonly api_keys: DrizzleQuery<ApiKeyRow>;
     readonly releases: DrizzleQuery<StoredReleaseRow>;
     readonly release_catalogs: DrizzleQuery<ReleaseCatalogRow>;
@@ -51,7 +58,7 @@ export type DrizzleDB = {
     };
   };
   readonly transaction?: <TResult>(
-    operation: (transaction: DrizzleDB) => Promise<TResult>,
+    operation: (transaction: DrizzleDB) => TResult | Promise<TResult>,
   ) => Promise<TResult>;
 };
 
@@ -82,6 +89,7 @@ const isDrizzleDB = (value: unknown): value is DrizzleDB => {
   if (
     !isRecord(query) ||
     !isDrizzleQuery(query["bundle_events"]) ||
+    !isDrizzleQuery(query["bundle_installations"]) ||
     !isDrizzleQuery(query["bundle_patches"]) ||
     !isDrizzleQuery(query["bundles"]) ||
     !isDrizzleQuery(query["channels"]) ||
@@ -193,6 +201,12 @@ export const createLazyDB = (config: DrizzleConfig): DrizzleDB => {
         findMany: async (args) =>
           (await getDB()).query.bundle_events.findMany(args),
       },
+      bundle_installations: {
+        findFirst: async (args) =>
+          (await getDB()).query.bundle_installations.findFirst(args),
+        findMany: async (args) =>
+          (await getDB()).query.bundle_installations.findMany(args),
+      },
       bundle_patches: {
         findFirst: async (args) =>
           (await getDB()).query.bundle_patches.findFirst(args),
@@ -241,7 +255,7 @@ export const createLazyDB = (config: DrizzleConfig): DrizzleDB => {
     ...(config.transaction === true
       ? {
           transaction: async <TResult>(
-            operation: (transaction: DrizzleDB) => Promise<TResult>,
+            operation: (transaction: DrizzleDB) => TResult | Promise<TResult>,
           ): Promise<TResult> => {
             const db = await getDB();
             if (db.transaction === undefined) {

package/src/adapters/insightsTransaction.ts

@@ -0,0 +1,32 @@
+const isRetryableConflict = (error: unknown): boolean => {
+  if (typeof error !== "object" || error === null) return false;
+  if (
+    "code" in error &&
+    [
+      "ER_DUP_ENTRY",
+      "ER_LOCK_DEADLOCK",
+      "ER_LOCK_WAIT_TIMEOUT",
+      "40001",
+      "40P01",
+    ].includes(String(error.code))
+  )
+    return true;
+  return (
+    "cause" in error &&
+    error.cause !== error &&
+    isRetryableConflict(error.cause)
+  );
+};
+
+export const runInsightsTransaction = async (
+  operation: () => Promise<void>,
+): Promise<void> => {
+  for (let attempt = 0; ; attempt += 1) {
+    try {
+      await operation();
+      return;
+    } catch (error) {
+      if (attempt >= 2 || !isRetryableConflict(error)) throw error;
+    }
+  }
+};

package/src/adapters/kysely.spec.ts

@@ -1,10 +1,12 @@
 import { PGlite } from "@electric-sql/pglite";
+import { toInsightsInstallationRow } from "@hot-updater/plugin-core";
 import { Kysely } from "kysely";
 import { PGliteDialect } from "kysely-pglite-dialect";
 import { describe, expect, it } from "vitest";
 
 import {
   createBundlePatchRowFixture,
+  createBundleEventRowFixture,
   createBundleRowFixture,
   createChannelRowFixture,
 } from "../../../test-utils/src/databaseTestFixtures";
@@ -54,6 +56,33 @@ setupDatabasePluginTestSuite({
 });
 
 describe("kyselyAdapter SQLite JSON storage", () => {
+  it("rolls back the event when the installation write fails and permits retry", async () => {
+    const db = new PGlite();
+    const kysely = new Kysely<object>({ dialect: new PGliteDialect(db) });
+    await db.exec(DATABASE_PLUGIN_TEST_SCHEMA_SQL);
+    await db.exec(
+      "alter table bundle_installations add constraint reject_snapshot check (install_id <> 'install-703')",
+    );
+    const plugin = kyselyAdapter({ db: kysely, provider: "postgresql" });
+    const event = createBundleEventRowFixture("703", 100);
+    const input = { event, installation: toInsightsInstallationRow(event) };
+    try {
+      await expect(plugin.models.insights.record(input)).rejects.toThrow();
+      expect((await db.query("select id from bundle_events")).rows).toEqual([]);
+      await db.exec(
+        "alter table bundle_installations drop constraint reject_snapshot",
+      );
+      await plugin.models.insights.record(input);
+      await expect(
+        plugin.models.insights.findInstallations({
+          installId: event.install_id,
+        }),
+      ).resolves.toEqual([input.installation]);
+    } finally {
+      await kysely.destroy();
+      await db.close();
+    }
+  });
   it("round-trips JSON values through text columns", async () => {
     const sqliteClient = new PGlite();
     const sqliteDatabase = new Kysely<object>({

package/src/adapters/kysely.ts

@@ -11,7 +11,8 @@ import type {
   ORMSQLProvider,
   RelationMode,
 } from "../db/types";
-import { createKyselyCrud } from "./kyselyCrud";
+import { runInsightsTransaction } from "./insightsTransaction";
+import { createKyselyCrud, recordKyselyInsights } from "./kyselyCrud";
 
 type KyselySQLProvider = Exclude<ORMSQLProvider, "mssql">;
 
@@ -31,6 +32,14 @@ const createImplementation = <TDatabase extends object>(
   const crud = createKyselyCrud(db, config.provider, relationMode);
   return {
     ...crud,
+    recordInsights: (input) =>
+      runInsightsTransaction(() =>
+        db
+          .transaction()
+          .execute((transaction) =>
+            recordKyselyInsights(transaction, config.provider, input),
+          ),
+      ),
     deleteChannel: (input) =>
       db
         .transaction()

package/src/adapters/kyselyCrud.ts

@@ -4,6 +4,8 @@ import {
   type BundlePatchRow,
   type ChannelRow,
   type ApiKeyRow,
+  type InsightsInstallationRow,
+  type InsightsRecordInput,
   type ReleaseCatalogRow,
 } from "@hot-updater/plugin-core";
 import type {
@@ -54,6 +56,7 @@ const whereClause = (
 const orderClause = (
   input:
     | {
+        readonly model?: string;
         readonly orderBy?: readonly {
           readonly direction: "asc" | "desc";
           readonly field: string;
@@ -67,6 +70,14 @@ const orderClause = (
   return sql` order by ${sql.join(
     clauses.map((clause) => {
       const field = sql.ref(clause.field);
+      if (
+        input?.model === "bundle_events" ||
+        input?.model === "bundle_installations"
+      ) {
+        return clause.direction === "asc"
+          ? sql`${field} asc`
+          : sql`${field} desc`;
+      }
       const nulls =
         clause.nulls ?? (clause.direction === "asc" ? "last" : "first");
       const nullOrder =
@@ -110,6 +121,46 @@ const insertRow = async (
   return Number(result.numAffectedRows ?? 0) > 0;
 };
 
+export const recordKyselyInsights = async (
+  executor: QueryExecutorProvider,
+  provider: Exclude<ORMSQLProvider, "mssql">,
+  { event, installation }: InsightsRecordInput,
+): Promise<void> => {
+  const insert = (table: string, row: object) => {
+    const entries = Object.entries(row);
+    return sql`insert into ${sql.table(table)} (${sql.join(entries.map(([field]) => sql.ref(field)))}) values (${sql.join(entries.map(([, value]) => value))})`;
+  };
+  if (provider === "mysql") {
+    const existing = await sql<{
+      id: string;
+    }>`select id from bundle_events where id = ${event.id} for update`.execute(
+      executor,
+    );
+    if (existing.rows.length > 0) return;
+    await insert("bundle_events", event).execute(executor);
+    await sql`${insert("bundle_installations", installation)} on duplicate key update install_id = ${installation.install_id}`.execute(
+      executor,
+    );
+  } else {
+    const result =
+      await sql`${insert("bundle_events", event)} on conflict (id) do nothing returning id`.execute(
+        executor,
+      );
+    if (result.rows.length === 0) return;
+    await sql`${insert("bundle_installations", installation)} on conflict (install_id) do nothing`.execute(
+      executor,
+    );
+  }
+  const assignments = Object.entries(installation).map(
+    ([field, value]) => sql`${sql.ref(field)} = ${value}`,
+  );
+  await sql`update ${sql.table("bundle_installations")} set ${sql.join(assignments)}
+    where ${sql.ref("install_id")} = ${installation.install_id}
+    and (${sql.ref("received_at_ms")} < ${installation.received_at_ms}
+      or (${sql.ref("received_at_ms")} = ${installation.received_at_ms}
+        and ${sql.ref("id")} < ${installation.id}))`.execute(executor);
+};
+
 const updateBundle = async (
   executor: QueryExecutorProvider,
   id: string,
@@ -298,6 +349,15 @@ export const createKyselyCrud = (
       case "bundle_events":
         await insertRow(executor, "bundle_events", input.data, provider);
         return input.data;
+      case "bundle_installations":
+        await insertRow(
+          executor,
+          "bundle_installations",
+          input.data,
+          provider,
+          input.onConflict,
+        );
+        return input.data;
       case "releases":
         await insertRow(
           executor,
@@ -330,6 +390,38 @@ export const createKyselyCrud = (
     }
   },
   async update(input) {
+    if (input.model === "bundle_installations") {
+      const installId = input.where.find(
+        (item) =>
+          item.field === "install_id" &&
+          (item.operator === undefined || item.operator === "eq") &&
+          typeof item.value === "string",
+      )?.value;
+      if (typeof installId !== "string") {
+        throw new KyselyAdapterInvariantError(
+          "bundle_installations.update.selector",
+        );
+      }
+      const assignments = Object.entries(input.update)
+        .filter(([, value]) => value !== undefined)
+        .map(([field, value]) => sql`${sql.ref(field)} = ${value}`);
+      const where = buildKyselyWhere(provider, input.where);
+      let updated = false;
+      if (assignments.length > 0 && where !== undefined) {
+        const result = await sql`update ${sql.table(
+          "bundle_installations",
+        )} set ${sql.join(assignments)} where ${where}`.execute(executor);
+        updated = Number(result.numAffectedRows ?? 0) > 0;
+      }
+      if (!updated) return null;
+      const result =
+        await sql<InsightsInstallationRow>`select * from ${sql.table(
+          "bundle_installations",
+        )} where ${sql.ref("install_id")} = ${installId} limit 1`.execute(
+          executor,
+        );
+      return result.rows[0] ?? null;
+    }
     const selector = input.where[0];
     if (selector === undefined || typeof selector.value !== "string") {
       throw new KyselyAdapterInvariantError(`${input.model}.update.selector`);
@@ -452,6 +544,12 @@ export const createKyselyCrud = (
       throw new DatabasePluginInputError("invalid-operation");
     }
     switch (input.model) {
+      case "bundle_events":
+        return countRows(
+          executor,
+          "bundle_events",
+          buildKyselyWhere(provider, input.where),
+        );
       case "bundles":
         return countRows(
           executor,
@@ -470,6 +568,12 @@ export const createKyselyCrud = (
           "releases",
           buildKyselyWhere(provider, input.where),
         );
+      case "bundle_installations":
+        return countRows(
+          executor,
+          "bundle_installations",
+          buildKyselyWhere(provider, input.where),
+        );
     }
   },
   async findOne(input) {
@@ -519,6 +623,14 @@ export const createKyselyCrud = (
         const row = result.rows[0];
         return row === undefined ? null : fromStoredReleaseCatalogRow(row);
       }
+      case "bundle_installations": {
+        const where = whereClause(buildKyselyWhere(provider, input.where));
+        const result =
+          await sql<InsightsInstallationRow>`select * from ${sql.table(
+            "bundle_installations",
+          )}${where} limit 1`.execute(executor);
+        return result.rows[0] ?? null;
+      }
     }
   },
   async findMany(input) {
@@ -551,6 +663,15 @@ export const createKyselyCrud = (
         )}${where}${order}${pagination}`.execute(executor);
         return [...result.rows];
       }
+      case "bundle_installations": {
+        const where = whereClause(buildKyselyWhere(provider, input.where));
+        const order = orderClause(input);
+        const result =
+          await sql<InsightsInstallationRow>`select * from ${sql.table(
+            "bundle_installations",
+          )}${where}${order}${pagination}`.execute(executor);
+        return [...result.rows];
+      }
       case "api_keys": {
         const where = whereClause(buildKyselyWhere(provider, input.where));
         const order = orderClause(input);

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");