@reventlessdev/rescript-aws-sdk 2.2.0-alpha.20

package/src/SQS_Helpers.res.mjs

@@ -0,0 +1,227 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as SQS$AwsSdk from "./SQS.res.mjs";
+import * as Stdlib_Math from "@rescript/runtime/lib/es6/Stdlib_Math.js";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as ClientSqs from "@aws-sdk/client-sqs";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+
+function arn2Url(arn) {
+  let match = arn.split(":");
+  if (match.length !== 6) {
+    return "";
+  }
+  let service = match[2];
+  let region = match[3];
+  let account = match[4];
+  let queueName = match[5];
+  return `https://` + service + `.` + region + `.amazonaws.com/` + account + `/` + queueName;
+}
+
+function validateDelay(__x) {
+  return Stdlib_Option.map(__x, delay => {
+    if (delay > 900) {
+      console.log("WARNING: [" + ("SQS_Helpers-AwsSdk" + (":" + ((16).toString() + "] SQS.sendMessage was called with a delay set to higher than 900 seconds, which is the maximum amount supported by AWS."))), "DelaySeconds was automatically set to 900 to prevent failure.");
+      return 900;
+    } else {
+      return delay;
+    }
+  });
+}
+
+async function sendMessage(queueId, messageBody, messageGroupId, messageDeduplicationId, delay) {
+  await SQS$AwsSdk.SendMessageCommand.send(new ClientSqs.SendMessageCommand({
+    MessageBody: messageBody,
+    QueueUrl: queueId,
+    DelaySeconds: Stdlib_Option.map(delay, delay => {
+      if (delay > 900) {
+        console.log("WARNING: [" + ("SQS_Helpers-AwsSdk" + (":" + ((47).toString() + "] SQS.sendMessage was called with a delay set to higher than 900 seconds, which is the maximum amount supported by AWS."))), "DelaySeconds was automatically set to 900 to prevent failure.");
+        return 900;
+      } else {
+        return delay;
+      }
+    }),
+    MessageDeduplicationId: messageDeduplicationId,
+    MessageGroupId: Stdlib_Option.map(messageGroupId, id => id.replace(/ /g, ""))
+  }));
+}
+
+function makeBatchEntry(messageBody, messageId, delay) {
+  return {
+    Id: messageId,
+    MessageBody: messageBody,
+    DelaySeconds: validateDelay(delay)
+  };
+}
+
+function makeBatchEntryFifo(groupId, messageBody, messageId, delay) {
+  return {
+    Id: messageId,
+    MessageBody: messageBody,
+    DelaySeconds: validateDelay(delay),
+    MessageGroupId: groupId.replace(/ /g, "")
+  };
+}
+
+function handleSendBatchPromises(promises, entries, name) {
+  return Promise.all(promises.map(async (promise, idx) => {
+    let batchNr = (idx + 1 | 0).toString();
+    let response;
+    try {
+      response = await promise;
+    } catch (raw_exn) {
+      let exn = Primitive_exceptions.internalToException(raw_exn);
+      let error = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), exn => Stdlib_JsExn.message(exn)), "unknown error");
+      console.log(`Error: SQS.` + name + ` batch ` + batchNr + ` failed: ` + error);
+      let start = idx * 10 | 0;
+      let end = start + 10 | 0;
+      return entries.slice(start, end).map(entry => entry.Id);
+    }
+    return Stdlib_Option.getOr(response.Failed, []).map(failure => {
+      let id = failure.Id;
+      let failureCode = failure.Code;
+      let failureMessage = Stdlib_Option.getOr(failure.Message, "unknown message");
+      console.log(`Error: SQS.` + name + ` batch ` + batchNr + ` entry failed: ` + id + `, ` + failureCode + `, ` + failureMessage);
+      return id;
+    });
+  }));
+}
+
+function handleBatchResult(failedIds) {
+  let failedIds$1 = failedIds.flat();
+  if (failedIds$1.length !== 0) {
+    return {
+      TAG: "Error",
+      _0: failedIds$1
+    };
+  } else {
+    return {
+      TAG: "Ok",
+      _0: undefined
+    };
+  }
+}
+
+async function sendMessagesParallel(queueId, entries) {
+  let totalMessageCount = entries.length;
+  let batchNr = 0;
+  let start = 0;
+  let batchPromises = [];
+  let sliceBatch = start => {
+    let end = {
+      contents: start
+    };
+    let batchBytes = 0;
+    let messageBytes = () => entries[end.contents].MessageBody.length;
+    while (end.contents < totalMessageCount && end.contents < (start + 10 | 0) && (batchBytes + messageBytes() | 0) <= 262144) {
+      batchBytes = batchBytes + messageBytes() | 0;
+      end.contents = end.contents + 1 | 0;
+    };
+    if (end.contents === start) {
+      console.log("SQS.sendMessagesParallel: no message sent !!");
+    }
+    return [
+      end.contents,
+      entries.slice(start, end.contents)
+    ];
+  };
+  while (start < totalMessageCount) {
+    let match = sliceBatch(start);
+    let batchEntries = match[1];
+    batchNr = batchNr + 1 | 0;
+    start = match[0];
+    let messages = batchEntries.map(param => param.MessageBody);
+    let messageCountStr = messages.length.toString();
+    let messageBytes = messages.map(message => message.length);
+    let batchBytes = Stdlib_Array.reduce(messageBytes, 0, (acc, a) => acc + a | 0);
+    let messageBytesStr = messageBytes.map(size => size.toString()).join(",");
+    console.log(`SQS.sendMessagesParallel: batchNr:` + batchNr.toString() + ` messageCount:` + messageCountStr + ` batchBytes: ` + batchBytes.toString() + `, messageBytes: ` + messageBytesStr);
+    batchPromises.push(SQS$AwsSdk.SendMessageBatchCommand.send(new ClientSqs.SendMessageBatchCommand({
+      Entries: batchEntries,
+      QueueUrl: queueId
+    })));
+  };
+  return handleBatchResult(await handleSendBatchPromises(batchPromises, entries, "sendMessagesParallel"));
+}
+
+function handleDeleteBatchPromises(promises, entries, name) {
+  return Promise.all(promises.map(async (promise, idx) => {
+    let batchNr = (idx + 1 | 0).toString();
+    let output;
+    try {
+      output = await promise;
+    } catch (raw_exn) {
+      let exn = Primitive_exceptions.internalToException(raw_exn);
+      let error = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), exn => Stdlib_JsExn.message(exn)), "unknown error");
+      console.log(`Error: SQS.` + name + ` batch ` + batchNr + ` failed: ` + error);
+      let start = idx * 10 | 0;
+      let end = start + 10 | 0;
+      return entries.slice(start, end).map(entry => entry.Id);
+    }
+    return Stdlib_Option.getOr(output.Failed, []).map(failure => {
+      let id = failure.Id;
+      let failureCode = failure.Code;
+      let failureMessage = Stdlib_Option.getOr(failure.Message, "unknown message");
+      console.log(`Error: SQS.` + name + ` batch ` + batchNr + ` entry failed: ` + id + `, ` + failureCode + `, ` + failureMessage);
+      return id;
+    });
+  }));
+}
+
+async function deleteMessagesParallel(queueId, entries) {
+  let arraySize = Stdlib_Math.Int.ceil(entries.length / 10);
+  return handleBatchResult(await handleDeleteBatchPromises(Stdlib_Array.fromInitializer(arraySize, batchNr => {
+    let start = batchNr * 10 | 0;
+    let end = start + 10 | 0;
+    return SQS$AwsSdk.DeleteMessageBatchCommand.send(new ClientSqs.DeleteMessageBatchCommand({
+      QueueUrl: queueId,
+      Entries: entries.slice(start, end)
+    }));
+  }), entries, "deleteMessagesParallel"));
+}
+
+async function getQueuePolicy(queueArn) {
+  let response = await SQS$AwsSdk.GetQueueAttributesCommand.send(new ClientSqs.GetQueueAttributesCommand({
+    AttributeNames: ["Policy"],
+    QueueUrl: arn2Url(queueArn)
+  }));
+  return JSON.parse(response.Attributes.Policy);
+}
+
+async function setQueuePolicy(queueArn, policy) {
+  let newPolicy = JSON.stringify(policy);
+  if (newPolicy !== undefined) {
+    await SQS$AwsSdk.SetQueueAttributesCommand.send(new ClientSqs.SetQueueAttributesCommand({
+      Attributes: {
+        Policy: newPolicy
+      },
+      QueueUrl: arn2Url(queueArn)
+    }));
+  } else {
+    console.log("Couldn't stringify policy");
+  }
+}
+
+let maxBatchMessages = 10;
+
+let maxBatchBytes = 262144;
+
+export {
+  arn2Url,
+  validateDelay,
+  sendMessage,
+  makeBatchEntry,
+  makeBatchEntryFifo,
+  maxBatchMessages,
+  maxBatchBytes,
+  handleSendBatchPromises,
+  handleBatchResult,
+  sendMessagesParallel,
+  handleDeleteBatchPromises,
+  deleteMessagesParallel,
+  getQueuePolicy,
+  setQueuePolicy,
+}
+/* SQS-AwsSdk Not a pure module */

package/src/SecretsManager.res

@@ -0,0 +1,61 @@
+/*** @aws-sdk/client-secrets-manager
+  see: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/secrets-manager/
+*/
+type client
+
+type options = {
+  region?: string,
+  maxAttempts?: int,
+  requestHandler?: NodeHttpHandler.t,
+}
+
+module Raw = {
+  @module("@aws-sdk/client-secrets-manager") @new
+  external client: (~options: options, unit) => client = "SecretsManagerClient"
+}
+
+let instance = ref(None)
+
+let client = () =>
+  switch instance.contents {
+  | None =>
+    let client = Raw.client(
+      ~options={
+        maxAttempts: 3,
+        requestHandler: NodeHttpHandler.make({
+          connectionTimeout: 1000,
+          requestTimeout: 5000,
+        }),
+      },
+      (),
+    )
+    instance := Some(client)
+    client
+  | Some(client) => client
+  }
+
+module GetSecretValueCommand = {
+  type t
+
+  type input = {
+    @as("SecretId") secretId: string,
+    @as("VersionId") versionId?: string,
+    @as("VersionStage") versionStage?: string,
+  }
+
+  type output = {
+    @as("SecretString") secretString: option<string>,
+    @as("VersionId") versionId: option<string>,
+    @as("VersionStage") versionStage: option<string>,
+  }
+
+  @new @module("@aws-sdk/client-secrets-manager")
+  external make: input => t = "GetSecretValueCommand"
+
+  module Raw = {
+    @send
+    external send: (client, t) => promise<output> = "send"
+  }
+
+  let send: t => promise<output> = command => Raw.send(client(), command)
+}

package/src/SecretsManager.res.mjs

@@ -0,0 +1,46 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as NodeHttpHandler from "@smithy/node-http-handler";
+import * as ClientSecretsManager from "@aws-sdk/client-secrets-manager";
+
+let Raw = {};
+
+let instance = {
+  contents: undefined
+};
+
+function client() {
+  let client$1 = instance.contents;
+  if (client$1 !== undefined) {
+    return Primitive_option.valFromOption(client$1);
+  }
+  let client$2 = new ClientSecretsManager.SecretsManagerClient({
+    maxAttempts: 3,
+    requestHandler: Primitive_option.some(new NodeHttpHandler.NodeHttpHandler({
+      connectionTimeout: 1000,
+      requestTimeout: 5000
+    }))
+  });
+  instance.contents = Primitive_option.some(client$2);
+  return client$2;
+}
+
+let Raw$1 = {};
+
+function send(command) {
+  return client().send(command);
+}
+
+let GetSecretValueCommand = {
+  Raw: Raw$1,
+  send: send
+};
+
+export {
+  Raw,
+  instance,
+  client,
+  GetSecretValueCommand,
+}
+/* @smithy/node-http-handler Not a pure module */

package/src/example/DynamoDbUtilExample.res

@@ -0,0 +1,20 @@
+open DynamoDb_Util
+open DynamoDb_Util_Helpers
+
+Console.log("----MARSHALL----")
+type a = {a: int, b: bool}
+let r = MarshallOptions.topLevelContainerConverted(~wrapNumbers=true)
+let test = {a: 42, b: true}->marshall(~options=r)
+Console.log(test) // `{ M: { a: { N: '42' }, b: { BOOL: true } } }`
+
+Console.log("----UNMARSHALL----")
+let num = {number: "42"}
+let bool = {bool: true}
+let dict = [("a", num), ("b", bool)]->Dict.fromArray
+let result = unmarshallDict(dict)
+Console.log(result)
+let attrV = {map: dict}
+let result = unmarshall(attrV)
+Console.log(result)
+let result = unmarshall(bool)
+Console.log(result)

package/src/example/DynamoDbUtilExample.res.mjs

@@ -0,0 +1,66 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as DynamoDb_Util$AwsSdk from "../DynamoDb_Util.res.mjs";
+import * as UtilDynamodb from "@aws-sdk/util-dynamodb";
+import * as DynamoDb_Util_Helpers$AwsSdk from "../DynamoDb_Util_Helpers.res.mjs";
+
+console.log("----MARSHALL----");
+
+let r = DynamoDb_Util$AwsSdk.MarshallOptions.topLevelContainerConverted(undefined, undefined, undefined, true);
+
+let test = UtilDynamodb.marshall({
+  a: 42,
+  b: true
+}, r);
+
+console.log(test);
+
+console.log("----UNMARSHALL----");
+
+let num = {
+  N: "42"
+};
+
+let bool = {
+  BOOL: true
+};
+
+let dict = Object.fromEntries([
+  [
+    "a",
+    num
+  ],
+  [
+    "b",
+    bool
+  ]
+]);
+
+let result = DynamoDb_Util_Helpers$AwsSdk.unmarshallDict(undefined, dict);
+
+console.log(result);
+
+let attrV_M = dict;
+
+let attrV = {
+  M: attrV_M
+};
+
+let result$1 = DynamoDb_Util_Helpers$AwsSdk.unmarshall(undefined, attrV);
+
+console.log(result$1);
+
+let result$2 = DynamoDb_Util_Helpers$AwsSdk.unmarshall(undefined, bool);
+
+console.log(result$2);
+
+export {
+  r,
+  test,
+  num,
+  bool,
+  dict,
+  attrV,
+  result$2 as result,
+}
+/*  Not a pure module */