okengine 0.2.6 → 0.3.2

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

@@ -0,0 +1,193 @@
+/**
+ * `oke dev` auto `oke db push` on schema change + opt-out.
+ */
+
+import { afterEach, describe, expect, test } from "bun:test";
+import { mkdir, mkdtemp, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { runDev, type DevSession, type DevWatchFn } from "./dev.ts";
+
+const sessions: DevSession[] = [];
+
+afterEach(() => {
+  for (const s of sessions.splice(0)) s.stop();
+});
+
+async function waitFor(predicate: () => boolean, timeoutMs = 3_000): Promise<void> {
+  const deadline = Date.now() + timeoutMs;
+  while (!predicate() && Date.now() < deadline) {
+    await Bun.sleep(20);
+  }
+}
+
+function controlledWatcher(): {
+  watchFs: DevWatchFn;
+  change(filename: string): void;
+} {
+  let listener: Parameters<DevWatchFn>[2] | undefined;
+  return {
+    watchFs: (_path, _options, next) => {
+      listener = next;
+      return { close() {} };
+    },
+    change(filename) {
+      if (!listener) throw new Error("watcher not started");
+      listener("change", filename);
+    },
+  };
+}
+
+async function scaffoldProject(): Promise<string> {
+  const dir = await mkdtemp(join(tmpdir(), "oke-dev-db-"));
+  await mkdir(join(dir, "src"), { recursive: true });
+  const configMod = join(import.meta.dir, "../config/index.ts");
+  await writeFile(
+    join(dir, "oke.config.ts"),
+    `import { defineConfig } from ${JSON.stringify(configMod)};
+export default defineConfig({
+  drivers: { store: { sql: { local: "sqlite", test: "memory", prod: "postgres" } } },
+});
+`,
+  );
+  await writeFile(join(dir, "src", "app.ts"), `export {};\n`);
+  await writeFile(
+    join(dir, "src", "schema.ts"),
+    `import { sqliteTable, text } from "drizzle-orm/sqlite-core";
+export const entries = sqliteTable("entries", { id: text("id").primaryKey() });
+`,
+  );
+  await writeFile(
+    join(dir, "drizzle.config.ts"),
+    `import { defineConfig } from "drizzle-kit";
+export default defineConfig({
+  dialect: "sqlite",
+  schema: "./src/schema.ts",
+  out: "./drizzle",
+  dbCredentials: { url: "file::memory:" },
+});
+`,
+  );
+  return dir;
+}
+
+describe("oke dev db auto-push", () => {
+  test("schema change triggers dbPush when auto-push is on", async () => {
+    const cwd = await scaffoldProject();
+    const pushes: string[] = [];
+    const watcher = controlledWatcher();
+    let resolveReady!: () => void;
+    const ready = new Promise<void>((r) => {
+      resolveReady = r;
+    });
+
+    const result = await runDev({
+      cwd,
+      local: true,
+      keepAlive: false,
+      dryRun: false,
+      appPort: 0,
+      consolePort: 0,
+      mcpPort: 0,
+      silentClaim: true,
+      stdinIsTTY: false,
+      startApp: async () => ({
+        port: 0,
+        url: new URL("http://127.0.0.1:9"),
+        stop() {},
+      }),
+      serveConsole: async () => ({
+        port: 0,
+        stop() {},
+      }),
+      serveMcp: async () => ({
+        port: 0,
+        url: new URL("http://127.0.0.1:9"),
+        stop() {},
+      }),
+      regenClient: async () => {},
+      dbPush: async () => {
+        pushes.push("push");
+        return 0;
+      },
+      onDbAutoPush: () => {
+        resolveReady();
+      },
+      watchFs: watcher.watchFs,
+      onReady: async (session) => {
+        sessions.push(session);
+      },
+    });
+
+    expect(result.code).toBe(0);
+    // Initial boot triggers one push.
+    await Promise.race([ready, Bun.sleep(800)]);
+    expect(pushes.length).toBeGreaterThanOrEqual(1);
+
+    const before = pushes.length;
+    await writeFile(
+      join(cwd, "src", "schema.ts"),
+      `import { sqliteTable, text, integer } from "drizzle-orm/sqlite-core";
+export const entries = sqliteTable("entries", {
+  id: text("id").primaryKey(),
+  n: integer("n"),
+});
+`,
+    );
+    watcher.change("schema.ts");
+    await waitFor(() => pushes.length > before);
+    expect(pushes.length).toBeGreaterThan(before);
+  });
+
+  test("--no-db-push / noDbPush never calls dbPush", async () => {
+    const cwd = await scaffoldProject();
+    const pushes: string[] = [];
+    const watcher = controlledWatcher();
+
+    const result = await runDev({
+      cwd,
+      local: true,
+      noDbPush: true,
+      keepAlive: false,
+      appPort: 0,
+      consolePort: 0,
+      mcpPort: 0,
+      silentClaim: true,
+      stdinIsTTY: false,
+      startApp: async () => ({
+        port: 0,
+        url: new URL("http://127.0.0.1:9"),
+        stop() {},
+      }),
+      serveConsole: async () => ({
+        port: 0,
+        stop() {},
+      }),
+      serveMcp: async () => ({
+        port: 0,
+        url: new URL("http://127.0.0.1:9"),
+        stop() {},
+      }),
+      regenClient: async () => {},
+      dbPush: async () => {
+        pushes.push("push");
+        return 0;
+      },
+      watchFs: watcher.watchFs,
+      onReady: async (session) => {
+        sessions.push(session);
+      },
+    });
+
+    expect(result.code).toBe(0);
+    await writeFile(
+      join(cwd, "src", "schema.ts"),
+      `import { sqliteTable, text } from "drizzle-orm/sqlite-core";
+export const entries = sqliteTable("entries", { id: text("id").primaryKey(), x: text("x") });
+`,
+    );
+    watcher.change("schema.ts");
+    await Bun.sleep(500);
+    expect(pushes).toHaveLength(0);
+  });
+});

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

@@ -0,0 +1,45 @@
+/**
+ * `.oke/mode` persistence and prompt gating.
+ */
+
+import { afterEach, describe, expect, test } from "bun:test";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { parseDevMode, readDevMode, shouldAskDevMode, writeDevMode } from "./dev-mode.ts";
+
+const dirs: string[] = [];
+
+afterEach(async () => {
+  await Promise.all(dirs.splice(0).map((d) => rm(d, { recursive: true, force: true })));
+});
+
+async function tempDir(): Promise<string> {
+  const dir = await mkdtemp(join(tmpdir(), "oke-mode-"));
+  dirs.push(dir);
+  return dir;
+}
+
+describe("dev-mode", () => {
+  test("parseDevMode accepts local|docker only", () => {
+    expect(parseDevMode("local")).toBe("local");
+    expect(parseDevMode(" docker \n")).toBe("docker");
+    expect(parseDevMode("stack")).toBeNull();
+    expect(parseDevMode(undefined)).toBeNull();
+  });
+
+  test("read/write round-trip", async () => {
+    const dir = await tempDir();
+    expect(await readDevMode(dir)).toBeNull();
+    await writeDevMode(dir, "docker");
+    expect(await readDevMode(dir)).toBe("docker");
+  });
+
+  test("shouldAskDevMode: TTY + unset → ask; non-TTY → never", () => {
+    expect(shouldAskDevMode({ saved: null, explicit: false, stdinIsTTY: true })).toBe(true);
+    expect(shouldAskDevMode({ saved: null, explicit: false, stdinIsTTY: false })).toBe(false);
+    expect(shouldAskDevMode({ saved: null, explicit: false, stdinIsTTY: undefined })).toBe(false);
+    expect(shouldAskDevMode({ saved: "local", explicit: false, stdinIsTTY: true })).toBe(false);
+    expect(shouldAskDevMode({ saved: null, explicit: true, stdinIsTTY: true })).toBe(false);
+  });
+});

package/src/cli/dev-mode.ts

@@ -0,0 +1,78 @@
+/**
+ * Persisted `oke dev` run mode — `local` vs `docker`.
+ */
+
+import { mkdir } from "node:fs/promises";
+import { join, resolve } from "node:path";
+
+/** Saved / selectable `oke dev` infrastructure mode. */
+export type DevMode = "local" | "docker";
+
+/** Relative path under the project root. */
+export const DEV_MODE_RELATIVE_PATH = ".oke/mode";
+
+/**
+ * Absolute path to the mode preference file.
+ *
+ * @param cwd - Project root
+ */
+export function devModePath(cwd: string): string {
+  return resolve(cwd, DEV_MODE_RELATIVE_PATH);
+}
+
+/**
+ * Parse a raw mode string.
+ *
+ * @param raw - File contents or CLI arg
+ */
+export function parseDevMode(raw: string | undefined | null): DevMode | null {
+  if (raw === undefined || raw === null) return null;
+  const value = raw.trim().toLowerCase();
+  if (value === "local" || value === "docker") return value;
+  return null;
+}
+
+/**
+ * Read the saved mode from `.oke/mode`, or `null` when unset / invalid.
+ *
+ * @param cwd - Project root
+ */
+export async function readDevMode(cwd: string): Promise<DevMode | null> {
+  const path = devModePath(cwd);
+  const file = Bun.file(path);
+  if (!(await file.exists())) return null;
+  try {
+    return parseDevMode(await file.text());
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Persist the preferred mode for future `oke dev` invocations.
+ *
+ * @param cwd - Project root
+ * @param mode - Mode to save
+ */
+export async function writeDevMode(cwd: string, mode: DevMode): Promise<void> {
+  const path = devModePath(cwd);
+  await mkdir(join(cwd, ".oke"), { recursive: true });
+  await Bun.write(path, `${mode}\n`);
+}
+
+/**
+ * Whether `oke dev` should open the one-time mode prompt.
+ *
+ * Mirrors create-oke: never prompt when stdin is not a TTY.
+ *
+ * @param options - Preference + TTY + explicit flag
+ */
+export function shouldAskDevMode(options: {
+  readonly saved: DevMode | null;
+  readonly explicit: boolean;
+  readonly stdinIsTTY: boolean | undefined;
+}): boolean {
+  if (options.explicit) return false;
+  if (options.saved !== null) return false;
+  return Boolean(options.stdinIsTTY);
+}

package/src/cli/dev-schema-sync.test.ts

@@ -0,0 +1,66 @@
+/**
+ * Mode-switch schema sync pipeline — ensure → emit → push, no data copy.
+ */
+
+import { afterEach, describe, expect, test } from "bun:test";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { ConfigEnv } from "../config/index.ts";
+import { sqlDialectForEnv, syncDevSchema } from "./dev-schema-sync.ts";
+
+const dirs: string[] = [];
+
+afterEach(async () => {
+  await Promise.all(dirs.splice(0).map((d) => rm(d, { recursive: true, force: true })));
+});
+
+async function tempDir(): Promise<string> {
+  const dir = await mkdtemp(join(tmpdir(), "oke-sync-"));
+  dirs.push(dir);
+  return dir;
+}
+
+describe("sqlDialectForEnv", () => {
+  test("local → sqlite, docker → postgresql", async () => {
+    const config = {
+      drivers: {
+        store: { sql: { local: "sqlite", docker: "postgres", prod: "postgres", test: "memory" } },
+      },
+    } as never;
+    expect(sqlDialectForEnv(config, "local").dialect).toBe("sqlite");
+    expect(sqlDialectForEnv(config, "docker").dialect).toBe("postgresql");
+  });
+
+  test("missing config → sqlite default", () => {
+    expect(sqlDialectForEnv(null, "local").dialect).toBe("sqlite");
+  });
+});
+
+describe("syncDevSchema", () => {
+  test("local: ensures drizzle config, emits, pushes with env", async () => {
+    const dir = await tempDir();
+    const calls: { cwd: string; env: ConfigEnv }[] = [];
+    const result = await syncDevSchema(dir, "local", {
+      write: () => {},
+      pushFn: async (cwd, env) => {
+        calls.push({ cwd, env });
+        return 0;
+      },
+    });
+    expect(result.dialect).toBe("sqlite");
+    expect(result.pushed).toBe(true);
+    expect(calls).toEqual([{ cwd: dir, env: "local" }]);
+    expect(await Bun.file(join(dir, "drizzle.config.ts")).exists()).toBe(true);
+  });
+
+  test("push failure surfaces code without throwing", async () => {
+    const dir = await tempDir();
+    const result = await syncDevSchema(dir, "local", {
+      write: () => {},
+      pushFn: async () => 1,
+    });
+    expect(result.pushed).toBe(false);
+    expect(result.code).toBe(1);
+  });
+});

package/src/cli/dev-schema-sync.ts

@@ -0,0 +1,139 @@
+/**
+ * Shared local↔docker schema sync pipeline for `oke mode` and `oke dev`
+ * one-shot start. Ensures artefacts, emits for the active dialect, then
+ * pushes via drizzle-kit. Data planes stay isolated — no row copying.
+ */
+
+import { resolve } from "node:path";
+import { resolveDriverId, type ConfigEnv, type OkeConfig } from "../config/index.ts";
+import {
+  DEFAULT_DOCKER_DIR,
+  deriveInfrastructure,
+  loadExistingStackControls,
+  loadExistingStackCredentials,
+  stackAppSlug,
+  stackInstanceId,
+  writeDerivedFiles,
+} from "../docker/index.ts";
+import { drizzleDialectFromSqlDriver } from "../drivers/drizzle-dialect.ts";
+import { ensureDrizzleConfig } from "./ensure-drizzle-config.ts";
+import { runDb } from "./db.ts";
+import { loadOkeConfig, resolveImages } from "./load-config.ts";
+
+/** Options for {@link syncDevSchema}. */
+export interface DevSchemaSyncOptions {
+  /** Write output (default: stdout). */
+  readonly write?: (text: string) => void;
+  /** Skip emitting `schema.generated.ts` (tests). */
+  readonly skipEmit?: boolean;
+  /** Injectable push (tests). Default: `runDb("push", ...)`. */
+  readonly pushFn?: (cwd: string, env: ConfigEnv) => Promise<number>;
+  /** Derive docker infra without running compose (tests). */
+  readonly dryRun?: boolean;
+}
+
+/** Outcome of {@link syncDevSchema}. */
+export interface DevSchemaSyncResult {
+  readonly env: ConfigEnv;
+  readonly dialect: "sqlite" | "postgresql";
+  readonly pushed: boolean;
+  readonly code: number;
+}
+
+/**
+ * Resolve the SQL driver id + drizzle dialect for an env from config.
+ *
+ * @param config - Loaded oke config
+ * @param env - Active env
+ */
+export function sqlDialectForEnv(
+  config: OkeConfig | null | undefined,
+  env: ConfigEnv,
+): { readonly driverId: string; readonly dialect: "sqlite" | "postgresql" } {
+  const driverId = resolveDriverId(config?.drivers?.store?.sql, env) ?? "sqlite";
+  if (driverId !== "sqlite" && driverId !== "postgres") {
+    throw new Error(
+      `store.sql driver "${driverId}" is not supported by drizzle-kit (sqlite | postgres)`,
+    );
+  }
+  return { driverId, dialect: drizzleDialectFromSqlDriver(driverId) };
+}
+
+/**
+ * Ensure docker compose artefacts + credentials exist. Fails loudly with a
+ * clear hint when images are not configured (no silent retry loop).
+ *
+ * @param cwd - Project root
+ * @param config - Loaded oke config
+ * @param write - Output
+ */
+async function ensureDockerStack(
+  cwd: string,
+  config: OkeConfig,
+  write: (text: string) => void,
+): Promise<void> {
+  const images = resolveImages(config);
+  if (Object.keys(images).length === 0) {
+    throw new Error(
+      "docker mode: no images configured — set `images` in oke.config.ts (or prod drivers postgres/redis for defaults)",
+    );
+  }
+  const roles = Object.keys(images);
+  const instanceId = stackInstanceId(cwd);
+  const appSlug = stackAppSlug(cwd);
+  const credentials = await loadExistingStackCredentials(cwd, roles);
+  const controls = await loadExistingStackControls(cwd);
+  const derived = deriveInfrastructure({
+    images,
+    app: appSlug,
+    prod: false,
+    includeApp: false,
+    composeDir: DEFAULT_DOCKER_DIR,
+    instanceId,
+    ...(credentials ? { credentials } : {}),
+    ...(controls ? { controls } : {}),
+    host: "127.0.0.1",
+  });
+  await writeDerivedFiles(derived, resolve(cwd, DEFAULT_DOCKER_DIR), { writeStackEnv: true });
+  write(
+    "oke: docker compose env ready under docker/.env.docker (start containers with `oke dev -d` or docker compose up)\n",
+  );
+}
+
+/**
+ * Ensure artefacts, emit for the active dialect, and push schema for an env.
+ * Returns a one-line summary outcome. Docker mode also ensures compose env
+ * exists (writes `docker/.env.docker`) before pushing to the live DB.
+ *
+ * @param cwd - Project root
+ * @param env - Target env (`local` | `docker`)
+ * @param options - Injectables
+ */
+export async function syncDevSchema(
+  cwd: string,
+  env: ConfigEnv,
+  options: DevSchemaSyncOptions = {},
+): Promise<DevSchemaSyncResult> {
+  const write = options.write ?? ((t) => process.stdout.write(t));
+  const loaded = await loadOkeConfig(cwd).catch(() => null);
+  const config = loaded?.config;
+
+  await ensureDrizzleConfig(cwd);
+
+  const { dialect } = sqlDialectForEnv(config, env);
+
+  if (env === "docker") {
+    if (!config) {
+      throw new Error("docker mode: oke.config.ts not found");
+    }
+    await ensureDockerStack(cwd, config, write);
+  }
+
+  const push =
+    options.pushFn ??
+    (async (projectCwd, envArg) =>
+      runDb("push", { cwd: projectCwd, env: envArg, write, skipEmit: options.skipEmit }));
+
+  const code = await push(cwd, env);
+  return { env, dialect, pushed: code === 0, code };
+}