@vantreeseba/drizzle-graphql 7.2.0 → 7.3.0

package/README.md

@@ -402,6 +402,124 @@ A **to-many** relation takes a `some` / `none` / `every` wrapper
     `users(where: { roles: { some: { name: { eq: "admin" } } } })` works the same as a direct
     to-many relation
 
+## Matching lists of values
+
+`inArray` / `notInArray` take a list of candidate values and compile to SQL `IN` / `NOT IN`.
+Two things about them are worth stating explicitly.
+
+**An empty list is answered, not rejected.** A caller building a filter from a variable often
+ends up with an empty list, and that list has a well-defined meaning: nothing is `IN ()` and
+everything is `NOT IN ()`.
+
+```graphql
+{
+    # no rows
+    posts(where: { id: { inArray: [] } }) {
+        id
+    }
+
+    # every row
+    posts(where: { id: { notInArray: [] } }) {
+        id
+    }
+}
+```
+
+The same rule applies to the Postgres array-column operators: `hasSome: []` matches nothing
+(overlapping with no elements is never true) and `hasEvery: []` matches everything (every
+array contains all zero of them).
+
+**The list's own order can be the sort order.** SQL returns `IN` matches in whatever order it
+likes, so a caller that fetches rows by a ranked list of ids normally has to re-sort them
+client-side. Setting `matchFilterOrder` on an `orderBy` entry sorts by the row's position in
+that column's `inArray` list instead of by the column's value:
+
+```graphql
+{
+    posts(
+        where: { id: { inArray: [7, 3, 12] } }
+        orderBy: { id: { direction: asc, priority: 1, matchFilterOrder: true } }
+    ) {
+        id # → 7, 3, 12
+    }
+}
+```
+
+-   `direction: asc` keeps the list's order; `desc` reverses it
+-   It needs an `inArray` filter on the same column, at the top level of `where` — an
+        `inArray` buried inside an `OR` branch raises an error rather than being guessed at
+-   It interleaves with the other `orderBy` entries by `priority` like any ordering key, and
+        works on relation fields as well as root lists
+-   It compiles to a `CASE` ladder over the list values, so it behaves identically on all
+        three dialects and every value stays a bound parameter
+-   It cannot be combined with `after` or `distinct`: a row's position in the request's own
+        filter list is not a value of the row, so it cannot be encoded into a cursor or rebuilt
+        against a subquery. Selecting `cursor` under it yields `null` rather than an error
+
+## Filtering inside JSON documents
+
+`json` / `jsonb` columns get a `path` filter that compares the value at one path inside the
+document, alongside the whole-document `eq` / `ne` / `contains` operators:
+
+```graphql
+{
+    users(where: { meta: { path: { path: ["profile", "level"], gt: 2 } } }) {
+        id
+    }
+}
+```
+
+`path` walks the document key by key from the root; an all-digits key indexes an array
+(`["tags", "0"]`). Several predicates may be given at once and are `AND`ed:
+
+```graphql
+{
+    users(
+        where: {
+            meta: {
+                path: [
+                    { path: ["profile", "role"], eq: "admin" }
+                    { path: ["profile", "level"], gte: 3 }
+                ]
+            }
+        }
+    ) {
+        id
+    }
+}
+```
+
+Available operators are `eq` / `ne` / `lt` / `lte` / `gt` / `gte`, the safe string matchers
+`startsWith` / `endsWith` / `contains` (plus their case-insensitive `i`-prefixed forms), and
+`isNull` / `isNotNull`. A missing key and a JSON `null` both read as null.
+
+**How the value is compared** is decided by the operand: a GraphQL number compares
+numerically, a boolean as a boolean, and anything else as text. Pass `as: TEXT | NUMBER |
+BOOLEAN` when the operand's type doesn't match the document's — comparing a numeric field
+against a `String` variable, say:
+
+```graphql
+{
+    users(where: { meta: { path: { path: ["profile", "level"], as: NUMBER, eq: "3" } } }) {
+        id
+    }
+}
+```
+
+A value of the wrong shape never matches rather than failing the query: `gt: 0` against a
+document whose path holds `"admin"` returns no rows on every dialect. That takes a guard on
+each one — Postgres errors outright on a bad `::numeric`, MySQL quietly casts a non-numeric
+string to `0`, and SQLite's cross-type ordering would otherwise sort every string above every
+number.
+
+Note that `contains` means different things at the two levels, because a path names a scalar:
+on the column it is structural JSON containment (Postgres `@>` / MySQL `JSON_CONTAINS`),
+inside a `path` filter it is substring matching on the extracted value.
+
+Path filters combine with `AND` / `OR` / `NOT` like any other operator, and are accepted
+everywhere a filter is — list, single and aggregate queries, `update` / `delete`, and the
+`where` argument on a relation field.
+
 ## Aggregate queries
 
 Every table also gets an aggregate query field — `<tableName>Aggregate` (e.g. `usersAggregate`),
@@ -642,8 +760,8 @@ field, and passing it back as `after` resumes strictly after that row.
 -   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`)
+-   `after` cannot be combined with `distinct` or with `matchFilterOrder`, 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
 

package/dist/README.md

@@ -402,6 +402,124 @@ A **to-many** relation takes a `some` / `none` / `every` wrapper
     `users(where: { roles: { some: { name: { eq: "admin" } } } })` works the same as a direct
     to-many relation
 
+## Matching lists of values
+
+`inArray` / `notInArray` take a list of candidate values and compile to SQL `IN` / `NOT IN`.
+Two things about them are worth stating explicitly.
+
+**An empty list is answered, not rejected.** A caller building a filter from a variable often
+ends up with an empty list, and that list has a well-defined meaning: nothing is `IN ()` and
+everything is `NOT IN ()`.
+
+```graphql
+{
+    # no rows
+    posts(where: { id: { inArray: [] } }) {
+        id
+    }
+
+    # every row
+    posts(where: { id: { notInArray: [] } }) {
+        id
+    }
+}
+```
+
+The same rule applies to the Postgres array-column operators: `hasSome: []` matches nothing
+(overlapping with no elements is never true) and `hasEvery: []` matches everything (every
+array contains all zero of them).
+
+**The list's own order can be the sort order.** SQL returns `IN` matches in whatever order it
+likes, so a caller that fetches rows by a ranked list of ids normally has to re-sort them
+client-side. Setting `matchFilterOrder` on an `orderBy` entry sorts by the row's position in
+that column's `inArray` list instead of by the column's value:
+
+```graphql
+{
+    posts(
+        where: { id: { inArray: [7, 3, 12] } }
+        orderBy: { id: { direction: asc, priority: 1, matchFilterOrder: true } }
+    ) {
+        id # → 7, 3, 12
+    }
+}
+```
+
+-   `direction: asc` keeps the list's order; `desc` reverses it
+-   It needs an `inArray` filter on the same column, at the top level of `where` — an
+        `inArray` buried inside an `OR` branch raises an error rather than being guessed at
+-   It interleaves with the other `orderBy` entries by `priority` like any ordering key, and
+        works on relation fields as well as root lists
+-   It compiles to a `CASE` ladder over the list values, so it behaves identically on all
+        three dialects and every value stays a bound parameter
+-   It cannot be combined with `after` or `distinct`: a row's position in the request's own
+        filter list is not a value of the row, so it cannot be encoded into a cursor or rebuilt
+        against a subquery. Selecting `cursor` under it yields `null` rather than an error
+
+## Filtering inside JSON documents
+
+`json` / `jsonb` columns get a `path` filter that compares the value at one path inside the
+document, alongside the whole-document `eq` / `ne` / `contains` operators:
+
+```graphql
+{
+    users(where: { meta: { path: { path: ["profile", "level"], gt: 2 } } }) {
+        id
+    }
+}
+```
+
+`path` walks the document key by key from the root; an all-digits key indexes an array
+(`["tags", "0"]`). Several predicates may be given at once and are `AND`ed:
+
+```graphql
+{
+    users(
+        where: {
+            meta: {
+                path: [
+                    { path: ["profile", "role"], eq: "admin" }
+                    { path: ["profile", "level"], gte: 3 }
+                ]
+            }
+        }
+    ) {
+        id
+    }
+}
+```
+
+Available operators are `eq` / `ne` / `lt` / `lte` / `gt` / `gte`, the safe string matchers
+`startsWith` / `endsWith` / `contains` (plus their case-insensitive `i`-prefixed forms), and
+`isNull` / `isNotNull`. A missing key and a JSON `null` both read as null.
+
+**How the value is compared** is decided by the operand: a GraphQL number compares
+numerically, a boolean as a boolean, and anything else as text. Pass `as: TEXT | NUMBER |
+BOOLEAN` when the operand's type doesn't match the document's — comparing a numeric field
+against a `String` variable, say:
+
+```graphql
+{
+    users(where: { meta: { path: { path: ["profile", "level"], as: NUMBER, eq: "3" } } }) {
+        id
+    }
+}
+```
+
+A value of the wrong shape never matches rather than failing the query: `gt: 0` against a
+document whose path holds `"admin"` returns no rows on every dialect. That takes a guard on
+each one — Postgres errors outright on a bad `::numeric`, MySQL quietly casts a non-numeric
+string to `0`, and SQLite's cross-type ordering would otherwise sort every string above every
+number.
+
+Note that `contains` means different things at the two levels, because a path names a scalar:
+on the column it is structural JSON containment (Postgres `@>` / MySQL `JSON_CONTAINS`),
+inside a `path` filter it is substring matching on the extracted value.
+
+Path filters combine with `AND` / `OR` / `NOT` like any other operator, and are accepted
+everywhere a filter is — list, single and aggregate queries, `update` / `delete`, and the
+`where` argument on a relation field.
+
 ## Aggregate queries
 
 Every table also gets an aggregate query field — `<tableName>Aggregate` (e.g. `usersAggregate`),
@@ -642,8 +760,8 @@ field, and passing it back as `after` resumes strictly after that row.
 -   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`)
+-   `after` cannot be combined with `distinct` or with `matchFilterOrder`, 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
 

package/dist/index.cjs

@@ -996,10 +996,10 @@ var runMutation = async (db, context, info, txCtx, body) => {
   }
   return runOnSharedTx(state, body);
 };
-var batchedPaginatedRelationQuery = async (db, targetTable, foreignCol, whereCondition, orderByArg, limit, offset, pkNames, orderCtx) => {
+var batchedPaginatedRelationQuery = async (db, targetTable, foreignCol, whereCondition, orderByArg, limit, offset, pkNames, orderCtx, whereArgs) => {
   const cols = (0, import_drizzle_orm4.getColumns)(targetTable);
   const orderExprs = [
-    ...orderByArg ? extractOrderBy(targetTable, orderByArg, orderCtx) : [],
+    ...orderByArg ? extractOrderBy(targetTable, orderByArg, orderCtx, whereArgs) : [],
     ...primaryKeyOrderExprs(targetTable, pkNames)
   ];
   const orderClause = orderExprs.length ? import_drizzle_orm4.sql` order by ${import_drizzle_orm4.sql.join(orderExprs, import_drizzle_orm4.sql`, `)}` : import_drizzle_orm4.sql``;
@@ -1110,11 +1110,12 @@ var createRelationResolverFactory = (db, tables, nullOrdering, filterCtx, limits
           limit ?? null,
           offset ?? null,
           targetPkNames,
-          relationFilterCtx(filterCtx, targetTableName)
+          relationFilterCtx(filterCtx, targetTableName),
+          whereArg
         );
       } else {
         let q = executor.select().from(targetTable).where(whereCondition);
-        const orderExprs = cursorEntries ? cursorOrderExprs(targetTable, cursorEntries) : orderByArg ? extractOrderBy(targetTable, orderByArg, relationFilterCtx(filterCtx, targetTableName)) : [];
+        const orderExprs = cursorEntries ? cursorOrderExprs(targetTable, cursorEntries) : orderByArg ? extractOrderBy(targetTable, orderByArg, relationFilterCtx(filterCtx, targetTableName), whereArg) : [];
         if (orderExprs.length) {
           q = q.orderBy(...orderExprs);
         }
@@ -1325,6 +1326,10 @@ var innerOrder = new import_graphql5.GraphQLInputObjectType({
     nulls: {
       type: orderNulls,
       description: "Where NULL values sort. Defaults to the database's own rule (PostgreSQL: last on asc, first on desc; MySQL/SQLite: first on asc, last on desc)"
+    },
+    matchFilterOrder: {
+      type: import_graphql5.GraphQLBoolean,
+      description: "Sort by this column's position in the `inArray` list the same request's `where` gives it, rather than by the column's own value \u2014 `direction: asc` keeps the list's order, `desc` reverses it. Requires an `inArray` filter on the same column at the top level of `where`, and cannot be combined with `after` or `distinct`."
     }
   }
 });
@@ -1390,10 +1395,59 @@ var jsonFilterFields = (column, colType) => {
         description: "Value structurally contains this JSON (Postgres `@>` / MySQL JSON_CONTAINS)"
       }
     } : {},
+    path: {
+      type: new import_graphql5.GraphQLList(new import_graphql5.GraphQLNonNull(jsonPathFilter)),
+      description: "Compares the value at one path inside the document. Several entries are ANDed; a single object may be passed without the list brackets."
+    },
     isNull: { type: import_graphql5.GraphQLBoolean },
     isNotNull: { type: import_graphql5.GraphQLBoolean }
   };
 };
+var jsonPathCast = new import_graphql5.GraphQLEnumType({
+  name: "JSONPathCast",
+  description: "How to read the value at a JSON path before comparing it",
+  values: {
+    TEXT: { value: "text", description: "Compare as text (lexicographic ordering)" },
+    NUMBER: { value: "number", description: "Compare as a number; a non-numeric value never matches" },
+    BOOLEAN: { value: "boolean", description: "Compare as a boolean" }
+  }
+});
+var jsonPathFilter = new import_graphql5.GraphQLInputObjectType({
+  name: "JSONPathFilter",
+  fields: {
+    path: {
+      type: new import_graphql5.GraphQLNonNull(new import_graphql5.GraphQLList(new import_graphql5.GraphQLNonNull(import_graphql5.GraphQLString))),
+      description: 'Keys to walk from the document root, e.g. `["profile", "level"]`. An all-digits key indexes an array.'
+    },
+    as: { type: jsonPathCast, description: "Overrides how the value is read before comparing" },
+    eq: { type: import_graphql_scalars.GraphQLJSON, description: "Equal to" },
+    ne: { type: import_graphql_scalars.GraphQLJSON, description: "Not equal to" },
+    lt: { type: import_graphql_scalars.GraphQLJSON, description: "Less than" },
+    lte: { type: import_graphql_scalars.GraphQLJSON, description: "Less than or equal to" },
+    gt: { type: import_graphql_scalars.GraphQLJSON, description: "Greater than" },
+    gte: { type: import_graphql_scalars.GraphQLJSON, description: "Greater than or equal to" },
+    startsWith: {
+      type: import_graphql5.GraphQLString,
+      description: "Extracted value starts with this string. `%`, `_` and `\\` are matched literally."
+    },
+    endsWith: {
+      type: import_graphql5.GraphQLString,
+      description: "Extracted value ends with this string. `%`, `_` and `\\` are matched literally."
+    },
+    contains: {
+      type: import_graphql5.GraphQLString,
+      description: "Extracted value contains this string. `%`, `_` and `\\` are matched literally."
+    },
+    iStartsWith: { type: import_graphql5.GraphQLString, description: "Case-insensitive `startsWith`." },
+    iEndsWith: { type: import_graphql5.GraphQLString, description: "Case-insensitive `endsWith`." },
+    iContains: { type: import_graphql5.GraphQLString, description: "Case-insensitive `contains`." },
+    isNull: {
+      type: import_graphql5.GraphQLBoolean,
+      description: "When true, matches rows where the path is missing or holds JSON null"
+    },
+    isNotNull: { type: import_graphql5.GraphQLBoolean, description: "When true, matches rows where the path holds a value" }
+  }
+});
 var IN_ARRAY_DESCRIPTION = "Matches any one of these values (SQL `IN`)";
 var NOT_IN_ARRAY_DESCRIPTION = "Matches none of these values (SQL `NOT IN`)";
 var arrayFilterFields = (colType, colArr) => {
@@ -1987,6 +2041,9 @@ var orderByEntries = (orderArgs) => Object.entries(orderArgs).sort((a, b) => (b[
   if (typeof config === "object" && config.direction === void 0) {
     throw new import_graphql5.GraphQLError(`ORDER BY ${column}: ordering through a relation is not supported in this query`);
   }
+  if (config.matchFilterOrder) {
+    throw new import_graphql5.GraphQLError(`ORDER BY ${column}: 'matchFilterOrder' is not supported in this query`);
+  }
   return [column, config.direction, config.nulls ?? void 0];
 });
 var orderExpressions = (expr, direction, nulls, dialectColumn) => {
@@ -2021,7 +2078,22 @@ var extendRelationOrderChain = (parentTable, relationName, relEntry, ctx, chain)
     table: aliasedTarget
   };
 };
-var collectOrderEntries = (table, tableKey, orderArgs, ctx, chain, out) => {
+var filterOrderExpression = (column, columnName, whereArgs) => {
+  const values = whereArgs?.[columnName]?.inArray;
+  if (!Array.isArray(values)) {
+    throw new import_graphql5.GraphQLError(
+      `ORDER BY ${columnName}: 'matchFilterOrder' needs an 'inArray' filter on the same column in this query's 'where'`
+    );
+  }
+  if (!values.length) {
+    return import_drizzle_orm4.sql`0`;
+  }
+  const branches = values.map(
+    (value, index) => import_drizzle_orm4.sql`when ${column} = ${remapFromGraphQLCore(value, column, columnName)} then ${import_drizzle_orm4.sql.raw(String(index))}`
+  );
+  return import_drizzle_orm4.sql`case ${import_drizzle_orm4.sql.join(branches, import_drizzle_orm4.sql` `)} else ${import_drizzle_orm4.sql.raw(String(values.length))} end`;
+};
+var collectOrderEntries = (table, tableKey, orderArgs, ctx, chain, out, whereArgs) => {
   const columns = (0, import_drizzle_orm4.getColumns)(table);
   const relations = ctx?.relationMap[tableKey];
   for (const [key, config] of Object.entries(orderArgs)) {
@@ -2030,8 +2102,11 @@ var collectOrderEntries = (table, tableKey, orderArgs, ctx, chain, out) => {
     }
     const column = columns[key];
     if (column) {
+      if (config.matchFilterOrder && chain) {
+        throw new import_graphql5.GraphQLError(`ORDER BY ${key}: 'matchFilterOrder' is not supported through a relation`);
+      }
       out.push({
-        expression: chain ? import_drizzle_orm4.sql`(select ${column} from ${import_drizzle_orm4.sql.join(chain.fromParts, import_drizzle_orm4.sql`, `)} where ${(0, import_drizzle_orm4.and)(...chain.conditions)})` : column,
+        expression: config.matchFilterOrder ? filterOrderExpression(column, key, whereArgs) : chain ? import_drizzle_orm4.sql`(select ${column} from ${import_drizzle_orm4.sql.join(chain.fromParts, import_drizzle_orm4.sql`, `)} where ${(0, import_drizzle_orm4.and)(...chain.conditions)})` : column,
         column,
         direction: config.direction,
         nulls: config.nulls ?? void 0,
@@ -2044,12 +2119,12 @@ var collectOrderEntries = (table, tableKey, orderArgs, ctx, chain, out) => {
       throw new import_graphql5.GraphQLError(`ORDER BY ${key}: Unknown column or relation`);
     }
     const nextChain = extendRelationOrderChain(chain?.table ?? table, key, relEntry, ctx, chain);
-    collectOrderEntries(nextChain.table, relEntry.targetTableName, config, ctx, nextChain, out);
+    collectOrderEntries(nextChain.table, relEntry.targetTableName, config, ctx, nextChain, out, void 0);
   }
 };
-var extractOrderBy = (table, orderArgs, ctx) => {
+var extractOrderBy = (table, orderArgs, ctx, whereArgs) => {
   const entries = [];
-  collectOrderEntries(table, ctx?.tableKey ?? "", orderArgs, ctx, void 0, entries);
+  collectOrderEntries(table, ctx?.tableKey ?? "", orderArgs, ctx, void 0, entries, whereArgs);
   return entries.sort((a, b) => b.priority - a.priority).flatMap((entry) => orderExpressions(entry.expression, entry.direction, entry.nulls, entry.column));
 };
 var LIKE_ESCAPE_CHAR = "\\";
@@ -2081,6 +2156,105 @@ var jsonContains = (column, columnName, value) => {
       throw new import_graphql5.GraphQLError(`WHERE ${columnName}: Operator 'contains' is not supported for this dialect!`);
   }
 };
+var sqlFalse = () => import_drizzle_orm4.sql`1 = 0`;
+var sqlTrue = () => import_drizzle_orm4.sql`1 = 1`;
+var jsonPathString = (path) => `$${path.map((part) => /^\d+$/.test(part) ? `[${part}]` : `."${part.replace(/(["\\])/g, "\\$1")}"`).join("")}`;
+var NUMERIC_TEXT_PATTERN = "^\\s*-?(\\d+\\.?\\d*|\\.\\d+)([eE][-+]?\\d+)?\\s*$";
+var jsonPathExprs = (column, path) => {
+  switch (columnDialect(column)) {
+    case "pg": {
+      const pathArray = import_drizzle_orm4.sql`array[${import_drizzle_orm4.sql.join(
+        path.map((part) => import_drizzle_orm4.sql`${part}`),
+        import_drizzle_orm4.sql`, `
+      )}]::text[]`;
+      const text = import_drizzle_orm4.sql`(${column} #>> ${pathArray})`;
+      return {
+        text,
+        number: import_drizzle_orm4.sql`(case when ${text} ~ ${NUMERIC_TEXT_PATTERN} then ${text}::numeric end)`,
+        boolean: text,
+        encodeBoolean: (value) => String(value)
+      };
+    }
+    case "mysql": {
+      const extracted = import_drizzle_orm4.sql`json_extract(${column}, ${jsonPathString(path)})`;
+      const text = import_drizzle_orm4.sql`(case when json_type(${extracted}) = 'NULL' then null else json_unquote(${extracted}) end)`;
+      return {
+        text,
+        number: import_drizzle_orm4.sql`(case when ${text} regexp ${NUMERIC_TEXT_PATTERN} then cast(${text} as decimal(65, 30)) end)`,
+        boolean: text,
+        encodeBoolean: (value) => String(value)
+      };
+    }
+    default: {
+      const extracted = import_drizzle_orm4.sql`json_extract(${column}, ${jsonPathString(path)})`;
+      return {
+        text: import_drizzle_orm4.sql`cast(${extracted} as text)`,
+        number: import_drizzle_orm4.sql`(case when typeof(${extracted}) in ('integer', 'real') then ${extracted} end)`,
+        // SQLite has no boolean type: a JSON `true` comes back as the integer 1.
+        boolean: extracted,
+        encodeBoolean: (value) => value ? 1 : 0
+      };
+    }
+  }
+};
+var JSON_PATH_COMPARISONS = {
+  eq: "=",
+  ne: "<>",
+  lt: "<",
+  lte: "<=",
+  gt: ">",
+  gte: ">="
+};
+var inferJsonPathCast = (value) => typeof value === "number" ? "number" : typeof value === "boolean" ? "boolean" : "text";
+var jsonPathCondition = (column, columnName, filter) => {
+  const { path, as: castOverride, ...operators } = filter;
+  const locator = `${columnName}.path`;
+  if (!Array.isArray(path) || !path.length) {
+    throw new import_graphql5.GraphQLError(`WHERE ${locator}: 'path' must name at least one key`);
+  }
+  const exprs = jsonPathExprs(column, path);
+  const variants = [];
+  for (const [operatorName, operatorValue] of Object.entries(operators)) {
+    if (operatorValue === null || operatorValue === void 0) {
+      continue;
+    }
+    if (operatorName === "isNull" || operatorName === "isNotNull") {
+      if (operatorValue === false) {
+        continue;
+      }
+      variants.push(operatorName === "isNull" ? import_drizzle_orm4.sql`${exprs.text} is null` : import_drizzle_orm4.sql`${exprs.text} is not null`);
+      continue;
+    }
+    if (operatorName in safeLikeOps) {
+      const { buildPattern, insensitive } = safeLikeOps[operatorName];
+      if (typeof operatorValue !== "string") {
+        throw new import_graphql5.GraphQLError(`WHERE ${locator}: operator '${operatorName}' takes a string`);
+      }
+      variants.push(safeLikeCondition(exprs.text, buildPattern(operatorValue), insensitive));
+      continue;
+    }
+    const comparison = JSON_PATH_COMPARISONS[operatorName];
+    if (!comparison) {
+      throw new import_graphql5.GraphQLError(`WHERE ${locator}: Unknown operator: ${operatorName}`);
+    }
+    const cast = castOverride ?? inferJsonPathCast(operatorValue);
+    if (cast === "number") {
+      const numeric = Number(operatorValue);
+      if (Number.isNaN(numeric)) {
+        throw new import_graphql5.GraphQLError(
+          `WHERE ${locator}: operator '${operatorName}' compares as a number, so its value must be one`
+        );
+      }
+      variants.push(import_drizzle_orm4.sql`${exprs.number} ${import_drizzle_orm4.sql.raw(comparison)} ${numeric}`);
+    } else if (cast === "boolean") {
+      const truthy = operatorValue === true || operatorValue === "true";
+      variants.push(import_drizzle_orm4.sql`${exprs.boolean} ${import_drizzle_orm4.sql.raw(comparison)} ${exprs.encodeBoolean(truthy)}`);
+    } else {
+      variants.push(import_drizzle_orm4.sql`${exprs.text} ${import_drizzle_orm4.sql.raw(comparison)} ${String(operatorValue)}`);
+    }
+  }
+  return variants.length ? variants.length > 1 ? (0, import_drizzle_orm4.and)(...variants) : variants[0] : void 0;
+};
 var extractFiltersColumn = (column, columnName, operators) => {
   const { OR, AND, NOT, ...restOperators } = operators;
   const entries = Object.entries(restOperators);
@@ -2102,6 +2276,13 @@ 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 === "path" && isJsonColumn2(column)) {
+      for (const pathFilter of operatorValue) {
+        const extracted = jsonPathCondition(column, columnName, pathFilter);
+        if (extracted) {
+          variants.push(extracted);
+        }
+      }
     } else if (operatorName === "contains" && isJsonColumn2(column)) {
       variants.push(jsonContains(column, columnName, operatorValue));
     } else if (operatorName in safeLikeOps) {
@@ -2109,7 +2290,8 @@ var extractFiltersColumn = (column, columnName, operators) => {
       variants.push(safeLikeCondition(column, buildPattern(operatorValue), insensitive));
     } else if (operatorName in arrayValueOps) {
       if (!operatorValue.length) {
-        throw new import_graphql5.GraphQLError(`WHERE ${columnName}: Unable to use operator ${operatorName} with an empty array!`);
+        variants.push(operatorName === "inArray" ? sqlFalse() : sqlTrue());
+        continue;
       }
       const arrayValue = operatorValue.map((val) => remapFromGraphQLCore(val, column, columnName));
       variants.push(arrayValueOps[operatorName](column, arrayValue));
@@ -2117,7 +2299,8 @@ var extractFiltersColumn = (column, columnName, operators) => {
       variants.push((0, import_drizzle_orm4.arrayContains)(column, [operatorValue]));
     } else if (operatorName in arrayMembershipOps) {
       if (!operatorValue.length) {
-        throw new import_graphql5.GraphQLError(`WHERE ${columnName}: Unable to use operator ${operatorName} with an empty array!`);
+        variants.push(operatorName === "hasSome" ? sqlFalse() : sqlTrue());
+        continue;
       }
       variants.push(arrayMembershipOps[operatorName](column, operatorValue));
     } else if (operatorName === "isEmpty") {
@@ -2380,7 +2563,7 @@ var extractRelationsParamsInner = (relationMap, tables, tableName, typeName, ori
     } : void 0;
     const hasPagination = offset != null || limit != null;
     const pkNames = targetPkNames ?? [];
-    thisRecord.orderBy = relationArgs?.orderBy ? (aliasedTable2) => extractOrderBy(aliasedTable2, relationArgs.orderBy, relationFilterCtx(filterCtx, targetTableName)) : hasPagination && pkNames.length ? (aliasedTable2) => primaryKeyOrderExprs(aliasedTable2, pkNames) : void 0;
+    thisRecord.orderBy = relationArgs?.orderBy ? (aliasedTable2) => extractOrderBy(aliasedTable2, relationArgs.orderBy, relationFilterCtx(filterCtx, targetTableName), relWhere) : hasPagination && pkNames.length ? (aliasedTable2) => primaryKeyOrderExprs(aliasedTable2, pkNames) : void 0;
     thisRecord.offset = offset;
     thisRecord.limit = limit;
     const relWith = relationField ? extractRelationsParamsInner(
@@ -2460,6 +2643,15 @@ var primaryKeyOrderExprs = (table, pkNames) => {
 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 orderByCursorObstacle = (orderBy) => {
+  if (orderByHasRelationEntry(orderBy)) {
+    return "'after' cannot be combined with an orderBy that orders through a relation \u2014 a related row's value cannot be encoded into a cursor.";
+  }
+  if (orderBy && Object.values(orderBy).some((config) => config && typeof config === "object" && config.matchFilterOrder)) {
+    return "'after' cannot be combined with 'matchFilterOrder' \u2014 a row's position in the request's own filter list is not a value of the row, so it cannot be encoded into a cursor.";
+  }
+  return void 0;
+};
 var cursorOrderingEntries = (orderBy, pkNames) => {
   const entries = orderBy ? orderByEntries(orderBy) : [];
   const seen = new Set(entries.map(([column]) => column));
@@ -3056,11 +3248,10 @@ var runRelationalSelect = async (opts) => {
     if (after != null && distinct) {
       throw new import_graphql5.GraphQLError("'after' cannot be combined with 'distinct'.");
     }
-    if (orderByHasRelationEntry(orderBy)) {
+    const cursorObstacle = orderByCursorObstacle(orderBy);
+    if (cursorObstacle) {
       if (after != null) {
-        throw new import_graphql5.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."
-        );
+        throw new import_graphql5.GraphQLError(cursorObstacle);
       }
     } else if (!pkNames?.length) {
       if (after != null) {
@@ -3100,13 +3291,13 @@ var runRelationalSelect = async (opts) => {
     // drizzle-orm v1 RQB calls orderBy/where with the aliased table proxy — use it
     // directly so column refs match the CTE alias.
     orderBy: distinctKeys ? (aliasedTable2) => [
-      ...orderBy ? extractOrderBy(aliasedTable2, orderBy, relationFilterCtx(filterCtx, tableName)) : [],
+      ...orderBy ? extractOrderBy(aliasedTable2, orderBy, relationFilterCtx(filterCtx, tableName), where) : [],
       ...primaryKeyOrderExprs(aliasedTable2, pkNames)
     ] : 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,
+    ) : orderBy ? (aliasedTable2) => extractOrderBy(aliasedTable2, orderBy, relationFilterCtx(filterCtx, tableName), where) : needsDefaultOrder && pkNames?.length ? (aliasedTable2) => primaryKeyOrderExprs(aliasedTable2, pkNames) : void 0,
     where: distinctKeys ? { RAW: (aliasedTable2) => primaryKeyRestriction(aliasedTable2, pkNames, distinctKeys) } : where || cursorValues ? {
       RAW: (aliasedTable2) => (0, import_drizzle_orm4.and)(
         where ? extractFilters(aliasedTable2, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0,
@@ -4763,11 +4954,10 @@ var generateSelectArray2 = (db, tableName, tables, relationMap, orderArgs, filte
           if (after != null && distinct?.length) {
             throw new import_graphql9.GraphQLError("'after' cannot be combined with 'distinct'.");
           }
-          if (orderByHasRelationEntry(orderBy)) {
+          const cursorObstacle = orderByCursorObstacle(orderBy);
+          if (cursorObstacle) {
             if (after != null) {
-              throw new import_graphql9.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."
-              );
+              throw new import_graphql9.GraphQLError(cursorObstacle);
             }
           } else if (!pkNames.length) {
             if (after != null) {
@@ -4815,7 +5005,7 @@ var generateSelectArray2 = (db, tableName, tables, relationMap, orderArgs, filte
           q = q.orderBy(...cursorOrderExprs(table, cursorEntries));
         } else if (orderBy) {
           q = q.orderBy(
-            ...extractOrderBy(table, orderBy, relationFilterCtx(filterCtx, tableName)),
+            ...extractOrderBy(table, orderBy, relationFilterCtx(filterCtx, tableName), where),
             ...distinctKeys ? primaryKeyOrderExprs(table, pkNames) : []
           );
         } else if ((distinctKeys || offset != null || limit != null) && pkNames.length) {
@@ -4881,7 +5071,7 @@ var generateSelectSingle2 = (db, tableName, tables, relationMap, orderArgs, filt
           q = q.where(extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName)));
         }
         if (orderBy) {
-          q = q.orderBy(...extractOrderBy(table, orderBy, relationFilterCtx(filterCtx, tableName)));
+          q = q.orderBy(...extractOrderBy(table, orderBy, relationFilterCtx(filterCtx, tableName), where));
         } else if (pkNames.length) {
           q = q.orderBy(...primaryKeyOrderExprs(table, pkNames));
         }