@junejs/juno 0.0.14 → 0.0.16

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.14",
+  "version": "0.0.16",
   "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,11 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@junejs/core": "0.0.14",
-    "@junejs/db": "0.0.14"
+    "@junejs/core": "0.0.16",
+    "@junejs/db": "0.0.16"
   },
   "devDependencies": {
-    "@junejs/server": "0.0.14"
+    "@junejs/server": "0.0.16"
   },
   "repository": {
     "type": "git",

package/src/compiler.ts

@@ -1,7 +1,8 @@
 // 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
@@ -21,12 +22,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 +79,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 +139,19 @@ 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)}"`;
+  }
+}
+
+// Shared singletons so each dialect's compile-once cache is process-level. `sqlite`
+// (sqlite + D1) is Juno's default; `postgres` compiles the same nodes for PG.
 export const sqlite = new SqliteDialect();
+export const postgres = new PostgresDialect();

package/src/index.ts

@@ -18,14 +18,32 @@ import type { Predicate, SelectNode } from "./ast";
 import { tableLoader, tableListLoader, type Loader, type ListLoader } from "./batch";
 import { sqlite } 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, sqlite, postgres, 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 = {
@@ -206,6 +224,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 +247,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 +285,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,64 @@
+// Stage 3b — schema codegen. Introspect a migrated SQLite/D1 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. Pure introspection — no schema DSL, nothing for the app to maintain.
+
+import type { JuneDb } from "@junejs/core/resources";
+
+// SQLite type affinity → TypeScript. Mirrors SQLite's affinity rules (the same five
+// the engine itself applies), so a declared `varchar(40)` lands on `string`, `int`
+// on `number`, etc. Unknown/blank affinity → Uint8Array (BLOB), the safe default.
+function tsType(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)
+  // A column is nullable unless declared NOT NULL or part of the primary key (an
+  // INTEGER PRIMARY KEY reports notnull=0 but is the never-null rowid alias).
+  const nullable = notnull === 0 && pk === 0;
+  return nullable ? `${base} | null` : base;
+}
+
+// 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);
+}
+
+type TableRow = { name: string };
+type ColRow = { name: string; type: string; nn: number; pk: number };
+
+// Introspect every user table (skipping sqlite internals + June's migration ledger)
+// and return the augmentation file text. Reads only — never mutates the database.
+export async function emitSchemaTypes(db: JuneDb): Promise<string> {
+  const tables = await db.query<TableRow>(
+    "select name from sqlite_master where type = 'table' " +
+      "and name not like 'sqlite_%' and name <> '_june_migrations' order by name",
+  );
+
+  const ifaces: string[] = [];
+  for (const { name } of tables) {
+    // pragma_table_info(?) — the table-valued form takes a BOUND param, so no
+    // identifier interpolation (injection-safe even for odd table names).
+    const cols = await db.query<ColRow>(
+      'select name, type, "notnull" as nn, pk from pragma_table_info(?)',
+      [name],
+    );
+    const fields = cols
+      .map((c) => `      ${propKey(c.name)}: ${tsType(c.type, c.nn, c.pk)};`)
+      .join("\n");
+    ifaces.push(`    ${propKey(name)}: {\n${fields}\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"
+  );
+}