@reventlessdev/rescript-aws-sdk 3.0.0-alpha.12 → 3.0.0-alpha.14

package/CHANGELOG.md

@@ -3,6 +3,27 @@
 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.14 (2026-08-27)
+
+### Bug Fixes
+
+* **seed-aws:** a throttled control plane aborts the reset hold and blames IAM ([95af263](https://github.com/ReventlessDev/reventless-core/commit/95af263afba7dfdfa9a7fc45f494b302dba4baf8))
+
+
+# 3.0.0-alpha.13 (2026-08-23)
+
+* feat(aws)!: scope the active-role store to the identity provider ([08e287d](https://github.com/ReventlessDev/reventless-core/commit/08e287db9721977b818bad76671ec4c62be6f9af))
+
+### BREAKING CHANGES
+
+* platform:cognitoUserPoolId is now
+platform:identityProviderId (REVENTLESS_IDENTITY_PROVIDER_ID). The old
+spelling is still read and warns — do not drop it until the new secret
+is in place, because an unset provider id is auto mode, and auto mode
+creates a new user pool.
+
+
+
 # 3.0.0-alpha.12 (2026-08-18)
 
 **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.12",
+  "version": "3.0.0-alpha.14",
   "description": "ReScript bindings for aws-sdk",
   "license": "Apache-2.0",
   "dependencies": {

package/src/CognitoIdentityServiceProvider.res

@@ -151,3 +151,115 @@ module AdminListGroupsForUserCommand = {
 
   let send: t => promise<output> = command => Raw.send(client(), command)
 }
+
+module CreateUserPoolCommand = {
+  type t
+
+  type passwordPolicy = {
+    @as("MinimumLength") minimumLength?: int,
+    @as("RequireLowercase") requireLowercase?: bool,
+    @as("RequireUppercase") requireUppercase?: bool,
+    @as("RequireNumbers") requireNumbers?: bool,
+    @as("RequireSymbols") requireSymbols?: bool,
+  }
+
+  type policies = {@as("PasswordPolicy") passwordPolicy?: passwordPolicy}
+
+  type adminCreateUserConfig = {
+    @as("AllowAdminCreateUserOnly") allowAdminCreateUserOnly?: bool,
+  }
+
+  /** Only the members a Reventless pool is provisioned with. The API accepts far
+    more; an operator wanting the rest edits the pool afterwards rather than
+    having every setting grow a parameter here. */
+  type input = {
+    @as("PoolName") poolName: string,
+    @as("UsernameAttributes") usernameAttributes?: array<string>,
+    @as("MfaConfiguration") mfaConfiguration?: string,
+    @as("Policies") policies?: policies,
+    @as("AdminCreateUserConfig") adminCreateUserConfig?: adminCreateUserConfig,
+    @as("UserPoolTags") userPoolTags?: Dict.t<string>,
+  }
+
+  type userPoolType = {
+    @as("Id") id?: string,
+    @as("Name") name?: string,
+    @as("Arn") arn?: string,
+  }
+
+  type output = {@as("UserPool") userPool?: userPoolType}
+
+  @new @module("@aws-sdk/client-cognito-identity-provider")
+  external make: input => t = "CreateUserPoolCommand"
+
+  module Raw = {
+    /**
+      see: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/cognito-identity-provider/command/CreateUserPoolCommand/
+    */
+    @send
+    external send: (client, t) => promise<output> = "send"
+  }
+
+  let send: t => promise<output> = command => Raw.send(client(), command)
+}
+
+module ListUserPoolsCommand = {
+  type t
+
+  /** `MaxResults` caps at 60, so a caller looking for a pool by name has to page.
+    Cognito offers no lookup by name and does not enforce name uniqueness. */
+  type input = {
+    @as("MaxResults") maxResults: int,
+    @as("NextToken") nextToken?: string,
+  }
+
+  type userPoolDescription = {
+    @as("Id") id?: string,
+    @as("Name") name?: string,
+  }
+
+  type output = {
+    @as("UserPools") userPools?: array<userPoolDescription>,
+    @as("NextToken") nextToken?: string,
+  }
+
+  @new @module("@aws-sdk/client-cognito-identity-provider")
+  external make: input => t = "ListUserPoolsCommand"
+
+  module Raw = {
+    /**
+      see: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/cognito-identity-provider/command/ListUserPoolsCommand/
+    */
+    @send
+    external send: (client, t) => promise<output> = "send"
+  }
+
+  let send: t => promise<output> = command => Raw.send(client(), command)
+}
+
+module DescribeUserPoolCommand = {
+  type t
+
+  type input = {@as("UserPoolId") userPoolId: string}
+
+  type userPoolType = {
+    @as("Id") id?: string,
+    @as("Name") name?: string,
+    @as("Arn") arn?: string,
+  }
+
+  type output = {@as("UserPool") userPool?: userPoolType}
+
+  @new @module("@aws-sdk/client-cognito-identity-provider")
+  external make: input => t = "DescribeUserPoolCommand"
+
+  module Raw = {
+    /**
+      see: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/cognito-identity-provider/command/DescribeUserPoolCommand/
+    */
+    @send
+    external send: (client, t) => promise<output> = "send"
+  }
+
+  let send: t => promise<output> = command => Raw.send(client(), command)
+}

package/src/CognitoIdentityServiceProvider.res.mjs

@@ -70,6 +70,39 @@ let AdminListGroupsForUserCommand = {
   send: send$3
 };
 
+let Raw$5 = {};
+
+function send$4(command) {
+  return client().send(command);
+}
+
+let CreateUserPoolCommand = {
+  Raw: Raw$5,
+  send: send$4
+};
+
+let Raw$6 = {};
+
+function send$5(command) {
+  return client().send(command);
+}
+
+let ListUserPoolsCommand = {
+  Raw: Raw$6,
+  send: send$5
+};
+
+let Raw$7 = {};
+
+function send$6(command) {
+  return client().send(command);
+}
+
+let DescribeUserPoolCommand = {
+  Raw: Raw$7,
+  send: send$6
+};
+
 export {
   Raw,
   clientInstance,
@@ -78,5 +111,8 @@ export {
   AdminAddUserToGroupCommand,
   AdminRemoveUserFromGroupCommand,
   AdminListGroupsForUserCommand,
+  CreateUserPoolCommand,
+  ListUserPoolsCommand,
+  DescribeUserPoolCommand,
 }
 /* @smithy/node-http-handler Not a pure module */

package/src/DynamoDb_DynamoDb.res

@@ -231,3 +231,70 @@ module UpdateContinuousBackupsCommand = {
 
   let send: t => promise<output> = command => Raw.send(client(), command)
 }
+
+module CreateTableCommand = {
+  /*** create a table
+
+  this command is not available in document-client
+
+  see: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/dynamodb/command/CreateTableCommand/ */
+
+  type t
+
+  type attributeDefinition = {
+    @as("AttributeName") attributeName: string,
+    /** "S" | "N" | "B" */
+    @as("AttributeType")
+    attributeType: string,
+  }
+
+  type input = {
+    @as("TableName") tableName: string,
+    @as("KeySchema") keySchema: array<DescribeTableCommand.keySchemaElement>,
+    @as("AttributeDefinitions") attributeDefinitions: array<attributeDefinition>,
+    /** "PROVISIONED" | "PAY_PER_REQUEST" */
+    @as("BillingMode")
+    billingMode?: string,
+    @as("Tags") tags?: array<Dict.t<string>>,
+  }
+
+  type output = {@as("$metadata") metadata: Metadata.t}
+
+  @new @module("@aws-sdk/client-dynamodb")
+  external make: input => t = "CreateTableCommand"
+
+  module Raw = {
+    @send
+    external send: (client, t) => promise<output> = "send"
+  }
+
+  let send: t => promise<output> = command => Raw.send(client(), command)
+}
+
+module TableExistsWaiter = {
+  /*** block until a table reports ACTIVE.
+
+  🚨 **Does not reject on failure.** The SDK's waiters resolve with a `state` of
+  `"SUCCESS"`, `"FAILURE"`, `"TIMEOUT"` or `"RETRY"` — so a caller that only
+  awaits this treats a timeout as success. Check [result.state].
+
+  see: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/dynamodb/#waiters */
+
+  type config = {
+    client: client,
+    /** seconds */
+    maxWaitTime: int,
+  }
+
+  type params = {@as("TableName") tableName: string}
+
+  type result = {state: string}
+
+  @module("@aws-sdk/client-dynamodb")
+  external waitUntilTableExists: (config, params) => promise<result> = "waitUntilTableExists"
+
+  let succeeded = (result: result): bool => result.state == "SUCCESS"
+
+  let wait = (~tableName: string, ~maxWaitTime: int=300): promise<result> =>
+    waitUntilTableExists({client: client(), maxWaitTime}, {tableName: tableName})
+}

package/src/DynamoDb_DynamoDb.res.mjs

@@ -70,6 +70,36 @@ let UpdateContinuousBackupsCommand = {
   send: send$3
 };
 
+let Raw$5 = {};
+
+function send$4(command) {
+  return client().send(command);
+}
+
+let CreateTableCommand = {
+  Raw: Raw$5,
+  send: send$4
+};
+
+function succeeded(result) {
+  return result.state === "SUCCESS";
+}
+
+function wait(tableName, maxWaitTimeOpt) {
+  let maxWaitTime = maxWaitTimeOpt !== undefined ? maxWaitTimeOpt : 300;
+  return ClientDynamodb.waitUntilTableExists({
+    client: client(),
+    maxWaitTime: maxWaitTime
+  }, {
+    TableName: tableName
+  });
+}
+
+let TableExistsWaiter = {
+  succeeded: succeeded,
+  wait: wait
+};
+
 export {
   Raw,
   clientInstance,
@@ -78,5 +108,7 @@ export {
   UpdateTableCommand,
   UpdateTimeToLiveCommand,
   UpdateContinuousBackupsCommand,
+  CreateTableCommand,
+  TableExistsWaiter,
 }
 /* @aws-sdk/client-dynamodb Not a pure module */

package/src/Lambda.res

@@ -24,12 +24,23 @@
 type client
 
 module Raw = {
-  type options = {region?: string}
+  type options = {region?: string, maxAttempts?: int, retryMode?: 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}, ())
+/** The Lambda control plane is rate-limited per account and region, and that
+    budget is shared with everything else touching it — a concurrent deploy, an
+    inspector sync, a second estate in the same region. A caller that walks every
+    function in a stack therefore meets `Rate exceeded` on calls it has every
+    right to make, and the SDK default of three attempts in `standard` mode is
+    not enough to ride it out.
+
+    `adaptive` adds a client-side rate limiter that slows the whole client down
+    when the service throttles it, rather than retrying into the same wall, which
+    is what the control plane wants. */
+let client = (~region: option<string>=?, ()): client =>
+  Raw.client(~options={region: ?region, maxAttempts: 10, retryMode: "adaptive"}, ())
 
 /** 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

package/src/Lambda.res.mjs

@@ -6,7 +6,9 @@ let Raw = {};
 
 function client(region, param) {
   return new ClientLambda.LambdaClient({
-    region: region
+    region: region,
+    maxAttempts: 10,
+    retryMode: "adaptive"
   });
 }