@junejs/juno 0.0.16 → 0.0.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@junejs/juno",
-  "version": "0.0.16",
+  "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.16",
-    "@junejs/db": "0.0.16"
+    "@junejs/core": "0.0.17",
+    "@junejs/db": "0.0.17"
   },
   "devDependencies": {
-    "@junejs/server": "0.0.16"
+    "@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

@@ -9,6 +9,8 @@
 // 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> = {
@@ -151,7 +153,44 @@ export class PostgresDialect extends Dialect {
   }
 }
 
+// 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` compiles the same nodes for PG.
+// (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,13 +16,13 @@ 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, PostgresDialect, sqlite, postgres, 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";
 
@@ -77,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
@@ -131,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> {
@@ -148,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));
   }
 
@@ -178,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));
   }
 
@@ -194,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),
@@ -211,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));
   }
 

package/src/types.ts

@@ -1,15 +1,25 @@
-// Stage 3b — schema codegen. Introspect a migrated SQLite/D1 database and emit the
+// 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. Pure introspection — no schema DSL, nothing for the app to maintain.
+// 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";
 
-// 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 {
+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
@@ -17,42 +27,91 @@ function tsType(declared: string, notnull: number, pk: number): string {
   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;
+  // 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);
 }
 
-// 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>(
+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 };
 
-  const ifaces: 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) {
-    // 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(?)',
+    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],
     );
-    const fields = cols
-      .map((c) => `      ${propKey(c.name)}: ${tsType(c.type, c.nn, c.pk)};`)
-      .join("\n");
-    ifaces.push(`    ${propKey(name)}: {\n${fields}\n    };`);
+    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' +
@@ -62,3 +121,16 @@ export async function emitSchemaTypes(db: JuneDb): Promise<string> {
     "\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);
+}