@cosmicdrift/kumiko-dev-server 0.152.0 → 0.153.0

package/src/__tests__/session-wiring.test.ts

@@ -1,51 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import {
-  createSessionsFeature,
-  SESSIONS_FEATURE,
-} from "@cosmicdrift/kumiko-bundled-features/sessions";
-import { resolveProdSessionsConfig, shouldWireProdSessions } from "../session-wiring";
-
-describe("shouldWireProdSessions — secure-by-default with opt-out (KF-1)", () => {
-  it("wires sessions when the feature is mounted, even without an explicit config", () => {
-    // The publicstatus bug: sessions feature mounted + auth set, but no auth.sessions —
-    // previously left stateless (no revocation). Now it wires automatically.
-    expect(shouldWireProdSessions(true, true, undefined)).toBe(true);
-  });
-
-  it("wires sessions when a config object is given", () => {
-    expect(shouldWireProdSessions(true, true, { expiresInMs: 1000 })).toBe(true);
-  });
-
-  it("does not wire when sessions: false (explicit opt-out)", () => {
-    expect(shouldWireProdSessions(true, true, false)).toBe(false);
-  });
-
-  it("does not wire when the sessions feature is not mounted", () => {
-    expect(shouldWireProdSessions(true, false, undefined)).toBe(false);
-  });
-
-  it("does not wire when the app has no auth at all", () => {
-    expect(shouldWireProdSessions(false, true, undefined)).toBe(false);
-  });
-});
-
-describe("SESSIONS_FEATURE constant matches the real feature name", () => {
-  it("createSessionsFeature()'s name equals SESSIONS_FEATURE", () => {
-    // shouldWireProdSessions's own arm only tests the pure boolean helper —
-    // the actual run-prod-app.ts integration seam
-    // (`features.some((f) => f.name === SESSIONS_FEATURE)`) drifts silently
-    // if the feature is ever renamed without updating this constant.
-    expect(createSessionsFeature().name).toBe(SESSIONS_FEATURE);
-  });
-});
-
-describe("resolveProdSessionsConfig", () => {
-  it("passes a config object through", () => {
-    expect(resolveProdSessionsConfig({ expiresInMs: 5000 })).toEqual({ expiresInMs: 5000 });
-  });
-
-  it("collapses false / undefined to defaults", () => {
-    expect(resolveProdSessionsConfig(undefined)).toEqual({});
-    expect(resolveProdSessionsConfig(false)).toEqual({});
-  });
-});

package/src/__tests__/try-hono-first.test.ts

@@ -1,63 +0,0 @@
-// Pure-function pin für tryHonoFirst. Trivial aber load-bearing:
-// Drift zwischen dev (createKumikoServer) und prod (runProdApp) hat
-// schon einen Bug verursacht (legal-pages funktionierten in prod aber
-// nicht in dev). Beide nutzen jetzt diesen helper — wenn die Semantik
-// sich ändert (z.B. "matched" auch für 4xx anders als 404), MÜSSEN
-// beide Pfade synchron updaten.
-
-import { describe, expect, test } from "bun:test";
-import { type HonoLikeApp, tryHonoFirst } from "../try-hono-first";
-
-function makeApp(response: Response): HonoLikeApp {
-  return { fetch: () => response };
-}
-
-function makeAsyncApp(response: Response): HonoLikeApp {
-  return { fetch: async () => response };
-}
-
-describe("tryHonoFirst", () => {
-  test("matched=true bei 200 (Hono-route greift)", async () => {
-    const app = makeApp(new Response("ok", { status: 200 }));
-    const res = await tryHonoFirst(app, new Request("http://test/foo"));
-    expect(res.matched).toBe(true);
-    expect(res.response.status).toBe(200);
-  });
-
-  test("matched=false bei 404 (keine Route — caller fällt auf SPA-fallback)", async () => {
-    const app = makeApp(new Response("not found", { status: 404 }));
-    const res = await tryHonoFirst(app, new Request("http://test/unknown"));
-    expect(res.matched).toBe(false);
-    // response wird trotzdem zurückgegeben — caller kann den 404 als
-    // letztes Sicherheitsnetz nutzen wenn auch SPA-fallback nichts liefert.
-    expect(res.response.status).toBe(404);
-  });
-
-  test("matched=true bei 401/403/500 (Hono hat geantwortet — kein SPA-fallback)", async () => {
-    // Bug-Pin: matched darf NUR bei status=404 false sein. Wenn Hono
-    // 401 (auth required) returnt, war die Route klar gefunden + hat
-    // bewusst rejected — SPA-fallback würde das überschreiben und den
-    // User auf eine SPA leiten statt die 401-message zu zeigen.
-    for (const status of [401, 403, 422, 500] as const) {
-      const app = makeApp(new Response(null, { status }));
-      const res = await tryHonoFirst(app, new Request("http://test/x"));
-      expect(res.matched, `status ${status} should be matched`).toBe(true);
-    }
-  });
-
-  test("akzeptiert sowohl sync als auch async fetch (Hono-Variation)", async () => {
-    // Hono.app.fetch returnt Response | Promise<Response> abhängig vom
-    // handler-mix. createApiEntrypoint's apiHandler dasselbe. Helper
-    // muss beide schluckable.
-    const sync = await tryHonoFirst(
-      makeApp(new Response("s", { status: 200 })),
-      new Request("http://t/"),
-    );
-    const asyncRes = await tryHonoFirst(
-      makeAsyncApp(new Response("a", { status: 200 })),
-      new Request("http://t/"),
-    );
-    expect(sync.matched).toBe(true);
-    expect(asyncRes.matched).toBe(true);
-  });
-});

package/src/boot/__tests__/job-run-logger.test.ts

@@ -1,26 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { createJobsFeature } from "@cosmicdrift/kumiko-bundled-features/jobs";
-import type { DbConnection } from "@cosmicdrift/kumiko-framework/db";
-import { createRegistry, defineFeature } from "@cosmicdrift/kumiko-framework/engine";
-import { jobRunLoggerCallbacks } from "../job-run-logger";
-
-// ponytail: callbacks shape only — no DB I/O; createTestDb needs TEST_DATABASE_URL (CI unit job has none).
-const mockDb = {} as DbConnection;
-
-describe("jobRunLoggerCallbacks", () => {
-  test("returns undefined when jobs feature is not registered", () => {
-    const registry = createRegistry([
-      defineFeature("empty", () => ({ handlers: {}, queries: {} })),
-    ]);
-    expect(jobRunLoggerCallbacks(registry, mockDb)).toBeUndefined();
-  });
-
-  test("returns logger callbacks when jobs feature is registered", () => {
-    const registry = createRegistry([createJobsFeature()]);
-    const callbacks = jobRunLoggerCallbacks(registry, mockDb);
-    expect(callbacks).toBeDefined();
-    expect(typeof callbacks?.onJobStart).toBe("function");
-    expect(typeof callbacks?.onJobComplete).toBe("function");
-    expect(typeof callbacks?.onJobFailed).toBe("function");
-  });
-});

package/src/boot/apply-boot-seeds.ts

@@ -1,19 +0,0 @@
-import { seedAllConfigValues } from "@cosmicdrift/kumiko-bundled-features/config";
-import type { DbConnection } from "@cosmicdrift/kumiko-framework/db";
-import type { Registry } from "@cosmicdrift/kumiko-framework/engine";
-import type { EnvelopeCipher } from "@cosmicdrift/kumiko-framework/secrets";
-
-// Single boot-seed entry-point. runDevApp + runProdApp both call this
-// from their post-stack hook, so the wiring lives in exactly one place
-// — config-seed-boot.integration.ts pins this helper, which means a
-// missing call site (e.g. someone deletes the line from runDevApp)
-// surfaces as a missing-helper-use in code review rather than silently
-// shipping a server that never seeds.
-// @wrapper-known semantic-alias
-export async function applyBootSeeds(deps: {
-  registry: Registry;
-  db: DbConnection;
-  cipher?: EnvelopeCipher;
-}): Promise<void> {
-  await seedAllConfigValues(deps.registry, deps.db, deps.cipher);
-}

package/src/boot/boot-crypto.ts

@@ -1,82 +0,0 @@
-// One place that turns env/options into the app-wide crypto objects:
-// the MasterKeyProvider (KUMIKO_SECRETS_MASTER_KEY_V<n> keyring) and the
-// EnvelopeCipher for `encrypted: true` config keys. runProdApp and
-// runDevApp both resolve this once and thread it into
-// buildBootExtraContext + applyBootSeeds so resolver, set-handler and
-// seeds share the same cipher instance (and DEK cache).
-
-import { createEncryptionProvider } from "@cosmicdrift/kumiko-framework/db";
-import {
-  createDekCache,
-  createEnvelopeCipher,
-  createEnvMasterKeyProvider,
-  type DekCache,
-  type EnvelopeCipher,
-  type MasterKeyProvider,
-} from "@cosmicdrift/kumiko-framework/secrets";
-
-// Keyring detection without throwing: only build the env provider when at
-// least one versioned KEK is actually set. Covers (a) apps without any
-// encryption — no KEK requirement, and (b) dev with an app-supplied
-// provider in options.masterKey — env stays irrelevant.
-const MASTER_KEK_VAR = /^KUMIKO_SECRETS_MASTER_KEY_V\d+$/;
-export function envHasMasterKek(env: Record<string, string | undefined>): boolean {
-  return Object.entries(env).some(([k, v]) => MASTER_KEK_VAR.test(k) && !!v);
-}
-
-export type BootCrypto = {
-  readonly masterKeyProvider?: MasterKeyProvider;
-  // Cipher for encrypted config keys. Present exactly when a master key is
-  // available. Decrypts legacy CONFIG_ENCRYPTION_KEY values as fallback
-  // until the config re-encrypt job migrated them.
-  readonly configCipher?: EnvelopeCipher;
-  // Cipher for `encrypted: true` entity fields — same master key, but the
-  // legacy fallback reads the pre-envelope ENCRYPTION_KEY format. Identical
-  // to configCipher when no ENCRYPTION_KEY is set.
-  readonly entityFieldCipher?: EnvelopeCipher;
-  readonly dekCache: DekCache;
-};
-
-export function resolveBootCrypto(
-  envSource: Record<string, string | undefined>,
-  masterKeyOverride?: MasterKeyProvider,
-): BootCrypto {
-  const masterKeyProvider =
-    masterKeyOverride ??
-    (envHasMasterKek(envSource)
-      ? createEnvMasterKeyProvider({
-          // CURRENT_VERSION default "1" spiegelt secretsEnvSchema — ohne
-          // ihn wirft der raw-env-Provider, obwohl V1 gesetzt ist.
-          env: {
-            ...envSource,
-            KUMIKO_SECRETS_MASTER_KEY_CURRENT_VERSION:
-              envSource["KUMIKO_SECRETS_MASTER_KEY_CURRENT_VERSION"] ?? "1",
-          },
-        })
-      : undefined);
-
-  const dekCache = createDekCache();
-  const legacyConfigKey = envSource["CONFIG_ENCRYPTION_KEY"];
-  const configCipher = masterKeyProvider
-    ? createEnvelopeCipher(masterKeyProvider, {
-        dekCache,
-        ...(legacyConfigKey ? { legacy: createEncryptionProvider(legacyConfigKey) } : {}),
-      })
-    : undefined;
-
-  const legacyEntityKey = envSource["ENCRYPTION_KEY"];
-  const entityFieldCipher =
-    masterKeyProvider && legacyEntityKey
-      ? createEnvelopeCipher(masterKeyProvider, {
-          dekCache,
-          legacy: createEncryptionProvider(legacyEntityKey),
-        })
-      : configCipher;
-
-  return {
-    ...(masterKeyProvider && { masterKeyProvider }),
-    ...(configCipher && { configCipher }),
-    ...(entityFieldCipher && { entityFieldCipher }),
-    dekCache,
-  };
-}

package/src/boot/job-run-logger.ts

@@ -1,51 +0,0 @@
-import { createJobRunLogger } from "@cosmicdrift/kumiko-bundled-features/jobs";
-import type { DbConnection } from "@cosmicdrift/kumiko-framework/db";
-import type { Registry } from "@cosmicdrift/kumiko-framework/engine";
-import type { JobRunIn } from "@cosmicdrift/kumiko-framework/engine/types";
-import { createJobRunner, type JobRunner } from "@cosmicdrift/kumiko-framework/jobs";
-
-export function jobRunLoggerCallbacks(
-  registry: Registry,
-  db: DbConnection,
-): ReturnType<typeof createJobRunLogger> | undefined {
-  if (registry.getFeature("jobs") === undefined) return undefined;
-  return createJobRunLogger({ db, registry });
-}
-
-/** Dev-server parity: consume api + worker lanes when jobs are registered. */
-export async function startDevJobRunners(opts: {
-  readonly registry: Registry;
-  readonly db: DbConnection;
-  readonly context: Record<string, unknown>;
-  readonly redisUrl: string;
-}): Promise<{ readonly runners: readonly JobRunner[]; readonly stop: () => Promise<void> }> {
-  const jobs = [...opts.registry.getAllJobs().values()];
-  if (opts.registry.getFeature("jobs") === undefined || jobs.length === 0) {
-    return { runners: [], stop: async () => {} };
-  }
-
-  const logger = createJobRunLogger({ db: opts.db, registry: opts.registry });
-  const runners: JobRunner[] = [];
-  const lanes = new Set(
-    jobs.map((j) => j.runIn).filter((lane): lane is JobRunIn => lane !== undefined),
-  );
-
-  for (const lane of lanes) {
-    const jr = createJobRunner({
-      registry: opts.registry,
-      context: { ...opts.context, db: opts.db },
-      redisUrl: opts.redisUrl,
-      consumerLane: lane,
-      ...logger,
-    });
-    await jr.start();
-    runners.push(jr);
-  }
-
-  return {
-    runners,
-    stop: async () => {
-      for (const runner of runners) await runner.stop();
-    },
-  };
-}