fix(gatsby): nodeModel.findAll supports v5 sort argument structure

packages/gatsby/src/schema/__tests__/node-model.js

@@ -676,6 +676,7 @@ describe(`NodeModel`, () => {
  nested: {
  foo: `foo1`,
  bar: `bar1`,
+ sort_order: 10,
  },
  internal: {
  type: `Test`,
@@ -689,6 +690,7 @@ describe(`NodeModel`, () => {
  nested: {
  foo: `foo2`,
  bar: `bar2`,
+ sort_order: 9,
  },
  internal: {
  type: `Test`,
@@ -1122,6 +1124,49 @@ describe(`NodeModel`, () => {
  expect(result2[0].id).toBe(`id2`)
  })
 
+ it(`findAll sorts using v5 sort fields`, async () => {
+ nodeModel.replaceFiltersCache()
+
+ const { entries } = await nodeModel.findAll(
+ {
+ query: {
+ sort: [{ nested: { sort_order: `asc` } }],
+ },
+ type: `Test`,
+ },
+ { path: `/` }
+ )
+
+ const result = Array.from(entries)
+
+ expect(result.length).toBe(2)
+ expect(result[0].id).toBe(`id2`)
+ expect(result[1].id).toBe(`id1`)
+ })
+
+ it(`findAll sorts using legacy (pre-v5) sort fields`, async () => {
+ nodeModel.replaceFiltersCache()
+
+ const { entries } = await nodeModel.findAll(
+ {
+ query: {
+ sort: {
+ fields: [`nested.sort_order`],
+ order: [`asc`],
+ },
+ },
+ type: `Test`,
+ },
+ { path: `/` }
+ )
+
+ const result = Array.from(entries)
+
+ expect(result.length).toBe(2)
+ expect(result[0].id).toBe(`id2`)
+ expect(result[1].id).toBe(`id1`)
+ })
+
  it(`always uses a custom resolvers for query fields`, async () => {
  // See https://github.com/gatsbyjs/gatsby/issues/27368
  nodeModel.replaceFiltersCache()

packages/gatsby/src/schema/node-model.js

@@ -16,7 +16,11 @@ import { store } from "../redux"
 import { getDataStore, getNode, getTypes } from "../datastore"
 import { GatsbyIterable, isIterable } from "../datastore/common/iterable"
 import { wrapNode, wrapNodes } from "../utils/detect-node-mutations"
-import { toNodeTypeNames, fieldNeedToResolve } from "./utils"
+import {
+ toNodeTypeNames,
+ fieldNeedToResolve,
+ maybeConvertSortInputObjectToSortPath,
+} from "./utils"
 import { getMaybeResolvedValue } from "./resolvers"
 
 type TypeOrTypeName = string | GraphQLOutputType
@@ -193,7 +197,7 @@ class LocalNodeModel {
  }
 
  async _query(args) {
- const { query = {}, type, stats, tracer } = args || {}
+ let { query = {}, type, stats, tracer } = args || {}
 
  // We don't support querying union types (yet?), because the combined types
  // need not have any fields in common.
@@ -236,6 +240,8 @@ class LocalNodeModel {
  }
  }
 
+ query = maybeConvertSortInputObjectToSortPath(query)
+
  let materializationActivity
  if (tracer) {
  materializationActivity = reporter.phantomActivity(`Materialization`, {

packages/gatsby/src/schema/resolvers.ts

@@ -16,7 +16,6 @@ import {
  SelectionNode,
  FieldNode,
 } from "graphql"
-import isPlainObject from "lodash/isPlainObject"
 import { Path } from "graphql/jsutils/Path"
 import reporter from "gatsby-cli/lib/reporter"
 import { pathToArray } from "../query/utils"
@@ -29,48 +28,18 @@ import {
 import { IGatsbyNode } from "../redux/types"
 import { IQueryResult } from "../datastore/types"
 import { GatsbyIterable } from "../datastore/common/iterable"
-import { getResolvedFields, fieldPathNeedToResolve } from "./utils"
+import {
+ getResolvedFields,
+ fieldPathNeedToResolve,
+ INestedPathStructureNode,
+ pathObjectToPathString,
+} from "./utils"
 
 type ResolvedLink = IGatsbyNode | Array<IGatsbyNode> | null
 
 type nestedListOfStrings = Array<string | nestedListOfStrings>
 type nestedListOfNodes = Array<IGatsbyNode | nestedListOfNodes>
 
-type NestedPathStructure = INestedPathStructureNode | true | "ASC" | "DESC"
-
-interface INestedPathStructureNode {
- [key: string]: NestedPathStructure
-}
-
-function pathObjectToPathString(input: INestedPathStructureNode): {
- path: string
- leaf: any
-} {
- const path: Array<string> = []
- let currentValue: NestedPathStructure | undefined = input
- let leaf: any = undefined
- while (currentValue) {
- if (isPlainObject(currentValue)) {
- const entries = Object.entries(currentValue)
- if (entries.length !== 1) {
- throw new Error(`Invalid field arg`)
- }
- for (const [key, value] of entries) {
- path.push(key)
- currentValue = value
- }
- } else {
- leaf = currentValue
- currentValue = undefined
- }
- }
-
- return {
- path: path.join(`.`),
- leaf,
- }
-}
-
 export function getMaybeResolvedValue(
  node: IGatsbyNode,
  field: string | INestedPathStructureNode,
@@ -113,39 +82,6 @@ export function findOne<TSource, TArgs>(
 
 type PaginatedArgs<TArgs> = TArgs & { skip?: number; limit?: number; sort: any }
 
-function maybeConvertSortInputObjectToSortPath<TArgs>(
- args: PaginatedArgs<TArgs>
-): any {
- if (!args.sort) {
- return args
- }
-
- if (_CFLAGS_.GATSBY_MAJOR === `5`) {
- let sorts = args.sort
- if (!Array.isArray(sorts)) {
- sorts = [sorts]
- }
-
- const modifiedSort: any = {
- fields: [],
- order: [],
- }
-
- for (const sort of sorts) {
- const { path, leaf } = pathObjectToPathString(sort)
- modifiedSort.fields.push(path)
- modifiedSort.order.push(leaf)
- }
-
- return {
- ...args,
- sort: modifiedSort,
- }
- }
-
- return args
-}
-
 export function findManyPaginated<TSource, TArgs>(
  typeName: string
 ): GatsbyResolver<TSource, PaginatedArgs<TArgs>> {
@@ -169,7 +105,7 @@ export function findManyPaginated<TSource, TArgs>(
  const limit = typeof args.limit === `number` ? args.limit + 2 : undefined
 
  const extendedArgs = {
- ...maybeConvertSortInputObjectToSortPath(args),
+ ...args,
  group: group || [],
  distinct: distinct || [],
  max: max || [],

packages/gatsby/src/schema/utils.ts

@@ -14,6 +14,7 @@ import {
  ObjectTypeComposer,
  SchemaComposer,
 } from "graphql-compose"
+import isPlainObject from "lodash/isPlainObject"
 
 import type { IGatsbyNodePartial } from "../datastore/in-memory/indexing"
 import { IGatsbyNode } from "../internal"
@@ -145,3 +146,83 @@ export function getResolvedFields(
  const resolvedNodes = store.getState().resolvedNodesCache.get(typeName)
  return resolvedNodes?.get(node.id)
 }
+
+type NestedPathStructure = INestedPathStructureNode | true | "ASC" | "DESC"
+
+export interface INestedPathStructureNode {
+ [key: string]: NestedPathStructure
+}
+
+export function pathObjectToPathString(input: INestedPathStructureNode): {
+ path: string
+ leaf: any
+} {
+ const path: Array<string> = []
+ let currentValue: NestedPathStructure | undefined = input
+ let leaf: any = undefined
+ while (currentValue) {
+ if (isPlainObject(currentValue)) {
+ const entries = Object.entries(currentValue)
+ if (entries.length !== 1) {
+ throw new Error(`Invalid field arg`)
+ }
+ for (const [key, value] of entries) {
+ path.push(key)
+ currentValue = value
+ }
+ } else {
+ leaf = currentValue
+ currentValue = undefined
+ }
+ }
+
+ return {
+ path: path.join(`.`),
+ leaf,
+ }
+}
+
+export function maybeConvertSortInputObjectToSortPath(args: any): any {
+ if (!args.sort) {
+ return args
+ }
+
+ if (_CFLAGS_.GATSBY_MAJOR === `5`) {
+ // check if it's already in expected format
+ if (
+ Array.isArray(args.sort?.fields) &&
+ Array.isArray(args.sort?.order) &&
+ args.sort.order.every(
+ item =>
+ typeof item === `string` &&
+ (item.toLowerCase() === `asc` || item.toLowerCase() === `desc`)
+ )
+ ) {
+ return args
+ }
+
+ let sorts = args.sort
+
+ if (!Array.isArray(sorts)) {
+ sorts = [sorts]
+ }
+
+ const modifiedSort: any = {
+ fields: [],
+ order: [],
+ }
+
+ for (const sort of sorts) {
+ const { path, leaf } = pathObjectToPathString(sort)
+ modifiedSort.fields.push(path)
+ modifiedSort.order.push(leaf)
+ }
+
+ return {
+ ...args,
+ sort: modifiedSort,
+ }
+ }
+
+ return args
+}