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

package/CHANGELOG.md

@@ -3,6 +3,81 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 3.0.0-alpha.10 (2026-08-14)
+
+**Note:** Version bump only for package @reventlessdev/rescript-aws-sdk
+
+
+
+
+
+# 3.0.0-alpha.9 (2026-08-13)
+
+### Features
+
+* **aws:** narrow the token to the role a caller chose to act as ([194332f](https://github.com/ReventlessDev/reventless-core/commit/194332fa0af8e13417f72d57904e2ed469747dde))
+
+
+# 3.0.0-alpha.8 (2026-08-13)
+
+**Note:** Version bump only for package @reventlessdev/rescript-aws-sdk
+
+
+
+
+
+# 3.0.0-alpha.7 (2026-08-11)
+
+**Note:** Version bump only for package @reventlessdev/rescript-aws-sdk
+
+
+
+
+
+# 3.0.0-alpha.6 (2026-08-09)
+
+**Note:** Version bump only for package @reventlessdev/rescript-aws-sdk
+
+
+
+
+
+# 3.0.0-alpha.5 (2026-08-09)
+
+### Bug Fixes
+
+* **seed-aws:** hold and recycle a stack's runtimes so a reset stays empty ([4baaa38](https://github.com/ReventlessDev/reventless-core/commit/4baaa3827ef30a0adccdef5d2bccc688e7b6686f))
+
+
+# 3.0.0-alpha.4 (2026-08-05)
+
+**Note:** Version bump only for package @reventlessdev/rescript-aws-sdk
+
+
+
+
+
+# 3.0.0-alpha.3 (2026-08-03)
+
+### Features
+
+* **outbound:** let an outbound slice read an aggregate, and geocode addresses with it ([867e63e](https://github.com/ReventlessDev/reventless-core/commit/867e63e774ebc8b78b2b19c78645c8a12a8d06f6))
+
+
+# 3.0.0-alpha.2 (2026-08-02)
+
+### Features
+
+* **aws:** S3 GetObject->string binding + structure offload resolver ([1274bcc](https://github.com/ReventlessDev/reventless-core/commit/1274bcce29f8a1b70db362a10585c508710e7b56))
+
+
+# 3.0.0-alpha.1 (2026-08-02)
+
+### Features
+
+* **aws,core,spec,seed-aws:** expire uploads nobody committed a reference to ([f63e84c](https://github.com/ReventlessDev/reventless-core/commit/f63e84c1a11cc350b799a6f69a2e7427cf1ea6e9))
+
+
 # 3.0.0-alpha.0 (2026-07-31)
 
 * feat(rescript)!: one Node bindings package, not two ([1258d8c](https://github.com/ReventlessDev/reventless-core/commit/1258d8c2b2ff2636b36a849fc5bdf9005c6fb0eb))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/rescript-aws-sdk",
-  "version": "3.0.0-alpha.0",
+  "version": "3.0.0-alpha.10",
   "description": "ReScript bindings for aws-sdk",
   "license": "Apache-2.0",
   "dependencies": {
@@ -9,6 +9,8 @@
     "@aws-sdk/client-dynamodb": "^3.1033.0",
     "@aws-sdk/client-ecs": "^3.1033.0",
     "@aws-sdk/client-kinesis": "^3.1033.0",
+    "@aws-sdk/client-lambda": "^3.1033.0",
+    "@aws-sdk/client-location": "^3.970.0",
     "@aws-sdk/client-resource-groups-tagging-api": "^3.1033.0",
     "@aws-sdk/client-s3": "^3.1033.0",
     "@aws-sdk/client-secrets-manager": "^3.1033.0",
@@ -18,7 +20,7 @@
     "@aws-sdk/lib-dynamodb": "^3.1033.0",
     "@aws-sdk/lib-storage": "^3.1033.0",
     "@smithy/node-http-handler": "^4.5.3",
-    "@reventlessdev/rescript-node": "2.0.0-alpha.0"
+    "@reventlessdev/rescript-node": "2.0.0-alpha.6"
   },
   "devDependencies": {
     "rescript": "12.3.0"

package/src/CognitoIdentityServiceProvider.res

@@ -115,3 +115,39 @@ module AdminRemoveUserFromGroupCommand = {
 
   let send: t => promise<unit> = command => Raw.send(client(), command)
 }
+
+module AdminListGroupsForUserCommand = {
+  type t
+
+  /** `Username` takes the username, any alias attribute, or — for a local user —
+    their `sub`, which is the one identifier a verified token always carries.
+    A value the pool cannot resolve raises `UserNotFoundException` rather than
+    returning an empty group list, so a caller is never mistaken for one holding
+    no groups. */
+  type input = {
+    @as("Username") username: string,
+    @as("UserPoolId") userPoolId: string,
+    @as("Limit") limit?: int,
+    @as("NextToken") nextToken?: string,
+  }
+
+  type group = {@as("GroupName") groupName?: string}
+
+  type output = {
+    @as("Groups") groups?: array<group>,
+    @as("NextToken") nextToken?: string,
+  }
+
+  @new @module("@aws-sdk/client-cognito-identity-provider")
+  external make: input => t = "AdminListGroupsForUserCommand"
+
+  module Raw = {
+    /**
+      see: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/cognito-identity-provider/command/AdminListGroupsForUserCommand/
+    */
+    @send
+    external send: (client, t) => promise<output> = "send"
+  }
+
+  let send: t => promise<output> = command => Raw.send(client(), command)
+}

package/src/CognitoIdentityServiceProvider.res.mjs

@@ -59,6 +59,17 @@ let AdminRemoveUserFromGroupCommand = {
   send: send$2
 };
 
+let Raw$4 = {};
+
+function send$3(command) {
+  return client().send(command);
+}
+
+let AdminListGroupsForUserCommand = {
+  Raw: Raw$4,
+  send: send$3
+};
+
 export {
   Raw,
   clientInstance,
@@ -66,5 +77,6 @@ export {
   SignUpCommand,
   AdminAddUserToGroupCommand,
   AdminRemoveUserFromGroupCommand,
+  AdminListGroupsForUserCommand,
 }
 /* @smithy/node-http-handler Not a pure module */

package/src/Lambda.res

@@ -0,0 +1,150 @@
+/*** @aws-sdk/client-lambda
+  see: https://docs.aws.amazon.com/lambda/latest/api/Welcome.html
+
+  Control-plane bindings only — enough to take a function out of service and put
+  it back. The seed reset uses them to quiesce a stack's runtimes for the length
+  of a wipe: a live runtime that holds state across invocations will write that
+  state back over a truncated table, so the wipe has to remove the contention
+  rather than race it.
+
+  Two distinct powers, deliberately kept apart:
+
+  - `PutFunctionConcurrency`/`DeleteFunctionConcurrency` stop *new* invocations.
+    Reserving 0 does not consume account concurrency, and it does not terminate
+    an execution environment that already exists — it only stops it being
+    invoked again.
+  - `UpdateFunctionConfiguration` is what actually discards existing execution
+    environments: after a configuration change, later invocations run in new
+    ones. That is the documented way to drop whatever a warm container was
+    holding; a concurrency change is not.
+
+  Like `ResourceGroupsTaggingApi` and unlike the memoised clients here, the
+  caller passes a client so the region is explicit.
+*/
+type client
+
+module Raw = {
+  type options = {region?: string}
+  @module("@aws-sdk/client-lambda") @new
+  external client: (~options: options=?, unit) => client = "LambdaClient"
+}
+
+let client = (~region: option<string>=?, ()): client => Raw.client(~options={region: ?region}, ())
+
+/** A function's environment variables, in the shape both the get and the update
+    use. `variables` absent and `variables` empty are different: sending an empty
+    map on an update CLEARS every variable. */
+type environment = {@as("Variables") variables?: dict<string>}
+
+module GetFunctionConfigurationCommand = {
+  /*** see: https://docs.aws.amazon.com/lambda/latest/api/API_GetFunctionConfiguration.html */
+
+  type t
+
+  type input = {@as("FunctionName") functionName: string}
+
+  type output = {
+    @as("$metadata") metadata: Metadata.t,
+    @as("FunctionName") functionName?: string,
+    @as("Environment") environment?: environment,
+    /** "Successful" | "Failed" | "InProgress" — absent on a function that has
+        never been updated. A second update while this reads "InProgress" is
+        rejected with ResourceConflictException, so callers poll it. */
+    @as("LastUpdateStatus")
+    lastUpdateStatus?: string,
+    @as("LastUpdateStatusReason") lastUpdateStatusReason?: string,
+    @as("State") state?: string,
+  }
+
+  @new @module("@aws-sdk/client-lambda")
+  external make: input => t = "GetFunctionConfigurationCommand"
+
+  @send external send: (client, t) => promise<output> = "send"
+}
+
+module UpdateFunctionConfigurationCommand = {
+  /*** see: https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionConfiguration.html
+
+    Only the fields a caller sends are changed. Sending `environment` replaces
+    the whole variable map, so an update that means to add one variable must
+    send the existing ones alongside it. */
+
+  type t
+
+  type input = {
+    @as("FunctionName") functionName: string,
+    @as("Environment") environment?: environment,
+  }
+
+  type output = {
+    @as("$metadata") metadata: Metadata.t,
+    @as("FunctionName") functionName?: string,
+    @as("LastUpdateStatus") lastUpdateStatus?: string,
+  }
+
+  @new @module("@aws-sdk/client-lambda")
+  external make: input => t = "UpdateFunctionConfigurationCommand"
+
+  @send external send: (client, t) => promise<output> = "send"
+}
+
+module GetFunctionConcurrencyCommand = {
+  /*** see: https://docs.aws.amazon.com/lambda/latest/api/API_GetFunctionConcurrency.html
+
+    `reservedConcurrentExecutions` is absent when the function has no reservation
+    at all — which is a different state from a reservation of 0, and the one a
+    restore has to be able to put back. */
+
+  type t
+
+  type input = {@as("FunctionName") functionName: string}
+
+  type output = {
+    @as("$metadata") metadata: Metadata.t,
+    @as("ReservedConcurrentExecutions") reservedConcurrentExecutions?: int,
+  }
+
+  @new @module("@aws-sdk/client-lambda")
+  external make: input => t = "GetFunctionConcurrencyCommand"
+
+  @send external send: (client, t) => promise<output> = "send"
+}
+
+module PutFunctionConcurrencyCommand = {
+  /*** see: https://docs.aws.amazon.com/lambda/latest/api/API_PutFunctionConcurrency.html */
+
+  type t
+
+  type input = {
+    @as("FunctionName") functionName: string,
+    @as("ReservedConcurrentExecutions") reservedConcurrentExecutions: int,
+  }
+
+  type output = {
+    @as("$metadata") metadata: Metadata.t,
+    @as("ReservedConcurrentExecutions") reservedConcurrentExecutions?: int,
+  }
+
+  @new @module("@aws-sdk/client-lambda")
+  external make: input => t = "PutFunctionConcurrencyCommand"
+
+  @send external send: (client, t) => promise<output> = "send"
+}
+
+module DeleteFunctionConcurrencyCommand = {
+  /*** see: https://docs.aws.amazon.com/lambda/latest/api/API_DeleteFunctionConcurrency.html
+
+    Removes the reservation entirely, returning the function to the account's
+    unreserved pool — the restore for a function that had no reservation before. */
+
+  type t
+
+  type input = {@as("FunctionName") functionName: string}
+
+  type output = {@as("$metadata") metadata: Metadata.t}
+
+  @new @module("@aws-sdk/client-lambda")
+  external make: input => t = "DeleteFunctionConcurrencyCommand"
+
+  @send external send: (client, t) => promise<output> = "send"
+}

package/src/Lambda.res.mjs

@@ -0,0 +1,32 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as ClientLambda from "@aws-sdk/client-lambda";
+
+let Raw = {};
+
+function client(region, param) {
+  return new ClientLambda.LambdaClient({
+    region: region
+  });
+}
+
+let GetFunctionConfigurationCommand = {};
+
+let UpdateFunctionConfigurationCommand = {};
+
+let GetFunctionConcurrencyCommand = {};
+
+let PutFunctionConcurrencyCommand = {};
+
+let DeleteFunctionConcurrencyCommand = {};
+
+export {
+  Raw,
+  client,
+  GetFunctionConfigurationCommand,
+  UpdateFunctionConfigurationCommand,
+  GetFunctionConcurrencyCommand,
+  PutFunctionConcurrencyCommand,
+  DeleteFunctionConcurrencyCommand,
+}
+/* @aws-sdk/client-lambda Not a pure module */

package/src/Location.res

@@ -0,0 +1,80 @@
+// Bindings for Amazon Location Service (`@aws-sdk/client-location`).
+//
+// Both callers of this service want different things from the same call, which
+// is why the bindings live here rather than inside either of them: the browser's
+// geocoder Function URL wants a best-effort list to show a human, and an
+// unattended translator wants to know *how sure* the service is before it writes
+// a coordinate into an event log.
+
+type client
+
+module Raw = {
+  @module("@aws-sdk/client-location") @new
+  external client: unit => client = "LocationClient"
+}
+
+let clientInstance = ref(None)
+
+let client = () => {
+  switch clientInstance.contents {
+  | None =>
+    let c = Raw.client()
+    clientInstance := Some(c)
+    c
+  | Some(c) => c
+  }
+}
+
+module SearchPlaceIndexForTextCommand = {
+  /*** see: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/location/command/SearchPlaceIndexForTextCommand/ */
+
+  type t
+
+  /** GeoJSON order — `[lng, lat]`, longitude first. Read it through
+      `Geometry.point` rather than indexing it at a call site; the order is the
+      single most reliable source of wrong-hemisphere markers in this domain. */
+  type point = array<float>
+
+  type geometry = {@as("Point") point?: point}
+
+  type place = {
+    @as("Label") label?: string,
+    @as("Geometry") geometry?: geometry,
+    @as("Country") country?: string,
+    @as("PostalCode") postalCode?: string,
+    @as("Municipality") municipality?: string,
+  }
+
+  type result = {
+    @as("Place") place?: place,
+    /** How well this result matches the query, 0…1 — present on results from
+        Esri and HERE index configurations and absent on some others, which is
+        why it is optional rather than defaulted. A caller that treats an absent
+        relevance as a perfect match is asserting something the service did not
+        say. */
+    @as("Relevance") relevance?: float,
+  }
+
+  type input = {
+    @as("IndexName") indexName: string,
+    @as("Text") text: string,
+    @as("MaxResults") maxResults?: int,
+    @as("Language") language?: string,
+    @as("FilterCountries") filterCountries?: array<string>,
+  }
+
+  type output = {
+    @as("$metadata") metadata: Metadata.t,
+    @as("Results") results?: array<result>,
+  }
+
+  @new @module("@aws-sdk/client-location")
+  external make: input => t = "SearchPlaceIndexForTextCommand"
+
+  module Raw = {
+    @send
+    external send: (client, t) => promise<output> = "send"
+  }
+
+  let send: t => promise<output> = input => Raw.send(client(), input)
+}

package/src/Location.res.mjs

@@ -0,0 +1,39 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as ClientLocation from "@aws-sdk/client-location";
+
+let Raw = {};
+
+let clientInstance = {
+  contents: undefined
+};
+
+function client() {
+  let c = clientInstance.contents;
+  if (c !== undefined) {
+    return Primitive_option.valFromOption(c);
+  }
+  let c$1 = new ClientLocation.LocationClient();
+  clientInstance.contents = Primitive_option.some(c$1);
+  return c$1;
+}
+
+let Raw$1 = {};
+
+function send(input) {
+  return client().send(input);
+}
+
+let SearchPlaceIndexForTextCommand = {
+  Raw: Raw$1,
+  send: send
+};
+
+export {
+  Raw,
+  clientInstance,
+  client,
+  SearchPlaceIndexForTextCommand,
+}
+/* @aws-sdk/client-location Not a pure module */

package/src/S3.res

@@ -46,6 +46,16 @@ module GetObjectCommand = {
   }
 
   let send: t => promise<output> = input => Raw.send(client(), input)
+
+  // AWS SDK v3 returns the object body as an SdkStream that adds
+  // `transformToString()` (UTF-8 by default) on top of the Node Readable the
+  // output type reflects. Bind the method here rather than inline at the call site.
+  @send
+  external transformToString: NodeStreams.Readable.t => promise<string> = "transformToString"
+
+  /** Fetch an object and return its body as a UTF-8 string. */
+  let getString: (~bucket: string, ~key: string) => promise<string> = (~bucket, ~key) =>
+    make({bucket, key})->send->Promise.then(output => output.body->transformToString)
 }
 
 module ListObjectVersionsCommand = {
@@ -95,6 +105,65 @@ module ListObjectVersionsCommand = {
   let send: t => promise<output> = input => Raw.send(client(), input)
 }
 
+/** An object tag. Shared by the get/put tagging commands, which exchange the
+  same `TagSet` — reading, filtering and writing back is the only way to remove
+  one tag without discarding the rest. */
+type tag = {
+  @as("Key") key: string,
+  @as("Value") value: string,
+}
+
+module GetObjectTaggingCommand = {
+  type t
+
+  type input = {
+    @as("Bucket") bucket: string,
+    @as("Key") key: string,
+  }
+
+  /** An object with no tags returns an empty `TagSet`, not an absent one — but
+    the field is optional here anyway, since a caller that treats "absent" and
+    "empty" differently would be reading a distinction S3 does not make. */
+  type output = {@as("TagSet") tagSet?: array<tag>}
+
+  @new @module("@aws-sdk/client-s3")
+  external make: input => t = "GetObjectTaggingCommand"
+
+  module Raw = {
+    @send
+    external send: (client, t) => promise<output> = "send"
+  }
+
+  let send: t => promise<output> = input => Raw.send(client(), input)
+}
+
+module PutObjectTaggingCommand = {
+  type t
+
+  /** Replaces the object's whole tag set — there is no partial update, so
+    removing one tag means putting back the others. An empty `tagSet` clears
+    every tag and is a valid, idempotent call on an already-untagged object. */
+  type tagging = {@as("TagSet") tagSet: array<tag>}
+
+  type input = {
+    @as("Bucket") bucket: string,
+    @as("Key") key: string,
+    @as("Tagging") tagging: tagging,
+  }
+
+  type output = {@as("VersionId") versionId?: string}
+
+  @new @module("@aws-sdk/client-s3")
+  external make: input => t = "PutObjectTaggingCommand"
+
+  module Raw = {
+    @send
+    external send: (client, t) => promise<output> = "send"
+  }
+
+  let send: t => promise<output> = input => Raw.send(client(), input)
+}
+
 module DeleteObjectsCommand = {
   /*** delete up to 1000 objects (each by key, optionally a specific version) in
     one call. Used by the seed reset to empty a bucket page by page.

package/src/S3.res.mjs

@@ -25,9 +25,18 @@ function send(input) {
   return client().send(input);
 }
 
+function getString(bucket, key) {
+  let input = new ClientS3.GetObjectCommand({
+    Bucket: bucket,
+    Key: key
+  });
+  return client().send(input).then(output => output.Body.transformToString());
+}
+
 let GetObjectCommand = {
   Raw: Raw$1,
-  send: send
+  send: send,
+  getString: getString
 };
 
 let Raw$2 = {};
@@ -47,7 +56,7 @@ function send$2(input) {
   return client().send(input);
 }
 
-let DeleteObjectsCommand = {
+let GetObjectTaggingCommand = {
   Raw: Raw$3,
   send: send$2
 };
@@ -58,17 +67,39 @@ function send$3(input) {
   return client().send(input);
 }
 
-let PutObjectCommand = {
+let PutObjectTaggingCommand = {
   Raw: Raw$4,
   send: send$3
 };
 
+let Raw$5 = {};
+
+function send$4(input) {
+  return client().send(input);
+}
+
+let DeleteObjectsCommand = {
+  Raw: Raw$5,
+  send: send$4
+};
+
+let Raw$6 = {};
+
+function send$5(input) {
+  return client().send(input);
+}
+
+let PutObjectCommand = {
+  Raw: Raw$6,
+  send: send$5
+};
+
 let CompleteMultipartUploadCommand = {};
 
-let Raw$5 = {};
+let Raw$7 = {};
 
 let Upload = {
-  Raw: Raw$5
+  Raw: Raw$7
 };
 
 export {
@@ -77,6 +108,8 @@ export {
   client,
   GetObjectCommand,
   ListObjectVersionsCommand,
+  GetObjectTaggingCommand,
+  PutObjectTaggingCommand,
   DeleteObjectsCommand,
   PutObjectCommand,
   CompleteMultipartUploadCommand,