@vantreeseba/drizzle-graphql 5.1.0 → 5.3.0

package/README.md

@@ -405,6 +405,53 @@ supplies no `orderBy`:
 An explicit `orderBy` always takes precedence, composite primary keys are ordered by every
 key column, and an unpaginated list query is left unordered so no sort is paid for.
 
+## Cursor pagination
+
+`OFFSET` pagination degrades linearly and shifts under concurrent writes. List queries also
+support keyset pagination: every row returned by a list query exposes an opaque `cursor`
+field, and passing it back as `after` resumes strictly after that row.
+
+```graphql
+{
+    posts(orderBy: { createdAt: { direction: desc, priority: 1 } }, limit: 10) {
+        id
+        createdAt
+        cursor
+    }
+}
+
+# next page — same orderBy, plus the last row's cursor
+{
+    posts(
+        orderBy: { createdAt: { direction: desc, priority: 1 } }
+        limit: 10
+        after: "eyJvIjogW1siY3JlYXRlZEF0IiwgImRlc2MiXSwgWyJpZCIsICJhc2MiXV0sIC4uLn0"
+    ) {
+        id
+        createdAt
+        cursor
+    }
+}
+```
+
+-   The cursor encodes the row's position in the query's **total order** — your `orderBy`
+    columns plus the primary key as an ascending tiebreak — so pages are stable even when
+    the ordered columns aren't unique, and inserts or deletes mid-scroll don't shift the
+    window
+-   `after` compiles to a keyset predicate built from drizzle's `and`/`or`/`gt`/`lt`
+    comparisons (not SQL row-value syntax), so mixed-direction `orderBy` works
+-   `NULL`s in ordered columns follow each dialect's native `ORDER BY` placement —
+    PostgreSQL sorts them largest (last in `asc`), MySQL and SQLite smallest (first in
+    `asc`) — and the predicate matches, so rows with `NULL` in an ordered column are paged
+    through, not skipped
+-   Dates and bigints round-trip losslessly through the cursor
+-   A cursor is only valid under the ordering it was issued for — reusing it with a
+    different `orderBy` (or a malformed/corrupted cursor) returns a `GraphQLError`
+-   `after` cannot be combined with `distinct`, and a table with no primary key cannot use
+    cursor pagination (its `cursor` field resolves to `null`)
+-   If a table has a real column named `cursor`, the column wins and the meta field is
+    skipped
+
 ## Upsert
 
 `features.upsert` adds a pair of mutations per table that insert rows, or update the ones

package/dist/README.md

@@ -405,6 +405,53 @@ supplies no `orderBy`:
 An explicit `orderBy` always takes precedence, composite primary keys are ordered by every
 key column, and an unpaginated list query is left unordered so no sort is paid for.
 
+## Cursor pagination
+
+`OFFSET` pagination degrades linearly and shifts under concurrent writes. List queries also
+support keyset pagination: every row returned by a list query exposes an opaque `cursor`
+field, and passing it back as `after` resumes strictly after that row.
+
+```graphql
+{
+    posts(orderBy: { createdAt: { direction: desc, priority: 1 } }, limit: 10) {
+        id
+        createdAt
+        cursor
+    }
+}
+
+# next page — same orderBy, plus the last row's cursor
+{
+    posts(
+        orderBy: { createdAt: { direction: desc, priority: 1 } }
+        limit: 10
+        after: "eyJvIjogW1siY3JlYXRlZEF0IiwgImRlc2MiXSwgWyJpZCIsICJhc2MiXV0sIC4uLn0"
+    ) {
+        id
+        createdAt
+        cursor
+    }
+}
+```
+
+-   The cursor encodes the row's position in the query's **total order** — your `orderBy`
+    columns plus the primary key as an ascending tiebreak — so pages are stable even when
+    the ordered columns aren't unique, and inserts or deletes mid-scroll don't shift the
+    window
+-   `after` compiles to a keyset predicate built from drizzle's `and`/`or`/`gt`/`lt`
+    comparisons (not SQL row-value syntax), so mixed-direction `orderBy` works
+-   `NULL`s in ordered columns follow each dialect's native `ORDER BY` placement —
+    PostgreSQL sorts them largest (last in `asc`), MySQL and SQLite smallest (first in
+    `asc`) — and the predicate matches, so rows with `NULL` in an ordered column are paged
+    through, not skipped
+-   Dates and bigints round-trip losslessly through the cursor
+-   A cursor is only valid under the ordering it was issued for — reusing it with a
+    different `orderBy` (or a malformed/corrupted cursor) returns a `GraphQLError`
+-   `after` cannot be combined with `distinct`, and a table with no primary key cannot use
+    cursor pagination (its `cursor` field resolves to `null`)
+-   If a table has a real column named `cursor`, the column wins and the meta field is
+    skipped
+
 ## Upsert
 
 `features.upsert` adds a pair of mutations per table that insert rows, or update the ones

package/dist/index.cjs

@@ -411,6 +411,21 @@ var geoXyInputType = new import_graphql3.GraphQLInputObjectType({
   }
 });
 var columnToGraphQLCore = (column, columnName, tableName, isInput) => {
+  const dimensions = column.dimensions;
+  if (dimensions !== void 0 && dimensions > 0) {
+    const inner = columnBaseToGraphQLCore(column, columnName, tableName, isInput);
+    const innerDesc = inner.description ?? inner.type.name;
+    let type = inner.type;
+    let description = innerDesc;
+    for (let i = 0; i < dimensions; i++) {
+      type = new import_graphql3.GraphQLList(new import_graphql3.GraphQLNonNull(type));
+      description = `Array<${description}>`;
+    }
+    return { type, description };
+  }
+  return columnBaseToGraphQLCore(column, columnName, tableName, isInput);
+};
+var columnBaseToGraphQLCore = (column, columnName, tableName, isInput) => {
   const { type: baseType, constraint } = (0, import_drizzle_orm2.extractExtendedColumnType)(column);
   switch (baseType) {
     case "boolean":
@@ -442,28 +457,10 @@ var columnToGraphQLCore = (column, columnName, tableName, isInput) => {
       if (column instanceof import_pg_core.PgDateString) {
         return isInput ? { type: import_graphql3.GraphQLString, description: "Date" } : { type: import_graphql_scalars.GraphQLDate, description: "Date" };
       }
-      {
-        const dims = column.dimensions;
-        if (dims !== void 0 && dims > 0) {
-          return {
-            type: new import_graphql3.GraphQLList(new import_graphql3.GraphQLNonNull(import_graphql3.GraphQLString)),
-            description: "Array<String>"
-          };
-        }
-      }
       return { type: import_graphql3.GraphQLString, description: "String" };
     case "bigint":
       return { type: GraphQLBigIntString, description: "BigInt" };
     case "number": {
-      const dims = column.dimensions;
-      if (dims !== void 0 && dims > 0) {
-        const baseDesc = (0, import_drizzle_orm2.is)(column, import_pg_core.PgInteger) || (0, import_drizzle_orm2.is)(column, import_pg_core.PgSerial) ? "Integer" : "Float";
-        const baseType2 = baseDesc === "Integer" ? import_graphql3.GraphQLInt : import_graphql3.GraphQLFloat;
-        return {
-          type: new import_graphql3.GraphQLList(new import_graphql3.GraphQLNonNull(baseType2)),
-          description: `Array<${baseDesc}>`
-        };
-      }
       return (0, import_drizzle_orm2.is)(column, import_pg_core.PgInteger) || (0, import_drizzle_orm2.is)(column, import_pg_core.PgSerial) || (0, import_drizzle_orm2.is)(column, import_mysql_core.MySqlInt) || (0, import_drizzle_orm2.is)(column, import_mysql_core.MySqlSerial) || (0, import_drizzle_orm2.is)(column, import_sqlite_core.SQLiteInteger) ? { type: import_graphql3.GraphQLInt, description: "Integer" } : { type: import_graphql3.GraphQLFloat, description: "Float" };
     }
     case "array": {
@@ -808,52 +805,95 @@ var innerOrder = new import_graphql4.GraphQLInputObjectType({
     }
   }
 });
-var resolveGenericFilterName = (column, columnGraphQLType) => {
+var columnDialect = (column) => {
+  const ct = column.columnType ?? "";
+  if (ct.startsWith("Pg")) {
+    return "pg";
+  }
+  if (ct.startsWith("MySql")) {
+    return "mysql";
+  }
+  if (ct.startsWith("SQLite")) {
+    return "sqlite";
+  }
+  return void 0;
+};
+var resolveGenericFilterDescriptor = (column, columnGraphQLType) => {
+  if (columnGraphQLType.type === import_graphql_scalars.GraphQLJSON) {
+    return { name: "JSON", kind: "json" };
+  }
+  if (columnGraphQLType.type instanceof import_graphql4.GraphQLList) {
+    let element = columnGraphQLType.type.ofType;
+    if (element instanceof import_graphql4.GraphQLNonNull) {
+      element = element.ofType;
+    }
+    return { name: `${element.name}Array`, kind: "array" };
+  }
   if (columnGraphQLType.type === import_graphql_scalars.GraphQLUUID) {
-    return "Id";
+    return { name: "Id", kind: "scalar" };
   }
   if (columnGraphQLType.type === import_graphql4.GraphQLBoolean) {
-    return "Boolean";
+    return { name: "Boolean", kind: "scalar" };
   }
   if (columnGraphQLType.type instanceof import_graphql4.GraphQLEnumType) {
-    return columnGraphQLType.type.name;
+    return { name: columnGraphQLType.type.name, kind: "scalar" };
   }
   if (columnGraphQLType.type === GraphQLBigIntString) {
-    return "BigInt";
+    return { name: "BigInt", kind: "scalar" };
   }
   if (columnGraphQLType.type === GraphQLDecimalString) {
-    return "Decimal";
-  }
-  if (columnGraphQLType.type instanceof import_graphql4.GraphQLList) {
-    const desc2 = columnGraphQLType.description ?? "";
-    let inner = columnGraphQLType.type.ofType;
-    if (inner instanceof import_graphql4.GraphQLNonNull) {
-      inner = inner.ofType;
-    }
-    if (desc2.includes("Integer") || inner === import_graphql4.GraphQLInt) {
-      return "IntArray";
-    }
-    if (desc2.includes("Float") || inner === import_graphql4.GraphQLFloat) {
-      return "FloatArray";
-    }
-    return "StringArray";
+    return { name: "Decimal", kind: "scalar" };
   }
   const ct = column.columnType ?? "";
   if (ct === "PgTimestamp" || ct === "PgTimestampString" || ct === "PgDate") {
-    return "DateTime";
+    return { name: "DateTime", kind: "scalar" };
   }
   if (columnGraphQLType.type === import_graphql4.GraphQLInt) {
-    return "Int";
+    return { name: "Int", kind: "scalar" };
   }
   if (columnGraphQLType.type === import_graphql4.GraphQLFloat) {
-    return "Float";
+    return { name: "Float", kind: "scalar" };
   }
-  return "String";
+  return { name: "String", kind: "scalar" };
+};
+var jsonFilterFields = (column, colType) => {
+  const dialect = columnDialect(column);
+  return {
+    eq: { type: colType, description: "JSON equality on the whole value" },
+    ne: { type: colType, description: "JSON inequality on the whole value" },
+    ...dialect === "pg" || dialect === "mysql" ? {
+      contains: {
+        type: colType,
+        description: "Value structurally contains this JSON (Postgres `@>` / MySQL JSON_CONTAINS)"
+      }
+    } : {},
+    isNull: { type: import_graphql4.GraphQLBoolean },
+    isNotNull: { type: import_graphql4.GraphQLBoolean }
+  };
+};
+var arrayFilterFields = (colType, colArr, colDesc) => {
+  let element = colType.ofType;
+  if (element instanceof import_graphql4.GraphQLNonNull) {
+    element = element.ofType;
+  }
+  const elementList = new import_graphql4.GraphQLList(new import_graphql4.GraphQLNonNull(element));
+  return {
+    eq: { type: colType, description: colDesc },
+    ne: { type: colType, description: colDesc },
+    has: { type: element, description: "Array contains this element" },
+    hasSome: { type: elementList, description: "Array contains at least one of these elements (overlap, `&&`)" },
+    hasEvery: { type: elementList, description: "Array contains every one of these elements (containment, `@>`)" },
+    isEmpty: { type: import_graphql4.GraphQLBoolean, description: "When true, matches arrays with no elements" },
+    inArray: { type: colArr, description: `Array<${colDesc}>` },
+    notInArray: { type: colArr, description: `Array<${colDesc}>` },
+    isNull: { type: import_graphql4.GraphQLBoolean },
+    isNotNull: { type: import_graphql4.GraphQLBoolean }
+  };
 };
 var FILTERS_WITHOUT_STRING_OPS = /* @__PURE__ */ new Set(["Id", "Int", "Float", "BigInt", "Decimal"]);
 var generateColumnFilterValues = (column, tableName, columnName, cacheCtx) => {
   const columnGraphQLType = drizzleColumnToGraphQLType(column, columnName, tableName, true, false, true);
-  const genericName = resolveGenericFilterName(column, columnGraphQLType);
+  const { name: genericName, kind } = resolveGenericFilterDescriptor(column, columnGraphQLType);
   const cached = cacheCtx.genericFilterCache.get(genericName);
   if (cached) {
     return cached;
@@ -862,7 +902,7 @@ var generateColumnFilterValues = (column, tableName, columnName, cacheCtx) => {
   const colDesc = columnGraphQLType.description;
   const colArr = new import_graphql4.GraphQLList(new import_graphql4.GraphQLNonNull(colType));
   const omitStringOps = FILTERS_WITHOUT_STRING_OPS.has(genericName);
-  const baseFields = {
+  const baseFields = kind === "json" ? jsonFilterFields(column, colType) : kind === "array" ? arrayFilterFields(colType, colArr, colDesc) : {
     eq: { type: colType, description: colDesc },
     ne: { type: colType, description: colDesc },
     lt: { type: colType, description: colDesc },
@@ -973,6 +1013,13 @@ var generateTableSelectTypeFieldsCached = (table, tableName) => {
       drizzleColumnToGraphQLType(columnDescription, columnName, tableName)
     ])
   );
+  if (!remapped[CURSOR_FIELD_NAME]) {
+    remapped[CURSOR_FIELD_NAME] = {
+      type: import_graphql4.GraphQLString,
+      description: "Opaque cursor of this row's position in the query's ordering. Pass it as `after` to resume from here. Only set on rows returned by a list query.",
+      resolve: rowCursorResolver
+    };
+  }
   fieldMap.set(table, remapped);
   return remapped;
 };
@@ -1435,12 +1482,28 @@ var safeLikeCondition = (column, pattern, insensitive) => {
   const isPg = (column.columnType ?? "").startsWith("Pg");
   return isPg ? import_drizzle_orm3.sql`${column} ilike ${pattern} escape ${LIKE_ESCAPE_CHAR}` : import_drizzle_orm3.sql`lower(${column}) like ${pattern.toLowerCase()} escape ${LIKE_ESCAPE_CHAR}`;
 };
+var isJsonColumn2 = (column) => (column.columnType ?? "").includes("Json");
+var jsonContains = (column, columnName, value) => {
+  const serialized = JSON.stringify(value);
+  switch (columnDialect(column)) {
+    case "pg":
+      return column.columnType === "PgJson" ? import_drizzle_orm3.sql`${column}::jsonb @> ${serialized}::jsonb` : import_drizzle_orm3.sql`${column} @> ${serialized}::jsonb`;
+    case "mysql":
+      return import_drizzle_orm3.sql`json_contains(${column}, ${serialized})`;
+    default:
+      throw new import_graphql4.GraphQLError(`WHERE ${columnName}: Operator 'contains' is not supported for this dialect!`);
+  }
+};
 var extractFiltersColumn = (column, columnName, operators) => {
   const { OR, AND, NOT, ...restOperators } = operators;
   const entries = Object.entries(restOperators);
   const singleValueOps = { eq: import_drizzle_orm3.eq, ne: import_drizzle_orm3.ne, gt: import_drizzle_orm3.gt, gte: import_drizzle_orm3.gte, lt: import_drizzle_orm3.lt, lte: import_drizzle_orm3.lte };
   const stringValueOps = { like: import_drizzle_orm3.like, notLike: import_drizzle_orm3.notLike, ilike: import_drizzle_orm3.ilike, notIlike: import_drizzle_orm3.notIlike };
   const arrayValueOps = { inArray: import_drizzle_orm3.inArray, notInArray: import_drizzle_orm3.notInArray };
+  const arrayMembershipOps = {
+    hasSome: import_drizzle_orm3.arrayOverlaps,
+    hasEvery: import_drizzle_orm3.arrayContains
+  };
   const nullableOps = { isNull: import_drizzle_orm3.isNull, isNotNull: import_drizzle_orm3.isNotNull };
   const variants = [];
   for (const [operatorName, operatorValue] of entries) {
@@ -1452,6 +1515,8 @@ var extractFiltersColumn = (column, columnName, operators) => {
       variants.push(singleValueOps[operatorName](column, singleValue));
     } else if (operatorName in stringValueOps) {
       variants.push(stringValueOps[operatorName](column, operatorValue));
+    } else if (operatorName === "contains" && isJsonColumn2(column)) {
+      variants.push(jsonContains(column, columnName, operatorValue));
     } else if (operatorName in safeLikeOps) {
       const { buildPattern, insensitive } = safeLikeOps[operatorName];
       variants.push(safeLikeCondition(column, buildPattern(operatorValue), insensitive));
@@ -1461,6 +1526,15 @@ var extractFiltersColumn = (column, columnName, operators) => {
       }
       const arrayValue = operatorValue.map((val) => remapFromGraphQLCore(val, column, columnName));
       variants.push(arrayValueOps[operatorName](column, arrayValue));
+    } else if (operatorName === "has") {
+      variants.push((0, import_drizzle_orm3.arrayContains)(column, [operatorValue]));
+    } else if (operatorName in arrayMembershipOps) {
+      if (!operatorValue.length) {
+        throw new import_graphql4.GraphQLError(`WHERE ${columnName}: Unable to use operator ${operatorName} with an empty array!`);
+      }
+      variants.push(arrayMembershipOps[operatorName](column, operatorValue));
+    } else if (operatorName === "isEmpty") {
+      variants.push(import_drizzle_orm3.sql`cardinality(${column}) = 0`);
     } else if (operatorName in nullableOps) {
       variants.push(nullableOps[operatorName](column));
     } else {
@@ -1773,6 +1847,117 @@ var primaryKeyOrderExprs = (table, pkNames) => {
   const cols = (0, import_drizzle_orm3.getColumns)(table);
   return pkNames.map((n) => cols[n]).filter(Boolean).map((col) => (0, import_drizzle_orm3.asc)(col));
 };
+var CURSOR_FIELD_NAME = "cursor";
+var ROW_CURSOR_PROP = "__drizzle_graphql_cursor";
+var orderByHasRelationEntry = (orderBy) => !!orderBy && Object.values(orderBy).some((config) => config && typeof config === "object" && config.direction === void 0);
+var cursorOrderingEntries = (orderBy, pkNames) => {
+  const entries = orderBy ? orderByEntries(orderBy) : [];
+  const seen = new Set(entries.map(([column]) => column));
+  for (const pk of pkNames) {
+    if (!seen.has(pk)) {
+      entries.push([pk, "asc"]);
+    }
+  }
+  return entries;
+};
+var cursorOrderExprs = (table, entries) => {
+  const cols = (0, import_drizzle_orm3.getColumns)(table);
+  return entries.flatMap(
+    ([column, direction, nulls]) => orderExpressions(cols[column], direction, nulls ?? void 0, cols[column])
+  );
+};
+var encodeCursorValue = (value) => {
+  if (value instanceof Date) {
+    return { $type: "date", value: value.toISOString() };
+  }
+  if (typeof value === "bigint") {
+    return { $type: "bigint", value: value.toString() };
+  }
+  return value;
+};
+var decodeCursorValue = (value) => {
+  if (value && typeof value === "object" && typeof value.$type === "string") {
+    if (value.$type === "date") {
+      return new Date(value.value);
+    }
+    if (value.$type === "bigint") {
+      return BigInt(value.value);
+    }
+  }
+  return value;
+};
+var encodeCursor = (entries, row) => {
+  const payload = {
+    o: entries,
+    v: entries.map(([column]) => encodeCursorValue(row[column] ?? null))
+  };
+  return Buffer.from(JSON.stringify(payload), "utf8").toString("base64url");
+};
+var decodeCursor = (after, entries) => {
+  let payload;
+  try {
+    payload = JSON.parse(Buffer.from(after, "base64url").toString("utf8"));
+  } catch (_e) {
+    throw new import_graphql4.GraphQLError("Invalid cursor: unable to decode it. Pass a cursor returned by a previous page.");
+  }
+  if (!payload || typeof payload !== "object" || !Array.isArray(payload.o) || !Array.isArray(payload.v) || payload.o.length !== payload.v.length) {
+    throw new import_graphql4.GraphQLError("Invalid cursor: malformed payload. Pass a cursor returned by a previous page.");
+  }
+  const matchesOrdering = payload.o.length === entries.length && payload.o.every(
+    (entry, i) => Array.isArray(entry) && entry[0] === entries[i][0] && entry[1] === entries[i][1] && // The nulls override changes where NULLs sort, so it is part of the ordering identity.
+    // JSON round-trips undefined as null — compare the normalized forms.
+    (entry[2] ?? null) === (entries[i][2] ?? null)
+  );
+  if (!matchesOrdering) {
+    throw new import_graphql4.GraphQLError(
+      "Invalid cursor: it was issued for a different ordering. Pass the same orderBy the cursor's page used."
+    );
+  }
+  return payload.v.map(decodeCursorValue);
+};
+var buildCursorCondition = (table, entries, values, nullOrdering) => {
+  const cols = (0, import_drizzle_orm3.getColumns)(table);
+  const disjuncts = [];
+  const equalities = [];
+  entries.forEach(([column, direction, nulls], i) => {
+    const col = cols[column];
+    if (!col) {
+      throw new import_graphql4.GraphQLError(`Invalid cursor: unknown column '${column}'.`);
+    }
+    const value = values[i];
+    const nullsSortLast = nulls != null ? nulls === "last" : direction === "asc" === (nullOrdering === "nulls-largest");
+    let strictlyAfter;
+    if (value === null || value === void 0) {
+      strictlyAfter = nullsSortLast ? void 0 : (0, import_drizzle_orm3.isNotNull)(col);
+    } else {
+      const comparison = direction === "asc" ? (0, import_drizzle_orm3.gt)(col, value) : (0, import_drizzle_orm3.lt)(col, value);
+      strictlyAfter = nullsSortLast ? (0, import_drizzle_orm3.or)(comparison, (0, import_drizzle_orm3.isNull)(col)) : comparison;
+    }
+    if (strictlyAfter) {
+      disjuncts.push(equalities.length ? (0, import_drizzle_orm3.and)(...equalities, strictlyAfter) : strictlyAfter);
+    }
+    equalities.push(value === null || value === void 0 ? (0, import_drizzle_orm3.isNull)(col) : (0, import_drizzle_orm3.eq)(col, value));
+  });
+  if (!disjuncts.length) {
+    return import_drizzle_orm3.sql`1 = 0`;
+  }
+  return disjuncts.length > 1 ? (0, import_drizzle_orm3.or)(...disjuncts) : disjuncts[0];
+};
+var isCursorFieldSelected = (tree, table) => {
+  if (!tree) {
+    return false;
+  }
+  if ((0, import_drizzle_orm3.getColumns)(table)[CURSOR_FIELD_NAME]) {
+    return false;
+  }
+  return Object.values(tree).some((field) => field.name === CURSOR_FIELD_NAME);
+};
+var attachRowCursors = (rows, entries) => {
+  for (const row of rows) {
+    row[ROW_CURSOR_PROP] = encodeCursor(entries, row);
+  }
+};
+var rowCursorResolver = (source) => source?.[ROW_CURSOR_PROP] ?? null;
 var getUniqueColumnSets = (table, getTableConfig4) => {
   const cols = (0, import_drizzle_orm3.getColumns)(table);
   const propNameByColumnName = new Map(Object.entries(cols).map(([propName, col]) => [col.name, propName]));
@@ -2097,6 +2282,10 @@ var selectArrayArgs = (orderArgs, filterArgs, distinctEnum) => ({
   limit: { type: import_graphql4.GraphQLInt },
   orderBy: { type: orderArgs },
   where: { type: filterArgs },
+  after: {
+    type: import_graphql4.GraphQLString,
+    description: "Keyset pagination: only return rows strictly after this cursor (a row's `cursor` field from a previous page, under the same orderBy)."
+  },
   ...distinctEnum ? { distinct: { type: new import_graphql4.GraphQLList(new import_graphql4.GraphQLNonNull(distinctEnum)) } } : {}
 });
 var selectSingleArgs = (orderArgs, filterArgs) => ({
@@ -2119,9 +2308,31 @@ var runRelationalSelect = async (opts) => {
     where,
     single,
     filterCtx,
-    pkNames
+    pkNames,
+    after
   } = opts;
   const distinct = opts.distinct?.length ? opts.distinct : void 0;
+  const cursorSelected = !single && isCursorFieldSelected(parsedInfo.fieldsByTypeName[typeName], table);
+  let cursorEntries;
+  if (!single && (after != null || cursorSelected)) {
+    if (after != null && distinct) {
+      throw new import_graphql4.GraphQLError("'after' cannot be combined with 'distinct'.");
+    }
+    if (orderByHasRelationEntry(orderBy)) {
+      if (after != null) {
+        throw new import_graphql4.GraphQLError(
+          "'after' cannot be combined with an orderBy that orders through a relation \u2014 a related row's value cannot be encoded into a cursor."
+        );
+      }
+    } else if (!pkNames?.length) {
+      if (after != null) {
+        throw new import_graphql4.GraphQLError(`Table ${tableName} has no primary key, so cursor pagination cannot be used on it.`);
+      }
+    } else {
+      cursorEntries = cursorOrderingEntries(orderBy, pkNames);
+    }
+  }
+  const cursorValues = after != null && cursorEntries ? decodeCursor(after, cursorEntries) : void 0;
   const needsDefaultOrder = single || offset != null || opts.limit != null;
   let distinctKeys;
   if (distinct) {
@@ -2152,9 +2363,21 @@ var runRelationalSelect = async (opts) => {
     orderBy: distinctKeys ? (aliasedTable2) => [
       ...orderBy ? extractOrderBy(aliasedTable2, orderBy, relationFilterCtx(filterCtx, tableName)) : [],
       ...primaryKeyOrderExprs(aliasedTable2, pkNames)
-    ] : orderBy ? (aliasedTable2) => extractOrderBy(aliasedTable2, orderBy, relationFilterCtx(filterCtx, tableName)) : needsDefaultOrder && pkNames?.length ? (aliasedTable2) => primaryKeyOrderExprs(aliasedTable2, pkNames) : void 0,
-    where: distinctKeys ? { RAW: (aliasedTable2) => primaryKeyRestriction(aliasedTable2, pkNames, distinctKeys) } : where ? {
-      RAW: (aliasedTable2) => extractFilters(aliasedTable2, tableName, where, relationFilterCtx(filterCtx, tableName))
+    ] : cursorEntries ? (
+      // Cursor pagination needs a total order: the request's orderBy plus the PK tiebreak,
+      // exactly the ordering the cursor encodes and the keyset predicate compares against.
+      (aliasedTable2) => cursorOrderExprs(aliasedTable2, cursorEntries)
+    ) : orderBy ? (aliasedTable2) => extractOrderBy(aliasedTable2, orderBy, relationFilterCtx(filterCtx, tableName)) : needsDefaultOrder && pkNames?.length ? (aliasedTable2) => primaryKeyOrderExprs(aliasedTable2, pkNames) : void 0,
+    where: distinctKeys ? { RAW: (aliasedTable2) => primaryKeyRestriction(aliasedTable2, pkNames, distinctKeys) } : where || cursorValues ? {
+      RAW: (aliasedTable2) => (0, import_drizzle_orm3.and)(
+        where ? extractFilters(aliasedTable2, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0,
+        cursorValues ? buildCursorCondition(
+          aliasedTable2,
+          cursorEntries,
+          cursorValues,
+          opts.nullOrdering ?? "nulls-smallest"
+        ) : void 0
+      )
     } : void 0,
     with: relationMap[tableName] ? extractRelationsParams(relationMap, tables, tableName, parsedInfo, typeName, typeNameMapper, filterCtx) : void 0
   };
@@ -2162,8 +2385,16 @@ var runRelationalSelect = async (opts) => {
     const result2 = await queryBase.findFirst(params);
     return result2 ? remapToGraphQLSingleOutput(result2, tableName, table, relationMap) : void 0;
   }
+  if (cursorEntries && cursorSelected) {
+    for (const [column] of cursorEntries) {
+      params.columns[column] = true;
+    }
+  }
   params.limit = distinctKeys ? void 0 : opts.limit;
   const result = await queryBase.findMany(params);
+  if (cursorEntries && cursorSelected) {
+    attachRowCursors(result, cursorEntries);
+  }
   return remapToGraphQLArrayOutput(result, tableName, table, relationMap);
 };
 var eagerLoadMutationRelations = async (db, tableName, rows, pkNames, withParams) => {
@@ -2711,7 +2942,9 @@ var generateSelectArray = (db, tableName, tables, relationMap, orderArgs, filter
           single: false,
           filterCtx,
           pkNames,
-          db: executor
+          db: executor,
+          // MySQL sorts NULLs as the smallest values (first in ASC).
+          nullOrdering: "nulls-smallest"
         });
       } catch (e) {
         throw toGraphQLError(e);
@@ -3209,16 +3442,48 @@ var generateSelectArray2 = (db, tableName, tables, relationMap, orderArgs, filte
             single: false,
             filterCtx,
             pkNames,
-            db: executor
+            db: executor,
+            // PostgreSQL sorts NULLs as the largest values (last in ASC).
+            nullOrdering: "nulls-largest"
           });
         }
-        const { offset, limit, orderBy, where, distinct } = args;
+        const { offset, limit, orderBy, where, distinct, after } = args;
         const selectedColumnsSql = extractSelectedColumnsFromTreeSQLFormat(
           parsedInfo.fieldsByTypeName[typeName],
           table,
           { tableName, relationMap, tables }
         );
-        const whereSql = where ? extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0;
+        const cursorSelected = isCursorFieldSelected(parsedInfo.fieldsByTypeName[typeName], table);
+        let cursorEntries;
+        if (after != null || cursorSelected) {
+          if (after != null && distinct?.length) {
+            throw new import_graphql7.GraphQLError("'after' cannot be combined with 'distinct'.");
+          }
+          if (orderByHasRelationEntry(orderBy)) {
+            if (after != null) {
+              throw new import_graphql7.GraphQLError(
+                "'after' cannot be combined with an orderBy that orders through a relation \u2014 a related row's value cannot be encoded into a cursor."
+              );
+            }
+          } else if (!pkNames.length) {
+            if (after != null) {
+              throw new import_graphql7.GraphQLError(
+                `Table ${tableName} has no primary key, so cursor pagination cannot be used on it.`
+              );
+            }
+          } else {
+            cursorEntries = cursorOrderingEntries(orderBy, pkNames);
+            if (cursorSelected) {
+              const allColumns = (0, import_drizzle_orm6.getColumns)(table);
+              for (const [column] of cursorEntries) {
+                selectedColumnsSql[column] ??= allColumns[column];
+              }
+            }
+          }
+        }
+        const cursorCondition = after != null && cursorEntries ? buildCursorCondition(table, cursorEntries, decodeCursor(after, cursorEntries), "nulls-largest") : void 0;
+        const baseWhereSql = where ? extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0;
+        const whereSql = cursorCondition ? (0, import_drizzle_orm6.and)(baseWhereSql, cursorCondition) : baseWhereSql;
         let distinctKeys;
         if (distinct?.length) {
           distinctKeys = await selectDistinctKeys({
@@ -3242,7 +3507,9 @@ var generateSelectArray2 = (db, tableName, tables, relationMap, orderArgs, filte
         } else if (whereSql) {
           q = q.where(whereSql);
         }
-        if (orderBy) {
+        if (cursorEntries && !distinctKeys) {
+          q = q.orderBy(...cursorOrderExprs(table, cursorEntries));
+        } else if (orderBy) {
           q = q.orderBy(
             ...extractOrderBy(table, orderBy, relationFilterCtx(filterCtx, tableName)),
             ...distinctKeys ? primaryKeyOrderExprs(table, pkNames) : []
@@ -3258,7 +3525,11 @@ var generateSelectArray2 = (db, tableName, tables, relationMap, orderArgs, filte
             q = q.limit(limit);
           }
         }
-        return remapToGraphQLArrayOutput(await q, tableName, table, relationMap);
+        const rows = await q;
+        if (cursorEntries && cursorSelected) {
+          attachRowCursors(rows, cursorEntries);
+        }
+        return remapToGraphQLArrayOutput(rows, tableName, table, relationMap);
       } catch (e) {
         throw toGraphQLError(e);
       }
@@ -3970,7 +4241,9 @@ var generateSelectArray3 = (db, tableName, tables, relationMap, orderArgs, filte
           single: false,
           filterCtx,
           pkNames,
-          db: executor
+          db: executor,
+          // SQLite sorts NULLs as the smallest values (first in ASC).
+          nullOrdering: "nulls-smallest"
         });
       } catch (e) {
         throw toGraphQLError(e);