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

package/src/testUtilsMutation.integration.spec.ts

@@ -1,216 +0,0 @@
-import { execFile } from "node:child_process";
-import {
-  mkdir,
-  mkdtemp,
-  readFile,
-  rm,
-  symlink,
-  writeFile,
-} from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { promisify } from "node:util";
-
-import { expect, it } from "vitest";
-
-const exec = promisify(execFile);
-const packageDirectory = path.resolve(import.meta.dirname, "..");
-
-// These are deliberately broken providers: a storage adapter, the Insights
-// model, or the served answers. Each must fail its behavioral scenario, not
-// merely fail to import or initialize the suite.
-const mutations = [
-  {
-    name: "ignore-lower-bound",
-    scenario: "pages all scoped Releases including disabled rows",
-    implementation:
-      "adapter.query = (table, request) => original.query(table, { ...request, lower: undefined });",
-  },
-  {
-    name: "ignore-upper-bound",
-    scenario: "pages each release filter set by key",
-    implementation:
-      "adapter.query = (table, request) => original.query(table, { ...request, upper: undefined });",
-  },
-  {
-    name: "reverse-order",
-    scenario: "pages Catalogs in scope order",
-    implementation:
-      'adapter.query = (table, request) => original.query(table, { ...request, order: request.order === "asc" ? "desc" : "asc" });',
-  },
-  {
-    name: "short-pages",
-    scenario:
-      "serves the newest Release among 200 distinct compatible version ranges",
-    implementation:
-      "adapter.query = (table, request) => original.query(table, { ...request, limit: Math.min(request.limit, 2) });",
-  },
-  {
-    name: "drop-deletes",
-    scenario: "hard deletes a Release, rebuilds its Catalog",
-    implementation:
-      'adapter.write = ops => original.write(ops.filter(op => op.type !== "delete"));',
-  },
-  {
-    name: "ignore-insights-cursor",
-    scenario: "uses exact identity and UTF-8 cursor order",
-    implementation:
-      'const model = insightsModel; insightsModel = database => { const m = model(database); return { ...m, findLatestEvents: input => m.findLatestEvents("userId" in input ? { ...input, afterInstallId: undefined } : input) }; };',
-  },
-  {
-    name: "oldest-ota-first",
-    scenario: "rolls a deleted active Release back to older OTA bytes",
-    implementation: "",
-    responseMutation: "if (body.releases) body.releases.reverse();",
-  },
-  {
-    name: "missing-rollback-candidates",
-    scenario:
-      "re-evaluates cohort changes and rolls back even when the predecessor rollout is closed",
-    implementation: "",
-    responseMutation: "if (body.rollbackReleases) body.rollbackReleases = [];",
-  },
-  {
-    name: "wrong-ota-artifact",
-    scenario: "runs built-in → OTA A → OTA B → rollback A → built-in",
-    implementation: "",
-    responseMutation:
-      'if (body.manifestFileHash) body.manifestFileHash = "wrong-manifest-hash";',
-  },
-] as const;
-
-it("rejects broken providers while the unmodified provider passes the public suite", async () => {
-  const directory = await mkdtemp(
-    path.join(os.tmpdir(), "hot-updater-contract-mutants-"),
-  );
-  try {
-    await mkdir(path.join(directory, "node_modules/@hot-updater"), {
-      recursive: true,
-    });
-    for (const name of ["server", "test-utils"]) {
-      await symlink(
-        path.resolve(packageDirectory, "..", name),
-        path.join(directory, "node_modules/@hot-updater", name),
-        "dir",
-      );
-    }
-    const variants = [
-      { name: "control", scenario: undefined, implementation: "" },
-      ...mutations,
-    ];
-    for (const variant of variants) {
-      await writeFile(
-        path.join(directory, `${variant.name}.spec.ts`),
-        `
-        import { createHotUpdater } from "@hot-updater/server";
-        import { createMemoryAdapter } from "@hot-updater/server/database";
-        import { createDatabasePluginApis } from "@hot-updater/server/db";
-        import { createInsightsModel, insights } from "@hot-updater/server/plugins/insights";
-        import { insightsTestSuite } from "@hot-updater/server/plugins/insights/testing";
-        import { setupDatabaseTestSuite, startHttpTestServer } from "@hot-updater/test-utils";
-        // An empty memory adapter per test, behind one adapter a mutant may break.
-        let original = createMemoryAdapter();
-        const adapter = {
-          id: "memory",
-          fits: ops => original.fits(ops),
-          get: (table, keys) => original.get(table, keys),
-          query: (table, request) => original.query(table, request),
-          write: ops => original.write(ops),
-        };
-        let insightsModel = database =>
-          createInsightsModel(createDatabasePluginApis(database, [insights()]).insights);
-        ${variant.implementation}
-        setupDatabaseTestSuite({
-          name: ${JSON.stringify(variant.name)},
-          createDatabase: () => ({ name: "memory", adapter }),
-          migrate: () => undefined,
-          reset: () => { original = createMemoryAdapter(); },
-          dispose: () => undefined,
-          plugins: [insightsTestSuite({ createModel: database => insightsModel(database) })],
-          createHttpClient: options => {
-            const handlers = createHotUpdater({
-              ...options, plugins: [insights()], clientAccess: "public",
-            }).handlers;
-            return startHttpTestServer({
-              ...handlers,
-              client: async request => {
-                const response = await handlers.client(request);
-                if (response.status !== 200) return response;
-                const body = await response.json();
-                ${"responseMutation" in variant ? variant.responseMutation : ""}
-                return new Response(JSON.stringify(body), {
-                  status: response.status, headers: response.headers,
-                });
-              },
-            });
-          },
-        });
-      `,
-      );
-    }
-    await writeFile(
-      path.join(directory, "vitest.config.mts"),
-      `export default ${JSON.stringify({
-        test: {
-          maxWorkers: 4,
-          projects: variants.map((variant) => ({
-            test: {
-              name: variant.name,
-              root: directory,
-              include: [`${variant.name}.spec.ts`],
-              testNamePattern: variant.scenario,
-              testTimeout: 20000,
-              hookTimeout: 20000,
-            },
-          })),
-        },
-      })};`,
-    );
-    const { code } = await exec(
-      process.execPath,
-      [
-        path.resolve(packageDirectory, "../../node_modules/vitest/vitest.mjs"),
-        "run",
-        "--config",
-        path.join(directory, "vitest.config.mts"),
-        "--reporter=json",
-        "--outputFile=results.json",
-      ],
-      { cwd: directory, timeout: 300000 },
-    ).then(
-      () => ({ code: 0 }),
-      (error: { code: number }) => ({ code: error.code }),
-    );
-    expect(code).toBe(1);
-    const result = JSON.parse(
-      await readFile(path.join(directory, "results.json"), "utf8"),
-    ) as {
-      testResults: {
-        name: string;
-        assertionResults: { title: string; status: string }[];
-      }[];
-    };
-    expect(result.testResults).toHaveLength(variants.length);
-    const control = result.testResults.find(
-      (test) => path.basename(test.name) === "control.spec.ts",
-    )!;
-    expect(control.assertionResults.length).toBeGreaterThan(0);
-    expect(
-      control.assertionResults.every((test) => test.status === "passed"),
-    ).toBe(true);
-    for (const mutation of mutations) {
-      const run = result.testResults.find(
-        (test) => path.basename(test.name) === `${mutation.name}.spec.ts`,
-      )!;
-      const detected = run.assertionResults.some(
-        (test) =>
-          test.status === "failed" && test.title.includes(mutation.scenario),
-      );
-      expect(detected, `${mutation.name} must fail: ${mutation.scenario}`).toBe(
-        true,
-      );
-    }
-  } finally {
-    await rm(directory, { recursive: true, force: true });
-  }
-}, 360000);

package/src/testUtilsPackage.integration.spec.ts

@@ -1,180 +0,0 @@
-import { execFile } from "node:child_process";
-import {
-  mkdir,
-  mkdtemp,
-  readFile,
-  readdir,
-  rm,
-  symlink,
-  writeFile,
-} from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { promisify } from "node:util";
-
-import { expect, it } from "vitest";
-
-import packageJson from "../package.json" with { type: "json" };
-
-const exec = promisify(execFile);
-const packageDirectory = path.resolve(import.meta.dirname, "..");
-
-it("runs the complete contract from the published test-utils package", async () => {
-  const directory = await mkdtemp(
-    path.join(os.tmpdir(), "hot-updater-provider-contract-"),
-  );
-  try {
-    await exec("pnpm", ["pack", "--pack-destination", directory], {
-      cwd: path.resolve(packageDirectory, "../test-utils"),
-    });
-    const archive = (await readdir(directory)).find((file) =>
-      file.endsWith(".tgz"),
-    )!;
-    const installed = path.join(
-      directory,
-      "node_modules/@hot-updater/test-utils",
-    );
-    await mkdir(installed, { recursive: true });
-    await exec("tar", [
-      "-xzf",
-      path.join(directory, archive),
-      "--strip-components=1",
-      "-C",
-      installed,
-    ]);
-
-    // The consumer uses the packed test-utils files and public dependencies only.
-    for (const dependency of [
-      ...Object.keys(packageJson.dependencies),
-      "vitest",
-      "execa",
-      "@hot-updater/server",
-      "@types/node",
-      "@electric-sql/pglite",
-      "kysely",
-      "kysely-pglite-dialect",
-    ]) {
-      const target = path.join(directory, "node_modules", dependency);
-      await mkdir(path.dirname(target), { recursive: true });
-      await symlink(
-        dependency === "@hot-updater/server"
-          ? packageDirectory
-          : dependency === "vitest"
-            ? path.resolve(packageDirectory, "../../node_modules/vitest")
-            : path.join(packageDirectory, "node_modules", dependency),
-        target,
-        "dir",
-      );
-    }
-    await writeFile(
-      path.join(directory, "package.json"),
-      JSON.stringify({ type: "module" }),
-    );
-    await writeFile(
-      path.join(directory, "vitest.config.ts"),
-      `
-      import { defineConfig } from "vitest/config";
-      export default defineConfig({ test: { testTimeout: 20000, hookTimeout: 20000 } });
-    `,
-    );
-    await writeFile(
-      path.join(directory, "provider.spec.ts"),
-      `
-      import { PGlite } from "@electric-sql/pglite";
-      import { Kysely } from "kysely";
-      import { PGliteDialect } from "kysely-pglite-dialect";
-      import { createHotUpdater } from "@hot-updater/server";
-      import { kyselyAdapter } from "@hot-updater/server/adapters/kysely";
-      import { createDatabasePluginApis, createMigrator } from "@hot-updater/server/db";
-      import { createInsightsModel, insights } from "@hot-updater/server/plugins/insights";
-      import { insightsTestSuite } from "@hot-updater/server/plugins/insights/testing";
-      import { setupDatabaseTestSuite, startHttpTestServer } from "@hot-updater/test-utils";
-
-      const db = new PGlite();
-      const kysely = new Kysely({ dialect: new PGliteDialect(db) });
-      const database = kyselyAdapter({ db: kysely, provider: "postgresql" });
-      setupDatabaseTestSuite({
-        name: "external provider",
-        createHttpClient: (options) => startHttpTestServer(createHotUpdater({
-          ...options, plugins: [insights()], clientAccess: "public",
-        }).handlers),
-        plugins: [insightsTestSuite({
-          createModel: (database) =>
-            createInsightsModel(createDatabasePluginApis(database, [insights()]).insights),
-        })],
-        createDatabase: () => database,
-        // Core's tables and those of the plugins the server runs.
-        migrate: async () => {
-          const migration = await createMigrator(createHotUpdater({
-            database, plugins: [insights()], clientAccess: "public",
-          })).migrateToLatest({ mode: "from-schema", updateSettings: true });
-          await migration.execute();
-        },
-        reset: async () => {
-          const { rows } = await db.query<{ tablename: string }>(
-            "select tablename from pg_tables where schemaname = 'public' and tablename <> 'private_hot_updater_settings'",
-          );
-          await db.exec('TRUNCATE ' + rows.map(({ tablename }) => '"' + tablename + '"').join(', ') + ' CASCADE');
-        },
-        dispose: async () => { await kysely.destroy(); await db.close(); },
-      });
-    `,
-    );
-
-    // Importing production and fixture entries must work outside a Vitest run.
-    await exec(
-      process.execPath,
-      [
-        "--input-type=module",
-        "--eval",
-        `
-      import { createHotUpdater } from "@hot-updater/server";
-      import { createReleaseCatalogTestStorage } from "@hot-updater/test-utils/node";
-      if (typeof createHotUpdater !== "function" || createReleaseCatalogTestStorage().protocol !== "storage") process.exit(1);
-    `,
-      ],
-      { cwd: directory },
-    );
-
-    await exec(
-      process.execPath,
-      [
-        path.join(directory, "node_modules/vitest/vitest.mjs"),
-        "run",
-        "--reporter=json",
-        "--outputFile=results.json",
-      ],
-      { cwd: directory, timeout: 120000 },
-    );
-    const result = JSON.parse(
-      await readFile(path.join(directory, "results.json"), "utf8"),
-    );
-    expect(result.success).toBe(true);
-    expect(result.numTotalTests).toBeGreaterThan(0);
-    expect(result.numPassedTests).toBe(result.numTotalTests);
-    expect(result.numPendingTests).toBe(0);
-
-    await exec(
-      process.execPath,
-      [
-        path.resolve(
-          packageDirectory,
-          "../../node_modules/typescript/bin/tsc6",
-        ),
-        "--noEmit",
-        "--module",
-        "NodeNext",
-        "--moduleResolution",
-        "NodeNext",
-        "--target",
-        "ES2022",
-        "--strict",
-        "--skipLibCheck",
-        "provider.spec.ts",
-      ],
-      { cwd: directory },
-    );
-  } finally {
-    await rm(directory, { recursive: true, force: true });
-  }
-}, 180000);

package/src/types/index.ts

@@ -1,2 +0,0 @@
-export type { Bundle } from "@hot-updater/core";
-export type { HotUpdaterAPI } from "../createHotUpdaterCore";

package/src/version.ts

@@ -1,3 +0,0 @@
-import pkg from "../package.json" with { type: "json" };
-
-export const HOT_UPDATER_SERVER_VERSION = pkg.version;