@vantreeseba/drizzle-graphql 15.1.0 → 15.1.1

package/dist/index.d.cts

@@ -449,7 +449,7 @@ type DrizzleErrorCode =
 'DRIZZLE_INVALID_DISTINCT' |
 /** An `onConflict` named a target or update column the upsert cannot use. */
 'DRIZZLE_INVALID_ON_CONFLICT' |
-/** A written value could not be converted to what its column stores. */
+/** A written value could not be converted to what its column stores, or a `limit` / `offset` was negative. */
 'DRIZZLE_INVALID_INPUT_VALUE' |
 /** An update's `set` gave a column that cannot hold null an explicit null. */
 'DRIZZLE_NOT_NULL' |

package/dist/index.d.ts

@@ -449,7 +449,7 @@ type DrizzleErrorCode =
 'DRIZZLE_INVALID_DISTINCT' |
 /** An `onConflict` named a target or update column the upsert cannot use. */
 'DRIZZLE_INVALID_ON_CONFLICT' |
-/** A written value could not be converted to what its column stores. */
+/** A written value could not be converted to what its column stores, or a `limit` / `offset` was negative. */
 'DRIZZLE_INVALID_INPUT_VALUE' |
 /** An update's `set` gave a column that cannot hold null an explicit null. */
 'DRIZZLE_NOT_NULL' |

package/dist/index.js

@@ -1592,13 +1592,20 @@ const nullableOps = {
 	isNull,
 	isNotNull
 };
+/** Operators whose operand is an on/off flag rather than a value: `false` adds no condition. */
+const FLAG_OPERATORS = /* @__PURE__ */ new Set([
+	"isNull",
+	"isNotNull",
+	"isEmpty"
+]);
 const extractFiltersColumn = (column, columnName, operators) => {
 	const { OR, AND, NOT, insensitive, ...restOperators } = operators;
 	const foldCase = insensitive === true;
 	const entries = Object.entries(restOperators);
 	const variants = [];
 	for (const [operatorName, operatorValue] of entries) {
-		if (operatorValue === null || operatorValue === false) continue;
+		if (operatorValue === null || operatorValue === void 0) continue;
+		if (operatorValue === false && FLAG_OPERATORS.has(operatorName)) continue;
 		if (operatorName in singleValueOps) {
 			const singleValue = remapFromGraphQLCore(operatorValue, column, columnName);
 			variants.push(foldCase ? lowerComparison(column, operatorName, singleValue) : singleValueOps[operatorName](column, singleValue));
@@ -2732,6 +2739,45 @@ const cursorOrderExprs = (table, entries) => {
 	return entries.flatMap(([column, direction, nulls]) => orderExpressions(cols[column], direction, nulls ?? void 0, cols[column]));
 };
 /**
+* Property a row carries an ordering column's full-precision text under, when the column holds
+* more than a JS Date can. Namespaced like {@link ROW_CURSOR_PROP}, and removed from the row
+* once its cursor is encoded.
+*/
+const preciseTextProp = (column) => `__drizzle_graphql_cursor_text_${column}`;
+/**
+* Whether a column reads into a JS Date (milliseconds) while the database keeps finer
+* fractional seconds: a PostgreSQL `timestamp` / `timestamptz` in `mode: 'date'` (precision 6
+* unless it says otherwise) or a MySQL `datetime` / `timestamp` in `mode: 'date'` with
+* `fsp` above 3. String-mode columns already arrive as the database's own text, and `time` is
+* always a string, so neither loses anything.
+*/
+const outgrowsJsDate = (column) => {
+	if (is(column, PgTimestamp)) return column.precision === void 0 || column.precision > 3;
+	if (is(column, MySqlDateTime) || is(column, MySqlTimestamp)) return (column.fsp ?? 0) > 3;
+	return false;
+};
+/**
+* Extra SQL expressions a cursor-computing query selects alongside the row: for each ordering
+* column whose values a JS Date would truncate, the value as the database's own text. The
+* cursor then encodes that text rather than the Date, and `after` compares the column against
+* it — so two rows a microsecond apart stay distinct positions. `table` may be the aliased RQB
+* proxy. Empty when no ordering column needs it.
+*/
+const cursorPreciseExtras = (table, entries) => {
+	const cols = getColumns(table);
+	const extras = {};
+	for (const [name] of entries) {
+		const column = cols[name];
+		if (column && outgrowsJsDate(column)) extras[preciseTextProp(name)] = is(column, PgTimestamp) ? sql`${column}::text` : sql`cast(${column} as char)`;
+	}
+	return extras;
+};
+/**
+* {@link cursorPreciseExtras} aliased under their property names, for a `select({...})` that
+* may be wrapped in a subquery (where a bare SQL expression would have no name).
+*/
+const cursorPreciseSelection = (table, entries) => Object.fromEntries(Object.entries(cursorPreciseExtras(table, entries)).map(([prop, expression]) => [prop, expression.as(prop)]));
+/**
 * Serializes one ordering-tuple value into a JSON-safe shape. Dates and bigints don't survive
 * JSON.stringify losslessly (bigint throws, Date turns into an untagged string), so they are
 * tagged; decimals already arrive from the driver as strings, which are lossless as-is.
@@ -2766,7 +2812,11 @@ const cursorEncoder = (entries) => {
 	const spec = JSON.stringify(entries);
 	const columns = entries.map(([column]) => column);
 	return (row) => {
-		const values = JSON.stringify(columns.map((column) => encodeCursorValue(row[column] ?? null)));
+		const values = JSON.stringify(columns.map((column) => {
+			const value = row[column] ?? null;
+			const precise = row[preciseTextProp(column)];
+			return value !== null && typeof precise === "string" ? precise : encodeCursorValue(value);
+		}));
 		return Buffer.from(`{"o":${spec},"v":${values}}`, "utf8").toString("base64url");
 	};
 };
@@ -2859,7 +2909,11 @@ const selectsCursorField = (info, table) => {
 */
 const attachRowCursors = (rows, entries) => {
 	const encode = cursorEncoder(entries);
-	for (const row of rows) row[ROW_CURSOR_PROP] = encode(row);
+	const preciseProps = entries.map(([column]) => preciseTextProp(column));
+	for (const row of rows) {
+		row[ROW_CURSOR_PROP] = encode(row);
+		for (const prop of preciseProps) delete row[prop];
+	}
 };
 /** Resolver for the `cursor` meta field: reads the value a list resolver attached, if any. */
 const rowCursorResolver = (source) => source?.[ROW_CURSOR_PROP] ?? null;
@@ -3217,6 +3271,21 @@ const withDefaultOrderBy = (args, tableName, defaults) => {
 	} : args;
 };
 /**
+* Rejects a negative `limit` or `offset`. Neither is a page size or a position, and the
+* dialects disagree on what one means: SQLite reads `LIMIT -1` as "no limit" — which would walk
+* straight past `maxLimit` — while PostgreSQL and MySQL fail with a raw database error. Applied
+* whether or not the table has a limit policy.
+*/
+const assertPagingNotNegative = (paging, errorCtx) => {
+	for (const name of ["limit", "offset"]) {
+		const value = paging[name];
+		if (value != null && value < 0) throw drizzleError(`'${name}' must not be negative, got ${value}.`, {
+			code: "DRIZZLE_INVALID_INPUT_VALUE",
+			...errorCtx
+		});
+	}
+};
+/**
 * The `limit` a query actually runs with, given the policy for the table it reads.
 *
 * A request that passes no `limit` falls back to `defaultLimit`, or to `maxLimit` when only
@@ -3228,6 +3297,7 @@ const withDefaultOrderBy = (args, tableName, defaults) => {
 * fail a client's query over.
 */
 const applyLimitPolicy = (limit, policy, errorCtx) => {
+	assertPagingNotNegative({ limit }, errorCtx);
 	if (!policy) return limit ?? void 0;
 	const { defaultLimit, maxLimit, clampToMax } = policy;
 	if (limit == null) {
@@ -3745,6 +3815,11 @@ const extractRelationsParams = (relationMap, tables, tableName, info, typeName,
 		thisRecord.columns = columns;
 		const relationArgs = is(relEntry.relation, One) ? field.args : withDefaultOrderBy(field.args ?? {}, targetTableName, defaultOrderBy);
 		const offset = relationArgs?.offset ?? void 0;
+		assertPagingNotNegative({ offset }, {
+			table: targetTableName,
+			operation: "relation",
+			relation: relName
+		});
 		const limit = is(relEntry.relation, One) ? relationArgs?.limit ?? void 0 : applyLimitPolicy(relationArgs?.limit, limits?.(targetTableName), {
 			table: targetTableName,
 			operation: "relation",
@@ -3788,6 +3863,10 @@ const pruneNonEagerRelations = (relationMap, shouldEagerLoad) => {
 const runRelationalSelect = async (opts) => {
 	const { queryBase, tables, tableName, table, relationMap, typeName, typeNameMapper, parsedInfo, offset, orderBy, where, single, filterCtx, pkNames, after, scope, deleted } = opts;
 	const distinct = opts.distinct?.length ? opts.distinct : void 0;
+	assertPagingNotNegative({
+		limit: opts.limit,
+		offset
+	});
 	const cursorSelected = !single && isCursorFieldSelected(parsedInfo.fieldsByTypeName[typeName], table);
 	let cursorEntries;
 	if (!single && (after != null || cursorSelected)) {
@@ -3839,7 +3918,11 @@ const runRelationalSelect = async (opts) => {
 		const result = await queryBase.findFirst(omitUndefinedKeys(params));
 		return result ? remapToGraphQLSingleOutput(result, tableName, table, relationMap) : void 0;
 	}
-	if (cursorEntries && cursorSelected) for (const [column] of cursorEntries) params.columns[column] = true;
+	if (cursorEntries && cursorSelected) {
+		for (const [column] of cursorEntries) params.columns[column] = true;
+		const preciseProps = Object.keys(cursorPreciseExtras(table, cursorEntries));
+		if (preciseProps.length) params.extras = Object.fromEntries(preciseProps.map((prop) => [prop, (aliasedTable) => cursorPreciseExtras(aliasedTable, cursorEntries)[prop]]));
+	}
 	params.limit = distinctKeys ? void 0 : opts.limit;
 	const result = await queryBase.findMany(omitUndefinedKeys(params));
 	if (cursorEntries && cursorSelected) attachRowCursors(result, cursorEntries);
@@ -4743,7 +4826,10 @@ const createRelationResolverFactory = (db, tables, nullOrdering, filterCtx, limi
 			const column = targetColumns[columnName];
 			if (column) columns[columnName] = column;
 		}
-		return columns;
+		return cursorEntries ? {
+			...columns,
+			...cursorPreciseSelection(targetTable, cursorEntries)
+		} : columns;
 	};
 	const resolve = async (parent, args, context, info) => {
 		if (parent[relationName] !== void 0) return parent[relationName];
@@ -4753,6 +4839,7 @@ const createRelationResolverFactory = (db, tables, nullOrdering, filterCtx, limi
 		const { orderByArg, limit, distinct, cursorEntries, cursorValues, columns, loaderKey } = getOrCreateRequestValue(context, info?.fieldNodes?.[0], `relation:${tableName}::${relationName}`, () => {
 			const orderByArg = isOne ? args?.orderBy : withDefaultOrderBy(args ?? {}, targetTableName, policies?.defaultOrderBy).orderBy;
 			const limit = applyLimitPolicy(requestedLimit, limitPolicy, errorCtx);
+			assertPagingNotNegative({ offset }, errorCtx);
 			const distinct = (args ?? {}).distinct?.length ? (args ?? {}).distinct : void 0;
 			const cursorSelected = !isOne && !!info && selectsCursorField(info, targetTable);
 			let cursorEntries;