qubu 0.6.1 → 0.6.2

package/dist/index.mjs

@@ -1,58 +1,47 @@
-import { a as assertDialectCapability } from "./json-Db7XRD91.mjs";
-import { A as parenthesize, B as resultValueOf, C as makeExpression, E as markSchemaExpression, F as dateResultDecoder, I as decodeResultRow, L as jsonTextResultDecoder, M as ResultDecodingError, N as booleanResultDecoder, O as fragment, P as createResultShape, R as resultShapeValue, S as isSchemaExpression, T as markExpressionCategory, V as timestampResultDecoder, b as snakeCaseIdentifier, i as identifier, k as isFragment, l as value, o as asValue, t as createColumnReference, w as makeSchemaExpression, x as isExpression, y as resolveSqlNames, z as resultValue } from "./column-BzN8KFJa.mjs";
-import { c as render, n as call, o as cast, r as schemaCall, t as createClause } from "./types-BLNRatG_.mjs";
-import { n as queryValidationError, t as QueryValidationError } from "./errors-Dxv73YJu.mjs";
-import { C as identityColumn, S as generatedColumn, _ as uuid, b as externalDefault, c as integer, d as nativeStorage, f as nullable, g as timestamp, h as text, i as column, l as json, m as portableStorage, n as binary, o as date, p as numeric, r as boolean, s as encodeColumnParameter, t as bigint, u as nativeColumn, x as externalGeneratedColumn } from "./column-CFvSbil0.mjs";
-import { a as isDistinctFrom, c as lt, d as notLike, f as expressionOperand, i as gte, l as lte, m as renderOperands, n as eq, o as isNotDistinctFrom, p as isNullOperand, r as gt, s as like, u as ne } from "./relational-DSAJ-l58.mjs";
-import { t as omit } from "./omit-OxV58AwX.mjs";
-import { r as exposeColumns, t as createSource } from "./source-BDuUXmAk.mjs";
-import { n as alias, r as lateral, t as table } from "./table-C1QGNe4P.mjs";
-import { a as primaryKey, c as uniqueConstraint, i as foreignKey, n as catalogForeignKey, o as references, r as check, s as unique, t as catalogCheck, u as index } from "./constraints-DM_tarXc.mjs";
-import { c as unsafeSchemaSql } from "./expressions-BCjc08zw.mjs";
-import { i as schema } from "./registry-oWDiqD7i.mjs";
+import { A as fragment, B as decodeResultRow, C as isExpression, D as markExpressionCategory, E as makeSchemaExpression, F as attachResultValue, G as timestampResultDecoder, H as resultShapeValue, I as bigintResultDecoder, L as booleanResultDecoder, M as parenthesize, O as markSchemaExpression, P as ResultDecodingError, R as createResultShape, S as snakeCaseIdentifier, T as makeExpression, U as resultValue, V as jsonTextResultDecoder, W as resultValueOf, X as assertDialectCapability, c as externalDefault, d as identityColumn, i as identifier, j as isFragment, l as externalGeneratedColumn, t as createColumnReference, u as generatedColumn, w as isSchemaExpression, x as resolveSqlNames, z as dateResultDecoder } from "./column-DDRvD7SF.mjs";
+import { i as value, t as asValue } from "./value-CpaUFtjw.mjs";
+import { c as render, n as call, o as cast, r as schemaCall, t as createClause } from "./types-CYHpSPwj.mjs";
+import { n as QueryValidationError, r as queryValidationError, t as omit } from "./omit-VEr9Ydux.mjs";
+import { _ as timestamp, c as encodeColumnParameter, d as nativeColumn, f as nativeStorage, g as text, h as portableStorage, i as column, l as integer, m as numeric, n as binary, o as columnSqlType, p as nullable, r as boolean, s as date, t as bigint, u as json, v as uuid } from "./column-Cyc2CMnG.mjs";
+import { a as isDistinctFrom, c as lt, d as notLike, f as expressionOperand, i as gte, l as lte, m as renderOperands, n as eq, o as isNotDistinctFrom, p as isNullOperand, r as gt, s as like, u as ne } from "./relational-CoPBETjI.mjs";
+import { r as exposeColumns, t as createSource } from "./source-DYSUqzvb.mjs";
+import { n as alias, r as lateral, t as table } from "./table-B8zEq0az.mjs";
+import { a as primaryKey, c as uniqueConstraint, i as foreignKey, n as catalogForeignKey, o as references, r as check, s as unique, t as catalogCheck, u as index } from "./constraints-CAmi18Uk.mjs";
+import { c as unsafeSchemaSql } from "./expressions-_6JF_J77.mjs";
+import { i as schema } from "./registry-BXE_4M9P.mjs";
+import { i as renderDuplicateKeyUpdate, n as incomingAlias } from "./on-duplicate-key-update-Czsw1Yq-.mjs";
 //#region src/execution.ts
 function qubu(adapter, options = {}) {
-	const observation = createObservation(options.hooks);
-	const client = createClient(adapter, observation);
-	if (!isTransactionalQueryAdapter(adapter)) return client;
-	return Object.freeze({
-		...client,
-		async transaction(callback, transactionOptions) {
-			const active = startTransactionOperation(observation, transactionOptions?.hookMetadata);
-			try {
-				const result = await adapter.transaction(async (transactionAdapter) => callback(createClient(transactionAdapter, observation, active?.operation.id)), adapterTransactionOptions(transactionOptions));
-				active?.finish({ status: "success" });
-				return result;
-			} catch (error) {
-				active?.finish({
-					status: "error",
-					error
-				});
-				throw error;
-			}
-		}
-	});
+	return createClient(adapter, createObservation(options.hooks));
 }
 function createClient(adapter, observation, parentId) {
-	const client = {
+	return Object.freeze({
 		adapter,
 		execute(query, options) {
 			return executeInternal(query, adapter, options ?? {}, observation, parentId);
 		},
 		rows(query, options) {
 			return executeRowsInternal(query, adapter, options ?? {}, observation, parentId);
-		}
-	};
-	const streaming = isStreamingQueryAdapter(adapter);
-	const explainable = isExplainableQueryAdapter(adapter);
-	if (!streaming && !explainable) return Object.freeze(client);
-	return Object.freeze({
-		...client,
-		...streaming ? { stream(query, options) {
+		},
+		...isStreamingQueryAdapter(adapter) ? { stream(query, options) {
 			return streamInternal(query, adapter, options ?? {}, observation, parentId);
 		} } : {},
-		...explainable ? { explain(query, options) {
+		...isExplainableQueryAdapter(adapter) ? { explain(query, options) {
 			return explainInternal(query, adapter, options ?? {}, observation, parentId);
+		} } : {},
+		...isTransactionalQueryAdapter(adapter) ? { async transaction(callback, options) {
+			const active = startTransactionOperation(observation, options?.hookMetadata, parentId);
+			try {
+				const result = await adapter.transaction(async (scoped) => callback(createClient(scoped, observation, active?.operation.id)), adapterTransactionOptions(options));
+				active?.finish({ status: "success" });
+				return result;
+			} catch (error) {
+				active?.finish({
+					status: "error",
+					error
+				});
+				throw error;
+			}
 		} } : {}
 	});
 }
@@ -83,11 +72,11 @@ function startQueryOperation(observation, kind, request, dialect, metadata, pare
 		parentId
 	});
 }
-function startTransactionOperation(observation, metadata) {
+function startTransactionOperation(observation, metadata, parentId) {
 	return startOperation(observation, {
 		kind: "transaction",
 		metadata,
-		parentId: void 0
+		parentId
 	});
 }
 function startOperation(observation, input) {
@@ -278,7 +267,8 @@ function createExplainRequest(query, adapter, options) {
 	});
 	const statement = Object.freeze({
 		text: dialect.explain.render(request.statement.text, query.queryKind, explainRenderOptions(options)),
-		parameters: request.statement.parameters
+		parameters: request.statement.parameters,
+		...request.statement.parameterSqlTypes === void 0 ? {} : { parameterSqlTypes: request.statement.parameterSqlTypes }
 	});
 	return Object.freeze({
 		...request,
@@ -307,7 +297,8 @@ function isQuery(value) {
 //#region src/expressions/map-result.ts
 /** Attach an application decoder to an expression without changing its SQL. */
 function mapResult(expression, decoder) {
-	const mapped = makeExpression(expression.expressionKind, (context) => context.render(expression), expression.expressionCategory, resultValue(resultValueOf(expression)?.type, decoder));
+	const metadata = resultValueOf(expression);
+	const mapped = makeExpression(expression.expressionKind, (context) => context.render(expression), expression.expressionCategory, resultValue(metadata?.type, decoder, metadata?.sqlType));
 	return isSchemaExpression(expression) ? markSchemaExpression(mapped) : mapped;
 }
 //#endregion
@@ -315,6 +306,7 @@ function mapResult(expression, decoder) {
 function caseWhen(condition, thenValue, elseValue) {
 	const thenExpression = asValue(thenValue);
 	const elseExpression = asValue(elseValue);
+	const domain = resultValueOf(thenExpression)?.sqlType ?? resultValueOf(elseExpression)?.sqlType;
 	return makeSchemaExpression("operator", (context) => {
 		context.append("CASE WHEN ");
 		context.render(condition);
@@ -323,7 +315,7 @@ function caseWhen(condition, thenValue, elseValue) {
 		context.append(" ELSE ");
 		context.render(elseExpression);
 		context.append(" END");
-	});
+	}, resultValue(void 0, void 0, domain === "integer" ? "decimal" : domain));
 }
 //#endregion
 //#region src/expressions/sql.ts
@@ -368,40 +360,40 @@ function count(expression) {
 		if (expression) context.render(expression);
 		else context.append("*");
 		context.append(")");
-	}, "aggregate");
+	}, "aggregate", resultValue(void 0, void 0, "integer"));
 }
 function countDistinct(expression) {
 	return makeExpression("function", (context) => {
 		context.append("COUNT(DISTINCT ");
 		context.render(expression);
 		context.append(")");
-	}, "aggregate");
+	}, "aggregate", resultValue(void 0, void 0, "integer"));
 }
 function sum(expression) {
-	return markExpressionCategory(call("SUM", expression), "aggregate");
+	return markExpressionCategory(attachResultValue(call("SUM", expression), resultValueOf(expression)), "aggregate");
 }
 function avg(expression) {
-	return markExpressionCategory(call("AVG", expression), "aggregate");
+	return markExpressionCategory(attachResultValue(call("AVG", expression), resultValue(void 0, void 0, "decimal")), "aggregate");
 }
 function min(expression) {
-	return markExpressionCategory(call("MIN", expression), "aggregate");
+	return markExpressionCategory(attachResultValue(call("MIN", expression), resultValueOf(expression)), "aggregate");
 }
 function max(expression) {
-	return markExpressionCategory(call("MAX", expression), "aggregate");
+	return markExpressionCategory(attachResultValue(call("MAX", expression), resultValueOf(expression)), "aggregate");
 }
 //#endregion
 //#region src/expressions/functions/string.ts
 function lower(input) {
-	return schemaCall("LOWER", input);
+	return attachResultValue(schemaCall("LOWER", input), resultValue(void 0, void 0, "text"));
 }
 function upper(input) {
-	return schemaCall("UPPER", input);
+	return attachResultValue(schemaCall("UPPER", input), resultValue(void 0, void 0, "text"));
 }
 function coalesce(first, ...rest) {
-	return schemaCall("COALESCE", first, ...rest);
+	return attachResultValue(schemaCall("COALESCE", first, ...rest), resultValueOf(first));
 }
 function concat(...argumentsToConcat) {
-	return schemaCall("CONCAT", ...argumentsToConcat);
+	return attachResultValue(schemaCall("CONCAT", ...argumentsToConcat), resultValue(void 0, void 0, "text"));
 }
 //#endregion
 //#region src/expressions/functions/window.ts
@@ -427,16 +419,16 @@ function over(expression, window) {
 			});
 		}
 		context.append(")");
-	}, "window");
+	}, "window", resultValueOf(expression));
 }
 function rowNumber() {
-	return markExpressionCategory(call("ROW_NUMBER"), "window");
+	return markExpressionCategory(attachResultValue(call("ROW_NUMBER"), resultValue(void 0, void 0, "integer")), "window");
 }
 function rank() {
-	return markExpressionCategory(call("RANK"), "window");
+	return markExpressionCategory(attachResultValue(call("RANK"), resultValue(void 0, void 0, "integer")), "window");
 }
 function denseRank() {
-	return markExpressionCategory(call("DENSE_RANK"), "window");
+	return markExpressionCategory(attachResultValue(call("DENSE_RANK"), resultValue(void 0, void 0, "integer")), "window");
 }
 //#endregion
 //#region src/expressions/subquery.ts
@@ -481,7 +473,7 @@ function jsonScalar(document, path, kind) {
 		assertDialectCapability(context.dialect, "json");
 		if (!context.dialect.json) throw new Error(`Dialect "${context.dialect.name}" advertises JSON support without a JSON renderer`);
 		context.dialect.json.renderScalar(context, document, path.segments, kind);
-	}, kind === "boolean" ? resultValue("boolean") : void 0);
+	}, kind === "boolean" ? resultValue("boolean") : resultValue(void 0, void 0, kind === "number" ? "decimal" : "text"));
 }
 /** Extract a JSON string, returning SQL NULL for missing, null, or non-string values. */
 function jsonText(document, path) {
@@ -513,7 +505,7 @@ function arithmetic(operator, left, right) {
 		context.append(` ${operator} `);
 		context.render(rightExpression);
 		context.append(")");
-	});
+	}, resultValue(void 0, void 0, resultValueOf(left)?.sqlType === "integer" ? "decimal" : resultValueOf(left)?.sqlType));
 }
 const add = (left, right) => arithmetic("+", left, right);
 const subtract = (left, right) => arithmetic("-", left, right);
@@ -686,11 +678,11 @@ function renderPagination(context, clauses) {
 		if (index > 0) context.append(" ");
 		if (part.kind === "offset") {
 			context.append("OFFSET ");
-			context.parameter(part.rows);
+			context.parameter(part.rows, "integer");
 			context.append(" ROWS");
 		} else {
 			context.append(`FETCH ${part.direction} `);
-			context.parameter(part.rows);
+			context.parameter(part.rows, "integer");
 			context.append(" ROWS ONLY");
 		}
 	});
@@ -824,7 +816,9 @@ function select(selection, ...parts) {
 		clause,
 		index
 	})).sort((left, right) => left.clause.order - right.clause.order || left.index - right.index).map(({ clause }) => clause);
-	return createQuery("select", selectionRow(selection), selectionResultShape(selection), (context) => {
+	const row = selectionRow(selection);
+	const query = createQuery("select", row, selectionResultShape(selection), renderBody);
+	function renderBody(context, extraOrdering) {
 		const beforeSelect = orderedClauses.filter((clause) => clause.placement === "before-select");
 		const afterSelect = orderedClauses.filter((clause) => clause.placement === "after-select");
 		const paginationClauses = afterSelect.filter((clause) => clause.clauseKind === "offset" || clause.clauseKind === "fetch");
@@ -841,6 +835,12 @@ function select(selection, ...parts) {
 			context.append(" ");
 		}
 		renderSelection(selection, context);
+		extraOrdering?.terms.forEach((term, index) => {
+			if (!extraOrdering.hidden[index]) return;
+			context.append(", ");
+			context.render(term.expression);
+			context.append(" AS " + context.dialect.quoteIdentifier(extraOrdering.names[index]));
+		});
 		for (const clause of afterSelect) {
 			if (clause.clauseKind === "correlate") continue;
 			if (clause === distinctClause) continue;
@@ -852,7 +852,56 @@ function select(selection, ...parts) {
 				continue;
 			}
 			context.append(" ");
-			context.render(clause);
+			if (clause.clauseKind === "order-by" && extraOrdering) {
+				context.append("ORDER BY ");
+				extraOrdering.terms.forEach((term, index) => {
+					if (index) context.append(", ");
+					context.append(context.dialect.quoteIdentifier(extraOrdering.names[index]));
+					if (term.direction) context.append(` ${term.direction}`);
+					if (term.nulls) context.append(` NULLS ${term.nulls}`);
+				});
+			} else context.render(clause);
+		}
+	}
+	return Object.freeze({
+		...query,
+		cardinality: normalizedClauses.some((clause) => clause.clauseKind === "fetch" && clause.rows <= 1) ? "zero-or-one" : normalizedClauses.every((clause) => [
+			"distinct",
+			"order-by",
+			"row-lock",
+			"with"
+		].includes(clause.clauseKind)) ? "exactly-one" : "many",
+		renderJsonRows(context, ordinal) {
+			const terms = orderedClauses.find((clause) => clause.clauseKind === "order-by")?.terms ?? [];
+			if (orderedClauses.some((clause) => clause.clauseKind === "distinct") && terms.some((term) => !Object.values(selection).includes(term.expression))) throw new TypeError("Nested JSON DISTINCT ordering must use selected expressions");
+			const occupied = new Set(Object.keys(row).map(snakeCaseIdentifier));
+			occupied.add(ordinal);
+			const hidden = [];
+			const names = terms.map((term, index) => {
+				const selected = Object.entries(selection).find(([, expression]) => expression === term.expression);
+				hidden.push(selected === void 0);
+				if (selected) return snakeCaseIdentifier(selected[0]);
+				let name = `__qubu_json_sort_${index}`;
+				while (occupied.has(name)) name += "_";
+				occupied.add(name);
+				return name;
+			});
+			const quote = context.dialect.quoteIdentifier;
+			context.append(`SELECT ${quote("__qubu_ordered")}.*, DENSE_RANK() OVER (`);
+			if (terms.length) context.append("ORDER BY ");
+			terms.forEach((term, index) => {
+				if (index) context.append(", ");
+				context.append(`${quote("__qubu_ordered")}.${quote(names[index])}`);
+				if (term.direction) context.append(` ${term.direction}`);
+				if (term.nulls) context.append(` NULLS ${term.nulls}`);
+			});
+			context.append(`) AS ${quote(ordinal)} FROM (`);
+			renderBody(context, {
+				terms,
+				names,
+				hidden
+			});
+			context.append(`) AS ${quote("__qubu_ordered")}`);
 		}
 	});
 }
@@ -864,8 +913,10 @@ function setOperation(operator, left, right) {
 		row: left.row,
 		resultShape: left.resultShape,
 		render: (context) => {
+			if (context.dialect.name === "sqlite") context.append("SELECT * FROM ");
 			context.render(parenthesize(left));
 			context.append(` ${operator} `);
+			if (context.dialect.name === "sqlite") context.append("SELECT * FROM ");
 			context.render(parenthesize(right));
 		}
 	};
@@ -1241,6 +1292,30 @@ function insertSelect(query, columns) {
 function insertInto(table, source, ...clauses) {
 	validateInsert(table, source);
 	const insertClauses = clauses;
+	const duplicate = insertClauses.find((clause) => clause.clauseKind === "on-duplicate-key-update");
+	if (duplicate) {
+		if (insertClauses.some((clause) => clause.clauseKind === "returning")) throw queryValidationError({
+			code: "invalid-mutation",
+			context: "insert.duplicate-key",
+			path: ["returning"],
+			message: "MySQL duplicate-key updates do not support RETURNING",
+			hint: "Read the row in a separate query."
+		});
+		if (duplicate.table !== table) throw queryValidationError({
+			code: "invalid-mutation",
+			context: "insert.duplicate-key",
+			path: ["onDuplicateKeyUpdate"],
+			message: "Duplicate-key updates require the same INSERT target table",
+			hint: "Pass the INSERT table to onDuplicateKeyUpdate()."
+		});
+		if (insertClauses.filter((clause) => clause.clauseKind === "on-duplicate-key-update" || clause.clauseKind === "on-conflict").length !== 1) throw queryValidationError({
+			code: "duplicate-clause",
+			context: "insert.duplicate-key",
+			path: ["clauses"],
+			message: "INSERT accepts one conflict clause",
+			hint: "Use one onDuplicateKeyUpdate() clause."
+		});
+	}
 	validateMutationWithClauses("INSERT", insertClauses);
 	const withClause = insertClauses.find((clause) => clause.clauseKind === "with");
 	return createMutation("insert", insertClauses.find((clause) => clause.clauseKind === "returning")?.row ?? {}, insertClauses.find((clause) => clause.clauseKind === "returning")?.resultShape ?? { fields: [] }, (context) => {
@@ -1255,7 +1330,7 @@ function insertInto(table, source, ...clauses) {
 			const explicitColumns = Object.keys(rows[0] ?? {});
 			const runtimeDefaultColumns = Object.entries(table.definitions).filter(([columnName, definition]) => !explicitColumns.includes(columnName) && definition.defaultFn !== void 0).map(([columnName]) => columnName);
 			const columns = [...explicitColumns, ...runtimeDefaultColumns];
-			if (columns.length === 0) context.append(" DEFAULT VALUES");
+			if (columns.length === 0) context.append(context.dialect.name === "mysql" ? ` () VALUES ${rows.map(() => "()").join(", ")}` : " DEFAULT VALUES");
 			else {
 				renderTargetColumns(context, table, columns);
 				context.append(" VALUES ");
@@ -1272,7 +1347,7 @@ function insertInto(table, source, ...clauses) {
 			}
 		} else if (source.insertKind === "default-values") {
 			const runtimeDefaults = Object.entries(table.definitions).filter(([, definition]) => definition.defaultFn !== void 0);
-			if (runtimeDefaults.length === 0) context.append(" DEFAULT VALUES");
+			if (runtimeDefaults.length === 0) context.append(context.dialect.name === "mysql" ? " () VALUES ()" : " DEFAULT VALUES");
 			else {
 				renderTargetColumns(context, table, runtimeDefaults.map(([columnName]) => columnName));
 				context.append(" VALUES (");
@@ -1285,12 +1360,41 @@ function insertInto(table, source, ...clauses) {
 		} else {
 			renderTargetColumns(context, table, source.columns);
 			context.append(" ");
-			context.renderRelation(source.query);
+			if (duplicate) {
+				const fields = Object.keys(source.query.row);
+				if (fields.length !== source.columns.length) throw queryValidationError({
+					code: "invalid-insert",
+					context: "insert.select.columns",
+					path: ["insertSelect", "columns"],
+					message: "INSERT SELECT target and projection lengths must match",
+					hint: "Map every projected field to one insert column."
+				});
+				context.append("SELECT * FROM (SELECT ");
+				fields.forEach((field, index) => {
+					if (index) context.append(", ");
+					context.render(identifier("__qubu_insert_source"));
+					context.append(".");
+					context.render(identifier(snakeCaseIdentifier(field)));
+					context.append(" AS ");
+					context.render(identifier(table.sqlNames[source.columns[index]] ?? source.columns[index]));
+				});
+				context.append(" FROM (");
+				context.renderRelation(source.query);
+				context.append(") AS ");
+				context.render(identifier("__qubu_insert_source"));
+				context.append(") AS ");
+				context.render(identifier(incomingAlias(table)));
+			} else context.renderRelation(source.query);
+		}
+		if (duplicate && source.insertKind !== "select") {
+			context.append(" AS ");
+			context.render(identifier(incomingAlias(table)));
 		}
 		for (const clause of insertClauses) {
 			if (clause.clauseKind === "with") continue;
 			context.append(" ");
-			context.render(clause);
+			if (clause.clauseKind === "on-duplicate-key-update") renderDuplicateKeyUpdate(context, clause, source.insertKind === "select" ? source.columns : void 0);
+			else context.render(clause);
 		}
 	});
 }
@@ -1304,7 +1408,7 @@ function renderTargetColumns(context, table, columns) {
 }
 function renderInsertValue(context, input, definition) {
 	if (isExpression(input)) context.render(input);
-	else context.parameter(encodeColumnParameter(definition, input));
+	else context.parameter(encodeColumnParameter(definition, input), columnSqlType(definition));
 }
 function validateInsert(table, source) {
 	const definitions = table.definitions;
@@ -1457,7 +1561,7 @@ function update(table, assignments, ...clauses) {
 }
 function renderAssignmentValue(context, value, definition) {
 	if (isExpression(value)) context.render(value);
-	else context.parameter(encodeColumnParameter(definition, value));
+	else context.parameter(encodeColumnParameter(definition, value), columnSqlType(definition));
 }
 function validateUpdate(table, assignments) {
 	const definitions = table.definitions;
@@ -1529,4 +1633,194 @@ function returning(selection) {
 	});
 }
 //#endregion
-export { QueryValidationError, ResultDecodingError, add, alias, all, allowAll, and, asValue, asc, avg, between, bigint, binary, boolean, booleanResultDecoder, call, caseWhen, cast, catalogCheck, catalogForeignKey, check, coalesce, column, concat, correlate, count, countDistinct, crossJoin, cte, date, dateResultDecoder, defaultValues, deleteFrom, denseRank, desc, distinct, divide, eq, except, execute, executeRows, exists, explain, externalDefault, externalGeneratedColumn, fetchFirst, fetchNext, foreignKey, from, fullJoin, generatedColumn, groupBy, gt, gte, having, identityColumn, inList, inQuery, index, innerJoin, insertInto, insertSelect, integer, intersect, isDistinctFrom, isNotDistinctFrom, isNotNull, isNull, isTrue, json, jsonBoolean, jsonExists, jsonNumber, jsonPath, jsonText, jsonTextResultDecoder, lateral, leftJoin, like, lower, lt, lte, mapResult, max, min, modulo, multiply, nativeColumn, nativeStorage, naturalJoin, ne, not, notExists, notIn, notLike, nullable, nullsFirst, nullsLast, numeric, offset, omit, or, order, orderBy, over, portableStorage, primaryKey, qubu, rank, recursiveCte, references, render, returning, rightJoin, rowLock, rowNumber, scalar, schema, schemaCall, select, sql, stream, subtract, sum, table, text, timestamp, timestampResultDecoder, union, unionAll, unique, uniqueConstraint, unsafeSchemaSql, update, upper, uuid, value, values, where, withCte };
+//#region src/expressions/nested-json.ts
+/**
+* Turn a SELECT or set query into an inferred array expression; empty queries return [].
+*
+* Preserves correlation, explicit ordering and pagination on PostgreSQL, MySQL 8.0.21+, and SQLite
+* 3.45+. Without ORDER BY, element order is unspecified. DISTINCT ordering must use expressions
+* present in the projection.
+*
+* Nested fields require supported runtime SQL domains. Bigints, binary values and serialized JSON
+* use exact text transport; dates and booleans are normalized without adapter-specific decoders.
+* Unsupported domains or lossy numeric representations throw. Custom result decoders receive the
+* transport value (including strings for bigint, decimal, binary hex and JSON), consistent with
+* their unknown-input contract.
+*/
+function jsonArrayFrom(query) {
+	return nestedJson(query, true);
+}
+/**
+* Turn a query proven to return at most one row into an inferred object.
+*
+* Empty queries return null; exactly-one queries retain a non-null result type. Use an
+* unconditional fetchFirst(1) to prove the row bound for a table query. Shares dialect, projection
+* and exact-decoding rules with {@link jsonArrayFrom}.
+*
+* @throws {TypeError} When the query lacks a runtime at-most-one-row proof.
+*/
+function jsonObjectFrom(query) {
+	if (query.cardinality !== "exactly-one" && query.cardinality !== "zero-or-one") throw new TypeError("jsonObjectFrom() requires a query proven to return at most one row");
+	return nestedJson(query, false);
+}
+function nestedJson(query, array) {
+	if (query.queryKind !== "select" && query.queryKind !== "set") throw new TypeError("Nested JSON requires a SELECT or set query");
+	return makeExpression("subquery", (context) => renderNestedJson(context, query, array), "subquery", resultValue("json", (value, context) => {
+		const parsed = typeof value === "string" ? parseExactJson(value) : value;
+		if (array) {
+			if (!Array.isArray(parsed)) throw new TypeError("Expected a nested JSON array");
+			return parsed.map((row) => decodeNestedRow(row, query.resultShape, context));
+		}
+		return parsed === null ? null : decodeNestedRow(parsed, query.resultShape, context);
+	}, "json"));
+}
+function renderNestedJson(context, query, array) {
+	const dialect = context.dialect.name;
+	if (dialect !== "postgresql" && dialect !== "sqlite" && dialect !== "mysql") throw new TypeError(`Nested JSON queries are not supported by dialect "${dialect}"`);
+	const q = context.dialect.quoteIdentifier;
+	const names = new Set(query.resultShape.fields.map((field) => snakeCaseIdentifier(field.name)));
+	let ordinal = "__qubu_json_order";
+	while (names.has(ordinal)) ordinal += "_";
+	const ordered = array && query.renderJsonRows !== void 0;
+	const reference = (name) => context.append(`${q("__qubu_json")}.${q(name)}`);
+	const renderObject = () => {
+		context.append(dialect === "postgresql" ? "json_build_object(" : "json_object(");
+		query.resultShape.fields.forEach((field, index) => {
+			if (index) context.append(", ");
+			context.parameter(field.name, "text");
+			if (dialect === "postgresql") context.append("::text");
+			context.append(", ");
+			const type = field.sqlType ?? field.type;
+			const ref = () => reference(snakeCaseIdentifier(field.name));
+			if (type === "decimal" && dialect === "sqlite") {
+				context.append("CASE typeof(");
+				ref();
+				context.append(") WHEN 'real' THEN printf('%!.17g', ");
+				ref();
+				context.append(") WHEN 'integer' THEN CAST(");
+				ref();
+				context.append(" AS TEXT) WHEN 'null' THEN NULL ELSE json('invalid numeric storage') END");
+			} else if (type === "bigint" || type === "decimal" || type === "json") {
+				context.append("CAST(");
+				ref();
+				context.append(dialect === "mysql" ? " AS CHAR)" : " AS TEXT)");
+			} else if (type === "binary") {
+				if (dialect === "sqlite") {
+					context.append("CASE WHEN ");
+					ref();
+					context.append(" IS NULL THEN NULL ELSE ");
+				}
+				context.append(dialect === "postgresql" ? "encode(" : "hex(");
+				ref();
+				context.append(dialect === "postgresql" ? ", 'hex')" : ")");
+				if (dialect === "sqlite") context.append(" END");
+			} else if (type === void 0 || type === "unknown" || ![
+				"text",
+				"uuid",
+				"integer",
+				"decimal",
+				"boolean",
+				"date",
+				"timestamp",
+				"json"
+			].includes(type)) throw new TypeError(`Nested JSON field "${field.name}" requires a supported declared SQL domain`);
+			else ref();
+		});
+		context.append(")");
+	};
+	context.append(array ? "COALESCE((SELECT " : "(SELECT ");
+	if (array) context.append(dialect === "postgresql" ? "json_agg(" : dialect === "sqlite" ? "json_group_array(" : "JSON_ARRAYAGG(");
+	renderObject();
+	if (array) {
+		if (ordered && dialect !== "mysql") {
+			context.append(" ORDER BY ");
+			reference(ordinal);
+		}
+		context.append(")");
+		if (dialect === "mysql") {
+			context.append(" OVER (");
+			if (ordered) {
+				context.append("ORDER BY ");
+				reference(ordinal);
+				context.append(" ");
+			}
+			context.append("ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING)");
+		}
+	}
+	context.append(" FROM (");
+	context.renderRelation(fragment((inner) => {
+		if (ordered) query.renderJsonRows(inner, ordinal);
+		else inner.render(query);
+	}));
+	context.append(`) AS ${q("__qubu_json")}`);
+	if (array && dialect === "mysql") context.append(" LIMIT 1");
+	context.append(")");
+	if (array) context.append(dialect === "postgresql" ? ", '[]'::json)" : dialect === "mysql" ? ", JSON_ARRAY())" : ", json('[]'))");
+}
+function decodeNestedRow(value, shape, context) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new TypeError("Expected a nested JSON object");
+	const row = value;
+	const entries = shape.fields.map((field) => {
+		if (!Object.hasOwn(row, field.name)) throw new TypeError(`Missing nested JSON field "${field.name}"`);
+		return [field.name, decodeNestedField(row[field.name], field, context)];
+	});
+	return Object.fromEntries(entries);
+}
+function decodeNestedField(value, field, context) {
+	if (value === null) return null;
+	if (field.decoder) return field.decoder(value, {
+		...context,
+		field: `${context.field}.${field.name}`
+	});
+	switch (field.type ?? field.sqlType) {
+		case "bigint": return bigintResultDecoder(value, context);
+		case "boolean": return booleanResultDecoder(value, context);
+		case "date": return dateResultDecoder(value, context);
+		case "timestamp": return timestampResultDecoder(value, context);
+		case "json": return typeof value === "string" ? parseExactJson(value) : value;
+		case "binary":
+			if (typeof value !== "string" || !/^(?:[\da-f]{2})*$/iu.test(value)) throw new TypeError("Expected hexadecimal binary result");
+			return Uint8Array.from(value.match(/../gu) ?? [], (byte) => parseInt(byte, 16));
+		case "integer":
+			if (typeof value !== "number" || !Number.isSafeInteger(value)) throw new TypeError("Expected a safe integer result");
+			return value;
+		case "decimal":
+			if (typeof value !== "string" && typeof value !== "number") throw new TypeError("Expected a numeric result");
+			if (context.dialect.name === "sqlite") {
+				canonicalDecimal(String(value));
+				const number = Number(value);
+				if (!Number.isFinite(number) || Number.isInteger(number) && !Number.isSafeInteger(number)) throw new TypeError("Expected a finite, safely represented SQLite number");
+				return number;
+			}
+			return exactNumber(String(value));
+		case "text":
+		case "uuid":
+			if (typeof value !== "string") throw new TypeError("Expected a text result");
+			return value;
+		default: throw new TypeError(`Unsupported nested JSON field "${field.name}"`);
+	}
+}
+function exactNumber(value) {
+	const number = Number(value);
+	if (!Number.isFinite(number) || canonicalDecimal(value) !== canonicalDecimal(String(number))) throw new TypeError("Nested JSON numeric value cannot be represented exactly as a JavaScript number");
+	if (Number.isInteger(number) && !Number.isSafeInteger(number)) throw new TypeError("Nested JSON integer exceeds JavaScript's safe integer range");
+	return number;
+}
+function canonicalDecimal(value) {
+	const match = /^([+-]?)(\d+)(?:\.(\d*))?(?:[eE]([+-]?\d+))?$/u.exec(value);
+	if (!match) throw new TypeError("Expected a decimal number");
+	let digits = (match[2] + (match[3] ?? "")).replace(/^0+/u, "");
+	if (!digits) return "0";
+	let exponent = Number(match[4] ?? 0) - (match[3]?.length ?? 0);
+	if (!Number.isSafeInteger(exponent)) throw new TypeError("Unsupported decimal exponent");
+	const zeros = /0+$/u.exec(digits)?.[0].length ?? 0;
+	digits = digits.slice(0, digits.length - zeros);
+	exponent += zeros;
+	return `${match[1] === "-" ? "-" : ""}${digits}e${exponent}`;
+}
+function parseExactJson(value) {
+	for (const token of value.matchAll(/"(?:[^"\\]|\\.)*"|-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?/gu)) if (token[0][0] !== "\"") exactNumber(token[0]);
+	return JSON.parse(value);
+}
+//#endregion
+export { QueryValidationError, ResultDecodingError, add, alias, all, allowAll, and, asValue, asc, avg, between, bigint, bigintResultDecoder, binary, boolean, booleanResultDecoder, call, caseWhen, cast, catalogCheck, catalogForeignKey, check, coalesce, column, concat, correlate, count, countDistinct, crossJoin, cte, date, dateResultDecoder, defaultValues, deleteFrom, denseRank, desc, distinct, divide, eq, except, execute, executeRows, exists, explain, externalDefault, externalGeneratedColumn, fetchFirst, fetchNext, foreignKey, from, fullJoin, generatedColumn, groupBy, gt, gte, having, identityColumn, inList, inQuery, index, innerJoin, insertInto, insertSelect, integer, intersect, isDistinctFrom, isNotDistinctFrom, isNotNull, isNull, isTrue, json, jsonArrayFrom, jsonBoolean, jsonExists, jsonNumber, jsonObjectFrom, jsonPath, jsonText, jsonTextResultDecoder, lateral, leftJoin, like, lower, lt, lte, mapResult, max, min, modulo, multiply, nativeColumn, nativeStorage, naturalJoin, ne, not, notExists, notIn, notLike, nullable, nullsFirst, nullsLast, numeric, offset, omit, or, order, orderBy, over, portableStorage, primaryKey, qubu, rank, recursiveCte, references, render, returning, rightJoin, rowLock, rowNumber, scalar, schema, schemaCall, select, sql, stream, subtract, sum, table, text, timestamp, timestampResultDecoder, union, unionAll, unique, uniqueConstraint, unsafeSchemaSql, update, upper, uuid, value, values, where, withCte };

package/dist/introspection/mysql.d.mts

@@ -1,4 +1,4 @@
-import { kt as CatalogConnection, st as IntrospectionCatalog, ut as IntrospectionOptions } from "../types-BEn0N_al.mjs";
+import { ft as IntrospectionOptions, jt as CatalogConnection, lt as IntrospectionCatalog } from "../types-CiMvKi5V.mjs";
 //#region src/introspection/mysql.d.ts
 declare const mysqlServerQuery = "SELECT VERSION() AS version, @@version_comment AS version_comment";
 declare const mysqlTablesQuery = "\n  SELECT TABLE_NAME AS table_name, TABLE_TYPE AS table_type,\n         ENGINE AS engine, TABLE_COLLATION AS table_collation,\n         CREATE_OPTIONS AS create_options, TABLE_COMMENT AS table_comment\n  FROM INFORMATION_SCHEMA.TABLES\n  WHERE TABLE_SCHEMA = ?\n  ORDER BY TABLE_NAME\n";