@reventlessdev/reventless-aws 3.0.0-alpha.167

package/src/adapter/StateTopic/StateTopic_AppSync.res.mjs

@@ -0,0 +1,295 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Aws from "@pulumi/aws";
+import * as IAM$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/IAM/IAM.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Pulumi from "@pulumi/pulumi";
+import * as Lambda$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/Lambda/Lambda.res.mjs";
+import * as AWS$ReventlessAws from "../AWS.res.mjs";
+import * as AWS_Tags$ReventlessAws from "../AWS_Tags.res.mjs";
+import * as QueryDb$ReventlessCore from "@reventlessdev/reventless-core/src/components/QueryDb/QueryDb.res.mjs";
+import * as PolicyDocument$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/IAM/PolicyDocument.res.mjs";
+import * as Util_Bundle$ReventlessAws from "../../util/Util_Bundle.res.mjs";
+import * as Util_ReadModel$ReventlessCore from "@reventlessdev/reventless-core/src/util/Util_ReadModel.res.mjs";
+import * as AppSync_EventsApi$ReventlessAws from "../Api/AppSync_EventsApi.res.mjs";
+import * as Util_DynamoDbStream$ReventlessAws from "../../util/Util_DynamoDbStream.res.mjs";
+
+let registry = {};
+
+let handlerCode = `
+import { createHmac, createHash } from "node:crypto";
+import { unmarshall } from "@aws-sdk/util-dynamodb";
+
+const TOPIC_MAP = JSON.parse(process.env.STATE_TOPIC_MAP || "{}");
+const APPSYNC_ENDPOINT = process.env.APPSYNC_ENDPOINT; // "https://{eventsApi.dns.http}"
+const AWS_REGION = process.env.AWS_REGION ?? "eu-west-1";
+
+function sha256hex(data) {
+  return createHash("sha256").update(typeof data === "string" ? data : JSON.stringify(data)).digest("hex");
+}
+function hmacBuf(key, data) {
+  return createHmac("sha256", key).update(data).digest();
+}
+
+async function signedHeaders(host, path, body) {
+  const accessKeyId = process.env.AWS_ACCESS_KEY_ID;
+  const secretAccessKey = process.env.AWS_SECRET_ACCESS_KEY;
+  const sessionToken = process.env.AWS_SESSION_TOKEN;
+  const now = new Date();
+  const amzDate = now.toISOString().replace(/[:\\-]|\\..../g, "").slice(0, 15) + "Z";
+  const dateStamp = now.toISOString().slice(0, 10).replace(/-/g, "");
+  const headers = { host, "x-amz-date": amzDate, ...(sessionToken ? { "x-amz-security-token": sessionToken } : {}) };
+  const canonH = Object.entries(headers).sort(([a],[b]) => a.localeCompare(b)).map(([k,v]) => \`\${k}:\${v}\\n\`).join("");
+  const signH = Object.keys(headers).sort().join(";");
+  const cr = ["POST", path, "", canonH, signH, sha256hex(body)].join("\\n");
+  const scope = \`\${dateStamp}/\${AWS_REGION}/appsync/aws4_request\`;
+  const sts = ["AWS4-HMAC-SHA256", amzDate, scope, sha256hex(cr)].join("\\n");
+  const kDate = hmacBuf("AWS4" + secretAccessKey, dateStamp);
+  const kSigning = hmacBuf(hmacBuf(hmacBuf(kDate, AWS_REGION), "appsync"), "aws4_request");
+  const sig = createHmac("sha256", kSigning).update(sts).digest("hex");
+  return { ...headers, Authorization: \`AWS4-HMAC-SHA256 Credential=\${accessKeyId}/\${scope}, SignedHeaders=\${signH}, Signature=\${sig}\` };
+}
+
+// AppSync Events channel segments allow only [A-Za-z0-9-]. Anything else
+// (\`@\`, \`.\`, \`:\`, \`_\`, \`/\`, …) collapses to \`-\` so the segment is a
+// legal channel-path token. The UI's AutoLive.normalizeSegment uses the same
+// rule for Entity-scoped subscribes.
+function pathSegment(value) {
+  return String(value).replace(/[^A-Za-z0-9-]/g, "-");
+}
+
+// Map record.eventSourceARN → topicRoot via STATE_TOPIC_MAP.
+// Stream ARNs look like: arn:aws:dynamodb:<region>:<acct>:table/<TableName>/stream/<ts>
+function topicRootFromEventSourceArn(arn) {
+  const m = arn && arn.match(/:table\\/([^/]+)\\/stream\\//);
+  if (!m) return undefined;
+  const topicName = TOPIC_MAP[m[1]];
+  if (topicName === undefined) return undefined;
+  return pathSegment(topicName);
+}
+
+// Build entityKey from record.dynamodb.Keys. Framework convention:
+// partition-key attr is named "id"; composite tables have one extra attr (the
+// sort key) whose name comes from the projection's subIdConfig.subIdField.
+// Returns the ORIGINAL key string — the descriptor body uses this verbatim so
+// AutoListView can match it against the GraphQL row.id. The channel path
+// segment is derived later via pathSegment().
+function entityKeyFromRecord(record) {
+  const keys = unmarshall(record.dynamodb.Keys ?? {});
+  const id = keys.id;
+  if (id === undefined) {
+    // Defensive: framework always names the partition key "id". If a future
+    // table breaks the convention, fall back to a stable sort-join.
+    const names = Object.keys(keys).sort();
+    return names.map((n) => String(keys[n])).join("-");
+  }
+  const subIdName = Object.keys(keys).find((k) => k !== "id");
+  return subIdName === undefined
+    ? String(id)
+    : String(id) + "-" + String(keys[subIdName]);
+}
+
+// Map DDB stream eventName → descriptor changeKind.
+function changeKindFor(eventName) {
+  switch (eventName) {
+    case "INSERT": return "Added";
+    case "MODIFY": return "Updated";
+    case "REMOVE": return "Removed";
+    default:       return "Updated";  // defensive default — shouldn't fire
+  }
+}
+
+// Pick the "natural" sort timestamp from an unmarshalled image. Conventions
+// in this codebase prefer updatedAt; createdAt is the fallback for views that
+// never mutate after insert. Returns undefined if neither is present.
+function pickSortKeyValue(image) {
+  if (image && typeof image.updatedAt === "string") return image.updatedAt;
+  if (image && typeof image.createdAt === "string") return image.createdAt;
+  return undefined;
+}
+
+export async function handler(event) {
+  const url = new URL(APPSYNC_ENDPOINT);
+  let transientErr;
+  for (const record of event.Records) {
+    const topicRoot = topicRootFromEventSourceArn(record.eventSourceARN);
+    if (topicRoot === undefined) {
+      console.warn("StateTopic: unknown table for ARN", record.eventSourceARN);
+      continue;
+    }
+    const channelRoot = "/default/" + topicRoot;
+    const image =
+      record.eventName === "REMOVE"
+        ? record.dynamodb.OldImage
+        : record.dynamodb.NewImage;
+    if (image === undefined) continue;
+    const entityKey = entityKeyFromRecord(record);
+    const channel = channelRoot + "/" + pathSegment(entityKey);
+    const unmarshalled = unmarshall(image);
+    const descriptor = {
+      changeKind: changeKindFor(record.eventName),
+      id: entityKey,
+    };
+    const sortKeyValue = pickSortKeyValue(unmarshalled);
+    if (sortKeyValue !== undefined) descriptor.sortKeyValue = sortKeyValue;
+    const body = JSON.stringify({ id: record.eventID, channel, events: [JSON.stringify(descriptor)] });
+    const auth = await signedHeaders(url.hostname, "/event", body);
+    try {
+      const res = await fetch(APPSYNC_ENDPOINT + "/event", {
+        method: "POST",
+        headers: { accept: "application/json, text/javascript", "content-encoding": "amz-1.0", "content-type": "application/json; charset=UTF-8", ...auth },
+        body,
+      });
+      if (!res.ok) {
+        const txt = await res.text();
+        // 4xx: permanent (bad request, auth, channel format) — retrying won't
+        // help. Log structurally so a CloudWatch metric filter on
+        // "STATE_TOPIC_PUBLISH_FAILED type=permanent" surfaces it; continue
+        // processing so one bad record doesn't block the rest of the batch.
+        // 5xx / network: transient — record it and throw at the end so the
+        // ESM retries (bounded by maximumRetryAttempts + bisectBatch).
+        const isTransient = res.status >= 500;
+        const tag = isTransient ? "transient" : "permanent";
+        console.error(
+          "STATE_TOPIC_PUBLISH_FAILED type=" + tag +
+          " status=" + res.status +
+          " channel=" + channel +
+          " body=" + txt.slice(0, 500)
+        );
+        if (isTransient) transientErr = new Error("StateTopic publish failed: " + res.status);
+      }
+    } catch (e) {
+      // Network-level error (DNS, connection refused, timeout) — always transient.
+      console.error(
+        "STATE_TOPIC_PUBLISH_FAILED type=transient status=network" +
+        " channel=" + channel +
+        " err=" + (e && e.message)
+      );
+      transientErr = e;
+    }
+  }
+  // Throw after the loop so a single transient error doesn't stop us from
+  // emitting other records' descriptors first. The ESM will retry the batch;
+  // bisectBatchOnFunctionError isolates the bad record across retries.
+  if (transientErr) throw transientErr;
+}
+`;
+
+function make(readModelName, topicName, allQueryDbs, eventsApi, param) {
+  let streamResource = Util_DynamoDbStream$ReventlessAws.findResource(Util_ReadModel$ReventlessCore.queryDbStorageResources(allQueryDbs, readModelName));
+  let streamArn = Util_DynamoDbStream$ReventlessAws.streamArnFromDynamoDbTableResource(streamResource);
+  let tableName = streamResource.name;
+  let key = eventsApi.name;
+  let entries = Stdlib_Option.getOr(registry[key], []);
+  registry[key] = entries.concat([{
+      tableName: tableName,
+      streamArn: streamArn,
+      topicName: topicName
+    }]);
+}
+
+function finish(eventsApi, opts) {
+  let key = eventsApi.name;
+  let entries = registry[key];
+  if (entries === undefined) {
+    return;
+  }
+  if (entries.length === 0) {
+    return;
+  }
+  let name = eventsApi.name;
+  let lambdaRole = IAM$PulumiAws.Role.makeWithDefaultPolicy(name + "StateTopicRole", Pulumi.output(AWS$ReventlessAws.Lambda.principal), opts);
+  let streamArnsOutput = Pulumi.all(entries.map(e => e.streamArn));
+  Pulumi.all([
+    streamArnsOutput,
+    eventsApi.api.apiArn
+  ]).apply(param => {
+    new (Aws.iam.RolePolicy)(name + "StateTopicPolicy", {
+      policy: PolicyDocument$PulumiAws.toJsonString(PolicyDocument$PulumiAws.make(undefined, name + "StateTopicPolicy", [
+        {
+          Sid: "AllowLambdaLogging",
+          Effect: "Allow",
+          Action: "logs:*",
+          Resource: "arn:aws:logs:*:*:*"
+        },
+        {
+          Sid: "AllowReadDynamoDbStream",
+          Effect: "Allow",
+          Action: [
+            "dynamodb:DescribeStream",
+            "dynamodb:GetRecords",
+            "dynamodb:GetShardIterator",
+            "dynamodb:ListStreams"
+          ],
+          Resource: param[0]
+        },
+        {
+          Sid: "AllowPublishAppSyncEvents",
+          Effect: "Allow",
+          Action: "appsync:EventPublish",
+          Resource: param[1] + "/*"
+        }
+      ])),
+      role: lambdaRole.id
+    }, opts);
+  });
+  let topicMapJson = Pulumi.all(entries.map(e => e.tableName)).apply(tableNames => {
+    let dict = {};
+    tableNames.forEach((tableName, i) => {
+      let topicName = entries[i].topicName;
+      dict[tableName] = topicName;
+    });
+    return JSON.stringify(dict);
+  });
+  let archiveContents = {};
+  archiveContents["index.mjs"] = new (Pulumi.asset.StringAsset)(handlerCode);
+  let code = new (Pulumi.asset.AssetArchive)(archiveContents);
+  let sourceCodeHash = Util_Bundle$ReventlessAws.hashString(handlerCode);
+  let layers = Stdlib_Option.getOr(Stdlib_Option.map(Lambda$PulumiAws.reventlessLayerArn, arn => [arn]), []);
+  let appsyncEndpoint = AppSync_EventsApi$ReventlessAws.httpEndpoint(eventsApi);
+  let lambda = new (Aws.lambda.Function)(name + "StateTopicPublisher", {
+    handler: "index.handler",
+    runtime: "nodejs22.x",
+    code: code,
+    role: lambdaRole.arn,
+    memorySize: 256,
+    timeout: 30,
+    layers: layers,
+    tags: AWS_Tags$ReventlessAws.make(name + "StateTopic", QueryDb$ReventlessCore.componentType),
+    environment: {
+      variables: Object.fromEntries([
+        [
+          "Environment",
+          Pulumi.getStack()
+        ],
+        [
+          "APPSYNC_ENDPOINT",
+          appsyncEndpoint
+        ],
+        [
+          "STATE_TOPIC_MAP",
+          topicMapJson
+        ]
+      ])
+    },
+    sourceCodeHash: sourceCodeHash
+  }, opts);
+  entries.forEach(entry => {
+    new (Aws.lambda.EventSourceMapping)(entry.topicName + "Stream2" + name + "StateTopic", {
+      functionName: lambda.arn,
+      bisectBatchOnFunctionError: true,
+      eventSourceArn: entry.streamArn,
+      maximumRetryAttempts: 3,
+      startingPosition: "LATEST"
+    }, opts);
+  });
+  registry[key] = [];
+}
+
+export {
+  registry,
+  handlerCode,
+  make,
+  finish,
+}
+/* @pulumi/aws Not a pure module */

package/src/adapter/Task/TaskBucket.res

@@ -0,0 +1 @@
+module S3 = TaskBucket_S3

package/src/adapter/Task/TaskBucket.res.mjs

@@ -0,0 +1,9 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+let S3;
+
+export {
+  S3,
+}
+/* No side effect */

package/src/adapter/Task/TaskBucket_S3.res

@@ -0,0 +1,157 @@
+type runtimeParts = Util.Lambda.runtimeParts
+type callbackEvent = PulumiAws.S3.Bucket.event
+type context = PulumiAws.Lambda.context
+type bucketParts = PulumiAws.S3.Bucket.t
+
+let subscribeLambda2S3Bucket = (lambda: Pulumi.Output.t<PulumiAws.Lambda.Function.t>, name, bucket, opts) => {
+  // Coerce Function.t → CallbackFunction.t for S3 bucket notification bindings
+  // (structurally compatible: both have arn, id, name)
+  let handler: Pulumi.Output.t<PulumiAws.Lambda.CallbackFunction.t> = lambda->Obj.magic
+  let _ = handler->Pulumi.Output.apply(handler => {
+    let _subscribeResources = [
+      bucket->PulumiAws.S3.Bucket.onObjectCreated(~name=name ++ "Created", ~handler, ~opts),
+      bucket->PulumiAws.S3.Bucket.onObjectRemoved(~name=name ++ "Deleted", ~handler, ~opts),
+    ]
+  })
+}
+
+open PulumiAws.PolicyDocument
+open ReventlessCore.Adapter
+open Adapter_Helpers
+
+let createLambdaPolicy = (
+  lambdaRole: PulumiAws.IAM.Role.t,
+  name,
+  bucket: PulumiAws.S3.Bucket.t,
+  bucketMode: ReventlessCore.Task.bucketMode,
+  resources: array<ReventlessInfra.Adapter.resource>,
+  opts,
+) => {
+  let _ =
+    (bucket.arn, resources->ReventlessCore.Adapter.resourcesToResolvedOutput)
+    ->Pulumi.Output.all2
+    ->Pulumi.Output.apply(((bucketArn, resources)) => {
+      let allowLambdaWriteS3 =
+        bucketMode == Write || bucketMode == ReadWrite
+          ? Some(
+              PulumiAws.PolicyDocument.make(
+                ~id=name ++ "WriteS3",
+                ~statements=[
+                  {
+                    sid: "allowLambdaWriteS3",
+                    effect: Allow,
+                    actions: Actions(["s3:PutObject", "s3:DeleteObject"]),
+                    resources: Resource(bucketArn),
+                  },
+                ],
+              ),
+            )
+          : None
+      let allowLambdaReadS3 =
+        bucketMode == Read || bucketMode == ReadWrite
+          ? Some(
+              PulumiAws.PolicyDocument.make(
+                ~id=name ++ "ReadS3",
+                ~statements=[
+                  {
+                    sid: "allowLambdaReadS3",
+                    effect: Allow,
+                    actions: Actions(["s3:GetObject"]),
+                    resources: Resource(bucketArn),
+                  },
+                ],
+              ),
+            )
+          : None
+      let allowLambdaSendSQS =
+        resources->Array.length > 0
+          ? {
+              Some(
+                PulumiAws.PolicyDocument.make(
+                  ~id=name ++ "SendSQS",
+                  ~statements=[
+                    {
+                      sid: "AllowLambdaSendSQS",
+                      effect: Allow,
+                      actions: Action("sqs:SendMessage"),
+                      resources: Resources(resources->sqsResources->urns),
+                    },
+                  ],
+                ),
+              )
+            }
+          : None
+
+      let _lambdaPolicy = PulumiAws.IAM.RolePolicy.make(
+        ~name,
+        ~args={
+          policy: PulumiAws.PolicyDocument.mergePolicyDocuments(
+            name ++ "LambdaPolicy",
+            [
+              Some(PulumiAws.Lambda.defaultLoggingPolicyDocument),
+              allowLambdaReadS3,
+              allowLambdaWriteS3,
+              allowLambdaSendSQS,
+            ]->Array.keepSome,
+          )->Pulumi.Output.asInput,
+          role: lambdaRole.id->Pulumi.Output.asInput,
+        },
+        ~opts,
+      )
+    })
+}
+
+let connect = (
+  ~name,
+  ~bucket: ReventlessCore.Task_Adapter.bucket<bucketParts>,
+  ~bucketMode: ReventlessCore.Task.bucketMode,
+  ~commandTopics: Pulumi.Output.t<ReventlessCore.CommandTopic.allOutputs>,
+  ~runtime: ReventlessCore.Runtime.environment<runtimeParts>,
+  ~opts,
+) => {
+  let opts = opts->ReventlessCore.Util.Pulumi.ComponentResourceOptions.toCustomResourceOptions
+
+  let lambda = runtime.parts.lambda
+  let lambdaRole = runtime.parts.lambdaRole
+
+  let _ = commandTopics->Pulumi.Output.apply(allCommandTopics => {
+    lambda->subscribeLambda2S3Bucket(name, bucket.parts, opts)
+    let resources =
+      allCommandTopics->Dict.valuesToArray->Array.flatMap(commandTopic => commandTopic.resources)
+    lambdaRole->createLambdaPolicy(name, bucket.parts, bucketMode, resources, opts)
+  })
+}
+
+let make: ReventlessCore.Task_Adapter.bucketMaker<bucketParts> = (~name, ~opts) => {
+  let opts = opts->ReventlessCore.Util.Pulumi.ComponentResourceOptions.toCustomResourceOptions
+
+  let bucket = {
+    PulumiAws.S3.Bucket.make(
+      ~name,
+      ~args={
+        corsRules: [
+          {
+            PulumiAws.S3.Bucket.allowedHeaders: ["*"],
+            allowedMethods: ["HEAD", "GET"],
+            allowedOrigins: ["*"],
+            exposeHeaders: [
+              "x-amz-server-side-encryption",
+              ">x-amz-request-id",
+              "x-amz-id-2",
+              "ETag",
+            ],
+            maxAgeSeconds: 3000,
+          },
+        ]->Pulumi.Input.make,
+      },
+      ~opts,
+    )
+  }
+
+  {
+    resources: [bucket->Util.S3.toResource],
+    parts: bucket,
+  }
+}
+
+let makeHandler = handleEvents => TaskBucket_S3_Runtime.handleBucketEvent(handleEvents, ...)

package/src/adapter/Task/TaskBucket_S3.res.mjs

@@ -0,0 +1,108 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Aws from "@pulumi/aws";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Pulumi from "@pulumi/pulumi";
+import * as Lambda$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/Lambda/Lambda.res.mjs";
+import * as Util_S3$ReventlessAws from "../../util/Util_S3.res.mjs";
+import * as Adapter$ReventlessCore from "@reventlessdev/reventless-core/src/adapter/Adapter.res.mjs";
+import * as PolicyDocument$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/IAM/PolicyDocument.res.mjs";
+import * as Util_Pulumi$ReventlessCore from "@reventlessdev/reventless-core/src/util/Util_Pulumi.res.mjs";
+import * as Adapter_Helpers$ReventlessAws from "../Adapter_Helpers.res.mjs";
+import * as TaskBucket_S3_Runtime$ReventlessAws from "./TaskBucket_S3_Runtime.res.mjs";
+
+function subscribeLambda2S3Bucket(lambda, name, bucket, opts) {
+  lambda.apply(handler => {
+    [
+      bucket.onObjectCreated(name + "Created", handler, undefined, opts),
+      bucket.onObjectRemoved(name + "Deleted", handler, undefined, opts)
+    ];
+  });
+}
+
+function createLambdaPolicy(lambdaRole, name, bucket, bucketMode, resources, opts) {
+  Pulumi.all([
+    bucket.arn,
+    Adapter$ReventlessCore.resourcesToResolvedOutput(resources)
+  ]).apply(param => {
+    let resources = param[1];
+    let bucketArn = param[0];
+    let allowLambdaWriteS3 = bucketMode === "Write" || bucketMode === "ReadWrite" ? PolicyDocument$PulumiAws.make(undefined, name + "WriteS3", [{
+          Sid: "allowLambdaWriteS3",
+          Effect: "Allow",
+          Action: [
+            "s3:PutObject",
+            "s3:DeleteObject"
+          ],
+          Resource: bucketArn
+        }]) : undefined;
+    let allowLambdaReadS3 = bucketMode === "Read" || bucketMode === "ReadWrite" ? PolicyDocument$PulumiAws.make(undefined, name + "ReadS3", [{
+          Sid: "allowLambdaReadS3",
+          Effect: "Allow",
+          Action: ["s3:GetObject"],
+          Resource: bucketArn
+        }]) : undefined;
+    let allowLambdaSendSQS = resources.length !== 0 ? PolicyDocument$PulumiAws.make(undefined, name + "SendSQS", [{
+          Sid: "AllowLambdaSendSQS",
+          Effect: "Allow",
+          Action: "sqs:SendMessage",
+          Resource: Adapter$ReventlessCore.urns(Adapter_Helpers$ReventlessAws.sqsResources(resources))
+        }]) : undefined;
+    new (Aws.iam.RolePolicy)(name, {
+      policy: PolicyDocument$PulumiAws.mergePolicyDocuments(name + "LambdaPolicy", Stdlib_Array.keepSome([
+        Lambda$PulumiAws.defaultLoggingPolicyDocument,
+        allowLambdaReadS3,
+        allowLambdaWriteS3,
+        allowLambdaSendSQS
+      ])),
+      role: lambdaRole.id
+    }, opts);
+  });
+}
+
+function connect(name, bucket, bucketMode, commandTopics, runtime, opts) {
+  let opts$1 = Util_Pulumi$ReventlessCore.ComponentResourceOptions.toCustomResourceOptions(opts);
+  let lambda = runtime.parts.lambda;
+  let lambdaRole = runtime.parts.lambdaRole;
+  commandTopics.apply(allCommandTopics => {
+    subscribeLambda2S3Bucket(lambda, name, bucket.parts, opts$1);
+    let resources = Object.values(allCommandTopics).flatMap(commandTopic => commandTopic.resources);
+    createLambdaPolicy(lambdaRole, name, bucket.parts, bucketMode, resources, opts$1);
+  });
+}
+
+function make(name, opts) {
+  let opts$1 = Util_Pulumi$ReventlessCore.ComponentResourceOptions.toCustomResourceOptions(opts);
+  let bucket = new (Aws.s3.Bucket)(name, {
+    corsRules: [{
+        allowedHeaders: ["*"],
+        allowedMethods: [
+          "HEAD",
+          "GET"
+        ],
+        allowedOrigins: ["*"],
+        exposeHeaders: [
+          "x-amz-server-side-encryption",
+          ">x-amz-request-id",
+          "x-amz-id-2",
+          "ETag"
+        ],
+        maxAgeSeconds: 3000
+      }]
+  }, opts$1);
+  return {
+    resources: [Util_S3$ReventlessAws.toResource(bucket)],
+    parts: bucket
+  };
+}
+
+let makeHandler = TaskBucket_S3_Runtime$ReventlessAws.handleBucketEvent;
+
+export {
+  subscribeLambda2S3Bucket,
+  createLambdaPolicy,
+  connect,
+  make,
+  makeHandler,
+}
+/* @pulumi/aws Not a pure module */

package/src/adapter/Task/TaskBucket_S3_Runtime.res

@@ -0,0 +1,11 @@
+let handleBucketEvent = (handleEvent: ReventlessCore.Task.bucketCallback) =>
+  (event: PulumiAws.S3.Bucket.event, _) => {
+    event.records
+    ->Array.map(record => {
+      let eventName = record.eventName
+      let key = decodeURIComponent(record.s3.object.key)
+      handleEvent(~eventName, ~key)
+    })
+    ->Promise.all
+    ->Promise.thenResolve(actions => actions->Array.flat)
+  }

package/src/adapter/Task/TaskBucket_S3_Runtime.res.mjs

@@ -0,0 +1,15 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+function handleBucketEvent(handleEvent) {
+  return (event, param) => Promise.all(event.Records.map(record => {
+    let eventName = record.eventName;
+    let key = decodeURIComponent(record.s3.object.key);
+    return handleEvent(eventName, key);
+  })).then(actions => actions.flat());
+}
+
+export {
+  handleBucketEvent,
+}
+/* No side effect */

package/src/components/Aggregate_Builder.res

@@ -0,0 +1 @@
+include Aggregate_Builder_Single

package/src/components/Aggregate_Builder.res.mjs

@@ -0,0 +1,25 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Aggregate_Builder_Single$ReventlessAws from "./Aggregate_Builder_Single.res.mjs";
+
+let CommandGeneratorResolvers = Aggregate_Builder_Single$ReventlessAws.CommandGeneratorResolvers;
+
+let CommandTopicChannel = Aggregate_Builder_Single$ReventlessAws.CommandTopicChannel;
+
+let EventCollectorChannel = Aggregate_Builder_Single$ReventlessAws.EventCollectorChannel;
+
+let RuntimeEnvironment = Aggregate_Builder_Single$ReventlessAws.RuntimeEnvironment;
+
+let AggregateRuntimeBuilder = Aggregate_Builder_Single$ReventlessAws.AggregateRuntimeBuilder;
+
+let Make = Aggregate_Builder_Single$ReventlessAws.Make;
+
+export {
+  CommandGeneratorResolvers,
+  CommandTopicChannel,
+  EventCollectorChannel,
+  RuntimeEnvironment,
+  AggregateRuntimeBuilder,
+  Make,
+}
+/* Aggregate_Builder_Single-ReventlessAws Not a pure module */