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

package/src/SES.res

@@ -0,0 +1,113 @@
+type client
+
+module Raw = {
+  @module("@aws-sdk/client-sesv2") @new
+  external client: unit => client = "SESv2Client"
+}
+
+let clientInstance = ref(None)
+
+let client = () => {
+  switch clientInstance.contents {
+  | None =>
+    let client = Raw.client()
+    clientInstance := Some(client)
+    client
+  | Some(client) => client
+  }
+}
+
+module SendEmailCommand = {
+  /*** see: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sesv2/command/SendEmailCommand/ */
+
+  type t
+
+  type content = {
+    @as("Data") data: string,
+    @as("Charset") charset?: string,
+  }
+
+  type raw // FIXME: implement
+
+  type template // FIXME: implement
+
+  type messageBody = {
+    @as("Html") html?: content,
+    @as("Text") text?: content,
+  }
+
+  type nameValue = {
+    @as("Name") name: string,
+    @as("Value") value: string,
+  }
+
+  type message = {
+    @as("Body") body: messageBody,
+    @as("Subject") subject: content,
+    @as("Headers") headers?: array<nameValue>,
+  }
+
+  type emailContent = {
+    @as("Raw") raw?: raw,
+    @as("Simple") simple?: message,
+    @as("Template") template?: template,
+  }
+
+  type destination = {
+    @as("ToAddresses") toAddresses?: array<string>,
+    @as("CcAddresses") ccAddresses?: array<string>,
+    @as("BccAddresses") bccAddresses?: array<string>,
+  }
+
+  type listManagementOptions = {
+    @as("ContactListName") listName: string,
+    @as("TopicName") topicName?: string,
+  }
+
+  type input = {
+    @as("Content") content: emailContent,
+    @as("ConfigurationSetName") configurationSetName?: string,
+    @as("Destination") destination: destination,
+    @as("EmailTags") emailTags?: array<nameValue>,
+    @as("FeedbackForwardingEmailAddress") feedbackForwardingEmailAddress?: string,
+    @as("FeedbackForwardingEmailAddressIdentityArn")
+    feedbackForwardingEmailAddressIdentityArn?: string,
+    @as("FromEmailAddress") fromEmailAddress?: string,
+    @as("FromEmailAddressIdentityArn") fromEmailAddressIdentityArn?: string,
+    @as("ListManagementOptions") listManagementOptions?: listManagementOptions,
+    @as("ReplyToAddresses") replyToAddresses?: array<string>,
+  }
+
+  type output = {
+    @as("$metadata") metadata: Metadata.t,
+    @as("MessageId") messageId?: string,
+  }
+
+  @new @module("@aws-sdk/client-sesv2")
+  external make: input => t = "SendEmailCommand"
+
+  module Raw = {
+    @send
+    external send: (client, t) => promise<output> = "send"
+  }
+
+  let send: t => promise<output> = input => Raw.send(client(), input)
+}
+
+let sendTextEmail = (
+  ~source: string,
+  ~destination: SendEmailCommand.destination,
+  ~subject: string,
+  ~message: string,
+) => {
+  SendEmailCommand.fromEmailAddress: source,
+  destination,
+  content: {
+    simple: {
+      subject: {data: subject},
+      body: {
+        text: {data: message},
+      },
+    },
+  },
+}

package/src/SES.res.mjs

@@ -0,0 +1,59 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as ClientSesv2 from "@aws-sdk/client-sesv2";
+
+let Raw = {};
+
+let clientInstance = {
+  contents: undefined
+};
+
+function client() {
+  let client$1 = clientInstance.contents;
+  if (client$1 !== undefined) {
+    return Primitive_option.valFromOption(client$1);
+  }
+  let client$2 = new ClientSesv2.SESv2Client();
+  clientInstance.contents = Primitive_option.some(client$2);
+  return client$2;
+}
+
+let Raw$1 = {};
+
+function send(input) {
+  return client().send(input);
+}
+
+let SendEmailCommand = {
+  Raw: Raw$1,
+  send: send
+};
+
+function sendTextEmail(source, destination, subject, message) {
+  return {
+    Content: {
+      Simple: {
+        Body: {
+          Text: {
+            Data: message
+          }
+        },
+        Subject: {
+          Data: subject
+        }
+      }
+    },
+    Destination: destination,
+    FromEmailAddress: source
+  };
+}
+
+export {
+  Raw,
+  clientInstance,
+  client,
+  SendEmailCommand,
+  sendTextEmail,
+}
+/* @aws-sdk/client-sesv2 Not a pure module */

package/src/SNS.res

@@ -0,0 +1,167 @@
+/***  @aws-sdk/client-sns
+  see: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sns/
+*/
+type client
+
+type options = {
+  maxAttempts?: int,
+  region?: string,
+  requestHandler?: NodeHttpHandler.t,
+}
+
+module Raw = {
+  @module("@aws-sdk/client-sns") @new
+  external client: (~options: options, unit) => client = "SNSClient"
+}
+
+let clientInstance = ref(None)
+
+// TODO: instead of mutating snsInstance, use lazy
+let client = () =>
+  switch clientInstance.contents {
+  | None =>
+    let client = Raw.client(
+      ~options={
+        maxAttempts: 5,
+        requestHandler: NodeHttpHandler.make({
+          connectionTimeout: 5000,
+          requestTimeout: 5000,
+        }),
+      },
+      (),
+    )
+    clientInstance := Some(client)
+    client
+  | Some(client) => client
+  }
+
+module PublishCommand = {
+  type input = {
+    @as("Message") message: string,
+    @as("MessageStructure") messageStructure?: string,
+    @as("PhoneNumber") phoneNumber?: string,
+    @as("TargetArn") targetArn?: string,
+    @as("TopicArn") topicArn?: string,
+    @as("Subject") subject?: string,
+    @as("MessageDeduplicationId") messageDeduplicationId?: string,
+    @as("MessageGroupId") messageGroupId?: string,
+  }
+
+  type output = {@as("MessageId") messageId: string}
+
+  type t
+  @new @module("@aws-sdk/client-sns")
+  external make: input => t = "PublishCommand"
+
+  module Raw = {
+    @send
+    external send: (client, t) => promise<output> = "send"
+  }
+
+  let send: t => promise<output> = command => Raw.send(client(), command)
+}
+
+module SubscribeCommand = {
+  type redrivePolicy = {deadLetterTargetArn?: string}
+
+  type attributes = {
+    @as("DeliveryPolicy") deliveryPolicy?: string,
+    @as("FilterPolicy") filterPolicy?: string,
+    @as("RawMessageDelivery") rawMessageDelivery?: string,
+    @as("RedrivePolicy") redrivePolicy?: redrivePolicy,
+  }
+
+  type t
+
+  type input = {
+    @as("TopicArn") topicArn: string,
+    @as("Protocol")
+    protocol: [
+      | #http
+      | #https
+      | #email
+      | #"email-json"
+      | #sms
+      | #sqs
+      | #application
+      | #lambda
+    ],
+    @as("Endpoint") endpoint: string,
+    @as("Attributes") attributes?: attributes,
+    @as("ReturnSubscriptionArn") returnSubscriptionArn?: bool,
+  }
+
+  type output = {
+    @as("SubscriptionArn")
+    subscriptionArn: string /* either the actual arn or "pending confirmation" */,
+  }
+
+  let getSubscriptionArn: output => result<string, string> = response => {
+    let subscriptionArn = response.subscriptionArn
+    if subscriptionArn == "pending confirmation" {
+      Error(subscriptionArn)
+    } else {
+      Ok(subscriptionArn)
+    }
+  }
+
+  @new @module("@aws-sdk/client-sns")
+  external make: input => /* default: false */ t = "SubscribeCommand"
+
+  module Raw = {
+    @send
+    external send: (client, t) => promise<output> = "send"
+  }
+
+  let send: t => promise<output> = command => Raw.send(client(), command)
+}
+
+module UnsubscribeCommand = {
+  type t
+
+  type input = {@as("SubscriptionArn") subscriptionArn: string}
+
+  type output = {.}
+
+  @new @module("@aws-sdk/client-sns") external make: input => t = "UnsubscribeCommand"
+
+  module Raw = {
+    @send
+    external send: (client, t) => promise<output> = "send"
+  }
+
+  let send: t => promise<output> = command => Raw.send(client(), command)
+}
+
+module ListSubscriptionsByTopicCommand = {
+  type t
+
+  type input = {
+    @as("TopicArn") topicArn: string,
+    @as("NextToken") nextToken?: string,
+  }
+
+  type subscription = {
+    @as("SubscriptionArn") subscriptionArn: string,
+    @as("Owner") owner: string,
+    @as("TopicArn") topicArn: string,
+    @as("Protocol") protocol: string,
+    @as("Endpoint") endpoint: string,
+  }
+
+  type output = {
+    @as("Subscriptions") subscriptions: array<subscription>,
+    @as("NextToken") nextToken: string,
+  }
+
+  @new @module("@aws-sdk/client-sns")
+  external make: input => t = "ListSubscriptionsByTopicCommand"
+
+  module Raw = {
+    @send
+    external send: (client, t) => promise<output> = "send"
+  }
+
+  let send: t => promise<output> = command => Raw.send(client(), command)
+}
+

package/src/SNS.res.mjs

@@ -0,0 +1,98 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as ClientSns from "@aws-sdk/client-sns";
+import * as NodeHttpHandler from "@smithy/node-http-handler";
+
+let Raw = {};
+
+let clientInstance = {
+  contents: undefined
+};
+
+function client() {
+  let client$1 = clientInstance.contents;
+  if (client$1 !== undefined) {
+    return Primitive_option.valFromOption(client$1);
+  }
+  let client$2 = new ClientSns.SNSClient({
+    maxAttempts: 5,
+    requestHandler: Primitive_option.some(new NodeHttpHandler.NodeHttpHandler({
+      connectionTimeout: 5000,
+      requestTimeout: 5000
+    }))
+  });
+  clientInstance.contents = Primitive_option.some(client$2);
+  return client$2;
+}
+
+let Raw$1 = {};
+
+function send(command) {
+  return client().send(command);
+}
+
+let PublishCommand = {
+  Raw: Raw$1,
+  send: send
+};
+
+function getSubscriptionArn(response) {
+  let subscriptionArn = response.SubscriptionArn;
+  if (subscriptionArn === "pending confirmation") {
+    return {
+      TAG: "Error",
+      _0: subscriptionArn
+    };
+  } else {
+    return {
+      TAG: "Ok",
+      _0: subscriptionArn
+    };
+  }
+}
+
+let Raw$2 = {};
+
+function send$1(command) {
+  return client().send(command);
+}
+
+let SubscribeCommand = {
+  getSubscriptionArn: getSubscriptionArn,
+  Raw: Raw$2,
+  send: send$1
+};
+
+let Raw$3 = {};
+
+function send$2(command) {
+  return client().send(command);
+}
+
+let UnsubscribeCommand = {
+  Raw: Raw$3,
+  send: send$2
+};
+
+let Raw$4 = {};
+
+function send$3(command) {
+  return client().send(command);
+}
+
+let ListSubscriptionsByTopicCommand = {
+  Raw: Raw$4,
+  send: send$3
+};
+
+export {
+  Raw,
+  clientInstance,
+  client,
+  PublishCommand,
+  SubscribeCommand,
+  UnsubscribeCommand,
+  ListSubscriptionsByTopicCommand,
+}
+/* @aws-sdk/client-sns Not a pure module */

package/src/SNS_Helpers.res

@@ -0,0 +1,45 @@
+let publish = (~topicArn, ~messageGroupId=?, message) =>
+  SNS.PublishCommand.send(
+    SNS.PublishCommand.make({
+      topicArn,
+      messageGroupId: ?(messageGroupId->Option.map(id => id->String.replaceRegExp(/ /g, ""))),
+      message,
+    }),
+  )
+
+let findSubscription = async (queueArn, topicArn) => {
+  let response = await SNS.ListSubscriptionsByTopicCommand.send(
+    SNS.ListSubscriptionsByTopicCommand.make({topicArn: topicArn}),
+  ) // TODO: handle paging of subscriptions
+  response.subscriptions->Array.find(subscription => subscription.endpoint == queueArn)
+}
+
+let subscribeQueueToTopic = async (queueArn, topicArn) =>
+  // TODO: add dlq in RedrivePolicy
+  switch await findSubscription(queueArn, topicArn) {
+  | None =>
+    let subscriptionResponse = await SNS.SubscribeCommand.send(
+      SNS.SubscribeCommand.make({
+        topicArn,
+        protocol: #sqs,
+        endpoint: queueArn,
+        attributes: {
+          rawMessageDelivery: "true",
+        },
+      }),
+    )
+    Console.log2("subscribed:", subscriptionResponse.subscriptionArn)
+
+  | Some(subscription) =>
+    Console.log2("re-using existing subscription:", subscription.subscriptionArn)
+  }
+
+let unsubscribeQueueFromTopic = async (queueArn, topicArn) =>
+  switch await findSubscription(queueArn, topicArn) {
+  | Some(subscription) =>
+    let _unsubscribeResponse = await SNS.UnsubscribeCommand.send(
+      SNS.UnsubscribeCommand.make({subscriptionArn: subscription.subscriptionArn}),
+    )
+    let _ = Console.log2("unsubscribed:", subscription.subscriptionArn)
+  | None => Console.log2("there is no subscription for queue:", queueArn)
+  }

package/src/SNS_Helpers.res.mjs

@@ -0,0 +1,57 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as SNS$AwsSdk from "./SNS.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as ClientSns from "@aws-sdk/client-sns";
+
+function publish(topicArn, messageGroupId, message) {
+  return SNS$AwsSdk.PublishCommand.send(new ClientSns.PublishCommand({
+    Message: message,
+    TopicArn: topicArn,
+    MessageGroupId: Stdlib_Option.map(messageGroupId, id => id.replace(/ /g, ""))
+  }));
+}
+
+async function findSubscription(queueArn, topicArn) {
+  let response = await SNS$AwsSdk.ListSubscriptionsByTopicCommand.send(new ClientSns.ListSubscriptionsByTopicCommand({
+    TopicArn: topicArn
+  }));
+  return response.Subscriptions.find(subscription => subscription.Endpoint === queueArn);
+}
+
+async function subscribeQueueToTopic(queueArn, topicArn) {
+  let subscription = await findSubscription(queueArn, topicArn);
+  if (subscription !== undefined) {
+    console.log("re-using existing subscription:", subscription.SubscriptionArn);
+    return;
+  }
+  let subscriptionResponse = await SNS$AwsSdk.SubscribeCommand.send(new ClientSns.SubscribeCommand({
+    TopicArn: topicArn,
+    Protocol: "sqs",
+    Endpoint: queueArn,
+    Attributes: {
+      RawMessageDelivery: "true"
+    }
+  }));
+  console.log("subscribed:", subscriptionResponse.SubscriptionArn);
+}
+
+async function unsubscribeQueueFromTopic(queueArn, topicArn) {
+  let subscription = await findSubscription(queueArn, topicArn);
+  if (subscription !== undefined) {
+    await SNS$AwsSdk.UnsubscribeCommand.send(new ClientSns.UnsubscribeCommand({
+      SubscriptionArn: subscription.SubscriptionArn
+    }));
+    console.log("unsubscribed:", subscription.SubscriptionArn);
+  } else {
+    console.log("there is no subscription for queue:", queueArn);
+  }
+}
+
+export {
+  publish,
+  findSubscription,
+  subscribeQueueToTopic,
+  unsubscribeQueueFromTopic,
+}
+/* SNS-AwsSdk Not a pure module */