@junejs/juno 0.0.15 → 0.0.17

package/README.md

@@ -34,6 +34,21 @@ await table("users").upsert({ email: "ada@x.dev", name: "Ada" }, { onConflict: "
 await db.query("select * from users where age > ?", [18]);   // raw escape hatch (auto-tags)
 ```
 
+## Typed tables (zero config)
+
+`table("users")` infers its row — the table name autocompletes, columns and their
+types flow through `findBy` / `all` / `where` / `orderBy` — with **no inline generic**.
+Run it once and after every migration:
+
+```sh
+june db types   # introspects the migrated db → writes db/schema.d.ts
+```
+
+That file is a `declare module "@junejs/juno"` augmentation generated from your SQL
+schema (`db/migrations/`), so types can't drift from the database and you maintain no
+schema DSL. Without it, `table()` is still fully usable — it just returns the untyped
+`Row` (or pass an inline generic: `table<User>("users")`).
+
 ## Non-obvious facts (the easy-to-get-wrong bits)
 
 The API shape is self-explanatory; these are the things models and humans get

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@junejs/juno",
-  "version": "0.0.15",
+  "version": "0.0.17",
   "description": "Juno — June's ergonomic data layer over the JuneDb contract. The default that ships with the agent-native magic (Tier 3).",
   "type": "module",
   "license": "MIT",
@@ -16,11 +16,14 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@junejs/core": "0.0.15",
-    "@junejs/db": "0.0.15"
+    "@junejs/core": "0.0.17",
+    "@junejs/db": "0.0.17"
   },
   "devDependencies": {
-    "@junejs/server": "0.0.15"
+    "@junejs/server": "0.0.17",
+    "@types/pg": "^8.20.0",
+    "mysql2": "^3.22.5",
+    "pg": "^8.21.0"
   },
   "repository": {
     "type": "git",

package/src/batch.ts

@@ -7,8 +7,19 @@
 import type { JuneDb } from "@junejs/core/resources";
 import { recordTableRead } from "@junejs/core/instrumentation";
 
+import type { SelectNode } from "./ast";
+import { dialectFor } from "./compiler";
 import type { Row } from "./index";
 
+// The batched `where <key> in (?, ?, …)` read as an operation node, compiled per
+// batch with the db's dialect (sqlite `?` / Postgres `$n` / MySQL backticks) — so the
+// auto-batch path is multi-dialect like the rest of the Table API. arity = batch size.
+function inQuery<V extends Row>(db: JuneDb, table: string, key: string, keys: unknown[]): Promise<V[]> {
+  recordTableRead(table); // batched read still participates in cache auto-tagging
+  const node: SelectNode = { kind: "select", from: table, where: [{ col: key, op: "in", arity: keys.length }] };
+  return db.query<V>(dialectFor(db).compile(node), keys);
+}
+
 export type Loader<K, V> = {
   load(key: K): Promise<V | null>;
 };
@@ -63,11 +74,7 @@ export function tableLoader<V extends Row = Row>(
     throw new Error(`unsafe SQL identifier: ${table}.${key}`);
   }
   return createLoader<string | number, V>(
-    async (keys) => {
-      recordTableRead(table); // batched read still participates in cache auto-tagging
-      const placeholders = keys.map(() => "?").join(", ");
-      return db.query<V>(`select * from ${table} where ${key} in (${placeholders})`, keys);
-    },
+    (keys) => inQuery<V>(db, table, key, keys),
     (row) => (row as Row)[key] as string | number,
   );
 }
@@ -132,11 +139,7 @@ export function tableListLoader<V extends Row = Row>(
     throw new Error(`unsafe SQL identifier: ${table}.${key}`);
   }
   return createGroupLoader<string | number, V>(
-    async (keys) => {
-      recordTableRead(table);
-      const placeholders = keys.map(() => "?").join(", ");
-      return db.query<V>(`select * from ${table} where ${key} in (${placeholders})`, keys);
-    },
+    (keys) => inQuery<V>(db, table, key, keys),
     (row) => (row as Row)[key] as string | number,
   );
 }

package/src/compiler.ts

@@ -1,13 +1,16 @@
 // The dialect compiler — walks an operation-node AST (ast.ts) into a SQL string.
 // A `Dialect` is the seam multi-dialect lands on: subclasses override placeholder
-// style / quoting / upsert syntax. SqliteDialect (sqlite + D1) is the default; a
-// PostgresDialect (`$n` placeholders) slots in later as another subclass.
+// style / identifier quoting. SqliteDialect (sqlite + D1, bare `?`) is the default;
+// PostgresDialect (`$n` placeholders, double-quoted identifiers) is the sibling. Both
+// share the upsert / limit / returning syntax — only the two dialect bits differ.
 //
 // Compile-once: `compile()` memoizes by the node's structural key. Nodes hold
 // shape only (no parameter values), so the same query shape compiles ONCE and
 // every later call reuses the string — what Kysely-style builders don't do (they
 // recompile per execute). Param VALUES are bound by the caller, never cached.
 
+import type { JuneDb, SqlDialect } from "@junejs/core/resources";
+
 import type { CmpOp, Node, Predicate } from "./ast";
 
 const SYM: Record<CmpOp, string> = {
@@ -21,12 +24,13 @@ const SYM: Record<CmpOp, string> = {
 };
 
 // Emit one WHERE predicate. `ph()` yields the next placeholder (and advances the
-// dialect's counter), so `in` can consume `arity` of them in order.
-function predicate(p: Predicate, ph: () => string): string {
+// dialect's counter), so `in` can consume `arity` of them in order. `q()` is the
+// dialect's identifier quoter (bare on sqlite, double-quoted on Postgres).
+function predicate(p: Predicate, ph: () => string, q: (name: string) => string): string {
   if (p.op === "in") {
-    return `${ident(p.col)} in (${Array.from({ length: p.arity }, ph).join(", ")})`;
+    return `${q(p.col)} in (${Array.from({ length: p.arity }, ph).join(", ")})`;
   }
-  return `${ident(p.col)} ${SYM[p.op]} ${ph()}`;
+  return `${q(p.col)} ${SYM[p.op]} ${ph()}`;
 }
 
 // Guard table/column names — identifiers can't be parameterized. Values always go
@@ -77,46 +81,54 @@ export abstract class Dialect {
   // The i-th bound placeholder (1-based). Sqlite ignores i (`?`); Postgres uses `$i`.
   protected abstract placeholder(i: number): string;
 
+  // Identifier emission — validated, then quoted per dialect. Sqlite emits bare
+  // (`col`); Postgres double-quotes (`"col"`) so reserved words (user, order) and
+  // exact case survive. Overridable so the seam covers quoting, not just placeholders.
+  protected quoteId(name: string): string {
+    return ident(name);
+  }
+
   protected emit(node: Node): string {
+    const q = (name: string) => this.quoteId(name);
     switch (node.kind) {
       case "select": {
         let i = 0;
         const ph = () => this.placeholder(++i);
         const where = node.where.length
-          ? ` where ${node.where.map((p) => predicate(p, ph)).join(" and ")}`
+          ? ` where ${node.where.map((p) => predicate(p, ph, q)).join(" and ")}`
           : "";
         const order = node.orderBy?.length
-          ? ` order by ${node.orderBy.map((o) => `${ident(o.col)} ${o.dir === "desc" ? "desc" : "asc"}`).join(", ")}`
+          ? ` order by ${node.orderBy.map((o) => `${q(o.col)} ${o.dir === "desc" ? "desc" : "asc"}`).join(", ")}`
           : "";
         const limit = node.limit === "param" ? ` limit ${ph()}` : node.limit != null ? ` limit ${node.limit}` : "";
         const offset = node.offset === "param" ? ` offset ${ph()}` : "";
-        return `select * from ${ident(node.from)}${where}${order}${limit}${offset}`;
+        return `select * from ${q(node.from)}${where}${order}${limit}${offset}`;
       }
       case "insert": {
         let i = 0;
-        const cols = node.columns.map(ident);
+        const cols = node.columns.map(q);
         const vals = node.columns.map(() => this.placeholder(++i));
-        return `insert into ${ident(node.into)} (${cols.join(", ")}) values (${vals.join(", ")})`;
+        return `insert into ${q(node.into)} (${cols.join(", ")}) values (${vals.join(", ")})`;
       }
       case "update": {
         let i = 0;
-        const set = node.set.map((c) => `${ident(c)} = ${this.placeholder(++i)}`).join(", ");
-        const where = node.where.map((c) => `${ident(c)} = ${this.placeholder(++i)}`).join(" and ");
-        return `update ${ident(node.table)} set ${set} where ${where}`;
+        const set = node.set.map((c) => `${q(c)} = ${this.placeholder(++i)}`).join(", ");
+        const where = node.where.map((c) => `${q(c)} = ${this.placeholder(++i)}`).join(" and ");
+        return `update ${q(node.table)} set ${set} where ${where}`;
       }
       case "delete": {
         let i = 0;
-        const where = node.where.map((c) => `${ident(c)} = ${this.placeholder(++i)}`).join(" and ");
-        return `delete from ${ident(node.from)} where ${where}`;
+        const where = node.where.map((c) => `${q(c)} = ${this.placeholder(++i)}`).join(" and ");
+        return `delete from ${q(node.from)} where ${where}`;
       }
       case "upsert": {
         let i = 0;
-        const cols = node.columns.map(ident);
+        const cols = node.columns.map(q);
         const vals = node.columns.map(() => this.placeholder(++i));
-        const set = node.update.map((c) => `${ident(c)} = excluded.${ident(c)}`).join(", ");
+        const set = node.update.map((c) => `${q(c)} = excluded.${q(c)}`).join(", ");
         return (
-          `insert into ${ident(node.into)} (${cols.join(", ")}) values (${vals.join(", ")}) ` +
-          `on conflict (${node.conflict.map(ident).join(", ")}) do update set ${set} returning *`
+          `insert into ${q(node.into)} (${cols.join(", ")}) values (${vals.join(", ")}) ` +
+          `on conflict (${node.conflict.map(q).join(", ")}) do update set ${set} returning *`
         );
       }
     }
@@ -129,6 +141,56 @@ export class SqliteDialect extends Dialect {
   }
 }
 
-// The default dialect (sqlite + D1). A shared singleton so its compile-once cache
-// is process-level. Postgres adds a sibling subclass later.
+// Postgres: numbered `$n` placeholders and double-quoted identifiers (so a column
+// named `user`/`order`, or any non-lowercase name, is emitted correctly). Same AST,
+// same upsert/limit/returning syntax — only the two dialect-specific bits differ.
+export class PostgresDialect extends Dialect {
+  protected placeholder(i: number): string {
+    return `$${i}`;
+  }
+  protected override quoteId(name: string): string {
+    return `"${ident(name)}"`;
+  }
+}
+
+// MySQL: positional `?` placeholders (like sqlite) but backtick-quoted identifiers,
+// and a different upsert — MySQL has no `ON CONFLICT`/`RETURNING`, it keys off any
+// unique/primary index with `ON DUPLICATE KEY UPDATE` and the 8.0.19+ row alias
+// (`AS new … new.col`). So `conflict` columns are ignored (MySQL picks the violated
+// key) and upsert returns no row — the Table layer must re-read if it needs one.
+export class MysqlDialect extends Dialect {
+  protected placeholder(): string {
+    return "?";
+  }
+  protected override quoteId(name: string): string {
+    return `\`${ident(name)}\``;
+  }
+  protected override emit(node: Node): string {
+    if (node.kind !== "upsert") return super.emit(node);
+    const q = (name: string) => this.quoteId(name);
+    const cols = node.columns.map(q);
+    const vals = node.columns.map(() => this.placeholder()); // `?` is positional — no index
+    const set = node.update.map((c) => `${q(c)} = new.${q(c)}`).join(", ");
+    return (
+      `insert into ${q(node.into)} (${cols.join(", ")}) values (${vals.join(", ")}) as new ` +
+      `on duplicate key update ${set}`
+    );
+  }
+}
+
+// Shared singletons so each dialect's compile-once cache is process-level. `sqlite`
+// (sqlite + D1) is Juno's default; `postgres` / `mysql` compile the same nodes for PG / MySQL.
 export const sqlite = new SqliteDialect();
+export const postgres = new PostgresDialect();
+export const mysql = new MysqlDialect();
+
+// The dialect-tag → compiler registry. This is the keystone of multi-dialect runtime:
+// a JuneDb handle declares the SQL it speaks (`db.dialect`), and Juno resolves the
+// matching compiler here — without the framework ever knowing about dialects.
+const BY_DIALECT: Record<SqlDialect, Dialect> = { sqlite, postgres, mysql };
+
+// Resolve the compiler for a JuneDb handle. An untagged handle (an older driver, or
+// the contract's optional `dialect`) defaults to sqlite — the safe, edge-first floor.
+export function dialectFor(db: Pick<JuneDb, "dialect">): Dialect {
+  return BY_DIALECT[db.dialect ?? "sqlite"];
+}

package/src/index.ts

@@ -16,16 +16,34 @@ import { db as ambientDb, requestLocal, registerSqlTagger } from "@junejs/db";
 
 import type { Predicate, SelectNode } from "./ast";
 import { tableLoader, tableListLoader, type Loader, type ListLoader } from "./batch";
-import { sqlite } from "./compiler";
+import { dialectFor, type Dialect } from "./compiler";
 import { taggingDb, tagSql } from "./tag";
+import { emitSchemaTypes } from "./types";
 
 export { createLoader, createGroupLoader, tableLoader, tableListLoader, type Loader, type ListLoader } from "./batch";
 export { tablesFromSql, tagSql, taggingDb, type SqlTouch } from "./tag";
-export { Dialect, SqliteDialect, sqlite, ident } from "./compiler";
+export { Dialect, SqliteDialect, PostgresDialect, MysqlDialect, sqlite, postgres, mysql, dialectFor, ident } from "./compiler";
+export { emitSchemaTypes } from "./types";
 export type { Node, SelectNode, InsertNode, UpdateNode, DeleteNode, UpsertNode } from "./ast";
 
 export type Row = Record<string, unknown>;
 
+// The app's table → row-type registry (Stage 3). EMPTY by default, so `table(name)`
+// stays untyped and every existing call keeps working (back-compat). Apps augment it
+// via `declare module "@junejs/juno" { interface Schema { users: {...} } }` — a file
+// `june db types` generates by introspecting the live schema (Stage 3b). Once
+// augmented, `table("users")` autocompletes the name and infers the row, with no
+// inline generic and no handle. Kysely-style declaration merging: zero runtime, and
+// the schema of record stays in SQL (db/migrations/), never owned by Juno.
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+export interface Schema {}
+
+// A known table name resolves to its declared row (intersected with Row so it always
+// satisfies the Table constraint); falls back to `never` when Schema is empty, which
+// makes the typed overload simply not match and the string overload take over.
+export type TableNames = keyof Schema & string;
+export type RowOf<K extends TableNames> = Schema[K] & Row;
+
 // A WHERE value is either an equality value or an operator object (Stage 2).
 // `{ age: { gte: 18 }, name: { like: "%a%" }, id: { in: [1, 2] } }` — AND-joined.
 export type Operators = {
@@ -59,6 +77,13 @@ export class Table<T extends Row = Row> {
     private readonly loaders: Map<string, unknown> = new Map(),
   ) {}
 
+  // The compiler for THIS table's db — picked from the handle's dialect tag (sqlite
+  // by default). So `table()` emits the right SQL whether db is sqlite/D1, Postgres,
+  // or MySQL, off the same operation-node AST. Cheap map lookup; called per query.
+  private get compiler(): Dialect {
+    return dialectFor(this.db);
+  }
+
   // No `where` → every row. With a `where`, the list of rows matching it (the list
   // counterpart of findBy, same where syntax). A single-column filter ambient-
   // batches like findBy — concurrent `all({user_id})` across components coalesce
@@ -113,7 +138,7 @@ export class Table<T extends Row = Row> {
     };
     if (opts?.limit != null) params.push(opts.limit);
     if (opts?.offset != null) params.push(opts.offset);
-    return this.db.query<T>(sqlite.compile(node), params);
+    return this.db.query<T>(this.compiler.compile(node), params);
   }
 
   async findBy(where: Partial<T>): Promise<T | undefined> {
@@ -130,7 +155,7 @@ export class Table<T extends Row = Row> {
       return (hit ?? undefined) as T | undefined;
     }
     const where2: Predicate[] = keys.map((k) => ({ col: k, op: "eq" }));
-    const sql = sqlite.compile({ kind: "select", from: this.name, where: where2, limit: 1 });
+    const sql = this.compiler.compile({ kind: "select", from: this.name, where: where2, limit: 1 });
     return this.db.get<T>(sql, Object.values(where));
   }
 
@@ -160,7 +185,7 @@ export class Table<T extends Row = Row> {
 
   async insert(values: Partial<T>): Promise<RunResult> {
     recordTableWrite(this.name); // auto-invalidate: invokeAction drops table:<name>
-    const sql = sqlite.compile({ kind: "insert", into: this.name, columns: Object.keys(values) });
+    const sql = this.compiler.compile({ kind: "insert", into: this.name, columns: Object.keys(values) });
     return this.db.run(sql, Object.values(values));
   }
 
@@ -176,13 +201,13 @@ export class Table<T extends Row = Row> {
     const conflict = Array.isArray(opts.onConflict) ? opts.onConflict : [opts.onConflict];
     const updates = columns.filter((c) => !conflict.includes(c));
     const update = updates.length ? updates : conflict;
-    const sql = sqlite.compile({ kind: "upsert", into: this.name, columns, conflict, update });
+    const sql = this.compiler.compile({ kind: "upsert", into: this.name, columns, conflict, update });
     return this.db.get<T>(sql, Object.values(values));
   }
 
   async update(where: Partial<T>, values: Partial<T>): Promise<RunResult> {
     recordTableWrite(this.name);
-    const sql = sqlite.compile({
+    const sql = this.compiler.compile({
       kind: "update",
       table: this.name,
       set: Object.keys(values),
@@ -193,7 +218,7 @@ export class Table<T extends Row = Row> {
 
   async delete(where: Partial<T>): Promise<RunResult> {
     recordTableWrite(this.name);
-    const sql = sqlite.compile({ kind: "delete", from: this.name, where: Object.keys(where) });
+    const sql = this.compiler.compile({ kind: "delete", from: this.name, where: Object.keys(where) });
     return this.db.run(sql, Object.values(where));
   }
 
@@ -206,6 +231,10 @@ export class Table<T extends Row = Row> {
 }
 
 export type Juno = {
+  // Schema-aware: a declared table name infers its row (and autocompletes). The
+  // string overload is the fallback for dynamic names / an empty Schema / an
+  // explicit inline generic (`table<Custom>("x")`).
+  table<K extends TableNames>(name: K): Table<RowOf<K>>;
   table<T extends Row = Row>(name: string): Table<T>;
   // Raw escape hatch. Reads/writes through it auto-tag by parsed table name, so a
   // `cache(() => db.query("select ... from posts"))` is invalidated by a posts
@@ -225,13 +254,16 @@ export type Juno = {
 // is what keeps keys from leaking across requests.
 export function juno(db: JuneDb): Juno {
   const loaders = new Map<string, unknown>();
+  function table<K extends TableNames>(name: K): Table<RowOf<K>>;
+  function table<T extends Row = Row>(name: string): Table<T>;
+  function table(name: string): Table {
+    return new Table(db, name, loaders);
+  }
   return {
     // Table API uses the raw db and tags explicitly (precise, parser-independent);
     // the exposed handle wraps it so the raw escape hatch auto-tags too.
     db: taggingDb(db),
-    table<T extends Row = Row>(name: string) {
-      return new Table<T>(db, name, loaders);
-    },
+    table,
     reads(...tables: string[]) {
       for (const t of tables) recordTableRead(t);
     },
@@ -260,12 +292,17 @@ export function installDataLayer(): void {
 // the worker (via `module`). Explicit (config-declared), NOT an import-time global
 // side-effect — and the framework still never imports Juno (the user's config does).
 export function junoDataLayer(): DataLayer {
-  return { install: installDataLayer, module: "@junejs/juno" };
+  // emitTypes: `june db types` introspects the migrated db through this hook and
+  // writes db/schema.d.ts — the framework calls it via the DataLayer seam, still
+  // never importing Juno. See src/types.ts.
+  return { install: installDataLayer, module: "@junejs/juno", emitTypes: emitSchemaTypes };
 }
 
-export function table<T extends Row = Row>(name: string): Table<T> {
+export function table<K extends TableNames>(name: K): Table<RowOf<K>>;
+export function table<T extends Row = Row>(name: string): Table<T>;
+export function table(name: string): Table {
   const loaders = requestLocal(LOADERS, () => new Map<string, unknown>());
-  return new Table<T>(ambientDb, name, loaders);
+  return new Table(ambientDb, name, loaders);
 }
 
 // No separate ambient `db` export: the canonical `db` from `@junejs/db` (and

package/src/types.ts

@@ -0,0 +1,136 @@
+// Stage 3b / step 4 — schema codegen. Introspect a migrated database and emit the
+// `declare module "@junejs/juno"` augmentation that powers Stage 3a's `table()`
+// inference. `june db types` writes the result to db/schema.d.ts. The schema of record
+// stays in SQL (db/migrations/); this only DERIVES types from it, so the two never
+// drift. Multi-dialect: sqlite/D1 via PRAGMA, Postgres/MySQL via information_schema —
+// dispatched on the JuneDb's `dialect` tag.
+
+import type { JuneDb } from "@junejs/core/resources";
+
+type Field = { name: string; ts: string };
+
+// Bare identifier if it's a safe JS property name, else a quoted key.
+function propKey(name: string): string {
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name) ? name : JSON.stringify(name);
+}
+
+const nul = (ts: string, nullable: boolean) => (nullable ? `${ts} | null` : ts);
+
+// --- SQLite / D1 — PRAGMA + type affinity -------------------------------------
+type SqliteCol = { name: string; type: string; nn: number; pk: number };
+
+function sqliteType(declared: string, notnull: number, pk: number): string {
+  const t = declared.toUpperCase();
+  let base: string;
+  if (t.includes("INT")) base = "number"; // INTEGER affinity
+  else if (t.includes("CHAR") || t.includes("CLOB") || t.includes("TEXT")) base = "string"; // TEXT
+  else if (t === "" || t.includes("BLOB")) base = "Uint8Array"; // BLOB
+  else if (t.includes("REAL") || t.includes("FLOA") || t.includes("DOUB")) base = "number"; // REAL
+  else base = "number"; // NUMERIC (decimal / boolean / date stored as 0/1/epoch)
+  // Nullable unless declared NOT NULL or part of the PK (an INTEGER PRIMARY KEY shows
+  // notnull=0 but is the never-null rowid alias).
+  return nul(base, notnull === 0 && pk === 0);
+}
+
+async function introspectSqlite(db: JuneDb): Promise<[string, Field[]][]> {
+  const tables = await db.query<{ name: string }>(
+    "select name from sqlite_master where type = 'table' " +
+      "and name not like 'sqlite_%' and name <> '_june_migrations' order by name",
+  );
+  const out: [string, Field[]][] = [];
+  for (const { name } of tables) {
+    // pragma_table_info(?) — table-valued form takes a BOUND param (injection-safe).
+    const cols = await db.query<SqliteCol>('select name, type, "notnull" as nn, pk from pragma_table_info(?)', [name]);
+    out.push([name, cols.map((c) => ({ name: c.name, ts: sqliteType(c.type, c.nn, c.pk) }))]);
+  }
+  return out;
+}
+
+// --- information_schema (Postgres / MySQL) ------------------------------------
+type InfoCol = { name: string; type: string; nullable: string };
+
+// Postgres data_type → TS, matching what node-postgres actually returns: timestamps/
+// dates parse to Date, bigint/numeric come back as string (precision), bytea as bytes.
+function postgresType(dataType: string, nullable: boolean): string {
+  const t = dataType.toLowerCase();
+  let base: string;
+  if (t === "boolean") base = "boolean";
+  else if (t === "smallint" || t === "integer" || t === "real" || t === "double precision") base = "number";
+  else if (t === "bigint" || t === "numeric" || t === "decimal") base = "string";
+  else if (t === "bytea") base = "Uint8Array";
+  else if (t === "json" || t === "jsonb") base = "unknown";
+  else if (t === "date" || t.startsWith("timestamp")) base = "Date";
+  else if (t === "uuid" || t === "text" || t.startsWith("character") || t === "name" || t.startsWith("time")) base = "string";
+  else base = "unknown";
+  return nul(base, nullable);
+}
+
+// MySQL data_type → TS, matching mysql2's defaults: DATE/DATETIME/TIMESTAMP → Date,
+// DECIMAL → string, BLOB/BINARY → bytes, JSON parsed (unknown).
+function mysqlType(dataType: string, nullable: boolean): string {
+  const t = dataType.toLowerCase();
+  let base: string;
+  if (["tinyint", "smallint", "mediumint", "int", "integer", "bigint", "float", "double", "year"].includes(t)) base = "number";
+  else if (t === "decimal" || t === "numeric") base = "string";
+  else if (["char", "varchar", "text", "tinytext", "mediumtext", "longtext", "enum", "set", "time"].includes(t)) base = "string";
+  else if (t === "date" || t === "datetime" || t === "timestamp") base = "Date";
+  else if (t === "json") base = "unknown";
+  else if (t.includes("blob") || t.includes("binary") || t === "bit") base = "Uint8Array";
+  else base = "unknown";
+  return nul(base, nullable);
+}
+
+// Generic information_schema walk; `ph` is the dialect's placeholder, `scope` the SQL
+// expression for the current schema (current_schema() / database()), `map` the type map.
+async function introspectInfoSchema(
+  db: JuneDb,
+  ph: string,
+  scope: string,
+  map: (dataType: string, nullable: boolean) => string,
+): Promise<[string, Field[]][]> {
+  const tables = await db.query<{ name: string }>(
+    `select table_name as name from information_schema.tables ` +
+      `where table_schema = ${scope} and table_type = 'BASE TABLE' ` +
+      `and table_name <> '_june_migrations' order by table_name`,
+  );
+  const out: [string, Field[]][] = [];
+  for (const { name } of tables) {
+    const cols = await db.query<InfoCol>(
+      `select column_name as name, data_type as type, is_nullable as nullable ` +
+        `from information_schema.columns where table_schema = ${scope} and table_name = ${ph} ` +
+        `order by ordinal_position`,
+      [name],
+    );
+    out.push([name, cols.map((c) => ({ name: c.name, ts: map(c.type, c.nullable === "YES") }))]);
+  }
+  return out;
+}
+
+// --- assembly + dispatch ------------------------------------------------------
+function assemble(tables: [string, Field[]][]): string {
+  const ifaces = tables.map(([name, fields]) => {
+    const lines = fields.map((f) => `      ${propKey(f.name)}: ${f.ts};`).join("\n");
+    return `    ${propKey(name)}: {\n${lines}\n    };`;
+  });
+  return (
+    "// Generated by `june db types`. Do not edit — re-run after a migration.\n" +
+    'import "@junejs/juno";\n\n' +
+    'declare module "@junejs/juno" {\n' +
+    "  interface Schema {\n" +
+    ifaces.join("\n") +
+    "\n  }\n}\n"
+  );
+}
+
+// Introspect every user table (skipping the migration ledger + engine internals) and
+// emit the augmentation text. Reads only — never mutates the database.
+export async function emitSchemaTypes(db: JuneDb): Promise<string> {
+  const dialect = db.dialect ?? "sqlite";
+  const tables =
+    dialect === "postgres"
+      ? await introspectInfoSchema(db, "$1", "current_schema()", postgresType)
+      : dialect === "mysql"
+        ? await introspectInfoSchema(db, "?", "database()", mysqlType)
+        : await introspectSqlite(db);
+  return assemble(tables);
+}