create-oke 0.10.2 → 0.11.0

package/src/drivers-catalog.ts

@@ -4,6 +4,9 @@
  * Never lists ids that fail loud at boot (signal postgres/nats,
  * ai bedrock/vertex). Clock + journal `postgres` are real (SKIP LOCKED
  * CronStore / durable-run journal).
+ *
+ * Docker-first: `dev`/`prod` share compose-backed protocols; `test` uses
+ * PGLite for SQL and memory drivers elsewhere. SQLite is not offered.
  */
 
 import type { CreateDefaults, CreateProfile, EnvDriverPins } from "./create-defaults.ts";
@@ -15,31 +18,21 @@ export type DriverChoice = {
   readonly label: string;
 };
 
-/** Standard template docker/prod pins (unchanged for local-only profile). */
-export const TEMPLATE_DOCKER_PROD = {
+/** Template `dev`/`prod` pins (Docker Compose runtime). */
+export const TEMPLATE_DEV = {
   sql: "postgres",
   kv: "redis",
   files: "s3",
   signal: "redis",
   clock: "postgres",
-  vault: "openbao",
+  /** Built-in encrypted-at-rest store — SQL-backed, so no extra container. */
+  vault: "vault",
   email: "smtp",
 } as const;
 
-/** Standard template local defaults. */
-export const TEMPLATE_LOCAL = {
-  sql: "sqlite",
-  kv: "memory",
-  files: "fs",
-  signal: "memory",
-  clock: "memory",
-  vault: "env",
-  email: "console",
-} as const;
-
-/** Test-column defaults (always applied). */
+/** Test-column defaults (PGLite for SQL — not a customize choice). */
 export const TEMPLATE_TEST = {
-  sql: "memory",
+  sql: "pglite",
   kv: "memory",
   files: "memory",
   signal: "memory",
@@ -48,11 +41,11 @@ export const TEMPLATE_TEST = {
   email: "console",
 } as const;
 
+/** @deprecated Use {@link TEMPLATE_DEV}. */
+export const TEMPLATE_DOCKER_PROD = TEMPLATE_DEV;
+
 export const SQL_CHOICES: readonly DriverChoice[] = [
-  { value: "sqlite", label: "sqlite" },
   { value: "postgres", label: "postgres" },
-  { value: "libsql", label: "libsql" },
-  { value: "pglite", label: "pglite" },
   { value: "memory", label: "memory" },
 ];
 
@@ -71,7 +64,6 @@ export const INDEX_CHOICES: readonly DriverChoice[] = [
   { value: "none", label: "none" },
   { value: "memory", label: "memory" },
   { value: "pgvector", label: "pgvector" },
-  { value: "libsql", label: "libsql" },
   { value: "meilisearch", label: "meilisearch" },
 ];
 
@@ -93,11 +85,17 @@ export const JOURNAL_CHOICES: readonly DriverChoice[] = [
   { value: "postgres", label: "postgres" },
 ];
 
+/**
+ * Vault backends. `vault` is okengine's own encrypted-at-rest store: it lives
+ * in the app's Postgres, so it needs no extra container, and it is the only
+ * backend with `oke vault init` / `seal` / `audit`. `managed` reads from a
+ * provider secret store (e.g. AWS Secrets Manager).
+ */
 export const VAULT_CHOICES: readonly DriverChoice[] = [
-  { value: "env", label: "env" },
-  { value: "openbao", label: "openbao" },
-  { value: "managed", label: "managed" },
-  { value: "memory", label: "memory" },
+  { value: "env", label: "env (dotenv layers only)" },
+  { value: "vault", label: "vault (built-in, encrypted at rest — recommended)" },
+  { value: "managed", label: "managed (KMS / provider secret store)" },
+  { value: "memory", label: "memory (test)" },
 ];
 
 /** Email driver ids for `drivers.channel.email` (SMS/WhatsApp/push are other mediums). */
@@ -140,31 +138,30 @@ export const AI_PROVIDERS = [
 export type AiProviderId = (typeof AI_PROVIDERS)[number]["value"];
 
 /**
- * Build env pins for local-only: user local + template docker/prod + test.
+ * Build `{ dev, test, prod }` pins (prod mirrors dev).
  *
- * @param local - Chosen local driver
- * @param dockerProd - Template docker/prod pin for this facet
+ * @param dev - Dev (Compose) driver
  * @param test - Test pin
+ * @param prod - Prod pin (defaults to `dev`)
  */
-export function pinsLocalOnly(local: string, dockerProd: string, test: string): EnvDriverPins {
-  return { local, docker: dockerProd, test, prod: dockerProd };
+export function pinsEnv(dev: string, test: string, prod: string = dev): EnvDriverPins {
+  return { dev, test, prod };
 }
 
 /**
- * Build env pins when the user chose both columns (docker-ready).
+ * Docker-ready pins — `dev`/`prod` share the chosen driver; `test` is separate.
  *
- * @param local - Local driver
- * @param docker - Docker driver (also copied to prod)
+ * @param dev - Dev/prod driver
  * @param test - Test pin
  */
-export function pinsDockerReady(local: string, docker: string, test: string): EnvDriverPins {
-  return { local, docker, test, prod: docker };
+export function pinsDockerReady(dev: string, test: string): EnvDriverPins {
+  return pinsEnv(dev, test, dev);
 }
 
 /**
  * Default recommended create-defaults (matches template driver maps).
  *
- * @param profile - Profile assumption
+ * @param profile - Always docker-ready (kept for call-site compat)
  * @param template - Starter id
  */
 export function recommendedDefaults(
@@ -172,9 +169,9 @@ export function recommendedDefaults(
   template: TemplateId = "standard",
 ): CreateDefaults {
   const store = {
-    sql: pinsLocalOnly(TEMPLATE_LOCAL.sql, TEMPLATE_DOCKER_PROD.sql, TEMPLATE_TEST.sql),
-    kv: pinsLocalOnly(TEMPLATE_LOCAL.kv, TEMPLATE_DOCKER_PROD.kv, TEMPLATE_TEST.kv),
-    files: pinsLocalOnly(TEMPLATE_LOCAL.files, TEMPLATE_DOCKER_PROD.files, TEMPLATE_TEST.files),
+    sql: pinsDockerReady(TEMPLATE_DEV.sql, TEMPLATE_TEST.sql),
+    kv: pinsDockerReady(TEMPLATE_DEV.kv, TEMPLATE_TEST.kv),
+    files: pinsDockerReady(TEMPLATE_DEV.files, TEMPLATE_TEST.files),
     index: null as EnvDriverPins | null,
   };
   return {
@@ -183,19 +180,17 @@ export function recommendedDefaults(
     profile,
     drivers: {
       store,
-      signal: pinsLocalOnly(
-        TEMPLATE_LOCAL.signal,
-        TEMPLATE_DOCKER_PROD.signal,
-        TEMPLATE_TEST.signal,
-      ),
-      clock: pinsLocalOnly(TEMPLATE_LOCAL.clock, TEMPLATE_DOCKER_PROD.clock, TEMPLATE_TEST.clock),
-      vault: pinsLocalOnly(TEMPLATE_LOCAL.vault, TEMPLATE_DOCKER_PROD.vault, TEMPLATE_TEST.vault),
+      signal: pinsDockerReady(TEMPLATE_DEV.signal, TEMPLATE_TEST.signal),
+      clock: pinsDockerReady(TEMPLATE_DEV.clock, TEMPLATE_TEST.clock),
+      vault: pinsDockerReady(TEMPLATE_DEV.vault, TEMPLATE_TEST.vault),
       channel: {
-        email: pinsLocalOnly(TEMPLATE_LOCAL.email, TEMPLATE_DOCKER_PROD.email, TEMPLATE_TEST.email),
+        email: pinsDockerReady(TEMPLATE_DEV.email, TEMPLATE_TEST.email),
       },
       ai: null,
     },
     ai: { enabled: false, provider: null, driver: null },
+    locales: [],
+    pgdog: false,
     updatedAt: new Date().toISOString(),
   };
 }
@@ -212,7 +207,7 @@ export type CustomizeFacetId =
   | "email";
 
 /**
- * Facets shown for a template (AI is asked after both env passes).
+ * Facets shown for a template (AI is asked after the env pass).
  *
  * @param template - Starter id
  */
@@ -238,7 +233,6 @@ export const DEFAULT_IMAGES: Readonly<Record<string, string>> = {
   "store.kv": "redis:8-alpine",
   "store.files": "rustfs/rustfs:1.0.0-beta.11",
   "channel.email": "axllent/mailpit:v1.22.3",
-  vault: "openbao/openbao:2.6.1",
   "store.index": "getmeili/meilisearch:v1.37",
   ai: LLAMA_CPP_IMAGE,
 };

package/src/local-okengine.test.ts

@@ -10,50 +10,59 @@ import { resolveLocalOkengineRoot } from "./templates.ts";
 import { resolveOkengineDependency } from "./transform.ts";
 
 describe("materializeLocalOkengineDependency", () => {
-  test("stages publish-shaped package without workspaces or devDependencies", () => {
-    const root = resolveLocalOkengineRoot();
-    expect(root).not.toBeNull();
-    if (!root) return;
+  // Cold `bun install` into ~/.oke can exceed the default 5s under full-suite load.
+  test(
+    "stages publish-shaped package without workspaces or devDependencies",
+    () => {
+      const root = resolveLocalOkengineRoot();
+      expect(root).not.toBeNull();
+      if (!root) return;
 
-    const dep = materializeLocalOkengineDependency(root);
-    const stage = localOkengineStageDir();
-    expect(dep).toBe(`file:${stage}`);
+      const dep = materializeLocalOkengineDependency(root);
+      const stage = localOkengineStageDir();
+      expect(dep).toBe(`file:${stage}`);
 
-    const pkg = JSON.parse(readFileSync(join(stage, "package.json"), "utf8")) as {
-      name: string;
-      dependencies?: Record<string, string>;
-      devDependencies?: unknown;
-      workspaces?: unknown;
-      peerDependencies?: Record<string, string>;
-      exports?: Record<string, string>;
-    };
-    expect(pkg.name).toBe("okengine");
-    expect(pkg.devDependencies).toBeUndefined();
-    expect(pkg.workspaces).toBeUndefined();
-    expect(pkg.peerDependencies).toBeUndefined();
-    expect(pkg.dependencies?.["oxc-parser"]).toBeDefined();
-    // Peers folded into dependencies so the out-of-tree stage can resolve them.
-    expect(pkg.dependencies?.["drizzle-orm"]).toBe("1.0.0-rc.4");
-    expect(pkg.dependencies?.["drizzle-kit"]).toBe("1.0.0-rc.4");
-    expect(pkg.dependencies?.["zod"]).toBeDefined();
-    expect(pkg.exports?.["./config"]).toBe("./src/config/index.ts");
+      const pkg = JSON.parse(readFileSync(join(stage, "package.json"), "utf8")) as {
+        name: string;
+        dependencies?: Record<string, string>;
+        devDependencies?: unknown;
+        workspaces?: unknown;
+        peerDependencies?: Record<string, string>;
+        exports?: Record<string, string>;
+      };
+      expect(pkg.name).toBe("okengine");
+      expect(pkg.devDependencies).toBeUndefined();
+      expect(pkg.workspaces).toBeUndefined();
+      expect(pkg.peerDependencies).toBeUndefined();
+      expect(pkg.dependencies?.["oxc-parser"]).toBeDefined();
+      // Peers folded into dependencies so the out-of-tree stage can resolve them.
+      expect(pkg.dependencies?.["drizzle-orm"]).toBe("1.0.0-rc.4");
+      expect(pkg.dependencies?.["drizzle-kit"]).toBe("1.0.0-rc.4");
+      expect(pkg.dependencies?.["zod"]).toBeDefined();
+      expect(pkg.exports?.["./config"]).toBe("./src/config/index.ts");
 
-    // Real copies — Bun file: install drops directory symlinks.
-    const src = join(stage, "src");
-    expect(existsSync(src)).toBe(true);
-    expect(lstatSync(src).isSymbolicLink()).toBe(false);
-    expect(existsSync(join(stage, "src/config/index.ts"))).toBe(true);
-    expect(existsSync(join(stage, "node_modules", "zod"))).toBe(true);
-    expect(existsSync(join(stage, "node_modules", "drizzle-kit", "cli.mjs"))).toBe(true);
-  });
+      // Real copies — Bun file: install drops directory symlinks.
+      const src = join(stage, "src");
+      expect(existsSync(src)).toBe(true);
+      expect(lstatSync(src).isSymbolicLink()).toBe(false);
+      expect(existsSync(join(stage, "src/config/index.ts"))).toBe(true);
+      expect(existsSync(join(stage, "node_modules", "zod"))).toBe(true);
+      expect(existsSync(join(stage, "node_modules", "drizzle-kit", "cli.mjs"))).toBe(true);
+    },
+    { timeout: 60_000 },
+  );
 
-  test("resolveOkengineDependency uses the staged file: path locally", () => {
-    const root = resolveLocalOkengineRoot();
-    expect(root).not.toBeNull();
-    if (!root) return;
+  test(
+    "resolveOkengineDependency uses the staged file: path locally",
+    () => {
+      const root = resolveLocalOkengineRoot();
+      expect(root).not.toBeNull();
+      if (!root) return;
 
-    const dep = resolveOkengineDependency(root);
-    expect(dep).toBe(`file:${localOkengineStageDir()}`);
-    expect(dep).not.toBe(`file:${root}`);
-  });
+      const dep = resolveOkengineDependency(root);
+      expect(dep).toBe(`file:${localOkengineStageDir()}`);
+      expect(dep).not.toBe(`file:${root}`);
+    },
+    { timeout: 60_000 },
+  );
 });

package/src/local-okengine.ts

@@ -95,9 +95,19 @@ export function materializeLocalOkengineDependency(localOkengineRoot: string): s
   };
 
   const stage = localOkengineStageDir();
-  rmSync(stage, { recursive: true, force: true });
-  mkdirSync(stage, { recursive: true });
-  writeFileSync(join(stage, "package.json"), `${JSON.stringify(consumer, null, 2)}\n`, "utf8");
+  const pkgBody = `${JSON.stringify(consumer, null, 2)}\n`;
+  const stagePkgPath = join(stage, "package.json");
+  const stageReady =
+    existsSync(join(stage, "node_modules", "zod")) &&
+    existsSync(join(stage, "node_modules", "drizzle-kit", "cli.mjs")) &&
+    existsSync(stagePkgPath) &&
+    readFileSync(stagePkgPath, "utf8") === pkgBody;
+
+  if (!stageReady) {
+    rmSync(stage, { recursive: true, force: true });
+    mkdirSync(stage, { recursive: true });
+    writeFileSync(stagePkgPath, pkgBody, "utf8");
+  }
 
   const entries =
     consumer.files && consumer.files.length > 0
@@ -109,20 +119,24 @@ export function materializeLocalOkengineDependency(localOkengineRoot: string): s
     if (!existsSync(from)) continue;
     const to = join(stage, rel);
     mkdirSync(dirname(to), { recursive: true });
+    // Refresh publish files every call so scaffold always sees current source.
+    rmSync(to, { recursive: true, force: true });
     cpSync(from, to, { recursive: true, dereference: true });
   }
 
-  const install = Bun.spawnSync({
-    cmd: ["bun", "install"],
-    cwd: stage,
-    stdout: "pipe",
-    stderr: "pipe",
-  });
-  if (install.exitCode !== 0) {
-    const err = new TextDecoder().decode(install.stderr).trim();
-    throw new Error(
-      `create-oke: bun install failed in local okengine stage${err ? `\n${err}` : ""}`,
-    );
+  if (!stageReady) {
+    const install = Bun.spawnSync({
+      cmd: ["bun", "install"],
+      cwd: stage,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    if (install.exitCode !== 0) {
+      const err = new TextDecoder().decode(install.stderr).trim();
+      throw new Error(
+        `create-oke: bun install failed in local okengine stage${err ? `\n${err}` : ""}`,
+      );
+    }
   }
 
   return `file:${stage}`;

package/src/locales.test.ts

@@ -0,0 +1,128 @@
+/**
+ * Locale parsing + scaffold apply helpers.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync, mkdirSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  applyLocalesToProject,
+  formatI18nConfig,
+  formatLocalesIndex,
+  parseExtraLocales,
+  replaceI18nConfig,
+  stripLegacyAppLocaleImports,
+} from "./locales.ts";
+
+describe("parseExtraLocales", () => {
+  test("parses ar and ar,fr", () => {
+    expect(parseExtraLocales("ar")).toEqual(["ar"]);
+    expect(parseExtraLocales("ar,fr")).toEqual(["ar", "fr"]);
+    expect(parseExtraLocales(" AR ; fr ")).toEqual(["ar", "fr"]);
+  });
+
+  test("drops en and duplicates", () => {
+    expect(parseExtraLocales("en,ar,en,ar")).toEqual(["ar"]);
+  });
+
+  test("rejects empty / invalid", () => {
+    expect(parseExtraLocales("")).toBeNull();
+    expect(parseExtraLocales("1ar")).toBeNull();
+  });
+});
+
+describe("formatI18nConfig", () => {
+  test("English-only omits dir", () => {
+    expect(formatI18nConfig(["en"])).toBe('i18n: { locales: ["en"], default: "en" }');
+  });
+
+  test("Arabic adds rtl dir", () => {
+    expect(formatI18nConfig(["en", "ar"])).toBe(
+      'i18n: { locales: ["en", "ar"], default: "en", dir: { "ar": "rtl" } }',
+    );
+  });
+});
+
+describe("formatLocalesIndex", () => {
+  test("lists en then extras as relative imports", () => {
+    const src = formatLocalesIndex(["en", "ar", "fr"]);
+    expect(src).toContain('import "./en";');
+    expect(src).toContain('import "./ar";');
+    expect(src).toContain('import "./fr";');
+    expect(src.match(/import "\.\//g)?.length).toBe(3);
+  });
+});
+
+describe("stripLegacyAppLocaleImports", () => {
+  test("removes @/ and ./ per-locale imports", () => {
+    const src = `import "@/core";
+import "@/locales/en";
+import "./locales/ar";
+
+import { oke } from "okengine/http";
+`;
+    const next = stripLegacyAppLocaleImports(src);
+    expect(next).not.toContain('import "@/locales/');
+    expect(next).not.toContain('import "./locales/');
+    expect(next).toContain('import "@/core";');
+    expect(next).toContain('import { oke } from "okengine/http";');
+  });
+});
+
+describe("replaceI18nConfig", () => {
+  test("replaces nested dir block", () => {
+    const src = `export default defineConfig({
+  i18n: { locales: ["en", "ar"], default: "en", dir: { ar: "rtl" } },
+});
+`;
+    const next = replaceI18nConfig(src, ["en"]);
+    expect(next).toContain('i18n: { locales: ["en"], default: "en" }');
+    expect(next).not.toContain("dir:");
+  });
+});
+
+describe("applyLocalesToProject", () => {
+  test("adds ar + fr files and updates locales index", () => {
+    const dir = mkdtempSync(join(tmpdir(), "oke-locales-"));
+    try {
+      mkdirSync(join(dir, "src/locales"), { recursive: true });
+      mkdirSync(join(dir, "src"), { recursive: true });
+      writeFileSync(
+        join(dir, "oke.config.ts"),
+        `export default defineConfig({\n  i18n: { locales: ["en"], default: "en" },\n});\n`,
+        "utf8",
+      );
+      writeFileSync(
+        join(dir, "src/app.ts"),
+        `import "@/core";\n\nexport const app = {};\n`,
+        "utf8",
+      );
+      writeFileSync(
+        join(dir, "src/core.ts"),
+        `export const noteCreatedMail = mail.template("note-created", {\n  locales: ["en"],\n});\n`,
+        "utf8",
+      );
+      writeFileSync(join(dir, "src/locales/en.ts"), "export const en = {};\n", "utf8");
+      writeFileSync(join(dir, "src/locales/index.ts"), formatLocalesIndex(["en"]), "utf8");
+
+      applyLocalesToProject(dir, ["ar", "fr"]);
+
+      expect(readFileSync(join(dir, "oke.config.ts"), "utf8")).toContain('"ar"');
+      expect(readFileSync(join(dir, "oke.config.ts"), "utf8")).toContain('"fr"');
+      expect(readFileSync(join(dir, "oke.config.ts"), "utf8")).toContain('"ar": "rtl"');
+      const index = readFileSync(join(dir, "src/locales/index.ts"), "utf8");
+      expect(index).toContain('import "./en";');
+      expect(index).toContain('import "./ar";');
+      expect(index).toContain('import "./fr";');
+      expect(readFileSync(join(dir, "src/app.ts"), "utf8")).not.toContain('import "@/locales/');
+      expect(readFileSync(join(dir, "src/locales/ar.ts"), "utf8")).toContain("غير موجود");
+      expect(readFileSync(join(dir, "src/locales/fr.ts"), "utf8")).toContain("TODO: translate");
+      expect(readFileSync(join(dir, "src/core.ts"), "utf8")).toContain(
+        'locales: ["en", "ar", "fr"]',
+      );
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});