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

package/src/adapters/prismaTestClients.ts

@@ -0,0 +1,175 @@
+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 { 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 generated models on an empty database, from Prisma's CLI. */
+export const prismaPushSql = async (
+  provider: PrismaProvider,
+): 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",
+    ).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

@@ -0,0 +1,14 @@
+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;
+};

package/src/apiKeys.integration.spec.ts

@@ -1,8 +1,9 @@
-import { describe, expect, it, vi } from "vitest";
+import { describe, expect, it } from "vitest";
 
-import { createInMemoryDatabasePlugin } from "../../test-utils/test/inMemoryDatabasePlugin";
-import { registerApiKey } from "./apiKeys";
 import { API_KEY_HEADER_NAME, createHotUpdater } from "./index";
+import { apiKeys } from "./plugins/api-keys";
+import { insights } from "./plugins/insights";
+import { createRuntimeDatabase } from "./runtime.testFixtures";
 
 const API_KEY = "AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQE";
 const updateUrl =
@@ -18,30 +19,19 @@ const withApiKey = (url: string, init?: RequestInit) =>
     },
   });
 
-describe("createHotUpdater API keys", () => {
-  it("rejects an invalid API key header name", () => {
-    expect(() =>
-      createHotUpdater({
-        clientAccess: {
-          headerName: "invalid header",
-          type: "api-key",
-        },
-        database: createInMemoryDatabasePlugin(),
-      }),
-    ).toThrow("clientAccess.headerName must be a valid header name.");
+/** A server whose client routes the apiKeys() plugin protects, with one registered key. */
+const start = async () => {
+  const hotUpdater = createHotUpdater({
+    database: createRuntimeDatabase(),
+    plugins: [apiKeys(), insights()],
   });
+  await hotUpdater.api.apiKeys.register({ apiKey: API_KEY, name: "App" });
+  return hotUpdater;
+};
 
+describe("createHotUpdater with the apiKeys() plugin", () => {
   it("protects only client OTA and Insights write routes", async () => {
-    const database = createInMemoryDatabasePlugin();
-    await registerApiKey({
-      apiKeys: database.models.apiKeys,
-      apiKey: API_KEY,
-      name: "App",
-    });
-    const hotUpdater = createHotUpdater({
-      clientAccess: { type: "api-key" },
-      database,
-    });
+    const hotUpdater = await start();
 
     expect(
       (await hotUpdater.handlers.client(new Request(updateUrl))).status,
@@ -59,44 +49,14 @@ describe("createHotUpdater API keys", () => {
     expect(
       (
         await hotUpdater.handlers.admin(
-          withApiKey("https://example.com/installations/overview"),
+          new Request("https://example.com/events"),
         )
       ).status,
     ).toBe(200);
   });
 
-  it("creates, lists, and revokes API keys without exposing hashes", async () => {
-    const hotUpdater = createHotUpdater({
-      clientAccess: { type: "public" },
-      database: createInMemoryDatabasePlugin(),
-    });
-
-    const created = await hotUpdater.apiKeys.create({ name: "Production" });
-    expect(created.apiKey).toMatch(/^[A-Za-z0-9_-]{43}$/u);
-    expect(created.record).not.toHaveProperty("hash");
-
-    await expect(hotUpdater.apiKeys.list()).resolves.toEqual([created.record]);
-    const revoked = await hotUpdater.apiKeys.revoke({
-      id: created.record.id,
-    });
-    expect(revoked).toMatchObject({
-      id: created.record.id,
-      revoked_at_ms: expect.any(Number),
-    });
-    expect(revoked).not.toHaveProperty("hash");
-  });
-
   it("authenticates before parsing Insights event bodies", async () => {
-    const database = createInMemoryDatabasePlugin();
-    await registerApiKey({
-      apiKeys: database.models.apiKeys,
-      apiKey: API_KEY,
-      name: "App",
-    });
-    const hotUpdater = createHotUpdater({
-      clientAccess: { type: "api-key" },
-      database,
-    });
+    const hotUpdater = await start();
     const invalidBody = {
       method: "POST",
       headers: { "content-type": "application/json" },
@@ -119,74 +79,14 @@ describe("createHotUpdater API keys", () => {
     ).toBe(400);
   });
 
-  it("returns 503 when credential storage is unavailable", async () => {
-    const database = createInMemoryDatabasePlugin();
-    vi.spyOn(database.models.apiKeys, "findByHash").mockRejectedValue(
-      new Error("database offline"),
-    );
+  it('keeps client routes public with clientAccess: "public"', async () => {
     const hotUpdater = createHotUpdater({
-      clientAccess: { type: "api-key" },
-      database,
-    });
-
-    const response = await hotUpdater.handlers.client(withApiKey(updateUrl));
-
-    expect(response.status).toBe(503);
-    await expect(response.json()).resolves.toEqual({
-      error: "Service unavailable",
-    });
-  });
-
-  it("keeps client routes public with the public access policy", async () => {
-    const hotUpdater = createHotUpdater({
-      clientAccess: { type: "public" },
-      database: createInMemoryDatabasePlugin(),
+      clientAccess: "public",
+      database: createRuntimeDatabase(),
     });
 
     expect(
       (await hotUpdater.handlers.client(new Request(updateUrl))).status,
     ).toBe(404);
   });
-
-  it("reads API keys only from the configured header", async () => {
-    const database = createInMemoryDatabasePlugin();
-    await registerApiKey({
-      apiKeys: database.models.apiKeys,
-      apiKey: API_KEY,
-      name: "App",
-    });
-    const hotUpdater = createHotUpdater({
-      clientAccess: {
-        headerName: "X-Hot-Updater-Key",
-        type: "api-key",
-      },
-      database,
-    });
-    const invalidBody = {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: "not-json",
-    } satisfies RequestInit;
-
-    expect(
-      (
-        await hotUpdater.handlers.client(
-          withApiKey("https://example.com/events", invalidBody),
-        )
-      ).status,
-    ).toBe(401);
-    expect(
-      (
-        await hotUpdater.handlers.client(
-          new Request("https://example.com/events", {
-            ...invalidBody,
-            headers: {
-              ...invalidBody.headers,
-              "x-hot-updater-key": API_KEY,
-            },
-          }),
-        )
-      ).status,
-    ).toBe(400);
-  });
 });

package/src/apiKeys.spec.ts

@@ -1,6 +1,6 @@
-import { describe, expect, it, vi } from "vitest";
+import { createMemoryAdapter } from "@hot-updater/plugin-core/internal";
+import { describe, expect, it } from "vitest";
 
-import { createInMemoryDatabasePlugin } from "../../test-utils/test/inMemoryDatabasePlugin";
 import {
   API_KEY_HEADER_NAME,
   authenticateApiKey,
@@ -11,6 +11,20 @@ import {
   provisionApiKey,
   registerApiKey,
 } from "./apiKeys";
+import { createDatabaseEngine } from "./database/database";
+import { resolveSchema } from "./database/resolveSchema";
+import { apiKeysSchema, createApiKeyModel } from "./plugins/api-keys";
+
+/** The api-keys plugin's table model on an empty in-memory database. */
+const createModel = () => {
+  const module = { id: "apiKeys", schema: apiKeysSchema } as const;
+  return createApiKeyModel(
+    createDatabaseEngine({
+      adapter: createMemoryAdapter(),
+      schema: resolveSchema([module]),
+    }).database(module),
+  );
+};
 
 const API_KEY = "AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQE";
 
@@ -21,18 +35,18 @@ describe("API keys", () => {
       "x-hot-updater-key",
     );
     expect(() => normalizeApiKeyHeaderName("")).toThrow(
-      "clientAccess.headerName must be a valid header name.",
+      "apiKeys({ headerName }) must name a valid header.",
     );
     expect(() => normalizeApiKeyHeaderName("invalid header")).toThrow(
-      "clientAccess.headerName must be a valid header name.",
+      "apiKeys({ headerName }) must name a valid header.",
     );
   });
 
   it("persists only the digest and metadata for a registered key", async () => {
-    const database = createInMemoryDatabasePlugin();
+    const model = createModel();
 
     const created = await registerApiKey({
-      apiKeys: database.models.apiKeys,
+      apiKeys: model,
       apiKey: API_KEY,
       createdAtMs: 100,
       name: " Production app ",
@@ -49,28 +63,25 @@ describe("API keys", () => {
     });
     expect(created.record).not.toHaveProperty("hash");
     expect(created.record.id).not.toContain(await hashApiKey(API_KEY));
-    expect(await database.models.apiKeys.list()).toEqual([
+    expect(await model.list()).toEqual([
       expect.objectContaining({ hash: await hashApiKey(API_KEY) }),
     ]);
-    expect(JSON.stringify(await database.models.apiKeys.list())).not.toContain(
-      API_KEY,
-    );
+    expect(JSON.stringify(await model.list())).not.toContain(API_KEY);
 
     const registeredAgain = await registerApiKey({
-      apiKeys: database.models.apiKeys,
+      apiKeys: model,
       apiKey: API_KEY,
       createdAtMs: 200,
       name: "Ignored replacement name",
     });
     expect(registeredAgain.record).toEqual(created.record);
-    expect(await database.models.apiKeys.list()).toHaveLength(1);
+    expect(await model.list()).toHaveLength(1);
   });
 
-  it("authenticates only active keys after the readiness check", async () => {
-    const database = createInMemoryDatabasePlugin();
-    const beforeLookup = vi.fn(async () => undefined);
+  it("authenticates only active keys", async () => {
+    const model = createModel();
     const { record } = await registerApiKey({
-      apiKeys: database.models.apiKeys,
+      apiKeys: model,
       apiKey: API_KEY,
       name: "App",
     });
@@ -80,30 +91,28 @@ describe("API keys", () => {
 
     await expect(
       authenticateApiKey({
-        apiKeys: database.models.apiKeys,
-        beforeLookup,
+        apiKeys: model,
         request,
       }),
     ).resolves.toBe(true);
-    expect(beforeLookup).toHaveBeenCalledOnce();
 
-    await database.models.apiKeys.revoke({
+    await model.revoke({
       id: record.id,
       revokedAtMs: Date.now(),
     });
     await expect(
       authenticateApiKey({
-        apiKeys: database.models.apiKeys,
+        apiKeys: model,
         request,
       }),
     ).resolves.toBe(false);
   });
 
   it("creates a canonical key and validates visible names", async () => {
-    const database = createInMemoryDatabasePlugin();
+    const model = createModel();
 
     const created = await createApiKey({
-      apiKeys: database.models.apiKeys,
+      apiKeys: model,
       name: "App",
     });
 
@@ -111,7 +120,7 @@ describe("API keys", () => {
     expect(created.record.prefix).toBe(created.apiKey.slice(0, 6));
     await expect(
       registerApiKey({
-        apiKeys: database.models.apiKeys,
+        apiKeys: model,
         apiKey: API_KEY,
         name: "   ",
       }),
@@ -119,29 +128,25 @@ describe("API keys", () => {
   });
 
   it("provisions a new key once and reuses an existing managed key", async () => {
-    const database = createInMemoryDatabasePlugin();
+    const model = createModel();
 
     const created = await provisionApiKey({
-      apiKeys: database.models.apiKeys,
+      apiKeys: model,
       name: "Managed init",
     });
     const reused = await provisionApiKey({
-      apiKeys: database.models.apiKeys,
+      apiKeys: model,
       existingApiKey: created.apiKey,
       name: "Managed init rerun",
     });
 
     expect(reused).toEqual(created);
-    expect(await database.models.apiKeys.list()).toHaveLength(1);
+    expect(await model.list()).toHaveLength(1);
   });
 
   it("manages keys without exposing stored hashes", async () => {
-    const database = createInMemoryDatabasePlugin();
-    const beforeOperation = vi.fn(async () => undefined);
-    const apiKeys = createApiKeyManagement({
-      apiKeys: database.models.apiKeys,
-      beforeOperation,
-    });
+    const model = createModel();
+    const apiKeys = createApiKeyManagement({ apiKeys: model });
 
     const created = await apiKeys.create({ name: "Production app" });
     expect(created.apiKey).toMatch(/^[A-Za-z0-9_-]{43}$/u);
@@ -157,6 +162,5 @@ describe("API keys", () => {
       revoked_at_ms: expect.any(Number),
     });
     expect(revoked).not.toHaveProperty("hash");
-    expect(beforeOperation).toHaveBeenCalledTimes(3);
   });
 });

package/src/apiKeys.ts

@@ -32,7 +32,7 @@ export const normalizeApiKeyHeaderName = (
   value: unknown = API_KEY_HEADER_NAME,
 ): string => {
   if (typeof value !== "string" || value.length === 0) {
-    throw new TypeError("clientAccess.headerName must be a valid header name.");
+    throw new TypeError("apiKeys({ headerName }) must name a valid header.");
   }
 
   try {
@@ -40,7 +40,7 @@ export const normalizeApiKeyHeaderName = (
     headers.set(value, "");
     return headers.keys().next().value!;
   } catch {
-    throw new TypeError("clientAccess.headerName must be a valid header name.");
+    throw new TypeError("apiKeys({ headerName }) must name a valid header.");
   }
 };
 
@@ -172,7 +172,6 @@ export const provisionApiKey = (input: {
 };
 
 export const authenticateApiKey = async (input: {
-  readonly beforeLookup?: () => Promise<void>;
   readonly apiKeys: ApiKeyModel;
   readonly headerName?: string;
   readonly request: Request;
@@ -182,7 +181,6 @@ export const authenticateApiKey = async (input: {
   );
   if (apiKey === null || !isApiKey(apiKey)) return false;
   const hash = await hashApiKey(apiKey);
-  await input.beforeLookup?.();
   const record = await input.apiKeys.findByHash(hash);
   return (
     record !== null &&
@@ -194,11 +192,9 @@ export const authenticateApiKey = async (input: {
 
 export const createApiKeyManagement = (input: {
   readonly apiKeys: ApiKeyModel;
-  readonly beforeOperation: () => Promise<void>;
 }): ApiKeyManagementAPI =>
   Object.freeze({
     async create({ name }: { readonly name: string }) {
-      await input.beforeOperation();
       const created = await createApiKey({ apiKeys: input.apiKeys, name });
       return Object.freeze({
         apiKey: created.apiKey,
@@ -206,11 +202,9 @@ export const createApiKeyManagement = (input: {
       });
     },
     async list() {
-      await input.beforeOperation();
       return Object.freeze((await input.apiKeys.list()).map(toApiKeyMetadata));
     },
     async revoke({ id }: { readonly id: string }) {
-      await input.beforeOperation();
       const record = await input.apiKeys.revoke({
         id,
         revokedAtMs: Date.now(),