@reventlessdev/reventless-aws 3.0.0-alpha.167

package/src/util/Util_SQS_Runtime.res.mjs

@@ -0,0 +1,150 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Effect from "@reventlessdev/rescript-effect/src/Effect.res.mjs";
+import * as SQS$AwsSdk from "@reventlessdev/rescript-aws-sdk/src/SQS.res.mjs";
+import * as Nodecrypto from "node:crypto";
+import * as Effect$1 from "effect/Effect";
+import * as SQS_Helpers$AwsSdk from "@reventlessdev/rescript-aws-sdk/src/SQS_Helpers.res.mjs";
+import * as ClientSqs from "@aws-sdk/client-sqs";
+import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Message.res.mjs";
+import * as SQS_Error$ReventlessAws from "../errors/SQS_Error.res.mjs";
+import * as EffectLogger$ReventlessCore from "@reventlessdev/reventless-core/src/util/EffectLogger.res.mjs";
+
+function toResolvedQueue(param) {
+  return {
+    id: param.id,
+    name: param.name,
+    arn: param.urn
+  };
+}
+
+function safeGroupId(id) {
+  if (id.length <= 128) {
+    return id;
+  } else {
+    return Nodecrypto.createHash("sha256").update(id).digest("hex");
+  }
+}
+
+function sendMessage(queue, delay, messageBody) {
+  return SQS_Helpers$AwsSdk.sendMessage(queue.id, messageBody, undefined, undefined, delay);
+}
+
+function sendFifoMessage(queue, delay, messageGroupId, messageBody) {
+  return SQS_Helpers$AwsSdk.sendMessage(queue.id, messageBody, messageGroupId, undefined, delay);
+}
+
+function send(queue, queueService, commandJson) {
+  let messageBody = Message$ReventlessCore.toMessageBody(commandJson);
+  return Effect$1.catchAll(Effect$1.retry(Effect$1.map(Effect.tryPromise(SQS_Error$ReventlessAws.classify, () => {
+    if (queueService === "SQS_FIFO") {
+      return sendFifoMessage(queue, commandJson.delay, safeGroupId(commandJson.id), messageBody);
+    } else {
+      return sendMessage(queue, commandJson.delay, messageBody);
+    }
+  }), () => {}), SQS_Error$ReventlessAws.sendRetrySchedule), err => {
+    let msg = SQS_Error$ReventlessAws.message(err);
+    return Effect$1.flatMap(EffectLogger$ReventlessCore.logError("Util_SQS_Runtime-ReventlessAws", undefined, "send: " + msg), () => Effect$1.fail(msg));
+  });
+}
+
+function makeEntry(queueService, commandJson) {
+  let messageId = commandJson.meta.msgId;
+  let messageBody = Message$ReventlessCore.toMessageBody(commandJson);
+  if (queueService === "SQS_FIFO") {
+    return SQS_Helpers$AwsSdk.makeBatchEntryFifo(safeGroupId(commandJson.id), messageBody, messageId, commandJson.delay);
+  } else {
+    return SQS_Helpers$AwsSdk.makeBatchEntry(messageBody, messageId, commandJson.delay);
+  }
+}
+
+function sendMessages(queue, queueService, commandJsons) {
+  let attempt = (retry, toSend) => Effect$1.flatMap(Effect$1.retry(Effect.tryPromise(SQS_Error$ReventlessAws.classify, () => SQS_Helpers$AwsSdk.sendMessagesParallel(queue.id, toSend.map(commandJson => makeEntry(queueService, commandJson)))), SQS_Error$ReventlessAws.retrySchedule), result => {
+    if (result.TAG === "Ok") {
+      return Effect$1.succeed();
+    }
+    let failedIds = result._0;
+    let commandJsonsToRetry = toSend.filter(param => {
+      let msgId = param.meta.msgId;
+      return failedIds.some(failedId => failedId === msgId);
+    });
+    if (retry < 5) {
+      return Effect$1.flatMap(EffectLogger$ReventlessCore.logInfo("Util_SQS_Runtime-ReventlessAws", undefined, `sendMessages: ` + failedIds.length.toString() + ` failed ids, retrying subset`), () => attempt(retry + 1 | 0, commandJsonsToRetry));
+    }
+    let ids = failedIds.join(", ");
+    return Effect$1.fail({
+      TAG: "Permanent",
+      _0: `sendMessages failed for ids: ` + ids
+    });
+  });
+  return Effect$1.catchAll(attempt(0, commandJsons), err => {
+    let msg = SQS_Error$ReventlessAws.message(err);
+    return Effect$1.flatMap(EffectLogger$ReventlessCore.logError("Util_SQS_Runtime-ReventlessAws", undefined, `sendMessages: ` + msg), () => Effect$1.fail(msg));
+  });
+}
+
+async function deleteMessage(queue, receiptHandle) {
+  return await SQS$AwsSdk.DeleteMessageCommand.send(new ClientSqs.DeleteMessageCommand({
+    QueueUrl: queue.id,
+    ReceiptHandle: receiptHandle
+  }));
+}
+
+function deleteMessages(entries, queue) {
+  let attempt = (retry, toDelete) => Effect$1.flatMap(Effect$1.retry(Effect.tryPromise(SQS_Error$ReventlessAws.classify, () => SQS_Helpers$AwsSdk.deleteMessagesParallel(queue.id, toDelete)), SQS_Error$ReventlessAws.retrySchedule), result => {
+    if (result.TAG === "Ok") {
+      return Effect$1.succeed();
+    }
+    let failedIds = result._0;
+    let entriesToRetry = toDelete.filter((param, idx) => {
+      let id = idx.toString();
+      return failedIds.some(failedId => failedId === id);
+    }).map((entry, idx) => ({
+      Id: idx.toString(),
+      ReceiptHandle: entry.ReceiptHandle
+    }));
+    if (retry < 5) {
+      return Effect$1.flatMap(EffectLogger$ReventlessCore.logInfo("Util_SQS_Runtime-ReventlessAws", undefined, `deleteMessages: ` + failedIds.length.toString() + ` failed ids, retrying subset`), () => attempt(retry + 1 | 0, entriesToRetry));
+    }
+    let ids = failedIds.join(", ");
+    return Effect$1.fail({
+      TAG: "Permanent",
+      _0: `deleteMessages failed for ids: ` + ids
+    });
+  });
+  return Effect$1.catchAll(attempt(0, entries), err => {
+    let msg = SQS_Error$ReventlessAws.message(err);
+    return Effect$1.flatMap(EffectLogger$ReventlessCore.logError("Util_SQS_Runtime-ReventlessAws", undefined, `deleteMessages: ` + msg), () => Effect$1.fail(msg));
+  });
+}
+
+function parseSqsRecord(record) {
+  let eventStr = record.body;
+  let json;
+  try {
+    json = JSON.parse(eventStr);
+  } catch (_err) {
+    return;
+  }
+  return json;
+}
+
+let sendMessagesMaxRetries = 5;
+
+let deleteMessagesMaxRetries = 5;
+
+export {
+  toResolvedQueue,
+  safeGroupId,
+  sendMessage,
+  sendFifoMessage,
+  send,
+  makeEntry,
+  sendMessagesMaxRetries,
+  sendMessages,
+  deleteMessage,
+  deleteMessagesMaxRetries,
+  deleteMessages,
+  parseSqsRecord,
+}
+/* Effect Not a pure module */

package/src/util/Util_SesPolicy_Runtime.res

@@ -0,0 +1,54 @@
+let emailIdentity: (
+  ~name: string,
+  ~email: string,
+  ~opts: Pulumi.CustomResourceOptions.t=?,
+) => PulumiAws.SES.EmailIdentity.t = (~name, ~email, ~opts=?) =>
+  PulumiAws.SES.EmailIdentity.make(~name="emailIdentity" ++ name, ~args={email: email}, ~opts?)
+
+let fromCustomResourceOptions: option<
+  Pulumi.CustomResourceOptions.t,
+> => Pulumi.InvokeOptions.t = x =>
+  switch x {
+  | None => {}
+  | Some(opts) => {Pulumi.InvokeOptions.parent: ?opts.parent, provider: ?opts.provider}
+  }
+
+let sesPolicyDocument: (
+  ~name: string,
+  ~identity: PulumiAws.SES.EmailIdentity.t,
+  ~opts: Pulumi.CustomResourceOptions.t=?,
+) => Pulumi.Output.t<PulumiAws.PolicyDocument.t> = (~name, ~identity, ~opts as _=?) =>
+  identity.arn->Pulumi.Output.flatMap(identityArn => {
+    open PulumiAws.PolicyDocument
+    PulumiAws.PolicyDocument.make(
+      ~id=name ++ "SESPolicy",
+      ~statements=[
+        {
+          sid: "AllowSES",
+          principal: Principals({aws: PrincipalId("*")}),
+          effect: Allow,
+          actions: Actions(["SES:SendEmail", "SES:SendRawEmail"]),
+          resources: Resource(identityArn),
+        },
+      ],
+    )->Pulumi.Output.make
+  })
+
+let identityWithPolicy: (
+  ~name: string,
+  ~email: string,
+  ~opts: Pulumi.CustomResourceOptions.t=?,
+) => PulumiAws.SES.IdentityPolicy.t = (~name, ~email, ~opts=?) => {
+  let identity = emailIdentity(~name, ~email, ~opts?)
+
+  PulumiAws.SES.IdentityPolicy.make(
+    ~name="identityPolicy" ++ name,
+    ~args={
+      identity: identity.arn->Pulumi.Output.asInput,
+      policy: sesPolicyDocument(~name, ~identity, ~opts?)
+      ->Pulumi.Output.apply(policyDocument => policyDocument->PulumiAws.PolicyDocument.toJsonString)
+      ->Pulumi.Output.asInput,
+    },
+    ~opts?,
+  )
+}

package/src/util/Util_SesPolicy_Runtime.res.mjs

@@ -0,0 +1,55 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Aws from "@pulumi/aws";
+import * as Output$Pulumi from "@reventlessdev/rescript-pulumi-pulumi/src/Output.res.mjs";
+import * as Pulumi from "@pulumi/pulumi";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as PolicyDocument$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/IAM/PolicyDocument.res.mjs";
+
+function emailIdentity(name, email, opts) {
+  return new (Aws.ses.EmailIdentity)("emailIdentity" + name, {
+    email: email
+  }, opts !== undefined ? Primitive_option.valFromOption(opts) : undefined);
+}
+
+function fromCustomResourceOptions(x) {
+  if (x !== undefined) {
+    return {
+      parent: x.parent,
+      provider: x.provider
+    };
+  } else {
+    return {};
+  }
+}
+
+function sesPolicyDocument(name, identity, param) {
+  return Output$Pulumi.flatMap(identity.arn, identityArn => Pulumi.output(PolicyDocument$PulumiAws.make(undefined, name + "SESPolicy", [{
+      Sid: "AllowSES",
+      Principal: {
+        AWS: "*"
+      },
+      Effect: "Allow",
+      Action: [
+        "SES:SendEmail",
+        "SES:SendRawEmail"
+      ],
+      Resource: identityArn
+    }])));
+}
+
+function identityWithPolicy(name, email, opts) {
+  let identity = emailIdentity(name, email, opts);
+  return new (Aws.ses.IdentityPolicy)("identityPolicy" + name, {
+    identity: identity.arn,
+    policy: sesPolicyDocument(name, identity, opts).apply(PolicyDocument$PulumiAws.toJsonString)
+  }, opts !== undefined ? Primitive_option.valFromOption(opts) : undefined);
+}
+
+export {
+  emailIdentity,
+  fromCustomResourceOptions,
+  sesPolicyDocument,
+  identityWithPolicy,
+}
+/* @pulumi/aws Not a pure module */

package/src/util/Util_StaticBundle.res

@@ -0,0 +1,124 @@
+let log = ReventlessCore.Logger.fromEnv()
+
+@module("path") external join2: (string, string) => string = "join"
+@module("path") external relative: (string, string) => string = "relative"
+
+@module("fs") external existsSync: string => bool = "existsSync"
+@module("fs") external readFileSync: string => Js.TypedArray2.Uint8Array.t = "readFileSync"
+type dirent
+@module("fs")
+external readdirSync: (string, {"withFileTypes": bool}) => array<dirent> = "readdirSync"
+@send external isDirectory: dirent => bool = "isDirectory"
+@get external direntName: dirent => string = "name"
+
+type hashObj
+@module("crypto") external createHash: string => hashObj = "createHash"
+@send external updateBuffer: (hashObj, Js.TypedArray2.Uint8Array.t) => hashObj = "update"
+@send external digest: (hashObj, string) => string = "digest"
+
+type fileEntry = {
+  relativePath: string,
+  absolutePath: string,
+  fileAsset: Pulumi.Asset.t,
+  contentHash: string,
+}
+
+let toForwardSlashes = (p: string): string => p->String.replaceAll("\\", "/")
+
+let isHidden = (name: string): bool => name->String.startsWith(".")
+
+let rec walkInto = (~dir: string, ~prefix: string, acc: array<fileEntry>): unit => {
+  let entries = readdirSync(dir, {"withFileTypes": true})
+  entries->Array.forEach(entry => {
+    let entryName = entry->direntName
+    if isHidden(entryName) {
+      ()
+    } else if entry->isDirectory {
+      let nextPrefix = prefix == "" ? entryName : prefix ++ "/" ++ entryName
+      walkInto(~dir=join2(dir, entryName), ~prefix=nextPrefix, acc)
+    } else {
+      let absolutePath = join2(dir, entryName)
+      let relativePath = prefix == "" ? entryName : prefix ++ "/" ++ entryName
+      let bytes = readFileSync(absolutePath)
+      let contentHash =
+        createHash("sha256")
+        ->updateBuffer(bytes)
+        ->digest("hex")
+      acc->Array.push({
+        relativePath: relativePath->toForwardSlashes,
+        absolutePath,
+        fileAsset: Pulumi.Asset.fileAsset(absolutePath),
+        contentHash,
+      })
+    }
+  })
+}
+
+/**
+ * Walk a directory recursively and return one entry per file with its
+ * relative S3 key, content hash, and a Pulumi FileAsset. Skips dotfiles.
+ */
+let walk = (assetsDir: string): array<fileEntry> => {
+  if !existsSync(assetsDir) {
+    JsError.throwWithMessage(
+      `Util_StaticBundle.walk: assetsDir does not exist: ${assetsDir}`,
+    )
+  }
+  let acc: array<fileEntry> = []
+  walkInto(~dir=assetsDir, ~prefix="", acc)
+  acc
+}
+
+/**
+ * Replace `/` and `.` so a path can be used as a Pulumi resource URN segment.
+ */
+let sanitizeName = (relativePath: string): string =>
+  relativePath
+  ->String.replaceAll("/", "-")
+  ->String.replaceAll(".", "-")
+
+let extensionOf = (path: string): string => {
+  let parts = path->String.split(".")
+  switch parts->Array.length {
+  | 0 | 1 => ""
+  | n => parts->Array.getUnsafe(n - 1)->String.toLowerCase
+  }
+}
+
+/**
+ * MIME type for common SPA bundle extensions. Defaults to
+ * application/octet-stream for unknown types and warns to console
+ * so missing types surface in the deploy log.
+ */
+let contentTypeFor = (relativePath: string): string => {
+  switch extensionOf(relativePath) {
+  | "html" => "text/html; charset=utf-8"
+  | "htm" => "text/html; charset=utf-8"
+  | "css" => "text/css; charset=utf-8"
+  | "js" | "mjs" => "application/javascript; charset=utf-8"
+  | "json" => "application/json; charset=utf-8"
+  | "map" => "application/json; charset=utf-8"
+  | "txt" => "text/plain; charset=utf-8"
+  | "xml" => "application/xml; charset=utf-8"
+  | "svg" => "image/svg+xml"
+  | "png" => "image/png"
+  | "jpg" | "jpeg" => "image/jpeg"
+  | "gif" => "image/gif"
+  | "webp" => "image/webp"
+  | "ico" => "image/x-icon"
+  | "avif" => "image/avif"
+  | "woff" => "font/woff"
+  | "woff2" => "font/woff2"
+  | "ttf" => "font/ttf"
+  | "otf" => "font/otf"
+  | "eot" => "application/vnd.ms-fontobject"
+  | "wasm" => "application/wasm"
+  | "pdf" => "application/pdf"
+  | _ =>
+    log.warn(
+      ~comp="Util_StaticBundle",
+      `contentTypeFor: no MIME mapping for "${relativePath}", defaulting to application/octet-stream`,
+    )
+    "application/octet-stream"
+  }
+}

package/src/util/Util_StaticBundle.res.mjs

@@ -0,0 +1,132 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Fs from "fs";
+import * as Path from "path";
+import * as Crypto from "crypto";
+import * as Pulumi from "@pulumi/pulumi";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Logger$ReventlessCore from "@reventlessdev/reventless-core/src/util/Logger.res.mjs";
+
+let log = Logger$ReventlessCore.fromEnv();
+
+function toForwardSlashes(p) {
+  return p.replaceAll("\\", "/");
+}
+
+function isHidden(name) {
+  return name.startsWith(".");
+}
+
+function walkInto(dir, prefix, acc) {
+  let entries = Fs.readdirSync(dir, {
+    withFileTypes: true
+  });
+  entries.forEach(entry => {
+    let entryName = entry.name;
+    if (entryName.startsWith(".")) {
+      return;
+    }
+    if (entry.isDirectory()) {
+      let nextPrefix = prefix === "" ? entryName : prefix + "/" + entryName;
+      return walkInto(Path.join(dir, entryName), nextPrefix, acc);
+    }
+    let absolutePath = Path.join(dir, entryName);
+    let relativePath = prefix === "" ? entryName : prefix + "/" + entryName;
+    let bytes = Fs.readFileSync(absolutePath);
+    let contentHash = Crypto.createHash("sha256").update(bytes).digest("hex");
+    acc.push({
+      relativePath: relativePath.replaceAll("\\", "/"),
+      absolutePath: absolutePath,
+      fileAsset: new (Pulumi.asset.FileAsset)(absolutePath),
+      contentHash: contentHash
+    });
+  });
+}
+
+function walk(assetsDir) {
+  if (!Fs.existsSync(assetsDir)) {
+    Stdlib_JsError.throwWithMessage(`Util_StaticBundle.walk: assetsDir does not exist: ` + assetsDir);
+  }
+  let acc = [];
+  walkInto(assetsDir, "", acc);
+  return acc;
+}
+
+function sanitizeName(relativePath) {
+  return relativePath.replaceAll("/", "-").replaceAll(".", "-");
+}
+
+function extensionOf(path) {
+  let parts = path.split(".");
+  let n = parts.length;
+  if (n !== 0 && n !== 1) {
+    return parts[n - 1 | 0].toLowerCase();
+  } else {
+    return "";
+  }
+}
+
+function contentTypeFor(relativePath) {
+  let match = extensionOf(relativePath);
+  switch (match) {
+    case "avif" :
+      return "image/avif";
+    case "css" :
+      return "text/css; charset=utf-8";
+    case "eot" :
+      return "application/vnd.ms-fontobject";
+    case "gif" :
+      return "image/gif";
+    case "htm" :
+    case "html" :
+      return "text/html; charset=utf-8";
+    case "ico" :
+      return "image/x-icon";
+    case "jpeg" :
+    case "jpg" :
+      return "image/jpeg";
+    case "json" :
+    case "map" :
+      return "application/json; charset=utf-8";
+    case "js" :
+    case "mjs" :
+      return "application/javascript; charset=utf-8";
+    case "otf" :
+      return "font/otf";
+    case "pdf" :
+      return "application/pdf";
+    case "png" :
+      return "image/png";
+    case "svg" :
+      return "image/svg+xml";
+    case "ttf" :
+      return "font/ttf";
+    case "txt" :
+      return "text/plain; charset=utf-8";
+    case "wasm" :
+      return "application/wasm";
+    case "webp" :
+      return "image/webp";
+    case "woff" :
+      return "font/woff";
+    case "woff2" :
+      return "font/woff2";
+    case "xml" :
+      return "application/xml; charset=utf-8";
+    default:
+      log.warn("Util_StaticBundle", undefined, `contentTypeFor: no MIME mapping for "` + relativePath + `", defaulting to application/octet-stream`);
+      return "application/octet-stream";
+  }
+}
+
+export {
+  log,
+  toForwardSlashes,
+  isHidden,
+  walkInto,
+  walk,
+  sanitizeName,
+  extensionOf,
+  contentTypeFor,
+}
+/* log Not a pure module */

package/src/util/Util_Vpc.res

@@ -0,0 +1,22 @@
+/**
+  Creates a VpcConfig from a VPC component in another stack
+ */
+let getVpcConfig: (
+  ~stackName: string,
+  ~outputName: string,
+) => Pulumi.Output.t<PulumiAws.Lambda.CallbackFunction.Args.vpcConfig> = (
+  ~stackName,
+  ~outputName,
+) => {
+  let stackReference = Pulumi.StackReference.make(stackName)
+  let vpcOutput = stackReference->Pulumi.StackReference.requireOutput(outputName->Pulumi.Input.make)
+  vpcOutput->Pulumi.Output.apply(vpc =>
+    switch (vpc["securityGroup"]["id"], vpc["privateSubnet"]["id"], vpc["vpc"]["id"]) {
+    | (Some(securityGroupId), Some(subnetId), Some(_vpcId)) => {
+        PulumiAws.Lambda.CallbackFunction.Args.securityGroupIds: [securityGroupId],
+        subnetIds: [subnetId],
+      }
+    | _ => JsError.throwWithMessage("Output is not a ReventlessCore Vpc Component")
+    }
+  )
+}

package/src/util/Util_Vpc.res.mjs

@@ -0,0 +1,27 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Pulumi from "@pulumi/pulumi";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+
+function getVpcConfig(stackName, outputName) {
+  let stackReference = new Pulumi.StackReference(stackName);
+  let vpcOutput = stackReference.requireOutput(outputName);
+  return vpcOutput.apply(vpc => {
+    let match = vpc.securityGroup.id;
+    let match$1 = vpc.privateSubnet.id;
+    let match$2 = vpc.vpc.id;
+    if (match !== undefined && match$1 !== undefined && match$2 !== undefined) {
+      return {
+        securityGroupIds: [match],
+        subnetIds: [match$1]
+      };
+    } else {
+      return Stdlib_JsError.throwWithMessage("Output is not a ReventlessCore Vpc Component");
+    }
+  });
+}
+
+export {
+  getVpcConfig,
+}
+/* @pulumi/pulumi Not a pure module */