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

package/src/adapters/drizzleCrud.ts

@@ -1,9 +1,12 @@
-import { DatabasePluginInputError } from "@hot-updater/plugin-core";
+import {
+  DatabasePluginInputError,
+  type InsightsRecordInput,
+} from "@hot-updater/plugin-core";
 import type {
   DatabasePluginImplementation,
   TransactionDatabasePluginImplementation,
 } from "@hot-updater/plugin-core/internal";
-import { asc, desc, eq, sql, type SQLWrapper } from "drizzle-orm";
+import { and, asc, desc, eq, lt, or, sql, type SQLWrapper } from "drizzle-orm";
 
 import {
   isChannelDeleteReferencedError,
@@ -78,9 +81,98 @@ const executeInsert = async (
   await ignored.execute();
 };
 
+export const recordDrizzleInsights = (
+  db: DrizzleDB,
+  provider: DrizzleProvider,
+  input: InsightsRecordInput,
+): void | Promise<void> => {
+  if (db.resultKind !== "sync")
+    return recordAsyncDrizzleInsights(db, provider, input);
+  const events = getDrizzleTable(db, "bundle_events");
+  const installations = getDrizzleTable(db, "bundle_installations");
+  const eventInsert = db
+    .insert(events)
+    .values(input.event)
+    .onConflictDoNothing?.()
+    .returning?.({ id: getDrizzleColumn(events, "id") });
+  const installationInsert = db
+    .insert(installations)
+    .values(input.installation)
+    .onConflictDoNothing?.();
+  const installationUpdate = db
+    .update(installations)
+    .set(input.installation)
+    .where(newerInstallationWhere(installations, input.installation));
+  if (
+    eventInsert?.all === undefined ||
+    installationInsert?.run === undefined ||
+    installationUpdate.run === undefined
+  )
+    throw new DrizzleAdapterInvariantError();
+  if (eventInsert.all().length === 0) return;
+  installationInsert.run();
+  installationUpdate.run();
+};
+
+const newerInstallationWhere = (
+  installations: DrizzleTable,
+  installation: InsightsRecordInput["installation"],
+) => {
+  const receivedAt = getDrizzleColumn(installations, "received_at_ms");
+  return and(
+    eq(getDrizzleColumn(installations, "install_id"), installation.install_id),
+    or(
+      lt(receivedAt, installation.received_at_ms),
+      and(
+        eq(receivedAt, installation.received_at_ms),
+        lt(getDrizzleColumn(installations, "id"), installation.id),
+      ),
+    ),
+  );
+};
+
+const recordAsyncDrizzleInsights = async (
+  db: DrizzleDB,
+  provider: DrizzleProvider,
+  { event, installation }: InsightsRecordInput,
+): Promise<void> => {
+  const events = getDrizzleTable(db, "bundle_events");
+  const installations = getDrizzleTable(db, "bundle_installations");
+  if (provider === "mysql") {
+    const existing = await db.query.bundle_events.findFirst({
+      where: eq(getDrizzleColumn(events, "id"), event.id),
+    });
+    if (existing !== undefined) return;
+    await db.insert(events).values(event).execute();
+    const insertInstallation = db
+      .insert(installations)
+      .values(installation)
+      .onDuplicateKeyUpdate?.({ set: { install_id: installation.install_id } });
+    if (insertInstallation === undefined)
+      throw new DrizzleAdapterInvariantError();
+    await insertInstallation.execute();
+  } else {
+    const insert = db.insert(events).values(event).onConflictDoNothing?.();
+    const returning = insert?.returning?.({
+      id: getDrizzleColumn(events, "id"),
+    });
+    if (returning === undefined) throw new DrizzleAdapterInvariantError();
+    const rows = await returning.execute();
+    if (!Array.isArray(rows)) throw new DrizzleAdapterInvariantError();
+    if (rows.length === 0) return;
+    await executeInsert(db, provider, installations, installation, "ignore");
+  }
+  await db
+    .update(installations)
+    .set(installation)
+    .where(newerInstallationWhere(installations, installation))
+    .execute();
+};
+
 const toOrderBy = (
   table: DrizzleTable,
   input: {
+    model?: string;
     orderBy?: readonly {
       field: string;
       direction: "asc" | "desc";
@@ -91,6 +183,12 @@ const toOrderBy = (
   const clauses = input.orderBy;
   return clauses?.flatMap((clause) => {
     const column = getDrizzleColumn(table, clause.field);
+    if (
+      input.model === "bundle_events" ||
+      input.model === "bundle_installations"
+    ) {
+      return [clause.direction === "asc" ? asc(column) : desc(column)];
+    }
     const nulls =
       clause.nulls ?? (clause.direction === "asc" ? "last" : "first");
     return [
@@ -110,6 +208,7 @@ export const createDrizzleCrud = (
   const bundles = getDrizzleTable(db, "bundles");
   const patches = getDrizzleTable(db, "bundle_patches");
   const events = getDrizzleTable(db, "bundle_events");
+  const installations = getDrizzleTable(db, "bundle_installations");
   const releases = getDrizzleTable(db, "releases");
   const releaseCatalogs = getDrizzleTable(db, "release_catalogs");
   const channels = getDrizzleTable(db, "channels");
@@ -169,6 +268,15 @@ export const createDrizzleCrud = (
         case "bundle_events":
           await executeInsert(db, provider, events, input.data, undefined);
           return input.data;
+        case "bundle_installations":
+          await executeInsert(
+            db,
+            provider,
+            installations,
+            input.data,
+            input.onConflict,
+          );
+          return input.data;
         case "releases":
           await executeInsert(
             db,
@@ -208,6 +316,27 @@ export const createDrizzleCrud = (
       }
     },
     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 DrizzleAdapterInvariantError();
+        }
+        const where = buildDrizzleWhere(provider, installations, input.where);
+        if (where === undefined) throw new DrizzleAdapterInvariantError();
+        await db.update(installations).set(input.update).where(where).execute();
+        const row = await db.query.bundle_installations.findFirst({
+          where: eq(getDrizzleColumn(installations, "install_id"), installId),
+        });
+        return row?.id === input.update.id &&
+          row.received_at_ms === input.update.received_at_ms
+          ? row
+          : null;
+      }
       const selector = input.where[0];
       if (selector === undefined || typeof selector.value !== "string") {
         throw new DrizzleAdapterInvariantError();
@@ -296,6 +425,11 @@ export const createDrizzleCrud = (
         throw new DatabasePluginInputError("invalid-operation");
       }
       switch (input.model) {
+        case "bundle_events":
+          return db.$count(
+            events,
+            buildDrizzleWhere(provider, events, input.where),
+          );
         case "bundles":
           return db.$count(
             bundles,
@@ -311,6 +445,11 @@ export const createDrizzleCrud = (
             releases,
             buildDrizzleWhere(provider, releases, input.where),
           );
+        case "bundle_installations":
+          return db.$count(
+            installations,
+            buildDrizzleWhere(provider, installations, input.where),
+          );
       }
     },
     async findOne(input) {
@@ -351,6 +490,12 @@ export const createDrizzleCrud = (
           });
           return row === undefined ? null : fromStoredReleaseCatalogRow(row);
         }
+        case "bundle_installations":
+          return (
+            (await db.query.bundle_installations.findFirst({
+              where: buildDrizzleWhere(provider, installations, input.where),
+            })) ?? null
+          );
       }
     },
     async findMany(input) {
@@ -374,6 +519,13 @@ export const createDrizzleCrud = (
             limit: input.limit,
             offset: input.offset,
           });
+        case "bundle_installations":
+          return db.query.bundle_installations.findMany({
+            where: buildDrizzleWhere(provider, installations, input.where),
+            orderBy: toOrderBy(installations, input),
+            limit: input.limit,
+            offset: input.offset,
+          });
         case "api_keys":
           return db.query.api_keys.findMany({
             where: buildDrizzleWhere(provider, apiKeys, input.where),

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