@voxgig/sdkgen 1.5.1 → 2.0.0

package/project/.sdk/tm/java/utility/MakeSpec.java

@@ -54,8 +54,23 @@ final class MakeSpec {
     ctx.spec.params = utility.prepareParams.apply(ctx);
     ctx.spec.query = utility.prepareQuery.apply(ctx);
     ctx.spec.headers = utility.prepareHeaders.apply(ctx);
-    ctx.spec.body = utility.prepareBody.apply(ctx);
-    ctx.spec.path = utility.preparePath.apply(ctx);
+
+    if ("graphql".equals(Struct.getprop(point, "kind", null))) {
+      // GraphQL addresses one endpoint: no path parts, no query string, and
+      // the body carries the operation. prepareBody is skipped deliberately
+      // — it only emits a body for data-input ops, whereas every GraphQL op
+      // posts one, including load/list/remove.
+      ctx.spec.body = utility.graphqlBody.apply(ctx);
+      ctx.spec.path = "";
+      // prepareQuery already copied the op's match arguments into the query
+      // string. Those same values are bound as operation variables, so
+      // leaving them would send /graphql?id=i1.
+      ctx.spec.query = new LinkedHashMap<>();
+      ctx.spec.headers.put("content-type", Graphql.GRAPHQL_CONTENT_TYPE);
+    } else {
+      ctx.spec.body = utility.prepareBody.apply(ctx);
+      ctx.spec.path = utility.preparePath.apply(ctx);
+    }
 
     if (ctx.ctrl.explain != null) {
       ctx.ctrl.explain.put("spec", ctx.spec);

package/project/.sdk/tm/java/utility/Register.java

@@ -32,6 +32,8 @@ public final class Register {
     u.prepareParams = PrepareParams::prepareParams;
     u.preparePath = PreparePath::preparePath;
     u.prepareQuery = PrepareQuery::prepareQuery;
+    u.graphqlBody = Graphql::graphqlBody;
+    u.graphqlErrors = Graphql::graphqlErrors;
     u.resultBasic = ResultBasic::resultBasic;
     u.resultBody = ResultBody::resultBody;
     u.resultHeaders = ResultHeaders::resultHeaders;

package/project/.sdk/tm/js/src/Point.js

@@ -5,6 +5,11 @@ const { getprop } = require('./utility/StructUtility')
 class Point {
   constructor(altmap) {
     this.args = getprop(altmap, 'args', { params: [] })
+    // Transport this point speaks: 'http' (default) or 'graphql'. GraphQL
+    // points carry their operation document in `graphql` and address the
+    // single endpoint, so method is always POST and parts is empty.
+    this.kind = getprop(altmap, 'kind', 'http')
+    this.graphql = getprop(altmap, 'graphql')
     this.rename = getprop(altmap, 'rename', { params: {} })
     this.method = getprop(altmap, 'method', '')
     this.orig = getprop(altmap, 'orig', '')

package/project/.sdk/tm/js/src/feature/paging/PagingFeature.js

@@ -46,6 +46,14 @@ class PagingFeature extends BaseFeature {
     // A per-call cursor/page from ctrl takes priority (used by auto-iteration).
     const paging = (ctx.ctrl && ctx.ctrl.paging) || {}
 
+    // GraphQL paginates through operation VARIABLES, not the query string.
+    // This hook runs after makeSpec, so spec.body already holds the
+    // { query, variables } envelope, and before makeFetchDef serialises it.
+    const point = ctx.point
+    if ('graphql' === (null == point ? undefined : point.kind)) {
+      return this._graphqlPreRequest(ctx, paging)
+    }
+
     if (null != paging.cursor) {
       spec.query[cursorParam] = paging.cursor
     }
@@ -71,6 +79,10 @@ class PagingFeature extends BaseFeature {
     const headers = result.headers || {}
     const body = result.body
 
+    // Set when the response states hasMore outright, rather than leaving it
+    // to be inferred from the presence of a cursor.
+    let explicitMore = false
+
     const paging = {
       page: this._num(this._header(headers, 'x-page')),
       totalCount: this._num(this._header(headers, 'x-total-count')),
@@ -89,16 +101,49 @@ class PagingFeature extends BaseFeature {
       }
     }
 
+    // Relay connections carry the cursor in pageInfo, at the path the model
+    // recorded for this op.
+    const point = ctx.point
+    const page = null == point ? undefined : (point.graphql || {}).page
+
+    if (null != page && body && 'object' === typeof body) {
+      const struct = ctx.utility.struct
+
+      // `connpath` locates the connection object inside the response
+      // envelope (data.<field>); the cursor/more paths are relative to it.
+      const conn = null == page.connpath || '' === page.connpath ? body :
+        (struct.getpath(body, page.connpath) || body)
+
+      const cursor = struct.getpath(conn, page.cursor)
+      const more = struct.getpath(conn, page.more)
+
+      if (null != cursor) { paging.cursor = cursor }
+      if ('boolean' === typeof more) {
+        paging.hasMore = more
+        explicitMore = true
+      }
+    }
+
     // Body-level cursors.
     if (body && 'object' === typeof body) {
       if (null != body.next) { paging.next = paging.next || body.next }
       if (null != body.cursor) { paging.cursor = body.cursor }
       if (null != body.nextCursor) { paging.cursor = body.nextCursor }
-      if ('boolean' === typeof body.hasMore) { paging.hasMore = body.hasMore }
+      if ('boolean' === typeof body.hasMore) {
+        paging.hasMore = body.hasMore
+        explicitMore = true
+      }
     }
 
-    paging.hasMore = paging.hasMore ||
-      null != paging.next || null != paging.cursor || null != paging.nextPage
+    // Cursor presence only INFERS another page. When the server stated the
+    // answer outright — relay's `hasNextPage: false`, or a body `hasMore` —
+    // that wins: a final page normally carries both an end cursor and
+    // hasNextPage false, and inferring from the cursor there would send the
+    // caller back for a page that does not exist, forever.
+    if (!explicitMore) {
+      paging.hasMore = paging.hasMore ||
+        null != paging.next || null != paging.cursor || null != paging.nextPage
+    }
 
     result.paging = paging
 
@@ -107,6 +152,40 @@ class PagingFeature extends BaseFeature {
   }
 
 
+
+  // Relay pagination: the cursor is the `after` variable (or whatever the
+  // model recorded), and the page size the `first` variable.
+  _graphqlPreRequest(ctx, paging) {
+    const spec = ctx.spec
+    const point = ctx.point
+
+    const body = spec.body
+    if (null == body || 'object' !== typeof body) {
+      return
+    }
+
+    const vars = (body.variables = body.variables || {})
+
+    const afterVar = this._options.afterVar || 'after'
+    const firstVar = this._options.firstVar || 'first'
+
+    // Only bind variables the operation actually declares, or the server
+    // rejects the document.
+    const declared = {}
+    for (const v of ((point.graphql && point.graphql.vars) || [])) {
+      declared[v.name] = true
+    }
+
+    if (null != paging.cursor && declared[afterVar]) {
+      vars[afterVar] = paging.cursor
+    }
+
+    if (null != this._options.limit && null == vars[firstVar] &&
+      declared[firstVar]) {
+      vars[firstVar] = this._options.limit
+    }
+  }
+
   _isList(ctx) {
     const ops = this._options.ops || ['list']
     return ops.indexOf(ctx.op && ctx.op.name) >= 0

package/project/.sdk/tm/js/src/feature/test/TestFeature.js

@@ -61,8 +61,20 @@ class TestFeature extends BaseFeature {
         if (null == data || 'string' !== typeof restf) {
           return data
         }
-        const m = restf.match(/^`body\.([^`.]+)`$/)
-        return null == m ? data : { [m[1]]: data }
+        // Rebuild whatever nesting the op's response transform unwraps, so
+        // the mock agrees with the model. Multi-segment on purpose: GraphQL
+        // ops unwrap `body.data.<field>` (and `body.data.<field>.<entity>`
+        // for mutation payloads), not just a single envelope property.
+        const m = restf.match(/^`body\.(.+)`$/)
+        if (null == m) {
+          return data
+        }
+        let out = data
+        const segs = m[1].split('.')
+        for (let i = segs.length - 1; 0 <= i; i--) {
+          out = { [segs[i]]: out }
+        }
+        return out
       }
 
       function respond(status, data, res) {

package/project/.sdk/tm/js/src/utility/GraphqlUtility.js

@@ -0,0 +1,148 @@
+// GraphQL transport. API-INDEPENDENT: every GraphQL SDK this generator
+// produces uses this file unchanged. The API-specific part — which
+// operations exist and what each one's document is — is model data,
+// computed once by apidef and emitted into Config.
+//
+// Two jobs:
+//
+//   graphqlBody    — build { query, variables } for a point, binding the
+//                    op's arguments to the document's declared variables.
+//
+//   graphqlErrors  — lift a GraphQL failure into an SDK error. GraphQL
+//                    reports failures as a top-level `errors` array under
+//                    HTTP 200, so the status-driven path in resultBasic
+//                    never sees them.
+
+
+// Content type every GraphQL-over-HTTP request uses.
+const GRAPHQL_CONTENT_TYPE = 'application/json'
+
+
+// Map a GraphQL error to the same error codes the HTTP path produces, so a
+// caller handles auth or rate limiting identically on both transports.
+// Servers put the machine-readable code in `extensions.code`; Linear-style
+// APIs use `extensions.type`.
+function graphqlErrorCode(gqlerr) {
+  const ext = (null == gqlerr ? undefined : gqlerr.extensions) || {}
+  const raw = String(ext.code || ext.type || '').toUpperCase()
+
+  if (raw.includes('AUTH') || raw.includes('FORBIDDEN') ||
+    raw.includes('UNAUTHENTICATED')) {
+    return 'request_auth'
+  }
+  if (raw.includes('RATELIMIT') || raw.includes('RATE_LIMIT') ||
+    raw.includes('TOO_MANY')) {
+    return 'request_ratelimit'
+  }
+  if (raw.includes('BAD_USER_INPUT') || raw.includes('VALIDATION') ||
+    raw.includes('INVALID')) {
+    return 'request_invalid'
+  }
+
+  return 'request_graphql'
+}
+
+
+// Build the request body for a GraphQL point.
+//
+// Variables come from the op's own arguments: a named variable binds to the
+// like-named argument (`from`), and the input-object variable (empty `from`)
+// takes the request data as a whole — which is what makes a generated
+// create/update call look exactly like its REST equivalent.
+function graphqlBody(ctx) {
+  const utility = ctx.utility
+  const struct = utility.struct
+  const getprop = struct.getprop
+
+  const point = ctx.point
+  const gql = null == point ? undefined : point.graphql
+
+  if (null == gql) {
+    return undefined
+  }
+
+  const op = ctx.op
+  const input = null == op ? 'match' : op.input
+
+  // reqmatch/reqdata hold the caller's arguments for this operation.
+  const reqsrc = getprop(ctx, 'req' + input) || {}
+  const datasrc = getprop(ctx, input) || {}
+
+  const variables = {}
+
+  for (const spec of (gql.vars || [])) {
+    if ('' === spec.from || null == spec.from) {
+      // The input object IS the request body. Strip the action selector,
+      // which is an SDK-side point discriminator, not an API field.
+      const body = {}
+      for (const key of Object.keys(reqsrc)) {
+        if ('$action' !== key) {
+          body[key] = reqsrc[key]
+        }
+      }
+      variables[spec.name] = body
+    }
+    else {
+      const val = undefined !== getprop(reqsrc, spec.from) ?
+        getprop(reqsrc, spec.from) : getprop(datasrc, spec.from)
+
+      // Only send variables the caller actually supplied: sending an
+      // explicit null would clear a field on many APIs.
+      if (undefined !== val && null !== val) {
+        variables[spec.name] = val
+      }
+    }
+  }
+
+  return {
+    query: gql.doc,
+    variables,
+  }
+}
+
+
+// Inspect a decoded GraphQL response body and record a failure when the
+// server reported one. Returns true when an error was recorded.
+//
+// Partial data (`data` alongside `errors`) is treated as failure: the REST
+// surface has no partial-success concept, and silently returning half an
+// object would be worse than failing. The raw envelope stays available on
+// the result for callers that need it.
+function graphqlErrors(ctx) {
+  const result = ctx.result
+  const point = ctx.point
+
+  if (null == result || null == point || 'graphql' !== point.kind) {
+    return false
+  }
+
+  const body = result.body
+  const errors = null == body ? undefined : body.errors
+
+  if (null == errors || !Array.isArray(errors) || 0 === errors.length) {
+    return false
+  }
+
+  const first = errors[0]
+  const msg = (null == first ? undefined : first.message) || 'graphql error'
+  const code = graphqlErrorCode(first)
+
+  const err = ctx.error(code,
+    'graphql: ' + msg + (1 < errors.length ?
+      ' (+' + (errors.length - 1) + ' more)' : ''))
+
+  // Keep the full error list reachable for diagnostics.
+  err.graphql = errors
+  result.err = err
+  result.ok = false
+
+  return true
+}
+
+
+module.exports = {
+  graphqlBody,
+  graphqlErrors,
+  graphqlErrorCode,
+  GRAPHQL_CONTENT_TYPE,
+}

package/project/.sdk/tm/js/src/utility/MakeOptionsUtility.js

@@ -52,7 +52,7 @@ function makeOptions(ctx) {
     },
     allow: {
       method: 'GET,PUT,POST,PATCH,DELETE,OPTIONS',
-      op: 'create,update,load,list,remove,command,direct'
+      op: 'create,update,load,list,remove,command,direct,graphql'
     },
     entity: {
       '`$CHILD`': {

package/project/.sdk/tm/js/src/utility/MakeResponseUtility.js

@@ -10,6 +10,7 @@ async function makeResponse(ctx) {
   const resultHeaders = utility.resultHeaders
   const resultBody = utility.resultBody
   const transformResponse = utility.transformResponse
+  const graphqlErrors = utility.graphqlErrors
 
   const spec = ctx.spec
   const result = ctx.result
@@ -33,6 +34,12 @@ async function makeResponse(ctx) {
     resultBasic(ctx)
     resultHeaders(ctx)
     await resultBody(ctx)
+
+    // GraphQL reports failures as a top-level `errors` array under HTTP 200,
+    // so resultBasic's status check never sees them. Lift them here, before
+    // the response transform tries to unwrap data that is not there.
+    graphqlErrors(ctx)
+
     transformResponse(ctx)
 
     if (null == result.err) {

package/project/.sdk/tm/js/src/utility/MakeSpecUtility.js

@@ -37,8 +37,25 @@ function makeSpec(ctx) {
   ctx.spec.params = prepareParams(ctx)
   ctx.spec.query = prepareQuery(ctx)
   ctx.spec.headers = prepareHeaders(ctx)
-  ctx.spec.body = prepareBody(ctx)
-  ctx.spec.path = preparePath(ctx)
+
+  if ('graphql' === point.kind) {
+    // GraphQL addresses one endpoint: no path parts, no query string, and
+    // the body carries the operation. prepareBody is skipped deliberately —
+    // it only emits a body for data-input ops (create/update), whereas every
+    // GraphQL op posts one, including load/list/remove.
+    ctx.spec.body = utility.graphqlBody(ctx)
+    ctx.spec.path = ''
+    // prepareQuery already copied the op's match arguments into the query
+    // string. Those same values are bound as operation variables, so leaving
+    // them would send /graphql?id=i1 — duplicating the argument, leaking it
+    // into the URL, and failing servers that reject unknown query params.
+    ctx.spec.query = {}
+    ctx.spec.headers['content-type'] = utility.GRAPHQL_CONTENT_TYPE
+  }
+  else {
+    ctx.spec.body = prepareBody(ctx)
+    ctx.spec.path = preparePath(ctx)
+  }
 
   if (ctx.ctrl.explain) {
     ctx.ctrl.explain.spec = ctx.spec

package/project/.sdk/tm/js/src/utility/Utility.js

@@ -15,6 +15,7 @@ const { makeResponse } = require('./MakeResponseUtility')
 const { makeResult } = require('./MakeResultUtility')
 const { makePoint } = require('./MakePointUtility')
 const { makeSpec } = require('./MakeSpecUtility')
+const { graphqlBody, graphqlErrors, GRAPHQL_CONTENT_TYPE } = require('./GraphqlUtility')
 const { makeUrl } = require('./MakeUrlUtility')
 const { param } = require('./ParamUtility')
 const { prepareAuth } = require('./PrepareAuthUtility')
@@ -50,6 +51,9 @@ class Utility {
   makeResult = makeResult
   makePoint = makePoint
   makeSpec = makeSpec
+  graphqlBody = graphqlBody
+  graphqlErrors = graphqlErrors
+  GRAPHQL_CONTENT_TYPE = GRAPHQL_CONTENT_TYPE
   makeUrl = makeUrl
   param = param
   prepareAuth = prepareAuth

package/project/.sdk/tm/kotlin/core/SdkClient.kt

@@ -159,7 +159,91 @@ abstract class SdkClient(sdkopts: MutableMap<String, Any?>?) {
     return utility.makeFetchDef(ctx)
   }
 
+  // Raw endpoint access is operator-controllable, like every entity op.
+  // Blocking it means denying BOTH the 'direct' and 'graphql' tokens, since
+  // either one reaches the same endpoint.
   fun direct(fetchargsIn: MutableMap<String, Any?>?): MutableMap<String, Any?> {
+    if (!opAllowed("direct")) {
+      return opDenied("direct")
+    }
+
+    return rawRequest(fetchargsIn)
+  }
+
+  // Is this raw-access op permitted by the SDK's allow.op option?
+  private fun opAllowed(op: String): Boolean {
+    val allow = Struct.getpath(this.options, listOf("allow", "op"))
+    return allow is String && allow.contains(op)
+  }
+
+  private fun opDenied(op: String): MutableMap<String, Any?> {
+    val allow = Struct.getpath(this.options, listOf("allow", "op")) as? String
+    val out = linkedMapOf<String, Any?>()
+    out["ok"] = false
+    out["err"] = SdkError(op + "_allow",
+      "ProjectNameSDK: " + op + ": operation not allowed by" +
+        " SDK option allow.op value: \"" + (allow ?: "") + "\"", null)
+    return out
+  }
+
+  // Raw GraphQL access: the pressure valve that makes the generated
+  // surface's deliberate omissions (per-call selection sets, typed filter
+  // builders, batching, subscriptions) livable — the whole schema stays
+  // reachable.
+  //
+  // Thin wrapper over the same prepare/fetch path direct uses, with the one
+  // thing raw direct cannot do for GraphQL: a GraphQL failure rides HTTP 200
+  // as a top-level `errors` array, so status alone would report a failed
+  // query as ok.
+  //
+  // NOTE: like direct, this bypasses the feature pipeline — no retry,
+  // ratelimit or paging features apply.
+  @JvmOverloads
+  fun graphql(
+    query: String,
+    variables: MutableMap<String, Any?>? = null,
+    ctrl: MutableMap<String, Any?>? = null,
+  ): MutableMap<String, Any?> {
+    if (!opAllowed("graphql")) {
+      return opDenied("graphql")
+    }
+
+    val res = rawRequest(linkedMapOf<String, Any?>(
+      "method" to "POST",
+      "headers" to linkedMapOf<String, Any?>(
+        "content-type" to "application/json"),
+      "body" to linkedMapOf<String, Any?>(
+        "query" to query,
+        "variables" to (variables ?: linkedMapOf<String, Any?>())),
+      "ctrl" to (ctrl ?: linkedMapOf<String, Any?>()),
+    ))
+
+    // Errors are read BEFORE any status check: a GraphQL parse or validation
+    // failure comes back as HTTP 400 carrying the standard { errors: [...] }
+    // body, and the raw path represents a non-2xx as ok:false with no err —
+    // so returning early on status would discard the server's own
+    // diagnostics, which are the only useful part of that response.
+    val errors = Struct.getpath(res, listOf("data", "errors")) as? List<Any?>
+
+    if (null != errors && errors.isNotEmpty()) {
+      val m = Struct.getprop(errors[0], "message") as? String
+      val msg = if (m.isNullOrEmpty()) "graphql error" else m
+      res["ok"] = false
+      res["err"] = SdkError("graphql_error",
+        "ProjectNameSDK: graphql: " + msg, null)
+      res["graphql"] = errors
+    }
+
+    return res
+  }
+
+  // Ungated request path shared by direct and graphql, each of which checks
+  // its own allow.op token first. Private, rather than a flag on fetchargs: a
+  // caller-supplied marker would let anyone opt straight back out of the gate
+  // by passing it.
+  private fun rawRequest(
+    fetchargsIn: MutableMap<String, Any?>?,
+  ): MutableMap<String, Any?> {
     val utility = this.util
 
     val fetchargs = fetchargsIn ?: linkedMapOf()

package/project/.sdk/tm/kotlin/core/Utility.kt

@@ -37,6 +37,8 @@ class Utility private constructor(register: Boolean) {
   lateinit var prepareParams: (Context) -> MutableMap<String, Any?>
   lateinit var preparePath: (Context) -> String
   lateinit var prepareQuery: (Context) -> MutableMap<String, Any?>
+  lateinit var graphqlBody: (Context) -> Any?
+  lateinit var graphqlErrors: (Context) -> Boolean
   lateinit var resultBasic: (Context) -> Result
   lateinit var resultBody: (Context) -> Result
   lateinit var resultHeaders: (Context) -> Result

package/project/.sdk/tm/kotlin/feature/PagingFeature.kt

@@ -4,6 +4,7 @@ import java.util.regex.Pattern
 
 import KOTLINPACKAGE.core.Context
 import KOTLINPACKAGE.core.SdkClient
+import KOTLINPACKAGE.utility.struct.Struct
 
 // Pagination support for list operations. On the way out (PreRequest) it
 // stamps page/limit (or a cursor) into the request query; on the way back
@@ -40,6 +41,14 @@ class PagingFeature : BaseFeature("paging", "0.0.1", true) {
       paging = linkedMapOf()
     }
 
+    // GraphQL paginates through operation VARIABLES, not the query string.
+    // This hook runs after makeSpec, so spec.body already holds the
+    // { query, variables } envelope, and before makeFetchDef serialises it.
+    if ("graphql" == Struct.getprop(ctx.point, "kind") as? String) {
+      graphqlPreRequest(ctx, paging)
+      return
+    }
+
     val cursor = paging["cursor"]
     if (cursor != null) {
       spec.query[cursorParam] = cursor
@@ -57,6 +66,45 @@ class PagingFeature : BaseFeature("paging", "0.0.1", true) {
     }
   }
 
+  // Relay pagination: the cursor is the `after` variable (or whatever the
+  // model named it), and the page size is `first`.
+  private fun graphqlPreRequest(ctx: Context, paging: MutableMap<String, Any?>) {
+    val body = ctx.spec?.body as? MutableMap<String, Any?> ?: return
+
+    var variables = body["variables"] as? MutableMap<String, Any?>
+    if (variables == null) {
+      variables = linkedMapOf()
+      body["variables"] = variables
+    }
+
+    val afterVar = FeatureOptions.foptStr(this.options, "afterVar", "after")
+    val firstVar = FeatureOptions.foptStr(this.options, "firstVar", "first")
+
+    // Only bind variables the operation actually declares, or the server
+    // rejects the document.
+    val declared = mutableSetOf<String>()
+    val varlist = Struct.getpath(ctx.point, listOf("graphql", "vars")) as? List<Any?>
+    if (varlist != null) {
+      for (v in varlist) {
+        val name = Struct.getprop(v, "name") as? String
+        if (name != null) {
+          declared.add(name)
+        }
+      }
+    }
+
+    val cursor = paging["cursor"]
+    if (cursor != null && declared.contains(afterVar)) {
+      variables[afterVar] = cursor
+    }
+
+    if (this.options?.get("limit") != null && variables[firstVar] == null &&
+      declared.contains(firstVar)
+    ) {
+      variables[firstVar] = FeatureOptions.foptInt(this.options, "limit", 0)
+    }
+  }
+
   override fun preResult(ctx: Context) {
     if (!this.active || !isList(ctx)) {
       return
@@ -81,6 +129,43 @@ class PagingFeature : BaseFeature("paging", "0.0.1", true) {
       }
     }
 
+    // Set when the response states hasMore outright, rather than leaving it
+    // to be inferred from the presence of a cursor.
+    var explicitMore = false
+
+    // Relay connections carry the cursor in pageInfo, at the path the model
+    // recorded for this op.
+    val page = Struct.getpath(ctx.point, listOf("graphql", "page")) as? Map<*, *>
+    if (page != null && body is MutableMap<*, *>) {
+      // `connpath` locates the connection object inside the response
+      // envelope (data.<field>); the cursor/more paths are relative to it.
+      var conn: Any? = body
+      val connpath = page["connpath"] as? String
+      if (!connpath.isNullOrEmpty()) {
+        val sub = Struct.getpath(body, connpath)
+        if (sub != null) {
+          conn = sub
+        }
+      }
+
+      val cursorpath = page["cursor"] as? String
+      if (!cursorpath.isNullOrEmpty()) {
+        val c = Struct.getpath(conn, cursorpath)
+        if (c != null) {
+          paging["cursor"] = c
+        }
+      }
+
+      val morepath = page["more"] as? String
+      if (!morepath.isNullOrEmpty()) {
+        val more = Struct.getpath(conn, morepath)
+        if (more is Boolean) {
+          paging["hasMore"] = more
+          explicitMore = true
+        }
+      }
+    }
+
     // Body-level cursors.
     if (body is MutableMap<*, *>) {
       val bm = body as MutableMap<String, Any?>
@@ -95,10 +180,16 @@ class PagingFeature : BaseFeature("paging", "0.0.1", true) {
       }
       if (bm["hasMore"] is Boolean) {
         paging["hasMore"] = bm["hasMore"]
+        explicitMore = true
       }
     }
 
-    if (paging["hasMore"] != true &&
+    // Cursor presence only INFERS another page. When the server stated the
+    // answer outright — relay's `hasNextPage: false`, or a body `hasMore` —
+    // that wins: a final page normally carries both an end cursor and
+    // hasNextPage false, and inferring from the cursor there would send the
+    // caller back for a page that does not exist, forever.
+    if (!explicitMore && paging["hasMore"] != true &&
       (paging["next"] != null || paging["cursor"] != null || paging["nextPage"] != null)
     ) {
       paging["hasMore"] = true