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

package/src/adapters/prisma.spec.ts

@@ -1,257 +0,0 @@
-import { DatabaseSync } from "node:sqlite";
-
-import { PGlite } from "@electric-sql/pglite";
-import {
-  setupDatabaseTestSuite,
-  startHttpTestServer,
-} from "@hot-updater/test-utils";
-import { describe, expect, it } from "vitest";
-
-import { createBundleFixture } from "../../../test-utils/src/databaseTestFixtures";
-import { createDatabasePluginApis } from "../assembly/databasePlugins";
-import { createInProcessCoreApi } from "../core/api";
-import { HotUpdaterSchemaMigrationRequiredError } from "../database/fence";
-import { classifySqlError } from "../database/sql/sqlAdapter";
-import { isMultiIndex, quoteSql } from "../database/sql/sqlSchema";
-import { toolingTargetOf } from "../db/coreDatabase";
-import type { ToolingDatabase } from "../db/types";
-import { createHotUpdater } from "../index";
-import { createInsightsModel, insights } from "../plugins/insights";
-import { insightsTestSuite } from "../plugins/insights/testing";
-import { prismaAdapter } from "./prisma";
-import {
-  prismaExecutor,
-  type PrismaTransactionalClient,
-} from "./prismaExecutor";
-import { pglitePrisma, prismaPushSql, sqlitePrisma } from "./prismaTestClients";
-
-/** What the suites run: core and the Insights plugin. */
-const target = toolingTargetOf([insights()]);
-
-/** Every data table; the settings rows stay across tests. */
-const dataTables = target.schema.tables.flatMap((table) => [
-  table.name,
-  ...table.indexes
-    .filter((index) => isMultiIndex(table, index))
-    .map((index) => `${table.name}__${index.name}`),
-]);
-
-/** Prisma's tables, as `prisma db push` creates them, then `hot-updater db migrate`. */
-const backends = {
-  postgresql: async () => {
-    const db = new PGlite();
-    await db.exec(await prismaPushSql("postgresql", target));
-    const prisma = pglitePrisma(db);
-    return {
-      prisma,
-      exec: (sql: string) => db.exec(sql).then(() => undefined),
-      close: () => db.close(),
-    };
-  },
-  sqlite: async () => {
-    const db = new DatabaseSync(":memory:");
-    db.exec(await prismaPushSql("sqlite", target));
-    return {
-      prisma: sqlitePrisma(db),
-      exec: async (sql: string) => db.exec(sql),
-      close: async () => db.close(),
-    };
-  },
-} as const;
-
-const migrate = async (database: ToolingDatabase) =>
-  (await database.createMigrator!(target).migrateToLatest()).execute();
-
-for (const provider of ["postgresql", "sqlite"] as const) {
-  let backend: Awaited<ReturnType<(typeof backends)[typeof provider]>>;
-  setupDatabaseTestSuite({
-    createHttpClient: (options) =>
-      startHttpTestServer(
-        createHotUpdater({
-          ...options,
-          plugins: [insights()],
-          clientAccess: "public",
-        }).handlers,
-      ),
-    plugins: [
-      insightsTestSuite({
-        createModel: (database) =>
-          createInsightsModel(
-            createDatabasePluginApis(database, [insights()]).insights,
-          ),
-      }),
-    ],
-    name: `prismaAdapter (${provider})`,
-    migrate: async () => {
-      backend = await backends[provider]();
-      await migrate(prismaAdapter({ prisma: backend.prisma, provider }));
-    },
-    createDatabase: () => prismaAdapter({ prisma: backend.prisma, provider }),
-    reset: async () => {
-      const quote = (name: string) => quoteSql(provider, name);
-      await backend.exec(
-        provider === "postgresql"
-          ? `TRUNCATE ${dataTables.map(quote).join(", ")}`
-          : dataTables.map((name) => `DELETE FROM ${quote(name)};`).join(""),
-      );
-    },
-    dispose: () => backend.close(),
-  });
-}
-
-describe("prismaAdapter migrations", () => {
-  it("sets the collations Prisma cannot declare, writes the settings, and serves behind the fence", async () => {
-    const { prisma, close } = await backends.postgresql();
-    const database = prismaAdapter({ prisma, provider: "postgresql" });
-    const core = createInProcessCoreApi(database.adapter);
-    await expect(core.listChannels()).rejects.toBeInstanceOf(
-      HotUpdaterSchemaMigrationRequiredError,
-    );
-
-    const migrator = database.createMigrator!();
-    const pending = await migrator.migrateToLatest();
-    expect(pending.operations.map(({ type }) => type)).toEqual([
-      "custom",
-      "custom",
-    ]);
-    expect(pending.getSQL?.()).toContain(
-      'ALTER TABLE "releases" ALTER COLUMN "id" TYPE varchar(36) COLLATE "C"',
-    );
-    await pending.execute();
-    await expect(migrator.migrateToLatest()).resolves.toMatchObject({
-      operations: [],
-    });
-    const collations = (await prisma.$queryRawUnsafe(
-      "SELECT column_name, collation_name FROM information_schema.columns WHERE table_name = 'releases' AND column_name IN ('scope_key', 'revision') ORDER BY column_name",
-    )) as { column_name: string; collation_name: string | null }[];
-    expect(collations).toEqual([
-      { column_name: "revision", collation_name: null },
-      { column_name: "scope_key", collation_name: "C" },
-    ]);
-
-    const [result] = await core.deploy([
-      {
-        bundle: createBundleFixture("1"),
-        release: {
-          channel: "production",
-          enabled: true,
-          fingerprintHash: null,
-          message: null,
-          shouldForceUpdate: false,
-          targetAppVersion: "1.0.0",
-        },
-      },
-    ]);
-    const release = result!.release!;
-    await expect(core.getRelease(release.id)).resolves.toEqual(release);
-    await close();
-  });
-
-  it("asks for Prisma's tables first", async () => {
-    const db = new PGlite();
-    await expect(
-      prismaAdapter({ prisma: pglitePrisma(db), provider: "postgresql" })
-        .createMigrator!().migrateToLatest(),
-    ).rejects.toThrow("prisma db push");
-    await db.close();
-  });
-
-  it.each(["mssql", "cockroachdb"])(
-    "refuses %s, which 1.0 dropped",
-    (provider) => {
-      expect(() =>
-        prismaAdapter({ prisma: {}, provider: provider as never }),
-      ).toThrow("CockroachDB and SQL Server were dropped in 1.0");
-    },
-  );
-});
-
-describe("prismaAdapter schema", () => {
-  const models = (provider: "mysql" | "postgresql" | "sqlite") =>
-    prismaAdapter({ prisma: {}, provider }).generateSchema!("latest").code;
-
-  it("maps engine columns to fields that start with a letter, with keys and named indexes but no relations", () => {
-    const code = models("postgresql");
-    expect(code).toContain('hu_v BigInt @default(0) @map("_v")');
-    expect(code).toContain("model private_hot_updater_settings {");
-    expect(code).toContain(
-      '@@index([platform, id], map: "bundles_byPlatform")',
-    );
-    expect(code).not.toContain("@relation");
-  });
-
-  it("stores MySQL's ASCII keys as VarBinary, within InnoDB's key limit", () => {
-    const code = models("mysql");
-    expect(code).toMatch(/scope_key Bytes @db\.VarBinary\(2048\)/u);
-    expect(code).toMatch(/id String @db\.VarChar\(36\)/u);
-  });
-});
-
-describe("prismaExecutor", () => {
-  it("carries the database's code from Prisma's error, so the SQL core can classify it", async () => {
-    const db = new PGlite();
-    await db.exec("CREATE TABLE t (id text PRIMARY KEY)");
-    const executor = prismaExecutor(pglitePrisma(db), "postgresql");
-    const insert = { sql: "INSERT INTO t (id) VALUES ($1)", params: ["a"] };
-    await executor.execute(insert);
-    const error = await executor
-      .execute(insert)
-      .catch((caught: unknown) => caught);
-    expect(error).toMatchObject({ code: "23505", cause: { code: "P2010" } });
-    expect(classifySqlError(error)).toBe("constraint");
-    await db.close();
-
-    const sqlite = new DatabaseSync(":memory:");
-    sqlite.exec("CREATE TABLE t (id TEXT PRIMARY KEY)");
-    const sqliteExecutor = prismaExecutor(sqlitePrisma(sqlite), "sqlite");
-    const row = { sql: "INSERT INTO t (id) VALUES (?)", params: ["a"] };
-    await sqliteExecutor.execute(row);
-    expect(
-      classifySqlError(
-        await sqliteExecutor.execute(row).catch((caught: unknown) => caught),
-      ),
-    ).toBe("constraint");
-  });
-
-  it("retries a transaction Prisma reports as a write conflict", async () => {
-    const conflict = Object.assign(new Error("write conflict"), {
-      code: "P2034",
-    });
-    const client = {
-      $queryRawUnsafe: async () => [],
-      $executeRawUnsafe: async () => 0,
-      $transaction: async () => {
-        throw conflict;
-      },
-    } satisfies PrismaTransactionalClient;
-    const error = await prismaExecutor(client, "postgresql")
-      .transaction(async () => undefined)
-      .catch((caught: unknown) => caught);
-    expect(classifySqlError(error)).toBe("retry");
-  });
-
-  it("takes SQLite's write lock with a transaction's first statement, and reads bytes as text", async () => {
-    const statements: string[] = [];
-    const tx = {
-      $queryRawUnsafe: async () => [
-        { scope_key: new TextEncoder().encode("key"), revision: 1 },
-      ],
-      $executeRawUnsafe: async (sql: string) => {
-        statements.push(sql);
-        return 0;
-      },
-    };
-    const client = {
-      ...tx,
-      $transaction: async <T>(fn: (runner: typeof tx) => Promise<T>) => fn(tx),
-    } satisfies PrismaTransactionalClient;
-    const rows = await prismaExecutor(client, "sqlite").transaction(
-      async (connection) =>
-        (await connection.execute({ sql: "SELECT 1", params: [] })).rows,
-    );
-    expect(statements).toEqual([
-      'UPDATE "private_hot_updater_settings" SET "_v" = "_v" WHERE 0 = 1',
-    ]);
-    expect(rows).toEqual([{ scope_key: "key", revision: 1 }]);
-  });
-});

package/src/adapters/prisma.ts

@@ -1,74 +0,0 @@
-import { createSqlAdapter } from "../database/sql/sqlAdapter";
-import {
-  coreSettings,
-  coreTarget,
-  createEngineDatabase,
-} from "../db/coreDatabase";
-import {
-  generatePrismaEngineSchema,
-  prismaCollationStatements,
-  type PrismaProvider,
-} from "../db/enginePrismaSchema";
-import { createSettingsMigrator } from "../db/settingsMigrator";
-import type { SchemaGenerator, ToolingDatabase } from "../db/types";
-import {
-  prismaExecutor,
-  type PrismaTransactionalClient,
-} from "./prismaExecutor";
-import { checkSqlProvider } from "./sqlProviders";
-
-export type { PrismaProvider };
-
-export interface PrismaConfig {
-  /** A Prisma client: raw queries and interactive transactions run on it. */
-  readonly prisma: object;
-  readonly provider: PrismaProvider;
-}
-
-/**
- * Hot Updater's database on a Prisma client: the storage engine through the
- * shared SQL core, fenced by the schema settings. `db generate` writes the
- * models Prisma applies; `db migrate` then sets the collations Prisma cannot
- * declare and writes the settings rows the fence checks.
- */
-export const prismaAdapter = (config: PrismaConfig): ToolingDatabase => {
-  const provider = checkSqlProvider("prismaAdapter", config.provider);
-  const executor = prismaExecutor(
-    config.prisma as PrismaTransactionalClient,
-    provider,
-  );
-  return {
-    ...createEngineDatabase({
-      name: "prisma",
-      adapter: createSqlAdapter({ executor }),
-    }),
-    provider,
-    generateSchema: ((version, _name, { schema } = coreTarget) => {
-      if (version !== "latest" && version !== coreSettings["schema.core"]) {
-        throw new Error(`Invalid version ${version}`);
-      }
-      return {
-        code: generatePrismaEngineSchema(provider, schema),
-        path: "prisma/schema.prisma",
-      };
-    }) satisfies SchemaGenerator,
-    createMigrator: ({ schema, settings } = coreTarget) => {
-      const collations = prismaCollationStatements(provider, schema);
-      return createSettingsMigrator({
-        adapterName: "prisma",
-        executor,
-        settings,
-        applyTables: "`prisma db push` (or `prisma migrate`)",
-        ...(collations.length === 0
-          ? {}
-          : {
-              fixups: {
-                description:
-                  "Set the collations Prisma cannot declare, so strings compare by their bytes",
-                statements: collations,
-              },
-            }),
-      });
-    },
-  };
-};

package/src/adapters/prismaExecutor.ts

@@ -1,107 +0,0 @@
-import { SETTINGS_TABLE } from "../database/fence";
-import type {
-  SqlConnection,
-  SqlDialect,
-  SqlExecutor,
-} from "../database/sql/sqlAdapter";
-import { quoteSql } from "../database/sql/sqlSchema";
-
-/** The members of a Prisma client, or of its transaction client, the executor uses. */
-export interface PrismaRawClient {
-  $queryRawUnsafe(query: string, ...values: unknown[]): Promise<unknown>;
-  $executeRawUnsafe(query: string, ...values: unknown[]): Promise<number>;
-}
-
-export interface PrismaTransactionalClient extends PrismaRawClient {
-  $transaction<T>(
-    fn: (tx: PrismaRawClient) => Promise<T>,
-    options?: { readonly maxWait?: number; readonly timeout?: number },
-  ): Promise<T>;
-}
-
-/**
- * Prisma reports a raw query's database error as P2010 with the database's
- * code in `meta.code`, and a failed transaction as P2034. The error thrown on
- * carries that code, as the SQL core classifies it, with Prisma's as `cause`.
- */
-const withDatabaseCode = (dialect: SqlDialect, error: unknown): unknown => {
-  const { code, meta } = (error ?? {}) as {
-    code?: unknown;
-    meta?: { code?: unknown; message?: unknown };
-  };
-  const database =
-    code === "P2034"
-      ? "40001"
-      : meta?.code === undefined
-        ? undefined
-        : String(meta.code);
-  if (database === undefined) return error;
-  return Object.assign(
-    new Error(String(meta?.message ?? (error as Error).message), {
-      cause: error,
-    }),
-    { code: dialect === "sqlite" ? `SQLITE:${database}` : database },
-  );
-};
-
-/** MySQL's ASCII keys are `VarBinary` in Prisma's schema, and read back as bytes. */
-const decoder = new TextDecoder();
-const decodeRow = (row: Record<string, unknown>) => {
-  for (const [column, value] of Object.entries(row)) {
-    if (value instanceof Uint8Array) row[column] = decoder.decode(value);
-  }
-  return row;
-};
-
-const over = (dialect: SqlDialect, client: PrismaRawClient): SqlConnection => ({
-  async execute({ sql, params }) {
-    try {
-      if (/^\s*SELECT\b/iu.test(sql)) {
-        const rows = (await client.$queryRawUnsafe(sql, ...params)) as Record<
-          string,
-          unknown
-        >[];
-        return { rows: rows.map(decodeRow), changes: 0 };
-      }
-      return {
-        rows: [],
-        changes: Number(await client.$executeRawUnsafe(sql, ...params)),
-      };
-    } catch (error) {
-      throw withDatabaseCode(dialect, error);
-    }
-  },
-});
-
-/** Taking the write lock first makes a SQLite transaction behave as BEGIN IMMEDIATE. */
-const writeLock = (dialect: SqlDialect) =>
-  `UPDATE ${quoteSql(dialect, SETTINGS_TABLE.name)} SET ${quoteSql(dialect, "_v")} = ${quoteSql(dialect, "_v")} WHERE 0 = 1`;
-
-/**
- * The SQL core's executor over a Prisma client, through raw queries and
- * interactive transactions. A SQLite transaction takes the write lock with
- * its first statement, as BEGIN IMMEDIATE would.
- */
-export const prismaExecutor = (
-  client: PrismaTransactionalClient,
-  dialect: SqlDialect,
-): SqlExecutor => ({
-  dialect,
-  ...over(dialect, client),
-  async transaction(fn) {
-    try {
-      return await client.$transaction(
-        async (tx) => {
-          const connection = over(dialect, tx);
-          if (dialect === "sqlite") {
-            await connection.execute({ sql: writeLock(dialect), params: [] });
-          }
-          return fn(connection);
-        },
-        { maxWait: 10_000, timeout: 30_000 },
-      );
-    } catch (error) {
-      throw withDatabaseCode(dialect, error);
-    }
-  },
-});

package/src/adapters/prismaTestClients.ts

@@ -1,182 +0,0 @@
-import { execFile } from "node:child_process";
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
-import { createRequire } from "node:module";
-import os from "node:os";
-import path from "node:path";
-import type { DatabaseSync, SqliteValue } from "node:sqlite";
-import { promisify } from "node:util";
-
-import type { PGlite, Transaction } from "@electric-sql/pglite";
-import type { Pool as MysqlPool, PoolConnection } from "mysql2/promise";
-
-import type { ToolingTarget } from "../db/types";
-import { prismaAdapter, type PrismaProvider } from "./prisma";
-import type {
-  PrismaRawClient,
-  PrismaTransactionalClient,
-} from "./prismaExecutor";
-
-/** A database error as Prisma reports a failed raw query: P2010, with the database's code. */
-const prismaError = (error: unknown) => {
-  const { code, errcode, errno, message } = error as Record<string, unknown>;
-  const database = String(errcode ?? errno ?? code);
-  return Object.assign(
-    new Error(
-      `Raw query failed. Code: \`${database}\`. Message: \`${String(message)}\``,
-    ),
-    {
-      name: "PrismaClientKnownRequestError",
-      code: "P2010",
-      meta: { code: database, message: String(message) },
-    },
-  );
-};
-
-const raw = (
-  query: (sql: string, params: unknown[]) => Promise<unknown[]>,
-  execute: (sql: string, params: unknown[]) => Promise<number>,
-): PrismaRawClient => ({
-  $queryRawUnsafe: (sql, ...params) =>
-    query(sql, params).catch((error: unknown) => {
-      throw prismaError(error);
-    }),
-  $executeRawUnsafe: (sql, ...params) =>
-    execute(sql, params).catch((error: unknown) => {
-      throw prismaError(error);
-    }),
-});
-
-/** Prisma's raw query API over PGlite, as the Prisma client answers it. */
-export const pglitePrisma = (db: PGlite): PrismaTransactionalClient => {
-  const over = (runner: PGlite | Transaction) =>
-    raw(
-      async (sql, params) => (await runner.query(sql, params)).rows,
-      async (sql, params) =>
-        (await runner.query(sql, params)).affectedRows ?? 0,
-    );
-  return {
-    ...over(db),
-    $transaction: (fn) => db.transaction((tx) => fn(over(tx))),
-  };
-};
-
-/**
- * Prisma's raw query API over `node:sqlite`. Like Prisma's SQLite client, it
- * runs one operation at a time, and begins transactions deferred.
- */
-export const sqlitePrisma = (db: DatabaseSync): PrismaTransactionalClient => {
-  const over = raw(
-    async (sql, params) => db.prepare(sql).all(...(params as SqliteValue[])),
-    async (sql, params) =>
-      Number(db.prepare(sql).run(...(params as SqliteValue[])).changes),
-  );
-  let queue: Promise<unknown> = Promise.resolve();
-  const serial = <T>(task: () => Promise<T>) => {
-    const result = queue.then(task);
-    queue = result.catch(() => undefined);
-    return result;
-  };
-  return {
-    $queryRawUnsafe: (sql, ...params) =>
-      serial(() => over.$queryRawUnsafe(sql, ...params)),
-    $executeRawUnsafe: (sql, ...params) =>
-      serial(() => over.$executeRawUnsafe(sql, ...params)),
-    $transaction: (fn) =>
-      serial(async () => {
-        db.exec("BEGIN");
-        try {
-          const result = await fn(over);
-          db.exec("COMMIT");
-          return result;
-        } catch (error) {
-          db.exec("ROLLBACK");
-          throw error;
-        }
-      }),
-  };
-};
-
-/** Prisma's raw query API over a mysql2 pool. */
-export const mysqlPrisma = (pool: MysqlPool): PrismaTransactionalClient => {
-  const over = (runner: MysqlPool | PoolConnection) =>
-    raw(
-      async (sql, params) => (await runner.query(sql, params))[0] as unknown[],
-      async (sql, params) => {
-        const [result] = await runner.query(sql, params);
-        return (result as { affectedRows: number }).affectedRows;
-      },
-    );
-  return {
-    ...over(pool),
-    async $transaction(fn) {
-      const connection = await pool.getConnection();
-      try {
-        await connection.beginTransaction();
-        const result = await fn(over(connection));
-        await connection.commit();
-        return result;
-      } catch (error) {
-        await connection.rollback().catch(() => undefined);
-        throw error;
-      } finally {
-        connection.release();
-      }
-    },
-  };
-};
-
-const prismaCli = createRequire(import.meta.url).resolve(
-  "prisma/build/index.js",
-);
-const urls: Record<PrismaProvider, string> = {
-  sqlite: "file:./unused.db",
-  postgresql: "postgresql://unused@localhost/unused",
-  mysql: "mysql://unused@localhost/unused",
-};
-
-/**
- * The DDL `prisma db push` runs for the models generated for `target` (core
- * and the plugins it lists) on an empty database, from Prisma's CLI.
- */
-export const prismaPushSql = async (
-  provider: PrismaProvider,
-  target?: ToolingTarget,
-): Promise<string> => {
-  const directory = await mkdtemp(
-    path.join(os.tmpdir(), "hot-updater-prisma-"),
-  );
-  try {
-    const file = path.join(directory, "schema.prisma");
-    const models = prismaAdapter({ prisma: {}, provider }).generateSchema!(
-      "latest",
-      undefined,
-      target,
-    ).code;
-    await writeFile(
-      file,
-      `datasource db {\n  provider = "${provider}"\n  url      = "${urls[provider]}"\n}\n\n${models}\n`,
-    );
-    const { stdout } = await promisify(execFile)(
-      process.execPath,
-      [
-        prismaCli,
-        "migrate",
-        "diff",
-        "--from-empty",
-        "--to-schema-datamodel",
-        file,
-        "--script",
-      ],
-      {
-        env: {
-          ...process.env,
-          CHECKPOINT_DISABLE: "1",
-          PRISMA_HIDE_UPDATE_MESSAGE: "1",
-        },
-      },
-    );
-    return stdout;
-  } finally {
-    await rm(directory, { recursive: true, force: true });
-  }
-};

package/src/adapters/sqlProviders.ts

@@ -1,14 +0,0 @@
-import { sqlProviders, type ORMSQLProvider } from "../db/types";
-
-/** The provider an adapter was given, when Hot Updater's SQL core runs on it. */
-export const checkSqlProvider = <TProvider extends ORMSQLProvider>(
-  adapter: string,
-  provider: TProvider,
-): TProvider => {
-  if (!(sqlProviders as readonly string[]).includes(provider)) {
-    throw new Error(
-      `${adapter}: provider "${String(provider)}" is not supported. Use ${sqlProviders.map((name) => `"${name}"`).join(", ")}; CockroachDB and SQL Server were dropped in 1.0.`,
-    );
-  }
-  return provider;
-};