@reventlessdev/rescript-aws-sdk 3.0.0-alpha.4 → 3.0.0-alpha.5

package/CHANGELOG.md

@@ -3,6 +3,13 @@
 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.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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/rescript-aws-sdk",
-  "version": "3.0.0-alpha.4",
+  "version": "3.0.0-alpha.5",
   "description": "ReScript bindings for aws-sdk",
   "license": "Apache-2.0",
   "dependencies": {
@@ -9,6 +9,7 @@
     "@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",

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