agent-sql 0.2.2 → 0.3.0

package/dist/index.d.mts

@@ -15,10 +15,10 @@ type WhereGuard = GuardCol & {
 };
 type OneOrTwoDots<S extends string> = S extends `${infer A}.${infer B}.${infer C}` ? A extends `${string}.${string}` ? never : B extends `${string}.${string}` ? never : C extends `${string}.${string}` ? never : S : S extends `${infer A}.${infer B}` ? A extends `${string}.${string}` ? never : B extends `${string}.${string}` ? never : S : never;
 type SchemaGuardKeys<T> = { [Table in keyof T & string]: `${Table}.${keyof T[Table] & string}` }[keyof T & string];
-declare function applyGuards(ast: SelectStatement, guards: WhereGuard[], limit?: number): Result<SelectStatement>;
+declare function applyGuards(ast: SelectStatement, guards: WhereGuard[], limit: number): Result<SelectStatement>;
 //#endregion
 //#region src/output.d.ts
-declare function outputSql(ast: SelectStatement): string;
+declare function outputSql(ast: SelectStatement, pretty?: boolean): string;
 //#endregion
 //#region src/parse.d.ts
 declare function parseSql(expr: string): Result<SelectStatement>;
@@ -26,23 +26,31 @@ declare function parseSql(expr: string): Result<SelectStatement>;
 //#region src/index.d.ts
 declare function agentSql<S extends string>(sql: string, column: S & OneOrTwoDots<S>, value: GuardVal, {
   schema,
+  autoJoin,
   limit,
+  pretty,
   db,
   allowExtraFunctions
 }?: {
   schema?: Schema;
+  autoJoin?: boolean;
   limit?: number;
+  pretty?: boolean;
   db?: DbType;
   allowExtraFunctions?: string[];
 }): string;
 declare function createAgentSql<T extends Schema, S extends SchemaGuardKeys<T>>(schema: T, guards: Record<S, GuardVal>, opts: {
+  autoJoin?: boolean;
   limit?: number;
+  pretty?: boolean;
   throws: false;
   db?: DbType;
   allowExtraFunctions?: string[];
 }): (expr: string) => Result<string>;
 declare function createAgentSql<T extends Schema, S extends SchemaGuardKeys<T>>(schema: T, guards: Record<S, GuardVal>, opts?: {
+  autoJoin?: boolean;
   limit?: number;
+  pretty?: boolean;
   throws?: true;
   db?: DbType;
   allowExtraFunctions?: string[];

package/dist/index.mjs

@@ -36,6 +36,7 @@ function returnOrThrow(result, throws) {
 }
 //#endregion
 //#region src/functions.ts
+const DEFAULT_DB = "postgres";
 const COMMON_FUNCTIONS = [
 	"count",
 	"sum",
@@ -773,28 +774,184 @@ function checkWhereExpr(expr, allowed) {
 	}
 }
 //#endregion
+//#region src/joins.ts
+function defineSchema(schema) {
+	return schema;
+}
+function checkJoins(ast, schema) {
+	if (schema === void 0) {
+		if (ast.joins.length > 0) return Err(new SanitiseError("No joins allowed when using simple API without schema."));
+		return Ok(ast);
+	}
+	if (!(ast.from.table.name in schema)) return Err(new SanitiseError(`Table ${ast.from.table.name} is not allowed`));
+	for (const join of ast.joins) {
+		const joinSettings = schema[join.table.name];
+		if (joinSettings === void 0) return Err(new SanitiseError(`Table ${join.table.name} is not allowed`));
+		if (join.condition === null || join.condition.type === "join_using" || join.condition.expr.type !== "where_comparison" || join.condition.expr.operator !== "=" || join.condition.expr.left.type !== "where_value" || join.condition.expr.left.kind !== "column_ref" || join.condition.expr.right.type !== "where_value" || join.condition.expr.right.kind !== "column_ref") return Err(new SanitiseError("Only JOIN ON column_ref = column_ref supported"));
+		const { joining, foreign } = getJoinTableRef(join.table.name, join.condition.expr.left.ref, join.condition.expr.right.ref);
+		const joinTableCol = joinSettings[joining.name];
+		if (joinTableCol === void 0) return Err(new SanitiseError(`Tried to join using ${join.table.name}.${joining.name}`));
+		if (joinTableCol === null) {
+			const foreignTableSettings = schema[foreign.table];
+			if (foreignTableSettings === void 0) return Err(new SanitiseError(`Table ${foreign.name} is not allowed`));
+			const foreignCol = foreignTableSettings[foreign.name];
+			if (foreignCol === void 0 || foreignCol === null) return Err(new SanitiseError(`Tried to join using ${foreign.table}.${foreign.name}`));
+			if (joining.table !== foreignCol.ft || joining.name !== foreignCol.fc) return Err(new SanitiseError(`Tried to join using ${joining.table}.${joining.name}`));
+		} else if (foreign.table !== joinTableCol.ft || foreign.name !== joinTableCol.fc) return Err(new SanitiseError(`Tried to join using ${foreign.table}.${foreign.name}`));
+	}
+	return Ok(ast);
+}
+function getJoinTableRef(joinTableName, left, right) {
+	if (left.table === joinTableName) return {
+		joining: left,
+		foreign: right
+	};
+	return {
+		joining: right,
+		foreign: left
+	};
+}
+//#endregion
+//#region src/graph.ts
+function insertNeededGuardJoins(ast, schema, guards, autoJoin) {
+	if (schema === void 0) return Ok(ast);
+	if (!autoJoin) return Ok(ast);
+	return resolveGraphForJoins(ast, schema, guards);
+}
+function resolveGraphForJoins(ast, schema, guards) {
+	const haveTables = /* @__PURE__ */ new Set();
+	haveTables.add(ast.from.table.name);
+	for (const join of ast.joins) haveTables.add(join.table.name);
+	const adj = buildAdjacency(schema);
+	const newJoins = [];
+	for (const guard of guards) {
+		if (haveTables.has(guard.table)) continue;
+		const path = bfsPath(adj, haveTables, guard.table);
+		if (path === null) return Err(new SanitiseError(`No join path from query tables to guard table '${guard.table}'`));
+		let current = [...haveTables].find((t) => path[0] && (path[0].tableA === t || path[0].tableB === t));
+		for (const edge of path) {
+			const neighbor = edge.tableA === current ? edge.tableB : edge.tableA;
+			if (!haveTables.has(neighbor)) {
+				newJoins.push(edgeToJoin(edge, neighbor));
+				haveTables.add(neighbor);
+			}
+			current = neighbor;
+		}
+	}
+	if (newJoins.length === 0) return Ok(ast);
+	return Ok({
+		...ast,
+		joins: [...ast.joins, ...newJoins]
+	});
+}
+function buildAdjacency(schema) {
+	const adj = /* @__PURE__ */ new Map();
+	const tables = schema;
+	for (const [tableName, cols] of Object.entries(tables)) {
+		if (!adj.has(tableName)) adj.set(tableName, []);
+		for (const [colName, def] of Object.entries(cols)) if (def && typeof def === "object" && "ft" in def && "fc" in def) {
+			const edge = {
+				tableA: tableName,
+				colA: colName,
+				tableB: def.ft,
+				colB: def.fc
+			};
+			adj.get(tableName).push(edge);
+			if (!adj.has(edge.tableB)) adj.set(edge.tableB, []);
+			adj.get(edge.tableB).push(edge);
+		}
+	}
+	return adj;
+}
+function bfsPath(adj, startTables, target) {
+	if (startTables.has(target)) return [];
+	const visited = new Set(startTables);
+	const queue = [];
+	for (const t of startTables) queue.push([t, []]);
+	while (queue.length > 0) {
+		const [current, path] = queue.shift();
+		for (const edge of adj.get(current) ?? []) {
+			const neighbor = edge.tableA === current ? edge.tableB : edge.tableA;
+			if (visited.has(neighbor)) continue;
+			visited.add(neighbor);
+			const newPath = [...path, edge];
+			if (neighbor === target) return newPath;
+			queue.push([neighbor, newPath]);
+		}
+	}
+	return null;
+}
+function edgeToJoin(edge, fromTable) {
+	const [localTable, localCol, foreignTable, foreignCol] = edge.tableA === fromTable ? [
+		edge.tableA,
+		edge.colA,
+		edge.tableB,
+		edge.colB
+	] : [
+		edge.tableB,
+		edge.colB,
+		edge.tableA,
+		edge.colA
+	];
+	return {
+		type: "join",
+		joinType: "inner",
+		table: {
+			type: "table_ref",
+			name: localTable
+		},
+		condition: {
+			type: "join_on",
+			expr: {
+				type: "where_comparison",
+				operator: "=",
+				left: {
+					type: "where_value",
+					kind: "column_ref",
+					ref: {
+						type: "column_ref",
+						table: localTable,
+						name: localCol
+					}
+				},
+				right: {
+					type: "where_value",
+					kind: "column_ref",
+					ref: {
+						type: "column_ref",
+						table: foreignTable,
+						name: foreignCol
+					}
+				}
+			}
+		}
+	};
+}
+//#endregion
 //#region src/utils.ts
 function unreachable(x) {
 	throw new Error(`Unhandled variant: ${JSON.stringify(x)}`);
 }
 //#endregion
 //#region src/output.ts
-function outputSql(ast) {
-	return normaliseWhitespace(r(ast));
+function outputSql(ast, pretty = false) {
+	const res = r(ast, pretty);
+	if (pretty) return res;
+	return normaliseWhitespace(res);
 }
 function normaliseWhitespace(s) {
 	return s.replace(/\s+/g, " ").trim();
 }
-function r(node) {
+function r(node, pretty = false) {
 	if (node === null || node === void 0) return "";
 	if (typeof node === "string") return node;
 	if (typeof node === "number") return String(node);
 	switch (node.type) {
-		case "select": return handleSelect(node);
+		case "select": return handleSelect(node, pretty);
 		case "select_from": return handleSelectFrom(node);
-		case "join": return handleJoin(node);
+		case "join": return handleJoin(node, pretty);
 		case "join_on":
-		case "join_using": return handleJoinCondition(node);
+		case "join_using": return handleJoinCondition(node, pretty);
 		case "table_ref": return handleTableRef(node);
 		case "limit": return handleLimit(node);
 		case "offset": return handleOffset(node);
@@ -822,7 +979,7 @@ function r(node) {
 		case "case_expr": return handleCaseExpr(node);
 		case "cast_expr": return handleCastExpr(node);
 		case "where_value": return handleWhereValue(node);
-		case "column": return handleColumn(node);
+		case "column": return handleColumn(node, pretty);
 		case "column_expr": return handleColumnExpr(node);
 		case "column_ref": return handleColumnRef(node);
 		case "alias": return handleAlias(node);
@@ -830,23 +987,37 @@ function r(node) {
 		default: return unreachable(node);
 	}
 }
-function mapR(t) {
-	return t.map((n) => r(n).trim()).join(", ");
+function rMap(t, pretty = false, sep = ", ") {
+	return t.map((n) => r(n, pretty).trimEnd()).join(sep);
 }
-function handleSelect(node) {
-	const joins = node.joins.map((j) => r(j)).join(" ");
-	return `SELECT ${node.distinct ? `${r(node.distinct)} ` : ""}${mapR(node.columns)} ${r(node.from)} ${joins} ${r(node.where)} ${r(node.groupBy)} ${r(node.having)} ${r(node.orderBy)} ${r(node.limit)} ${r(node.offset)}`;
+function handleSelect(node, pretty) {
+	const distinctStr = node.distinct ? `${r(node.distinct)} ` : "";
+	const colSep = pretty ? ",\n" : ", ";
+	const joinSep = pretty ? "\n" : " ";
+	const joiner = pretty ? "\n" : " ";
+	return [
+		"SELECT",
+		`${distinctStr}${rMap(node.columns, pretty, colSep)}`,
+		r(node.from),
+		rMap(node.joins, pretty, joinSep),
+		r(node.where),
+		r(node.groupBy),
+		r(node.having),
+		r(node.orderBy),
+		r(node.limit),
+		r(node.offset)
+	].join(joiner);
 }
 function handleDistinct(_node) {
 	return "DISTINCT";
 }
 function handleDistinctOn(node) {
-	return `DISTINCT ON (${mapR(node.columns)})`;
+	return `DISTINCT ON (${rMap(node.columns)})`;
 }
 function handleSelectFrom(node) {
 	return `FROM ${r(node.table)}`;
 }
-function handleJoin(node) {
+function handleJoin(node, pretty) {
 	const typeStr = {
 		inner: "INNER JOIN",
 		inner_outer: "INNER OUTER JOIN",
@@ -859,12 +1030,13 @@ function handleJoin(node) {
 		cross: "CROSS JOIN",
 		natural: "NATURAL JOIN"
 	};
-	const cond = node.condition ? ` ${handleJoinCondition(node.condition)}` : "";
+	const cond = node.condition ? `${handleJoinCondition(node.condition, pretty)}` : "";
 	return `${typeStr[node.joinType]} ${r(node.table)}${cond}`;
 }
-function handleJoinCondition(node) {
-	if (node.type === "join_on") return `ON ${r(node.expr)}`;
-	return `USING (${node.columns.join(", ")})`;
+function handleJoinCondition(node, pretty) {
+	const prefix = pretty ? "\n  " : " ";
+	if (node.type === "join_on") return `${prefix}ON ${r(node.expr)}`;
+	return `${prefix}USING (${node.columns.join(", ")})`;
 }
 function handleLimit(node) {
 	return `LIMIT ${node.value}`;
@@ -873,13 +1045,13 @@ function handleOffset(node) {
 	return `OFFSET ${node.value}`;
 }
 function handleGroupBy(node) {
-	return `GROUP BY ${mapR(node.items)}`;
+	return `GROUP BY ${rMap(node.items)}`;
 }
 function handleHaving(node) {
 	return `HAVING ${r(node.expr)}`;
 }
 function handleOrderBy(node) {
-	return `ORDER BY ${mapR(node.items)}`;
+	return `ORDER BY ${rMap(node.items)}`;
 }
 function handleOrderByItem(node) {
 	const dir = node.direction ? ` ${node.direction.toUpperCase()}` : "";
@@ -914,7 +1086,7 @@ function handleWhereBetween(node) {
 	return `${r(node.expr)}${node.not ? " NOT" : ""} BETWEEN ${r(node.low)} AND ${r(node.high)}`;
 }
 function handleWhereIn(node) {
-	return `${r(node.expr)}${node.not ? " NOT" : ""} IN (${mapR(node.list)})`;
+	return `${r(node.expr)}${node.not ? " NOT" : ""} IN (${rMap(node.list)})`;
 }
 function handleCaseExpr(node) {
 	return `CASE${node.subject ? ` ${r(node.subject)}` : ""} ${node.whens.map((w) => `WHEN ${r(w.condition)} THEN ${r(w.result)}`).join(" ")}${node.else ? ` ELSE ${r(node.else)}` : ""} END`;
@@ -959,8 +1131,8 @@ function handleWhereValue(node) {
 		default: return unreachable(node);
 	}
 }
-function handleColumn(node) {
-	return `${r(node.expr)} ${r(node.alias)}`;
+function handleColumn(node, pretty) {
+	return `${pretty ? "  " : ""}${r(node.expr)} ${r(node.alias)}`;
 }
 function handleAlias(node) {
 	return `AS ${node.name}`;
@@ -972,7 +1144,7 @@ function handleColumnRef(node) {
 function handleFuncCall(node) {
 	const { name, args } = node;
 	if (args.kind === "wildcard") return `${name}(*)`;
-	return `${name}(${args.distinct ? "DISTINCT " : ""}${mapR(args.args)})`;
+	return `${name}(${args.distinct ? "DISTINCT " : ""}${rMap(args.args)})`;
 }
 function handleColumnExpr(node) {
 	switch (node.kind) {
@@ -985,7 +1157,7 @@ function handleColumnExpr(node) {
 //#endregion
 //#region src/guard.ts
 const DEFAULT_LIMIT = 1e4;
-function applyGuards(ast, guards, limit = DEFAULT_LIMIT) {
+function applyGuards(ast, guards, limit) {
 	const ast2 = addWhereGuard(ast, guards);
 	if (!ast2.ok) return ast2;
 	return addLimitGuard(ast2.data, limit);
@@ -1090,44 +1262,6 @@ function tableEquals(a, b) {
 	return a.schema == b.schema && a.name == b.name;
 }
 //#endregion
-//#region src/joins.ts
-function defineSchema(schema) {
-	return schema;
-}
-function checkJoins(ast, schema) {
-	if (schema === void 0) {
-		if (ast.joins.length > 0) return Err(new SanitiseError("No joins allowed when using simple API without schema."));
-		return Ok(ast);
-	}
-	if (!(ast.from.table.name in schema)) return Err(new SanitiseError(`Table ${ast.from.table.name} is not allowed`));
-	for (const join of ast.joins) {
-		const joinSettings = schema[join.table.name];
-		if (joinSettings === void 0) return Err(new SanitiseError(`Table ${join.table.name} is not allowed`));
-		if (join.condition === null || join.condition.type === "join_using" || join.condition.expr.type !== "where_comparison" || join.condition.expr.operator !== "=" || join.condition.expr.left.type !== "where_value" || join.condition.expr.left.kind !== "column_ref" || join.condition.expr.right.type !== "where_value" || join.condition.expr.right.kind !== "column_ref") return Err(new SanitiseError("Only JOIN ON column_ref = column_ref supported"));
-		const { joining, foreign } = getJoinTableRef(join.table.name, join.condition.expr.left.ref, join.condition.expr.right.ref);
-		const joinTableCol = joinSettings[joining.name];
-		if (joinTableCol === void 0) return Err(new SanitiseError(`Tried to join using ${join.table.name}.${joining.name}`));
-		if (joinTableCol === null) {
-			const foreignTableSettings = schema[foreign.table];
-			if (foreignTableSettings === void 0) return Err(new SanitiseError(`Table ${foreign.name} is not allowed`));
-			const foreignCol = foreignTableSettings[foreign.name];
-			if (foreignCol === void 0 || foreignCol === null) return Err(new SanitiseError(`Tried to join using ${foreign.table}.${foreign.name}`));
-			if (joining.table !== foreignCol.ft || joining.name !== foreignCol.fc) return Err(new SanitiseError(`Tried to join using ${joining.table}.${joining.name}`));
-		} else if (foreign.table !== joinTableCol.ft || foreign.name !== joinTableCol.fc) return Err(new SanitiseError(`Tried to join using ${foreign.table}.${foreign.name}`));
-	}
-	return Ok(ast);
-}
-function getJoinTableRef(joinTableName, left, right) {
-	if (left.table === joinTableName) return {
-		joining: left,
-		foreign: right
-	};
-	return {
-		joining: right,
-		foreign: left
-	};
-}
-//#endregion
 //#region src/sql.ohm-bundle.js
 const result = makeRecipe([
 	"grammar",
@@ -7186,34 +7320,40 @@ function parseSql(expr) {
 }
 //#endregion
 //#region src/index.ts
-function agentSql(sql, column, value, { schema, limit, db = "postgres", allowExtraFunctions = [] } = {}) {
+function agentSql(sql, column, value, { schema, autoJoin = true, limit = DEFAULT_LIMIT, pretty = false, db = DEFAULT_DB, allowExtraFunctions = [] } = {}) {
 	return privateAgentSql(sql, {
 		guards: { [column]: value },
 		schema,
+		autoJoin,
 		limit,
+		pretty,
 		db,
 		allowExtraFunctions,
 		throws: true
 	});
 }
-function createAgentSql(schema, guards, { limit, throws = true, db = "postgres", allowExtraFunctions = [] } = {}) {
+function createAgentSql(schema, guards, { autoJoin = true, limit = DEFAULT_LIMIT, pretty = false, db = DEFAULT_DB, allowExtraFunctions = [], throws = true } = {}) {
 	return (expr) => throws ? privateAgentSql(expr, {
 		guards,
 		schema,
+		autoJoin,
 		limit,
+		pretty,
 		db,
 		allowExtraFunctions,
 		throws
 	}) : privateAgentSql(expr, {
 		guards,
 		schema,
+		autoJoin,
 		limit,
+		pretty,
 		db,
 		allowExtraFunctions,
 		throws
 	});
 }
-function privateAgentSql(sql, { guards: guardsRaw, schema, limit, db, allowExtraFunctions, throws }) {
+function privateAgentSql(sql, { guards: guardsRaw, schema, autoJoin, limit, pretty, db, allowExtraFunctions, throws }) {
 	const guards = resolveGuards(guardsRaw);
 	if (!guards.ok) throw guards.error;
 	const ast = parseSql(sql);
@@ -7222,9 +7362,11 @@ function privateAgentSql(sql, { guards: guardsRaw, schema, limit, db, allowExtra
 	if (!ast2.ok) return returnOrThrow(ast2, throws);
 	const ast3 = checkFunctions(ast2.data, db, allowExtraFunctions);
 	if (!ast3.ok) return returnOrThrow(ast3, throws);
-	const san = applyGuards(ast3.data, guards.data, limit);
+	const ast4 = insertNeededGuardJoins(ast3.data, schema, guards.data, autoJoin);
+	if (!ast4.ok) return returnOrThrow(ast4, throws);
+	const san = applyGuards(ast4.data, guards.data, limit);
 	if (!san.ok) return returnOrThrow(san, throws);
-	const res = outputSql(san.data);
+	const res = outputSql(san.data, pretty);
 	if (throws) return res;
 	return Ok(res);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-sql",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "A starter for creating a TypeScript package.",
   "keywords": [
     "agent",
@@ -36,7 +36,7 @@
     "test": "vp test",
     "check": "vp check",
     "prepublishOnly": "vp run build",
-    "gen:types": "ohm generateBundles --withTypes --esm 'src/sql.ohm'",
+    "ohm": "ohm generateBundles --withTypes --esm 'src/sql.ohm'",
     "script": "vp exec tsx"
   },
   "dependencies": {