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

package/src/AppSync/AppSync_Resolver_Functions.res.mjs

@@ -388,25 +388,66 @@ 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)`;
+}
+
+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');
+  }`;
+
+function connectionPageResponse(pathExpr) {
+  let tag = pathExpr !== undefined ? `, p: ` + pathExpr : "";
+  return `
+  const _first = ctx.args.first ?? 50;
+  const _rest = items.slice(_from);
+  const _page = _rest.slice(0, _first);
+  const _more = _rest.length > _first;
+  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,
+      hasNextPage: _more || !!_next,
       hasPreviousPage: !!ctx.args.after,
-      startCursor: edges.length > 0 ? edges[0].cursor : boundary,
-      endCursor: edges.length > 0 ? edges[edges.length - 1].cursor : boundary,
+      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) + `
 }`;
 
 let indexBackwardPagingGuard = `
@@ -414,12 +455,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 +495,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 +552,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 +576,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 +597,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 +657,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,6 +679,44 @@ 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: ` + (`(` + "parts.length > 0" + ` ? (_first > 1000 ? _first : 1000) : _first + _from)`) + `,
+        nextToken: _window,
+      }
+    : {
+        operation: 'Query',
+        index: '` + ownerIndex$1 + `',
+        query: {
+          expression: '#owner = :owner',
+          expressionNames: { '#owner': '` + ownerField + `' },
+          expressionValues: { ':owner': util.dynamodb.toDynamoDB(_sub) },
+        },
+        limit: ` + (`(` + "parts.length > 0" + ` ? (_first > 1000 ? _first : 1000) : _first + _from)`) + `,
+        nextToken: _window,
+        scanIndexForward: !(_indexOrdered && ctx.args.orderBy.direction === 'DESC'),
+      };` : `
+  const req = {
+    operation: 'Scan',
+    limit: ` + (`(` + "parts.length > 0" + ` ? (_first > 1000 ? _first : 1000) : _first + _from)`) + `,
+    nextToken: _window,
+  };`
+    ) : `
+  const req = {
+    operation: 'Scan',
+    limit: ` + (`(` + "parts.length > 0" + ` ? (_first > 1000 ? _first : 1000) : _first + _from)`) + `,
+    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") : connectionPageResponse(undefined);
   return importUtil + `
 export function request(ctx) {
   // Scan cannot page backward (ScanIndexForward is Query-only). Fail loud rather than
@@ -673,18 +748,8 @@ 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,
-  };
+` + cursorDecode("ctx.args") + requestPathGuard + `
+  const _first = ctx.args.first ?? 50;` + requestOperation + `
   if (parts.length > 0) {
     req.filter = {
       expression: parts.join(' AND '),
@@ -696,30 +761,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 + cursorDecode("ctx.args") + pageResponse + `
 }
 `;
 }
@@ -948,12 +990,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 +1288,10 @@ export {
   queryByIndex,
   queryByIndexDeletable,
   queryByIndexSort,
+  pageWindowBudget,
+  cursorDecode,
+  cursorPathGuard,
+  connectionPageResponse,
   indexConnectionResponseCode,
   indexBackwardPagingGuard,
   indexCursorPreamble,
@@ -1285,4 +1328,4 @@ export {
   resolveIdsResult,
   $$null,
 }
-/* No side effect */
+/* indexConnectionResponseCode Not a pure module */

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 */