create-oke 0.2.6 → 0.3.2

package/README.md

@@ -8,52 +8,43 @@ cd my-app
 oke dev
 ```
 
-On a TTY, create-oke opens a Clack wizard: confirm name, pick a template, and
-optionally install + start `oke dev`. Pass `--yes` or `--template` /
-`--from-example` for non-interactive (CI / agents).
+On a TTY, create-oke opens a Clack wizard to confirm the name and optionally
+install dependencies and start `oke dev`. Pass `--yes` for non-interactive use.
 
-| Port | What |
-|---|---|
-| `:6530` | your app |
-| `:6533` | Console |
-| `:6535` | MCP |
+| Port    | What                |
+| ------- | ------------------- |
+| `:6530` | your app            |
+| `:6533` | Console             |
+| `:6535` | MCP (live Manifest) |
 
-Default template is **standard** (full recommended file layout, empty scaffolding).
-Pick another with `--template`, or start from a teaching example with `--from-example`:
+The single bundled template is **standard**: the full recommended file layout
+with empty scaffolding.
 
 ```bash
-bunx create-oke@latest my-app --template hello
-bunx create-oke@latest my-app --template minimal
-bunx create-oke@latest my-app --template full
+bunx create-oke@latest my-app --template standard
+bunx create-oke@latest my-app --sql postgres
 bunx create-oke@latest my-app --yes
-bunx create-oke@latest my-notes --from-example notes
 ```
 
-| Template | Purpose |
-|---|---|
-| `hello` | Fastest possible "it works" — one flow, no Store |
-| `minimal` | Smallest shape you'd actually ship — Store + 1–2 flows |
-| `standard` | Full recommended file layout, empty scaffolding (default) |
-| `full` | Every element present and wired, no business logic |
+`--sql sqlite|postgres` is opt-in. The default keeps the dual-mode Store
+config (`local: sqlite` · `docker`/`prod: postgres`) and abstract
+`src/schema.decl.ts` (dialect emitted from the active driver). Pass
+`--sql postgres` to pin `oke.config.ts` `store.sql` local/docker/prod to
+`postgres`. The interactive wizard does not ask and keeps the same dual-mode
+default.
+
+Store-bearing scaffolds ship `drizzle.config.ts` and `.env.example`. Local
+`oke dev` auto-runs `oke db push` on schema change; use `oke mode docker` /
+`oke dev --docker` for compose infra.
 
 Every scaffold writes an `AGENTS.md` so coding agents know the OKE contract
 (`--no-agents-md` to skip).
 
-`--from-example` copies a teaching example (including its business logic and
-comments) — most new projects want `--template` instead.
-
-| Example | Adds |
-|---|---|
-| `notes` | `oke` · `flow` · `http` · `store.sql` · typed client |
-| `linkly` | `signal` · `clock` · `gate` |
-| `provisions` | durable flows · `vault` · `channel` · plugins |
-| `skyport` | `ai` · multi-tenancy · distributed topology |
-
 ## Registries
 
-| Registry | Package |
-|---|---|
-| npm (CLI) | [`create-oke`](https://www.npmjs.com/package/create-oke) — use this with `bunx` |
-| JSR | [`@omqkhafi/create-oke`](https://jsr.io/@omqkhafi/create-oke) — same sources; prefer npm for the binary |
+| Registry  | Package                                                                                                 |
+| --------- | ------------------------------------------------------------------------------------------------------- |
+| npm (CLI) | [`create-oke`](https://www.npmjs.com/package/create-oke) — use this with `bunx`                         |
+| JSR       | [`@omqkhafi/create-oke`](https://jsr.io/@omqkhafi/create-oke) — same sources; prefer npm for the binary |
 
-Requires **Bun ≥ 1.3**. Docs: [okengine.vercel.app](https://okengine.vercel.app) · [handbook](https://okengine.vercel.app/docs) · [unified theory](https://github.com/omqkhafi/okengine/blob/main/docs/spec/unified-theory.md).
+Requires **Bun ≥ 1.3**. Docs: [oke.omqkhafi.dev](https://oke.omqkhafi.dev) · [handbook](https://oke.omqkhafi.dev/docs).

package/package.json

@@ -1,10 +1,8 @@
 {
   "name": "create-oke",
-  "version": "0.2.6",
+  "version": "0.3.2",
   "description": "Scaffold an okengine app — bunx create-oke@latest <name>",
   "license": "MIT",
-  "type": "module",
-  "sideEffects": false,
   "repository": {
     "type": "git",
     "url": "git+https://github.com/omqkhafi/okengine.git",
@@ -13,28 +11,28 @@
   "bin": {
     "create-oke": "src/index.ts"
   },
-  "exports": {
-    ".": "./src/index.ts"
-  },
   "files": [
     "src",
-    "templates",
-    "examples"
+    "template"
   ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": "./src/index.ts"
+  },
   "scripts": {
-    "prepack": "bun ./src/sync-templates.ts",
     "typecheck": "tsc --noEmit",
     "test": "bun test",
     "test:integration": "CREATE_OKE_INTEGRATION=1 bun test tests/scaffold.integration.test.ts tests/dev.integration.test.ts"
   },
-  "engines": {
-    "bun": ">=1.3"
-  },
   "dependencies": {
     "@clack/prompts": "^1.7.0"
   },
   "devDependencies": {
     "@types/bun": "latest",
     "typescript": "^7.0.2"
+  },
+  "engines": {
+    "bun": ">=1.3"
   }
 }

package/src/cli.test.ts

@@ -3,17 +3,10 @@
  */
 
 import { describe, expect, test } from "bun:test";
-import {
-  existsSync,
-  mkdtempSync,
-  readFileSync,
-  readdirSync,
-  rmSync,
-} from "node:fs";
+import { existsSync, mkdtempSync, readFileSync, readdirSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import {
-  FROM_EXAMPLE_CHOICE,
   formatCdPath,
   nextStepsText,
   parseArgs,
@@ -25,18 +18,13 @@ import {
   type InteractiveAnswers,
 } from "./cli.ts";
 import { listTemplateFiles, scaffold } from "./scaffold.ts";
-import {
-  DEFAULT_TEMPLATE,
-  EXAMPLES,
-  TEMPLATES,
-  packageRoot,
-  resolveExampleDir,
-  resolveTemplateDir,
-} from "./templates.ts";
+import { DEFAULT_TEMPLATE, TEMPLATES, packageRoot, resolveTemplateDir } from "./templates.ts";
 import {
   sanitizeProjectName,
   shouldSkipTemplatePath,
+  transformConfigForSqlDriver,
   transformPackageJson,
+  transformSchemaForSqlDriver,
 } from "./transform.ts";
 
 describe("parseArgs", () => {
@@ -45,31 +33,27 @@ describe("parseArgs", () => {
     expect(a.name).toBe("my-app");
     expect(a.template).toBe("standard");
     expect(a.templateExplicit).toBe(false);
-    expect(a.fromExample).toBeUndefined();
   });
 
   test("accepts --template and -t", () => {
-    expect(parseArgs(["x", "--template", "hello"]).template).toBe("hello");
-    expect(parseArgs(["x", "-t", "full"]).template).toBe("full");
-    expect(parseArgs(["x", "--template=minimal"]).template).toBe("minimal");
-    expect(parseArgs(["x", "--template", "hello"]).templateExplicit).toBe(true);
+    expect(parseArgs(["x", "--template", "standard"]).template).toBe("standard");
+    expect(parseArgs(["x", "-t", "standard"]).template).toBe("standard");
+    expect(parseArgs(["x", "--template=standard"]).template).toBe("standard");
+    expect(parseArgs(["x", "--template", "standard"]).templateExplicit).toBe(true);
   });
 
-  test("accepts --from-example", () => {
-    expect(parseArgs(["x", "--from-example", "notes"]).fromExample).toBe(
-      "notes",
-    );
-    expect(parseArgs(["x", "--from-example=skyport"]).fromExample).toBe(
-      "skyport",
-    );
+  test("accepts --sql sqlite|postgres", () => {
+    expect(parseArgs(["x"]).sqlDriver).toBe("sqlite");
+    expect(parseArgs(["x"]).sqlDriverExplicit).toBe(false);
+    expect(parseArgs(["x", "--sql", "postgres"]).sqlDriver).toBe("postgres");
+    expect(parseArgs(["x", "--sql=sqlite"]).sqlDriver).toBe("sqlite");
+    expect(parseArgs(["x", "--sql", "postgres"]).sqlDriverExplicit).toBe(true);
   });
 
-  test("rejects unknown template / example / both", () => {
+  test("rejects unknown template, option, and sql", () => {
     expect(() => parseArgs(["x", "--template", "nope"])).toThrow(/template/);
-    expect(() => parseArgs(["x", "--from-example", "nope"])).toThrow(/example/);
-    expect(() =>
-      parseArgs(["x", "--template", "hello", "--from-example", "notes"]),
-    ).toThrow(/either/);
+    expect(() => parseArgs(["x", "--unknown"])).toThrow(/unknown option/);
+    expect(() => parseArgs(["x", "--sql", "mysql"])).toThrow(/sql/);
   });
 });
 
@@ -86,13 +70,8 @@ describe("shouldPrompt", () => {
     expect(shouldPrompt(parseArgs([]), false)).toBe(false);
     expect(shouldPrompt(parseArgs(["my-app"]), false)).toBe(false);
     expect(shouldPrompt(parseArgs(["my-app", "--yes"]), true)).toBe(false);
-    expect(shouldPrompt(parseArgs(["my-app", "--template", "hello"]), true)).toBe(
-      false,
-    );
-    expect(shouldPrompt(parseArgs(["--template", "hello"]), true)).toBe(false);
-    expect(shouldPrompt(parseArgs(["--from-example", "notes"]), true)).toBe(
-      false,
-    );
+    expect(shouldPrompt(parseArgs(["my-app", "--template", "standard"]), true)).toBe(false);
+    expect(shouldPrompt(parseArgs(["--template", "standard"]), true)).toBe(false);
     expect(shouldPrompt(parseArgs(["--help"]), true)).toBe(false);
   });
 });
@@ -108,17 +87,12 @@ describe("parseArgs flags", () => {
   });
 
   test("rejects --install with --no-install", () => {
-    expect(() => parseArgs(["x", "--install", "--no-install"])).toThrow(
-      /install/,
-    );
+    expect(() => parseArgs(["x", "--install", "--no-install"])).toThrow(/install/);
   });
 });
 
 describe("sourceFromArgs", () => {
-  test("prefers example when set", () => {
-    expect(sourceFromArgs(parseArgs(["x", "--from-example", "linkly"]))).toEqual(
-      { kind: "example", id: "linkly" },
-    );
+  test("uses the standard template", () => {
     expect(sourceFromArgs(parseArgs(["x"]))).toEqual({
       kind: "template",
       id: DEFAULT_TEMPLATE,
@@ -136,34 +110,29 @@ describe("scaffoldArgsFromAnswers ≡ flag-driven", () => {
         agentsMd: true,
       };
       const fromAnswers = scaffoldArgsFromAnswers(answers);
-      const fromFlags = scaffoldArgsFromCli(
-        parseArgs(["x", "--template", id]),
-      );
+      const fromFlags = scaffoldArgsFromCli(parseArgs(["x", "--template", id]));
       expect(fromAnswers).toEqual(fromFlags);
       expect(fromAnswers.source).toEqual({ kind: "template", id });
+      expect(fromAnswers.sqlDriver).toBe("sqlite");
     }
   });
 
-  test("each --from-example path matches interactive from-example choice", () => {
-    for (const id of EXAMPLES) {
-      const answers: InteractiveAnswers = {
-        name: "x",
-        choice: FROM_EXAMPLE_CHOICE,
-        example: id,
-        installAndRun: false,
-        agentsMd: true,
-      };
-      const fromAnswers = scaffoldArgsFromAnswers(answers);
-      const fromFlags = scaffoldArgsFromCli(
-        parseArgs(["x", "--from-example", id]),
-      );
-      expect(fromAnswers).toEqual(fromFlags);
-      expect(fromAnswers.source).toEqual({ kind: "example", id });
-    }
+  test("interactive never opts into --sql postgres (flag-only)", () => {
+    const answers: InteractiveAnswers = {
+      name: "x",
+      choice: "standard",
+      installAndRun: false,
+      agentsMd: true,
+    };
+    expect(scaffoldArgsFromAnswers(answers).sqlDriver).toBe("sqlite");
+    expect(
+      scaffoldArgsFromCli(parseArgs(["x", "--template", "standard", "--sql", "postgres"]))
+        .sqlDriver,
+    ).toBe("postgres");
   });
 
-  test("8 paths cover every template and every example", () => {
-    expect(TEMPLATES.length + EXAMPLES.length).toBe(8);
+  test("only standard is available", () => {
+    expect(TEMPLATES).toEqual(["standard"]);
   });
 });
 
@@ -171,7 +140,7 @@ describe("transformPackageJson", () => {
   test("rewrites name and okengine file:../.. to installable ref", () => {
     const next = transformPackageJson(
       {
-        name: "@oke/template-hello",
+        name: "@oke/template-standard",
         private: true,
         dependencies: {
           okengine: "file:../..",
@@ -189,11 +158,51 @@ describe("transformPackageJson", () => {
   });
 });
 
+describe("transformSchemaForSqlDriver", () => {
+  const sqliteSchema = `import { sqliteTable, text, integer } from "drizzle-orm/sqlite-core";
+export const pings = sqliteTable("pings", {});
+`;
+
+  test("postgres swaps dialect imports and table helper", () => {
+    const next = transformSchemaForSqlDriver(sqliteSchema, "postgres");
+    expect(next).toContain('from "drizzle-orm/pg-core"');
+    expect(next).toContain("pgTable(");
+    expect(next).not.toContain("sqliteTable");
+    expect(next).not.toContain("sqlite-core");
+  });
+
+  test("sqlite is idempotent on template sources", () => {
+    expect(transformSchemaForSqlDriver(sqliteSchema, "sqlite")).toBe(sqliteSchema);
+  });
+});
+
+describe("transformConfigForSqlDriver", () => {
+  const config = `export default defineConfig({
+  drivers: {
+    store: {
+      sql: {
+        local: "sqlite",
+        docker: "postgres",
+        test: "memory",
+        prod: "postgres",
+      },
+    },
+  },
+});
+`;
+
+  test("postgres pins local/docker/prod and leaves test memory", () => {
+    const next = transformConfigForSqlDriver(config, "postgres");
+    expect(next).toContain('local: "postgres"');
+    expect(next).toContain('docker: "postgres"');
+    expect(next).toContain('prod: "postgres"');
+    expect(next).toContain('test: "memory"');
+  });
+});
+
 describe("shouldSkipTemplatePath", () => {
   test("skips node_modules, locks, and monorepo docker test", () => {
-    expect(shouldSkipTemplatePath("node_modules/okengine/package.json")).toBe(
-      true,
-    );
+    expect(shouldSkipTemplatePath("node_modules/okengine/package.json")).toBe(true);
     expect(shouldSkipTemplatePath("bun.lock")).toBe(true);
     expect(shouldSkipTemplatePath("tests/docker.test.ts")).toBe(true);
     expect(shouldSkipTemplatePath("tests/support.test.ts")).toBe(false);
@@ -225,23 +234,23 @@ describe("scaffold structure", () => {
           name: `app-${id}`,
           source: { kind: "template", id },
         });
-        expect([...result.files].sort()).toEqual(
-          [...expected, "AGENTS.md"].sort(),
-        );
+        const extras = ["AGENTS.md"];
+        if (expected.includes(".env.example")) extras.push(".env.local");
+        expect([...result.files].sort()).toEqual([...expected, ...extras].sort());
         expect(result.files).toContain(".gitignore");
         expect(result.files).toContain("README.md");
-        expect(
-          readFileSync(join(result.targetDir, "AGENTS.md"), "utf8"),
-        ).toMatch(/one law|on\(Trigger\)/i);
+        expect(result.sqlDriver).toBe("sqlite");
+        expect(readFileSync(join(result.targetDir, "AGENTS.md"), "utf8")).toMatch(
+          /one law|on\(Trigger\)/i,
+        );
         const readme = readFileSync(join(result.targetDir, "README.md"), "utf8");
         expect(readme).toMatch(/oke dev/);
         expect(readme).toMatch(new RegExp(`^# ${id}`, "m"));
-        expect(
-          readFileSync(join(result.targetDir, ".gitignore"), "utf8"),
-        ).toMatch(/node_modules/);
-        const pkg = JSON.parse(
-          readFileSync(join(result.targetDir, "package.json"), "utf8"),
-        ) as { name: string; dependencies: { okengine: string } };
+        expect(readFileSync(join(result.targetDir, ".gitignore"), "utf8")).toMatch(/node_modules/);
+        const pkg = JSON.parse(readFileSync(join(result.targetDir, "package.json"), "utf8")) as {
+          name: string;
+          dependencies: { okengine: string };
+        };
         expect(pkg.name).toBe(`app-${id}`);
         expect(pkg.dependencies.okengine).not.toBe("file:../..");
       } finally {
@@ -250,37 +259,6 @@ describe("scaffold structure", () => {
     }
   });
 
-  test("hello has exactly one flow and no Store", () => {
-    const dir = mkdtempSync(join(tmpdir(), "create-oke-hello-assert-"));
-    try {
-      const result = scaffold({
-        targetDir: join(dir, "hello"),
-        name: "hello-app",
-        source: { kind: "template", id: "hello" },
-      });
-      const flowFiles = result.files.filter(
-        (f) => f.startsWith("src/flows/") && f.endsWith(".ts"),
-      );
-      expect(flowFiles).toEqual(["src/flows/hello/index.ts"]);
-      const flowSrc = readFileSync(
-        join(result.targetDir, "src/flows/hello/index.ts"),
-        "utf8",
-      );
-      expect(flowSrc).toMatch(/export const hello/);
-      expect(flowSrc).not.toMatch(/\bstore\b/);
-      expect(result.files.some((f) => f.includes("core.ts"))).toBe(false);
-      expect(result.files.some((f) => f.includes("schema.ts"))).toBe(false);
-      const all = result.files
-        .filter((f) => f.endsWith(".ts"))
-        .map((f) => readFileSync(join(result.targetDir, f), "utf8"))
-        .join("\n");
-      expect(all).not.toMatch(/store\.sql/);
-      expect(all).not.toMatch(/\bbookings\b|\borders\b|\blinks\b|\bnotes\b/);
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-
   test("standard has full four-applications layout and no business domain", () => {
     const dir = mkdtempSync(join(tmpdir(), "create-oke-standard-assert-"));
     try {
@@ -298,7 +276,7 @@ describe("scaffold structure", () => {
         "src/flows/main/shapes.ts",
         "src/flows/main/signals.ts",
         "src/core.ts",
-        "src/schema.ts",
+        "src/schema.decl.ts",
         "src/app.ts",
       ]) {
         expect(result.files).toContain(path);
@@ -313,20 +291,29 @@ describe("scaffold structure", () => {
     }
   });
 
-  test("--from-example notes matches today's example tree", () => {
-    const dir = mkdtempSync(join(tmpdir(), "create-oke-from-example-"));
+  test("--sql postgres pins store.sql (abstract schema stays dialect-agnostic)", () => {
+    const dir = mkdtempSync(join(tmpdir(), "create-oke-sql-pg-"));
     try {
-      const exampleDir = resolveExampleDir("notes");
-      const expected = listTemplateFiles(exampleDir);
       const result = scaffold({
-        targetDir: join(dir, "notes"),
-        name: "from-notes",
-        source: { kind: "example", id: "notes" },
+        targetDir: join(dir, "pg-app"),
+        name: "pg-app",
+        source: { kind: "template", id: "standard" },
+        sqlDriver: "postgres",
       });
-      expect([...result.files].sort()).toEqual(
-        [...expected, "AGENTS.md"].sort(),
-      );
-      expect(result.files).toContain("src/flows/notes/index.ts");
+      expect(result.sqlDriver).toBe("postgres");
+      // Abstract decl is dialect-agnostic — emit picks pgTable at sync time.
+      const decl = readFileSync(join(result.targetDir, "src/schema.decl.ts"), "utf8");
+      expect(decl).toContain("store.schema.table(");
+      expect(decl).not.toContain("sqliteTable");
+      expect(decl).not.toContain("pgTable");
+      const drizzle = readFileSync(join(result.targetDir, "drizzle.config.ts"), "utf8");
+      expect(drizzle).toContain("OKE_DRIZZLE_DIALECT");
+      expect(drizzle).toContain("schema.generated.ts");
+      const config = readFileSync(join(result.targetDir, "oke.config.ts"), "utf8");
+      expect(config).toMatch(/sql:\s*\{[\s\S]*local:\s*"postgres"/);
+      expect(config).toMatch(/sql:\s*\{[\s\S]*docker:\s*"postgres"/);
+      expect(config).toMatch(/sql:\s*\{[\s\S]*prod:\s*"postgres"/);
+      expect(config).toMatch(/sql:\s*\{[\s\S]*test:\s*"memory"/);
     } finally {
       rmSync(dir, { recursive: true, force: true });
     }
@@ -336,9 +323,9 @@ describe("scaffold structure", () => {
     const dir = mkdtempSync(join(tmpdir(), "create-oke-no-agents-"));
     try {
       const result = scaffold({
-        targetDir: join(dir, "hello"),
+        targetDir: join(dir, "standard"),
         name: "no-agents",
-        source: { kind: "template", id: "hello" },
+        source: { kind: "template", id: "standard" },
         writeAgentsMd: false,
       });
       expect(result.files).not.toContain("AGENTS.md");
@@ -376,34 +363,27 @@ describe("non-TTY CLI", () => {
     const root = mkdtempSync(join(tmpdir(), "create-oke-flag-"));
     const target = join(root, "flag-app");
     try {
-      const code = await run(
-        [target, "--template", "hello", "--no-install"],
-        { stdinIsTTY: false, runPostScaffold: false },
-      );
+      const code = await run([target, "--template", "standard", "--no-install"], {
+        stdinIsTTY: false,
+        runPostScaffold: false,
+      });
       expect(code).toBe(0);
       expect(readdirSync(target).length).toBeGreaterThan(0);
       expect(existsSync(join(target, "AGENTS.md"))).toBe(true);
       const result = {
         targetDir: target,
         name: "flag-app",
-        source: { kind: "template" as const, id: "hello" as const },
-        label: "hello",
+        source: { kind: "template" as const, id: "standard" as const },
+        label: "standard",
         okengineDependency: "x",
         files: [],
+        sqlDriver: "sqlite" as const,
       };
       expect(nextStepsText(result)).toContain("oke dev");
       expect(nextStepsText(result)).toContain("bun install");
-      expect(nextStepsText(result)).toContain("okengine.vercel.app");
+      expect(nextStepsText(result)).toContain("oke.omqkhafi.dev");
     } finally {
       rmSync(root, { recursive: true, force: true });
     }
   });
 });
-
-describe("examples catalogue", () => {
-  test("all four teaching examples resolve", () => {
-    for (const id of EXAMPLES) {
-      expect(resolveExampleDir(id)).toBeTruthy();
-    }
-  });
-});