@reventlessdev/rescript-pulumi-aws 3.0.0-alpha.0 → 3.0.0-alpha.10

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,35 +802,33 @@ 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 + `
 }
 `;
 }
 
-function resolveId(sourceIdField) {
+function resolvedFieldResponse(multi, ownerField, elevatedGroups, retiredField, retiredValues) {
+  if (ownerField === undefined && retiredField === undefined) {
+    if (multi) {
+      return resultListResponseCode;
+    } else {
+      return firstResultResponseCode;
+    }
+  }
+  let ownerPart = ownerField !== undefined ? `
+  // ── owner scoping (generated) ──` + ownerGuardPreamble(ownerField, elevatedGroups) : "\n  const _owns = (row) => true;";
+  let retiredPart = retiredGuardPreamble(retiredField, retiredValues, elevatedGroups, Stdlib_Option.isSome(ownerField));
+  let live = Stdlib_Option.isSome(retiredField) ? " && _live(_row)" : "";
+  let body = multi ? `  return (ctx.result.items ?? []).filter(_row => _owns(_row)` + live + `);` : `  const _row = ctx.result.items[0] ?? null;\n  return _owns(_row)` + live + ` ? _row : null;`;
+  return `
+export function response(ctx) {
+  if (ctx.error) util.error(ctx.error.message, ctx.error.type);` + ownerPart + retiredPart + `
+` + body + `
+}`;
+}
+
+function resolveId(sourceIdField, responseOpt) {
+  let response = responseOpt !== undefined ? responseOpt : firstResultResponseCode;
   return importUtil + `
 export function request(ctx) {
   if (!ctx.source.` + sourceIdField + `) return runtime.earlyReturn(null);
@@ -740,11 +844,12 @@ export function request(ctx) {
     scanIndexForward: (ctx.args.forward ?? true)
   };
 }
-` + firstResultResponseCode + `
+` + response + `
 `;
 }
 
-function resolveIdSort(sourceIdField, sourceSortField, targetSortField) {
+function resolveIdSort(sourceIdField, sourceSortField, targetSortField, responseOpt) {
+  let response = responseOpt !== undefined ? responseOpt : firstResultResponseCode;
   return importUtil + `
 export function request(ctx) {
   return {
@@ -762,11 +867,12 @@ export function request(ctx) {
     scanIndexForward: (ctx.args.forward ?? true)
   };
 }
-` + firstResultResponseCode + `
+` + response + `
 `;
 }
 
-function resolveIdSortArgument(sourceIdField, sourceSortArgument, targetSortField) {
+function resolveIdSortArgument(sourceIdField, sourceSortArgument, targetSortField, responseOpt) {
+  let response = responseOpt !== undefined ? responseOpt : firstResultResponseCode;
   return importUtil + `
 export function request(ctx) {
   const query = ctx.args.` + sourceSortArgument + `
@@ -791,11 +897,12 @@ export function request(ctx) {
     scanIndexForward: (ctx.args.forward ?? true)
   };
 }
-` + firstResultResponseCode + `
+` + response + `
 `;
 }
 
-function resolveIdByIndex(index, sourceIdField, targetIdField) {
+function resolveIdByIndex(index, sourceIdField, targetIdField, responseOpt) {
+  let response = responseOpt !== undefined ? responseOpt : firstResultResponseCode;
   return importUtil + `
 export function request(ctx) {
   return {
@@ -811,11 +918,12 @@ export function request(ctx) {
     scanIndexForward: (ctx.args.forward ?? true)
   };
 }
-` + firstResultResponseCode + `
+` + response + `
 `;
 }
 
-function resolveIdByIndexSort(index, sourceIdField, sourceSortField, targetIdField, targetSortField) {
+function resolveIdByIndexSort(index, sourceIdField, sourceSortField, targetIdField, targetSortField, responseOpt) {
+  let response = responseOpt !== undefined ? responseOpt : firstResultResponseCode;
   return importUtil + `
 export function request(ctx) {
   return {
@@ -834,11 +942,12 @@ export function request(ctx) {
     scanIndexForward: (ctx.args.forward ?? true)
   };
 }
-` + firstResultResponseCode + `
+` + response + `
 `;
 }
 
-function resolveIdByIndexSortArgument(index, sourceIdField, sourceSortArgument, targetIdField, targetSortField) {
+function resolveIdByIndexSortArgument(index, sourceIdField, sourceSortArgument, targetIdField, targetSortField, responseOpt) {
+  let response = responseOpt !== undefined ? responseOpt : firstResultResponseCode;
   return importUtil + `
 export function request(ctx) {
   const query = ctx.args.` + sourceSortArgument + `
@@ -864,34 +973,42 @@ export function request(ctx) {
     scanIndexForward: (ctx.args.forward ?? true)
   };
 }
-` + firstResultResponseCode + `
+` + response + `
 `;
 }
 
-function resolveIds(tableName, idsField, sortField) {
-  let keysCode = sortField !== undefined ? `id => ({ id: util.dynamodb.toString(id.id), ` + sortField + `: util.dynamodb.toString(id.` + sortField + `) })` : `id => ({ id: util.dynamodb.toString(id) })`;
-  return importUtil + `
+function resolveIds(idsField, sortField, ownerField, retiredField, retiredValues, $staropt$star) {
+  return tableName => {
+    let elevatedGroups = $staropt$star !== undefined ? $staropt$star : [];
+    let keysCode = sortField !== undefined ? `id => ({ id: util.dynamodb.toString(id.id), ` + sortField + `: util.dynamodb.toString(id.` + sortField + `) })` : `id => ({ id: util.dynamodb.toString(id) })`;
+    return importUtil + `
 import { runtime } from '@aws-appsync/utils';
 export function request(ctx) {
-  const idList = ctx.source.` + idsField + `;
-  if (idList && idList.length > 0) {
-    return {
-      operation: 'BatchGetItem',
-      tables: {
-        '` + tableName + `': {
-          keys: idList.map(` + keysCode + `),
-          consistentRead: true
-        }
+  const idList = ctx.source.` + idsField + ` ?? [];
+  if (idList.length === 0) return runtime.earlyReturn([]);
+  return {
+    operation: 'BatchGetItem',
+    tables: {
+      '` + tableName + `': {
+        keys: idList.map(` + keysCode + `),
+        consistentRead: true
       }
-    };
-  }
-  return { operation: 'GetItem', key: { id: util.dynamodb.toString(ctx.source.id) } };
+    }
+  };
 }
 export function response(ctx) {
-  if (ctx.error) util.error(ctx.error.message, ctx.error.type);
-  return ctx.result;
+  if (ctx.error) util.error(ctx.error.message, ctx.error.type);` + (
+      ownerField !== undefined ? ownerGuardPreamble(ownerField, elevatedGroups) : ""
+    ) + retiredGuardPreamble(retiredField, retiredValues, elevatedGroups, Stdlib_Option.isSome(ownerField)) + `
+  return (ctx.result?.data?.['` + tableName + `'] ?? []).filter(item =>
+    item !== null` + (
+      Stdlib_Option.isSome(ownerField) ? " && _owns(item)" : ""
+    ) + (
+      Stdlib_Option.isSome(retiredField) ? " && _live(item)" : ""
+    ) + `);
 }
 `;
+  };
 }
 
 function batchGetItemsByIds(ownerField, retiredField, retiredValues, $staropt$star) {
@@ -914,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
@@ -938,7 +1052,7 @@ export function response(ctx) {
   };
 }
 
-function refsByIds(labelField, retiredField, retiredValues, namedWhenRetired, ownerField, $staropt$star) {
+function refsByIds(labelField, retiredField, retiredValues, namedWhenRetired, imageExpr, ownerField, $staropt$star) {
   return tableName => {
     let elevatedGroups = $staropt$star !== undefined ? $staropt$star : [];
     let ownerGuard = ownerField !== undefined ? ownerGuardPreamble(ownerField, elevatedGroups) : "\n  const _owns = (row) => true;";
@@ -981,6 +1095,7 @@ export function response(ctx) {
     .map(row => ({
       id: row.id,
       label: row['` + labelField + `'] ?? row.id,
+      image: ` + Stdlib_Option.getOr(imageExpr, "null") + `,
       retired: _retired(row),
       retiredState: ` + stateExpr + `,
     }));
@@ -1215,6 +1330,12 @@ export {
   queryByIndex,
   queryByIndexDeletable,
   queryByIndexSort,
+  pageWindowBudget,
+  listPageWindowBudget,
+  cursorDecode,
+  cursorPathGuard,
+  listCursorPreamble,
+  connectionPageResponse,
   indexConnectionResponseCode,
   indexBackwardPagingGuard,
   indexCursorPreamble,
@@ -1223,6 +1344,7 @@ export {
   queryByIndexSortFiltered,
   listAllItems,
   listAllItemsConnection,
+  resolvedFieldResponse,
   resolveId,
   resolveIdSort,
   resolveIdSortArgument,
@@ -1250,4 +1372,4 @@ export {
   resolveIdsResult,
   $$null,
 }
-/* No side effect */
+/* indexConnectionResponseCode Not a pure module */

package/src/Cloudwatch/Cloudwatch_EventRule.res

@@ -44,6 +44,10 @@ module ScheduleExpression: {
 type args = {
   description?: Pulumi.Input.t<string>,
   scheduleExpression?: ScheduleExpression.t,
+  /** JSON event pattern the rule matches on. A rule fires on a schedule or on a
+    pattern — set exactly one of the two.
+    see: https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-event-patterns.html */
+  eventPattern?: Pulumi.Input.t<string>,
   roleArn?: Pulumi.Input.t<string>,
   tags?: Pulumi.Input.t<Aws.tags>,
 }

package/src/Cloudwatch/Cloudwatch_EventTarget.res

@@ -17,10 +17,21 @@ module Rule: {
   let ofEventRule = (rule: Cloudwatch_EventRule.t) => rule.name->Pulumi.Output.asInput
 }
 
+/** Rewrites a matched event before it reaches the target. `inputPaths` binds names to
+  JSON paths in the event; `inputTemplate` substitutes them where it writes `<name>`.
+  A template that is not JSON arrives as plain text — an SNS email body, say.
+  see: https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-transform-target-input.html */
+type inputTransformer = {
+  inputPaths?: dict<string>,
+  inputTemplate: Pulumi.Input.t<string>,
+}
+
 type args = {
   rule: Rule.t,
   arn: Pulumi.Input.t<string>,
+  /** A fixed payload, sent verbatim. Mutually exclusive with `inputTransformer`. */
   input?: Pulumi.Input.t<string>,
+  inputTransformer?: Pulumi.Input.t<inputTransformer>,
 }
 
 @module("@pulumi/aws") @scope("cloudwatch") @new

package/src/DynamoDb/DynamoDb_Table.res

@@ -9,7 +9,9 @@ type t = {
   name: Pulumi.Output.t<string>,
   id: Pulumi.Output.t<string>,
   hashKey: Pulumi.Output.t<string>,
-  rangeKey: Pulumi.Output.t<option<string>>,
+  // Pulumi resolves an absent range key to `null`, which ReScript's `option`
+  // (None = undefined) does not accept. Nullable is the shape that arrives.
+  rangeKey: Pulumi.Output.t<Nullable.t<string>>,
   streamEnabled: Pulumi.Output.t<option<bool>>,
   streamArn: Pulumi.Output.t<string>,
   streamLabel: Pulumi.Output.t<string>,
@@ -64,3 +66,26 @@ type args = {
 @module("@pulumi/aws") @scope("dynamodb") @new
 external make: (~name: string, ~args: args, ~opts: Pulumi.CustomResourceOptions.t=?) => table =
   "Table"
+
+/** Look up a table this stack does not own.
+
+  In a submodule because the lookup result's fields are a subset of [t]'s: at
+  file level the later record would win inference for `{id, name, arn}` and
+  silently retype every such destructuring of a real table.
+
+  The lookup fails the deploy when the table does not exist, which is the point —
+  a name that resolves to nothing would otherwise reach a Lambda's environment
+  and surface at sign-in. */
+module Get = {
+  type args = {name: string}
+
+  type result = {
+    arn: string,
+    id: string,
+    name: string,
+  }
+
+  @module("@pulumi/aws") @scope("dynamodb") @val
+  external output: (~args: args, ~opts: Pulumi.InvokeOptions.t=?) => Pulumi.Output.t<result> =
+    "getTableOutput"
+}

package/src/DynamoDb/DynamoDb_Table.res.mjs

@@ -1,2 +1,9 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
-/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */
+
+
+let Get = {};
+
+export {
+  Get,
+}
+/* No side effect */

package/src/example/AlarmMailExample.res

@@ -0,0 +1,34 @@
+// Compile-only smoke for the EventBridge bindings: a rule that matches CloudWatch
+// alarm state changes by pattern, and an SNS target that rewrites the matched event
+// into a plain-text body rather than forwarding the raw JSON. Not executed at deploy
+// time — it keeps `eventPattern` and `inputTransformer` type-checked together.
+
+let alarmMailTopic = SNS.Topic.make(~name="example-alarm-mail")
+
+let alarmStateChanges = Cloudwatch.EventRule.make(
+  ~name="example-alarm-state-changes",
+  ~args={
+    description: "CloudWatch alarm state changes, ALARM and OK only"->Pulumi.Input.make,
+    eventPattern: `{"source":["aws.cloudwatch"],"detail-type":["CloudWatch Alarm State Change"],"detail":{"state":{"value":["ALARM","OK"]}}}`->Pulumi.Input.make,
+  },
+)
+
+// A template that is not JSON has to arrive quoted — the surrounding double quotes are
+// part of the value, not ReScript syntax.
+let mailBody: Cloudwatch.EventTarget.inputTransformer = {
+  inputPaths: Dict.fromArray([
+    ("name", "$.detail.alarmName"),
+    ("state", "$.detail.state.value"),
+    ("reason", "$.detail.state.reason"),
+  ]),
+  inputTemplate: `"<state>: <name> — <reason>"`->Pulumi.Input.make,
+}
+
+let _ = Cloudwatch.EventTarget.make(
+  ~name="example-alarm-mail-target",
+  ~args={
+    rule: Cloudwatch.EventTarget.Rule.ofEventRule(alarmStateChanges),
+    arn: alarmMailTopic.arn->Pulumi.Output.asInput,
+    inputTransformer: mailBody->Pulumi.Input.make,
+  },
+)