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

package/src/adapters/mongodbWrites.ts

@@ -0,0 +1,260 @@
+import type { BundlePatchRow } from "@hot-updater/plugin-core";
+import { createUUIDv7 } from "@hot-updater/plugin-core";
+import type { DatabasePluginImplementation } from "@hot-updater/plugin-core/internal";
+import type { ClientSession, Collection } from "mongodb";
+
+import {
+  activeBundleFilter,
+  DELETION_TOKEN_FIELD,
+  type MongoBundleDocument,
+  type MongoCollections,
+  MongoAdapterConstraintError,
+  mongoSessionOptions,
+  WITHOUT_INTERNAL_FIELDS,
+} from "./mongodbCollections";
+import {
+  createMongoBundleWhere,
+  createMongoChannelWhere,
+  createMongoApiKeyWhere,
+  createMongoPatchWhere,
+  createMongoReleaseCatalogWhere,
+  createMongoReleaseWhere,
+} from "./mongodbQuery";
+
+const assertPatchReferences = async (
+  bundles: Collection<MongoBundleDocument>,
+  patch: BundlePatchRow,
+  session?: ClientSession,
+): Promise<void> => {
+  const ids = Array.from(new Set([patch.bundle_id, patch.base_bundle_id]));
+  const count = await bundles.countDocuments(
+    activeBundleFilter({ id: { $in: ids } }),
+    mongoSessionOptions(session),
+  );
+  if (count !== ids.length) {
+    throw new MongoAdapterConstraintError(
+      `patch "${patch.id}" references a missing bundle`,
+    );
+  }
+};
+
+type MongoWriteImplementation = Pick<
+  DatabasePluginImplementation,
+  "create" | "delete" | "deleteChannel" | "insertChannel" | "update"
+>;
+
+export const createMongoWrites = (
+  collections: MongoCollections,
+  session?: ClientSession,
+): MongoWriteImplementation => ({
+  deleteChannel: async ({ id }) => {
+    if (session === undefined) {
+      throw new MongoAdapterConstraintError(
+        "channel deletion requires transaction support",
+      );
+    }
+    const locked = await collections.channels.updateOne(
+      { id },
+      { $set: { id } },
+      mongoSessionOptions(session),
+    );
+    if (locked.matchedCount !== 1) {
+      return { deleted: false, reason: "not_found" };
+    }
+    const referencedReleases = await collections.releases.countDocuments(
+      { channel_id: id },
+      mongoSessionOptions(session),
+    );
+    if (referencedReleases > 0) {
+      return { deleted: false, reason: "not_empty" };
+    }
+    await collections.channels.deleteMany({ id }, mongoSessionOptions(session));
+    return { deleted: true };
+  },
+  insertChannel: async (input) => {
+    const result = await collections.channels.updateOne(
+      { name: input.row.name },
+      { $setOnInsert: input.row },
+      { upsert: true, ...mongoSessionOptions(session) },
+    );
+    const row = await collections.channels.findOne(
+      { name: input.row.name },
+      mongoSessionOptions(session),
+    );
+    if (row === null) {
+      throw new MongoAdapterConstraintError("channels.insert.return-existing");
+    }
+    return { row, inserted: result.upsertedCount === 1 };
+  },
+  create: async (input) => {
+    switch (input.model) {
+      case "bundles":
+        await collections.bundles.insertOne(
+          input.data,
+          mongoSessionOptions(session),
+        );
+        return input.data;
+      case "bundle_patches":
+        await assertPatchReferences(collections.bundles, input.data, session);
+        await collections.bundlePatches.insertOne(
+          input.data,
+          mongoSessionOptions(session),
+        );
+        try {
+          await assertPatchReferences(collections.bundles, input.data, session);
+        } catch (error) {
+          await collections.bundlePatches.deleteMany(
+            { id: input.data.id },
+            mongoSessionOptions(session),
+          );
+          throw error;
+        }
+        return input.data;
+      case "bundle_events":
+        await collections.bundleEvents.insertOne(
+          input.data,
+          mongoSessionOptions(session),
+        );
+        return input.data;
+      case "releases":
+        await collections.releases.insertOne(
+          input.data,
+          mongoSessionOptions(session),
+        );
+        return input.data;
+      case "release_catalogs":
+        await collections.releaseCatalogs.insertOne(
+          input.data,
+          mongoSessionOptions(session),
+        );
+        return input.data;
+      case "api_keys":
+        if (input.onConflict === "ignore") {
+          await collections.apiKeys.updateOne(
+            { hash: input.data.hash },
+            { $setOnInsert: input.data },
+            { upsert: true, ...mongoSessionOptions(session) },
+          );
+          return input.data;
+        }
+        await collections.apiKeys.insertOne(
+          input.data,
+          mongoSessionOptions(session),
+        );
+        return input.data;
+      case "channels":
+        if (input.onConflict === "ignore") {
+          await collections.channels.updateOne(
+            { name: input.data.name },
+            { $setOnInsert: input.data },
+            { upsert: true, ...mongoSessionOptions(session) },
+          );
+          return input.data;
+        }
+        await collections.channels.insertOne(
+          input.data,
+          mongoSessionOptions(session),
+        );
+        return input.data;
+    }
+  },
+  update: async (input) => {
+    if (input.model === "api_keys") {
+      return collections.apiKeys.findOneAndUpdate(
+        createMongoApiKeyWhere(input.where),
+        { $set: input.update },
+        {
+          projection: WITHOUT_INTERNAL_FIELDS,
+          returnDocument: "after",
+          ...mongoSessionOptions(session),
+        },
+      );
+    }
+    if (input.model === "releases") {
+      return collections.releases.findOneAndUpdate(
+        createMongoReleaseWhere(input.where),
+        { $set: input.update },
+        {
+          projection: WITHOUT_INTERNAL_FIELDS,
+          returnDocument: "after",
+          ...mongoSessionOptions(session),
+        },
+      );
+    }
+    if (input.model === "release_catalogs") {
+      return collections.releaseCatalogs.findOneAndUpdate(
+        createMongoReleaseCatalogWhere(input.where),
+        { $set: input.update },
+        {
+          projection: WITHOUT_INTERNAL_FIELDS,
+          returnDocument: "after",
+          ...mongoSessionOptions(session),
+        },
+      );
+    }
+    return collections.bundles.findOneAndUpdate(
+      activeBundleFilter(createMongoBundleWhere(input.where)),
+      { $set: input.update },
+      {
+        projection: WITHOUT_INTERNAL_FIELDS,
+        returnDocument: "after",
+        ...mongoSessionOptions(session),
+      },
+    );
+  },
+  delete: async (input) => {
+    switch (input.model) {
+      case "bundle_patches":
+        await collections.bundlePatches.deleteMany(
+          createMongoPatchWhere(input.where),
+          mongoSessionOptions(session),
+        );
+        return;
+      case "bundles": {
+        const deletionToken = createUUIDv7();
+        await collections.bundles.updateMany(
+          createMongoBundleWhere(input.where),
+          { $set: { [DELETION_TOKEN_FIELD]: deletionToken } },
+          mongoSessionOptions(session),
+        );
+        const rows = await collections.bundles
+          .find(
+            { [DELETION_TOKEN_FIELD]: deletionToken },
+            {
+              projection: { _id: 0, id: 1 },
+              ...mongoSessionOptions(session),
+            },
+          )
+          .toArray();
+        const ids = rows.map(({ id }) => id);
+        if (ids.length === 0) return;
+        await collections.bundlePatches.deleteMany(
+          {
+            $or: [
+              { bundle_id: { $in: ids } },
+              { base_bundle_id: { $in: ids } },
+            ],
+          },
+          mongoSessionOptions(session),
+        );
+        await collections.bundles.deleteMany(
+          { [DELETION_TOKEN_FIELD]: deletionToken },
+          mongoSessionOptions(session),
+        );
+        return;
+      }
+      case "releases":
+        await collections.releases.deleteMany(
+          createMongoReleaseWhere(input.where),
+          mongoSessionOptions(session),
+        );
+        return;
+      case "channels":
+        await collections.channels.deleteMany(
+          createMongoChannelWhere(input.where),
+          mongoSessionOptions(session),
+        );
+        return;
+    }
+  },
+});

package/src/adapters/prisma.spec.ts

@@ -0,0 +1,196 @@
+import { describe, expect, expectTypeOf, it } from "vitest";
+
+import { setupDatabasePluginTestSuite } from "../../../test-utils/src/setupDatabasePluginTestSuite";
+import { prismaAdapter, type PrismaConfig } from "./prisma";
+import { createPrismaTestHarness } from "./prismaTestClient";
+
+const harness = createPrismaTestHarness();
+
+setupDatabasePluginTestSuite({
+  name: "prismaAdapter v2",
+  migrate: () => undefined,
+  createPlugin: () =>
+    prismaAdapter({ prisma: harness.client, provider: "postgresql" }),
+  reset: () => harness.reset(),
+  dispose: () => undefined,
+});
+
+const bundleRow = (id: string) => ({
+  id,
+  platform: "ios" as const,
+  file_hash: "hash",
+  git_commit_hash: null,
+  storage_uri: "storage://bundle",
+  archive_byte_size: 3_000_000_001,
+  metadata: {},
+  manifest_storage_uri: null,
+  manifest_file_hash: null,
+  asset_base_storage_uri: null,
+});
+
+const productionChannel = {
+  id: "channel-production",
+  name: "production",
+} as const;
+
+describe("prismaAdapter capabilities", () => {
+  it("excludes MongoDB from the public configuration", () => {
+    expectTypeOf<"mongodb">().not.toMatchTypeOf<PrismaConfig["provider"]>();
+  });
+
+  it("returns a named provider adapter", () => {
+    const plugin = prismaAdapter({
+      prisma: harness.client,
+      provider: "postgresql",
+    });
+
+    expect(plugin.name).toBe("prisma");
+    expect(plugin.adapterName).toBe("prisma");
+    expect(plugin.provider).toBe("postgresql");
+  });
+
+  it("rejects MongoDB before creating the implementation", () => {
+    expect(() =>
+      Reflect.apply(prismaAdapter, undefined, [
+        { prisma: harness.client, provider: "mongodb" },
+      ]),
+    ).toThrow("Prisma adapter does not support MongoDB");
+  });
+
+  it("does not expose low-level transactions", () => {
+    const { $transaction: _transaction, ...client } = harness.client;
+    const plugin = prismaAdapter({ prisma: client, provider: "postgresql" });
+
+    expect(Reflect.has(plugin, "transaction")).toBe(false);
+  });
+
+  it("requires transactions for emulated relations", () => {
+    const { $transaction: _transaction, ...client } = harness.client;
+
+    expect(() =>
+      prismaAdapter({
+        prisma: client,
+        provider: "postgresql",
+        relationMode: "prisma",
+      }),
+    ).toThrow('relation mode "prisma" requires callback transactions');
+  });
+
+  it("uses serializable transactions for emulated relation commits", async () => {
+    harness.reset();
+    const plugin = prismaAdapter({
+      prisma: harness.client,
+      provider: "postgresql",
+      relationMode: "prisma",
+    });
+    const base = bundleRow("bundle-base");
+    const owner = bundleRow("bundle-target");
+    const patch = {
+      id: "patch-1",
+      bundle_id: owner.id,
+      base_bundle_id: base.id,
+      base_file_hash: "base-hash",
+      patch_file_hash: "patch-hash",
+      patch_storage_uri: "storage://patch",
+      byte_size: 3_000_000_002,
+      order_index: 0,
+    };
+
+    await plugin.models.channels.insert({
+      row: productionChannel,
+      onConflict: "returnExisting",
+    });
+
+    await plugin.commit({
+      changes: [{ model: "bundles", operation: "insert", row: base }],
+    });
+    await plugin.commit({
+      changes: [
+        { model: "bundles", operation: "insert", row: owner },
+        { model: "bundlePatches", operation: "insert", row: patch },
+      ],
+    });
+    await plugin.commit({
+      changes: [
+        {
+          model: "bundles",
+          operation: "delete",
+          where: { id: owner.id },
+        },
+      ],
+    });
+
+    expect(harness.getTransactionOptions()).toEqual(
+      Array.from({ length: 3 }, () => ({ isolationLevel: "Serializable" })),
+    );
+  });
+
+  it("uses serializable transactions for atomic CAS commits", async () => {
+    harness.reset();
+    const plugin = prismaAdapter({
+      prisma: harness.client,
+      provider: "postgresql",
+    });
+
+    await plugin.commit({
+      changes: [
+        { model: "bundles", operation: "insert", row: bundleRow("bundle") },
+      ],
+    });
+
+    expect(harness.getTransactionOptions()).toEqual([
+      { isolationLevel: "Serializable" },
+    ]);
+  });
+
+  it("does not delete patches before a bundle delete fails", async () => {
+    harness.reset();
+    const { $transaction: _transaction, ...client } = harness.client;
+    const plugin = prismaAdapter({ prisma: client, provider: "postgresql" });
+    const base = bundleRow("bundle-base");
+    const owner = bundleRow("bundle-target");
+    const patch = {
+      id: "patch-1",
+      bundle_id: owner.id,
+      base_bundle_id: base.id,
+      base_file_hash: "base-hash",
+      patch_file_hash: "patch-hash",
+      patch_storage_uri: "storage://patch",
+      byte_size: 3_000_000_002,
+      order_index: 0,
+    };
+    await plugin.models.channels.insert({
+      row: productionChannel,
+      onConflict: "returnExisting",
+    });
+    for (const row of [base, owner]) {
+      await plugin.commit({
+        changes: [{ model: "bundles", operation: "insert", row }],
+      });
+    }
+    await plugin.commit({
+      changes: [{ model: "bundlePatches", operation: "insert", row: patch }],
+    });
+
+    harness.failNextBundleDelete();
+    await expect(
+      plugin.commit({
+        changes: [
+          {
+            model: "bundles",
+            operation: "delete",
+            where: { id: owner.id },
+          },
+        ],
+      }),
+    ).rejects.toThrow("injected bundle delete failure");
+    await expect(
+      plugin.models.bundles.findById(owner.id),
+    ).resolves.toMatchObject({
+      id: owner.id,
+    });
+    await expect(
+      plugin.models.bundlePatches.findByBundleIds([owner.id]),
+    ).resolves.toEqual([patch]);
+  });
+});