@podosoft/podokit 1.1.6 → 1.3.0

package/dist/templates/fullstack/apps/api/src/core/services.ts

@@ -6,7 +6,7 @@ import {
 } from "@podosoft/podokit-runtime";
 import type { AppEnv } from "../config/env.validation";
 import { Database } from "../database/database";
-import { ReadinessService } from "../health/readiness.service";
+import { DATABASE_READINESS_CHECK, ReadinessService } from "../health/readiness.service";
 
 export type { ServiceKey } from "@podosoft/podokit-runtime";
 
@@ -124,6 +124,9 @@ export class RequestGuardRegistry {
 
 export interface RequestIdentity {
   userId(request: Request): Promise<string | undefined>;
+  isAdmin(request: Request): Promise<boolean>;
+  roles(request: Request): Promise<string[]>;
+  activeOrganizationId(request: Request): Promise<string | undefined>;
 }
 
 export interface OpenApiContribution {
@@ -177,7 +180,14 @@ export interface PodokitModule {
 export function createCoreServices(env: AppEnv): ServiceRegistry {
   const services = new ServiceRegistry();
   const database = new Database(env);
-  const readiness = new ReadinessService();
+  const readiness = new ReadinessService({
+    timeoutMs: env.READINESS_CHECK_TIMEOUT_MS,
+    cacheMs: env.READINESS_CACHE_MS,
+    // Resolved on use: a module such as logging may replace the logger after this point.
+    onCheckFailure: (check, reason) => {
+      services.resolve(LOGGER).warn({ check, reason }, "Readiness check failed");
+    },
+  });
   const logger = pino({ level: process.env.LOG_LEVEL ?? "info" });
   const accessPolicy = new AccessPolicy();
   const requestGuards = new RequestGuardRegistry();
@@ -191,10 +201,16 @@ export function createCoreServices(env: AppEnv): ServiceRegistry {
   services.register(DATABASE, database, () => database.close());
   services.onStart(() => database.connect());
   services.register(READINESS, readiness);
+  readiness.register(DATABASE_READINESS_CHECK, () => services.resolve(DATABASE).ping());
   services.register(LOGGER, logger);
   services.register(ACCESS_POLICY, accessPolicy);
   services.register(REQUEST_GUARDS, requestGuards);
-  services.register(REQUEST_IDENTITY, { userId: async () => undefined });
+  services.register(REQUEST_IDENTITY, {
+    userId: async () => undefined,
+    isAdmin: async () => false,
+    roles: async () => [],
+    activeOrganizationId: async () => undefined,
+  });
   services.register(OPENAPI, openapiRegistry);
   return services;
 }

package/dist/templates/fullstack/apps/api/src/database/data-source.spec.ts

@@ -0,0 +1,15 @@
+import { describe, expect, it } from "bun:test";
+import type { DatabaseProviderName } from "@podosoft/podokit-runtime";
+import { PROVIDERS } from "../config/providers";
+
+function databaseProvider(): DatabaseProviderName {
+  return PROVIDERS.database;
+}
+
+// SQLite applications migrate with the Bun SQLite migrator, not this TypeORM source.
+describe.skipIf(databaseProvider() !== "postgres")("migration data source", () => {
+  it("runs each migration in its own transaction so one can build indexes concurrently", async () => {
+    const { dataSourceOptions } = await import("./data-source.js");
+    expect(dataSourceOptions.migrationsTransactionMode).toBe("each");
+  });
+});

package/dist/templates/fullstack/apps/api/src/database/data-source.ts

@@ -15,6 +15,9 @@ const migrations = existsSync(compiledMigrations)
 const commonOptions = {
   entities: [],
   migrations,
+  // One transaction per migration, so a migration can set `transaction = false`
+  // for statements such as CREATE INDEX CONCURRENTLY.
+  migrationsTransactionMode: "each" as const,
   synchronize: false,
 };
 

package/dist/templates/fullstack/apps/api/src/database/database.spec.ts

@@ -1,13 +1,20 @@
+import { SQL } from "bun";
 import { describe, expect, it } from "bun:test";
 import { existsSync, mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
-import type { AppEnv } from "../config/env.validation";
+import { validateEnv } from "../config/env.validation";
 import { PROVIDERS } from "../config/providers";
-import { databaseUrl, sqliteDatabasePath } from "./database";
+import {
+  Database,
+  databaseUrl,
+  isDatabaseUnavailable,
+  postgresPoolOptions,
+  sqliteDatabasePath,
+} from "./database";
 import type { DatabaseProviderName } from "@podosoft/podokit-runtime";
 
-const env: AppEnv = {
+const env = validateEnv({
   NODE_ENV: "test",
   PORT: 5002,
   POSTGRES_HOST: "localhost",
@@ -15,12 +22,44 @@ const env: AppEnv = {
   POSTGRES_USER: "podokit",
   POSTGRES_PASSWORD: "podokit",
   POSTGRES_DB: "podokit",
-};
+});
 
 function databaseProvider(): DatabaseProviderName {
   return PROVIDERS.database;
 }
 
+interface ProbedSql {
+  sql: SQL;
+  probes: () => number;
+  setAvailable: (available: boolean) => void;
+  close: () => Promise<void>;
+}
+
+// Counts `SELECT 1` probes against an in-memory database and can simulate an outage.
+function probedSql(): ProbedSql {
+  const target = new SQL(":memory:", { adapter: "sqlite" });
+  let probes = 0;
+  let available = true;
+  const sql = new Proxy(target, {
+    apply(query, thisArg: unknown, args: unknown[]): unknown {
+      const [strings] = args;
+      if (Array.isArray(strings) && strings.join("").trim() === "SELECT 1") {
+        probes += 1;
+        if (!available) return Promise.reject(new Error("database unavailable"));
+      }
+      return Reflect.apply(query, thisArg, args);
+    },
+  });
+  return {
+    sql,
+    probes: () => probes,
+    setAvailable: (value) => {
+      available = value;
+    },
+    close: () => target.close(),
+  };
+}
+
 describe("database provider", () => {
   it("uses DATABASE_URL as the canonical connection setting", () => {
     const provider = databaseProvider();
@@ -56,3 +95,109 @@ describe("database provider", () => {
     }
   });
 });
+
+describe("Database ping", () => {
+  it("queries the database on every ping", async () => {
+    const probe = probedSql();
+    const database = new Database(env, probe.sql);
+    try {
+      await database.ping();
+      const afterFirstPing = probe.probes();
+      await database.ping();
+      await database.ping();
+      expect(probe.probes()).toBe(afterFirstPing + 2);
+    } finally {
+      await probe.close();
+    }
+  });
+
+  it("reports an outage that starts after a successful connect", async () => {
+    const probe = probedSql();
+    const database = new Database(env, probe.sql);
+    try {
+      await database.connect();
+      probe.setAvailable(false);
+      await expect(database.ping()).rejects.toThrow("database unavailable");
+      probe.setAvailable(true);
+      await expect(database.ping()).resolves.toBeUndefined();
+    } finally {
+      await probe.close();
+    }
+  });
+
+  it("retries the connection after a failed attempt", async () => {
+    const probe = probedSql();
+    const database = new Database(env, probe.sql);
+    try {
+      probe.setAvailable(false);
+      await expect(database.connect()).rejects.toThrow("database unavailable");
+      probe.setAvailable(true);
+      await expect(database.ping()).resolves.toBeUndefined();
+      await expect(database.connect()).resolves.toBeUndefined();
+    } finally {
+      await probe.close();
+    }
+  });
+});
+
+describe("PostgreSQL pool settings", () => {
+  it("bounds connections and converts the millisecond settings to Bun seconds", () => {
+    expect(postgresPoolOptions(env)).toEqual({ max: 20, connectionTimeout: 10, idleTimeout: 30 });
+    expect(env.DB_AUTH_POOL_MAX).toBe(10);
+    expect(
+      postgresPoolOptions(validateEnv({ DB_POOL_MAX: "5", DB_CONNECT_TIMEOUT_MS: "2500", DB_IDLE_TIMEOUT_MS: "0" })),
+    ).toEqual({ max: 5, connectionTimeout: 2.5, idleTimeout: 0 });
+  });
+
+  it("rejects pool settings that would disable the limits", () => {
+    expect(() => validateEnv({ DB_POOL_MAX: "0" })).toThrow("DB_POOL_MAX");
+    expect(() => validateEnv({ DB_AUTH_POOL_MAX: "-1" })).toThrow("DB_AUTH_POOL_MAX");
+    expect(() => validateEnv({ DB_CONNECT_TIMEOUT_MS: "0" })).toThrow("DB_CONNECT_TIMEOUT_MS");
+  });
+});
+
+describe("isDatabaseUnavailable", () => {
+  it("recognizes Bun SQL connection failures", () => {
+    for (const code of [
+      "ERR_POSTGRES_CONNECTION_TIMEOUT",
+      "ERR_POSTGRES_CONNECTION_REFUSED",
+      "ERR_POSTGRES_CONNECTION_FAILED",
+      "ERR_POSTGRES_CONNECTION_CLOSED",
+    ]) {
+      expect(isDatabaseUnavailable(new SQL.PostgresError("Connection failed", { code }))).toBe(true);
+    }
+  });
+
+  it("recognizes pg pool and connection timeouts, also when wrapped", () => {
+    const acquire = new Error("timeout exceeded when trying to connect");
+    const connect = new Error("Connection terminated due to connection timeout");
+    expect(isDatabaseUnavailable(acquire)).toBe(true);
+    expect(isDatabaseUnavailable(connect)).toBe(true);
+    expect(isDatabaseUnavailable(new Error("Failed to get session", { cause: acquire }))).toBe(true);
+  });
+
+  it("leaves query and application errors alone", () => {
+    expect(isDatabaseUnavailable(new SQL.PostgresError("syntax error", { code: "ERR_POSTGRES_SYNTAX_ERROR" })))
+      .toBe(false);
+    expect(
+      isDatabaseUnavailable(new SQL.PostgresError("duplicate key", { code: "ERR_POSTGRES_SERVER_ERROR", errno: "23505" })),
+    ).toBe(false);
+    expect(isDatabaseUnavailable(new Error("timeout"))).toBe(false);
+    expect(isDatabaseUnavailable("ERR_POSTGRES_CONNECTION_TIMEOUT")).toBe(false);
+    expect(isDatabaseUnavailable(undefined)).toBe(false);
+  });
+
+  it("recognizes a real Bun SQL connection timeout", async () => {
+    // Accepts the TCP connection and never answers, like an overloaded server.
+    const server = Bun.listen({ hostname: "127.0.0.1", port: 0, socket: { data() {} } });
+    const sql = new SQL(`postgres://podokit:podokit@127.0.0.1:${server.port}/podokit`, { connectionTimeout: 0.2 });
+    try {
+      const error: unknown = await sql`SELECT 1`.then(() => undefined, (reason: unknown) => reason);
+      expect(error).toBeInstanceOf(SQL.PostgresError);
+      expect(isDatabaseUnavailable(error)).toBe(true);
+    } finally {
+      await sql.close();
+      server.stop(true);
+    }
+  });
+});

package/dist/templates/fullstack/apps/api/src/database/database.ts

@@ -47,35 +47,88 @@ export function sqliteDatabasePath(url: string): string {
   return path;
 }
 
+export interface PostgresPoolOptions {
+  max: number;
+  connectionTimeout: number;
+  idleTimeout: number;
+}
+
+/** Bun SQL takes these timeouts in seconds; the environment sets milliseconds. */
+export function postgresPoolOptions(env: AppEnv): PostgresPoolOptions {
+  return {
+    max: env.DB_POOL_MAX,
+    connectionTimeout: env.DB_CONNECT_TIMEOUT_MS / 1000,
+    idleTimeout: env.DB_IDLE_TIMEOUT_MS / 1000,
+  };
+}
+
+// Bun SQL and pg report a database that cannot be reached, or a connection that
+// could not be opened or taken from a full pool in time, with these shapes.
+const UNAVAILABLE_SQL_CODES = new Set([
+  "ERR_POSTGRES_CONNECTION_TIMEOUT",
+  "ERR_POSTGRES_CONNECTION_REFUSED",
+  "ERR_POSTGRES_CONNECTION_FAILED",
+  "ERR_POSTGRES_CONNECTION_CLOSED",
+]);
+const UNAVAILABLE_PG_MESSAGES = new Set([
+  "timeout exceeded when trying to connect",
+  "Connection terminated due to connection timeout",
+]);
+
+/** Whether an error, or one it wraps, means the database is unavailable rather than the request being wrong. */
+export function isDatabaseUnavailable(error: unknown): boolean {
+  let current: unknown = error;
+  for (let depth = 0; depth < 5 && current instanceof Error; depth += 1) {
+    if (current instanceof SQL.PostgresError && UNAVAILABLE_SQL_CODES.has(current.code)) return true;
+    if (UNAVAILABLE_PG_MESSAGES.has(current.message)) return true;
+    current = current.cause;
+  }
+  return false;
+}
+
+function createSql(provider: DatabaseProviderName, env: AppEnv): SQL {
+  const url = databaseUrl(env);
+  return provider === "sqlite"
+    ? new SQL(url, { adapter: "sqlite", create: true, readwrite: true, strict: true })
+    : new SQL(url, postgresPoolOptions(env));
+}
+
 export class Database {
   readonly provider: DatabaseProviderName = selectedDatabaseProvider();
   readonly sql: SQL;
   private ready?: Promise<void>;
 
-  constructor(env: AppEnv) {
-    const url = databaseUrl(env);
-    this.sql = this.provider === "sqlite"
-      ? new SQL(url, { adapter: "sqlite", create: true, readwrite: true, strict: true })
-      : new SQL(url, { max: 20 });
+  constructor(env: AppEnv, sql?: SQL) {
+    this.sql = sql ?? createSql(this.provider, env);
   }
 
   connect(): Promise<void> {
-    this.ready ??= (async () => {
-      if (this.provider === "sqlite") {
-        await this.sql`PRAGMA journal_mode = WAL`;
-        await this.sql`PRAGMA foreign_keys = ON`;
-        await this.sql`PRAGMA busy_timeout = 5000`;
-      }
-      await this.sql`SELECT 1`;
-    })();
+    if (!this.ready) {
+      const attempt = this.initialize();
+      this.ready = attempt;
+      // Forget a failed start so the next call retries instead of replaying the failure.
+      void attempt.catch(() => {
+        if (this.ready === attempt) this.ready = undefined;
+      });
+    }
     return this.ready;
   }
 
   async ping(): Promise<void> {
     await this.connect();
+    await this.sql`SELECT 1`;
   }
 
   async close(): Promise<void> {
     await this.sql.close();
   }
+
+  private async initialize(): Promise<void> {
+    if (this.provider === "sqlite") {
+      await this.sql`PRAGMA journal_mode = WAL`;
+      await this.sql`PRAGMA foreign_keys = ON`;
+      await this.sql`PRAGMA busy_timeout = 5000`;
+    }
+    await this.sql`SELECT 1`;
+  }
 }

package/dist/templates/fullstack/apps/api/src/database/migrate.ts

@@ -25,7 +25,7 @@ async function migrate(): Promise<void> {
   await dataSource.initialize();
   try {
     if (process.argv.includes("--revert")) await dataSource.undoLastMigration({ transaction: "all" });
-    else await dataSource.runMigrations({ transaction: "all" });
+    else await dataSource.runMigrations();
   } finally {
     await dataSource.destroy();
   }

package/dist/templates/fullstack/apps/api/src/health/health.plugin.spec.ts

@@ -0,0 +1,86 @@
+import { SQL } from "bun";
+import { afterEach, describe, expect, it } from "bun:test";
+import type { DatabaseProviderName } from "@podosoft/podokit-runtime";
+import { Elysia } from "elysia";
+import { AppException } from "../common/app-exception";
+import { validateEnv } from "../config/env.validation";
+import { PROVIDERS } from "../config/providers";
+import {
+  appContext,
+  createCoreServices,
+  DATABASE,
+  READINESS,
+  type ServiceRegistry,
+} from "../core/services";
+import { Database } from "../database/database";
+import type { ReadinessCheck } from "./readiness.service";
+import { healthPlugin } from "./health.plugin";
+
+const opened: ServiceRegistry[] = [];
+
+function databaseProvider(): DatabaseProviderName {
+  return PROVIDERS.database;
+}
+
+afterEach(async () => {
+  for (const services of opened.splice(0)) await services.close();
+});
+
+async function readiness(
+  options: { databaseUp: boolean; checks?: Record<string, ReadinessCheck> },
+): Promise<{ status: number; body: unknown }> {
+  const env = validateEnv({
+    NODE_ENV: "test",
+    DATABASE_URL: databaseProvider() === "sqlite"
+      ? "sqlite://:memory:"
+      : "postgres://podokit:podokit@localhost:5432/podokit",
+    READINESS_CHECK_TIMEOUT_MS: "20",
+    READINESS_CACHE_MS: "0",
+  });
+  const services = createCoreServices(env);
+  opened.push(services);
+  const sql = new SQL(":memory:", { adapter: "sqlite" });
+  if (!options.databaseUp) await sql.close();
+  const database = new Database(env, sql);
+  services.override(DATABASE, database, () => database.close());
+  for (const [name, check] of Object.entries(options.checks ?? {})) {
+    services.resolve(READINESS).register(name, check);
+  }
+  const app = new Elysia()
+    .onError(({ error, set }) => {
+      set.status = error instanceof AppException ? error.statusCode : 500;
+      return { code: error instanceof AppException ? error.code : "INTERNAL_ERROR" };
+    })
+    .use(healthPlugin(appContext(env, services)));
+  const response = await app.handle(new Request("http://localhost/health/ready"));
+  return { status: response.status, body: await response.json() };
+}
+
+describe("GET /health/ready", () => {
+  it("reports the database as db and module checks separately", async () => {
+    const result = await readiness({
+      databaseUp: true,
+      checks: { cache: () => Promise.resolve() },
+    });
+
+    expect(result).toEqual({
+      status: 200,
+      body: { status: "ready", db: "up", checks: { cache: "up" } },
+    });
+  });
+
+  it("fails when the database is down", async () => {
+    const result = await readiness({ databaseUp: false });
+
+    expect(result).toEqual({ status: 503, body: { code: "READINESS_FAILED" } });
+  });
+
+  it("fails when a module check exceeds its timeout", async () => {
+    const result = await readiness({
+      databaseUp: true,
+      checks: { storage: () => new Promise<void>(() => {}) },
+    });
+
+    expect(result).toEqual({ status: 503, body: { code: "READINESS_FAILED" } });
+  });
+});

package/dist/templates/fullstack/apps/api/src/health/health.plugin.ts

@@ -1,8 +1,9 @@
 import { Elysia } from "elysia";
 import { AppException } from "../common/app-exception";
 import type { AppPlugin } from "../core/services";
+import { DATABASE_READINESS_CHECK } from "./readiness.service";
 
-export const healthPlugin: AppPlugin = ({ database, readiness }) =>
+export const healthPlugin: AppPlugin = ({ readiness }) =>
   new Elysia({ name: "podokit.health" })
     .get(
       "/health",
@@ -12,14 +13,8 @@ export const healthPlugin: AppPlugin = ({ database, readiness }) =>
     .get(
       "/health/ready",
       async () => {
-        let db: "up" | "down" = "up";
-        try {
-          await database.ping();
-        } catch {
-          db = "down";
-        }
-        const checks = await readiness.run();
-        if (db === "down" || Object.values(checks).includes("down")) {
+        const { [DATABASE_READINESS_CHECK]: db, ...checks } = await readiness.run();
+        if (db !== "up" || Object.values(checks).includes("down")) {
           throw new AppException("READINESS_FAILED", "One or more dependencies are unavailable", 503);
         }
         return { status: "ready" as const, db: "up" as const, checks };

package/dist/templates/fullstack/apps/api/src/health/readiness.service.spec.ts

@@ -1,6 +1,23 @@
-import { describe, expect, it } from "bun:test";
+import { afterEach, describe, expect, it, setSystemTime } from "bun:test";
 import { ReadinessService } from "./readiness.service";
 
+interface Deferred {
+  promise: Promise<void>;
+  resolve: () => void;
+}
+
+function deferred(): Deferred {
+  let resolve: () => void = () => {};
+  const promise = new Promise<void>((done) => {
+    resolve = done;
+  });
+  return { promise, resolve };
+}
+
+afterEach(() => {
+  setSystemTime();
+});
+
 describe("ReadinessService", () => {
   it("runs registered checks and removes them with the returned callback", async () => {
     const service = new ReadinessService();
@@ -19,4 +36,127 @@ describe("ReadinessService", () => {
       'Readiness check "cache" is already registered',
     );
   });
+
+  it("reports a check that exceeds the timeout as down with the reason", async () => {
+    const failures: Array<[string, string]> = [];
+    const service = new ReadinessService({
+      timeoutMs: 20,
+      cacheMs: 0,
+      onCheckFailure: (name, reason) => failures.push([name, reason]),
+    });
+    service.register("storage", () => new Promise<void>(() => {}));
+    service.register("cache", () => Promise.resolve());
+
+    const started = performance.now();
+    await expect(service.run()).resolves.toEqual({ storage: "down", cache: "up" });
+    expect(performance.now() - started).toBeLessThan(1_000);
+    expect(failures).toEqual([["storage", 'Readiness check "storage" timed out after 20 ms']]);
+  });
+
+  it("reports the error message of a failed check", async () => {
+    const failures: Array<[string, string]> = [];
+    const service = new ReadinessService({
+      cacheMs: 0,
+      onCheckFailure: (name, reason) => failures.push([name, reason]),
+    });
+    service.register("events", () => Promise.reject(new Error("connection refused")));
+    service.register("cache", () => {
+      throw new Error("not connected");
+    });
+
+    await expect(service.run()).resolves.toEqual({ events: "down", cache: "down" });
+    expect(Object.fromEntries(failures)).toEqual({
+      events: "connection refused",
+      cache: "not connected",
+    });
+  });
+
+  it("reuses a finished evaluation until the cache window ends", async () => {
+    setSystemTime(new Date("2026-01-01T00:00:00.000Z"));
+    let calls = 0;
+    const service = new ReadinessService({ cacheMs: 2_000 });
+    service.register("cache", async () => {
+      calls += 1;
+    });
+
+    await service.run();
+    setSystemTime(new Date("2026-01-01T00:00:01.999Z"));
+    await service.run();
+    expect(calls).toBe(1);
+
+    setSystemTime(new Date("2026-01-01T00:00:02.000Z"));
+    await service.run();
+    expect(calls).toBe(2);
+  });
+
+  it("caches a failed evaluation for the same window", async () => {
+    setSystemTime(new Date("2026-01-01T00:00:00.000Z"));
+    let available = false;
+    const service = new ReadinessService({ cacheMs: 2_000 });
+    service.register("cache", async () => {
+      if (!available) throw new Error("unavailable");
+    });
+
+    await expect(service.run()).resolves.toEqual({ cache: "down" });
+    available = true;
+    await expect(service.run()).resolves.toEqual({ cache: "down" });
+    setSystemTime(new Date("2026-01-01T00:00:02.000Z"));
+    await expect(service.run()).resolves.toEqual({ cache: "up" });
+  });
+
+  it("evaluates on every run when the cache is disabled", async () => {
+    let calls = 0;
+    const service = new ReadinessService({ cacheMs: 0 });
+    service.register("cache", async () => {
+      calls += 1;
+    });
+
+    await service.run();
+    await service.run();
+    await service.run();
+    expect(calls).toBe(3);
+  });
+
+  it("shares one evaluation between concurrent runs", async () => {
+    let calls = 0;
+    const gate = deferred();
+    const service = new ReadinessService({ cacheMs: 0 });
+    service.register("cache", async () => {
+      calls += 1;
+      await gate.promise;
+    });
+
+    const runs = [service.run(), service.run(), service.run()];
+    gate.resolve();
+    const results = await Promise.all(runs);
+
+    expect(calls).toBe(1);
+    expect(results).toEqual([{ cache: "up" }, { cache: "up" }, { cache: "up" }]);
+    await service.run();
+    expect(calls).toBe(2);
+  });
+
+  it("does not share or cache an evaluation across a registration change", async () => {
+    const gate = deferred();
+    const service = new ReadinessService({ cacheMs: 60_000 });
+    service.register("cache", () => gate.promise);
+
+    const before = service.run();
+    service.register("events", () => Promise.resolve());
+    const after = service.run();
+    gate.resolve();
+
+    await expect(before).resolves.toEqual({ cache: "up" });
+    await expect(after).resolves.toEqual({ cache: "up", events: "up" });
+    await expect(service.run()).resolves.toEqual({ cache: "up", events: "up" });
+  });
+
+  it("returns a copy that callers cannot use to change the cached result", async () => {
+    const service = new ReadinessService({ cacheMs: 60_000 });
+    service.register("cache", () => Promise.resolve());
+
+    const first = await service.run();
+    first.cache = "down";
+    await expect(service.run()).resolves.toEqual({ cache: "up" });
+  });
 });