@reventlessdev/reventless-aws 3.0.0-alpha.227 → 3.0.0-alpha.229

package/src/adapter/Upload/Upload_Presign_S3.res.mjs

@@ -0,0 +1,170 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Aws from "@pulumi/aws";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+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 Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as AWS$ReventlessAws from "../AWS.res.mjs";
+import * as ClientS3 from "@aws-sdk/client-s3";
+import * as AWS_Tags$ReventlessAws from "../AWS_Tags.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 S3RequestPresigner from "@aws-sdk/s3-request-presigner";
+
+let getEnv = (function(k) { var v = process.env[k]; return (v === undefined || v === null || v === "") ? undefined : v; });
+
+let genUuid = (function() {
+    return (globalThis.crypto && globalThis.crypto.randomUUID)
+      ? globalThis.crypto.randomUUID()
+      : require("crypto").randomUUID();
+  });
+
+let decodeJwtSub = (function(header) {
+    try {
+      var token = header.indexOf("Bearer ") === 0 ? header.slice(7) : header;
+      var parts = token.split(".");
+      if (parts.length < 2) return undefined;
+      var base64 = parts[1].replace(/-/g, "+").replace(/_/g, "/");
+      var json = Buffer.from(base64, "base64").toString("utf8");
+      var claims = JSON.parse(json);
+      return (claims && claims.sub) ? String(claims.sub) : undefined;
+    } catch (_) { return undefined; }
+  });
+
+function corsHeaders() {
+  return Object.fromEntries([
+    [
+      "content-type",
+      "application/json"
+    ],
+    [
+      "access-control-allow-origin",
+      "*"
+    ],
+    [
+      "access-control-allow-methods",
+      "POST,OPTIONS"
+    ],
+    [
+      "access-control-allow-headers",
+      "*"
+    ]
+  ]);
+}
+
+function identityPrefix(event) {
+  let authHeader = Stdlib_Option.flatMap(event.headers, h => Stdlib_Option.orElse(h["authorization"], h["Authorization"]));
+  let sub = Stdlib_Option.flatMap(authHeader, decodeJwtSub);
+  if (sub !== undefined) {
+    return sub + `/`;
+  } else {
+    return "";
+  }
+}
+
+async function handlePresign(event, _context) {
+  try {
+    let bucket = Stdlib_Option.getOr(getEnv("UPLOAD_BUCKET"), "");
+    let parsed = Stdlib_Option.getOr(Stdlib_JSON.Decode.object(JSON.parse(Stdlib_Option.getOr(event.body, "{}"))), {});
+    let fileName = Stdlib_Option.getOr(Stdlib_Option.flatMap(parsed["fileName"], Stdlib_JSON.Decode.string), "upload");
+    let contentType = Stdlib_Option.flatMap(parsed["contentType"], Stdlib_JSON.Decode.string);
+    let servedPrefix = Stdlib_Option.getOr(getEnv("SERVED_PREFIX"), "uploads");
+    let key = servedPrefix + `/` + identityPrefix(event) + genUuid() + `/` + fileName;
+    let client = new ClientS3.S3Client();
+    let command = new ClientS3.PutObjectCommand({
+      Bucket: bucket,
+      Key: key,
+      ContentType: contentType
+    });
+    let uploadUrl = await S3RequestPresigner.getSignedUrl(client, command, {
+      expiresIn: 300
+    });
+    let storageRef = `/` + key;
+    return {
+      statusCode: 200,
+      headers: corsHeaders(),
+      body: JSON.stringify(Object.fromEntries([
+        [
+          "uploadUrl",
+          uploadUrl
+        ],
+        [
+          "storageRef",
+          storageRef
+        ]
+      ]))
+    };
+  } catch (exn) {
+    return {
+      statusCode: 400,
+      headers: corsHeaders(),
+      body: JSON.stringify(Object.fromEntries([[
+          "error",
+          "presign_failed"
+        ]]))
+    };
+  }
+}
+
+function make(bucketName, corsOriginsOpt, servedPrefixOpt, opts) {
+  let corsOrigins = corsOriginsOpt !== undefined ? corsOriginsOpt : ["*"];
+  let servedPrefix = servedPrefixOpt !== undefined ? servedPrefixOpt : "uploads";
+  let serviceName = "UploadPresignService";
+  let opts$1 = Stdlib_Option.map(opts, Util_Pulumi$ReventlessCore.ComponentResourceOptions.toCustomResourceOptions);
+  let lambdaRole = IAM$PulumiAws.Role.makeWithDefaultPolicy(serviceName, Pulumi.output(AWS$ReventlessAws.Lambda.principal), AWS_Tags$ReventlessAws.make(serviceName, "Platform", "Identity", "Platform", undefined, undefined, undefined, undefined), opts$1);
+  bucketName.apply(b => {
+    let arn = `arn:aws:s3:::` + b + `/*`;
+    new (Aws.iam.RolePolicy)(serviceName + `Policy`, {
+      policy: PolicyDocument$PulumiAws.toJsonString(PolicyDocument$PulumiAws.make(undefined, serviceName + `Policy`, [{
+          Sid: "AllowUploadPut",
+          Effect: "Allow",
+          Action: "s3:PutObject",
+          Resource: arn
+        }])),
+      role: lambdaRole.id
+    }, opts$1 !== undefined ? Primitive_option.valFromOption(opts$1) : undefined);
+  });
+  let environment = {
+    variables: Object.fromEntries([
+      [
+        "UPLOAD_BUCKET",
+        bucketName
+      ],
+      [
+        "SERVED_PREFIX",
+        servedPrefix
+      ]
+    ])
+  };
+  let lambda = new (Aws.lambda.CallbackFunction)(serviceName, Lambda$PulumiAws.CallbackFunction.Args.make(handlePresign, lambdaRole, undefined, undefined, undefined, undefined, 30, undefined, undefined, undefined, AWS_Tags$ReventlessAws.make(serviceName, "Platform", "Runtime", "Platform", undefined, undefined, undefined, undefined), environment), opts$1 !== undefined ? Primitive_option.valFromOption(opts$1) : undefined);
+  let functionUrl = new (Aws.lambda.FunctionUrl)(serviceName + `Url`, {
+    authorizationType: "NONE",
+    functionName: lambda.name,
+    cors: {
+      allowHeaders: ["*"].map(prim => prim),
+      allowMethods: ["POST"].map(prim => prim),
+      allowOrigins: corsOrigins.map(prim => prim)
+    }
+  }, opts$1 !== undefined ? Primitive_option.valFromOption(opts$1) : undefined);
+  return {
+    url: functionUrl.functionUrl,
+    resources: [
+      lambda.arn,
+      functionUrl.functionArn
+    ]
+  };
+}
+
+export {
+  getEnv,
+  genUuid,
+  decodeJwtSub,
+  corsHeaders,
+  identityPrefix,
+  handlePresign,
+  make,
+}
+/* @pulumi/aws Not a pure module */

package/src/plugin/stack/Plugin_Stack.res

@@ -142,6 +142,7 @@ let makeUiBundleDistribution = (
   ~stableName: bool=false,
   ~excludeFiles: array<string>=[],
   ~customDomain: option<customDomain>=?,
+  ~servedBuckets: array<ReventlessInfra.Platform.servedBucket>=[],
 ): bundleDistribution => {
   // When stableName=true, Pulumi resource names omit bundleVersion so every
   // deploy updates the same bucket + CloudFront distribution in place. The
@@ -219,9 +220,26 @@ let makeUiBundleDistribution = (
     cachedMethods: Pulumi.Input.make(["GET", "HEAD"]),
     cachePolicyId: Pulumi.Input.make(cachingDisabledPolicyId),
   }
+  // Ordered cache behavior routing a served bucket's `{prefix}/*` path to its own
+  // origin. Served objects have immutable uuid keys ⇒ the long-TTL
+  // CachingOptimized policy is safe. Prepended to `orderedCacheBehaviors` so a
+  // served path is matched before the SPA-serving default behavior and never
+  // routed to the bundle bucket.
+  let servedOriginId = (prefix: string): string => "served-" ++ prefix
+  let servedCacheBehavior = (prefix: string): PulumiAws.CloudFront.Distribution.orderedCacheBehavior => {
+    pathPattern: Pulumi.Input.make(prefix ++ "/*"),
+    targetOriginId: Pulumi.Input.make(servedOriginId(prefix)),
+    viewerProtocolPolicy: Pulumi.Input.make("redirect-to-https"),
+    allowedMethods: Pulumi.Input.make(["GET", "HEAD"]),
+    cachedMethods: Pulumi.Input.make(["GET", "HEAD"]),
+    cachePolicyId: Pulumi.Input.make(cachingOptimizedPolicyId),
+  }
   let orderedCacheBehaviors = Array.concat(
-    [noCacheBehavior("/remoteEntry.js")],
-    spaFallback ? [noCacheBehavior("/" ++ indexDocument), noCacheBehavior("/config.json")] : [],
+    servedBuckets->Array.map(sb => servedCacheBehavior(sb.prefix)),
+    Array.concat(
+      [noCacheBehavior("/remoteEntry.js")],
+      spaFallback ? [noCacheBehavior("/" ++ indexDocument), noCacheBehavior("/config.json")] : [],
+    ),
   )
 
   // Custom-domain provisioning. When `customDomain` is supplied the bundle is
@@ -305,13 +323,23 @@ let makeUiBundleDistribution = (
       origins: (bucket.bucketRegionalDomainName, oac.id)
         ->Pulumi.Output.all2
         ->Pulumi.Output.apply(((domainName, oacId)) =>
-          [
-            {
-              PulumiAws.CloudFront.Distribution.domainName: Pulumi.Input.make(domainName),
-              originId: Pulumi.Input.make(originId),
+          Array.concat(
+            [
+              {
+                PulumiAws.CloudFront.Distribution.domainName: Pulumi.Input.make(domainName),
+                originId: Pulumi.Input.make(originId),
+                originAccessControlId: Pulumi.Input.make(oacId),
+              },
+            ],
+            // One S3 origin per served bucket, sharing the same OAC as the bundle
+            // origin (the OAC only authorizes CloudFront→S3 sigv4 signing; the
+            // per-bucket read grant is the served bucket's own BucketPolicy below).
+            servedBuckets->Array.map(sb => {
+              PulumiAws.CloudFront.Distribution.domainName: sb.bucketRegionalDomainName,
+              originId: Pulumi.Input.make(servedOriginId(sb.prefix)),
               originAccessControlId: Pulumi.Input.make(oacId),
-            },
-          ]
+            }),
+          )
         )
         ->Pulumi.Output.asInput,
       defaultCacheBehavior: Pulumi.Input.make(
@@ -400,6 +428,41 @@ let makeUiBundleDistribution = (
     },
   )
 
+  // Per served bucket: grant CloudFront read scoped to THIS distribution, so the
+  // object is fetchable at `https://<ui-domain>/{prefix}/<key>` while the bucket
+  // stays private (direct S3 GET is 403). Mirrors the bundle bucket policy above;
+  // the served bucket keeps its own all-true BucketPublicAccessBlock (app-owned).
+  servedBuckets->Array.forEach(sb => {
+    let _ = PulumiAws.S3.BucketPolicy.make(
+      ~name=name ++ "-served-" ++ sb.prefix ++ "-policy",
+      ~args={
+        bucket: sb.bucketId,
+        policy: (sb.bucketArn->Pulumi.Output.fromInput, distribution.arn)
+          ->Pulumi.Output.all2
+          ->Pulumi.Output.apply(((bucketArn, distributionArn)) =>
+            {
+              "Version": "2012-10-17",
+              "Statement": [
+                {
+                  "Sid": "AllowCloudFrontServicePrincipal",
+                  "Effect": "Allow",
+                  "Principal": {"Service": "cloudfront.amazonaws.com"},
+                  "Action": "s3:GetObject",
+                  "Resource": bucketArn ++ "/*",
+                  "Condition": {
+                    "StringEquals": {"AWS:SourceArn": distributionArn},
+                  },
+                },
+              ],
+            }
+            ->JSON.stringifyAny
+            ->Option.getUnsafe
+          )
+          ->Pulumi.Output.asInput,
+      },
+    )
+  })
+
   switch assetsDir {
   | None => ()
   | Some(dir) =>

package/src/plugin/stack/Plugin_Stack.res.mjs

@@ -68,11 +68,12 @@ async function invalidateDistribution(distributionId, paths) {
   }
 }
 
-function makeUiBundleDistribution(pluginId, bundleVersion, assetsDir, spaFallbackOpt, indexDocumentOpt, stableNameOpt, excludeFilesOpt, customDomain) {
+function makeUiBundleDistribution(pluginId, bundleVersion, assetsDir, spaFallbackOpt, indexDocumentOpt, stableNameOpt, excludeFilesOpt, customDomain, servedBucketsOpt) {
   let spaFallback = spaFallbackOpt !== undefined ? spaFallbackOpt : false;
   let indexDocument = indexDocumentOpt !== undefined ? indexDocumentOpt : "index.html";
   let stableName = stableNameOpt !== undefined ? stableNameOpt : false;
   let excludeFiles = excludeFilesOpt !== undefined ? excludeFilesOpt : [];
+  let servedBuckets = servedBucketsOpt !== undefined ? servedBucketsOpt : [];
   let name = stableName ? pluginId : pluginId + "-" + bundleVersion;
   let bucket = new (Aws.s3.Bucket)(name + "-bundle", {
     tags: AWS_Tags$ReventlessAws.make(name + "-bundle", "Plugin", "Hosting", "Plugin", undefined, undefined, pluginId, undefined)
@@ -118,10 +119,26 @@ function makeUiBundleDistribution(pluginId, bundleVersion, assetsDir, spaFallbac
     ],
     cachePolicyId: cachingDisabledPolicyId
   });
-  let orderedCacheBehaviors = [noCacheBehavior("/remoteEntry.js")].concat(spaFallback ? [
+  let orderedCacheBehaviors = servedBuckets.map(sb => {
+    let prefix = sb.prefix;
+    return {
+      pathPattern: prefix + "/*",
+      targetOriginId: "served-" + prefix,
+      viewerProtocolPolicy: "redirect-to-https",
+      allowedMethods: [
+        "GET",
+        "HEAD"
+      ],
+      cachedMethods: [
+        "GET",
+        "HEAD"
+      ],
+      cachePolicyId: cachingOptimizedPolicyId
+    };
+  }).concat([noCacheBehavior("/remoteEntry.js")].concat(spaFallback ? [
       noCacheBehavior("/" + indexDocument),
       noCacheBehavior("/config.json")
-    ] : []);
+    ] : []));
   let viewerCertificate;
   if (customDomain !== undefined) {
     let usEast1 = _getUsEast1Provider();
@@ -163,11 +180,18 @@ function makeUiBundleDistribution(pluginId, bundleVersion, assetsDir, spaFallbac
     origins: Pulumi.all([
       bucket.bucketRegionalDomainName,
       oac.id
-    ]).apply(param => [{
-        domainName: param[0],
-        originId: originId,
-        originAccessControlId: param[1]
-      }]),
+    ]).apply(param => {
+      let oacId = param[1];
+      return [{
+          domainName: param[0],
+          originId: originId,
+          originAccessControlId: oacId
+        }].concat(servedBuckets.map(sb => ({
+        domainName: sb.bucketRegionalDomainName,
+        originId: "served-" + sb.prefix,
+        originAccessControlId: oacId
+      })));
+    }),
     defaultCacheBehavior: {
       targetOriginId: originId,
       viewerProtocolPolicy: "redirect-to-https",
@@ -228,6 +252,31 @@ function makeUiBundleDistribution(pluginId, bundleVersion, assetsDir, spaFallbac
         }]
     }))
   });
+  servedBuckets.forEach(sb => {
+    new (Aws.s3.BucketPolicy)(name + "-served-" + sb.prefix + "-policy", {
+      bucket: sb.bucketId,
+      policy: Pulumi.all([
+        sb.bucketArn,
+        distribution.arn
+      ]).apply(param => JSON.stringify({
+        Version: "2012-10-17",
+        Statement: [{
+            Sid: "AllowCloudFrontServicePrincipal",
+            Effect: "Allow",
+            Principal: {
+              Service: "cloudfront.amazonaws.com"
+            },
+            Action: "s3:GetObject",
+            Resource: param[0] + "/*",
+            Condition: {
+              StringEquals: {
+                "AWS:SourceArn": param[1]
+              }
+            }
+          }]
+      }))
+    });
+  });
   if (assetsDir !== undefined) {
     let allEntries = Util_StaticBundle$ReventlessAws.walk(assetsDir);
     if (allEntries.length === 0) {

package/src/util/Util_DynamoDbStream_Runtime.res

@@ -34,10 +34,16 @@ let buildJsonEvent' = dict => {
       ->Dict.fromArray
       ->JSON.Encode.object
     }
+    // Carry the stored `recorded_at` column into the envelope so StateViewSlice
+    // projections receive it as `consumed.recordedAt` (the authoritative storage
+    // time on the AWS path). Absent on non-event rows → empty string.
+    let recordedAt =
+      dict->Dict.get("recordedAt")->Option.getOr(""->JSON.Encode.string)
     Some(
       [
         ("id", dict->Dict.get("id")->Option.getOrThrow),
         ("meta", meta),
+        ("recordedAt", recordedAt),
         ("event", ReventlessCore.Message.combineMessage(eventType, payload)),
       ]
       ->Dict.fromArray

package/src/util/Util_DynamoDbStream_Runtime.res.mjs

@@ -53,6 +53,7 @@ function buildJsonEvent$p(dict) {
       ]
     ]);
   }
+  let recordedAt = Stdlib_Option.getOr(dict["recordedAt"], "");
   return Object.fromEntries([
     [
       "id",
@@ -62,6 +63,10 @@ function buildJsonEvent$p(dict) {
       "meta",
       meta
     ],
+    [
+      "recordedAt",
+      recordedAt
+    ],
     [
       "event",
       Message$ReventlessCore.combineMessage(match, payload)

package/src/util/Util_StaticBundle.res

@@ -5,6 +5,7 @@ let log = ReventlessCore.Logger.fromEnv()
 
 @module("fs") external existsSync: string => bool = "existsSync"
 @module("fs") external readFileSync: string => Js.TypedArray2.Uint8Array.t = "readFileSync"
+@module("fs") external readFileSyncUtf8: (string, string) => string = "readFileSync"
 type dirent
 @module("fs")
 external readdirSync: (string, {"withFileTypes": bool}) => array<dirent> = "readdirSync"
@@ -69,6 +70,26 @@ let walk = (assetsDir: string): array<fileEntry> => {
   acc
 }
 
+/**
+ * Read a JSON file at deploy time and return its exact bytes as a string, after
+ * validating that it parses. A missing or malformed file throws with an
+ * actionable message so a broken file fails the deploy rather than shipping a
+ * file a consumer will fetch-and-ignore. The verbatim bytes are returned (not
+ * re-serialised) so formatting/key order the author chose is preserved.
+ */
+let readJsonFileVerbatim = (~path: string, ~label: string): string => {
+  if !existsSync(path) {
+    JsError.throwWithMessage(`${label}: file does not exist: ${path}`)
+  }
+  let content = readFileSyncUtf8(path, "utf8")
+  try {
+    let _ = JSON.parseOrThrow(content)
+    content
+  } catch {
+  | _ => JsError.throwWithMessage(`${label}: file is not valid JSON: ${path}`)
+  }
+}
+
 /**
  * Replace `/` and `.` so a path can be used as a Pulumi resource URN segment.
  */

package/src/util/Util_StaticBundle.res.mjs

@@ -52,6 +52,19 @@ function walk(assetsDir) {
   return acc;
 }
 
+function readJsonFileVerbatim(path, label) {
+  if (!Fs.existsSync(path)) {
+    Stdlib_JsError.throwWithMessage(label + `: file does not exist: ` + path);
+  }
+  let content = Fs.readFileSync(path, "utf8");
+  try {
+    JSON.parse(content);
+    return content;
+  } catch (exn) {
+    return Stdlib_JsError.throwWithMessage(label + `: file is not valid JSON: ` + path);
+  }
+}
+
 function sanitizeName(relativePath) {
   return relativePath.replaceAll("/", "-").replaceAll(".", "-");
 }
@@ -125,6 +138,7 @@ export {
   isHidden,
   walkInto,
   walk,
+  readJsonFileVerbatim,
   sanitizeName,
   extensionOf,
   contentTypeFor,

package/tests/Util_StaticBundleTest.res

@@ -134,3 +134,43 @@ describe("Util_StaticBundle.walk", () => {
     expect(threw)->toBe(true)
   })
 })
+
+describe("Util_StaticBundle.readJsonFileVerbatim", () => {
+  let writeTmp = (contents: string): string => {
+    let dir = mkdtempSync(join2(tmpdir(), "ui-hints-"))
+    let path = join2(dir, "ui-hints.json")
+    writeFileSync(path, contents)
+    path
+  }
+
+  testSync("returns the file's exact bytes for valid JSON (verbatim, not re-serialised)", () => {
+    // Deliberately non-canonical formatting: extra spaces + trailing newline.
+    let raw = "{\n  \"dashboards\":  [ ] \n}\n"
+    let path = writeTmp(raw)
+    expect(Util_StaticBundle.readJsonFileVerbatim(~path, ~label="test"))->toBe(raw)
+    rmSync(path, {"recursive": true, "force": true})
+  })
+
+  testSync("throws on malformed JSON", () => {
+    let path = writeTmp("{ not valid json ")
+    let threw = try {
+      let _ = Util_StaticBundle.readJsonFileVerbatim(~path, ~label="test")
+      false
+    } catch {
+    | _ => true
+    }
+    expect(threw)->toBe(true)
+    rmSync(path, {"recursive": true, "force": true})
+  })
+
+  testSync("throws when the file does not exist", () => {
+    let missing = join2(tmpdir(), "ui-hints-missing-xyz123.json")
+    let threw = try {
+      let _ = Util_StaticBundle.readJsonFileVerbatim(~path=missing, ~label="test")
+      false
+    } catch {
+    | _ => true
+    }
+    expect(threw)->toBe(true)
+  })
+})

package/tests/Util_StaticBundleTest.res.mjs

@@ -143,6 +143,50 @@ globalThis.describe("Util_StaticBundle.walk", () => {
   });
 });
 
+globalThis.describe("Util_StaticBundle.readJsonFileVerbatim", () => {
+  let writeTmp = contents => {
+    let dir = Fs.mkdtempSync(Path.join(Os.tmpdir(), "ui-hints-"));
+    let path = Path.join(dir, "ui-hints.json");
+    Fs.writeFileSync(path, contents);
+    return path;
+  };
+  globalThis.test("returns the file's exact bytes for valid JSON (verbatim, not re-serialised)", () => {
+    let raw = "{\n  \"dashboards\":  [ ] \n}\n";
+    let path = writeTmp(raw);
+    globalThis.expect(Util_StaticBundle$ReventlessAws.readJsonFileVerbatim(path, "test")).toBe(raw);
+    Fs.rmSync(path, {
+      recursive: true,
+      force: true
+    });
+  });
+  globalThis.test("throws on malformed JSON", () => {
+    let path = writeTmp("{ not valid json ");
+    let threw;
+    try {
+      Util_StaticBundle$ReventlessAws.readJsonFileVerbatim(path, "test");
+      threw = false;
+    } catch (exn) {
+      threw = true;
+    }
+    globalThis.expect(threw).toBe(true);
+    Fs.rmSync(path, {
+      recursive: true,
+      force: true
+    });
+  });
+  globalThis.test("throws when the file does not exist", () => {
+    let missing = Path.join(Os.tmpdir(), "ui-hints-missing-xyz123.json");
+    let threw;
+    try {
+      Util_StaticBundle$ReventlessAws.readJsonFileVerbatim(missing, "test");
+      threw = false;
+    } catch (exn) {
+      threw = true;
+    }
+    globalThis.expect(threw).toBe(true);
+  });
+});
+
 export {
   makeFixture,
 }

package/tests/integration/SvsTestSlice_Projection.res

@@ -10,7 +10,7 @@
 open Reventless.Projection
 open SvsTestSlice
 
-let project = event =>
+let project = ({event}: Reventless.StateViewSlice.consumed<consumedEvent>) =>
   switch event {
   | ItemAddedToCart({cartId, productId, qty}) => [
       UpdateMultiState(

package/tests/integration/SvsTestSlice_Projection.res.mjs

@@ -1,7 +1,8 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 
-function project(event) {
+function project(param) {
+  let event = param.event;
   let qty = event.qty;
   let productId = event.productId;
   let cartId = event.cartId;