@reventlessdev/rescript-pulumi-aws 2.4.0-alpha.58 → 2.4.0-alpha.60

package/CHANGELOG.md

@@ -3,6 +3,20 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 2.4.0-alpha.60 (2026-07-26)
+
+### Features
+
+* **example:** activate geocoder + upload services in platform-aws deploy ([e684d66](https://github.com/ReventlessDev/reventless-core/commit/e684d66bc4ce844ae36e8292ed0b78fd965490ff))
+
+
+# 2.4.0-alpha.59 (2026-07-23)
+
+### Bug Fixes
+
+* **aws:** round-trip the DynamoDB Scan cursor in full-list connections ([0e21008](https://github.com/ReventlessDev/reventless-core/commit/0e2100860767a153a5c2f50a88fd6b501787c7f4))
+
+
 # 2.4.0-alpha.58 (2026-07-22)
 
 ### Bug Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/rescript-pulumi-aws",
-  "version": "2.4.0-alpha.58",
+  "version": "2.4.0-alpha.60",
   "description": "ReScript bindings for @pulumi/aws",
   "license": "Apache-2.0",
   "jest": {

package/src/AppSync/AppSync_Resolver_Functions.res

@@ -506,6 +506,12 @@ let listAllItemsConnection = (
   }
   `${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');
+  }
   const filter = ctx.args.filter ?? {};
   const names = {};
   const values = {};
@@ -529,10 +535,17 @@ export function request(ctx) {
     });
     parts.push('#id IN (' + placeholders.join(', ') + ')');
   }${filterClauses}${rangeClauses}${requireAttributeClause}
+  // 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: (ctx.args.after ?? null),
+    nextToken: after,
   };
   if (parts.length > 0) {
     req.filter = {
@@ -546,17 +559,27 @@ 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: ctx.args.after ? ctx.args.after + '_' + i : '' + i,
+    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: !!ctx.result?.nextToken,
+      hasNextPage: !!next,
       hasPreviousPage: !!ctx.args.after,
-      startCursor: edges.length > 0 ? edges[0].cursor : null,
-      endCursor: edges.length > 0 ? edges[edges.length - 1].cursor : null,
+      startCursor: edges.length > 0 ? edges[0].cursor : boundary,
+      endCursor: edges.length > 0 ? edges[edges.length - 1].cursor : boundary,
     },
   };
 }

package/src/AppSync/AppSync_Resolver_Functions.res.mjs

@@ -408,6 +408,12 @@ function listAllItemsConnection(labelField, filterFieldsOpt, rangeFieldsOpt, sor
   }`;
   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');
+  }
   const filter = ctx.args.filter ?? {};
   const names = {};
   const values = {};
@@ -431,10 +437,17 @@ export function request(ctx) {
     });
     parts.push('#id IN (' + placeholders.join(', ') + ')');
   }` + filterClauses + rangeClauses + requireAttributeClause + `
+  // 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: (ctx.args.after ?? null),
+    nextToken: after,
   };
   if (parts.length > 0) {
     req.filter = {
@@ -448,17 +461,27 @@ 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: ctx.args.after ? ctx.args.after + '_' + i : '' + i,
+    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: !!ctx.result?.nextToken,
+      hasNextPage: !!next,
       hasPreviousPage: !!ctx.args.after,
-      startCursor: edges.length > 0 ? edges[0].cursor : null,
-      endCursor: edges.length > 0 ? edges[edges.length - 1].cursor : null,
+      startCursor: edges.length > 0 ? edges[0].cursor : boundary,
+      endCursor: edges.length > 0 ? edges[edges.length - 1].cursor : boundary,
     },
   };
 }

package/src/Location/Location.res

@@ -0,0 +1,4 @@
+/** @pulumi/aws/location
+  see: https://www.pulumi.com/registry/packages/aws/api-docs/location/
+*/
+module PlaceIndex = Location_PlaceIndex

package/src/Location/Location.res.mjs

@@ -0,0 +1,9 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+let PlaceIndex;
+
+export {
+  PlaceIndex,
+}
+/* No side effect */

package/src/Location/Location_PlaceIndex.res

@@ -0,0 +1,33 @@
+/** @pulumi/aws/location/PlaceIndex
+  see: https://www.pulumi.com/registry/packages/aws/api-docs/location/placeindex/
+*/
+type dataSourceConfiguration = {
+  // "SingleUse" | "Storage" — geocoding for immediate display uses SingleUse.
+  intendedUse?: Pulumi.Input.t<string>,
+}
+
+type args = {
+  indexName: Pulumi.Input.t<string>,
+  // Provider of geospatial data: "Esri" | "Grab" | "Here".
+  dataSource: Pulumi.Input.t<string>,
+  dataSourceConfiguration?: Pulumi.Input.t<dataSourceConfiguration>,
+  description?: Pulumi.Input.t<string>,
+  tags?: Pulumi.Input.t<Aws.tags>,
+}
+
+type t = {
+  indexName: Pulumi.Output.t<string>,
+  indexArn: Pulumi.Output.t<string>,
+  createTime: Pulumi.Output.t<string>,
+}
+
+@module("@pulumi/aws") @scope("location") @new
+external make: (~name: string, ~args: args, ~opts: Pulumi.CustomResourceOptions.t=?) => t =
+  "PlaceIndex"
+
+@module("@pulumi/aws") @scope(("location", "PlaceIndex"))
+external get: (
+  ~name: string,
+  ~id: Pulumi.Input.t<string>,
+  ~opts: Pulumi.CustomResourceOptions.t=?,
+) => t = "get"

package/src/Location/Location_PlaceIndex.res.mjs

@@ -0,0 +1,2 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */

package/tests/AppSync_Resolver_FunctionsTest.mjs

@@ -1,4 +1,5 @@
 import { evalResolver, makeCtx } from './resolverTestHelper.mjs'
+import { util } from './__mocks__/appsync-utils.mjs'
 import * as F from '../src/AppSync/AppSync_Resolver_Functions.res.mjs'
 
 // ---------------------------------------------------------------------------
@@ -182,7 +183,7 @@ describe('listAllItemsConnection', () => {
       expect(result.filter.expressionValues[':id0']).toEqual({ S: 'a' })
     })
 
-    test('response returns edges + pageInfo with positional cursors', () => {
+    test('response returns edges + pageInfo carrying the DynamoDB token cursor', () => {
       const ctx = makeCtx({
         args: {},
         result: { items: [{ id: 'a' }, { id: 'b' }], nextToken: 'next' },
@@ -192,6 +193,60 @@ describe('listAllItemsConnection', () => {
       expect(r.edges[0].node).toEqual({ id: 'a' })
       expect(r.pageInfo.hasNextPage).toBe(true)
       expect(r.pageInfo.hasPreviousPage).toBe(false)
+      // Fix 1: the cursor encodes the real nextToken, not a positional index.
+      expect(JSON.parse(util.base64Decode(r.pageInfo.endCursor)).token).toBe('next')
+    })
+
+    // Fix 1 (docs/plans/done/aws-scan-connection-cursor-roundtrip.md): the cursor the
+    // response emits must decode back to the exact DynamoDB nextToken the request feeds
+    // to the next Scan. This is the round-trip that failed before the fix.
+    test('endCursor round-trips: response endCursor → request nextToken', () => {
+      const page1 = response(makeCtx({
+        args: {},
+        result: { items: [{ id: 'a' }], nextToken: 'TOK1' },
+      }))
+      const req2 = request(makeCtx({ args: { after: page1.pageInfo.endCursor } }))
+      expect(req2.nextToken).toBe('TOK1')
+    })
+
+    test('final page (nextToken null) closes the connection', () => {
+      const r = response(makeCtx({
+        args: { after: 'x' },
+        result: { items: [{ id: 'z' }], nextToken: null },
+      }))
+      expect(r.pageInfo.hasNextPage).toBe(false)
+      expect(r.pageInfo.hasPreviousPage).toBe(true)
+    })
+
+    // Fix 3: a filtered Scan can return an empty page while nextToken is still set.
+    // The boundary cursor must let the client resume instead of restarting page 1.
+    test('empty-but-continuable page yields a resumable boundary cursor', () => {
+      const empty = response(makeCtx({
+        args: {},
+        result: { items: [], nextToken: 'TOK2' },
+      }))
+      expect(empty.edges).toHaveLength(0)
+      expect(empty.pageInfo.hasNextPage).toBe(true)
+      expect(empty.pageInfo.endCursor).not.toBeNull()
+      const req = request(makeCtx({ args: { after: empty.pageInfo.endCursor } }))
+      expect(req.nextToken).toBe('TOK2')
+    })
+
+    test('empty final page (nextToken null) has a null boundary and stops', () => {
+      const r = response(makeCtx({ args: {}, result: { items: [], nextToken: null } }))
+      expect(r.pageInfo.endCursor).toBeNull()
+      expect(r.pageInfo.hasNextPage).toBe(false)
+    })
+
+    // Fix 2: Scan cannot page backward; last/before must error, not mislead.
+    test('request rejects backward pagination (before)', () => {
+      expect(() => request(makeCtx({ args: { before: 'x' } }))).toThrow(
+        'Backward pagination',
+      )
+    })
+
+    test('request rejects backward pagination (last)', () => {
+      expect(() => request(makeCtx({ args: { last: 5 } }))).toThrow('Backward pagination')
     })
   })
 

package/tests/__mocks__/appsync-utils.mjs

@@ -12,6 +12,8 @@ export const util = {
     toStringSet: arr => ({ SS: arr }),
     toNumberSet: arr => ({ NS: arr.map(String) }),
   },
+  base64Encode: str => Buffer.from(String(str), 'utf8').toString('base64'),
+  base64Decode: b64 => Buffer.from(String(b64), 'base64').toString('utf8'),
   error: (msg, type) => { throw Object.assign(new Error(msg), { errorType: type }) },
   unauthorized: () => { throw new Error('Unauthorized') },
   defaultIfNull: (val, def) => (val === null || val === undefined ? def : val),