okengine 0.10.1 → 0.10.3

package/src/config/driver-defaults.ts

@@ -0,0 +1,186 @@
+/**
+ * Real, already-established default driver ids per {@link ConfigEnv} —
+ * one source of truth for every driver map that has a single default table.
+ *
+ * These mirror the literal fallbacks that used to live inline in each
+ * `src/kernel/boot-bind/*.ts` resolver (`docker ? "postgres" : "memory"`,
+ * `env === "test" ? "frozen" : "memory"`, …). Kept here so
+ * {@link mergeEnvDriverMap} has one real map to merge a developer's partial
+ * override onto, instead of every resolver re-deriving its own default.
+ *
+ * `store.index`, `channel.whatsapp` / `push`, and `ai` are intentionally
+ * absent — they don't have one established default across all four envs
+ * (index/whatsapp/push default to nothing until configured; ai has no prod
+ * default at all and must be declared) and keep using
+ * {@link resolveDriverId}'s legacy cascade.
+ * @module
+ */
+
+import {
+  mergeEnvDriverMap,
+  normalizeEnvDriverMap,
+  type DriversConfig,
+  type EnvDriverMap,
+  type RawEnvDriverMap,
+} from "./index.ts";
+
+/** `drivers.store.sql` — Postgres for docker/prod, in-memory otherwise. */
+export const STORE_SQL_DEFAULTS: EnvDriverMap = {
+  local: "memory",
+  docker: "postgres",
+  test: "memory",
+  prod: "postgres",
+};
+
+/** `drivers.store.kv` — Redis for docker/prod, in-memory otherwise. */
+export const STORE_KV_DEFAULTS: EnvDriverMap = {
+  local: "memory",
+  docker: "redis",
+  test: "memory",
+  prod: "redis",
+};
+
+/** `drivers.store.files` — S3 for docker/prod, in-memory otherwise. */
+export const STORE_FILES_DEFAULTS: EnvDriverMap = {
+  local: "memory",
+  docker: "s3",
+  test: "memory",
+  prod: "s3",
+};
+
+/** `drivers.signal` — in-memory bus everywhere. */
+export const SIGNAL_DEFAULTS: EnvDriverMap = {
+  local: "memory",
+  docker: "memory",
+  test: "memory",
+  prod: "memory",
+};
+
+/** `drivers.clock` — frozen test clock in `test`, in-memory cron elsewhere. */
+export const CLOCK_DEFAULTS: EnvDriverMap = {
+  local: "memory",
+  docker: "memory",
+  test: "frozen",
+  prod: "memory",
+};
+
+/** `drivers.journal` — in-memory durable-run store everywhere. */
+export const JOURNAL_DEFAULTS: EnvDriverMap = {
+  local: "memory",
+  docker: "memory",
+  test: "memory",
+  prod: "memory",
+};
+
+/** `drivers.vault` — OS env vars everywhere except `test` (in-memory). */
+export const VAULT_DEFAULTS: EnvDriverMap = {
+  local: "env",
+  docker: "env",
+  test: "memory",
+  prod: "env",
+};
+
+/** `drivers.channel.email` — SMTP for docker/prod, console inbox otherwise. */
+export const CHANNEL_EMAIL_DEFAULTS: EnvDriverMap = {
+  local: "console",
+  docker: "smtp",
+  test: "console",
+  prod: "smtp",
+};
+
+/**
+ * `drivers.channel.sms` — no default provider in any env; SMS is opt-in
+ * only (an unconfigured env simply gets no SMS channel).
+ */
+export const CHANNEL_SMS_DEFAULTS: EnvDriverMap = {};
+
+/**
+ * Effective default map for a driver whose real default also depends on the
+ * boot-time `docker` flag (real docker-compose infra available), not just
+ * the active {@link ConfigEnv} key — `store.sql` / `store.kv` /
+ * `store.files` / `channel.email` / the Gate KV facet. Real usage always
+ * pairs `docker: true` with `env: "docker"` / `"prod"`, so the static table
+ * (`docker`/`prod` → real infra id) applies as-is; with the flag `false`
+ * (`oke dev -l`, `test`, or a boot that deliberately decouples `env` from
+ * infra availability) every key falls back to the same safe, no-external-
+ * deps id the real table already uses for `test`.
+ *
+ * @param defaults - Real per-env default table (its `docker`/`prod` slots
+ *   assume real infra is actually up)
+ * @param docker - Boot-time docker/compose-infra flag
+ */
+export function dockerFlagDefaults(defaults: EnvDriverMap, docker: boolean): EnvDriverMap {
+  if (docker) return defaults;
+  const safe = defaults.test;
+  return { local: safe, docker: safe, test: safe, prod: safe };
+}
+
+/** Every driver map with one established default table, grouped by element. */
+export const DRIVER_DEFAULTS = {
+  store: {
+    sql: STORE_SQL_DEFAULTS,
+    kv: STORE_KV_DEFAULTS,
+    files: STORE_FILES_DEFAULTS,
+  },
+  signal: SIGNAL_DEFAULTS,
+  clock: CLOCK_DEFAULTS,
+  journal: JOURNAL_DEFAULTS,
+  vault: VAULT_DEFAULTS,
+  channel: {
+    email: CHANNEL_EMAIL_DEFAULTS,
+    sms: CHANNEL_SMS_DEFAULTS,
+  },
+} as const;
+
+/**
+ * Every driver map from {@link DRIVER_DEFAULTS}, fully resolved — the
+ * developer's `oke.config.ts` override merged onto the real default,
+ * per-key, for all four {@link ConfigEnv} slots at once. This is the "full
+ * picture" `oke doctor` prints: what boot actually uses for every env, even
+ * when the config on disk only pins one key.
+ */
+export interface EffectiveDriversConfig {
+  readonly store: {
+    readonly sql: EnvDriverMap;
+    readonly kv: EnvDriverMap;
+    readonly files: EnvDriverMap;
+  };
+  readonly signal: EnvDriverMap;
+  readonly clock: EnvDriverMap;
+  readonly journal: EnvDriverMap;
+  readonly vault: EnvDriverMap;
+  readonly channel: {
+    readonly email: EnvDriverMap;
+    readonly sms: EnvDriverMap;
+  };
+}
+
+/**
+ * Merge every driver map in {@link DRIVER_DEFAULTS} against the matching
+ * slot of a loaded `oke.config.ts` `drivers` block.
+ *
+ * @param drivers - `drivers` block from a loaded `oke.config.ts` (already
+ *   normalized if it came through `defineConfig`; normalized again here so
+ *   an un-normalized/raw block is still handled)
+ */
+export function resolveEffectiveDrivers(
+  drivers: DriversConfig | undefined,
+): EffectiveDriversConfig {
+  const merge = (map: EnvDriverMap | undefined, defaults: EnvDriverMap) =>
+    mergeEnvDriverMap(normalizeEnvDriverMap(map as RawEnvDriverMap), defaults);
+  return {
+    store: {
+      sql: merge(drivers?.store?.sql, STORE_SQL_DEFAULTS),
+      kv: merge(drivers?.store?.kv, STORE_KV_DEFAULTS),
+      files: merge(drivers?.store?.files, STORE_FILES_DEFAULTS),
+    },
+    signal: merge(drivers?.signal, SIGNAL_DEFAULTS),
+    clock: merge(drivers?.clock, CLOCK_DEFAULTS),
+    journal: merge(drivers?.journal, JOURNAL_DEFAULTS),
+    vault: merge(drivers?.vault, VAULT_DEFAULTS),
+    channel: {
+      email: merge(drivers?.channel?.email, CHANNEL_EMAIL_DEFAULTS),
+      sms: merge(drivers?.channel?.sms, CHANNEL_SMS_DEFAULTS),
+    },
+  };
+}

package/src/config/index.ts

@@ -81,8 +81,55 @@ export interface DriversConfig {
   readonly runs?: EnvDriverMap;
 }
 
-/** Image lock entries keyed by element role (`store.sql`, …). */
-export type ImagesConfig = Readonly<Record<string, string>>;
+/**
+ * Container image pins, nested the same way as {@link DriversConfig}:
+ * `store.*` / `channel.*` facets nest under their owning element; roles with
+ * no driver counterpart (`vault` picks a driver but pins its own image;
+ * `ai`, `pgdog`, `proxy` have no config-level element at all) stay flat.
+ *
+ * Always fully explicit — `images` has no hidden default merge. Omitted keys
+ * mean "no container for that role," never "inherit a default image."
+ */
+export interface ImagesConfig {
+  readonly store?: {
+    readonly sql?: string;
+    readonly kv?: string;
+    readonly files?: string;
+    readonly index?: string;
+  };
+  readonly channel?: {
+    readonly email?: string;
+  };
+  readonly vault?: string;
+  readonly ai?: string;
+  readonly pgdog?: string;
+  readonly proxy?: string;
+}
+
+/**
+ * Flatten {@link ImagesConfig} to the dotted-role `Record<string, string>`
+ * every internal consumer (compose role matching, credentials, env prefixes)
+ * has always kept working with — the nesting is a config-surface / type-safety
+ * concern only, not an internal representation change.
+ *
+ * @param images - Nested config-surface images (or `undefined`)
+ */
+export function flattenImagesConfig(
+  images: ImagesConfig | undefined,
+): Readonly<Record<string, string>> {
+  if (!images) return {};
+  const out: Record<string, string> = {};
+  if (images.store?.sql) out["store.sql"] = images.store.sql;
+  if (images.store?.kv) out["store.kv"] = images.store.kv;
+  if (images.store?.files) out["store.files"] = images.store.files;
+  if (images.store?.index) out["store.index"] = images.store.index;
+  if (images.channel?.email) out["channel.email"] = images.channel.email;
+  if (images.vault) out.vault = images.vault;
+  if (images.ai) out.ai = images.ai;
+  if (images.pgdog) out.pgdog = images.pgdog;
+  if (images.proxy) out.proxy = images.proxy;
+  return out;
+}
 
 /** i18n config. */
 export interface I18nConfig {
@@ -293,6 +340,32 @@ export function normalizeDriversConfig(
   };
 }
 
+/**
+ * Merge a developer's partial {@link EnvDriverMap} onto the real default map
+ * for one specific driver — per environment key, never a whole-object
+ * replace. An unset key keeps that driver's own real default; it never
+ * inherits a sibling key's value (the old `docker → prod → local → test`
+ * cascade in {@link resolveDriverId} did that, which is exactly the bug this
+ * fixes — `{ local: "pglite" }` no longer leaks `pglite` into `docker`).
+ *
+ * Scoped strictly to the `{ local?, docker?, test?, prod? }` shape — not a
+ * generic deep merge, and never applied to a whole config object.
+ *
+ * @param override - Developer-supplied partial map (may be `undefined`)
+ * @param defaults - Real, already-established default map for this driver
+ */
+export function mergeEnvDriverMap(
+  override: EnvDriverMap | undefined,
+  defaults: EnvDriverMap,
+): EnvDriverMap {
+  return {
+    local: override?.local ?? defaults.local,
+    docker: override?.docker ?? defaults.docker,
+    test: override?.test ?? defaults.test,
+    prod: override?.prod ?? defaults.prod,
+  };
+}
+
 /**
  * Fill missing `docker` pins from `prod` (compose infra ≈ production protocols).
  *
@@ -365,22 +438,39 @@ export function defineConfig(config: OkeConfig): OkeConfig {
 /**
  * Resolve a driver id for an env from an {@link EnvDriverMap}.
  *
- * `docker` falls back to `prod` then `local` so existing configs keep working
- * until an explicit `docker:` pin is added. Legacy keys are normalized first.
+ * With `defaults` given, the developer's map is merged onto it per-key via
+ * {@link mergeEnvDriverMap} and the active env's slot is read directly — a
+ * key the developer never set keeps that driver's real default, full stop.
+ * This is the path every driver map with an established default should use.
+ *
+ * Without `defaults` (legacy path — `store.index`, `channel.whatsapp` /
+ * `push`, `ai`, which have no single established default table): `docker`
+ * falls back to `prod` then `local` then `test` so existing configs keep
+ * working until an explicit `docker:` pin is added. Legacy `dev`/`stack`
+ * keys are normalized first either way.
  *
  * @param map - Env → driver map
  * @param env - Active environment
+ * @param defaults - Real default map for this specific driver (per-key merge)
  */
 export function resolveDriverId(
   map: EnvDriverMap | RawEnvDriverMap | undefined,
   env: ConfigEnv,
+  defaults?: EnvDriverMap,
 ): string | undefined {
+  const normalized = normalizeEnvDriverMap(map as RawEnvDriverMap);
+  if (defaults) {
+    const merged = mergeEnvDriverMap(normalized, defaults);
+    const ref = merged[env];
+    if (ref === undefined) return undefined;
+    return typeof ref === "string" ? ref : ref.driver;
+  }
   if (!map) return undefined;
-  const normalized = normalizeEnvDriverMap(map as RawEnvDriverMap) ?? map;
+  const resolved = normalized ?? map;
   const ref =
     env === "docker"
-      ? (normalized.docker ?? normalized.prod ?? normalized.local ?? normalized.test)
-      : (normalized[env] ?? normalized.local ?? normalized.test);
+      ? (resolved.docker ?? resolved.prod ?? resolved.local ?? resolved.test)
+      : (resolved[env] ?? resolved.local ?? resolved.test);
   if (ref === undefined) return undefined;
   return typeof ref === "string" ? ref : ref.driver;
 }

package/src/console/server/dry-run.audit.test.ts

@@ -95,7 +95,7 @@ describe("console dry-run / preview audit", () => {
 
   test("Channels preview is locale template rendering, not dry-run mutation", async () => {
     const flows = await Bun.file(`${import.meta.dir}/flows.ts`).text();
-    const previewIdx = flows.indexOf('name: "console.channel.preview"');
+    const previewIdx = flows.indexOf('flow("console.channel.preview"');
     expect(previewIdx).toBeGreaterThan(0);
     const slice = flows.slice(previewIdx, previewIdx + 800);
     expect(slice).not.toContain("withDryRun");
@@ -104,7 +104,7 @@ describe("console dry-run / preview audit", () => {
 
   test("Traces dryRun is metadata / logging, not withDryRun execution", async () => {
     const flows = await Bun.file(`${import.meta.dir}/flows.ts`).text();
-    const idx = flows.indexOf('name: "console.traces.replay"');
+    const idx = flows.indexOf('flow("console.traces.replay"');
     expect(idx).toBeGreaterThan(0);
     const slice = flows.slice(idx, idx + 500);
     expect(slice).not.toContain("withDryRun");