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

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"]>();
   });

package/src/adapters/prisma.ts

@@ -1,6 +1,8 @@
 import {
   createDatabasePlugin,
   DatabasePluginInputError,
+  type InsightsRecordInput,
+  type InsightsModel,
 } from "@hot-updater/plugin-core";
 import {
   createDatabasePluginAdapter,
@@ -30,6 +32,7 @@ import { createPrismaOrderBy, createPrismaWhere } from "./prismaQuery";
 import {
   getPrismaDelegate,
   parsePrismaBundleEventRow,
+  parsePrismaInsightsInstallationRow,
   parsePrismaBundleRow,
   parsePrismaChannelRow,
   parsePrismaApiKeyRow,
@@ -69,6 +72,7 @@ const runPrismaTransaction = <TResult>(
   client: PrismaTransactionClient,
   isolationLevel: "default" | "serializable",
   callback: (client: object) => Promise<TResult>,
+  retryUniqueConflict = false,
 ): Promise<TResult> => {
   const execute = () =>
     isolationLevel === "serializable"
@@ -86,7 +90,8 @@ const runPrismaTransaction = <TResult>(
           typeof error !== "object" ||
           error === null ||
           !("code" in error) ||
-          error.code !== "P2034"
+          (error.code !== "P2034" &&
+            !(retryUniqueConflict && error.code === "P2002"))
         ) {
           throw error;
         }
@@ -135,6 +140,8 @@ const findMany = async (
       return parsePrismaRows(rows, parsePrismaPatchRow);
     case "bundle_events":
       return parsePrismaRows(rows, parsePrismaBundleEventRow);
+    case "bundle_installations":
+      return parsePrismaRows(rows, parsePrismaInsightsInstallationRow);
     case "channels":
       return parsePrismaRows(rows, parsePrismaChannelRow);
     case "api_keys":
@@ -218,7 +225,9 @@ const createCrudImplementation = (
       const where =
         input.model === "channels"
           ? { name: input.data.name }
-          : { hash: input.data.hash };
+          : input.model === "api_keys"
+            ? { hash: input.data.hash }
+            : { install_id: input.data.install_id };
       row = await delegate.upsert({
         where,
         create: input.data,
@@ -234,6 +243,8 @@ const createCrudImplementation = (
         return parsePrismaPatchRow(row);
       case "bundle_events":
         return parsePrismaBundleEventRow(row);
+      case "bundle_installations":
+        return parsePrismaInsightsInstallationRow(row);
       case "channels":
         return parsePrismaChannelRow(row);
       case "api_keys":
@@ -245,6 +256,36 @@ const createCrudImplementation = (
     }
   },
   update: async (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 PrismaAdapterError(
+          "bundle_installations update requires install_id",
+        );
+      }
+      const delegate = getPrismaDelegate(client, "bundle_installations");
+      if (delegate.updateMany === undefined) {
+        throw new PrismaAdapterError(
+          'model delegate "bundle_installations" requires updateMany',
+        );
+      }
+      const result = await delegate.updateMany({
+        where: createPrismaWhere(input.where, provider),
+        data: input.update,
+      });
+      if (result.count === 0) return null;
+      const stored = await delegate.findFirst({
+        where: { install_id: installId },
+      });
+      return stored === null
+        ? null
+        : parsePrismaInsightsInstallationRow(stored);
+    }
     const id = input.where[0]?.value;
     if (typeof id !== "string") {
       throw new PrismaAdapterError(
@@ -343,6 +384,8 @@ const createCrudImplementation = (
         return parsePrismaReleaseRow(row);
       case "release_catalogs":
         return parsePrismaReleaseCatalogRow(row);
+      case "bundle_installations":
+        return parsePrismaInsightsInstallationRow(row);
     }
   },
   findMany: (input) => findMany(client, input, provider),
@@ -356,6 +399,48 @@ const createPrismaImplementation = (
   const crud = createCrudImplementation(client, provider, relationMode);
   const implementation: DatabasePluginImplementation = {
     ...crud,
+    recordInsights: (input: InsightsRecordInput) => {
+      if (!hasCallbackTransaction(client)) {
+        throw new PrismaAdapterError(
+          "Insights recording requires callback transactions",
+        );
+      }
+      return runPrismaTransaction(
+        client,
+        "serializable",
+        async (transactionClient) => {
+          const events = getPrismaDelegate(transactionClient, "bundle_events");
+          if (
+            (await events.findFirst({ where: { id: input.event.id } })) !== null
+          )
+            return;
+          await events.create({ data: input.event });
+          const installations = getPrismaDelegate(
+            transactionClient,
+            "bundle_installations",
+          );
+          const existing = await installations.findFirst({
+            where: { install_id: input.installation.install_id },
+          });
+          if (existing === null) {
+            await installations.create({ data: input.installation });
+            return;
+          }
+          const current = parsePrismaInsightsInstallationRow(existing);
+          if (
+            current.received_at_ms > input.installation.received_at_ms ||
+            (current.received_at_ms === input.installation.received_at_ms &&
+              current.id >= input.installation.id)
+          )
+            return;
+          await installations.update({
+            where: { install_id: input.installation.install_id },
+            data: input.installation,
+          });
+        },
+        true,
+      );
+    },
     deleteChannel: (input) => {
       if (!hasCallbackTransaction(client)) {
         throw new PrismaAdapterError(
@@ -442,10 +527,25 @@ export const prismaAdapter = (
       config.provider,
     ),
   );
+  const unsupportedMssqlInsights = async (): Promise<never> => {
+    throw new PrismaAdapterError(
+      "SQL Server Insights is unsupported: string keys pad trailing spaces and do not provide the required exact UTF-8 identity ordering",
+    );
+  };
+  const insights: InsightsModel =
+    config.provider === "mssql"
+      ? {
+          record: unsupportedMssqlInsights,
+          listEvents: unsupportedMssqlInsights,
+          findInstallations: unsupportedMssqlInsights,
+          countInstallations: unsupportedMssqlInsights,
+          countEvents: unsupportedMssqlInsights,
+        }
+      : adapter.models.insights;
   return Object.assign(
     createDatabasePlugin({
       name: "prisma",
-      models: adapter.models,
+      models: { ...adapter.models, insights },
       commit: adapter.commit,
     }),
     {

package/src/adapters/prismaRows.ts

@@ -4,6 +4,7 @@ import type {
   BundleRow,
   ChannelRow,
   ApiKeyRow,
+  InsightsInstallationRow,
   ReleaseCatalogRow,
   ReleaseRow,
 } from "@hot-updater/plugin-core";
@@ -19,7 +20,9 @@ export type PrismaDelegate = {
   readonly findFirst: (args?: PrismaQuery) => Promise<unknown>;
   readonly findMany: (args?: PrismaQuery) => Promise<readonly unknown[]>;
   readonly update: (args: PrismaQuery) => Promise<unknown>;
-  readonly updateMany?: (args: PrismaQuery) => Promise<unknown>;
+  readonly updateMany?: (
+    args: PrismaQuery,
+  ) => Promise<{ readonly count: number }>;
   readonly upsert: (args: PrismaQuery) => Promise<unknown>;
 };
 
@@ -48,6 +51,7 @@ const modelDelegates = {
   bundles: "bundles",
   bundle_patches: "bundle_patches",
   bundle_events: "bundle_events",
+  bundle_installations: "bundle_installations",
   channels: "channels",
   api_keys: "api_keys",
   releases: "releases",
@@ -196,6 +200,38 @@ export const parsePrismaBundleEventRow = (value: unknown): BundleEventRow => {
   } as BundleEventRow;
 };
 
+export const parsePrismaInsightsInstallationRow = (
+  value: unknown,
+): InsightsInstallationRow => {
+  if (!isRecord(value)) {
+    throw new PrismaAdapterError("invalid installation row");
+  }
+  const platform = readString(value, "platform");
+  const type = readString(value, "type");
+  if (
+    (platform !== "ios" && platform !== "android") ||
+    (type !== "UPDATE_APPLIED" &&
+      type !== "RECOVERED" &&
+      type !== "RELEASE_ADOPTED" &&
+      type !== "UNCHANGED")
+  ) {
+    throw new PrismaAdapterError("invalid installation fields");
+  }
+  return {
+    install_id: readString(value, "install_id"),
+    id: readString(value, "id"),
+    user_id: readNullableString(value, "user_id"),
+    username: readNullableString(value, "username"),
+    to_bundle_id: readString(value, "to_bundle_id"),
+    type,
+    platform,
+    app_version: readString(value, "app_version"),
+    channel: readString(value, "channel"),
+    cohort: readString(value, "cohort"),
+    received_at_ms: readNumber(value, "received_at_ms"),
+  };
+};
+
 export const parsePrismaApiKeyRow = (value: unknown): ApiKeyRow => {
   if (!isRecord(value)) {
     throw new PrismaAdapterError("invalid API key row");

package/src/adapters/prismaTestClient.ts

@@ -4,9 +4,11 @@ import type {
   BundleRow,
   ChannelRow,
   ApiKeyRow,
+  InsightsInstallationRow,
   ReleaseCatalogRow,
   ReleaseRow,
 } from "@hot-updater/plugin-core";
+import { compareInsightsText } from "@hot-updater/plugin-core";
 
 type Row =
   | BundleEventRow
@@ -14,6 +16,7 @@ type Row =
   | BundleRow
   | ChannelRow
   | ApiKeyRow
+  | InsightsInstallationRow
   | ReleaseRow
   | ReleaseCatalogRow;
 type Table = Row[];
@@ -21,6 +24,7 @@ type Tables = {
   bundle_patches: Table;
   bundles: Table;
   bundle_events: Table;
+  bundle_installations: Table;
   channels: Table;
   api_keys: Table;
   releases: Table;
@@ -60,7 +64,7 @@ const compare = (left: unknown, right: unknown): number => {
     return left - right;
   }
   if (typeof left === "string" && typeof right === "string") {
-    return left.localeCompare(right);
+    return compareInsightsText(left, right);
   }
   return 0;
 };
@@ -71,7 +75,12 @@ const normalize = (value: unknown, insensitive: boolean): unknown =>
 const readField = (row: Row, field: string): unknown =>
   Object.entries(row).find(([key]) => key === field)?.[1];
 
-const rowKey = (row: Row): string => ("id" in row ? row.id : row.scope_key);
+const rowKey = (model: keyof Tables, row: Row): string =>
+  model === "bundle_installations" && "install_id" in row
+    ? row.install_id
+    : "id" in row
+      ? row.id
+      : row.scope_key;
 
 const matchesCondition = (current: unknown, condition: unknown): boolean => {
   if (!isRecord(condition)) return Object.is(current, condition);
@@ -190,7 +199,9 @@ const createDelegate = (tables: Tables, model: keyof Tables, hooks: Hooks) => ({
   count: async (args?: QueryArgs): Promise<number> =>
     tables[model].filter((row) => matchesWhere(row, args?.where)).length,
   create: async ({ data }: CreateArgs): Promise<Row> => {
-    if (tables[model].some((row) => rowKey(row) === rowKey(data))) {
+    if (
+      tables[model].some((row) => rowKey(model, row) === rowKey(model, data))
+    ) {
       throw new PrismaTestConstraintError("duplicate id");
     }
     if (
@@ -220,7 +231,7 @@ const createDelegate = (tables: Tables, model: keyof Tables, hooks: Hooks) => ({
       matchesWhere(row, args?.where),
     );
     if (model === "bundles") {
-      const ids = new Set(selected.map(rowKey));
+      const ids = new Set(selected.map((row) => rowKey(model, row)));
       if (
         tables.releases.some(
           (row) =>
@@ -293,7 +304,9 @@ const createDelegate = (tables: Tables, model: keyof Tables, hooks: Hooks) => ({
       tables[model][index] = updated;
       return structuredClone(updated);
     }
-    if (tables[model].some((row) => rowKey(row) === rowKey(create))) {
+    if (
+      tables[model].some((row) => rowKey(model, row) === rowKey(model, create))
+    ) {
       throw new PrismaTestConstraintError("duplicate id");
     }
     assertReferences(tables, model, create);
@@ -304,6 +317,7 @@ const createDelegate = (tables: Tables, model: keyof Tables, hooks: Hooks) => ({
 
 const createClient = (tables: Tables, hooks: Hooks) => ({
   bundle_events: createDelegate(tables, "bundle_events", hooks),
+  bundle_installations: createDelegate(tables, "bundle_installations", hooks),
   bundle_patches: createDelegate(tables, "bundle_patches", hooks),
   bundles: createDelegate(tables, "bundles", hooks),
   channels: createDelegate(tables, "channels", hooks),
@@ -317,6 +331,7 @@ export const createPrismaTestHarness = () => {
     bundle_patches: [],
     bundles: [],
     bundle_events: [],
+    bundle_installations: [],
     channels: [],
     api_keys: [],
     releases: [],
@@ -347,6 +362,7 @@ export const createPrismaTestHarness = () => {
         tables.bundle_patches = transactionTables.bundle_patches;
         tables.bundles = transactionTables.bundles;
         tables.bundle_events = transactionTables.bundle_events;
+        tables.bundle_installations = transactionTables.bundle_installations;
         tables.channels = transactionTables.channels;
         tables.api_keys = transactionTables.api_keys;
         tables.releases = transactionTables.releases;
@@ -387,6 +403,7 @@ export const createPrismaTestHarness = () => {
       tables.bundle_patches = [];
       tables.bundles = [];
       tables.bundle_events = [];
+      tables.bundle_installations = [];
       tables.channels = [];
       tables.api_keys = [];
       tables.releases = [];

package/src/apiKeys.integration.spec.ts

@@ -59,7 +59,7 @@ describe("createHotUpdater API keys", () => {
     expect(
       (
         await hotUpdater.handlers.admin(
-          withApiKey("https://example.com/installations/overview"),
+          withApiKey("https://example.com/events"),
         )
       ).status,
     ).toBe(200);