@reventlessdev/reventless-aws 3.0.0-alpha.344 → 3.0.0-alpha.345

package/tests/QueryDbResolvers_AppSyncTest.res

@@ -20,21 +20,27 @@ describe("QueryDbResolvers_AppSync.internalRowRequiredAttr", () => {
 })
 
 describe("AppSync_Resolver_Retrying.Functions.listAllItemsConnection", () => {
-  testSync("with ~requireAttribute emits an attribute_exists filter that excludes internal rows", () => {
-    let code =
-      AppSync_Resolver_Retrying.Functions.listAllItemsConnection(
-        ~labelField="name",
-        ~requireAttribute="name",
-      )->codeOf
-    expect(code->String.includes("attribute_exists(#name)"))->toBe(true)
-    expect(code->String.includes("names['#name'] = 'name'"))->toBe(true)
-  })
+  testSync(
+    "with ~requireAttribute emits an attribute_exists filter that excludes internal rows",
+    () => {
+      let code =
+        AppSync_Resolver_Retrying.Functions.listAllItemsConnection(
+          ~labelField="name",
+          ~requireAttribute="name",
+        )->codeOf
+      expect(code->String.includes("attribute_exists(#name)"))->toBe(true)
+      expect(code->String.includes("names['#name'] = 'name'"))->toBe(true)
+    },
+  )
 
-  testSync("without ~requireAttribute emits no attribute_exists filter (default read models unchanged)", () => {
-    let code =
-      AppSync_Resolver_Retrying.Functions.listAllItemsConnection(~labelField="name")->codeOf
-    expect(code->String.includes("attribute_exists"))->toBe(false)
-  })
+  testSync(
+    "without ~requireAttribute emits no attribute_exists filter (default read models unchanged)",
+    () => {
+      let code =
+        AppSync_Resolver_Retrying.Functions.listAllItemsConnection(~labelField="name")->codeOf
+      expect(code->String.includes("attribute_exists"))->toBe(false)
+    },
+  )
 })
 
 // Tripwires for the Scan connection's paging. The behaviour itself is exercised
@@ -56,8 +62,9 @@ describe("listAllItemsConnection — paging", () => {
     expect(
       code->String.includes("parts.length > 0 ? ((_backward ? _upTo : _first + _from) > 1000"),
     )->toBe(true)
-    expect(code->String.includes("const _page = _backward ? _rest : _rest.slice(0, _first);"))
-    ->toBe(true)
+    expect(
+      code->String.includes("const _page = _backward ? _rest : _rest.slice(0, _first);"),
+    )->toBe(true)
     expect(code->String.includes("hasNextPage: _more || !!_next,"))->toBe(true)
   })
 

package/tests/QueryInterceptor_LambdaTest.res

@@ -54,14 +54,12 @@ describe("interceptor handler", () => {
 
   testPromise("an allowing hook is consulted and the read proceeds", async () => {
     let seen = ref([])
-    QueryDb_Callback.registerQueryInterceptor(async (
-      ~identity as _,
-      ~readModelName,
-      ~args as _,
-    ) => {
-      seen := seen.contents->Array.concat([readModelName])
-      QueryDb_Callback.Allow
-    })
+    QueryDb_Callback.registerQueryInterceptor(
+      async (~identity as _, ~readModelName, ~args as _) => {
+        seen := seen.contents->Array.concat([readModelName])
+        QueryDb_Callback.Allow
+      },
+    )
     let allowed = await QueryInterceptor_Lambda.handler(read(~readModelName="Order"), context)
     expect((allowed, seen.contents))->toEqual((true, ["Order"]))
   })
@@ -70,11 +68,11 @@ describe("interceptor handler", () => {
     // The refusal has to surface as a thrown error: the pipeline's response
     // function turns `ctx.error` into a GraphQL field error, and a returned
     // `false` would read as a successful read of nothing.
-    QueryDb_Callback.registerQueryInterceptor(async (
-      ~identity as _,
-      ~readModelName as _,
-      ~args as _,
-    ) => QueryDb_Callback.Deny("over the allowance"))
+    QueryDb_Callback.registerQueryInterceptor(
+      async (~identity as _, ~readModelName as _, ~args as _) => QueryDb_Callback.Deny(
+        "over the allowance",
+      ),
+    )
     let message = try {
       let _ = await QueryInterceptor_Lambda.handler(read(), context)
       "did not throw"

package/tests/ReadModelEntryPoint_OpsTest.res

@@ -18,32 +18,33 @@ describe("ReadModelEntryPoint_Ops.parseHandlerConfig", () => {
   })
 
   testSync("decodes a full entry incl. attribution and Postgres fields", () => {
-    let config = obj([
-      (
-        "handlers",
-        JSON.Encode.array([
-          obj([
-            ("specModule", str("@x/spec/src/ReadModel/Products.res.mjs")),
-            ("mappingsModule", str("@x/spec/src/ReadModel/Products_Projections.res.mjs")),
-            ("queryDbTableName", str("Products-abc")),
-            ("sourceUrn", str("arn:aws:sqs:eu-west-1:1:q")),
-            ("comp", str("EventCollector(ProductsEC)")),
-            ("plugin", str("Catalog")),
-            ("stateTopicName", str("catalogProducts")),
-            (
-              "pgConnection",
-              obj([
-                ("host", str("db.local")),
-                ("port", JSON.Encode.int(5432)),
-                ("database", str("app")),
-                ("username", str("master")),
-                ("secretArn", str("arn:secret")),
-              ]),
-            ),
+    let config =
+      obj([
+        (
+          "handlers",
+          JSON.Encode.array([
+            obj([
+              ("specModule", str("@x/spec/src/ReadModel/Products.res.mjs")),
+              ("mappingsModule", str("@x/spec/src/ReadModel/Products_Projections.res.mjs")),
+              ("queryDbTableName", str("Products-abc")),
+              ("sourceUrn", str("arn:aws:sqs:eu-west-1:1:q")),
+              ("comp", str("EventCollector(ProductsEC)")),
+              ("plugin", str("Catalog")),
+              ("stateTopicName", str("catalogProducts")),
+              (
+                "pgConnection",
+                obj([
+                  ("host", str("db.local")),
+                  ("port", JSON.Encode.int(5432)),
+                  ("database", str("app")),
+                  ("username", str("master")),
+                  ("secretArn", str("arn:secret")),
+                ]),
+              ),
+            ]),
           ]),
-        ]),
-      ),
-    ])->JSON.stringify
+        ),
+      ])->JSON.stringify
     let entries = ReadModelEntryPoint_Ops.parseHandlerConfig(config)
     expect(entries->Array.length)->toBe(1)
     let e = entries->Array.getUnsafe(0)
@@ -65,20 +66,21 @@ describe("ReadModelEntryPoint_Ops.parseHandlerConfig", () => {
   })
 
   testSync("optional fields default to None; null pgConnection maps to None", () => {
-    let config = obj([
-      (
-        "handlers",
-        JSON.Encode.array([
-          obj([
-            ("specModule", str("a.res.mjs")),
-            ("mappingsModule", str("b.res.mjs")),
-            ("queryDbTableName", str("t")),
-            ("sourceUrn", str("u")),
-            ("pgConnection", JSON.Null),
+    let config =
+      obj([
+        (
+          "handlers",
+          JSON.Encode.array([
+            obj([
+              ("specModule", str("a.res.mjs")),
+              ("mappingsModule", str("b.res.mjs")),
+              ("queryDbTableName", str("t")),
+              ("sourceUrn", str("u")),
+              ("pgConnection", JSON.Null),
+            ]),
           ]),
-        ]),
-      ),
-    ])->JSON.stringify
+        ),
+      ])->JSON.stringify
     let e = ReadModelEntryPoint_Ops.parseHandlerConfig(config)->Array.getUnsafe(0)
     expect(e.comp->Option.isNone)->toBe(true)
     expect(e.plugin->Option.isNone)->toBe(true)
@@ -99,9 +101,9 @@ describe("ReadModelEntryPoint_Ops.injectId", () => {
 
   testSync("passes non-object states through unchanged", () => {
     expect(ReadModelEntryPoint_Ops.injectId("p-1", str("scalar")))->toEqual(str("scalar"))
-    expect(
-      ReadModelEntryPoint_Ops.injectId("p-1", JSON.Encode.array([str("a")])),
-    )->toEqual(JSON.Encode.array([str("a")]))
+    expect(ReadModelEntryPoint_Ops.injectId("p-1", JSON.Encode.array([str("a")])))->toEqual(
+      JSON.Encode.array([str("a")]),
+    )
     expect(ReadModelEntryPoint_Ops.injectId("p-1", JSON.Null))->toEqual(JSON.Null)
   })
 })

package/tests/RuntimeExtensionEntryPoint_OpsTest.res

@@ -99,9 +99,10 @@ describe("RuntimeExtensionEntryPoint_Ops.fire", () => {
     // ComponentType and the layer's. Firing under a guessed kind would silently
     // attach a kind-routing extension to the wrong runtime.
     let seen: array<string> = []
-    let config = RuntimeExtensionEntryPoint_Ops.parseConfig(
-      Some(`{"modules":["a"],"runtimeKind":"SomethingNewer","component":"X"}`),
-    )->Option.getOrThrow
+    let config =
+      RuntimeExtensionEntryPoint_Ops.parseConfig(
+        Some(`{"modules":["a"],"runtimeKind":"SomethingNewer","component":"X"}`),
+      )->Option.getOrThrow
 
     RuntimeExtensionEntryPoint_Ops.fire(config, [recordingHook("tracing", seen)])
 

package/tests/SideEffectEntryPoint_OpsTest.res

@@ -16,23 +16,27 @@ describe("SideEffectEntryPoint_Ops.parseHandlerConfig", () => {
   })
 
   testSync("decodes handlers incl. attribution fields", () => {
-    let config = obj([
-      (
-        "handlers",
-        JSON.Encode.array([
-          obj([
-            ("sideEffectModules", JSON.Encode.array([str("@x/p/src/A.res.mjs"), str("@x/p/src/B.res.mjs")])),
-            ("sourceUrn", str("arn:stream-1")),
-            ("comp", str("SideEffectHandler(Mailer)")),
-            ("plugin", str("Ordering")),
+    let config =
+      obj([
+        (
+          "handlers",
+          JSON.Encode.array([
+            obj([
+              (
+                "sideEffectModules",
+                JSON.Encode.array([str("@x/p/src/A.res.mjs"), str("@x/p/src/B.res.mjs")]),
+              ),
+              ("sourceUrn", str("arn:stream-1")),
+              ("comp", str("SideEffectHandler(Mailer)")),
+              ("plugin", str("Ordering")),
+            ]),
+            obj([
+              ("sideEffectModules", JSON.Encode.array([str("@x/p/src/C.res.mjs")])),
+              ("sourceUrn", str("arn:stream-2")),
+            ]),
           ]),
-          obj([
-            ("sideEffectModules", JSON.Encode.array([str("@x/p/src/C.res.mjs")])),
-            ("sourceUrn", str("arn:stream-2")),
-          ]),
-        ]),
-      ),
-    ])->JSON.stringify
+        ),
+      ])->JSON.stringify
     let entries = SideEffectEntryPoint_Ops.parseHandlerConfig(config)
     expect(entries->Array.length)->toBe(2)
     let first = entries->Array.getUnsafe(0)
@@ -70,8 +74,9 @@ describe("SideEffectEntryPoint_Ops.makeRegisteredHandler", () => {
       comp: Some("SideEffectHandler(Mailer)"),
       plugin: Some("Ordering"),
     }
-    let registered = SideEffectEntryPoint_Ops.makeRegisteredHandler(entry, _stream =>
-      Effect.succeed()
+    let registered = SideEffectEntryPoint_Ops.makeRegisteredHandler(
+      entry,
+      _stream => Effect.succeed(),
     )
     expect(registered.comp)->toEqual(Some("SideEffectHandler(Mailer)"))
     expect(registered.plugin)->toEqual(Some("Ordering"))

package/tests/StateChangeDescriptorParityTest.res

@@ -30,16 +30,17 @@ describe("state-change descriptor parity", () => {
     let cases = await buildAll()
     // A silent zero-case run would pass while asserting nothing.
     expect(cases->Array.length)->toBe(11)
-    cases->Array.forEach(c => {
-      expect((c.name, c.relay))->toEqual((c.name, c.local))
-      expect((c.name, c.postgres))->toEqual((c.name, c.local))
-    })
+    cases->Array.forEach(
+      c => {
+        expect((c.name, c.relay))->toEqual((c.name, c.local))
+        expect((c.name, c.postgres))->toEqual((c.name, c.local))
+      },
+    )
   })
 
   testAsync("a save carries the row, a delete carries none", async () => {
     let cases = await buildAll()
-    let stateOf = (d: JSON.t) =>
-      d->JSON.Decode.object->Option.flatMap(o => o->Dict.get("state"))
+    let stateOf = (d: JSON.t) => d->JSON.Decode.object->Option.flatMap(o => o->Dict.get("state"))
     let byName = name => cases->Array.find(c => c.name == name)
 
     switch byName("single-key save with updatedAt") {
@@ -102,26 +103,27 @@ describe("state-change descriptor parity", () => {
     [
       "row in the first retired state degrades to metadata only",
       "row in the second retired state degrades to metadata only",
-    ]->Array.forEach(name =>
-      switch byName(name) {
-      | Some(c) =>
-        expect((name, keyOf(c.local, "state"), keyOf(c.local, "sortKeyValue")))->toEqual((
-          name,
-          None,
-          None,
-        ))
-        expect((name, keyOf(c.relay, "state"), keyOf(c.relay, "sortKeyValue")))->toEqual((
-          name,
-          None,
-          None,
-        ))
-        expect((name, keyOf(c.postgres, "state"), keyOf(c.postgres, "sortKeyValue")))->toEqual((
-          name,
-          None,
-          None,
-        ))
-      | None => expect(name ++ " missing")->toBe("present")
-      }
+    ]->Array.forEach(
+      name =>
+        switch byName(name) {
+        | Some(c) =>
+          expect((name, keyOf(c.local, "state"), keyOf(c.local, "sortKeyValue")))->toEqual((
+            name,
+            None,
+            None,
+          ))
+          expect((name, keyOf(c.relay, "state"), keyOf(c.relay, "sortKeyValue")))->toEqual((
+            name,
+            None,
+            None,
+          ))
+          expect((name, keyOf(c.postgres, "state"), keyOf(c.postgres, "sortKeyValue")))->toEqual((
+            name,
+            None,
+            None,
+          ))
+        | None => expect(name ++ " missing")->toBe("present")
+        },
     )
 
     // The control for the state form: a live state on the same lifecycle, so an

package/tests/StateTopicKeySchemaTest.res

@@ -16,32 +16,35 @@ let capture = f =>
 
 describe("StateTopic_AppSync_Helpers.checkPartitionKeyName", () => {
   testSync("accepts the framework convention", () => {
-    let thrown = capture(() =>
-      StateTopic_AppSync_Helpers.checkPartitionKeyName(
-        ~tableName="PlatformUsageLedger-1a2b3c4",
-        ~partitionKeyName="id",
-      )
+    let thrown = capture(
+      () =>
+        StateTopic_AppSync_Helpers.checkPartitionKeyName(
+          ~tableName="PlatformUsageLedger-1a2b3c4",
+          ~partitionKeyName="id",
+        ),
     )
     expect(thrown)->toEqual(None)
   })
 
   testSync("rejects a table keyed on anything else", () => {
-    let thrown = capture(() =>
-      StateTopic_AppSync_Helpers.checkPartitionKeyName(
-        ~tableName="PlatformUsageLedger-1a2b3c4",
-        ~partitionKeyName="pluginId",
-      )
+    let thrown = capture(
+      () =>
+        StateTopic_AppSync_Helpers.checkPartitionKeyName(
+          ~tableName="PlatformUsageLedger-1a2b3c4",
+          ~partitionKeyName="pluginId",
+        ),
     )
     expect(thrown->Option.isSome)->toBe(true)
   })
 
   testSync("names the table and its actual key in the message", () => {
     let message =
-      capture(() =>
-        StateTopic_AppSync_Helpers.checkPartitionKeyName(
-          ~tableName="PlatformUsageLedger-1a2b3c4",
-          ~partitionKeyName="pluginId",
-        )
+      capture(
+        () =>
+          StateTopic_AppSync_Helpers.checkPartitionKeyName(
+            ~tableName="PlatformUsageLedger-1a2b3c4",
+            ~partitionKeyName="pluginId",
+          ),
       )->Option.getOr("")
     expect(message->String.includes("PlatformUsageLedger-1a2b3c4"))->toBe(true)
     expect(message->String.includes("pluginId"))->toBe(true)

package/tests/StateViewSliceEntryPoint_OpsTest.res

@@ -33,34 +33,39 @@ describe("StateViewSliceEntryPoint_Ops.parseHandlerConfig", () => {
   })
 
   testSync("expands compact-v2 entries against shared base/sourceUrn/pgConnection", () => {
-    let config = obj([
-      ("v", JSON.Encode.int(2)),
-      ("base", str("@x/plugin/src/StateViewSlice/")),
-      ("sourceUrn", str("arn:shared")),
-      (
-        "pgConnection",
-        obj([
-          ("host", str("db.local")),
-          ("port", JSON.Encode.int(5432)),
-          ("database", str("app")),
-          ("username", str("master")),
-          ("secretArn", str("arn:secret")),
-        ]),
-      ),
-      (
-        "handlers",
-        JSON.Encode.array([
-          obj([("s", str("Carts.res.mjs")), ("p", str("Carts_Projection.res.mjs")), ("q", str("qdb_Carts"))]),
+    let config =
+      obj([
+        ("v", JSON.Encode.int(2)),
+        ("base", str("@x/plugin/src/StateViewSlice/")),
+        ("sourceUrn", str("arn:shared")),
+        (
+          "pgConnection",
           obj([
-            ("s", str("Totals.res.mjs")),
-            ("p", str("Totals_Projection.res.mjs")),
-            ("q", str("qdb_Totals")),
-            ("u", str("arn:override")),
-            ("t", str("cartTotals")),
+            ("host", str("db.local")),
+            ("port", JSON.Encode.int(5432)),
+            ("database", str("app")),
+            ("username", str("master")),
+            ("secretArn", str("arn:secret")),
           ]),
-        ]),
-      ),
-    ])->JSON.stringify
+        ),
+        (
+          "handlers",
+          JSON.Encode.array([
+            obj([
+              ("s", str("Carts.res.mjs")),
+              ("p", str("Carts_Projection.res.mjs")),
+              ("q", str("qdb_Carts")),
+            ]),
+            obj([
+              ("s", str("Totals.res.mjs")),
+              ("p", str("Totals_Projection.res.mjs")),
+              ("q", str("qdb_Totals")),
+              ("u", str("arn:override")),
+              ("t", str("cartTotals")),
+            ]),
+          ]),
+        ),
+      ])->JSON.stringify
     let entries = StateViewSliceEntryPoint_Ops.parseHandlerConfig(config)
     expect(entries->Array.length)->toBe(2)
     let first = entries->Array.getUnsafe(0)
@@ -76,21 +81,22 @@ describe("StateViewSliceEntryPoint_Ops.parseHandlerConfig", () => {
   })
 
   testSync("passes legacy full-key entries through with per-entry fields", () => {
-    let config = obj([
-      ("base", str("ignored/")),
-      ("sourceUrn", str("arn:shared")),
-      (
-        "handlers",
-        JSON.Encode.array([
-          obj([
-            ("specModule", str("full/Carts.res.mjs")),
-            ("projectionModule", str("full/Carts_Projection.res.mjs")),
-            ("queryDbTableName", str("qdb_Carts")),
-            ("sourceUrn", str("arn:own")),
+    let config =
+      obj([
+        ("base", str("ignored/")),
+        ("sourceUrn", str("arn:shared")),
+        (
+          "handlers",
+          JSON.Encode.array([
+            obj([
+              ("specModule", str("full/Carts.res.mjs")),
+              ("projectionModule", str("full/Carts_Projection.res.mjs")),
+              ("queryDbTableName", str("qdb_Carts")),
+              ("sourceUrn", str("arn:own")),
+            ]),
           ]),
-        ]),
-      ),
-    ])->JSON.stringify
+        ),
+      ])->JSON.stringify
     let e = StateViewSliceEntryPoint_Ops.parseHandlerConfig(config)->Array.getUnsafe(0)
     // Legacy entries are NOT base-prefixed and keep their own sourceUrn.
     expect(e.specModule)->toBe("full/Carts.res.mjs")
@@ -142,9 +148,9 @@ describe("StateViewSliceEntryPoint_Ops.makeJsonEventsHandler", () => {
 
   // String-typed consumed events keep the pipeline test independent of any
   // real slice: each event value becomes the row id, `recordedAt` the state.
-  let project = (
-    {event, recordedAt, _}: Reventless.StateViewSlice.consumed<string>,
-  ): array<Reventless.Projection.action<string, JSON.t>> => [Set(event, str(recordedAt))]
+  let project = ({event, recordedAt, _}: Reventless.StateViewSlice.consumed<string>): array<
+    Reventless.Projection.action<string, JSON.t>,
+  > => [Set(event, str(recordedAt))]
 
   test("decodes envelopes, projects, and runs actions against the ops", async () => {
     let saved = []
@@ -205,7 +211,12 @@ describe("StateViewSliceEntryPoint_Ops.makeJsonEventsHandler", () => {
         "row-1",
         obj([
           ("lifecycle", str("Placed")),
-          ("trail", JSON.Encode.array([obj([("state", str("Placed")), ("at", str("2026-03-02T09:00:00Z"))])])),
+          (
+            "trail",
+            JSON.Encode.array([
+              obj([("state", str("Placed")), ("at", str("2026-03-02T09:00:00Z"))]),
+            ]),
+          ),
         ]),
       ),
     ])

package/tests/TaskBucketEntryPoint_OpsTest.res

@@ -11,7 +11,6 @@ open JestGlobals
 let str = JSON.Encode.string
 let obj = pairs => JSON.Encode.object(Dict.fromArray(pairs))
 
-
 describe("TaskBucketEntryPoint_Ops.parseHandlerConfig", () => {
   testSync("empty raw config decodes to empty defaults", () => {
     let c = TaskBucketEntryPoint_Ops.parseHandlerConfig("")
@@ -21,18 +20,19 @@ describe("TaskBucketEntryPoint_Ops.parseHandlerConfig", () => {
   })
 
   testSync("decodes callbackModule, publishToAggregates, and scheduler env names", () => {
-    let config = obj([
-      ("callbackModule", str("@x/plugin/src/Task/ImportCatalog.res.mjs")),
-      ("publishToAggregates", obj([("Product", str("PTA_Product_QUEUE_URL"))])),
-      (
-        "scheduler",
-        obj([
-          ("roleArnEnv", str("SCHEDULER_ROLE_ARN")),
-          ("targetArnEnv", str("SCHEDULER_TARGET_ARN")),
-          ("targetNameEnv", str("SCHEDULER_TARGET_NAME")),
-        ]),
-      ),
-    ])->JSON.stringify
+    let config =
+      obj([
+        ("callbackModule", str("@x/plugin/src/Task/ImportCatalog.res.mjs")),
+        ("publishToAggregates", obj([("Product", str("PTA_Product_QUEUE_URL"))])),
+        (
+          "scheduler",
+          obj([
+            ("roleArnEnv", str("SCHEDULER_ROLE_ARN")),
+            ("targetArnEnv", str("SCHEDULER_TARGET_ARN")),
+            ("targetNameEnv", str("SCHEDULER_TARGET_NAME")),
+          ]),
+        ),
+      ])->JSON.stringify
     let c = TaskBucketEntryPoint_Ops.parseHandlerConfig(config)
     expect(c.callbackModule)->toBe("@x/plugin/src/Task/ImportCatalog.res.mjs")
     expect(c.publishToAggregates->Dict.get("Product"))->toEqual(Some("PTA_Product_QUEUE_URL"))

package/tests/Upload_ClaimTest.res

@@ -29,9 +29,9 @@ describe("Upload_Claim_S3_Ops.tableNameFromEventSourceArn", () => {
   )
 
   testSync("returns None for an ARN that is not a table stream", () =>
-    expect(Ops.tableNameFromEventSourceArn("arn:aws:sqs:eu-west-1:123456789012:SomeQueue"))->toEqual(
-      None,
-    )
+    expect(
+      Ops.tableNameFromEventSourceArn("arn:aws:sqs:eu-west-1:123456789012:SomeQueue"),
+    )->toEqual(None)
   )
 })
 

package/tests/Util_AwsErrorTest.res

@@ -52,9 +52,7 @@ describe("Util_AwsError.isNotFound", () => {
   // the original guard tested, and it is false for the real error.
   testSync("...and its message does not carry the code, which is why", () =>
     expect(
-      AwsError.describe(dynamoNotFound)->String.includes(
-        "Requested resource not found",
-      ),
+      AwsError.describe(dynamoNotFound)->String.includes("Requested resource not found"),
     )->toBe(true)
   )
 
@@ -118,10 +116,9 @@ describe("Util_AwsError.describe", () => {
   // failure with another.
   testSync("every shape yields something an operator can read", () =>
     expect(
-      [
-        awsError(~name="X", ~message="y"),
-        Not_found,
-      ]->Array.every(e => AwsError.describe(e)->String.length > 0),
+      [awsError(~name="X", ~message="y"), Not_found]->Array.every(
+        e => AwsError.describe(e)->String.length > 0,
+      ),
     )->toBe(true)
   )
 })

package/tests/Util_BundleDependencyClosureTest.res

@@ -62,8 +62,17 @@ export const rule = () => Rules.check();
     ),
   ],
 )
-let _ = writePkg(~root=rulesRoot, ~name=rulesName, [("src/Rules.res.mjs", `export const check = () => true;
-`)])
+let _ = writePkg(
+  ~root=rulesRoot,
+  ~name=rulesName,
+  [
+    (
+      "src/Rules.res.mjs",
+      `export const check = () => true;
+`,
+    ),
+  ],
+)
 
 let closureOf = (packageDirs: dict<string>) => {
   Util_Bundle.addImportedPackageClosure(packageDirs)
@@ -130,7 +139,10 @@ describe("Util_Bundle — bundled user packages carry their imports", () => {
     // Walking reventless-aws would reach its deploy-time-only imports (the
     // @pulumi bindings) and add tens of megabytes to every archive.
     let packageDirs = Dict.fromArray([
-      ("@reventlessdev/reventless-aws", Util_Bundle.resolvePackageRoot("@reventlessdev/reventless-aws")),
+      (
+        "@reventlessdev/reventless-aws",
+        Util_Bundle.resolvePackageRoot("@reventlessdev/reventless-aws"),
+      ),
     ])
     expect(closureOf(packageDirs)->Dict.keysToArray->Array.length)->toBe(1)
   })