@junejs/juno 0.0.30-dev.0 → 0.0.30-dev.2

package/dist/ast-BsvUEqhl.d.ts

@@ -0,0 +1,48 @@
+//#region src/ast.d.ts
+type Node = SelectNode | InsertNode | UpdateNode | DeleteNode | UpsertNode;
+type CmpOp = "eq" | "ne" | "gt" | "gte" | "lt" | "lte" | "like";
+type Predicate = {
+  col: string;
+  op: CmpOp;
+} | {
+  col: string;
+  op: "in";
+  arity: number;
+};
+type OrderTerm = {
+  col: string;
+  dir: "asc" | "desc";
+};
+type SelectNode = {
+  kind: "select";
+  from: string;
+  where: Predicate[];
+  orderBy?: OrderTerm[];
+  limit?: number | "param";
+  offset?: "param";
+};
+type InsertNode = {
+  kind: "insert";
+  into: string;
+  columns: string[];
+};
+type UpdateNode = {
+  kind: "update";
+  table: string;
+  set: string[];
+  where: string[];
+};
+type DeleteNode = {
+  kind: "delete";
+  from: string;
+  where: string[];
+};
+type UpsertNode = {
+  kind: "upsert";
+  into: string;
+  columns: string[];
+  conflict: string[];
+  update: string[];
+};
+//#endregion
+export { OrderTerm as a, UpdateNode as c, Node as i, UpsertNode as l, DeleteNode as n, Predicate as o, InsertNode as r, SelectNode as s, CmpOp as t };

package/dist/ast.d.ts

@@ -0,0 +1,2 @@
+import { a as OrderTerm, c as UpdateNode, i as Node, l as UpsertNode, n as DeleteNode, o as Predicate, r as InsertNode, s as SelectNode, t as CmpOp } from "./ast-BsvUEqhl.js";
+export { CmpOp, DeleteNode, InsertNode, Node, OrderTerm, Predicate, SelectNode, UpdateNode, UpsertNode };

package/dist/batch-c_vy0gyx.d.ts

@@ -0,0 +1,72 @@
+import "./tag-B0HQho7q.js";
+import "./compiler-PkKpLl6z.js";
+import "./types-qDjFvlZu.js";
+import { JuneDb, RunResult } from "@junejs/core/resources";
+import { DataLayer } from "@junejs/core/config";
+//#region src/index.d.ts
+type Row = Record<string, unknown>;
+interface Schema {}
+type TableNames = keyof Schema & string;
+type RowOf<K extends TableNames> = Schema[K] & Row;
+type Operators = {
+  eq?: unknown;
+  ne?: unknown;
+  gt?: unknown;
+  gte?: unknown;
+  lt?: unknown;
+  lte?: unknown;
+  in?: unknown[];
+  like?: string;
+};
+type Where<T> = { [K in keyof T]?: T[K] | Operators; };
+type OrderBy<T> = { [K in keyof T]?: "asc" | "desc"; };
+declare class Table<T extends Row = Row> {
+  private readonly db;
+  private readonly name;
+  private readonly loaders;
+  constructor(db: JuneDb, name: string, loaders?: Map<string, unknown>);
+  private get compiler();
+  all(where?: Where<T>, opts?: {
+    orderBy?: OrderBy<T>;
+    limit?: number;
+    offset?: number;
+  }): Promise<T[]>;
+  findBy(where: Partial<T>): Promise<T | undefined>;
+  private ambientLoader;
+  private ambientListLoader;
+  insert(values: Partial<T>): Promise<RunResult>;
+  upsert(values: Partial<T>, opts: {
+    onConflict: string | string[];
+  }): Promise<T | undefined>;
+  update(where: Partial<T>, values: Partial<T>): Promise<RunResult>;
+  delete(where: Partial<T>): Promise<RunResult>;
+  loader(key?: string): Loader<string | number, T>;
+}
+type Juno = {
+  table<K extends TableNames>(name: K): Table<RowOf<K>>;
+  table<T extends Row = Row>(name: string): Table<T>;
+  db: JuneDb;
+  reads(...tables: string[]): void;
+  writes(...tables: string[]): void;
+};
+declare function juno(db: JuneDb): Juno;
+declare function installDataLayer(): void;
+declare function junoDataLayer(): DataLayer;
+declare function table<K extends TableNames>(name: K): Table<RowOf<K>>;
+declare function table<T extends Row = Row>(name: string): Table<T>;
+declare function reads(...tables: string[]): void;
+declare function writes(...tables: string[]): void;
+//#endregion
+//#region src/batch.d.ts
+type Loader<K, V> = {
+  load(key: K): Promise<V | null>;
+};
+declare function createLoader<K, V>(batchFn: (keys: K[]) => Promise<V[]>, keyOf: (value: V) => K): Loader<K, V>;
+declare function tableLoader<V extends Row = Row>(db: JuneDb, table: string, key?: string): Loader<string | number, V>;
+type ListLoader<K, V> = {
+  load(key: K): Promise<V[]>;
+};
+declare function createGroupLoader<K, V>(batchFn: (keys: K[]) => Promise<V[]>, keyOf: (value: V) => K): ListLoader<K, V>;
+declare function tableListLoader<V extends Row = Row>(db: JuneDb, table: string, key?: string): ListLoader<string | number, V>;
+//#endregion
+export { juno as _, tableListLoader as a, table as b, Operators as c, RowOf as d, Schema as f, installDataLayer as g, Where as h, createLoader as i, OrderBy as l, TableNames as m, Loader as n, tableLoader as o, Table as p, createGroupLoader as r, Juno as s, ListLoader as t, Row as u, junoDataLayer as v, writes as x, reads as y };

package/dist/batch.d.ts

@@ -0,0 +1,2 @@
+import { a as tableListLoader, i as createLoader, n as Loader, o as tableLoader, r as createGroupLoader, t as ListLoader } from "./batch-c_vy0gyx.js";
+export { ListLoader, Loader, createGroupLoader, createLoader, tableListLoader, tableLoader };

package/dist/batch.js

@@ -0,0 +1,88 @@
+import { dialectFor } from "./compiler.js";
+import { recordTableRead } from "@junejs/core/instrumentation";
+//#region src/batch.ts
+function inQuery(db, table, key, keys) {
+	recordTableRead(table);
+	const node = {
+		kind: "select",
+		from: table,
+		where: [{
+			col: key,
+			op: "in",
+			arity: keys.length
+		}]
+	};
+	return db.query(dialectFor(db).compile(node), keys);
+}
+function createLoader(batchFn, keyOf) {
+	let queue = [];
+	let scheduled = false;
+	function flush() {
+		const batch = queue;
+		queue = [];
+		scheduled = false;
+		batchFn([...new Set(batch.map((b) => b.key))]).then((values) => {
+			const byKey = new Map(values.map((v) => [keyOf(v), v]));
+			for (const b of batch) b.resolve(byKey.get(b.key) ?? null);
+		}, (err) => {
+			for (const b of batch) b.reject(err);
+		});
+	}
+	return { load(key) {
+		return new Promise((resolve, reject) => {
+			queue.push({
+				key,
+				resolve,
+				reject
+			});
+			if (!scheduled) {
+				scheduled = true;
+				queueMicrotask(flush);
+			}
+		});
+	} };
+}
+function tableLoader(db, table, key = "id") {
+	if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(table) || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) throw new Error(`unsafe SQL identifier: ${table}.${key}`);
+	return createLoader((keys) => inQuery(db, table, key, keys), (row) => row[key]);
+}
+function createGroupLoader(batchFn, keyOf) {
+	let queue = [];
+	let scheduled = false;
+	function flush() {
+		const batch = queue;
+		queue = [];
+		scheduled = false;
+		batchFn([...new Set(batch.map((b) => b.key))]).then((values) => {
+			const byKey = /* @__PURE__ */ new Map();
+			for (const v of values) {
+				const k = keyOf(v);
+				const list = byKey.get(k);
+				if (list) list.push(v);
+				else byKey.set(k, [v]);
+			}
+			for (const b of batch) b.resolve(byKey.get(b.key) ?? []);
+		}, (err) => {
+			for (const b of batch) b.reject(err);
+		});
+	}
+	return { load(key) {
+		return new Promise((resolve, reject) => {
+			queue.push({
+				key,
+				resolve,
+				reject
+			});
+			if (!scheduled) {
+				scheduled = true;
+				queueMicrotask(flush);
+			}
+		});
+	} };
+}
+function tableListLoader(db, table, key = "id") {
+	if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(table) || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) throw new Error(`unsafe SQL identifier: ${table}.${key}`);
+	return createGroupLoader((keys) => inQuery(db, table, key, keys), (row) => row[key]);
+}
+//#endregion
+export { createGroupLoader, createLoader, tableListLoader, tableLoader };

package/dist/compiler-PkKpLl6z.d.ts

@@ -0,0 +1,29 @@
+import { i as Node } from "./ast-BsvUEqhl.js";
+import { JuneDb } from "@junejs/core/resources";
+//#region src/compiler.d.ts
+declare function ident(name: string): string;
+declare abstract class Dialect {
+  private readonly cache;
+  compile(node: Node): string;
+  protected abstract placeholder(i: number): string;
+  protected quoteId(name: string): string;
+  protected emit(node: Node): string;
+}
+declare class SqliteDialect extends Dialect {
+  protected placeholder(): string;
+}
+declare class PostgresDialect extends Dialect {
+  protected placeholder(i: number): string;
+  protected quoteId(name: string): string;
+}
+declare class MysqlDialect extends Dialect {
+  protected placeholder(): string;
+  protected quoteId(name: string): string;
+  protected emit(node: Node): string;
+}
+declare const sqlite: SqliteDialect;
+declare const postgres: PostgresDialect;
+declare const mysql: MysqlDialect;
+declare function dialectFor(db: Pick<JuneDb, "dialect">): Dialect;
+//#endregion
+export { dialectFor as a, postgres as c, SqliteDialect as i, sqlite as l, MysqlDialect as n, ident as o, PostgresDialect as r, mysql as s, Dialect as t };

package/dist/compiler.d.ts

@@ -0,0 +1,2 @@
+import { a as dialectFor, c as postgres, i as SqliteDialect, l as sqlite, n as MysqlDialect, o as ident, r as PostgresDialect, s as mysql, t as Dialect } from "./compiler-PkKpLl6z.js";
+export { Dialect, MysqlDialect, PostgresDialect, SqliteDialect, dialectFor, ident, mysql, postgres, sqlite };

package/dist/compiler.js

@@ -0,0 +1,122 @@
+//#region src/compiler.ts
+const SYM = {
+	eq: "=",
+	ne: "!=",
+	gt: ">",
+	gte: ">=",
+	lt: "<",
+	lte: "<=",
+	like: "like"
+};
+function predicate(p, ph, q) {
+	if (p.op === "in") return `${q(p.col)} in (${Array.from({ length: p.arity }, ph).join(", ")})`;
+	return `${q(p.col)} ${SYM[p.op]} ${ph()}`;
+}
+function ident(name) {
+	if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) throw new Error(`unsafe SQL identifier: ${name}`);
+	return name;
+}
+function keyOf(node) {
+	switch (node.kind) {
+		case "select": return `s|${node.from}|` + node.where.map((p) => p.op === "in" ? `${p.col}:in${p.arity}` : `${p.col}:${p.op}`).join("&") + `|${(node.orderBy ?? []).map((o) => `${o.col} ${o.dir}`).join(",")}|${node.limit ?? ""}|${node.offset ?? ""}`;
+		case "insert": return `i|${node.into}|${node.columns.join(",")}`;
+		case "update": return `u|${node.table}|${node.set.join(",")}|${node.where.join(",")}`;
+		case "delete": return `d|${node.from}|${node.where.join(",")}`;
+		case "upsert": return `x|${node.into}|${node.columns.join(",")}|${node.conflict.join(",")}|${node.update.join(",")}`;
+	}
+}
+var Dialect = class {
+	cache = /* @__PURE__ */ new Map();
+	compile(node) {
+		const key = keyOf(node);
+		let sql = this.cache.get(key);
+		if (sql === void 0) {
+			sql = this.emit(node);
+			this.cache.set(key, sql);
+		}
+		return sql;
+	}
+	quoteId(name) {
+		return ident(name);
+	}
+	emit(node) {
+		const q = (name) => 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, q)).join(" and ")}` : "";
+				const order = node.orderBy?.length ? ` 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 ${q(node.from)}${where}${order}${limit}${offset}`;
+			}
+			case "insert": {
+				let i = 0;
+				const cols = node.columns.map(q);
+				const vals = node.columns.map(() => this.placeholder(++i));
+				return `insert into ${q(node.into)} (${cols.join(", ")}) values (${vals.join(", ")})`;
+			}
+			case "update": {
+				let i = 0;
+				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) => `${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(q);
+				const vals = node.columns.map(() => this.placeholder(++i));
+				const set = node.update.map((c) => `${q(c)} = excluded.${q(c)}`).join(", ");
+				return `insert into ${q(node.into)} (${cols.join(", ")}) values (${vals.join(", ")}) on conflict (${node.conflict.map(q).join(", ")}) do update set ${set} returning *`;
+			}
+		}
+	}
+};
+var SqliteDialect = class extends Dialect {
+	placeholder() {
+		return "?";
+	}
+};
+var PostgresDialect = class extends Dialect {
+	placeholder(i) {
+		return `$${i}`;
+	}
+	quoteId(name) {
+		return `"${ident(name)}"`;
+	}
+};
+var MysqlDialect = class extends Dialect {
+	placeholder() {
+		return "?";
+	}
+	quoteId(name) {
+		return `\`${ident(name)}\``;
+	}
+	emit(node) {
+		if (node.kind !== "upsert") return super.emit(node);
+		const q = (name) => this.quoteId(name);
+		const cols = node.columns.map(q);
+		const vals = node.columns.map(() => this.placeholder());
+		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}`;
+	}
+};
+const sqlite = new SqliteDialect();
+const postgres = new PostgresDialect();
+const mysql = new MysqlDialect();
+const BY_DIALECT = {
+	sqlite,
+	postgres,
+	mysql
+};
+function dialectFor(db) {
+	return BY_DIALECT[db.dialect ?? "sqlite"];
+}
+//#endregion
+export { Dialect, MysqlDialect, PostgresDialect, SqliteDialect, dialectFor, ident, mysql, postgres, sqlite };

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import { c as UpdateNode, i as Node, l as UpsertNode, n as DeleteNode, r as InsertNode, s as SelectNode } from "./ast-BsvUEqhl.js";
+import { i as taggingDb, n as tablesFromSql, r as tagSql, t as SqlTouch } from "./tag-B0HQho7q.js";
+import { a as dialectFor, c as postgres, i as SqliteDialect, l as sqlite, n as MysqlDialect, o as ident, r as PostgresDialect, s as mysql, t as Dialect } from "./compiler-PkKpLl6z.js";
+import { t as emitSchemaTypes } from "./types-qDjFvlZu.js";
+import { _ as juno, a as tableListLoader, b as table, c as Operators, d as RowOf, f as Schema, g as installDataLayer, h as Where, i as createLoader, l as OrderBy, m as TableNames, n as Loader, o as tableLoader, p as Table, r as createGroupLoader, s as Juno, t as ListLoader, u as Row, v as junoDataLayer, x as writes, y as reads } from "./batch-c_vy0gyx.js";
+export { type DeleteNode, Dialect, type InsertNode, Juno, type ListLoader, type Loader, MysqlDialect, type Node, Operators, OrderBy, PostgresDialect, Row, RowOf, Schema, type SelectNode, type SqlTouch, SqliteDialect, Table, TableNames, type UpdateNode, type UpsertNode, Where, createGroupLoader, createLoader, dialectFor, emitSchemaTypes, ident, installDataLayer, juno, junoDataLayer, mysql, postgres, reads, sqlite, table, tableListLoader, tableLoader, tablesFromSql, tagSql, taggingDb, writes };

package/dist/index.js

@@ -0,0 +1,205 @@
+import { Dialect, MysqlDialect, PostgresDialect, SqliteDialect, dialectFor, ident, mysql, postgres, sqlite } from "./compiler.js";
+import { createGroupLoader, createLoader, tableListLoader, tableLoader } from "./batch.js";
+import { tablesFromSql, tagSql, taggingDb } from "./tag.js";
+import { emitSchemaTypes } from "./types.js";
+import { recordTableRead, recordTableWrite } from "@junejs/core/instrumentation";
+import { db, registerSqlTagger, requestLocal } from "@junejs/db";
+//#region src/index.ts
+const OPS = /* @__PURE__ */ new Set([
+	"eq",
+	"ne",
+	"gt",
+	"gte",
+	"lt",
+	"lte",
+	"in",
+	"like"
+]);
+function isOperators(v) {
+	return v != null && typeof v === "object" && !Array.isArray(v);
+}
+var Table = class {
+	db;
+	name;
+	loaders;
+	constructor(db, name, loaders = /* @__PURE__ */ new Map()) {
+		this.db = db;
+		this.name = name;
+		this.loaders = loaders;
+	}
+	get compiler() {
+		return dialectFor(this.db);
+	}
+	async all(where, opts) {
+		recordTableRead(this.name);
+		const w = where ?? {};
+		const keys = Object.keys(w);
+		const [col] = keys;
+		if (!opts && keys.length === 1 && col !== void 0 && !isOperators(w[col])) return this.ambientListLoader(col).load(w[col]);
+		const predicates = [];
+		const params = [];
+		for (const c of keys) {
+			const v = w[c];
+			if (isOperators(v)) for (const op of Object.keys(v)) {
+				if (!OPS.has(op)) throw new Error(`unknown operator: ${op}`);
+				const operand = v[op];
+				if (op === "in") {
+					const arr = operand;
+					predicates.push({
+						col: c,
+						op: "in",
+						arity: arr.length
+					});
+					params.push(...arr);
+				} else {
+					predicates.push({
+						col: c,
+						op
+					});
+					params.push(operand);
+				}
+			}
+			else {
+				predicates.push({
+					col: c,
+					op: "eq"
+				});
+				params.push(v);
+			}
+		}
+		const orderBy = opts?.orderBy ? Object.entries(opts.orderBy).map(([c, dir]) => ({
+			col: c,
+			dir
+		})) : void 0;
+		const node = {
+			kind: "select",
+			from: this.name,
+			where: predicates,
+			orderBy,
+			limit: opts?.limit != null ? "param" : void 0,
+			offset: opts?.offset != null ? "param" : void 0
+		};
+		if (opts?.limit != null) params.push(opts.limit);
+		if (opts?.offset != null) params.push(opts.offset);
+		return this.db.query(this.compiler.compile(node), params);
+	}
+	async findBy(where) {
+		recordTableRead(this.name);
+		const keys = Object.keys(where);
+		const [col] = keys;
+		if (keys.length === 1 && col !== void 0) return await this.ambientLoader(col).load(where[col]) ?? void 0;
+		const where2 = keys.map((k) => ({
+			col: k,
+			op: "eq"
+		}));
+		const sql = this.compiler.compile({
+			kind: "select",
+			from: this.name,
+			where: where2,
+			limit: 1
+		});
+		return this.db.get(sql, Object.values(where));
+	}
+	ambientLoader(col) {
+		const key = `${this.name}::${col}`;
+		let loader = this.loaders.get(key);
+		if (!loader) {
+			loader = tableLoader(this.db, this.name, col);
+			this.loaders.set(key, loader);
+		}
+		return loader;
+	}
+	ambientListLoader(col) {
+		const key = `list:${this.name}::${col}`;
+		let loader = this.loaders.get(key);
+		if (!loader) {
+			loader = tableListLoader(this.db, this.name, col);
+			this.loaders.set(key, loader);
+		}
+		return loader;
+	}
+	async insert(values) {
+		recordTableWrite(this.name);
+		const sql = this.compiler.compile({
+			kind: "insert",
+			into: this.name,
+			columns: Object.keys(values)
+		});
+		return this.db.run(sql, Object.values(values));
+	}
+	async upsert(values, opts) {
+		recordTableWrite(this.name);
+		const columns = Object.keys(values);
+		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 = this.compiler.compile({
+			kind: "upsert",
+			into: this.name,
+			columns,
+			conflict,
+			update
+		});
+		return this.db.get(sql, Object.values(values));
+	}
+	async update(where, values) {
+		recordTableWrite(this.name);
+		const sql = this.compiler.compile({
+			kind: "update",
+			table: this.name,
+			set: Object.keys(values),
+			where: Object.keys(where)
+		});
+		return this.db.run(sql, [...Object.values(values), ...Object.values(where)]);
+	}
+	async delete(where) {
+		recordTableWrite(this.name);
+		const sql = this.compiler.compile({
+			kind: "delete",
+			from: this.name,
+			where: Object.keys(where)
+		});
+		return this.db.run(sql, Object.values(where));
+	}
+	loader(key = "id") {
+		return tableLoader(this.db, this.name, key);
+	}
+};
+function juno(db) {
+	const loaders = /* @__PURE__ */ new Map();
+	function table(name) {
+		return new Table(db, name, loaders);
+	}
+	return {
+		db: taggingDb(db),
+		table,
+		reads(...tables) {
+			for (const t of tables) recordTableRead(t);
+		},
+		writes(...tables) {
+			for (const t of tables) recordTableWrite(t);
+		}
+	};
+}
+const LOADERS = Symbol.for("junejs.juno.loaders");
+function installDataLayer() {
+	registerSqlTagger(tagSql);
+}
+function junoDataLayer() {
+	return {
+		install: installDataLayer,
+		module: "@junejs/juno",
+		emitTypes: emitSchemaTypes
+	};
+}
+function table(name) {
+	return new Table(db, name, requestLocal(LOADERS, () => /* @__PURE__ */ new Map()));
+}
+function reads(...tables) {
+	for (const t of tables) recordTableRead(t);
+}
+function writes(...tables) {
+	for (const t of tables) recordTableWrite(t);
+}
+//#endregion
+export { Dialect, MysqlDialect, PostgresDialect, SqliteDialect, Table, createGroupLoader, createLoader, dialectFor, emitSchemaTypes, ident, installDataLayer, juno, junoDataLayer, mysql, postgres, reads, sqlite, table, tableListLoader, tableLoader, tablesFromSql, tagSql, taggingDb, writes };

package/dist/tag-B0HQho7q.d.ts

@@ -0,0 +1,11 @@
+import { JuneDb } from "@junejs/core/resources";
+//#region src/tag.d.ts
+type SqlTouch = {
+  kind: "read" | "write" | "other";
+  tables: string[];
+};
+declare function tablesFromSql(sqlRaw: string): SqlTouch;
+declare function tagSql(sql: string): void;
+declare function taggingDb(db: JuneDb): JuneDb;
+//#endregion
+export { taggingDb as i, tablesFromSql as n, tagSql as r, SqlTouch as t };

package/dist/tag.d.ts

@@ -0,0 +1,2 @@
+import { i as taggingDb, n as tablesFromSql, r as tagSql, t as SqlTouch } from "./tag-B0HQho7q.js";
+export { SqlTouch, tablesFromSql, tagSql, taggingDb };

package/dist/tag.js

@@ -0,0 +1,60 @@
+import { recordTableRead, recordTableWrite } from "@junejs/core/instrumentation";
+//#region src/tag.ts
+const TABLE = "[`\"'\\[]?([A-Za-z_][\\w.]*)[`\"'\\]]?";
+function bare(token) {
+	const dot = token.lastIndexOf(".");
+	return dot >= 0 ? token.slice(dot + 1) : token;
+}
+function normalize(sql) {
+	return sql.replace(/--[^\n]*/g, " ").replace(/\/\*[\s\S]*?\*\//g, " ").replace(/\s+/g, " ").trim();
+}
+function collect(sql, re) {
+	const out = /* @__PURE__ */ new Set();
+	for (const m of sql.matchAll(re)) if (m[1]) out.add(bare(m[1]));
+	return [...out];
+}
+function tablesFromSql(sqlRaw) {
+	const sql = normalize(sqlRaw);
+	switch ((sql.match(/^(\w+)/)?.[1] ?? "").toLowerCase()) {
+		case "select":
+		case "with": return {
+			kind: "read",
+			tables: collect(sql, new RegExp(`\\b(?:from|join)\\s+${TABLE}`, "gi"))
+		};
+		case "insert": return {
+			kind: "write",
+			tables: collect(sql, new RegExp(`\\binto\\s+${TABLE}`, "gi"))
+		};
+		case "update": return {
+			kind: "write",
+			tables: collect(sql, new RegExp(`^update\\s+${TABLE}`, "gi"))
+		};
+		case "delete": return {
+			kind: "write",
+			tables: collect(sql, new RegExp(`\\bfrom\\s+${TABLE}`, "gi"))
+		};
+		default: return {
+			kind: "other",
+			tables: []
+		};
+	}
+}
+function tagSql(sql) {
+	const t = tablesFromSql(sql);
+	if (t.kind === "read") for (const name of t.tables) recordTableRead(name);
+	else if (t.kind === "write") for (const name of t.tables) recordTableWrite(name);
+}
+function taggingDb(db) {
+	const query = (sql, params) => (tagSql(sql), db.query(sql, params));
+	const get = (sql, params) => (tagSql(sql), db.get(sql, params));
+	const run = (sql, params) => (tagSql(sql), db.run(sql, params));
+	return new Proxy(db, { get(target, prop, receiver) {
+		if (prop === "query") return query;
+		if (prop === "get") return get;
+		if (prop === "run") return run;
+		const value = Reflect.get(target, prop, receiver);
+		return typeof value === "function" ? value.bind(target) : value;
+	} });
+}
+//#endregion
+export { tablesFromSql, tagSql, taggingDb };

package/dist/types-qDjFvlZu.d.ts

@@ -0,0 +1,5 @@
+import { JuneDb } from "@junejs/core/resources";
+//#region src/types.d.ts
+declare function emitSchemaTypes(db: JuneDb): Promise<string>;
+//#endregion
+export { emitSchemaTypes as t };

package/dist/types.d.ts

@@ -0,0 +1,2 @@
+import { t as emitSchemaTypes } from "./types-qDjFvlZu.js";
+export { emitSchemaTypes };

package/dist/types.js

@@ -0,0 +1,96 @@
+//#region src/types.ts
+function propKey(name) {
+	return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name) ? name : JSON.stringify(name);
+}
+const nul = (ts, nullable) => nullable ? `${ts} | null` : ts;
+function sqliteType(declared, notnull, pk) {
+	const t = declared.toUpperCase();
+	let base;
+	if (t.includes("INT")) base = "number";
+	else if (t.includes("CHAR") || t.includes("CLOB") || t.includes("TEXT")) base = "string";
+	else if (t === "" || t.includes("BLOB")) base = "Uint8Array";
+	else if (t.includes("REAL") || t.includes("FLOA") || t.includes("DOUB")) base = "number";
+	else base = "number";
+	return nul(base, notnull === 0 && pk === 0);
+}
+async function introspectSqlite(db) {
+	const tables = await db.query("select name from sqlite_master where type = 'table' and name not like 'sqlite_%' and name <> '_june_migrations' order by name");
+	const out = [];
+	for (const { name } of tables) {
+		const cols = await db.query("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;
+}
+function postgresType(dataType, nullable) {
+	const t = dataType.toLowerCase();
+	let base;
+	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);
+}
+function mysqlType(dataType, nullable) {
+	const t = dataType.toLowerCase();
+	let base;
+	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);
+}
+async function introspectInfoSchema(db, ph, scope, map) {
+	const tables = await db.query(`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 = [];
+	for (const { name } of tables) {
+		const cols = await db.query(`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;
+}
+function assemble(tables) {
+	return "// Generated by `june db types`. Do not edit — re-run after a migration.\nimport \"@junejs/juno\";\n\ndeclare module \"@junejs/juno\" {\n  interface Schema {\n" + tables.map(([name, fields]) => {
+		const lines = fields.map((f) => `      ${propKey(f.name)}: ${f.ts};`).join("\n");
+		return `    ${propKey(name)}: {\n${lines}\n    };`;
+	}).join("\n") + "\n  }\n}\n";
+}
+async function emitSchemaTypes(db) {
+	const dialect = db.dialect ?? "sqlite";
+	return assemble(dialect === "postgres" ? await introspectInfoSchema(db, "$1", "current_schema()", postgresType) : dialect === "mysql" ? await introspectInfoSchema(db, "?", "database()", mysqlType) : await introspectSqlite(db));
+}
+//#endregion
+export { emitSchemaTypes };

package/package.json

@@ -1,26 +1,33 @@
 {
   "name": "@junejs/juno",
-  "version": "0.0.30-dev.0",
+  "version": "0.0.30-dev.2",
   "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",
   "homepage": "https://june.build",
   "exports": {
-    ".": "./src/index.ts"
+    ".": {
+      "source": "./src/index.ts",
+      "bun": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
   },
   "files": [
+    "dist",
     "src"
   ],
   "scripts": {
     "test": "bun test",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "build": "tsdown"
   },
   "dependencies": {
-    "@junejs/core": ">=0.1.0-dev.0",
-    "@junejs/db": ">=0.0.33-dev.0"
+    "@junejs/core": ">=0.1.0-dev.4",
+    "@junejs/db": ">=0.0.33-dev.1"
   },
   "devDependencies": {
-    "@junejs/server": "^0.0.47",
+    "@junejs/server": "^0.1.0-dev.4",
     "@types/pg": "^8.20.0",
     "mysql2": "^3.22.5",
     "pg": "^8.21.0"

package/src/index.ts

@@ -67,15 +67,20 @@ function isOperators(v: unknown): v is Operators {
 }
 
 export class Table<T extends Row = Row> {
-  constructor(
-    private readonly db: JuneDb,
-    private readonly name: string,
-    // Per-request ambient-loader registry, shared across the juno() handle's
-    // .table() calls so concurrent findBy/all coalesce. Holds both point and list
-    // loaders (keyed apart). Optional/defaulted so a standalone `new Table(db,
-    // name)` still works (it just batches alone).
-    private readonly loaders: Map<string, unknown> = new Map(),
-  ) {}
+  // Explicit fields, not parameter properties — parameter properties aren't
+  // erasable, and June ships raw .ts that consumers type-strip (erasableSyntaxOnly).
+  private readonly db: JuneDb;
+  private readonly name: string;
+  // Per-request ambient-loader registry, shared across the juno() handle's
+  // .table() calls so concurrent findBy/all coalesce. Holds both point and list
+  // loaders (keyed apart). Optional/defaulted so a standalone `new Table(db,
+  // name)` still works (it just batches alone).
+  private readonly loaders: Map<string, unknown>;
+  constructor(db: JuneDb, name: string, loaders: Map<string, unknown> = new Map()) {
+    this.db = db;
+    this.name = name;
+    this.loaders = loaders;
+  }
 
   // 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,