okengine 0.2.6 → 0.3.2

package/src/cli/db.test.ts

@@ -0,0 +1,189 @@
+/**
+ * `oke db` CLI wrappers.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { mkdir, mkdtemp, readFile, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { EXIT_OK, EXIT_RUNTIME } from "./exit.ts";
+import { dbCli, emitAbstractSchemaPrestep, runDb, runGenerate, runPush } from "./db.ts";
+
+/** Repo public entry — absolute import so temp apps need no install. */
+const OKE_INDEX = resolve(import.meta.dir, "../index.ts");
+const CONFIG_MOD = resolve(import.meta.dir, "../config/index.ts");
+
+describe("oke db", () => {
+  test("help lists subcommands", async () => {
+    const lines: string[] = [];
+    const orig = console.log;
+    console.log = (msg?: unknown) => {
+      lines.push(String(msg ?? ""));
+    };
+    try {
+      const code = await dbCli(["--help"]);
+      expect(code).toBe(EXIT_OK);
+      expect(lines.join("\n")).toContain("push");
+      expect(lines.join("\n")).toContain("generate");
+      expect(lines.join("\n")).toContain("migrate");
+      expect(lines.join("\n")).toContain("oke schema generate");
+    } finally {
+      console.log = orig;
+    }
+  });
+
+  test("push reports ok / no_changes via injectable", async () => {
+    const out: string[] = [];
+    const code = await runPush("/tmp/drizzle.config.ts", (t) => out.push(t), {
+      pushFn: async () => ({ status: "no_changes" }),
+      skipEmit: true,
+    });
+    expect(code).toBe(EXIT_OK);
+    expect(out.join("")).toContain("no_changes");
+  });
+
+  test("generate surfaces migration_path", async () => {
+    const out: string[] = [];
+    const code = await runGenerate("/tmp/drizzle.config.ts", (t) => out.push(t), {
+      generateFn: async () => ({
+        status: "ok",
+        migration_path: "/tmp/drizzle/0001_init.sql",
+      }),
+      skipEmit: true,
+    });
+    expect(code).toBe(EXIT_OK);
+    expect(out.join("")).toContain("0001_init.sql");
+  });
+
+  test("missing_hints exits runtime", async () => {
+    const code = await runDb("push", {
+      pushFn: async () => ({ status: "missing_hints", unresolved: [] }),
+      write: () => {},
+      skipEmit: true,
+    });
+    expect(code).toBe(EXIT_RUNTIME);
+  });
+
+  test("resolveDrizzleConfigPath uses db.config from oke.config", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "oke-db-"));
+    await writeFile(
+      join(dir, "oke.config.ts"),
+      `import { defineConfig } from ${JSON.stringify(CONFIG_MOD)};
+export default defineConfig({ db: { config: "custom.drizzle.ts" } });
+`,
+    );
+    const { resolveDrizzleConfigPath } = await import("./db.ts");
+    const path = await resolveDrizzleConfigPath(dir);
+    expect(path.endsWith("custom.drizzle.ts")).toBe(true);
+  });
+});
+
+describe("oke db emit — live plugged plugin tables", () => {
+  /**
+   * End-to-end: real oke().plug() app + schema.decl + runDb("push") must write
+   * the plugin's field.* table into schema.generated.ts. Not a unit merge call.
+   */
+  test("push emits plugin field.* table into schema.generated.ts", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "oke-db-plugin-emit-"));
+    await mkdir(join(dir, "src"), { recursive: true });
+
+    await writeFile(
+      join(dir, "oke.config.ts"),
+      `import { defineConfig } from ${JSON.stringify(CONFIG_MOD)};
+export default defineConfig({
+  drivers: { store: { sql: { local: "sqlite", test: "memory", prod: "postgres" } } },
+  db: { declare: "src/schema.decl.ts", generated: "src/schema.generated.ts" },
+});
+`,
+    );
+
+    await writeFile(
+      join(dir, "src", "schema.decl.ts"),
+      `import { store, field, id } from ${JSON.stringify(OKE_INDEX)};
+export const notes = store.schema.table("notes", {
+  id: field.text().primaryKey().defaultFn(id),
+  title: field.text().notNull(),
+});
+`,
+    );
+
+    await writeFile(
+      join(dir, "src", "app.ts"),
+      `import { oke, plugin, field, id } from ${JSON.stringify(OKE_INDEX)};
+
+const audit = plugin("audit", { version: "1.0.0" }).table("audit_events", {
+  id: field.text().primaryKey().defaultFn(id),
+  actorId: field.text().notNull().pii(),
+  action: field.text().notNull(),
+});
+
+export const app = oke({ name: "plugin-emit" }).plug(audit);
+`,
+    );
+
+    await writeFile(
+      join(dir, "drizzle.config.ts"),
+      `import { defineConfig } from "drizzle-kit";
+export default defineConfig({
+  dialect: "sqlite",
+  schema: "./src/schema.generated.ts",
+  out: "./drizzle",
+  dbCredentials: { url: "file:./local.db" },
+});
+`,
+    );
+
+    const out: string[] = [];
+    const code = await runDb("push", {
+      cwd: dir,
+      write: (t) => out.push(t),
+      pushFn: async () => ({ status: "no_changes" }),
+      // Real emit path — do not skip; kit is mocked after emit.
+    });
+
+    expect(code).toBe(EXIT_OK);
+    expect(out.join("")).toMatch(/emitted.*schema\.generated\.ts/);
+
+    const generated = await readFile(join(dir, "src", "schema.generated.ts"), "utf8");
+    expect(generated).toContain('sqliteTable("notes"');
+    expect(generated).toContain('sqliteTable("audit_events"');
+    expect(generated).toContain('text("actor_id")');
+    expect(generated).toContain('text("action")');
+    expect(generated).toContain(".notNull()");
+  });
+
+  test("emitAbstractSchemaPrestep loads plugin tables from app entry alone", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "oke-db-plugin-only-"));
+    await mkdir(join(dir, "src"), { recursive: true });
+
+    await writeFile(
+      join(dir, "oke.config.ts"),
+      `import { defineConfig } from ${JSON.stringify(CONFIG_MOD)};
+export default defineConfig({
+  drivers: { store: { sql: { local: "sqlite" } } },
+});
+`,
+    );
+
+    await writeFile(
+      join(dir, "src", "app.ts"),
+      `import { oke, plugin, field } from ${JSON.stringify(OKE_INDEX)};
+export const app = oke({ name: "plugin-only" }).plug(
+  plugin("metrics", { version: "1.0.0" }).table("metrics_daily", {
+    day: field.text().primaryKey(),
+    hits: field.integer().notNull().default(0),
+  }),
+);
+`,
+    );
+
+    const { loadOkeConfig } = await import("./load-config.ts");
+    const loaded = await loadOkeConfig(dir);
+    const emitted = await emitAbstractSchemaPrestep(dir, loaded.config, () => {}, "local");
+    expect(emitted).toBe(true);
+
+    const generated = await readFile(join(dir, "src", "schema.generated.ts"), "utf8");
+    expect(generated).toContain('sqliteTable("metrics_daily"');
+    expect(generated).toContain('integer("hits")');
+  });
+});

package/src/cli/db.ts

@@ -0,0 +1,456 @@
+/**
+ * `oke db push|generate|migrate` — domain schema sync via drizzle-kit.
+ *
+ * Distinct from `oke schema generate` (core/plugin stub tables).
+ * When abstract decls exist (`src/schema.decl.ts`), emits Drizzle first —
+ * not a third schema CLI.
+ */
+
+import { resolve } from "node:path";
+import {
+  dialectFromDriverId,
+  maybeEmitDomainSchema,
+  type SqlDialect,
+} from "../elements/store/emit-drizzle.ts";
+import { loadPluginTablesFromAppEntry } from "../elements/store/load-plugin-tables.ts";
+import { resolveDriverId, type ConfigEnv, type OkeConfig } from "../config/index.ts";
+import type { TableContribution } from "../kernel/plugin.ts";
+import { resolveDrizzleKitEnv } from "./drizzle-env.ts";
+import { resolveDevSqlEnv } from "./resolve-dev-sql-env.ts";
+import { EXIT_OK, EXIT_RUNTIME, EXIT_USAGE } from "./exit.ts";
+import { loadOkeConfig } from "./load-config.ts";
+
+/**
+ * Apply a drizzle-kit env overlay to `process.env` for the in-process SDK,
+ * returning a restore function. drizzle-kit's `push`/`generate` read
+ * `process.env` directly (the project `drizzle.config.ts` also reads it), so
+ * CLI-resolved dialect + connection env must be present in this process.
+ *
+ * @param overlay - Env keys to set
+ */
+export function applyDrizzleEnvOverlay(overlay: Record<string, string>): () => void {
+  const previous = new Map<string, string | undefined>();
+  for (const [key, value] of Object.entries(overlay)) {
+    previous.set(key, process.env[key]);
+    process.env[key] = value;
+  }
+  return () => {
+    for (const [key, value] of previous) {
+      if (value === undefined) delete process.env[key];
+      else process.env[key] = value;
+    }
+  };
+}
+
+/**
+ * Resolve env + apply the drizzle-kit overlay for the in-process SDK.
+ * Restores the env afterward via a `finally`.
+ *
+ * @param cwd - Project root
+ * @param config - Loaded oke config
+ * @param env - Active env
+ * @param fn - Work to run under the overlay
+ */
+export async function withDrizzleKitEnv<T>(
+  cwd: string,
+  config: OkeConfig | null | undefined,
+  env: ConfigEnv,
+  fn: (dialect: string) => Promise<T>,
+): Promise<T> {
+  const { dialect, overlay } = await resolveDrizzleKitEnv(cwd, config, env);
+  const restore = applyDrizzleEnvOverlay(overlay);
+  try {
+    return await fn(dialect);
+  } finally {
+    restore();
+  }
+}
+
+/** Subcommands under `oke db`. */
+export type DbSubcommand = "push" | "generate" | "migrate";
+
+/** Options for {@link runDb}. */
+export interface DbOptions {
+  readonly cwd?: string;
+  /** Path to drizzle.config.ts (overrides `db.config`). */
+  readonly config?: string;
+  readonly write?: (text: string) => void;
+  /** Injectable push (tests). */
+  readonly pushFn?: (opts: { config: string }) => Promise<DbKitResult>;
+  /** Injectable generate (tests). */
+  readonly generateFn?: (opts: {
+    config: string;
+  }) => Promise<DbKitResult & { readonly migration_path?: string }>;
+  /** Injectable migrate (tests). */
+  readonly migrateFn?: (opts: {
+    config: string;
+    cwd: string;
+    env: Record<string, string>;
+  }) => Promise<number>;
+  /**
+   * Dry-run push via drizzle-kit `explain` — used by doctor drift checks.
+   */
+  readonly explain?: boolean;
+  /**
+   * Skip abstract-schema emit pre-step (tests / explain-only).
+   */
+  readonly skipEmit?: boolean;
+  /** Active config env for dialect resolution (default `local`). */
+  readonly env?: ConfigEnv;
+  /**
+   * Injectable plugin tables for emit (tests). When omitted, loads the live
+   * app entry and reads `app.plugins.tableContributions()`.
+   */
+  readonly pluginTables?: readonly TableContribution[];
+  /** Override app entry path for plugin-table discovery. */
+  readonly entry?: string;
+}
+
+/** Minimal drizzle-kit envelope we handle. */
+export interface DbKitResult {
+  readonly status: "ok" | "no_changes" | "missing_hints" | "error" | string;
+  readonly error?: { readonly code?: string; readonly message?: string };
+  readonly unresolved?: readonly unknown[];
+}
+
+/**
+ * Resolve the drizzle config path for a project.
+ *
+ * @param cwd - Project root
+ * @param options - CLI / config overrides
+ */
+export async function resolveDrizzleConfigPath(
+  cwd: string,
+  options: {
+    readonly config?: string;
+    readonly loadedConfig?: OkeConfig | null;
+  } = {},
+): Promise<string> {
+  if (options.config) return resolve(cwd, options.config);
+  const loaded = options.loadedConfig ?? (await loadOkeConfig(cwd).catch(() => null))?.config;
+  const fromConfig = loaded?.db?.config;
+  return resolve(cwd, fromConfig ?? "drizzle.config.ts");
+}
+
+/**
+ * Run `oke db <subcommand>`.
+ *
+ * @param sub - push | generate | migrate
+ * @param options - Paths / injectables
+ */
+export async function runDb(sub: DbSubcommand, options: DbOptions = {}): Promise<number> {
+  const write = options.write ?? ((t) => process.stdout.write(t));
+  const cwd = options.cwd ?? process.cwd();
+  const loaded = await loadOkeConfig(cwd).catch(() => null);
+  const env = options.env ?? (await resolveDevSqlEnv(cwd));
+  if (!options.skipEmit) {
+    await emitAbstractSchemaPrestep(cwd, loaded?.config, write, env, {
+      pluginTables: options.pluginTables,
+      entry: options.entry,
+    });
+  }
+  const configPath = await resolveDrizzleConfigPath(cwd, {
+    config: options.config,
+    loadedConfig: loaded?.config,
+  });
+  const resolved = { ...options, skipEmit: true, env };
+
+  if (sub === "push") {
+    return runPush(configPath, write, resolved);
+  }
+  if (sub === "generate") {
+    return runGenerate(configPath, write, resolved);
+  }
+  if (sub === "migrate") {
+    return runMigrate(configPath, cwd, write, resolved);
+  }
+  write(`oke db: unknown subcommand\n`);
+  return EXIT_USAGE;
+}
+
+/**
+ * Emit `schema.generated.ts` from abstract decls + live plugged plugin tables.
+ *
+ * @param cwd - Project root
+ * @param config - Loaded oke config
+ * @param write - Output
+ * @param env - Active env for dialect
+ * @param options - Injectables / entry override
+ */
+export async function emitAbstractSchemaPrestep(
+  cwd: string,
+  config: OkeConfig | null | undefined,
+  write: (text: string) => void = () => {},
+  env: ConfigEnv = "local",
+  options: {
+    readonly pluginTables?: readonly TableContribution[];
+    readonly entry?: string;
+  } = {},
+): Promise<boolean> {
+  const driverId = resolveDriverId(config?.drivers?.store?.sql, env);
+  const dialect: SqlDialect = dialectFromDriverId(driverId);
+  const pluginTables =
+    options.pluginTables ??
+    (await loadPluginTablesFromAppEntry(cwd, {
+      entry: options.entry ?? config?.db?.entry,
+      write,
+    }));
+  const result = await maybeEmitDomainSchema({
+    cwd,
+    dialect,
+    declarePath: config?.db?.declare,
+    outPath: config?.db?.generated,
+    pluginTables,
+    write,
+  });
+  return result.emitted;
+}
+
+/**
+ * Push domain schema to the live database (dev).
+ *
+ * @param configPath - Absolute drizzle.config.ts
+ * @param write - Output
+ * @param options - Injectables / explain
+ */
+export async function runPush(
+  configPath: string,
+  write: (text: string) => void = (t) => process.stdout.write(t),
+  options: DbOptions = {},
+): Promise<number> {
+  const cwd = options.cwd ?? process.cwd();
+  const loaded = await loadOkeConfig(cwd).catch(() => null);
+  const env = options.env ?? (await resolveDevSqlEnv(cwd));
+  if (!options.skipEmit) {
+    await emitAbstractSchemaPrestep(cwd, loaded?.config, write, env, {
+      pluginTables: options.pluginTables,
+      entry: options.entry,
+    });
+  }
+
+  const pushFn =
+    options.pushFn ??
+    (async (opts: { config: string }) => {
+      const { push } = await import("drizzle-kit/cli");
+      return (await push({
+        config: opts.config,
+        ...(options.explain ? { explain: true } : {}),
+      })) as DbKitResult;
+    });
+
+  let result: DbKitResult;
+  try {
+    result = await withDrizzleKitEnv(cwd, loaded?.config, env, () =>
+      pushFn({ config: configPath }),
+    );
+  } catch (err) {
+    write(`oke db push: ${err instanceof Error ? err.message : String(err)}\n`);
+    write("         → install drizzle-kit and ensure drizzle.config.ts exists\n");
+    return EXIT_RUNTIME;
+  }
+
+  return reportKitResult("push", result, write);
+}
+
+/**
+ * Generate versioned migration SQL under `out` (prod artefact folder).
+ *
+ * @param configPath - Absolute drizzle.config.ts
+ * @param write - Output
+ * @param options - Injectables
+ */
+export async function runGenerate(
+  configPath: string,
+  write: (text: string) => void = (t) => process.stdout.write(t),
+  options: DbOptions = {},
+): Promise<number> {
+  const cwd = options.cwd ?? process.cwd();
+  const loaded = await loadOkeConfig(cwd).catch(() => null);
+  const env = options.env ?? (await resolveDevSqlEnv(cwd));
+  if (!options.skipEmit) {
+    await emitAbstractSchemaPrestep(cwd, loaded?.config, write, env, {
+      pluginTables: options.pluginTables,
+      entry: options.entry,
+    });
+  }
+
+  const generateFn =
+    options.generateFn ??
+    (async (opts: { config: string }) => {
+      const { generate } = await import("drizzle-kit/cli");
+      return (await generate({ config: opts.config })) as DbKitResult & {
+        readonly migration_path?: string;
+      };
+    });
+
+  let result: DbKitResult & { readonly migration_path?: string };
+  try {
+    result = await withDrizzleKitEnv(cwd, loaded?.config, env, () =>
+      generateFn({ config: configPath }),
+    );
+  } catch (err) {
+    write(`oke db generate: ${err instanceof Error ? err.message : String(err)}\n`);
+    write("         → install drizzle-kit and ensure drizzle.config.ts exists\n");
+    return EXIT_RUNTIME;
+  }
+
+  if (result.status === "ok" && result.migration_path) {
+    write(`oke db generate: wrote ${result.migration_path}\n`);
+    return EXIT_OK;
+  }
+  return reportKitResult("generate", result, write);
+}
+
+/**
+ * Apply versioned migrations (`drizzle-kit migrate`).
+ *
+ * @param configPath - Absolute drizzle.config.ts
+ * @param cwd - Project root
+ * @param write - Output
+ * @param options - Injectables
+ */
+export async function runMigrate(
+  configPath: string,
+  cwd: string,
+  write: (text: string) => void = (t) => process.stdout.write(t),
+  options: DbOptions = {},
+): Promise<number> {
+  const loaded = await loadOkeConfig(cwd).catch(() => null);
+  const env = options.env ?? (await resolveDevSqlEnv(cwd));
+  if (!options.skipEmit) {
+    await emitAbstractSchemaPrestep(cwd, loaded?.config, write, env, {
+      pluginTables: options.pluginTables,
+      entry: options.entry,
+    });
+  }
+
+  const migrateFn =
+    options.migrateFn ??
+    (async (opts: { config: string; cwd: string; env: Record<string, string> }) => {
+      const proc = Bun.spawn(["bunx", "drizzle-kit", "migrate", "--config", opts.config], {
+        cwd: opts.cwd,
+        stdout: "inherit",
+        stderr: "inherit",
+        env: opts.env,
+      });
+      return await proc.exited;
+    });
+
+  const { overlay } = await resolveDrizzleKitEnv(cwd, loaded?.config, env);
+  try {
+    const code = await migrateFn({
+      config: configPath,
+      cwd,
+      env: { ...(process.env as Record<string, string>), ...overlay },
+    });
+    if (code === 0) {
+      write("oke db migrate: applied\n");
+      return EXIT_OK;
+    }
+    write(`oke db migrate: exited ${code}\n`);
+    return EXIT_RUNTIME;
+  } catch (err) {
+    write(`oke db migrate: ${err instanceof Error ? err.message : String(err)}\n`);
+    return EXIT_RUNTIME;
+  }
+}
+
+/**
+ * Whether domain schema differs from the live DB (drizzle-kit push explain).
+ *
+ * @param options - Paths / injectables
+ */
+export async function detectDbDrift(options: DbOptions = {}): Promise<{
+  readonly drifted: boolean;
+  readonly detail?: string;
+}> {
+  const cwd = options.cwd ?? process.cwd();
+  const loaded = await loadOkeConfig(cwd).catch(() => null);
+  const env = options.env ?? (await resolveDevSqlEnv(cwd));
+  const configPath = await resolveDrizzleConfigPath(cwd, { config: options.config });
+  const pushFn =
+    options.pushFn ??
+    (async (opts: { config: string }) => {
+      const { push } = await import("drizzle-kit/cli");
+      return (await push({ config: opts.config, explain: true })) as DbKitResult;
+    });
+
+  try {
+    const result = await withDrizzleKitEnv(cwd, loaded?.config, env, () =>
+      pushFn({ config: configPath }),
+    );
+    if (result.status === "no_changes") return { drifted: false };
+    if (result.status === "ok" || result.status === "missing_hints") {
+      return { drifted: true, detail: `drizzle-kit push explain: ${result.status}` };
+    }
+    if (result.status === "error") {
+      return {
+        drifted: false,
+        detail: result.error?.message ?? "drizzle-kit push explain failed",
+      };
+    }
+    return { drifted: false };
+  } catch (err) {
+    return {
+      drifted: false,
+      detail: err instanceof Error ? err.message : String(err),
+    };
+  }
+}
+
+/**
+ * CLI entry: parse `oke db <push|generate|migrate> [--config path]`.
+ *
+ * @param args - Args after `db`
+ */
+export async function dbCli(args: readonly string[]): Promise<number> {
+  const sub = args[0];
+  if (!sub || sub === "--help" || sub === "-h") {
+    console.log(`oke db push|generate|migrate [--config|-c drizzle.config.ts]
+
+Domain schema sync via drizzle-kit.
+When src/schema.decl.ts and/or a plugged app entry exists, emits
+schema.generated.ts from store.schema.table + live plugin .table()
+contributions — then runs drizzle-kit.
+Hand-written src/schema.ts remains supported (emit skipped if nothing to emit).
+Not the same as \`oke schema generate\` (core/plugin stub tables).
+
+  push       Apply schema to the live local DB (dev; no migration files)
+  generate   Write versioned SQL under drizzle/ for review
+  migrate    Apply generated migrations (explicit; never automatic in prod)
+`);
+    return sub ? EXIT_OK : EXIT_USAGE;
+  }
+  if (sub !== "push" && sub !== "generate" && sub !== "migrate") {
+    console.error(`oke db: unknown subcommand "${sub}"`);
+    return EXIT_USAGE;
+  }
+
+  let config: string | undefined;
+  for (let i = 1; i < args.length; i++) {
+    const a = args[i]!;
+    if (a === "--config" || a === "-c") config = args[++i];
+    else if (a === "--help" || a === "-h") {
+      return dbCli(["--help"]);
+    }
+  }
+
+  return runDb(sub, { config });
+}
+
+function reportKitResult(verb: string, result: DbKitResult, write: (text: string) => void): number {
+  if (result.status === "ok" || result.status === "no_changes") {
+    write(`oke db ${verb}: ${result.status}\n`);
+    return EXIT_OK;
+  }
+  if (result.status === "missing_hints") {
+    write(
+      `oke db ${verb}: missing_hints — resolve destructive changes manually (not auto-applied)\n`,
+    );
+    return EXIT_RUNTIME;
+  }
+  write(
+    `oke db ${verb}: ${result.status}${result.error?.message ? ` — ${result.error.message}` : ""}\n`,
+  );
+  return EXIT_RUNTIME;
+}

package/src/cli/dev-app-runner.ts

@@ -19,11 +19,7 @@ import { resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 import { createBunRuntime } from "../runtime/bun.ts";
 import { APP_PORT, type FetchApp } from "../runtime/types.ts";
-import {
-  clearTerminalScreen,
-  formatAppReadyLine,
-  formatDevHero,
-} from "../term.ts";
+import { clearTerminalScreen, formatAppReadyLine, formatDevHero } from "../term.ts";
 import { decodeHeroSnapshot } from "./hero-meta.ts";
 
 /** Stable Bun.serve id so `--hot` reuses the socket across soft reloads. */
@@ -62,9 +58,7 @@ if (
   typeof mod.app.boot !== "function" ||
   typeof mod.app.fetch !== "function"
 ) {
-  console.error(
-    `oke dev: ${absoluteEntry} must export app with boot() and fetch()`,
-  );
+  console.error(`oke dev: ${absoluteEntry} must export app with boot() and fetch()`);
   process.exit(1);
 }