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

package/src/database/schema.types.spec.ts

@@ -1,94 +0,0 @@
-import { describe, expectTypeOf, it } from "vitest";
-
-import {
-  type CheckIndex,
-  defineAggregate,
-  defineTable,
-  type RowOf,
-} from "./schema";
-
-const fields = {
-  id: { type: "string", maxLength: 36 },
-  size: { type: "integer" },
-  note: { type: "string", required: false },
-  meta: { type: "json" },
-} as const;
-
-describe("schema DSL types", () => {
-  it("types a row from its fields, optional fields as nullable", () => {
-    expectTypeOf<RowOf<typeof fields>>().toEqualTypeOf<{
-      id: string;
-      size: number;
-      note: string | null;
-      meta: import("@hot-updater/plugin-core/internal").DatabaseJson;
-    }>();
-  });
-
-  it("types derived compute over the declared row", () => {
-    defineTable(fields, {
-      key: ["id"],
-      derived: {
-        bucket: {
-          type: "integer",
-          compute: (row) => {
-            expectTypeOf(row.size).toEqualTypeOf<number>();
-            expectTypeOf(row.note).toEqualTypeOf<string | null>();
-            return row.size - (row.size % 10);
-          },
-        },
-        words: {
-          type: "string",
-          multi: true,
-          compute: (row) => row.note?.split(" ") ?? null,
-        },
-      },
-      indexes: { byBucket: { eq: ["bucket"], sort: ["size"] } },
-    });
-
-    defineTable(fields, {
-      key: ["id"],
-      derived: {
-        // @ts-expect-error An integer field cannot compute a string.
-        bucket: { type: "integer", compute: (row) => row.id },
-      },
-    });
-  });
-
-  it("rejects an undeclared key or index field and names it", () => {
-    // @ts-expect-error "missing" is not a declared field.
-    defineTable(fields, { key: ["missing"] });
-
-    defineTable(fields, {
-      key: ["id"],
-      indexes: {
-        // @ts-expect-error The index names an undeclared field.
-        byMissing: { eq: ["missing"], sort: ["size"] },
-      },
-    });
-
-    expectTypeOf<
-      CheckIndex<
-        "byMissing",
-        { eq: ["missing"]; sort: ["size"] },
-        "id" | "size"
-      >
-    >().toEqualTypeOf<'Index "byMissing" names undeclared field "missing"'>();
-    expectTypeOf<
-      CheckIndex<"bySize", { eq: []; sort: ["size"] }, "id" | "size">
-    >().toEqualTypeOf<{ eq: []; sort: ["size"] }>();
-  });
-
-  it("keys aggregates by identity fields only", () => {
-    const totals = defineAggregate(
-      { platform_key: { type: "string", maxLength: 16 } },
-      { key: ["platform_key"], counters: ["bundles"] },
-    );
-    expectTypeOf(totals.counters).toEqualTypeOf<readonly "bundles"[]>();
-
-    defineAggregate(
-      { platform_key: { type: "string" } },
-      // @ts-expect-error A metric is not an identity field.
-      { key: ["bundles"], counters: ["bundles"] },
-    );
-  });
-});

package/src/database/sql/docker-compose.yml

@@ -1,36 +0,0 @@
-# Pooled PostgreSQL and MySQL for the SQL core's integration conformance run.
-services:
-  postgres:
-    image: postgres:17-alpine
-    environment:
-      POSTGRES_PASSWORD: hot_updater
-      POSTGRES_DB: hot_updater
-      POSTGRES_INITDB_ARGS: --encoding=UTF8
-    ports:
-      - "55432:5432"
-    healthcheck:
-      test: ["CMD-SHELL", "pg_isready -U postgres -d hot_updater"]
-      interval: 2s
-      timeout: 5s
-      retries: 30
-  mysql:
-    image: mysql:8.0
-    environment:
-      MYSQL_ROOT_PASSWORD: hot_updater
-      MYSQL_DATABASE: hot_updater
-    ports:
-      - "53306:3306"
-    healthcheck:
-      test:
-        [
-          "CMD",
-          "mysqladmin",
-          "ping",
-          "-h",
-          "127.0.0.1",
-          "-uroot",
-          "-phot_updater",
-        ]
-      interval: 2s
-      timeout: 5s
-      retries: 60

package/src/database/sql/sqlAdapter.integration.spec.ts

@@ -1,145 +0,0 @@
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-
-import { setupDatabaseAdapterConformanceSuite } from "@hot-updater/test-utils";
-import { assertDockerComposeAvailable } from "@hot-updater/test-utils/node";
-import { execa } from "execa";
-import mysql from "mysql2/promise";
-import pg from "pg";
-import { afterAll, beforeAll, describe, expect, it } from "vitest";
-
-import { createBundleFixture } from "../../../../test-utils/src/databaseTestFixtures";
-import { createInProcessCoreApi } from "../../core/api";
-import { createEngineDatabase, migrateCoreSchema } from "../../db/coreDatabase";
-import {
-  createSqlAdapter,
-  type SqlExecutor,
-  WRITE_GUARD_TABLE,
-} from "./sqlAdapter";
-import { mysqlExecutor, pgBatchExecutor, pgExecutor } from "./sqlTestExecutors";
-
-assertDockerComposeAvailable(
-  "SQL core integration tests need Docker Compose and a running Docker daemon.",
-);
-
-const compose = [
-  "compose",
-  "-f",
-  path.join(path.dirname(fileURLToPath(import.meta.url)), "docker-compose.yml"),
-  "-p",
-  "hot-updater-sql-core",
-];
-
-/** Retries `connect` until the server accepts connections. */
-const ready = async (connect: () => Promise<unknown>) => {
-  for (let attempt = 0; ; attempt += 1) {
-    try {
-      await connect();
-      return;
-    } catch (error) {
-      if (attempt > 60) throw error;
-      await new Promise((resolve) => setTimeout(resolve, 1000));
-    }
-  }
-};
-
-let postgres: pg.Pool;
-let mariadb: mysql.Pool;
-
-beforeAll(async () => {
-  await execa("docker", [...compose, "up", "-d", "--wait"]);
-  postgres = new pg.Pool({
-    connectionString:
-      "postgres://postgres:hot_updater@127.0.0.1:55432/hot_updater",
-    max: 16,
-  });
-  mariadb = mysql.createPool({
-    uri: "mysql://root:hot_updater@127.0.0.1:53306/hot_updater",
-    connectionLimit: 16,
-  });
-  await ready(() => postgres.query("SELECT 1"));
-  await ready(() => mariadb.query("SELECT 1"));
-}, 180_000);
-
-afterAll(async () => {
-  await postgres?.end();
-  await mariadb?.end();
-  await execa("docker", [...compose, "down", "-v"]);
-}, 60_000);
-
-let tests = 0;
-const suite = (name: string, executor: () => SqlExecutor) =>
-  setupDatabaseAdapterConformanceSuite({
-    name,
-    maxOps: 50,
-    createAdapter: async ({ tables }) => {
-      tests += 1;
-      const adapter = createSqlAdapter({
-        executor: executor(),
-        tablePrefix: `t${tests}_`,
-        maxOps: 50,
-      });
-      await adapter.migrations?.apply(tables);
-      return { adapter };
-    },
-  });
-
-suite("sql (pooled PostgreSQL)", () => pgExecutor(postgres));
-suite("sql (pooled MySQL)", () => mysqlExecutor(mariadb));
-
-/** Batch writes under READ COMMITTED: guards lock the rows they read until the batch commits. */
-setupDatabaseAdapterConformanceSuite({
-  name: "sql batch (pooled PostgreSQL)",
-  maxOps: 50,
-  createAdapter: async ({ tables }) => {
-    tests += 1;
-    const adapter = createSqlAdapter({
-      executor: pgBatchExecutor(postgres),
-      tablePrefix: `b${tests}_`,
-      maxOps: 50,
-    });
-    await adapter.migrations?.apply([...tables, WRITE_GUARD_TABLE]);
-    return { adapter };
-  },
-});
-
-/** The whole schema the façade spans, migrated and fenced on each server. */
-describe.each([
-  ["PostgreSQL", () => pgExecutor(postgres)],
-  ["MySQL", () => mysqlExecutor(mariadb)],
-] as const)("core's schema on pooled %s", (name, executor) => {
-  it("migrates, passes the fence, and deploys into the longest scope key", async () => {
-    tests += 1;
-    const adapter = createSqlAdapter({
-      executor: executor(),
-      tablePrefix: `f${tests}_`,
-    });
-    await migrateCoreSchema(adapter, name);
-    await migrateCoreSchema(adapter, name);
-    const core = createInProcessCoreApi(
-      createEngineDatabase({ name, adapter }).adapter,
-    );
-    // The longest channel name and fingerprint make the longest scope key.
-    const [result] = await core.deploy([
-      {
-        bundle: createBundleFixture("901"),
-        release: {
-          channel: "x".repeat(255),
-          enabled: true,
-          fingerprintHash: "f".repeat(255),
-          message: null,
-          shouldForceUpdate: false,
-          targetAppVersion: null,
-        },
-      },
-    ]);
-    const release = result!.release!;
-    expect(release.scope_key.length).toBeGreaterThan(600);
-    await expect(
-      core.listReleases({
-        limit: 10,
-        filter: { kind: "scope", scopeKey: release.scope_key },
-      }),
-    ).resolves.toEqual([release]);
-  });
-});

package/src/database/sql/sqlAdapter.readBudgets.integration.spec.ts

@@ -1,123 +0,0 @@
-import path from "node:path";
-
-import {
-  mysqlRowsExamined,
-  postgresRowsExamined,
-  setupReadBudgetTestSuite,
-} from "@hot-updater/test-utils";
-import { assertDockerComposeAvailable } from "@hot-updater/test-utils/node";
-import { execa } from "execa";
-import mysql from "mysql2/promise";
-import pg from "pg";
-import { afterAll, beforeAll } from "vitest";
-
-import { readBudgetServer } from "../../readBudgets.testFixtures";
-import { createSqlAdapter } from "./sqlAdapter";
-import { mysqlExecutor, pgExecutor } from "./sqlTestExecutors";
-
-assertDockerComposeAvailable(
-  "SQL core read-budget tests need Docker Compose and a running Docker daemon.",
-);
-
-const compose = [
-  "compose",
-  "-f",
-  path.join(import.meta.dirname, "docker-compose.yml"),
-  "-p",
-  "hot-updater-sql-core",
-];
-
-/** Retries `connect` until the server accepts connections. */
-const ready = async (connect: () => Promise<unknown>) => {
-  for (let attempt = 0; ; attempt += 1) {
-    try {
-      await connect();
-      return;
-    } catch (error) {
-      if (attempt > 60) throw error;
-      await new Promise((resolve) => setTimeout(resolve, 1000));
-    }
-  }
-};
-
-const MYSQL_URI = "mysql://root:hot_updater@127.0.0.1:53306/hot_updater";
-
-let postgres: pg.Pool;
-let mariadb: mysql.Pool;
-
-beforeAll(async () => {
-  await execa("docker", [...compose, "up", "-d", "--wait"]);
-  postgres = new pg.Pool({
-    connectionString:
-      "postgres://postgres:hot_updater@127.0.0.1:55432/hot_updater",
-    max: 16,
-  });
-  await ready(() => postgres.query("SELECT 1"));
-  // Each row a plan evaluates costs as much as an index entry it reads, as
-  // PostgreSQL's planner settings make it, so a small table plans like a
-  // production-sized one: an index range rather than a primary-key prefix
-  // filtered down to it. Sessions opened after the flush use the new cost.
-  await ready(async () => {
-    const admin = await mysql.createConnection(MYSQL_URI);
-    try {
-      await admin.query(
-        "UPDATE mysql.server_cost SET cost_value = 1 WHERE cost_name = 'row_evaluate_cost'",
-      );
-      await admin.query("FLUSH OPTIMIZER_COSTS");
-    } finally {
-      await admin.end();
-    }
-  });
-  mariadb = mysql.createPool({ uri: MYSQL_URI, connectionLimit: 16 });
-  await ready(() => mariadb.query("SELECT 1"));
-}, 180_000);
-
-afterAll(async () => {
-  await postgres?.end();
-  await mariadb?.end();
-  await execa("docker", [...compose, "down", "-v"]);
-}, 60_000);
-
-/** The SQL core over a pool; reads are explained on one connection of it. */
-setupReadBudgetTestSuite({
-  name: "sql (pooled PostgreSQL)",
-  server: readBudgetServer,
-  createAdapter: async ({ tables }) => {
-    const session = await postgres.connect();
-    const reads = postgresRowsExamined(
-      async (sql, params) => (await session.query(sql, [...params])).rows,
-    );
-    const adapter = createSqlAdapter({
-      executor: reads.wrap(pgExecutor(postgres)),
-      tablePrefix: "budget_",
-    });
-    await adapter.migrations!.apply(tables);
-    return {
-      adapter,
-      examined: reads.examined,
-      cleanup: async () => session.release(),
-    };
-  },
-});
-
-setupReadBudgetTestSuite({
-  name: "sql (pooled MySQL)",
-  server: readBudgetServer,
-  createAdapter: async ({ tables }) => {
-    const session = await mariadb.getConnection();
-    const reads = mysqlRowsExamined(
-      async (sql, params) =>
-        (await session.query(sql, [...params]))[0] as Record<string, unknown>[],
-    );
-    const adapter = createSqlAdapter({
-      executor: reads.wrap(mysqlExecutor(mariadb)),
-      tablePrefix: "budget_",
-    });
-    await adapter.migrations!.apply(tables);
-    return {
-      adapter,
-      examined: reads.examined,
-      cleanup: async () => session.release(),
-    };
-  },
-});