@reventlessdev/rescript-pulumi-aws 3.0.0-alpha.3 → 3.0.0-alpha.5

package/src/AppSync/AppSync_Resolver_Functions.res.mjs

@@ -388,25 +388,99 @@ export function request(ctx) {
 `;
 }
 
-let indexConnectionResponseCode = `
-export function response(ctx) {
-  if (ctx.error) util.error(ctx.error.message, ctx.error.type);
-  const items = ctx.result?.items ?? [];
-  const next = ctx.result?.nextToken ?? null;
-  const edges = items.map((item, i) => ({
+function pageWindowBudget(filtered) {
+  return `(` + filtered + ` ? (_first > 1000 ? _first : 1000) : _first + _from)`;
+}
+
+let need = "(_backward ? _upTo : _first + _from)";
+
+let listPageWindowBudget = `(parts.length > 0 ? (` + need + ` > 1000 ? ` + need + ` : 1000) : ` + need + `)`;
+
+function cursorDecode(args) {
+  return `
+  let _window = null;
+  let _from = 0;
+  let _cursorPath = null;
+  if (` + args + `.after != null && ` + args + `.after !== '') {
+    const _c = JSON.parse(util.base64Decode(` + args + `.after));
+    _window = (_c.t !== undefined ? _c.t : _c.token) ?? null;
+    _from = _c.n !== undefined ? _c.n + 1 : 0;
+    _cursorPath = _c.p ?? 's';
+  }`;
+}
+
+let cursorPathGuard = `
+  if (_cursorPath !== null && _cursorPath !== (_exempt ? 's' : 'q')) {
+    util.error('This cursor belongs to a different read of this list; restart from the first page.', 'CursorPathMismatch');
+  }`;
+
+let listCursorPreamble = `
+  const _first = ctx.args.first ?? 50;
+  let _window = null;
+  let _from = 0;
+  let _cursorPath = null;
+  let _backward = false;
+  let _upTo = -1;
+  if (ctx.args.before != null && ctx.args.before !== '') {
+    const _c = JSON.parse(util.base64Decode(ctx.args.before));
+    _window = (_c.t !== undefined ? _c.t : _c.token) ?? null;
+    _cursorPath = _c.p ?? 's';
+    _backward = true;
+    _upTo = _c.n !== undefined ? _c.n : 0;
+    _from = (_upTo - _first) > 0 ? (_upTo - _first) : 0;
+  } else if (ctx.args.after != null && ctx.args.after !== '') {
+    const _c = JSON.parse(util.base64Decode(ctx.args.after));
+    _window = (_c.t !== undefined ? _c.t : _c.token) ?? null;
+    _from = _c.n !== undefined ? _c.n + 1 : 0;
+    _cursorPath = _c.p ?? 's';
+  }`;
+
+function connectionPageResponse(pathExpr, bidirectionalOpt) {
+  let bidirectional = bidirectionalOpt !== undefined ? bidirectionalOpt : false;
+  let tag = pathExpr !== undefined ? `, p: ` + pathExpr : "";
+  let firstDecl = bidirectional ? "" : "\n  const _first = ctx.args.first ?? 50;";
+  let slice = bidirectional ? `
+  const _rest = _backward ? items.slice(_from, _upTo) : items.slice(_from);
+  const _page = _backward ? _rest : _rest.slice(0, _first);
+  // A backward page was cut from ahead, so a next page provably exists — the one
+  // the caller came from — whatever this window's tail looks like.
+  const _more = _backward ? true : _rest.length > _first;` : `
+  const _rest = items.slice(_from);
+  const _page = _rest.slice(0, _first);
+  const _more = _rest.length > _first;`;
+  let hasPrevious = bidirectional ? "_from > 0" : "!!ctx.args.after";
+  return firstDecl + slice + `
+  const _next = ctx.result?.nextToken ?? null;
+  const _lastIndex = _page.length - 1;
+  // A row's cursor names its own position. The last row of a page that closes its
+  // window is the exception — no position follows it there, so it names the next
+  // window, or resuming from it answers blank.
+  const edges = _page.map((item, i) => ({
     node: item,
-    cursor: util.base64Encode(JSON.stringify({ token: next, index: i })),
+    cursor: util.base64Encode(JSON.stringify(
+      (!_more && _next && i === _lastIndex)
+        ? { t: _next, n: -1` + tag + ` }
+        : { t: _window, n: _from + i` + tag + ` }
+    )),
   }));
-  const boundary = next ? util.base64Encode(JSON.stringify({ token: next, index: -1 })) : null;
+  // A window the filter emptied leaves no row to cut a cursor from; the token is
+  // the window's, so a client can step past it rather than restart.
+  const _boundary = _next ? util.base64Encode(JSON.stringify({ t: _next, n: -1` + tag + ` })) : null;
   return {
     edges,
     pageInfo: {
-      hasNextPage: !!next,
-      hasPreviousPage: !!ctx.args.after,
-      startCursor: edges.length > 0 ? edges[0].cursor : boundary,
-      endCursor: edges.length > 0 ? edges[edges.length - 1].cursor : boundary,
+      hasNextPage: _more || !!_next,
+      hasPreviousPage: ` + hasPrevious + `,
+      startCursor: edges.length > 0 ? edges[0].cursor : _boundary,
+      endCursor: edges.length > 0 ? edges[edges.length - 1].cursor : _boundary,
     },
-  };
+  };`;
+}
+
+let indexConnectionResponseCode = `
+export function response(ctx) {
+  if (ctx.error) util.error(ctx.error.message, ctx.error.type);
+  const items = ctx.result?.items ?? [];` + cursorDecode("ctx.args") + connectionPageResponse(undefined, undefined) + `
 }`;
 
 let indexBackwardPagingGuard = `
@@ -414,12 +488,8 @@ let indexBackwardPagingGuard = `
     util.error('Backward pagination (last/before) is not supported on by-index connections; use first/after.', 'UnsupportedPagination');
   }`;
 
-let indexCursorPreamble = `
-  let after = null;
-  if (args.after != null && args.after !== '') {
-    const parsed = JSON.parse(util.base64Decode(args.after));
-    after = parsed.token ?? null;
-  }`;
+let indexCursorPreamble = cursorDecode("args") + `
+  const _first = args.first ?? 50;`;
 
 let indexReservedArgs = `key === 'first' || key === 'after' || key === 'last' || key === 'before' || key === 'includeRetired' || key === 'limit' || key === 'nextToken' || key === 'forward'`;
 
@@ -458,8 +528,8 @@ export function request(ctx) {
     operation: 'Query',
     query,
     index: '` + index + `',
-    limit: (args.first ?? 50),
-    nextToken: after,
+    limit: ` + (`(` + "expression" + ` ? (_first > 1000 ? _first : 1000) : _first + _from)`) + `,
+    nextToken: _window,
     scanIndexForward: (args.forward ?? true)
   };
   if (expression) {
@@ -515,8 +585,8 @@ export function request(ctx) {
     operation: 'Query',
     query,
     index: '` + index + `',
-    limit: (args.first ?? 50),
-    nextToken: after,
+    limit: ` + (`(` + "expression" + ` ? (_first > 1000 ? _first : 1000) : _first + _from)`) + `,
+    nextToken: _window,
     scanIndexForward: (args.forward ?? true)
   };
   if (expression) {
@@ -539,18 +609,17 @@ export function request(ctx) {
 ` + resultResponseCode + `
 `;
 
-function listAllItemsConnection(labelField, filterFieldsOpt, rangeFieldsOpt, sortFieldsOpt, requireAttribute, ownerField, elevatedGroupsOpt, retiredField, retiredValues) {
+function listAllItemsConnection(labelField, filterFieldsOpt, rangeFieldsOpt, sortFieldsOpt, requireAttribute, ownerField, elevatedGroupsOpt, retiredField, retiredValues, ownerIndex, ownerIndexSortField) {
   let filterFields = filterFieldsOpt !== undefined ? filterFieldsOpt : [];
   let rangeFields = rangeFieldsOpt !== undefined ? rangeFieldsOpt : [];
   let sortFields = sortFieldsOpt !== undefined ? sortFieldsOpt : [];
   let elevatedGroups = elevatedGroupsOpt !== undefined ? elevatedGroupsOpt : [];
+  let ownerIndex$1 = Stdlib_Option.isSome(ownerField) ? ownerIndex : undefined;
   let requireAttributeClause = requireAttribute !== undefined ? `
   names['#` + requireAttribute + `'] = '` + requireAttribute + `';
   parts.push('attribute_exists(#` + requireAttribute + `)');` : "";
-  let ownerClause;
-  if (ownerField !== undefined) {
-    let elevatedLiteral = elevatedGroups.map(g => `'` + g + `'`).join(", ");
-    ownerClause = `
+  let elevatedLiteral = elevatedGroups.map(g => `'` + g + `'`).join(", ");
+  let ownerIdentityPreamble = `
   // ── owner scoping (generated) ──
   // Not read from ctx.args: a predicate deciding what the caller may see must
   // arrive on a channel the caller cannot name, and this field is usually absent
@@ -561,15 +630,15 @@ function listAllItemsConnection(labelField, filterFieldsOpt, rangeFieldsOpt, sor
   const _elevated = [` + elevatedLiteral + `];
   // No identity at all, or an identity with no \`sub\`, is the IAM service caller
   // the API also accepts — inside the trust boundary, and exempt.
-  const _exempt = _sub == null || _groups.some(g => _elevated.indexOf(g) >= 0);
+  const _exempt = _sub == null || _groups.some(g => _elevated.indexOf(g) >= 0);`;
+  let ownerClause = ownerField !== undefined ? (
+      ownerIndex$1 !== undefined ? ownerIdentityPreamble : ownerIdentityPreamble + `
   if (!_exempt) {
     names['#owner'] = '` + ownerField + `';
     values[':owner'] = util.dynamodb.toDynamoDB(_sub);
     parts.push('#owner = :owner');
-  }`;
-  } else {
-    ownerClause = "";
-  }
+  }`
+    ) : "";
   let retiredClause;
   if (retiredField !== undefined) {
     let elevatedLiteral$1 = elevatedGroups.map(g => `'` + g + `'`).join(", ");
@@ -621,13 +690,14 @@ function listAllItemsConnection(labelField, filterFieldsOpt, rangeFieldsOpt, sor
     parts.push('#` + f + ` <= :` + f + `To');
   }`).join("");
   let sortFieldsLiteral = sortFields.map(f => `'` + f + `'`).join(", ");
+  let sortGuard = ownerIndex$1 !== undefined && ownerIndexSortField !== undefined ? "!_indexOrdered && " : "";
   let sortBlock = sortFields.length === 0 ? "" : `
   // Per-page sort (Scan returns items in indeterminate order; ScanIndexForward
   // does not apply to Scan). Global ordering across pages requires v1.5 index
   // promotion; @scanSort is per-page even then.
   const orderBy = ctx.args.orderBy;
   const sortFields = [` + sortFieldsLiteral + `];
-  if (orderBy && orderBy.field && sortFields.indexOf(orderBy.field) >= 0) {
+  if (` + sortGuard + `orderBy && orderBy.field && sortFields.indexOf(orderBy.field) >= 0) {
     const field = orderBy.field;
     const nulls = items.filter(it => it[field] === null || it[field] === undefined);
     const nonNulls = items.filter(it => it[field] !== null && it[field] !== undefined);
@@ -642,13 +712,53 @@ function listAllItemsConnection(labelField, filterFieldsOpt, rangeFieldsOpt, sor
     if (orderBy.direction === 'DESC') encoded.reverse();
     items = encoded.map(e => JSON.parse(e.split('\\x01')[1])).concat(nulls);
   }`;
+  let indexOrderedExpr = ownerIndex$1 !== undefined && ownerIndexSortField !== undefined ? `!_exempt && !!(ctx.args.orderBy && ctx.args.orderBy.field === '` + ownerIndexSortField + `')` : "false";
+  let requestOperation = ownerField !== undefined ? (
+      ownerIndex$1 !== undefined ? `
+  const _indexOrdered = ` + indexOrderedExpr + `;
+  const req = _exempt
+    ? {
+        operation: 'Scan',
+        limit: ` + listPageWindowBudget + `,
+        nextToken: _window,
+      }
+    : {
+        operation: 'Query',
+        index: '` + ownerIndex$1 + `',
+        query: {
+          expression: '#owner = :owner',
+          expressionNames: { '#owner': '` + ownerField + `' },
+          expressionValues: { ':owner': util.dynamodb.toDynamoDB(_sub) },
+        },
+        limit: ` + listPageWindowBudget + `,
+        nextToken: _window,
+        scanIndexForward: !(_indexOrdered && ctx.args.orderBy.direction === 'DESC'),
+      };` : `
+  const req = {
+    operation: 'Scan',
+    limit: ` + listPageWindowBudget + `,
+    nextToken: _window,
+  };`
+    ) : `
+  const req = {
+    operation: 'Scan',
+    limit: ` + listPageWindowBudget + `,
+    nextToken: _window,
+  };`;
+  let requestPathGuard = Stdlib_Option.isSome(ownerIndex$1) ? cursorPathGuard : "";
+  let responsePathPreamble = ownerIndex$1 !== undefined ? ownerIdentityPreamble + `
+  const _path = _exempt ? 's' : 'q';
+  const _indexOrdered = ` + indexOrderedExpr + `;` : "";
+  let pageResponse = ownerIndex$1 !== undefined ? connectionPageResponse("_path", true) : connectionPageResponse(undefined, true);
   return importUtil + `
 export function request(ctx) {
-  // Scan cannot page backward (ScanIndexForward is Query-only). Fail loud rather than
-  // silently returning the forward page. The ordered {single}Items connection
-  // (queryItemsWithSortConditions) supports last/before — direct backward callers there.
-  if (ctx.args.before != null || ctx.args.last != null) {
-    util.error('Backward pagination (last/before) is not supported on full-list connections; use first/after.', 'UnsupportedPagination');
+  // 'before' IS served — the page is cut backward out of the window the cursor
+  // names. 'last' is not: "the last N rows of the list" needs the end of the
+  // list, which a forward-only Scan cursor cannot reach. The ordered
+  // {single}Items connection (queryItemsWithSortConditions) has a real keyset
+  // cursor and honours both — direct callers who need 'last' there.
+  if (ctx.args.last != null) {
+    util.error('last is not supported on full-list connections; page backward with first and before.', 'UnsupportedPagination');
   }
   const filter = ctx.args.filter ?? {};
   const names = {};
@@ -673,18 +783,14 @@ export function request(ctx) {
     });
     parts.push('#id IN (' + placeholders.join(', ') + ')');
   }` + filterClauses + rangeClauses + requireAttributeClause + ownerClause + retiredClause + `
-  // The cursor is base64(JSON({ token, index })); decode the after arg back to the raw
-  // DynamoDB continuation token the response side emitted (Fix 1 round-trip).
-  let after = null;
-  if (ctx.args.after != null && ctx.args.after !== '') {
-    const parsed = JSON.parse(util.base64Decode(ctx.args.after));
-    after = parsed.token ?? null;
-  }
-  const req = {
-    operation: 'Scan',
-    limit: (ctx.args.first ?? 50),
-    nextToken: after,
-  };
+` + listCursorPreamble + requestPathGuard + `
+  // The one page a cursor cannot reach: it begins in an earlier window, and a
+  // continuation token cannot name the one before it. Refused by itself rather
+  // than folded into the 'last' guard, because the two are different limits and a
+  // caller can act on this one (page forward from the start).
+  if (_backward && _upTo <= 0 && _window !== null) {
+    util.error('The previous page begins in an earlier read window, which this cursor cannot name; page forward from the start.', 'UnsupportedPagination');
+  }` + requestOperation + `
   if (parts.length > 0) {
     req.filter = {
       expression: parts.join(' AND '),
@@ -696,30 +802,7 @@ export function request(ctx) {
 }
 export function response(ctx) {
   if (ctx.error) util.error(ctx.error.message, ctx.error.type);
-  let items = ctx.result?.items ?? [];` + sortBlock + `
-  // One Scan continuation token per page; encode it (with the item's page index for a
-  // unique, opaque Relay cursor). The request side decodes .token back to the raw
-  // DynamoDB nextToken (Fix 1).
-  const next = ctx.result?.nextToken ?? null;
-  const edges = items.map((item, i) => ({
-    node: item,
-    cursor: util.base64Encode(JSON.stringify({ token: next, index: i })),
-  }));
-  // A filtered/1MB-capped page can be empty or short while next is still set (limit
-  // caps rows scanned, not returned). The token is page-level, so synthesise a
-  // boundary cursor from it alone so a client can resume past a fully-filtered-out
-  // page instead of restarting from page 1 (Fix 3). The request only reads .token,
-  // so index -1 is inert on resume.
-  const boundary = next ? util.base64Encode(JSON.stringify({ token: next, index: -1 })) : null;
-  return {
-    edges,
-    pageInfo: {
-      hasNextPage: !!next,
-      hasPreviousPage: !!ctx.args.after,
-      startCursor: edges.length > 0 ? edges[0].cursor : boundary,
-      endCursor: edges.length > 0 ? edges[edges.length - 1].cursor : boundary,
-    },
-  };
+  let items = ctx.result?.items ?? [];` + responsePathPreamble + sortBlock + listCursorPreamble + pageResponse + `
 }
 `;
 }
@@ -948,12 +1031,9 @@ export function request(ctx) {
 }
 export function response(ctx) {
   if (ctx.error) util.error(ctx.error.message, ctx.error.type);
-  // BatchGetItem returns null in the result array for keys that don't exist
-  // in the table, preserving index correspondence with the input. The SDL
-  // returns this field as \`[T!]!\` (non-null element list), so any single
-  // missing id makes the entire field fail with "Cannot return null for
-  // non-nullable type" and the caller sees data=null. Filter the nulls so
-  // the field returns just the items that were found.
+  // BatchGetItem returns null for keys that don't exist, preserving index
+  // correspondence. The SDL declares \`[T!]!\`, so one missing id would null the
+  // whole field — drop them and return what was found.
   // The owner and retirement guards the list pushes into a FilterExpression,
   // applied after the read because BatchGetItem has none to push into. A row the
   // caller does not own is dropped rather than refused, for the reason the
@@ -1249,6 +1329,12 @@ export {
   queryByIndex,
   queryByIndexDeletable,
   queryByIndexSort,
+  pageWindowBudget,
+  listPageWindowBudget,
+  cursorDecode,
+  cursorPathGuard,
+  listCursorPreamble,
+  connectionPageResponse,
   indexConnectionResponseCode,
   indexBackwardPagingGuard,
   indexCursorPreamble,
@@ -1285,4 +1371,4 @@ export {
   resolveIdsResult,
   $$null,
 }
-/* No side effect */
+/* indexConnectionResponseCode Not a pure module */