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

package/src/adapters/kyselyQuery.ts

@@ -1,128 +0,0 @@
-import type {
-  DatabaseModel,
-  DatabaseWhere,
-} from "@hot-updater/plugin-core/internal";
-import { sql, type RawBuilder } from "kysely";
-
-import type { ORMSQLProvider } from "../db/types";
-import { escapeGlobPattern, escapeLikePattern } from "./databasePluginUtils";
-
-class InvalidDatabasePredicateError extends Error {
-  readonly name = "InvalidDatabasePredicateError";
-}
-
-const stringPredicate = (
-  provider: ORMSQLProvider,
-  field: string,
-  operator: "contains" | "ends_with" | "starts_with",
-  value: string,
-  insensitive: boolean,
-): RawBuilder<boolean> => {
-  const column = sql.ref(field);
-  if (provider === "sqlite" && !insensitive) {
-    const literal = escapeGlobPattern(value);
-    const pattern =
-      operator === "contains"
-        ? `*${literal}*`
-        : operator === "starts_with"
-          ? `${literal}*`
-          : `*${literal}`;
-    return sql<boolean>`${column} glob ${pattern}`;
-  }
-
-  const literal = escapeLikePattern(value);
-  const pattern =
-    operator === "contains"
-      ? `%${literal}%`
-      : operator === "starts_with"
-        ? `${literal}%`
-        : `%${literal}`;
-  if (insensitive) {
-    return sql<boolean>`lower(${column}) like lower(${pattern}) escape '\\'`;
-  }
-  if (provider === "mysql") {
-    return sql<boolean>`binary ${column} like binary ${pattern} escape '\\'`;
-  }
-  return sql<boolean>`${column} like ${pattern} escape '\\'`;
-};
-
-const predicate = <TModel extends DatabaseModel>(
-  provider: ORMSQLProvider,
-  condition: DatabaseWhere<TModel>,
-): RawBuilder<boolean> => {
-  const column = sql.ref(condition.field);
-  const operator = condition.operator ?? "eq";
-  switch (operator) {
-    case "eq":
-    case "ne": {
-      if (condition.value === null) {
-        return operator === "eq"
-          ? sql<boolean>`${column} is null`
-          : sql<boolean>`${column} is not null`;
-      }
-      const insensitive =
-        "mode" in condition && condition.mode === "insensitive";
-      if (insensitive) {
-        return operator === "eq"
-          ? sql<boolean>`lower(${column}) = lower(${condition.value})`
-          : sql<boolean>`lower(${column}) <> lower(${condition.value})`;
-      }
-      return operator === "eq"
-        ? sql<boolean>`${column} = ${condition.value}`
-        : sql<boolean>`${column} <> ${condition.value}`;
-    }
-    case "gt":
-      return sql<boolean>`${column} > ${condition.value}`;
-    case "gte":
-      return sql<boolean>`${column} >= ${condition.value}`;
-    case "lt":
-      return sql<boolean>`${column} < ${condition.value}`;
-    case "lte":
-      return sql<boolean>`${column} <= ${condition.value}`;
-    case "in":
-    case "not_in": {
-      if (!Array.isArray(condition.value)) {
-        throw new InvalidDatabasePredicateError();
-      }
-      if (operator === "in") {
-        return condition.value.length === 0
-          ? sql<boolean>`false`
-          : sql<boolean>`${column} in (${sql.join(condition.value)})`;
-      }
-      return condition.value.length === 0
-        ? sql<boolean>`true`
-        : sql<boolean>`${column} not in (${sql.join(condition.value)})`;
-    }
-    case "contains":
-    case "starts_with":
-    case "ends_with": {
-      if (typeof condition.value !== "string") {
-        throw new InvalidDatabasePredicateError();
-      }
-      return stringPredicate(
-        provider,
-        condition.field,
-        operator,
-        condition.value,
-        "mode" in condition && condition.mode === "insensitive",
-      );
-    }
-  }
-};
-
-export const buildKyselyWhere = <TModel extends DatabaseModel>(
-  provider: ORMSQLProvider,
-  where: readonly DatabaseWhere<TModel>[] | undefined,
-): RawBuilder<boolean> | undefined => {
-  const [first, ...rest] = where ?? [];
-  if (first === undefined) return undefined;
-  let expression = predicate(provider, first);
-  for (const condition of rest) {
-    const next = predicate(provider, condition);
-    expression =
-      condition.connector === "OR"
-        ? sql<boolean>`(${expression} or ${next})`
-        : sql<boolean>`(${expression} and ${next})`;
-  }
-  return expression;
-};

package/src/adapters/mongodb.integration.spec.ts

@@ -1,210 +0,0 @@
-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,209 +0,0 @@
-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";
-import { createMongoBundleWhere } from "./mongodbQuery";
-import { createMongoTestHarness } from "./mongodbTestClient";
-
-const harness = createMongoTestHarness();
-
-setupDatabasePluginTestSuite({
-  name: "mongoAdapter v2",
-  migrate: () => undefined,
-  createPlugin: () =>
-    mongoAdapter({ client: harness.client, transactions: true }),
-  reset: () => harness.reset(),
-  dispose: () => harness.close(),
-});
-
-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");
-    expect(plugin.adapterName).toBe("mongodb");
-    expect(plugin.provider).toBe("mongodb");
-    expect(Reflect.has(plugin, "transaction")).toBe(false);
-  });
-
-  it("rejects a cross-table commit when transactions are disabled", async () => {
-    const plugin = mongoAdapter({ client: harness.client });
-    const owner = createBundleRowFixture("970");
-    const patch = createBundlePatchRowFixture(
-      "971",
-      owner.id,
-      createBundleRowFixture("972").id,
-    );
-
-    await expect(
-      plugin.commit({
-        changes: [
-          {
-            model: "bundles",
-            operation: "insert",
-            row: owner,
-          },
-          {
-            model: "bundlePatches",
-            operation: "insert",
-            row: patch,
-          },
-        ],
-      }),
-    ).rejects.toMatchObject({ name: "DatabaseAtomicCommitUnsupportedError" });
-  });
-
-  it("recovers a tombstoned bundle when an aggregate delete is retried", async () => {
-    harness.reset();
-    const client = createDatabaseClient(
-      mongoAdapter({ client: harness.client }),
-    );
-    const bundle = {
-      id: "bundle-retry",
-      platform: "ios" as const,
-      fileHash: "bundle-retry-hash",
-      gitCommitHash: null,
-      storageUri: "storage://bundle-retry",
-      archiveByteSize: 3_000_000_001,
-    };
-    await client.insertBundle(bundle);
-
-    harness.failNextBundleTombstone();
-    await expect(client.deleteBundleById(bundle.id)).rejects.toThrow(
-      "injected tombstone failure",
-    );
-    await expect(client.deleteBundleById(bundle.id)).resolves.toBeUndefined();
-    await expect(client.insertBundle(bundle)).resolves.toBeUndefined();
-    await expect(client.getBundleById(bundle.id)).resolves.toMatchObject({
-      id: bundle.id,
-      fileHash: bundle.fileHash,
-      storageUri: bundle.storageUri,
-    });
-  });
-});
-
-describe("MongoDB low-level predicate translation", () => {
-  it("composes connectors left to right", () => {
-    expect(
-      createMongoBundleWhere([
-        { field: "id", value: "first" },
-        { field: "id", value: "second", connector: "OR" },
-        { field: "platform", value: "ios", connector: "AND" },
-      ]),
-    ).toEqual({
-      $and: [
-        {
-          $or: [
-            { $expr: { $eq: ["$id", { $literal: "first" }] } },
-            { $expr: { $eq: ["$id", { $literal: "second" }] } },
-          ],
-        },
-        { $expr: { $eq: ["$platform", { $literal: "ios" }] } },
-      ],
-    });
-  });
-
-  it("escapes insensitive string patterns", () => {
-    expect(
-      createMongoBundleWhere([
-        {
-          field: "storage_uri",
-          operator: "contains",
-          value: "release.*",
-          mode: "insensitive",
-        },
-      ]),
-    ).toEqual({
-      $expr: {
-        $regexMatch: {
-          input: { $ifNull: ["$storage_uri", ""] },
-          regex: { $literal: "release\\.\\*" },
-          options: "i",
-        },
-      },
-    });
-  });
-
-  it("preserves empty set semantics", () => {
-    expect(
-      createMongoBundleWhere([{ field: "id", operator: "in", value: [] }]),
-    ).toEqual({ $expr: { $in: ["$id", { $literal: [] }] } });
-    expect(
-      createMongoBundleWhere([{ field: "id", operator: "not_in", value: [] }]),
-    ).toEqual({
-      $expr: { $not: [{ $in: ["$id", { $literal: [] }] }] },
-    });
-  });
-});

package/src/adapters/mongodb.ts

@@ -1,138 +0,0 @@
-import {
-  compareInsightsText,
-  createDatabasePlugin,
-} from "@hot-updater/plugin-core";
-import {
-  createDatabasePluginAdapter,
-  type DatabasePluginImplementation,
-  type TransactionDatabasePluginImplementation,
-} from "@hot-updater/plugin-core/internal";
-import {
-  MongoServerError,
-  type ClientSession,
-  type MongoClient,
-} from "mongodb";
-
-import { createMongoMigrator } from "../db/fixedMigrator";
-import type { DatabaseAdapterWithCapabilities } from "../db/types";
-import { createMongoCollections } from "./mongodbCollections";
-import { createMongoReads } from "./mongodbReads";
-import { createMongoWrites } from "./mongodbWrites";
-
-export interface MongoDBConfig {
-  readonly client: MongoClient;
-  /** Enables atomic catalog commits. Insights always requires MongoDB 5+ on a replica set or sharded cluster. */
-  readonly transactions?: boolean;
-}
-
-const createMongoImplementation = (
-  client: MongoClient,
-  session?: ClientSession,
-): DatabasePluginImplementation => {
-  const collections = createMongoCollections(client);
-  return {
-    recordInsights: async (input) => {
-      const record = () =>
-        client.withSession((recordSession) =>
-          recordSession.withTransaction(
-            async () => {
-              const records = createMongoCollections(client);
-              const options = {
-                session: recordSession,
-                collation: { locale: "simple" },
-              };
-              const inserted = await records.bundleEvents.updateOne(
-                { id: input.event.id },
-                { $setOnInsert: input.event },
-                { ...options, upsert: true },
-              );
-              if (inserted.upsertedCount === 0) return;
-              const current = await records.bundleInstallations.findOne(
-                { install_id: input.installation.install_id },
-                options,
-              );
-              if (current === null) {
-                await records.bundleInstallations.insertOne(
-                  { ...input.installation },
-                  {
-                    session: recordSession,
-                  },
-                );
-              } else if (
-                input.installation.received_at_ms > current.received_at_ms ||
-                (input.installation.received_at_ms === current.received_at_ms &&
-                  compareInsightsText(input.installation.id, current.id) > 0)
-              ) {
-                await records.bundleInstallations.updateOne(
-                  { install_id: input.installation.install_id },
-                  { $set: input.installation },
-                  options,
-                );
-              }
-            },
-            {
-              readConcern: { level: "snapshot" },
-              readPreference: "primary",
-              writeConcern: { w: "majority" },
-            },
-          ),
-        );
-      try {
-        await record();
-      } catch (error) {
-        if (!(error instanceof MongoServerError) || error.code !== 11000)
-          throw error;
-        // A concurrent insert won a canonical key. Read that committed winner
-        // in a new transaction; some MongoDB versions do not retry E11000.
-        await record();
-      }
-    },
-    ...createMongoWrites(collections, session),
-    ...createMongoReads(collections, session),
-  };
-};
-
-const createTransactionalMongoImplementation = (
-  client: MongoClient,
-): DatabasePluginImplementation => ({
-  ...createMongoImplementation(client),
-  deleteChannel: (input) =>
-    client.withSession((session) =>
-      session.withTransaction(() =>
-        createMongoImplementation(client, session).deleteChannel(input),
-      ),
-    ),
-  transaction: <TResult>(
-    callback: (
-      transaction: TransactionDatabasePluginImplementation,
-    ) => Promise<TResult>,
-  ): Promise<TResult> =>
-    client.withSession((session) =>
-      session.withTransaction(() =>
-        callback(createMongoImplementation(client, session)),
-      ),
-    ),
-});
-
-export const mongoAdapter = (
-  config: MongoDBConfig,
-): DatabaseAdapterWithCapabilities => {
-  const adapter = createDatabasePluginAdapter(
-    "mongodb",
-    config.transactions === true
-      ? createTransactionalMongoImplementation(config.client)
-      : createMongoImplementation(config.client),
-  );
-  return Object.assign(
-    createDatabasePlugin({
-      name: "mongodb",
-      models: adapter.models,
-      commit: adapter.commit,
-    }),
-    {
-      adapterName: "mongodb",
-      provider: "mongodb" as const,
-      createMigrator: () => createMongoMigrator(config.client),
-    },
-  );
-};