create-oke 0.2.6 → 0.2.8

package/README.md

@@ -12,11 +12,11 @@ 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).
 
-| 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`:
@@ -25,16 +25,28 @@ Pick another with `--template`, or start from a teaching example with `--from-ex
 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 --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 |
+`--sql sqlite|postgres` is opt-in. The default keeps the dual-mode Store
+config (`local: sqlite` · `docker`/`prod: postgres`) and a `sqliteTable`
+schema. Pass `--sql postgres` to rewrite `src/schema.ts` to `pgTable` /
+`drizzle-orm/pg-core` and pin `oke.config.ts` `store.sql` local/docker/prod to
+`postgres`. The interactive wizard does not ask — same dual-mode default
+(skipped entirely for `hello`, which has no Store).
+
+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.
+
+| 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 |
+| `full`     | Every element present and wired, no business logic        |
 
 Every scaffold writes an `AGENTS.md` so coding agents know the OKE contract
 (`--no-agents-md` to skip).
@@ -42,18 +54,18 @@ Every scaffold writes an `AGENTS.md` so coding agents know the OKE contract
 `--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 |
+| Example      | Adds                                                 |
+| ------------ | ---------------------------------------------------- |
+| `notes`      | `oke` · `flow` · `http` · `store.sql` · typed client |
+| `linkly`     | `signal` · `clock` · `gate` · abstract `schema.decl` |
+| `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).

package/examples/linkly/.env.example

@@ -0,0 +1,15 @@
+# Environment template — copy to `.env.local` for local overrides.
+# create-oke copies this file to `.env.local` when you scaffold a new project.
+#
+# Resolution order (first hit wins):
+#   process.env → .env.local → docker/.env.docker → vault driver → dev fallback
+#
+# --- Infrastructure (optional) ---
+# This app pins postgres (store.sql) and redis (store.kv) for prod in oke.config.ts.
+# Local dev uses sqlite + in-memory kv; uncomment only for prod overrides.
+
+# DATABASE_URL — primary Postgres connection; from your host (Neon, RDS, …)
+# DATABASE_URL=postgres://user:password@host:5432/linkly
+
+# REDIS_URL — Redis/Valkey connection for store.kv; from your host (Upstash, ElastiCache, …)
+# REDIS_URL=redis://:password@host:6379

package/examples/linkly/drizzle.config.ts

@@ -0,0 +1,11 @@
+import { defineConfig } from "drizzle-kit";
+
+/** Domain schema sync for `oke db push|generate|migrate`. */
+export default defineConfig({
+  dialect: "sqlite",
+  schema: "./src/schema.generated.ts",
+  out: "./drizzle",
+  dbCredentials: {
+    url: process.env.OKE_SQLITE_URL ?? "file:.oke/app.sqlite",
+  },
+});

package/examples/linkly/oke.config.ts

@@ -2,9 +2,11 @@ import { defineConfig } from "okengine/config";
 
 export default defineConfig({
   drivers: {
-    store:  { sql: { dev: "sqlite", test: "memory", prod: "postgres" },
-              kv:  { dev: "memory", test: "memory", prod: "redis" } },
-    signal: { dev: "memory", test: "memory", prod: "postgres" },
-    clock:  { dev: "memory", test: "frozen", prod: "postgres" },
+    store: {
+      sql: { local: "sqlite", test: "memory", prod: "postgres" },
+      kv: { local: "memory", test: "memory", prod: "redis" },
+    },
+    signal: { local: "memory", test: "memory", prod: "postgres" },
+    clock: { local: "memory", test: "frozen", prod: "postgres" },
   },
 });

package/examples/linkly/package.json

@@ -3,13 +3,16 @@
   "version": "0.0.1",
   "private": true,
   "type": "module",
+  "scripts": {
+    "test": "bun test",
+    "dev": "oke dev"
+  },
   "dependencies": {
-    "okengine": "file:../..",
     "drizzle-orm": "^1.0.0-rc.4",
+    "okengine": "file:../..",
     "zod": "^4.4.3"
   },
-  "scripts": {
-    "test": "bun test",
-    "dev": "oke dev"
+  "devDependencies": {
+    "drizzle-kit": "^1.0.0-rc.4"
   }
 }

package/examples/linkly/src/flows/analytics/index.ts

@@ -6,19 +6,34 @@ import { db } from "../../core";
 import { member } from "../../gates";
 import { daily } from "../../schema";
 
-on(linkClicked, flow({                    // a second consumer of the same signal
-  do: async ({ code, at }, fx) => {
-    const day = new Date(at).toISOString().slice(0, 10);
-    const [row] = await fx.store(db).select().from(daily)
-      .where(and(eq(daily.code, code), eq(daily.day, day))).limit(1);
+on(
+  linkClicked,
+  flow({
+    // a second consumer of the same signal
+    do: async ({ code, at }, fx) => {
+      const day = new Date(at).toISOString().slice(0, 10);
+      const [row] = await fx
+        .store(db)
+        .select()
+        .from(daily)
+        .where(and(eq(daily.code, code), eq(daily.day, day)))
+        .limit(1);
 
-    if (row) await fx.store(db).increment(daily, row.id, "clicks");
-    else await fx.store(db).insert(daily).values({ id: fx.id(), code, day, clicks: 1 });
-  },
-}));
+      if (row) await fx.store(db).increment(daily, row.id, "clicks");
+      else await fx.store(db).insert(daily).values({ id: fx.id(), code, day, clicks: 1 });
+    },
+  }),
+);
 
-export const report = on(http.get("/links/:code/report").gate(member), flow({
-  out: z.array(z.object({ day: z.string(), clicks: z.number() })),
-  do: ({ code }, fx) => fx.store(db).select({ day: daily.day, clicks: daily.clicks })
-    .from(daily).where(eq(daily.code, code)),
-}));
+export const report = on(
+  http.get("/links/:code/report").gate(member),
+  flow({
+    out: z.array(z.object({ day: z.string(), clicks: z.number() })),
+    do: ({ code }, fx) =>
+      fx
+        .store(db)
+        .select({ day: daily.day, clicks: daily.clicks })
+        .from(daily)
+        .where(eq(daily.code, code)),
+  }),
+);

package/examples/linkly/src/flows/links/index.ts

@@ -8,52 +8,75 @@ import { NewLink, LinkCode, Link, NotFound, Taken } from "./shapes";
 import { links } from "../../schema";
 
 // ① HTTP — "an endpoint"
-export const shorten = on(http.post("/links").gate(member, fair), flow({
-  in: NewLink, out: LinkCode, errors: { Taken },
-  do: async ({ url, code }, fx) => {
-    if (await fx.store(db).exists(links, { code })) return fx.fail("Taken", {});
-    const id = fx.id();
-    await fx.store(db).insert(links).values(
-      { id, code, url, userId: fx.auth.userId, clicks: 0, createdAt: Date.now() });
-    return { code };
-  },
-}));
+export const shorten = on(
+  http.post("/links").gate(member, fair),
+  flow({
+    in: NewLink,
+    out: LinkCode,
+    errors: { Taken },
+    do: async ({ url, code }, fx) => {
+      if (await fx.store(db).exists(links, { code })) return fx.fail("Taken", {});
+      const id = fx.id();
+      await fx
+        .store(db)
+        .insert(links)
+        .values({ id, code, url, userId: fx.auth.userId, clicks: 0, createdAt: Date.now() });
+      return { code };
+    },
+  }),
+);
 
 // ② HTTP — the hot path
-export const redirect = on(http.get("/:code").gate(fair), flow({
-  in: LinkCode, out: Link, errors: { NotFound },
-  do: async ({ code }, fx) => {
-    const [link] = await fx.store(db).select().from(links).where(eq(links.code, code)).limit(1);
-    if (!link) return fx.fail("NotFound", {});
+export const redirect = on(
+  http.get("/:code").gate(fair),
+  flow({
+    in: LinkCode,
+    out: Link,
+    errors: { NotFound },
+    do: async ({ code }, fx) => {
+      const [link] = await fx.store(db).select().from(links).where(eq(links.code, code)).limit(1);
+      if (!link) return fx.fail("NotFound", {});
 
-    await fx.emit(linkClicked, { code, at: Date.now() });   // same transaction as any write
-    return link;
-  },
-}));
+      await fx.emit(linkClicked, { code, at: Date.now() }); // same transaction as any write
+      return link;
+    },
+  }),
+);
 
 // ③ SIGNAL — "a queue consumer", and the same species as ① and ②
-on(linkClicked, flow({
-  do: async ({ code }, fx) => {
-    const [link] = await fx.store(db).select().from(links).where(eq(links.code, code)).limit(1);
-    const clicks = await fx.store(db).increment(links, link.id, "clicks");
-    await fx.emit(linkStats, { code, clicks });             // live: pushed to subscribers
-  },
-}));
+on(
+  linkClicked,
+  flow({
+    do: async ({ code }, fx) => {
+      const [link] = await fx.store(db).select().from(links).where(eq(links.code, code)).limit(1);
+      const clicks = await fx.store(db).increment(links, link.id, "clicks");
+      await fx.emit(linkStats, { code, clicks }); // live: pushed to subscribers
+    },
+  }),
+);
 
 // ④ CLOCK — "a cron job", and still the same species
-on(every("1h"), flow({
-  do: (_, fx) => {
-    const cutoff = Date.now() - 30 * 24 * 60 * 60 * 1000;   // 30 days
-    return fx.store(db).delete(links).where(lt(links.createdAt, cutoff));
-  },
-}));
+on(
+  every("1h"),
+  flow({
+    do: (_, fx) => {
+      const cutoff = Date.now() - 30 * 24 * 60 * 60 * 1000; // 30 days
+      return fx.store(db).delete(links).where(lt(links.createdAt, cutoff));
+    },
+  }),
+);
 
 // ⑤ A plain flow with no trigger — callable, not "private"
 export const stats = flow({
-  in: LinkCode, out: z.object({ clicks: z.number() }),
+  in: LinkCode,
+  out: z.object({ clicks: z.number() }),
   do: async ({ code }, fx) => {
-    const [link] = await fx.store(db).select({ clicks: links.clicks })
-      .from(links).where(eq(links.code, code)).limit(1);
+    const [link] = await fx
+      .store(db)
+      .select({ clicks: links.clicks })
+      .from(links)
+      .where(eq(links.code, code))
+      .limit(1);
     return link ?? { clicks: 0 };
   },
 });

package/examples/linkly/src/flows/links/signals.ts

@@ -3,11 +3,12 @@ import { z } from "zod";
 
 export const linkClicked = signal("link-clicked", {
   schema: z.object({ code: z.string(), at: z.number(), referrer: z.string().optional() }),
-  delivery: "once",                       // queue physics: one consumer, retries, DLQ
-  retries: 3, deadLetter: true,
+  delivery: "once", // queue physics: one consumer, retries, DLQ
+  retries: 3,
+  deadLetter: true,
 });
 
 export const linkStats = signal("link-stats", {
   schema: z.object({ code: z.string(), clicks: z.number() }),
-  delivery: "live",                       // stream physics: clients subscribe
+  delivery: "live", // stream physics: clients subscribe
 });

package/examples/linkly/src/gates.ts

@@ -3,6 +3,8 @@ import { gate } from "okengine";
 export const member = gate.policy("member", ({ auth }) => !!auth?.verified);
 
 export const fair = gate.rate({
-  strategy: "sliding-window-counter",   // near-exact, two keys, no boundary bursts
-  max: 60, per: "1m", keyBy: "ip",
+  strategy: "sliding-window-counter", // near-exact, two keys, no boundary bursts
+  max: 60,
+  per: "1m",
+  keyBy: "ip",
 });

package/examples/linkly/src/schema.decl.ts

@@ -0,0 +1,39 @@
+import { store, field } from "okengine";
+
+/** Short links — `code` is the human-facing unique key. */
+export const links = store.schema.table("links", {
+  id: field.text().primaryKey(), // `increment` targets this column
+  code: field.text().notNull().unique(), // the short, human-facing key
+  url: field.text().notNull(),
+  userId: field.text().notNull(),
+  clicks: field.integer().notNull().default(0),
+  createdAt: field.integer().notNull(),
+});
+
+/** Per-link daily click counts — FK to `links.code`. */
+export const daily = store.schema.table("daily", {
+  id: field.text().primaryKey(),
+  code: field
+    .text()
+    .notNull()
+    .references(() => links.code),
+  day: field.text().notNull(), // "YYYY-MM-DD"
+  clicks: field.integer().notNull().default(0),
+});
+
+/** links ↔ daily — one link has many daily rows. */
+export const relations = store.schema.relations({ links, daily }, (r) => ({
+  links: {
+    daily: r.many.daily({
+      from: r.links.code,
+      to: r.daily.code,
+    }),
+  },
+  daily: {
+    link: r.one.links({
+      from: r.daily.code,
+      to: r.links.code,
+      optional: false,
+    }),
+  },
+}));

package/examples/linkly/src/schema.generated.ts

@@ -0,0 +1,30 @@
+// generated by oke — do not edit
+import { sqliteTable, text, integer } from "drizzle-orm/sqlite-core";
+import { defineRelations } from "drizzle-orm";
+
+export const links = sqliteTable("links", {
+  id: text("id").primaryKey(),
+  code: text("code").notNull().unique(),
+  url: text("url").notNull(),
+  userId: text("user_id").notNull(),
+  clicks: integer("clicks").notNull().default(0),
+  createdAt: integer("created_at").notNull(),
+});
+
+export const daily = sqliteTable("daily", {
+  id: text("id").primaryKey(),
+  code: text("code")
+    .notNull()
+    .references(() => links.code),
+  day: text("day").notNull(),
+  clicks: integer("clicks").notNull().default(0),
+});
+
+export const relations = defineRelations({ links, daily }, (r) => ({
+  links: {
+    daily: r.many.daily({ from: r.links.code, to: r.daily.code }),
+  },
+  daily: {
+    link: r.one.links({ from: r.daily.code, to: r.links.code, optional: false }),
+  },
+}));

package/examples/linkly/src/schema.ts

@@ -1,17 +1,2 @@
-import { sqliteTable, text, integer } from "drizzle-orm/sqlite-core";
-
-export const links = sqliteTable("links", {
-  id:        text("id").primaryKey(),               // `increment` targets this column
-  code:      text("code").notNull().unique(),        // the short, human-facing key
-  url:       text("url").notNull(),
-  userId:    text("user_id").notNull(),
-  clicks:    integer("clicks").notNull().default(0),
-  createdAt: integer("created_at").notNull(),
-});
-
-export const daily = sqliteTable("daily", {
-  id:     text("id").primaryKey(),
-  code:   text("code").notNull(),
-  day:    text("day").notNull(),                      // "YYYY-MM-DD"
-  clicks: integer("clicks").notNull().default(0),
-});
+/** Stable import surface — re-exports generated Drizzle from abstract decls. */
+export { links, daily, relations } from "./schema.generated";

package/examples/linkly/tests/linkly.test.ts

@@ -3,17 +3,17 @@ import { createTestApp } from "okengine/test";
 import { app } from "../src/app";
 
 test("shorten → redirect → report · time travel", async () => {
-const t = await createTestApp(app);                 // memory drivers, frozen clock
-const u = await t.auth.loginAs({});
+  const t = await createTestApp(app); // memory drivers, frozen clock
+  const u = await t.auth.loginAs({});
 
-await t.api.links.shorten({ url: "https://example.com", code: "sa" }, { as: u });
-await t.api.links.redirect({ code: "sa" });
-await t.signals.drain();                            // run queued work deterministically
+  await t.api.links.shorten({ url: "https://example.com", code: "sa" }, { as: u });
+  await t.api.links.redirect({ code: "sa" });
+  await t.signals.drain(); // run queued work deterministically
 
-const { data } = await t.api.links.report({ code: "sa" }, { as: u });
-expect(data![0].clicks).toBe(1);
+  const { data } = await t.api.links.report({ code: "sa" }, { as: u });
+  expect(data![0].clicks).toBe(1);
 
-await t.clock.advance("31d");
-await t.cron.run("1h");                             // time travel
+  await t.clock.advance("31d");
+  await t.cron.run("1h"); // time travel
   await t.close();
 });

package/examples/notes/.env.example

@@ -0,0 +1,12 @@
+# Environment template — copy to `.env.local` for local overrides.
+# create-oke copies this file to `.env.local` when you scaffold a new project.
+#
+# Resolution order (first hit wins):
+#   process.env → .env.local → docker/.env.docker → vault driver → dev fallback
+#
+# --- Infrastructure (optional) ---
+# This app pins postgres for prod SQL in oke.config.ts (local dev uses sqlite).
+# Uncomment only when overriding the prod connection URL.
+
+# DATABASE_URL — primary Postgres connection; from your host (Neon, RDS, …)
+# DATABASE_URL=postgres://user:password@host:5432/notes

package/examples/notes/drizzle.config.ts

@@ -0,0 +1,11 @@
+import { defineConfig } from "drizzle-kit";
+
+/** Domain schema sync for `oke db push|generate|migrate`. */
+export default defineConfig({
+  dialect: "sqlite",
+  schema: "./src/schema.ts",
+  out: "./drizzle",
+  dbCredentials: {
+    url: process.env.OKE_SQLITE_URL ?? "file:.oke/app.sqlite",
+  },
+});

package/examples/notes/oke.config.ts

@@ -4,8 +4,8 @@ export default defineConfig({
   drivers: {
     store: {
       sql: {
-        dev: "sqlite",
-        stack: "postgres",
+        local: "sqlite",
+        docker: "postgres",
         test: "memory",
         prod: "postgres",
       },

package/examples/notes/package.json

@@ -3,14 +3,17 @@
   "version": "0.0.1",
   "private": true,
   "type": "module",
+  "scripts": {
+    "test": "bun test",
+    "dev": "oke dev"
+  },
   "dependencies": {
-    "okengine": "file:../..",
     "drizzle-orm": "^1.0.0-rc.4",
     "drizzle-zod": "^0.8.3",
+    "okengine": "file:../..",
     "zod": "^4.4.3"
   },
-  "scripts": {
-    "test": "bun test",
-    "dev": "oke dev"
+  "devDependencies": {
+    "drizzle-kit": "^1.0.0-rc.4"
   }
 }

package/examples/notes/src/app.ts

@@ -5,7 +5,7 @@ import * as notes from "./flows/notes";
 
 export const app = oke({ name: "notes" }).adopt({ notes });
 
-export type App = typeof app;   // ← the client needs nothing else
+export type App = typeof app; // ← the client needs nothing else
 
 Object.assign(app.$options, {
   env: "test",

package/examples/notes/src/flows/notes/index.ts

@@ -5,40 +5,54 @@ import { db } from "../../core";
 import { notes } from "../../schema";
 
 // Contracts derived from the schema — one source of truth, refined where the API is stricter
-const NewNote  = createInsertSchema(notes, { title: (s) => s.min(1).max(120) })
-                   .omit({ id: true, createdAt: true });
-const Note     = createSelectSchema(notes);
-const NoteId   = z.object({ id: z.string() });
+const NewNote = createInsertSchema(notes, { title: (s) => s.min(1).max(120) }).omit({
+  id: true,
+  createdAt: true,
+});
+const Note = createSelectSchema(notes);
+const NoteId = z.object({ id: z.string() });
 const NotFound = z.object({});
 
-export const create = on(http.post("/notes"), flow({
-  in: NewNote,
-  out: NoteId,
-  do: async (input, fx) => {
-    const [note] = await fx.store(db).insert(notes).values(input).returning();
-    return { id: note.id };
-  },
-}));
+export const create = on(
+  http.post("/notes"),
+  flow({
+    in: NewNote,
+    out: NoteId,
+    do: async (input, fx) => {
+      const [note] = await fx.store(db).insert(notes).values(input).returning();
+      return { id: note.id };
+    },
+  }),
+);
 // effects → writes[sql:notes]
 
-export const list = on(http.get("/notes"), flow({
-  out: Note.array(),
-  do: (_, fx) => fx.store(db).select().from(notes),
-}));
+export const list = on(
+  http.get("/notes"),
+  flow({
+    out: Note.array(),
+    do: (_, fx) => fx.store(db).select().from(notes),
+  }),
+);
 // effects → reads[sql:notes]
 
-export const get = on(http.get("/notes/:id"), flow({
-  in: NoteId,
-  out: Note,
-  errors: { NotFound },
-  do: async ({ id }, fx) => (await fx.store(db).findById(notes, id)) ?? fx.fail("NotFound", {}),
-}));
+export const get = on(
+  http.get("/notes/:id"),
+  flow({
+    in: NoteId,
+    out: Note,
+    errors: { NotFound },
+    do: async ({ id }, fx) => (await fx.store(db).findById(notes, id)) ?? fx.fail("NotFound", {}),
+  }),
+);
 
-export const remove = on(http.delete("/notes/:id"), flow({
-  in: NoteId,
-  errors: { NotFound },
-  do: async ({ id }, fx) => {
-    const deleted = await fx.store(db).delete(notes, id);
-    if (!deleted) return fx.fail("NotFound", {});
-  },
-}));
+export const remove = on(
+  http.delete("/notes/:id"),
+  flow({
+    in: NoteId,
+    errors: { NotFound },
+    do: async ({ id }, fx) => {
+      const deleted = await fx.store(db).delete(notes, id);
+      if (!deleted) return fx.fail("NotFound", {});
+    },
+  }),
+);

package/examples/notes/src/schema.ts

@@ -2,8 +2,8 @@ import { sqliteTable, text, integer } from "drizzle-orm/sqlite-core";
 import { id, now } from "okengine/store";
 
 export const notes = sqliteTable("notes", {
-  id:        text("id").primaryKey().$defaultFn(id),
-  title:     text("title").notNull(),
-  body:      text("body").notNull(),
+  id: text("id").primaryKey().$defaultFn(id),
+  title: text("title").notNull(),
+  body: text("body").notNull(),
   createdAt: integer("created_at").notNull().$defaultFn(now),
 });

package/examples/notes/tests/notes.test.ts

@@ -3,7 +3,7 @@ import { createTestApp } from "okengine/test";
 import { app } from "../src/app";
 
 test("create then read", async () => {
-  const t = await createTestApp(app);            // memory driver, automatic
+  const t = await createTestApp(app); // memory driver, automatic
   const { data } = await t.api.notes.create({ title: "First", body: "Hello" });
   const { data: note } = await t.api.notes.get({ id: data!.id });
   expect(note!.title).toBe("First");