okengine 0.2.6 → 0.3.2

package/src/kernel/boot-bind/channel.ts

@@ -2,26 +2,82 @@
  * Lazy channel binder — loaded only when Channel is declared.
  */
 
+import { resolveDriverId, type ConfigEnv } from "../../config/index.ts";
 import { openConsoleChannel } from "../../drivers/channel-console.ts";
-import {
-  createChannelRuntime,
-  type ChannelRuntime,
-} from "../../elements/channel.ts";
+import { openSmtpChannel } from "../../drivers/channel-smtp.ts";
+import type { ChannelDriver, ChannelOpenOptions } from "../../drivers/channel-types.ts";
+import { createChannelRuntime, type ChannelRuntime } from "../../elements/channel.ts";
 import type { BootOptions } from "../boot.ts";
 
 /**
  * Construct a Channel runtime (console inbox default).
  *
  * @param options - Boot options
+ * @param env - Active environment
  * @param now - Clock
+ * @param docker - Prefer compose SMTP when active
  */
 export function bindChannel(
   options: BootOptions,
+  env: ConfigEnv,
   now: () => number,
+  docker = false,
 ): ChannelRuntime {
   return createChannelRuntime({
     ...(options.channel ?? {}),
-    drivers: options.channel?.drivers ?? [openConsoleChannel()],
+    drivers: options.channel?.drivers ?? [channelDriverFor(options, env, docker)],
     now,
   });
 }
+
+function channelDriverFor(options: BootOptions, env: ConfigEnv, docker: boolean): ChannelDriver {
+  const id = resolveEmailDriverId(options, env, docker);
+  if (id === "console") return openConsoleChannel();
+  if (id === "smtp") return openSmtpChannel(smtpOptionsFromEnv(docker));
+  throw new Error(`oke boot: unknown email channel driver "${id}"`);
+}
+
+/**
+ * Resolve the configured email driver for one environment.
+ *
+ * @param options - Boot options
+ * @param env - Active environment
+ * @param docker - Docker mode
+ */
+export function resolveEmailDriverId(
+  options: BootOptions,
+  env: ConfigEnv,
+  docker: boolean,
+): string {
+  return (
+    resolveDriverId(options.config?.drivers?.channel?.email, env) ?? (docker ? "smtp" : "console")
+  );
+}
+
+/**
+ * Resolve SMTP connection options from `SMTP_URL` plus optional auth overrides.
+ *
+ * @param docker - Whether to include the docker-specific missing URL hint
+ */
+export function smtpOptionsFromEnv(docker = false): ChannelOpenOptions {
+  const raw = process.env.SMTP_URL ?? process.env.OKE_CHANNEL_EMAIL_URL;
+  if (!raw) {
+    throw new Error(
+      docker
+        ? "oke boot: smtp driver needs SMTP_URL (did `oke dev -d` write docker/.env.docker?)"
+        : "oke boot: smtp driver needs SMTP_URL",
+    );
+  }
+  const url = new URL(raw);
+  if (url.protocol !== "smtp:") throw new Error(`oke boot: SMTP_URL must use smtp://`);
+  const urlUser = url.username ? decodeURIComponent(url.username) : undefined;
+  const urlPass = url.password ? decodeURIComponent(url.password) : undefined;
+  const user = process.env.SMTP_USER ?? urlUser;
+  const pass = process.env.SMTP_PASSWORD ?? urlPass;
+  return {
+    host: url.hostname,
+    port: url.port ? Number(url.port) : 25,
+    ...(user ? { user } : {}),
+    ...(pass ? { pass } : {}),
+  };
+}

package/src/kernel/boot-bind/clock.ts

@@ -9,10 +9,7 @@ import {
   type ClockDecl,
   type ClockRuntime,
 } from "../../elements/clock.ts";
-import {
-  resolveDriverId,
-  type ConfigEnv,
-} from "../../config/index.ts";
+import { resolveDriverId, type ConfigEnv } from "../../config/index.ts";
 import type { BootOptions } from "../boot.ts";
 
 /** Result of binding a clock runtime. */
@@ -36,8 +33,7 @@ export async function bindClock(
   prebuilt?: ClockRuntime,
 ): Promise<BindClockResult> {
   const clockDriver =
-    resolveDriverId(options.config?.drivers?.clock, env) ??
-    (env === "test" ? "frozen" : "memory");
+    resolveDriverId(options.config?.drivers?.clock, env) ?? (env === "test" ? "frozen" : "memory");
   const clock =
     prebuilt ??
     (clockDriver === "frozen" || env === "test"

package/src/kernel/boot-bind/gate.ts

@@ -3,10 +3,7 @@
  */
 
 import { memoryDrivers } from "../../drivers/memory.ts";
-import {
-  createGateRuntime,
-  type GateRuntime,
-} from "../../elements/gate.ts";
+import { createGateRuntime, type GateRuntime } from "../../elements/gate.ts";
 import type { BootOptions } from "../boot.ts";
 
 /**
@@ -15,10 +12,7 @@ import type { BootOptions } from "../boot.ts";
  * @param options - Boot options
  * @param now - Clock
  */
-export async function bindGate(
-  options: BootOptions,
-  now: () => number,
-): Promise<GateRuntime> {
+export async function bindGate(options: BootOptions, now: () => number): Promise<GateRuntime> {
   const kvNs = await memoryDrivers.kv.open({ name: "oke:gates" });
   return createGateRuntime({
     gates: options.gates ?? [],

package/src/kernel/boot-bind/runs.ts

@@ -14,9 +14,7 @@ import {
  *
  * @param options - Create options (when not already a runtime)
  */
-export async function bindRuns(
-  options?: CreateRunsRuntimeOptions,
-): Promise<RunsRuntime> {
+export async function bindRuns(options?: CreateRunsRuntimeOptions): Promise<RunsRuntime> {
   const runs = createRunsRuntime({
     driver: options?.driver ?? memoryRunsDriver,
     ...(options ?? {}),

package/src/kernel/boot-bind/signal.ts

@@ -3,14 +3,8 @@
  */
 
 import { memorySignalDriver } from "../../drivers/signal-memory.ts";
-import {
-  createSignalRuntime,
-  type SignalRuntime,
-} from "../../elements/signal.ts";
-import {
-  resolveDriverId,
-  type ConfigEnv,
-} from "../../config/index.ts";
+import { createSignalRuntime, type SignalRuntime } from "../../elements/signal.ts";
+import { resolveDriverId, type ConfigEnv } from "../../config/index.ts";
 import type { BootOptions } from "../boot.ts";
 
 /**
@@ -25,8 +19,7 @@ export async function bindSignal(
   env: ConfigEnv,
   now: () => number,
 ): Promise<SignalRuntime> {
-  const signalId =
-    resolveDriverId(options.config?.drivers?.signal, env) ?? "memory";
+  const signalId = resolveDriverId(options.config?.drivers?.signal, env) ?? "memory";
   void signalId;
   const signal = createSignalRuntime({
     driver: memorySignalDriver,

package/src/kernel/boot-bind/store.test.ts

@@ -1,60 +1,69 @@
 /**
- * Store binder — stack profile (+ env overrides).
+ * Store binder — docker profile (+ env overrides).
  */
 
 import { afterEach, describe, expect, test } from "bun:test";
-import { resolveKvDriverId, resolveSqlDriverId } from "./store.ts";
+import { resolveFilesDriverId, resolveKvDriverId, resolveSqlDriverId } from "./store.ts";
 
 describe("bindStore driver resolution", () => {
   const prev = {
-    stack: process.env.OKE_STACK,
+    docker: process.env.OKE_DOCKER,
     sql: process.env.OKE_SQL_DRIVER,
     kv: process.env.OKE_KV_DRIVER,
+    files: process.env.OKE_FILES_DRIVER,
   };
 
   afterEach(() => {
-    if (prev.stack === undefined) delete process.env.OKE_STACK;
-    else process.env.OKE_STACK = prev.stack;
+    if (prev.docker === undefined) delete process.env.OKE_DOCKER;
+    else process.env.OKE_DOCKER = prev.docker;
     if (prev.sql === undefined) delete process.env.OKE_SQL_DRIVER;
     else process.env.OKE_SQL_DRIVER = prev.sql;
     if (prev.kv === undefined) delete process.env.OKE_KV_DRIVER;
     else process.env.OKE_KV_DRIVER = prev.kv;
+    if (prev.files === undefined) delete process.env.OKE_FILES_DRIVER;
+    else process.env.OKE_FILES_DRIVER = prev.files;
   });
 
-  test("dev env keeps sqlite / memory from config", () => {
+  test("local env keeps sqlite / memory from config", () => {
     const options = {
       config: {
         drivers: {
           store: {
-            sql: { dev: "sqlite", stack: "postgres", prod: "postgres" },
-            kv: { dev: "memory", stack: "redis", prod: "redis" },
+            sql: { local: "sqlite", docker: "postgres", prod: "postgres" },
+            kv: { local: "memory", docker: "redis", prod: "redis" },
+            files: { local: "fs", docker: "s3", prod: "s3" },
           },
         },
       },
     };
-    expect(resolveSqlDriverId(options, "dev", false)).toBe("sqlite");
-    expect(resolveKvDriverId(options, "dev", false)).toBe("memory");
+    expect(resolveSqlDriverId(options, "local", false)).toBe("sqlite");
+    expect(resolveKvDriverId(options, "local", false)).toBe("memory");
+    expect(resolveFilesDriverId(options, "local", false)).toBe("fs");
   });
 
-  test("stack env uses stack profile (falls back to prod)", () => {
+  test("docker env uses docker profile (falls back to prod)", () => {
     const options = {
       config: {
         drivers: {
           store: {
-            sql: { dev: "sqlite", stack: "postgres", prod: "postgres" },
-            kv: { dev: "memory", prod: "redis" },
+            sql: { local: "sqlite", docker: "postgres", prod: "postgres" },
+            kv: { local: "memory", prod: "redis" },
+            files: { local: "fs", prod: "s3" },
           },
         },
       },
     };
-    expect(resolveSqlDriverId(options, "stack", true)).toBe("postgres");
-    expect(resolveKvDriverId(options, "stack", true)).toBe("redis");
+    expect(resolveSqlDriverId(options, "docker", true)).toBe("postgres");
+    expect(resolveKvDriverId(options, "docker", true)).toBe("redis");
+    expect(resolveFilesDriverId(options, "docker", true)).toBe("s3");
   });
 
-  test("stack mode honours OKE_*_DRIVER overrides", () => {
+  test("docker mode honours OKE_*_DRIVER overrides", () => {
     process.env.OKE_SQL_DRIVER = "postgres";
     process.env.OKE_KV_DRIVER = "redis";
-    expect(resolveSqlDriverId({}, "stack", true)).toBe("postgres");
-    expect(resolveKvDriverId({}, "stack", true)).toBe("redis");
+    process.env.OKE_FILES_DRIVER = "s3";
+    expect(resolveSqlDriverId({}, "docker", true)).toBe("postgres");
+    expect(resolveKvDriverId({}, "docker", true)).toBe("redis");
+    expect(resolveFilesDriverId({}, "docker", true)).toBe("s3");
   });
 });

package/src/kernel/boot-bind/store.ts

@@ -2,49 +2,45 @@
  * Lazy store binder — loaded only when Store is declared.
  */
 
-import {
-  resolveDriverId,
-  type ConfigEnv,
-} from "../../config/index.ts";
+import { resolveDomainDdlMode, resolveDriverId, type ConfigEnv } from "../../config/index.ts";
+import { fsDriver } from "../../drivers/fs.ts";
 import { memoryDrivers } from "../../drivers/memory.ts";
 import { postgresDriver } from "../../drivers/postgres.ts";
 import { redisDriver } from "../../drivers/redis.ts";
+import { s3Driver } from "../../drivers/s3.ts";
 import { sqliteDriver } from "../../drivers/sqlite.ts";
-import type { KvDriver, SqlDriver } from "../../drivers/types.ts";
-import {
-  createStoreRuntime,
-  type StoreRuntime,
-} from "../../elements/store.ts";
+import type { FilesDriver, KvDriver, SqlDriver } from "../../drivers/types.ts";
+import { createStoreRuntime, type StoreRuntime } from "../../elements/store.ts";
 import type { StoreDecl } from "../../elements/store/declare.ts";
 import type { BootOptions } from "../boot.ts"; // type-only — no cycle at runtime
 
 /**
  * Construct a Store runtime and register facet declarations.
  *
- * In stack mode (`env === "stack"` / `OKE_STACK=1`), SQL/KV resolve from the
- * `stack` driver map (falling back to `prod`) and URLs from `.env.stack`.
+ * In docker mode (`env === "docker"` / `OKE_DOCKER=1`), SQL/KV resolve from the
+ * `docker` driver map (falling back to `prod`) and URLs from `docker/.env.docker`.
  *
  * @param options - Boot options
  * @param env - Active environment
  * @param now - Clock
- * @param stack - Prefer compose URLs when opening postgres/redis
+ * @param docker - Prefer compose URLs when opening postgres/redis
  */
 export function bindStore(
   options: BootOptions,
   env: ConfigEnv,
   now: () => number,
-  stack = false,
+  docker = false,
 ): StoreRuntime {
-  const sqlId = resolveSqlDriverId(options, env, stack);
-  const kvId = resolveKvDriverId(options, env, stack);
-  const sqlUrl = sqlUrlFor(sqlId, stack);
-  const kvUrl = kvUrlFor(kvId, stack);
-
-  const sqlBindings: Record<
-    string,
-    { name: string; primary: { url: string } }
-  > = {};
+  const sqlId = resolveSqlDriverId(options, env, docker);
+  const kvId = resolveKvDriverId(options, env, docker);
+  const filesId = resolveFilesDriverId(options, env, docker);
+  const sqlUrl = sqlUrlFor(sqlId, docker);
+  const kvUrl = kvUrlFor(kvId, docker);
+  const filesRoot = filesRootFor(filesId);
+
+  const sqlBindings: Record<string, { name: string; primary: { url: string } }> = {};
   const kvBindings: Record<string, { url?: string }> = {};
+  const filesBindings: Record<string, { root?: string }> = {};
 
   for (const decl of options.stores ?? []) {
     if (isSqlDecl(decl)) {
@@ -54,19 +50,26 @@ export function bindStore(
       };
     } else if (isKvDecl(decl)) {
       kvBindings[decl.name] = kvUrl !== undefined ? { url: kvUrl } : {};
+    } else if (isFilesDecl(decl)) {
+      filesBindings[decl.name] = filesRoot !== undefined ? { root: filesRoot } : {};
     }
   }
 
+  const autoPush = resolveAutoPush(options);
+  const domainDdl = resolveDomainDdlMode(env, autoPush);
+
   const store = createStoreRuntime({
     drivers: {
       sql: sqlDriverFor(sqlId),
       kv: kvDriverFor(kvId),
-      files: memoryDrivers.files,
+      files: filesDriverFor(filesId),
       index: memoryDrivers.index,
     },
     sql: sqlBindings,
     kv: kvBindings,
+    files: filesBindings,
     now,
+    domainDdl,
   });
   for (const decl of options.stores ?? []) {
     store.register?.(decl);
@@ -74,38 +77,59 @@ export function bindStore(
   return store;
 }
 
+/**
+ * Effective `db.autoPush` — config default true; `OKE_DB_AUTO_PUSH=0` opts out.
+ *
+ * @param options - Boot options
+ */
+function resolveAutoPush(options: BootOptions): boolean {
+  const fromEnv = process.env.OKE_DB_AUTO_PUSH?.trim();
+  if (fromEnv === "0" || fromEnv === "false") return false;
+  if (fromEnv === "1" || fromEnv === "true") return true;
+  return options.config?.db?.autoPush !== false;
+}
+
 /**
  * @param options - Boot options
  * @param env - Active env
- * @param stack - Stack mode
+ * @param docker - Docker mode
  */
-export function resolveSqlDriverId(
-  options: BootOptions,
-  env: ConfigEnv,
-  stack: boolean,
-): string {
+export function resolveSqlDriverId(options: BootOptions, env: ConfigEnv, docker: boolean): string {
   const fromEnv = process.env.OKE_SQL_DRIVER?.trim();
-  if (stack && fromEnv) return fromEnv;
+  if (docker && fromEnv) return fromEnv;
   const resolved = resolveDriverId(options.config?.drivers?.store?.sql, env);
   if (resolved) return resolved;
-  return stack ? "postgres" : "memory";
+  return docker ? "postgres" : "memory";
+}
+
+/**
+ * @param options - Boot options
+ * @param env - Active env
+ * @param docker - Docker mode
+ */
+export function resolveKvDriverId(options: BootOptions, env: ConfigEnv, docker: boolean): string {
+  const fromEnv = process.env.OKE_KV_DRIVER?.trim();
+  if (docker && fromEnv) return fromEnv;
+  const resolved = resolveDriverId(options.config?.drivers?.store?.kv, env);
+  if (resolved) return resolved;
+  return docker ? "redis" : "memory";
 }
 
 /**
  * @param options - Boot options
  * @param env - Active env
- * @param stack - Stack mode
+ * @param docker - Docker mode
  */
-export function resolveKvDriverId(
+export function resolveFilesDriverId(
   options: BootOptions,
   env: ConfigEnv,
-  stack: boolean,
+  docker: boolean,
 ): string {
-  const fromEnv = process.env.OKE_KV_DRIVER?.trim();
-  if (stack && fromEnv) return fromEnv;
-  const resolved = resolveDriverId(options.config?.drivers?.store?.kv, env);
+  const fromEnv = process.env.OKE_FILES_DRIVER?.trim();
+  if (docker && fromEnv) return fromEnv;
+  const resolved = resolveDriverId(options.config?.drivers?.store?.files, env);
   if (resolved) return resolved;
-  return stack ? "redis" : "memory";
+  return docker ? "s3" : "memory";
 }
 
 function sqlDriverFor(id: string): SqlDriver {
@@ -132,14 +156,26 @@ function kvDriverFor(id: string): KvDriver {
   }
 }
 
-function sqlUrlFor(sqlId: string, stack: boolean): string {
+function filesDriverFor(id: string): FilesDriver {
+  switch (id) {
+    case "s3":
+      return s3Driver;
+    case "fs":
+      return fsDriver;
+    case "memory":
+      return memoryDrivers.files;
+    default:
+      throw new Error(`oke boot: unknown files driver "${id}"`);
+  }
+}
+
+function sqlUrlFor(sqlId: string, docker: boolean): string {
   if (sqlId === "postgres") {
-    const url =
-      process.env.DATABASE_URL ?? process.env.OKE_STORE_SQL_URL ?? undefined;
+    const url = process.env.DATABASE_URL ?? process.env.OKE_STORE_SQL_URL ?? undefined;
     if (!url) {
       throw new Error(
-        stack
-          ? "oke boot: postgres driver needs DATABASE_URL (did `oke dev -s` write .env.stack?)"
+        docker
+          ? "oke boot: postgres driver needs DATABASE_URL (did `oke dev -d` write docker/.env.docker?)"
           : "oke boot: postgres driver needs DATABASE_URL",
       );
     }
@@ -151,27 +187,32 @@ function sqlUrlFor(sqlId: string, stack: boolean): string {
   return ":memory:";
 }
 
-function kvUrlFor(kvId: string, stack: boolean): string | undefined {
+function kvUrlFor(kvId: string, docker: boolean): string | undefined {
   if (kvId !== "redis") return undefined;
   const url = process.env.REDIS_URL ?? process.env.OKE_STORE_KV_URL ?? undefined;
   if (!url) {
     throw new Error(
-      stack
-        ? "oke boot: redis driver needs REDIS_URL (did `oke dev -s` write .env.stack?)"
+      docker
+        ? "oke boot: redis driver needs REDIS_URL (did `oke dev -d` write docker/.env.docker?)"
         : "oke boot: redis driver needs REDIS_URL",
     );
   }
   return url;
 }
 
-function isSqlDecl(
-  decl: StoreDecl,
-): decl is Extract<StoreDecl, { facet: "sql" }> {
+function filesRootFor(filesId: string): string | undefined {
+  if (filesId !== "s3") return undefined;
+  return process.env.S3_BUCKET ?? process.env.OKE_STORE_FILES_DB ?? undefined;
+}
+
+function isSqlDecl(decl: StoreDecl): decl is Extract<StoreDecl, { facet: "sql" }> {
   return decl.facet === "sql";
 }
 
-function isKvDecl(
-  decl: StoreDecl,
-): decl is Extract<StoreDecl, { facet: "kv" }> {
+function isKvDecl(decl: StoreDecl): decl is Extract<StoreDecl, { facet: "kv" }> {
   return decl.facet === "kv";
 }
+
+function isFilesDecl(decl: StoreDecl): decl is Extract<StoreDecl, { facet: "files" }> {
+  return decl.facet === "files";
+}

package/src/kernel/boot-bind/vault.ts

@@ -3,10 +3,7 @@
  */
 
 import { memoryVaultDriver } from "../../drivers/vault-memory.ts";
-import {
-  createVaultRuntime,
-  type VaultRuntime,
-} from "../../elements/vault.ts";
+import { createVaultRuntime, type VaultRuntime } from "../../elements/vault.ts";
 import type { ConfigEnv } from "../../config/index.ts";
 import type { BootOptions } from "../boot.ts";
 
@@ -16,10 +13,7 @@ import type { BootOptions } from "../boot.ts";
  * @param options - Boot options
  * @param env - Active environment
  */
-export async function bindVault(
-  options: BootOptions,
-  env: ConfigEnv,
-): Promise<VaultRuntime> {
+export async function bindVault(options: BootOptions, env: ConfigEnv): Promise<VaultRuntime> {
   const vaultSecrets = options.vault?.secrets ?? options.secrets ?? [];
   const vault = createVaultRuntime({
     secrets: vaultSecrets,

package/src/kernel/boot.test.ts

@@ -38,10 +38,7 @@ describe("boot — vault gaps", () => {
     } catch (err) {
       expect(err).toBeInstanceOf(VaultBootError);
       const boot = err as VaultBootError;
-      expect(boot.gaps.map((g) => g.name).sort()).toEqual([
-        "DATABASE_URL",
-        "STRIPE_KEY",
-      ]);
+      expect(boot.gaps.map((g) => g.name).sort()).toEqual(["DATABASE_URL", "STRIPE_KEY"]);
       expect(boot.message).toContain("STRIPE_KEY");
       expect(boot.message).toContain("DATABASE_URL");
     }
@@ -103,7 +100,6 @@ describe("boot — lazy element needs", () => {
         external: [
           "@duckdb/node-api",
           "@duckdb/*",
-          "age-encryption",
           "sently",
           "sently/*",
           "ajv",
@@ -206,9 +202,7 @@ describe("boot — HTTP gate wiring lives behind boot", () => {
       }),
     );
     const app = oke({ name: "legacy" });
-    const res = await app.fetch(
-      new Request("http://localhost/ping", { method: "GET" }),
-    );
+    const res = await app.fetch(new Request("http://localhost/ping", { method: "GET" }));
     expect(res.status).toBe(200);
   });
 });
@@ -234,10 +228,10 @@ describe("boot — cron autostart via real timer loop", () => {
       }),
     );
 
-    // env: "dev" → startScheduler defaults ON. No createTestApp / advance.
+    // env: "local" → startScheduler defaults ON. No createTestApp / advance.
     const app = oke({
       name: "cron-autostart",
-      env: "dev",
+      env: "local",
       schedulerIntervalMs: 1000,
     });
     await app.boot();