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

package/src/createHotUpdaterCore.ts

@@ -1,5 +1,6 @@
 import {
   assertStorageOperations,
+  type InsightsModel,
   type StoragePlugin,
 } from "@hot-updater/plugin-core";
 
@@ -18,7 +19,7 @@ import {
   isDatabasePlugin,
 } from "./db/types";
 import { createHotUpdaterHandlers, type HotUpdaterHandlers } from "./handler";
-import { createInsightsProvider } from "./insights/bounded/provider";
+import { createInsightsProvider } from "./insights/provider";
 import type { InsightsProvider } from "./insights/types";
 import { createStorageAccess } from "./storageAccess";
 
@@ -168,16 +169,29 @@ export function createHotUpdaterCore(
     readStorageText,
   });
   const clientAccess = normalizeClientAccess(options.clientAccess);
-  const insights = createInsightsProvider({
-    async append(row) {
+  const insightsModel: InsightsModel = {
+    async record(input) {
       await assertSchemaReady();
-      return plugin.models.insights.append(row);
+      return plugin.models.insights.record(input);
     },
-    async scan(input) {
+    async listEvents(input) {
       await assertSchemaReady();
-      return plugin.models.insights.scan(input);
+      return plugin.models.insights.listEvents(input);
     },
-  });
+    async findInstallations(input) {
+      await assertSchemaReady();
+      return plugin.models.insights.findInstallations(input);
+    },
+    async countInstallations(input) {
+      await assertSchemaReady();
+      return plugin.models.insights.countInstallations(input);
+    },
+    async countEvents(input) {
+      await assertSchemaReady();
+      return plugin.models.insights.countEvents(input);
+    },
+  };
+  const insights = createInsightsProvider(insightsModel);
   const apiKeys = createApiKeyManagement({
     apiKeys: plugin.models.apiKeys,
     beforeOperation: assertSchemaReady,

package/src/db/databasePluginUpdateCheck.bench.ts

@@ -54,6 +54,9 @@ class BenchmarkMutationError extends Error {
 
 const name = "release-catalog-benchmark";
 const adapter = createDatabasePluginAdapter(name, {
+  async recordInsights() {
+    throw new BenchmarkMutationError();
+  },
   async count() {
     return 0;
   },

package/src/db/fixedMigrator.spec.ts

@@ -1,11 +1,14 @@
 import { DatabaseSync, type SqliteValue } from "node:sqlite";
 
 import { PGlite } from "@electric-sql/pglite";
+import { toInsightsInstallationRow } from "@hot-updater/plugin-core";
 import { Kysely, SqliteDialect } from "kysely";
 import { PGliteDialect } from "kysely-pglite-dialect";
 import { afterEach, describe, expect, it, vi } from "vitest";
 
+import { createBundleEventRowFixture } from "../../../test-utils/src/databaseTestFixtures";
 import { createInMemoryDatabasePlugin } from "../../../test-utils/test/inMemoryDatabasePlugin";
+import { kyselyAdapter } from "../adapters/kysely";
 import { createDatabasePluginCore } from "./databasePluginCore";
 import { createKyselyMigrator } from "./fixedMigrator";
 import { createSchemaReadinessChecker } from "./schemaReadiness";
@@ -54,6 +57,68 @@ describe("Kysely migrator", () => {
     await Promise.all(databases.splice(0).map((db) => db.close()));
   });
 
+  it("creates the final Insights access paths in the initial schema", async () => {
+    const database = new PGlite();
+    databases.push(database);
+    const kysely = new Kysely<SettingsDatabase>({
+      dialect: new PGliteDialect(database),
+    });
+    kyselyInstances.push(kysely);
+    const migrator = createKyselyMigrator({
+      db: kysely,
+      provider: "postgresql",
+    });
+    await expect(migrator.next()).resolves.toEqual({ version: "1.0.0" });
+    await expect(migrator.previous()).resolves.toBeUndefined();
+    const migration = await migrator.migrateToLatest();
+    await migration.execute();
+    await expect(migrator.getVersion()).resolves.toBe("1.0.0");
+    const plugin = kyselyAdapter({ db: kysely, provider: "postgresql" });
+    const event = createBundleEventRowFixture("706", 100);
+    const input = { event, installation: toInsightsInstallationRow(event) };
+    await plugin.models.insights.record(input);
+
+    const repeated = await migrator.migrateToLatest();
+    expect(repeated.operations).toEqual([]);
+    expect(repeated.getSQL?.()).toBe("");
+    await repeated.execute();
+    await expect(migrator.next()).resolves.toBeUndefined();
+    await expect(
+      plugin.models.insights.findInstallations({ installId: event.install_id }),
+    ).resolves.toEqual([input.installation]);
+    await expect(
+      plugin.models.insights.countEvents({
+        filter: {
+          platform: "ios",
+          channel: "production",
+          type: "UPDATE_APPLIED",
+          toBundleId: event.to_bundle_id,
+        },
+        sinceMs: 0,
+        beforeReceivedAtMs: 101,
+      }),
+    ).resolves.toBe(1);
+    const indexes = await database.query<{ indexname: string }>(
+      "select indexname from pg_indexes where tablename in ('bundle_events', 'bundle_installations')",
+    );
+    expect(indexes.rows.map(({ indexname }) => indexname)).toEqual(
+      expect.arrayContaining([
+        "bundle_events_from_bundle_idx",
+        "bundle_events_to_bundle_idx",
+        "bundle_installations_scope_idx",
+        "bundle_installations_bundle_idx",
+      ]),
+    );
+    await database.exec("set enable_seqscan = off");
+    const plan = await database.query<{ "QUERY PLAN": string }>(
+      "explain select * from bundle_events where type = 'UPDATE_APPLIED' and platform = 'ios' and channel = 'production' and to_bundle_id = $1 and received_at_ms < 101 order by received_at_ms desc, id desc limit 10",
+      [event.to_bundle_id],
+    );
+    expect(plan.rows.map((row) => row["QUERY PLAN"]).join("\n")).toContain(
+      "bundle_events_to_bundle_idx",
+    );
+  });
+
   it("creates schema 1.0.0 from an empty database", async () => {
     const database = new PGlite();
     databases.push(database);

package/src/db/fixedMigratorMongo.spec.ts

@@ -2,6 +2,7 @@ import { MongoClient } from "mongodb";
 import { describe, expect, it, vi } from "vitest";
 
 import { createInMemoryDatabasePlugin } from "../../../test-utils/test/inMemoryDatabasePlugin";
+import { HOT_UPDATER_SCHEMA_VERSION } from "../schema/types";
 import { createDatabasePluginCore } from "./databasePluginCore";
 import { createMongoMigrator } from "./fixedMigrator";
 import { createSchemaReadinessChecker } from "./schemaReadiness";
@@ -29,7 +30,7 @@ function createSettingsMongoClient(
 }
 
 describe("MongoDB migration", () => {
-  it("creates schema 1.0.0 from an empty database", async () => {
+  it("creates the current schema from an empty database", async () => {
     const settings = new Map<string, unknown>();
     const settingsCollection = {
       find: ({ key }: { readonly key: string }) => ({
@@ -50,7 +51,7 @@ describe("MongoDB migration", () => {
     const modelCollection = {
       find: () => ({ toArray: async () => [] }),
       listIndexes: () => ({ toArray: async () => [] }),
-      createIndex: async () => "created",
+      createIndex: vi.fn(async () => "created"),
     };
     const command = vi.fn(
       async (_input: Record<string, unknown>): Promise<void> => undefined,
@@ -76,7 +77,47 @@ describe("MongoDB migration", () => {
       { key: 1 },
       { unique: true },
     );
-    expect(settings.get("schema.core")).toBe("1.0.0");
+    expect(settings.get("schema.core")).toBe(HOT_UPDATER_SCHEMA_VERSION);
+    expect(modelCollection.createIndex).toHaveBeenCalledWith(
+      { install_id: 1 },
+      {
+        name: "bundle_installations_install_id_idx",
+        unique: true,
+        collation: { locale: "simple" },
+      },
+    );
+    expect(modelCollection.createIndex).toHaveBeenCalledWith(
+      {
+        type: 1,
+        platform: 1,
+        channel: 1,
+        from_bundle_id: 1,
+        received_at_ms: 1,
+        id: 1,
+      },
+      {
+        name: "bundle_events_from_bundle_idx",
+        collation: { locale: "simple" },
+      },
+    );
+    expect(modelCollection.createIndex).toHaveBeenCalledWith(
+      {
+        type: 1,
+        platform: 1,
+        channel: 1,
+        to_bundle_id: 1,
+        received_at_ms: 1,
+        id: 1,
+      },
+      { name: "bundle_events_to_bundle_idx", collation: { locale: "simple" } },
+    );
+    expect(modelCollection.createIndex).toHaveBeenCalledWith(
+      { platform: 1, channel: 1, to_bundle_id: 1, received_at_ms: 1 },
+      {
+        name: "bundle_installations_bundle_idx",
+        collation: { locale: "simple" },
+      },
+    );
     const commands = command.mock.calls.map(([input]) => input);
     expect(commands.find(({ collMod }) => collMod === "bundles")).toMatchObject(
       {
@@ -138,24 +179,30 @@ describe("MongoDB migration", () => {
     });
   });
 
-  it("is a no-op when schema.core is already 1.0.0", async () => {
-    const client = createSettingsMongoClient({ "schema.core": "1.0.0" });
+  it("is a no-op when schema.core is current", async () => {
+    const client = createSettingsMongoClient({
+      "schema.core": HOT_UPDATER_SCHEMA_VERSION,
+    });
     const migrator = createMongoMigrator(client);
 
-    await expect(migrator.getVersion()).resolves.toBe("1.0.0");
+    await expect(migrator.getVersion()).resolves.toBe(
+      HOT_UPDATER_SCHEMA_VERSION,
+    );
     await expect(
       migrator.migrateToLatest({ mode: "from-schema" }),
     ).resolves.toMatchObject({ operations: [] });
   });
 
-  it("ignores a leftover version marker when schema.core is 1.0.0", async () => {
+  it("ignores a leftover version marker when schema.core is current", async () => {
     const client = createSettingsMongoClient({
-      "schema.core": "1.0.0",
+      "schema.core": HOT_UPDATER_SCHEMA_VERSION,
       version: "0.36.0",
     });
     const migrator = createMongoMigrator(client);
 
-    await expect(migrator.getVersion()).resolves.toBe("1.0.0");
+    await expect(migrator.getVersion()).resolves.toBe(
+      HOT_UPDATER_SCHEMA_VERSION,
+    );
     await expect(
       migrator.migrateToLatest({ mode: "from-schema" }),
     ).resolves.toMatchObject({ operations: [] });

package/src/db/fixedMigratorMongo.ts

@@ -334,7 +334,11 @@ export const createMongoMigrator = (client: MongoClient): Migrator => {
               await ensureSettingsKeyIndex();
               for (const table of hotUpdaterSchema.tables) {
                 if (table.internal) continue;
+                const isInsights =
+                  table.ormName === "bundle_events" ||
+                  table.ormName === "bundle_installations";
                 const collection = db.collection(table.ormName);
+                const collation = isInsights ? { locale: "simple" } : undefined;
                 const primaryKey = table.columns.find(
                   (column) => column.primaryKey,
                 );
@@ -344,18 +348,13 @@ export const createMongoMigrator = (client: MongoClient): Migrator => {
                   );
                 }
                 const idIndexName = `${table.ormName}_${primaryKey.ormName}_idx`;
-                const existingIndexes = await collection
-                  .listIndexes()
-                  .toArray();
-                const existingIdIndex = existingIndexes.find(
-                  ({ name }) => name === idIndexName,
-                );
-                if (existingIdIndex && existingIdIndex.unique !== true) {
-                  await collection.dropIndex(idIndexName);
-                }
                 await collection.createIndex(
                   { [primaryKey.ormName]: 1 },
-                  { name: idIndexName, unique: true },
+                  {
+                    name: idIndexName,
+                    unique: true,
+                    ...(collation ? { collation } : {}),
+                  },
                 );
                 for (const index of (table.indexes ?? []).filter((item) =>
                   schemaIndexAppliesToProvider(item, "mongodb"),
@@ -367,6 +366,7 @@ export const createMongoMigrator = (client: MongoClient): Migrator => {
                     {
                       name: index.name,
                       ...(index.unique ? { unique: true } : {}),
+                      ...(collation ? { collation } : {}),
                     },
                   );
                 }

package/src/db/index.spec.ts

@@ -415,7 +415,7 @@ describe("server/db hotUpdater (PGlite + Kysely)", async () => {
   });
 
   describe("migrator enhancements", () => {
-    it("registers only schema 1.0.0", () => {
+    it("registers only the initial schema", () => {
       expect(hotUpdaterSchemaVersions.map((schema) => schema.version)).toEqual([
         "1.0.0",
       ]);
@@ -837,6 +837,9 @@ describe("server/db hotUpdater (PGlite + Kysely)", async () => {
         bundle_events: {
           id: "event_id",
         },
+        bundle_installations: {
+          install_id: "install_id",
+        },
         bundle_patches: {
           bundle_id: "bundle_id",
           id: "patch_id",
@@ -878,6 +881,10 @@ describe("server/db hotUpdater (PGlite + Kysely)", async () => {
             findFirst: vi.fn(),
             findMany: vi.fn(),
           },
+          bundle_installations: {
+            findFirst: vi.fn(),
+            findMany: vi.fn(),
+          },
           bundle_patches: {
             findFirst: vi.fn(),
             findMany: vi.fn(),

package/src/db/schema/insightsCollation.ts

@@ -0,0 +1,21 @@
+import { bundleEventsV100, bundleInstallationsV100 } from "../../schema/v1_0_0";
+import type { ORMSQLProvider } from "../types";
+import { getSqlType, sqlColumnDefinition } from "./sql";
+
+export const getInsightsCollationSql = (
+  provider: ORMSQLProvider,
+): readonly string[] =>
+  [bundleEventsV100, bundleInstallationsV100].flatMap((table) =>
+    table.columns.flatMap((column) => {
+      const collation = column.providerCollations?.[provider];
+      if (collation === undefined) return [];
+      if (provider === "mysql") {
+        return [
+          `alter table ${table.ormName} modify column ${sqlColumnDefinition(table, { ...column, primaryKey: undefined }, provider)}`,
+        ];
+      }
+      return [
+        `alter table ${table.ormName} alter column ${column.ormName} type ${getSqlType(column.type, provider)} collate ${collation}`,
+      ];
+    }),
+  );

package/src/db/schema/sql.ts

@@ -5,6 +5,7 @@ import {
   type HotUpdaterColumnType,
   type HotUpdaterForeignKeySchema,
   type HotUpdaterTableSchema,
+  type HotUpdaterVersionedSchema,
 } from "../../schema/types";
 import type {
   MigrationOperation,
@@ -209,9 +210,10 @@ export const createTableStatement = (
 export const createForeignKeySqlStatements = (
   provider: ORMSQLProvider,
   relationMode: RelationMode = "foreign-keys",
+  schema: HotUpdaterVersionedSchema = hotUpdaterSchema,
 ): readonly string[] => {
   if (relationMode !== "foreign-keys" || provider === "sqlite") return [];
-  return hotUpdaterSchema.tables.flatMap((table) =>
+  return schema.tables.flatMap((table) =>
     (table.foreignKeys ?? []).map((foreignKey) =>
       createForeignKeySql(table, foreignKey, provider),
     ),
@@ -221,21 +223,22 @@ export const createForeignKeySqlStatements = (
 export const createTableSql = (
   provider: ORMSQLProvider,
   relationMode: RelationMode = "foreign-keys",
+  schema: HotUpdaterVersionedSchema = hotUpdaterSchema,
 ): readonly string[] => [
-  ...hotUpdaterSchema.tables.map((table) =>
+  ...schema.tables.map((table) =>
     createTableStatement(table, provider, relationMode),
   ),
-  ...hotUpdaterSchema.tables.flatMap((table) =>
+  ...schema.tables.flatMap((table) =>
     (table.indexes ?? [])
       .filter((index) => schemaIndexAppliesToProvider(index, provider))
       .map((index) => createIndexSql(table, index, provider)),
   ),
   ...(provider === "sqlite"
     ? []
-    : hotUpdaterSchema.tables.flatMap((table) =>
+    : schema.tables.flatMap((table) =>
         (table.checks ?? []).map((check) =>
           createCheckSql(table, check, provider),
         ),
       )),
-  ...createForeignKeySqlStatements(provider, relationMode),
+  ...createForeignKeySqlStatements(provider, relationMode, schema),
 ];

package/src/db/schemaGenerators.ts

@@ -7,11 +7,13 @@ import {
   type HotUpdaterTableSchema,
   type HotUpdaterVersionedSchema,
 } from "../schema/types";
+import { getInsightsCollationSql } from "./schema/insightsCollation";
 import {
   getHotUpdaterSchemaVersion,
   hotUpdaterSchema,
   schemaIndexAppliesToProvider,
 } from "./schema/registry";
+import { getSqlType } from "./schema/sql";
 import type { ORMProvider, ORMSQLProvider, SchemaGenerator } from "./types";
 import { getSQLProvider } from "./types";
 
@@ -154,19 +156,33 @@ const prismaIndexes = (
 export const generatePrismaSchema = (
   provider: ORMProvider,
   schema: HotUpdaterVersionedSchema = hotUpdaterSchema,
-) =>
-  schema.tables
-    .map((table) => {
-      const lines = [
-        ...table.columns.map((column) => prismaField(column, provider)),
-        ...prismaRelationFields(table, schema),
-        ...prismaIndexes(table, provider),
-      ];
-      return `model ${table.ormName} {\n${lines
-        .map((line) => `  ${line}`)
-        .join("\n")}\n}`;
-    })
-    .join("\n\n");
+) => {
+  const sqlProvider = getSQLProvider(provider);
+  const collationSql = sqlProvider ? getInsightsCollationSql(sqlProvider) : [];
+  const header =
+    collationSql.length === 0
+      ? ""
+      : [
+          "// Apply these statements in the initial Prisma SQL migration to preserve exact Insights identities and cursors:",
+          ...collationSql.map((statement) => `// ${statement};`),
+          "",
+        ].join("\n");
+  return (
+    header +
+    schema.tables
+      .map((table) => {
+        const lines = [
+          ...table.columns.map((column) => prismaField(column, provider)),
+          ...prismaRelationFields(table, schema),
+          ...prismaIndexes(table, provider),
+        ];
+        return `model ${table.ormName} {\n${lines
+          .map((line) => `  ${line}`)
+          .join("\n")}\n}`;
+      })
+      .join("\n\n")
+  );
+};
 
 const drizzleImportSource = (provider: ORMSQLProvider) =>
   provider === "sqlite"
@@ -186,6 +202,18 @@ const drizzleColumnFn = (
   column: HotUpdaterColumnSchema,
   provider: ORMSQLProvider,
 ): { code: string; imports: readonly string[] } => {
+  const collation = column.providerCollations?.[provider];
+  if (collation !== undefined) {
+    const charset =
+      provider === "mysql"
+        ? ` character set ${collation === "ascii_bin" ? "ascii" : "utf8mb4"}`
+        : "";
+    const dataType = `${getSqlType(column.type, provider)}${charset} collate ${collation}`;
+    return {
+      code: `customType<{ data: string }>({ dataType: () => ${literal(dataType)} })(${literal(column.ormName)})`,
+      imports: ["customType"],
+    };
+  }
   if (provider === "sqlite") {
     if (column.type === "bool") {
       return {

package/src/db/types.spec.ts

@@ -26,6 +26,13 @@ describe("isDatabasePlugin", () => {
       ...plugin,
       models: { ...plugin.models, insights: undefined },
     };
+    const malformedInsights = {
+      ...plugin,
+      models: {
+        ...plugin.models,
+        insights: { ...plugin.models.insights, listEvents: null },
+      },
+    };
     const malformedChannels = {
       ...plugin,
       models: {
@@ -48,6 +55,7 @@ describe("isDatabasePlugin", () => {
     expect(isDatabasePlugin(factory)).toBe(false);
     expect(isDatabasePlugin(malformedBundles)).toBe(false);
     expect(isDatabasePlugin(missingInsights)).toBe(false);
+    expect(isDatabasePlugin(malformedInsights)).toBe(false);
     expect(isDatabasePlugin(malformedChannels)).toBe(false);
     expect(isDatabasePlugin(malformedApiKeys)).toBe(false);
     expect(isDatabasePlugin(malformedDispose)).toBe(false);

package/src/db/types.ts

@@ -126,10 +126,16 @@ export function isDatabasePlugin(plugin: unknown): plugin is DatabasePlugin {
     "insights" in plugin.models &&
     typeof plugin.models.insights === "object" &&
     plugin.models.insights !== null &&
-    "append" in plugin.models.insights &&
-    typeof plugin.models.insights.append === "function" &&
-    "scan" in plugin.models.insights &&
-    typeof plugin.models.insights.scan === "function" &&
+    "record" in plugin.models.insights &&
+    typeof plugin.models.insights.record === "function" &&
+    "listEvents" in plugin.models.insights &&
+    typeof plugin.models.insights.listEvents === "function" &&
+    "findInstallations" in plugin.models.insights &&
+    typeof plugin.models.insights.findInstallations === "function" &&
+    "countEvents" in plugin.models.insights &&
+    typeof plugin.models.insights.countEvents === "function" &&
+    "countInstallations" in plugin.models.insights &&
+    typeof plugin.models.insights.countInstallations === "function" &&
     "apiKeys" in plugin.models &&
     typeof plugin.models.apiKeys === "object" &&
     plugin.models.apiKeys !== null &&

package/src/handler-standalone.integration.spec.ts

@@ -186,15 +186,13 @@ describe("Handler <-> Standalone Repository Integration", () => {
         }),
       }),
     );
-    const overview = await api.handlers.admin(
-      new Request(`${baseUrl}/installations/overview`),
-    );
+    const events = await api.handlers.admin(new Request(`${baseUrl}/events`));
 
     expect(ingestion.status).toBe(204);
-    expect(overview.status).toBe(200);
-    await expect(overview.json()).resolves.toEqual({
-      bundles: [{ bundleId, installations: 1 }],
-      trackedInstallations: 1,
+    expect(events.status).toBe(200);
+    await expect(events.json()).resolves.toMatchObject({
+      data: [{ installId, toBundleId: bundleId, type: "UPDATE_APPLIED" }],
+      nextCursor: null,
     });
   });
 

package/src/index.ts

@@ -4,9 +4,9 @@ export type {
   HotUpdaterHandler,
   HotUpdaterHandlers,
 } from "./handler";
-export { createInsightsProvider } from "./insights/bounded/provider";
+export { createInsightsProvider } from "./insights/provider";
 export type * from "./insights/domain";
-export type { InsightsProvider } from "./insights/types";
+export type * from "./insights/types";
 export {
   API_KEY_HEADER_NAME,
   createApiKey,