okengine 0.2.6 → 0.2.8

package/src/cli/ask-dev-mode.ts

@@ -0,0 +1,40 @@
+/**
+ * One-time interactive `oke dev` mode choice via `@clack/prompts`.
+ */
+
+import { isCancel, select } from "@clack/prompts";
+import type { DevMode } from "./dev-mode.ts";
+
+/**
+ * Injectable ask step — production uses {@link askDevMode}.
+ *
+ * @returns Chosen mode, or `null` if the user cancelled
+ */
+export type AskDevModeFn = () => Promise<DevMode | null>;
+
+/**
+ * Prompt once: local vs docker.
+ *
+ * @returns Chosen mode, or `null` on cancel
+ */
+export async function askDevMode(): Promise<DevMode | null> {
+  const value = await select({
+    message: "Run against",
+    options: [
+      {
+        value: "local",
+        label: "local",
+        hint: "in-memory, instant, no Docker needed",
+      },
+      {
+        value: "docker",
+        label: "docker",
+        hint: "real Postgres/Redis via compose, closer to production",
+      },
+    ],
+    initialValue: "local",
+  });
+  if (isCancel(value)) return null;
+  if (value === "local" || value === "docker") return value;
+  return null;
+}

package/src/cli/build.ts

@@ -26,8 +26,7 @@ export async function runBuild(options: BuildOptions = {}): Promise<number> {
   const target = options.target ?? "bun";
   const entry = options.entry ?? "src/app.ts";
   const outdir = options.outdir ?? "dist";
-  const bunTarget =
-    target === "edge" ? "browser" : target === "node" ? "node" : "bun";
+  const bunTarget = target === "edge" ? "browser" : target === "node" ? "node" : "bun";
 
   const bundle =
     options.bundle ??

package/src/cli/client-add.test.ts

@@ -6,10 +6,7 @@ import { describe, expect, test } from "bun:test";
 import { mkdtemp } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import {
-  clientAdd,
-  emitAmbient,
-} from "./client-add.ts";
+import { clientAdd, emitAmbient } from "./client-add.ts";
 import type { ClientDescriptor } from "../client/types.ts";
 
 const fixture: ClientDescriptor = {
@@ -72,10 +69,7 @@ void seats;
     // Minimal stub so `import type { Register }` resolves.
     const stubDir = join(dir, "node_modules/okengine");
     await Bun.$`mkdir -p ${stubDir}`.quiet();
-    await Bun.write(
-      join(stubDir, "client.d.ts"),
-      `export interface Register {}\n`,
-    );
+    await Bun.write(join(stubDir, "client.d.ts"), `export interface Register {}\n`);
     await Bun.write(
       join(stubDir, "package.json"),
       JSON.stringify({
@@ -102,10 +96,11 @@ void seats;
       }),
     );
 
-    const proc = Bun.spawn(
-      ["bunx", "tsc", "--project", tsconfig],
-      { cwd: dir, stdout: "pipe", stderr: "pipe" },
-    );
+    const proc = Bun.spawn(["bunx", "tsc", "--project", tsconfig], {
+      cwd: dir,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
     const [stdout, stderr, code] = await Promise.all([
       new Response(proc.stdout).text(),
       new Response(proc.stderr).text(),
@@ -113,9 +108,7 @@ void seats;
     ]);
 
     if (code !== 0) {
-      throw new Error(
-        `tsc failed (${code})\n${stdout}\n${stderr}\n--- d.ts ---\n${result.source}`,
-      );
+      throw new Error(`tsc failed (${code})\n${stdout}\n${stderr}\n--- d.ts ---\n${result.source}`);
     }
   });
 

package/src/cli/client-add.ts

@@ -32,12 +32,9 @@ export interface ClientAddResult {
  *
  * @param options - URL / out / test overrides
  */
-export async function clientAdd(
-  options: ClientAddOptions,
-): Promise<ClientAddResult> {
+export async function clientAdd(options: ClientAddOptions): Promise<ClientAddResult> {
   const out = options.out ?? "oke-client.d.ts";
-  const descriptor =
-    options.descriptor ?? (await fetchDescriptor(options.url, options.fetch));
+  const descriptor = options.descriptor ?? (await fetchDescriptor(options.url, options.fetch));
   const source = emitAmbient(descriptor);
   await Bun.write(out, source);
   return { out, source };
@@ -102,12 +99,8 @@ export function emitAmbient(descriptor: ClientDescriptor): string {
                   `          in: ${c.in ?? "unknown"};`,
                   `          out: ${c.out ?? "unknown"};`,
                   errorBlock,
-                  c.method
-                    ? `          method: ${JSON.stringify(c.method)};`
-                    : undefined,
-                  c.path
-                    ? `          path: ${JSON.stringify(c.path)};`
-                    : undefined,
+                  c.method ? `          method: ${JSON.stringify(c.method)};` : undefined,
+                  c.path ? `          path: ${JSON.stringify(c.path)};` : undefined,
                   `        }`,
                 ]
                   .filter((line): line is string => line !== undefined)
@@ -147,9 +140,7 @@ async function fetchDescriptor(
   const base = url.replace(/\/+$/, "");
   const res = await fetchFn(`${base}/_oke/client.json`);
   if (!res.ok) {
-    throw new Error(
-      `Failed to fetch ${base}/_oke/client.json (${res.status})`,
-    );
+    throw new Error(`Failed to fetch ${base}/_oke/client.json (${res.status})`);
   }
   const json: unknown = await res.json();
   if (

package/src/cli/completion.test.ts

@@ -4,11 +4,7 @@
 
 import { describe, expect, test } from "bun:test";
 import { generateCompletion } from "./completion.ts";
-import {
-  OKE_COMMANDS,
-  commandNames,
-  type CliCommand,
-} from "./registry.ts";
+import { OKE_COMMANDS, commandNames, type CliCommand } from "./registry.ts";
 
 describe("oke completion", () => {
   test("bash script lists every registry command", () => {

package/src/cli/completion.ts

@@ -3,12 +3,7 @@
  */
 
 import { EXIT_OK, EXIT_USAGE } from "./exit.ts";
-import {
-  OKE_COMMANDS,
-  commandNames,
-  type CliCommand,
-  type CliFlag,
-} from "./registry.ts";
+import { OKE_COMMANDS, commandNames, type CliCommand, type CliFlag } from "./registry.ts";
 
 /** Supported completion shells. */
 export const COMPLETION_SHELLS = ["bash", "zsh", "fish"] as const;
@@ -63,9 +58,7 @@ Install:
 
   const shell = args[0];
   if (!shell || !isCompletionShell(shell)) {
-    console.error(
-      "oke completion: require bash, zsh, or fish — e.g. oke completion zsh",
-    );
+    console.error("oke completion: require bash, zsh, or fish — e.g. oke completion zsh");
     return EXIT_USAGE;
   }
 
@@ -223,9 +216,7 @@ function fishScript(commands: readonly CliCommand[]): string {
       `complete -c oke -f -n "not __fish_seen_subcommand_from ${names}" -a "${cmd.name}" -d ${fishQuote(cmd.summary)}`,
     );
   }
-  rebuilt.push(
-    `complete -c oke -f -n "__fish_seen_subcommand_from completion" -a "bash zsh fish"`,
-  );
+  rebuilt.push(`complete -c oke -f -n "__fish_seen_subcommand_from completion" -a "bash zsh fish"`);
   for (const cmd of commands) {
     const subs = cmd.subcommands ?? [];
     if (subs.length === 0) {
@@ -248,11 +239,7 @@ function fishScript(commands: readonly CliCommand[]): string {
   return `${rebuilt.join("\n")}\n`;
 }
 
-function fishFlagLine(
-  command: string,
-  sub: string | undefined,
-  flag: CliFlag,
-): string {
+function fishFlagLine(command: string, sub: string | undefined, flag: CliFlag): string {
   const seen = sub
     ? `__fish_seen_subcommand_from ${command}; and __fish_seen_subcommand_from ${sub}`
     : `__fish_seen_subcommand_from ${command}`;

package/src/cli/db-auto-push.test.ts

@@ -0,0 +1,64 @@
+/**
+ * Domain schema watch-path + auto-push policy.
+ */
+
+import { describe, expect, test } from "bun:test";
+import {
+  createDebouncedRunner,
+  isDomainSchemaWatchPath,
+  resolveDevAutoPush,
+} from "./db-auto-push.ts";
+
+describe("isDomainSchemaWatchPath", () => {
+  test("matches schema.ts and drizzle.config.ts", () => {
+    expect(isDomainSchemaWatchPath("schema.ts")).toBe(true);
+    expect(isDomainSchemaWatchPath("drizzle.config.ts")).toBe(true);
+    expect(isDomainSchemaWatchPath("flows/notes/schema.ts")).toBe(true);
+    expect(isDomainSchemaWatchPath("src/schema.decl.ts")).toBe(true);
+    expect(isDomainSchemaWatchPath("src/schema.generated.ts")).toBe(true);
+  });
+
+  test("ignores unrelated files", () => {
+    expect(isDomainSchemaWatchPath("flows/notes/index.ts")).toBe(false);
+    expect(isDomainSchemaWatchPath(undefined)).toBe(false);
+  });
+
+  test("matches app entry (plugin .table contributions)", () => {
+    expect(isDomainSchemaWatchPath("app.ts")).toBe(true);
+    expect(isDomainSchemaWatchPath("src/app.ts")).toBe(true);
+  });
+});
+
+describe("resolveDevAutoPush", () => {
+  test("default on for local", () => {
+    expect(resolveDevAutoPush({})).toBe(true);
+  });
+
+  test("off for docker", () => {
+    expect(resolveDevAutoPush({ docker: true })).toBe(false);
+  });
+
+  test("off for --no-db-push", () => {
+    expect(resolveDevAutoPush({ noDbPush: true })).toBe(false);
+  });
+
+  test("off when config.db.autoPush is false", () => {
+    expect(resolveDevAutoPush({ configAutoPush: false })).toBe(false);
+  });
+});
+
+describe("createDebouncedRunner", () => {
+  test("coalesces rapid triggers", async () => {
+    let count = 0;
+    const runner = createDebouncedRunner(() => {
+      count++;
+    }, 40);
+    runner.trigger();
+    runner.trigger();
+    runner.trigger();
+    expect(count).toBe(0);
+    await Bun.sleep(80);
+    expect(count).toBe(1);
+    runner.cancel();
+  });
+});

package/src/cli/db-auto-push.ts

@@ -0,0 +1,72 @@
+/**
+ * Debounced domain-schema auto-push for `oke dev` (local mode).
+ */
+
+import { basename } from "node:path";
+
+/** Default debounce for schema-change → push. */
+export const DB_AUTO_PUSH_DEBOUNCE_MS = 300;
+
+/**
+ * Whether a watched path should trigger `oke db push`.
+ *
+ * @param filename - Relative path from the watcher (may be undefined)
+ */
+export function isDomainSchemaWatchPath(filename: string | null | undefined): boolean {
+  if (!filename) return false;
+  const normalized = filename.replace(/\\/g, "/");
+  const base = basename(normalized);
+  if (base === "schema.ts" || base === "schema.tsx") return true;
+  if (base === "schema.decl.ts" || base === "schema.decl.tsx") return true;
+  if (base === "schema.generated.ts" || base === "schema.generated.tsx") return true;
+  if (base === "drizzle.config.ts" || base === "drizzle.config.js") return true;
+  // App entry / plugins — `.plug()` table contributions feed emit.
+  if (base === "app.ts" || base === "app.tsx") return true;
+  // Nested domain schemas commonly live under src/**/schema.ts
+  if (/(^|\/)schema(\.decl|\.generated)?\.tsx?$/.test(normalized)) return true;
+  return false;
+}
+
+/**
+ * Resolve whether auto-push is enabled for this `oke dev` session.
+ *
+ * @param options - Explicit CLI opt-out, config, docker mode
+ */
+export function resolveDevAutoPush(options: {
+  readonly noDbPush?: boolean;
+  readonly docker?: boolean;
+  readonly configAutoPush?: boolean;
+}): boolean {
+  if (options.docker) return false;
+  if (options.noDbPush) return false;
+  return options.configAutoPush !== false;
+}
+
+/**
+ * Create a debounced callback runner.
+ *
+ * @param fn - Async work
+ * @param ms - Debounce window
+ */
+export function createDebouncedRunner(
+  fn: () => void | Promise<void>,
+  ms = DB_AUTO_PUSH_DEBOUNCE_MS,
+): {
+  readonly trigger: () => void;
+  readonly cancel: () => void;
+} {
+  let timer: ReturnType<typeof setTimeout> | null = null;
+  return {
+    trigger() {
+      if (timer) clearTimeout(timer);
+      timer = setTimeout(() => {
+        timer = null;
+        void fn();
+      }, ms);
+    },
+    cancel() {
+      if (timer) clearTimeout(timer);
+      timer = null;
+    },
+  };
+}

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")');
+  });
+});