agent-sql 0.2.2 → 0.2.3

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>;
@@ -27,22 +27,26 @@ declare function parseSql(expr: string): Result<SelectStatement>;
 declare function agentSql<S extends string>(sql: string, column: S & OneOrTwoDots<S>, value: GuardVal, {
   schema,
   limit,
+  pretty,
   db,
   allowExtraFunctions
 }?: {
   schema?: Schema;
   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: {
   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?: {
   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",
@@ -779,22 +780,24 @@ function unreachable(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 +825,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 +833,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 +876,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 +891,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 +932,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 +977,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 +990,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 +1003,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);
@@ -7186,21 +7204,23 @@ function parseSql(expr) {
 }
 //#endregion
 //#region src/index.ts
-function agentSql(sql, column, value, { schema, limit, db = "postgres", allowExtraFunctions = [] } = {}) {
+function agentSql(sql, column, value, { schema, limit = DEFAULT_LIMIT, pretty = false, db = DEFAULT_DB, allowExtraFunctions = [] } = {}) {
 	return privateAgentSql(sql, {
 		guards: { [column]: value },
 		schema,
 		limit,
+		pretty,
 		db,
 		allowExtraFunctions,
 		throws: true
 	});
 }
-function createAgentSql(schema, guards, { limit, throws = true, db = "postgres", allowExtraFunctions = [] } = {}) {
+function createAgentSql(schema, guards, { limit = DEFAULT_LIMIT, pretty = false, db = DEFAULT_DB, allowExtraFunctions = [], throws = true } = {}) {
 	return (expr) => throws ? privateAgentSql(expr, {
 		guards,
 		schema,
 		limit,
+		pretty,
 		db,
 		allowExtraFunctions,
 		throws
@@ -7208,12 +7228,13 @@ function createAgentSql(schema, guards, { limit, throws = true, db = "postgres",
 		guards,
 		schema,
 		limit,
+		pretty,
 		db,
 		allowExtraFunctions,
 		throws
 	});
 }
-function privateAgentSql(sql, { guards: guardsRaw, schema, limit, db, allowExtraFunctions, throws }) {
+function privateAgentSql(sql, { guards: guardsRaw, schema, limit, pretty, db, allowExtraFunctions, throws }) {
 	const guards = resolveGuards(guardsRaw);
 	if (!guards.ok) throw guards.error;
 	const ast = parseSql(sql);
@@ -7224,7 +7245,7 @@ function privateAgentSql(sql, { guards: guardsRaw, schema, limit, db, allowExtra
 	if (!ast3.ok) return returnOrThrow(ast3, throws);
 	const san = applyGuards(ast3.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.2.3",
   "description": "A starter for creating a TypeScript package.",
   "keywords": [
     "agent",