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

package/src/adapters/mongodb.ts

@@ -1,45 +0,0 @@
-import type { MongoClient } from "mongodb";
-
-import { SETTINGS_TABLE } from "../database/fence";
-import { coreTarget, createEngineDatabase } from "../db/coreDatabase";
-import { createEngineMigrator } from "../db/engineMigrator";
-import type { ToolingDatabase } from "../db/types";
-import { createMongoAdapter } from "./mongodbAdapter";
-
-export { MongoTransactionUnsupportedError } from "./mongodbAdapter";
-
-/** Every write runs in a transaction, which needs a replica set or a sharded cluster. */
-export interface MongoDBConfig {
-  readonly client: MongoClient;
-}
-
-/** Settings rows by their `key` field: the engine's rows and a v0 database's alike. */
-const readSettings = (client: MongoClient) => async () => {
-  const rows = await client
-    .db()
-    .collection(SETTINGS_TABLE.name)
-    .find({ key: { $type: "string" } })
-    .toArray();
-  return new Map(rows.map((row) => [String(row.key), row.value]));
-};
-
-/**
- * Hot Updater's database on MongoDB: the storage engine's MongoDB adapter,
- * fenced by the schema settings. `db migrate` creates the collections and
- * indexes, then writes the settings.
- */
-export const mongoAdapter = (config: MongoDBConfig): ToolingDatabase => {
-  const adapter = createMongoAdapter({ client: config.client });
-  return {
-    ...createEngineDatabase({ name: "mongodb", adapter }),
-    provider: "mongodb",
-    createMigrator: ({ schema, settings } = coreTarget) =>
-      createEngineMigrator({
-        adapterName: "mongodb",
-        adapter,
-        schema,
-        settings,
-        readSettings: readSettings(config.client),
-      }),
-  };
-};

package/src/adapters/mongodbAdapter.ts

@@ -1,307 +0,0 @@
-import {
-  type DatabaseAdapter,
-  type DatabaseKey,
-  type DatabaseKeyValue,
-  DATABASE_VERSION_COLUMN as V,
-  findPhysicalColumn,
-  findPhysicalIndex,
-  indexOrderColumns,
-  normalizeStoredRow,
-  type PhysicalIndex,
-  type PhysicalTable,
-  type QueryBound,
-  rowKey,
-  type StoredRow,
-  type WriteOp,
-} from "@hot-updater/plugin-core/internal";
-import {
-  type ClientSession,
-  type Document,
-  type Filter,
-  type IndexDescription,
-  MongoError,
-  type MongoClient,
-} from "mongodb";
-
-export interface MongoAdapterOptions {
-  readonly client: MongoClient;
-  /** Prepended to every collection name. */
-  readonly tablePrefix?: string;
-  /** The most ops one write accepts (default 1,000). */
-  readonly maxOps?: number;
-  /** Test-only: documents per native page. */
-  readonly batchSize?: number;
-}
-
-export class MongoTransactionUnsupportedError extends Error {
-  readonly name = "MongoTransactionUnsupportedError";
-  constructor(cause: unknown) {
-    super(
-      "Hot Updater writes in MongoDB transactions, which need a replica set or a sharded cluster.",
-      { cause },
-    );
-  }
-}
-
-type StoredId = DatabaseKeyValue | Readonly<Record<string, DatabaseKeyValue>>;
-
-/** A single key column is the `_id`; a composite key is a document in key-column order. */
-const idOf = (table: PhysicalTable, key: DatabaseKey): StoredId =>
-  table.key.length === 1
-    ? key[0]!
-    : Object.fromEntries(table.key.map((column, at) => [column, key[at]]));
-
-/** A filter on `_id` (never an ObjectId), and on the version when given. */
-const byId = (
-  _id: StoredId | { readonly $in: readonly StoredId[] },
-  v?: number,
-): Filter<Document> =>
-  (v === undefined ? { _id } : { _id, [V]: v }) as unknown as Filter<Document>;
-
-/** MongoDB's TTL monitor deletes a document once its `_expireAt` passes. */
-const TTL = { name: "_expireAt", key: { _expireAt: 1 }, expireAfterSeconds: 0 };
-/** When a row with retention expires; a null retention column never does. */
-const expireAt = ({ retention }: PhysicalTable, row: StoredRow) => {
-  const at = row[retention!.column];
-  return typeof at === "number" ? new Date(at + retention!.ms) : null;
-};
-
-/** Null columns are left out, so unique indexes skip them as SQL's do. */
-const toDocument = (table: PhysicalTable, row: StoredRow): Document => ({
-  _id: idOf(table, rowKey(table, row)),
-  ...Object.fromEntries(
-    table.columns.flatMap(({ name }) =>
-      row[name] === null || row[name] === undefined ? [] : [[name, row[name]]],
-    ),
-  ),
-  ...(table.retention && { [TTL.name]: expireAt(table, row) }),
-});
-
-/** `columns op bound` over a tuple prefix, expanded into ORs. */
-const compare = (
-  columns: readonly string[],
-  { values, inclusive }: QueryBound,
-  op: "$gt" | "$lt",
-): Document => {
-  const terms = values.map((value, position) => ({
-    ...Object.fromEntries(
-      columns.slice(0, position).map((column, at) => [column, values[at]]),
-    ),
-    [columns[position]!]: {
-      [position === values.length - 1 && inclusive ? `${op}e` : op]: value,
-    },
-  }));
-  return terms.length === 1 ? terms[0]! : { $or: terms };
-};
-
-const indexDescription = (
-  table: PhysicalTable,
-  index: PhysicalIndex,
-): IndexDescription => {
-  const columns = index.unique
-    ? index.eq
-    : [...index.eq, ...indexOrderColumns(table, index)];
-  const exists = columns
-    .filter((column) => findPhysicalColumn(table, column).nullable)
-    .map((column) => [column, { $exists: true }]);
-  return {
-    name: index.name,
-    key: Object.fromEntries(columns.map((column) => [column, 1])),
-    ...(index.unique && { unique: true }),
-    ...(index.unique &&
-      exists.length > 0 && {
-        partialFilterExpression: Object.fromEntries(exists),
-      }),
-  };
-};
-
-const mongoError = (error: unknown) =>
-  error instanceof MongoError ? error : undefined;
-
-/**
- * The storage engine's adapter over MongoDB: one collection per table, the
- * key as `_id`, and indexes as declared, with multi-valued fields as multikey
- * indexes. A write runs in one transaction. Guards are conditional updates,
- * and `check` is a conditional `$inc`: a real write, so a concurrent
- * transaction on the document conflicts.
- */
-export const createMongoAdapter = (
-  options: MongoAdapterOptions,
-): DatabaseAdapter => {
-  const { client, tablePrefix = "", maxOps = 1000 } = options;
-  const collection = (table: PhysicalTable) =>
-    client.db().collection(tablePrefix + table.name);
-  const normalize = (table: PhysicalTable, document: Document) =>
-    normalizeStoredRow(table, document, { jsonText: false });
-
-  /** Whether the op applied; a guard that no longer matches changes nothing. */
-  const apply = async (op: WriteOp, session: ClientSession) => {
-    const target = collection(op.table);
-    if (op.type === "insert") {
-      await target.insertOne(toDocument(op.table, op.row), { session });
-      return true;
-    }
-    const _id = idOf(op.table, op.key);
-    const update = async (filter: Filter<Document>, change: Document) =>
-      (await target.updateOne(filter, change, { session })).matchedCount === 1;
-    switch (op.type) {
-      case "patch": {
-        const $set: Document = { [V]: op.guard.v + 1 };
-        const $unset: Document = {};
-        for (const [name, value] of Object.entries(op.set)) {
-          if (value === null) $unset[name] = "";
-          else $set[name] = value;
-        }
-        if (op.table.retention)
-          $set[TTL.name] = expireAt(op.table, { ...op.previous, ...op.set });
-        return update(byId(_id, op.guard.v), { $set, $unset });
-      }
-      case "delete":
-        return (
-          (await target.deleteOne(byId(_id, op.guard.v), { session }))
-            .deletedCount === 1
-        );
-      case "check":
-        // Written, never read: a concurrent transaction on the document conflicts.
-        return update(byId(_id, op.guard.v), { $inc: { _checked: 1 } });
-      case "increment": {
-        if (op.init === undefined || op.guard !== undefined) {
-          return update(byId(_id, op.guard?.v), {
-            $inc: { ...op.by, [V]: 1 },
-          });
-        }
-        // Creates the row from `init` when it is missing, in one upsert.
-        const set: Document = {};
-        for (const { name } of op.table.columns) {
-          const start = op.init[name] ?? null;
-          const by = name === V ? 1 : op.by[name];
-          const stored = { $ifNull: [`$${name}`, { $literal: start ?? 0 }] };
-          if (by !== undefined) set[name] = { $add: [stored, by] };
-          else if (start !== null) set[name] = stored;
-        }
-        // A Date or null in a pipeline stage is a literal, not an expression.
-        if (op.table.retention) set[TTL.name] = expireAt(op.table, op.init);
-        await target.updateOne(byId(_id), [{ $set: set }], {
-          upsert: true,
-          session,
-        });
-        return true;
-      }
-    }
-  };
-
-  return {
-    id: "mongodb",
-    fits: (ops) => ops.length <= maxOps,
-
-    async get(table, keys) {
-      if (keys.length === 0) return [];
-      const ids = keys.map((key) => idOf(table, key));
-      const documents = await collection(table)
-        .find(byId({ $in: ids }))
-        .toArray();
-      const found = new Map(
-        documents.map((document) => [JSON.stringify(document._id), document]),
-      );
-      return ids.map((id) => {
-        const document = found.get(JSON.stringify(id));
-        return document === undefined ? null : normalize(table, document);
-      });
-    },
-
-    async query(table, request) {
-      const index = findPhysicalIndex(table, request.index);
-      const columns = indexOrderColumns(table, index);
-      const bounds = [
-        ...(request.lower ? [compare(columns, request.lower, "$gt")] : []),
-        ...(request.upper ? [compare(columns, request.upper, "$lt")] : []),
-      ];
-      const direction = request.order === "asc" ? 1 : -1;
-      const documents = await collection(table)
-        .find(
-          {
-            ...Object.fromEntries(
-              index.eq.map((column, at) => [column, request.eq[at]]),
-            ),
-            ...(bounds.length > 0 && { $and: bounds }),
-          },
-          {
-            sort: Object.fromEntries(
-              columns.map((column) => [column, direction]),
-            ),
-            limit: request.limit,
-            ...(options.batchSize && { batchSize: options.batchSize }),
-          },
-        )
-        .toArray();
-      return documents.map((document) => normalize(table, document));
-    },
-
-    async write(ops) {
-      const session = client.startSession();
-      let position = 0;
-      try {
-        session.startTransaction({
-          readConcern: { level: "snapshot" },
-          writeConcern: { w: "majority" },
-        });
-        for (; position < ops.length; position += 1) {
-          if (!(await apply(ops[position]!, session))) {
-            await session.abortTransaction();
-            return { ok: false, failedOp: position };
-          }
-        }
-        // Committing again is safe when the outcome is unknown.
-        await session.commitTransaction().catch(async (error: unknown) => {
-          const unknown = mongoError(error)?.hasErrorLabel(
-            "UnknownTransactionCommitResult",
-          );
-          if (!unknown) throw error;
-          await session.commitTransaction();
-        });
-        return { ok: true };
-      } catch (error) {
-        if (session.inTransaction()) {
-          await session.abortTransaction().catch(() => undefined);
-        }
-        const failure = mongoError(error);
-        if (
-          failure?.hasErrorLabel("TransientTransactionError") ||
-          failure?.code === 112
-        ) {
-          return { ok: false, retry: true };
-        }
-        if (failure?.code === 11000 && position < ops.length) {
-          // Two upserts creating one key race; the loser runs again.
-          return ops[position]!.type === "increment"
-            ? { ok: false, retry: true }
-            : { ok: false, failedOp: position };
-        }
-        throw failure?.code === 20
-          ? new MongoTransactionUnsupportedError(error)
-          : error;
-      } finally {
-        await session.endSession();
-      }
-    },
-
-    migrations: {
-      async apply(tables) {
-        for (const table of tables) {
-          // An existing collection keeps its documents; its indexes are ensured.
-          await client
-            .db()
-            .createCollection(tablePrefix + table.name)
-            .catch((error: unknown) => {
-              if (mongoError(error)?.code !== 48) throw error;
-            });
-          if (table.retention) await collection(table).createIndexes([TTL]);
-          if (table.indexes.length === 0) continue;
-          await collection(table).createIndexes(
-            table.indexes.map((index) => indexDescription(table, index)),
-          );
-        }
-      },
-    },
-  };
-};

package/src/adapters/prisma.conformance.integration.spec.ts

@@ -1,36 +0,0 @@
-import { PGlite } from "@electric-sql/pglite";
-import { setupDatabaseAdapterConformanceSuite } from "@hot-updater/test-utils";
-
-import { SETTINGS_TABLE } from "../database/fence";
-import { createTableStatements } from "../database/sql/sqlSchema";
-import { coreSettings } from "../db/coreDatabase";
-import { settingsStatements } from "../db/engineSql";
-import { prismaAdapter } from "./prisma";
-import { pglitePrisma } from "./prismaTestClients";
-
-/**
- * The adapter `prismaAdapter` returns, schema fence included, over Prisma's
- * raw query API on a new PGlite per test. Prisma has no models for the
- * conformance tables, so the SQL core's DDL creates them, beside the settings
- * rows the fence checks. PostgreSQL has no cap on one write and no native
- * pages.
- */
-setupDatabaseAdapterConformanceSuite({
-  name: "prisma (PGlite)",
-  createAdapter: async ({ tables }) => {
-    const client = new PGlite();
-    await client.exec(
-      [
-        ...createTableStatements("postgresql", [...tables, SETTINGS_TABLE]),
-        ...settingsStatements("postgresql", coreSettings),
-      ].join(";\n"),
-    );
-    return {
-      adapter: prismaAdapter({
-        prisma: pglitePrisma(client),
-        provider: "postgresql",
-      }).adapter,
-      cleanup: () => client.close(),
-    };
-  },
-});

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

@@ -1,146 +0,0 @@
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-
-import {
-  setupDatabaseTestSuite,
-  startHttpTestServer,
-} from "@hot-updater/test-utils";
-import { assertDockerComposeAvailable } from "@hot-updater/test-utils/node";
-import { execa } from "execa";
-import mysql from "mysql2/promise";
-import { afterAll, beforeAll, describe, expect, it } from "vitest";
-
-import { createDatabasePluginApis } from "../assembly/databasePlugins";
-import { isMultiIndex, quoteSql } from "../database/sql/sqlSchema";
-import { toolingTargetOf } from "../db/coreDatabase";
-import { createHotUpdater } from "../index";
-import { createInsightsModel, insights } from "../plugins/insights";
-import { insightsTestSuite } from "../plugins/insights/testing";
-import { prismaAdapter } from "./prisma";
-import { mysqlPrisma, prismaPushSql } from "./prismaTestClients";
-
-assertDockerComposeAvailable(
-  "Prisma's MySQL integration tests need Docker Compose and a running Docker daemon.",
-);
-
-const compose = [
-  "compose",
-  "-f",
-  path.join(
-    path.dirname(fileURLToPath(import.meta.url)),
-    "../database/sql/docker-compose.yml",
-  ),
-  "-p",
-  "hot-updater-sql-core",
-];
-const server = "mysql://root:hot_updater@127.0.0.1:53306";
-const database = `prisma_${process.pid}`;
-
-/** What the suite runs: core and the Insights plugin. */
-const target = toolingTargetOf([insights()]);
-
-const dataTables = target.schema.tables.flatMap((table) => [
-  table.name,
-  ...table.indexes
-    .filter((index) => isMultiIndex(table, index))
-    .map((index) => `${table.name}__${index.name}`),
-]);
-
-let admin: mysql.Pool;
-let pool: mysql.Pool;
-
-/**
- * MySQL has no Prisma example, so the tables come from Prisma's own DDL for
- * the generated models, as `prisma db push` would run it, and the adapter
- * runs over mysql2 through Prisma's raw query API.
- */
-beforeAll(async () => {
-  await execa("docker", [...compose, "up", "-d", "--wait", "mysql"]);
-  admin = mysql.createPool({ uri: server, multipleStatements: true });
-  for (let attempt = 0; ; attempt += 1) {
-    try {
-      await admin.query("SELECT 1");
-      break;
-    } catch (error) {
-      if (attempt > 60) throw error;
-      await new Promise((resolve) => setTimeout(resolve, 1000));
-    }
-  }
-  await admin.query(
-    `DROP DATABASE IF EXISTS ${database}; CREATE DATABASE ${database}`,
-  );
-  await admin.query(`USE ${database}; ${await prismaPushSql("mysql", target)}`);
-  pool = mysql.createPool({
-    uri: `${server}/${database}`,
-    connectionLimit: 16,
-  });
-  const migrator = prismaAdapter({
-    prisma: mysqlPrisma(pool),
-    provider: "mysql",
-  }).createMigrator!(target);
-  await (await migrator.migrateToLatest()).execute();
-}, 180_000);
-
-afterAll(async () => {
-  await pool?.end();
-  await admin?.query(`DROP DATABASE IF EXISTS ${database}`);
-  await admin?.end();
-  await execa("docker", [...compose, "down", "-v"]);
-}, 60_000);
-
-setupDatabaseTestSuite({
-  createHttpClient: (options) =>
-    startHttpTestServer(
-      createHotUpdater({
-        ...options,
-        plugins: [insights()],
-        clientAccess: "public",
-      }).handlers,
-    ),
-  plugins: [
-    insightsTestSuite({
-      createModel: (database) =>
-        createInsightsModel(
-          createDatabasePluginApis(database, [insights()]).insights,
-        ),
-    }),
-  ],
-  name: "prismaAdapter (MySQL, Prisma's tables)",
-  migrate: () => undefined,
-  createDatabase: () =>
-    prismaAdapter({ prisma: mysqlPrisma(pool), provider: "mysql" }),
-  reset: async () => {
-    for (const table of dataTables) {
-      await pool.query(`DELETE FROM ${quoteSql("mysql", table)}`);
-    }
-  },
-  dispose: () => undefined,
-});
-
-describe("prismaAdapter on Prisma's MySQL tables", () => {
-  it("keeps ASCII keys binary and sets binary UTF-8 collations after Prisma", async () => {
-    const [columns] = await pool.query(
-      "SELECT TABLE_NAME AS name, COLUMN_NAME AS col, DATA_TYPE AS type, COLLATION_NAME AS collation FROM information_schema.COLUMNS WHERE TABLE_SCHEMA = DATABASE() AND ((TABLE_NAME = 'releases' AND COLUMN_NAME IN ('scope_key', 'channel_id')) OR (TABLE_NAME = 'channels' AND COLUMN_NAME = 'name')) ORDER BY TABLE_NAME, COLUMN_NAME",
-    );
-    expect(columns).toEqual([
-      {
-        name: "channels",
-        col: "name",
-        type: "varchar",
-        collation: "utf8mb4_0900_bin",
-      },
-      {
-        name: "releases",
-        col: "channel_id",
-        type: "varbinary",
-        collation: null,
-      },
-      {
-        name: "releases",
-        col: "scope_key",
-        type: "varbinary",
-        collation: null,
-      },
-    ]);
-  });
-});

package/src/adapters/prisma.readBudgets.integration.spec.ts

@@ -1,43 +0,0 @@
-import { PGlite } from "@electric-sql/pglite";
-import {
-  postgresRowsExamined,
-  setupReadBudgetTestSuite,
-} from "@hot-updater/test-utils";
-
-import { createSqlAdapter } from "../database/sql/sqlAdapter";
-import { readBudgetServer } from "../readBudgets.testFixtures";
-import { prismaAdapter } from "./prisma";
-import { prismaExecutor } from "./prismaExecutor";
-import { pglitePrisma, prismaPushSql } from "./prismaTestClients";
-
-/** Core's tables and those of the plugins the suite measures. */
-const target = readBudgetServer.toolingTargetOf(readBudgetServer.plugins);
-
-/**
- * `prismaAdapter`'s composition without its schema fence: the SQL core over
- * the Prisma executor, through Prisma's raw query API on PGlite, on the
- * tables `prisma db push` creates and its migrator completes.
- */
-setupReadBudgetTestSuite({
-  name: "prisma (PGlite)",
-  server: readBudgetServer,
-  createAdapter: async () => {
-    const client = new PGlite();
-    await client.exec(await prismaPushSql("postgresql", target));
-    const prisma = pglitePrisma(client);
-    const migrator = prismaAdapter({ prisma, provider: "postgresql" })
-      .createMigrator!(target);
-    await (await migrator.migrateToLatest()).execute();
-    const reads = postgresRowsExamined(
-      async (sql, params) =>
-        (await client.query<Record<string, unknown>>(sql, [...params])).rows,
-    );
-    return {
-      adapter: createSqlAdapter({
-        executor: reads.wrap(prismaExecutor(prisma, "postgresql")),
-      }),
-      examined: reads.examined,
-      cleanup: () => client.close(),
-    };
-  },
-});