@reventlessdev/rescript-pulumi-aws 3.0.0-alpha.2 → 3.0.0-alpha.20

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 + `
 }
 `;
 }
@@ -894,9 +977,9 @@ export function request(ctx) {
 `;
 }
 
-function resolveIds(idsField, sortField, ownerField, retiredField, retiredValues, $staropt$star) {
+function resolveIds(idsField, sortField, ownerField, retiredField, retiredValues, elevatedGroupsOpt) {
+  let elevatedGroups = elevatedGroupsOpt !== undefined ? elevatedGroupsOpt : [];
   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';
@@ -928,10 +1011,9 @@ export function response(ctx) {
   };
 }
 
-function batchGetItemsByIds(ownerField, retiredField, retiredValues, $staropt$star) {
-  return tableName => {
-    let elevatedGroups = $staropt$star !== undefined ? $staropt$star : [];
-    return importUtil + `
+function batchGetItemsByIds(ownerField, retiredField, retiredValues, elevatedGroupsOpt) {
+  let elevatedGroups = elevatedGroupsOpt !== undefined ? elevatedGroupsOpt : [];
+  return tableName => importUtil + `
 import { runtime } from '@aws-appsync/utils';
 export function request(ctx) {
   const ids = ctx.args.ids ?? [];
@@ -948,33 +1030,29 @@ 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
   // single-key door answers null: distinguishing "not yours" from "not there"
   // would make this door an oracle for which ids exist.` + (
-      ownerField !== undefined ? ownerGuardPreamble(ownerField, elevatedGroups) : ""
-    ) + retiredGuardPreamble(retiredField, retiredValues, elevatedGroups, Stdlib_Option.isSome(ownerField)) + `
+    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)" : ""
-    ) + `);
+    Stdlib_Option.isSome(ownerField) ? " && _owns(item)" : ""
+  ) + (
+    Stdlib_Option.isSome(retiredField) ? " && _live(item)" : ""
+  ) + `);
 }
 `;
-  };
 }
 
-function refsByIds(labelField, retiredField, retiredValues, namedWhenRetired, ownerField, $staropt$star) {
+function refsByIds(labelField, retiredField, retiredValues, namedWhenRetired, imageExpr, ownerField, elevatedGroupsOpt) {
+  let elevatedGroups = elevatedGroupsOpt !== undefined ? elevatedGroupsOpt : [];
   return tableName => {
-    let elevatedGroups = $staropt$star !== undefined ? $staropt$star : [];
     let ownerGuard = ownerField !== undefined ? ownerGuardPreamble(ownerField, elevatedGroups) : "\n  const _owns = (row) => true;";
     let retiredExpr;
     if (retiredField !== undefined) {
@@ -1015,6 +1093,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 + `,
     }));
@@ -1249,6 +1328,12 @@ export {
   queryByIndex,
   queryByIndexDeletable,
   queryByIndexSort,
+  pageWindowBudget,
+  listPageWindowBudget,
+  cursorDecode,
+  cursorPathGuard,
+  listCursorPreamble,
+  connectionPageResponse,
   indexConnectionResponseCode,
   indexBackwardPagingGuard,
   indexCursorPreamble,
@@ -1285,4 +1370,4 @@ export {
   resolveIdsResult,
   $$null,
 }
-/* No side effect */
+/* indexConnectionResponseCode Not a pure module */

package/src/AppSync/AppSync_SourceApiAssociation.res

@@ -28,9 +28,7 @@ type args = {
   mergedApiArn?: Pulumi.Input.t<string>,
   sourceApiId?: Pulumi.Input.t<string>,
   sourceApiArn?: Pulumi.Input.t<string>,
-  sourceApiAssociationConfigs?: Pulumi.Input.t<
-    array<Pulumi.Input.t<sourceApiAssociationConfig>>,
-  >,
+  sourceApiAssociationConfigs?: Pulumi.Input.t<array<Pulumi.Input.t<sourceApiAssociationConfig>>>,
   description?: Pulumi.Input.t<string>,
 }
 

package/src/AwsNative/AppSync/AwsNative_AppSync_Api.res

@@ -1,11 +1,10 @@
+// ── Auth types ────────────────────────────────────────────────────────────────
+
 /** @pulumi/aws-native/appsync/Api — AppSync Events (Pub/Sub) API.
     Distinct from AppSync GraphQL API (`aws.appsync.GraphQLApi`).
     Used for real-time server-to-client event push via AppSync Events channels.
     See: https://www.pulumi.com/registry/packages/aws-native/api-docs/appsync/api
 */
-
-// ── Auth types ────────────────────────────────────────────────────────────────
-
 /** Authentication mode for connections / publish / subscribe. */
 type authMode = {
   /** Auth type string — use the `authType` constants below. */

package/src/AwsNative/AppSync/AwsNative_AppSync_ChannelNamespace.res

@@ -4,7 +4,6 @@
     Channels within the namespace are addressed as `/default/{channelName}`.
     See: https://www.pulumi.com/registry/packages/aws-native/api-docs/appsync/channelnamespace
 */
-
 type authMode = {
   authType?: Pulumi.Input.t<string>,
 }
@@ -74,8 +73,5 @@ type args = {
 }
 
 @module("@pulumi/aws-native") @scope("appsync") @new
-external make: (
-  ~name: string,
-  ~args: args,
-  ~opts: option<Pulumi.CustomResourceOptions.t>=?,
-) => t = "ChannelNamespace"
+external make: (~name: string, ~args: args, ~opts: option<Pulumi.CustomResourceOptions.t>=?) => t =
+  "ChannelNamespace"

package/src/AwsNative/AppSync/AwsNative_AppSync_Resolver.res

@@ -32,8 +32,5 @@ type args = {
 }
 
 @module("@pulumi/aws-native") @scope("appsync") @new
-external make: (
-  ~name: string,
-  ~args: args,
-  ~opts: option<Pulumi.CustomResourceOptions.t>=?,
-) => t = "Resolver"
+external make: (~name: string, ~args: args, ~opts: option<Pulumi.CustomResourceOptions.t>=?) => t =
+  "Resolver"

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/Cloudwatch/Cloudwatch_LogMetricFilter.res

@@ -1,7 +1,6 @@
 /** @pulumi/aws/cloudwatch/logmetricfilter
   see: https://www.pulumi.com/registry/packages/aws/api-docs/cloudwatch/logmetricfilter/
 */
-
 /** How matched log events are turned into a CloudWatch metric data point.
   `value`/`dimensions` use metric-filter JSON selectors (e.g. `"$.value"`). */
 type metricTransformation = {

package/src/Cloudwatch/Cloudwatch_MetricAlarm.res

@@ -1,7 +1,6 @@
 /** @pulumi/aws/cloudwatch/metricalarm
   see: https://www.pulumi.com/registry/packages/aws/api-docs/cloudwatch/metricalarm/
 */
-
 type t = {arn: Pulumi.Output.t<string>, id: Pulumi.Output.t<string>}
 
 /** Single-metric alarm args. `comparisonOperator` uses CloudWatch's operator

package/src/Cognito/Cognito_UserPool.res

@@ -119,7 +119,5 @@ type getResult = {
 }
 
 @module("@pulumi/aws") @scope("cognito") @val
-external getUserPoolOutput: (
-  ~args: getArgs,
-  ~opts: InvokeOptions.t=?,
-) => Output.t<getResult> = "getUserPoolOutput"
+external getUserPoolOutput: (~args: getArgs, ~opts: InvokeOptions.t=?) => Output.t<getResult> =
+  "getUserPoolOutput"

package/src/DynamoDb/DynamoDb_Table.res

@@ -66,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/IAM/IAM.res

@@ -103,7 +103,7 @@ module Role = {
         assumeRolePolicy: servicePrincipal
         ->Pulumi.Output.apply(principal => Policy.assumeRolePolicy(name, principal))
         ->Pulumi.Output.asInput,
-        tags: ?tags,
+        ?tags,
       },
       ~opts,
     )

package/src/IAM/PolicyDocument.res

@@ -124,12 +124,12 @@ type t = policy
 
 let toJsonString: t => string = t => {
   t
-  ->S.decodeOrThrow(~from=policySchema, ~to=S.json)
+  ->S.convertOrThrow(~from=policySchema, ~to=S.json)
   ->JSON.stringify(~space=1)
 }
 
 let fromJsonString: string => t = (policyString: string) =>
-  policyString->S.decodeOrThrow(~from=S.jsonString, ~to=policySchema)
+  S.JsonString(policyString)->S.convertOrThrow(~from=S.jsonString, ~to=policySchema)
 
 let make = (~version=Version2012, ~id=?, ~statements) => {
   version,

package/src/IAM/PolicyDocument.res.mjs

@@ -48,7 +48,7 @@ let conditionEntrySchema = Sury.union([
   Sury.$schema(s => (s.m(Sury.array(Sury.string))))
 ]);
 
-let conditionMapSchema = Sury.dict(conditionEntrySchema);
+let conditionMapSchema = Sury.record(conditionEntrySchema);
 
 let conditionSchema = Sury.$schema(s => ({
   StringEquals: s.m(Sury.$option(conditionMapSchema)),
@@ -121,11 +121,11 @@ let policySchema = Sury.$schema(s => ({
 }));
 
 function toJsonString(t) {
-  return JSON.stringify(S.decodeOrThrow(t, policySchema, Sury.json), undefined, 1);
+  return JSON.stringify(S.convertOrThrow(t, policySchema, undefined, Sury.json), undefined, 1);
 }
 
 function fromJsonString(policyString) {
-  return S.decodeOrThrow(policyString, Sury.jsonString, policySchema);
+  return S.convertOrThrow(policyString, Sury.jsonString, undefined, policySchema);
 }
 
 function make(versionOpt, id, statements) {

package/src/Kinesis/Kinesis_Stream.res

@@ -54,11 +54,8 @@ module EventSubscription = {
 }
 
 @module("@pulumi/aws") @scope("kinesis") @new
-external make: (
-  ~name: string,
-  ~args: args=?,
-  ~opts: Pulumi.CustomResourceOptions.t=?
-) => stream = "Stream"
+external make: (~name: string, ~args: args=?, ~opts: Pulumi.CustomResourceOptions.t=?) => stream =
+  "Stream"
 
 @send
 external onEvent: (
@@ -66,5 +63,5 @@ external onEvent: (
   ~name: string,
   ~handler: Lambda.eventHandlerNoResult<event>,
   ~args: subscriptionArgs=?,
-  ~opts: Pulumi.CustomResourceOptions.t=?
+  ~opts: Pulumi.CustomResourceOptions.t=?,
 ) => EventSubscription.t = "onEvent"