@reventlessdev/reventless-local 3.0.0-alpha.249 → 3.0.0-alpha.250

package/src/reset/LocalSeedReset.res

@@ -444,11 +444,8 @@ let build = (db, ~root: string, ~scope: scope): plan => {
   // structure mentions, which only a `domain` scope reaches.
   let unattributed = switch scope {
   | OnePlugin(_) =>
-    let claimedByAnyPlugin =
-      plugins->Array.flatMap(p => p.queryables->Array.map(qdbTableName))
-    qdbTables(db)->Array.filter(t =>
-      !isPlatformQdb(t) && !(claimedByAnyPlugin->Array.includes(t))
-    )
+    let claimedByAnyPlugin = plugins->Array.flatMap(p => p.queryables->Array.map(qdbTableName))
+    qdbTables(db)->Array.filter(t => !isPlatformQdb(t) && !(claimedByAnyPlugin->Array.includes(t)))
   | Domain | Platform | Everything => []
   }
 

package/src/test/Mocks/MockDcbEventLogStorage.res

@@ -41,7 +41,11 @@ let matchesQuery = (event: DcbEventLog_Adapter.rawSequencedEvent, query: Reventl
     })
   }
 
-let make = (~name="mock-dcb-log", ~indexes: array<string>=[], ~opts: Pulumi.CustomResourceOptions.t={}) => {
+let make = (
+  ~name="mock-dcb-log",
+  ~indexes: array<string>=[],
+  ~opts: Pulumi.CustomResourceOptions.t={},
+) => {
   let _ = (name, indexes, opts)
   let events: ref<array<DcbEventLog_Adapter.rawSequencedEvent>> = ref([])
   let position = ref(0)

package/src/test/Mocks/MockEventLogStorage.res

@@ -36,15 +36,20 @@ let make = (~name as _="mock-event-log", ~opts as _: Pulumi.CustomResourceOption
 
   let snapshots: dict<ReventlessCore.EventLog.snapshot> = Dict.make()
 
-  let latestSnapshot: ReventlessCore.EventLog.latestSnapshot<string> = async id =>
-    Ok(snapshots->Dict.get(id))
+  let latestSnapshot: ReventlessCore.EventLog.latestSnapshot<string> = async id => Ok(
+    snapshots->Dict.get(id),
+  )
 
   let writeSnapshot: ReventlessCore.EventLog.writeSnapshot<string> = async (id, snap) => {
     snapshots->Dict.set(id, snap)
     Ok()
   }
 
-  let appendStream: ReventlessCore.EventLog.appendStream<string, JSON.t> = (_startingSeqNr, id, stream) =>
+  let appendStream: ReventlessCore.EventLog.appendStream<string, JSON.t> = (
+    _startingSeqNr,
+    id,
+    stream,
+  ) =>
     stream->Stream.runForEach(json =>
       Effect.sync(() => {
         let existing = events.contents->Dict.get(id)->Option.getOr([])

package/src/test/Mocks/MockQueryDbStorage.res

@@ -28,8 +28,9 @@ module Make = (Bus: LocalBus.T) => {
       allItems.contents = store.contents->Dict.valuesToArray->Array.flatMap(v => v)
     }
 
-    let load: QueryDb.load<string, JSON.t> = async id =>
-      Ok(store.contents->Dict.get(id)->Option.getOr([]))
+    let load: QueryDb.load<string, JSON.t> = async id => Ok(
+      store.contents->Dict.get(id)->Option.getOr([]),
+    )
 
     let loadStream: QueryDb.loadStream<string, JSON.t> = id =>
       store.contents->Dict.get(id)->Option.getOr([])->Stream.fromIterable

package/src/test/TestRunner.res

@@ -15,7 +15,7 @@ type mockResult = {
 }
 
 @module("@pulumi/pulumi") @scope("runtime")
-external setMocks: ({"newResource": mockArgs => mockResult, "call": mockArgs => JSON.t}) => unit =
+external setMocks: {"newResource": mockArgs => mockResult, "call": mockArgs => JSON.t} => unit =
   "setMocks"
 
 // Activate Pulumi mock mode. Must be called once before any Platform.Make() or component creation.

package/tests/BakedManifestFilesTest.res

@@ -16,7 +16,6 @@ let keysOf = (config: ReventlessInfra.Platform.bakedManifest) =>
   BakedManifest.files(~config)->Array.map(((key, _)) => key)
 
 describe("BakedManifest.files", () => {
-
   // The regression line: one declaration, one file, under the name every
   // existing deployment's config.json already points at.
   testSync("a declaration with no journeys produces exactly one file", () => {
@@ -39,11 +38,7 @@ describe("BakedManifest.files", () => {
           {group: "Fulfilment", components: [sel("Ordering")], key: "fulfil.json"},
         ],
       }),
-    )->toEqual([
-      "component-manifest.json",
-      "component-manifest-shopper.json",
-      "fulfil.json",
-    ])
+    )->toEqual(["component-manifest.json", "component-manifest-shopper.json", "fulfil.json"])
   })
 
   // A group name is a Cognito identifier and a key is part of a URL, so the
@@ -55,10 +50,12 @@ describe("BakedManifest.files", () => {
   })
 
   testSync("carries each journey's own selections", () => {
-    let files = BakedManifest.files(~config={
-      components: [sel("Catalog")],
-      journeys: [{group: "Fulfilment", components: [sel("Ordering")]}],
-    })
+    let files = BakedManifest.files(
+      ~config={
+        components: [sel("Catalog")],
+        journeys: [{group: "Fulfilment", components: [sel("Ordering")]}],
+      },
+    )
     expect(files->Array.map(((_, sels)) => sels->Array.map(s => s.plugin)))->toEqual([
       ["Catalog"],
       ["Ordering"],

package/tests/LocalEventTapTest.res

@@ -47,8 +47,8 @@ describe("LocalEventTap.settingFromEnv", () => {
   })
 
   testSync("switches the socket off on request", () =>
-    ["off", "false", "none"]->Array.forEach(v =>
-      expect(LocalEventTap.settingFromEnv(~env=envWith(Some(v))))->toEqual(LocalEventTap.Off)
+    ["off", "false", "none"]->Array.forEach(
+      v => expect(LocalEventTap.settingFromEnv(~env=envWith(Some(v))))->toEqual(LocalEventTap.Off),
     )
   )
 })
@@ -113,8 +113,8 @@ describe("LocalEventTap.start", () => {
   // picks, reported only once it is actually bound.
   test("binds an ephemeral port by default and reports the one it got", async () => {
     LocalEventTap.resetForTests()
-    let bound = await Promise.make((resolve, _reject) =>
-      LocalEventTap.start(~env=envWith(None), ~onBound=p => resolve(p), ())
+    let bound = await Promise.make(
+      (resolve, _reject) => LocalEventTap.start(~env=envWith(None), ~onBound=p => resolve(p), ()),
     )
     expect(bound > 0)->toEqual(true)
     // What the registry entry will carry — the real port, not a hoped-for one.
@@ -127,26 +127,31 @@ describe("LocalEventTap.start", () => {
   test("serves the lines it is sent on the port it was named", async () => {
     LocalEventTap.resetForTests()
     let port = 47311
-    let bound = await Promise.make((resolve, _reject) =>
-      LocalEventTap.start(~env=envWith(Some(port->Int.toString)), ~onBound=p => resolve(p), ())
+    let bound = await Promise.make(
+      (resolve, _reject) =>
+        LocalEventTap.start(~env=envWith(Some(port->Int.toString)), ~onBound=p => resolve(p), ()),
     )
     expect(bound)->toEqual(port)
 
-    let received = await Promise.make((resolve, _reject) => {
-      let socket = NodeNet.connect(port, "127.0.0.1", () => ())
-      socket->NodeNet.setEncoding("utf8")
-      socket->NodeNet.onSocketError(e =>
-        resolve("connect failed: " ++ e->JsExn.message->Option.getOr("unknown"))
-      )
-      // Re-sent until it lands: the server's accept and the client's connect are
-      // separate events, so a single broadcast could beat the connection.
-      let ticker = ref(None)
-      socket->NodeNet.onSocketData(chunk => {
-        ticker.contents->Option.forEach(clearInterval)
-        resolve(chunk)
-      })
-      ticker := Some(setInterval(() => LocalEventTap.broadcast(`@@RVLESS_EVT@@ {"seq":7}`), 5))
-    })
+    let received = await Promise.make(
+      (resolve, _reject) => {
+        let socket = NodeNet.connect(port, "127.0.0.1", () => ())
+        socket->NodeNet.setEncoding("utf8")
+        socket->NodeNet.onSocketError(
+          e => resolve("connect failed: " ++ e->JsExn.message->Option.getOr("unknown")),
+        )
+        // Re-sent until it lands: the server's accept and the client's connect are
+        // separate events, so a single broadcast could beat the connection.
+        let ticker = ref(None)
+        socket->NodeNet.onSocketData(
+          chunk => {
+            ticker.contents->Option.forEach(clearInterval)
+            resolve(chunk)
+          },
+        )
+        ticker := Some(setInterval(() => LocalEventTap.broadcast(`@@RVLESS_EVT@@ {"seq":7}`), 5))
+      },
+    )
 
     expect(received)->toEqual(`@@RVLESS_EVT@@ {"seq":7}\n`)
     await LocalEventTap.stopForTests()

package/tests/LocalPlatformStartTest.res

@@ -122,42 +122,47 @@ describe("LocalPlatformStart.orAddressRunning", () => {
 
 describe("LocalPlatformStart.decide", () => {
   testSync("starts where nothing is running", () =>
-    withoutBypass(() =>
-      expect(LocalPlatformStart.decide(~cwd=tempRoot(), ()))->toEqual(LocalPlatformStart.Start)
+    withoutBypass(
+      () =>
+        expect(LocalPlatformStart.decide(~cwd=tempRoot(), ()))->toEqual(LocalPlatformStart.Start),
     )
   )
 
   testSync("addresses the one platform already serving this directory", () =>
-    withoutBypass(() => {
-      let cwd = tempRoot()
-      let _ = writeAt(~cwd, ~port=4000, ~store=sqliteStore(NodePath.join([cwd, "local.db"])))
-
-      switch LocalPlatformStart.decide(~cwd, ()) {
-      | Start => fail("expected the running platform to be addressed")
-      | AlreadyRunning(entries) =>
-        expect(entries->Array.map(e => e.port))->toEqual([4000])
-        let lines = LocalPlatformStart.report(entries)
-        expect(lines->Array.length)->toEqual(2)
-        expect(lines->Array.join("\n")->String.includes(":4000"))->toEqual(true)
-      }
-    })
+    withoutBypass(
+      () => {
+        let cwd = tempRoot()
+        let _ = writeAt(~cwd, ~port=4000, ~store=sqliteStore(NodePath.join([cwd, "local.db"])))
+
+        switch LocalPlatformStart.decide(~cwd, ()) {
+        | Start => fail("expected the running platform to be addressed")
+        | AlreadyRunning(entries) =>
+          expect(entries->Array.map(e => e.port))->toEqual([4000])
+          let lines = LocalPlatformStart.report(entries)
+          expect(lines->Array.length)->toEqual(2)
+          expect(lines->Array.join("\n")->String.includes(":4000"))->toEqual(true)
+        }
+      },
+    )
   )
 
   // The state this is trying to make impossible: say so rather than pick one.
   testSync("names all of them when two are running", () =>
-    withoutBypass(() => {
-      let cwd = tempRoot()
-      let _ = writeAt(~cwd, ~port=4000, ~store=sqliteStore(NodePath.join([cwd, "local.db"])))
-      let _ = writeAt(~cwd, ~port=4010, ~store=memoryStore)
-
-      switch LocalPlatformStart.decide(~cwd, ()) {
-      | Start => fail("expected both running platforms to be reported")
-      | AlreadyRunning(entries) =>
-        let printed = LocalPlatformStart.report(entries)->Array.join("\n")
-        expect(printed->String.includes(":4000"))->toEqual(true)
-        expect(printed->String.includes(":4010"))->toEqual(true)
-      }
-    })
+    withoutBypass(
+      () => {
+        let cwd = tempRoot()
+        let _ = writeAt(~cwd, ~port=4000, ~store=sqliteStore(NodePath.join([cwd, "local.db"])))
+        let _ = writeAt(~cwd, ~port=4010, ~store=memoryStore)
+
+        switch LocalPlatformStart.decide(~cwd, ()) {
+        | Start => fail("expected both running platforms to be reported")
+        | AlreadyRunning(entries) =>
+          let printed = LocalPlatformStart.report(entries)->Array.join("\n")
+          expect(printed->String.includes(":4000"))->toEqual(true)
+          expect(printed->String.includes(":4010"))->toEqual(true)
+        }
+      },
+    )
   )
 
   // The escape hatch the e2e suites and the VS Code runner already take.

package/tests/PluginEventDecodeTest.res

@@ -93,9 +93,9 @@ describe("Platform.decodeUiFragmentRegistryEventEnvelope", () => {
   })
 
   testSync("returns None for malformed input", () => {
-    expect(
-      Platform.decodeUiFragmentRegistryEventEnvelope(JSON.Encode.string("junk")),
-    )->toEqual(None)
+    expect(Platform.decodeUiFragmentRegistryEventEnvelope(JSON.Encode.string("junk")))->toEqual(
+      None,
+    )
     expect(
       Platform.decodeUiFragmentRegistryEventEnvelope(
         JSON.Encode.object(Dict.fromArray([("event", JSON.Encode.object(Dict.make()))])),

package/tests/ShellConfigTest.res

@@ -11,7 +11,7 @@ let _ = TestRunner.setup()
 
 let manifest = (~key: option<string>=?): ReventlessInfra.Platform.bakedManifest => {
   components: [{plugin: "Catalog", views: ["Products"], commands: []}],
-  key: ?key,
+  ?key,
 }
 
 let str = (d: dict<JSON.t>, k: string): option<string> =>
@@ -65,13 +65,14 @@ describe("ShellConfig.overlay", () => {
   // did not write, with nothing in the diff to say so.
   testSync("refuses a shellConfig key the platform computes", () =>
     expect(
-      threw(() =>
-        ShellConfig.overlay(
-          ~bakedManifest=Some(manifest()),
-          ~shellConfig=Some(
-            Dict.fromArray([("manifestUrl", JSON.Encode.string("/elsewhere.json"))]),
-          ),
-        )->ignore
+      threw(
+        () =>
+          ShellConfig.overlay(
+            ~bakedManifest=Some(manifest()),
+            ~shellConfig=Some(
+              Dict.fromArray([("manifestUrl", JSON.Encode.string("/elsewhere.json"))]),
+            ),
+          )->ignore,
       ),
     )->toBe(true)
   )
@@ -107,12 +108,15 @@ describe("ShellConfig.overlay — uiSlotsFile", () => {
 
   testSync("refuses a shellConfig key redirecting the computed module", () =>
     expect(
-      threw(() =>
-        ShellConfig.overlay(
-          ~bakedManifest=None,
-          ~uiSlotsFile="/src/storefront-slots.js",
-          ~shellConfig=Some(Dict.fromArray([("uiSlotsUrl", JSON.Encode.string("/elsewhere.js"))])),
-        )->ignore
+      threw(
+        () =>
+          ShellConfig.overlay(
+            ~bakedManifest=None,
+            ~uiSlotsFile="/src/storefront-slots.js",
+            ~shellConfig=Some(
+              Dict.fromArray([("uiSlotsUrl", JSON.Encode.string("/elsewhere.js"))]),
+            ),
+          )->ignore,
       ),
     )->toBe(true)
   )
@@ -208,7 +212,6 @@ let fulfilment: ReventlessInfra.Platform.bakedJourney = {
 }
 
 describe("ShellConfig.overlay — journeys", () => {
-
   // The regression line. A shell that has never heard of journeys must not
   // suddenly find a key it does not know.
   testSync("a bake declaring no journeys writes no map", () => {
@@ -217,7 +220,10 @@ describe("ShellConfig.overlay — journeys", () => {
   })
 
   testSync("an empty journeys array is the same as none", () => {
-    let out = ShellConfig.overlay(~bakedManifest=Some(withJourneys(~journeys=[])), ~shellConfig=None)
+    let out = ShellConfig.overlay(
+      ~bakedManifest=Some(withJourneys(~journeys=[])),
+      ~shellConfig=None,
+    )
     expect(out->Dict.get("journeyManifestUrls"))->toEqual(None)
   })
 
@@ -250,11 +256,14 @@ describe("ShellConfig.overlay — journeys", () => {
   // `manifestUrl` already carries, extended to the map it now writes beside it.
   testSync("refuses a shellConfig that sets the journey map itself", () =>
     expect(
-      threw(() =>
-        ShellConfig.overlay(
-          ~bakedManifest=Some(withJourneys(~journeys=[shopper])),
-          ~shellConfig=Some(Dict.fromArray([("journeyManifestUrls", JSON.Encode.object(Dict.make()))])),
-        )->ignore
+      threw(
+        () =>
+          ShellConfig.overlay(
+            ~bakedManifest=Some(withJourneys(~journeys=[shopper])),
+            ~shellConfig=Some(
+              Dict.fromArray([("journeyManifestUrls", JSON.Encode.object(Dict.make()))]),
+            ),
+          )->ignore,
       ),
     )->toBe(true)
   )

package/tests/SplitApiFixtures.res

@@ -31,7 +31,9 @@ let extractSdlFieldName = (sdlField: string): string => {
 let adminGraphQL = ReventlessGraphqlServer.GraphQL_ServerInstance.make(~label="GraphQL:Admin")
 
 // Build admin SDL — authoritative source for field names.
-let baseParts = ReventlessCore.GraphQL_Stitcher.decode(ReventlessCore.Platform_AdminApi.baseFragment(~cloner=true))
+let baseParts = ReventlessCore.GraphQL_Stitcher.decode(
+  ReventlessCore.Platform_AdminApi.baseFragment(~cloner=true),
+)
 let () = adminGraphQL.registerTypes(~sdlTypes=baseParts.types)
 
 // Derive query/mutation field names directly from SDL so that any SDL
@@ -45,16 +47,23 @@ let singleQueryField = adminQueryEntry.singleFieldName
 let listQueryField = adminQueryEntry.listFieldName
 
 let adminQueryResolvers = Dict.make()
-let () = adminQueryFieldNames->Array.forEach(field =>
-  adminQueryResolvers->Dict.set(field, async (_root, _args, _ctx): JSON.t => JSON.Encode.null)
-)
+let () =
+  adminQueryFieldNames->Array.forEach(field =>
+    adminQueryResolvers->Dict.set(field, async (_root, _args, _ctx): JSON.t => JSON.Encode.null)
+  )
 let () = adminGraphQL.registerQueries(~sdlFields=baseParts.queries, ~resolvers=adminQueryResolvers)
 
 let adminMutationResolvers = Dict.make()
-let () = adminMutationFieldNames->Array.forEach(field =>
-  adminMutationResolvers->Dict.set(field, async (_root, _args, _ctx): JSON.t => JSON.Encode.string("ok"))
+let () =
+  adminMutationFieldNames->Array.forEach(field =>
+    adminMutationResolvers->Dict.set(field, async (_root, _args, _ctx): JSON.t =>
+      JSON.Encode.string("ok")
+    )
+  )
+let () = adminGraphQL.registerMutations(
+  ~sdlFields=baseParts.mutations,
+  ~resolvers=adminMutationResolvers,
 )
-let () = adminGraphQL.registerMutations(~sdlFields=baseParts.mutations, ~resolvers=adminMutationResolvers)
 
 // ─────────────────────────────────────────────────────────────
 // Register fake plugin schema into the singleton (plugin server)
@@ -66,8 +75,18 @@ let pluginTypes = [`type SplitTestPlugin_SplitTestItem { id: ID!, name: String!
 let () = GraphQL_Server.registerTypes(~sdlTypes=pluginTypes)
 
 let pluginQueryResolvers = Dict.make()
-let () = pluginQueryResolvers->Dict.set("SplitTestPlugin_SplitTestItem", async (_root, _args, _ctx): JSON.t => JSON.Encode.null)
-let () = pluginQueryResolvers->Dict.set("SplitTestPlugin_SplitTestItems", async (_root, _args, _ctx): JSON.t => JSON.Encode.null)
+let () =
+  pluginQueryResolvers->Dict.set("SplitTestPlugin_SplitTestItem", async (
+    _root,
+    _args,
+    _ctx,
+  ): JSON.t => JSON.Encode.null)
+let () =
+  pluginQueryResolvers->Dict.set("SplitTestPlugin_SplitTestItems", async (
+    _root,
+    _args,
+    _ctx,
+  ): JSON.t => JSON.Encode.null)
 let () = GraphQL_Server.registerQueries(
   ~sdlFields=[
     `SplitTestPlugin_SplitTestItem(id: ID!): SplitTestPlugin_SplitTestItem`,
@@ -77,7 +96,12 @@ let () = GraphQL_Server.registerQueries(
 )
 
 let pluginMutationResolvers = Dict.make()
-let () = pluginMutationResolvers->Dict.set("SplitTestPlugin_SplitTestItem_CreateItem", async (_root, _args, _ctx): JSON.t => JSON.Encode.string("ok"))
+let () =
+  pluginMutationResolvers->Dict.set("SplitTestPlugin_SplitTestItem_CreateItem", async (
+    _root,
+    _args,
+    _ctx,
+  ): JSON.t => JSON.Encode.string("ok"))
 let () = GraphQL_Server.registerMutations(
   ~sdlFields=[`SplitTestPlugin_SplitTestItem_CreateItem(id: ID!, name: String!): String`],
   ~resolvers=pluginMutationResolvers,

package/tests/SplitApiTest.res

@@ -25,78 +25,108 @@ let pluginQueryPrefix = "SplitTestPlugin_SplitTestItem"
 
 describe("Split API Mode — Schema Separation", () => {
   describe("Plugin GraphQL singleton", () => {
-    testPromise("contains plugin mutation fields", async () => {
-      let d = GraphQL_Server.diagnostics()
-      let hasPluginMutation =
-        d.registeredMutationFields->Array.some(f => f->String.startsWith(pluginMutationPrefix))
-      expect(hasPluginMutation)->toBe(true)
-    })
+    testPromise(
+      "contains plugin mutation fields",
+      async () => {
+        let d = GraphQL_Server.diagnostics()
+        let hasPluginMutation =
+          d.registeredMutationFields->Array.some(f => f->String.startsWith(pluginMutationPrefix))
+        expect(hasPluginMutation)->toBe(true)
+      },
+    )
 
-    testPromise("contains plugin query fields", async () => {
-      let d = GraphQL_Server.diagnostics()
-      let hasPluginQuery =
-        d.registeredQueryFields->Array.some(f => f->String.startsWith(pluginQueryPrefix))
-      expect(hasPluginQuery)->toBe(true)
-    })
+    testPromise(
+      "contains plugin query fields",
+      async () => {
+        let d = GraphQL_Server.diagnostics()
+        let hasPluginQuery =
+          d.registeredQueryFields->Array.some(f => f->String.startsWith(pluginQueryPrefix))
+        expect(hasPluginQuery)->toBe(true)
+      },
+    )
 
-    testPromise("does NOT contain admin mutation fields", async () => {
-      let d = GraphQL_Server.diagnostics()
-      let hasAdminField =
-        d.registeredMutationFields->Array.some(f =>
-          adminMutationFields->Array.includes(f)
-        )
-      expect(hasAdminField)->toBe(false)
-    })
+    testPromise(
+      "does NOT contain admin mutation fields",
+      async () => {
+        let d = GraphQL_Server.diagnostics()
+        let hasAdminField =
+          d.registeredMutationFields->Array.some(f => adminMutationFields->Array.includes(f))
+        expect(hasAdminField)->toBe(false)
+      },
+    )
 
-    testPromise("does NOT contain admin query fields", async () => {
-      let d = GraphQL_Server.diagnostics()
-      let hasAdminQuery =
-        d.registeredQueryFields->Array.some(f =>
-          adminQueryFields->Array.includes(f)
-        )
-      expect(hasAdminQuery)->toBe(false)
-    })
+    testPromise(
+      "does NOT contain admin query fields",
+      async () => {
+        let d = GraphQL_Server.diagnostics()
+        let hasAdminQuery =
+          d.registeredQueryFields->Array.some(f => adminQueryFields->Array.includes(f))
+        expect(hasAdminQuery)->toBe(false)
+      },
+    )
   })
 
   describe("Admin GraphQL instance", () => {
-    testPromise("contains admin mutation fields", async () => {
-      let d = adminGraphQL.diagnostics()
-      adminMutationFields->Array.forEach(field => {
-        let hasField = d.registeredMutationFields->Array.includes(field)
-        expect(hasField)->toBe(true)
-      })
-    })
+    testPromise(
+      "contains admin mutation fields",
+      async () => {
+        let d = adminGraphQL.diagnostics()
+        adminMutationFields->Array.forEach(
+          field => {
+            let hasField = d.registeredMutationFields->Array.includes(field)
+            expect(hasField)->toBe(true)
+          },
+        )
+      },
+    )
 
-    testPromise("contains admin query fields", async () => {
-      let d = adminGraphQL.diagnostics()
-      adminQueryFields->Array.forEach(field => {
-        let hasField = d.registeredQueryFields->Array.includes(field)
-        expect(hasField)->toBe(true)
-      })
-    })
+    testPromise(
+      "contains admin query fields",
+      async () => {
+        let d = adminGraphQL.diagnostics()
+        adminQueryFields->Array.forEach(
+          field => {
+            let hasField = d.registeredQueryFields->Array.includes(field)
+            expect(hasField)->toBe(true)
+          },
+        )
+      },
+    )
 
-    testPromise("does NOT contain plugin mutation fields", async () => {
-      let d = adminGraphQL.diagnostics()
-      let hasPluginMutation =
-        d.registeredMutationFields->Array.some(f => f->String.startsWith(pluginMutationPrefix))
-      expect(hasPluginMutation)->toBe(false)
-    })
+    testPromise(
+      "does NOT contain plugin mutation fields",
+      async () => {
+        let d = adminGraphQL.diagnostics()
+        let hasPluginMutation =
+          d.registeredMutationFields->Array.some(f => f->String.startsWith(pluginMutationPrefix))
+        expect(hasPluginMutation)->toBe(false)
+      },
+    )
 
-    testPromise("does NOT contain plugin query fields", async () => {
-      let d = adminGraphQL.diagnostics()
-      let hasPluginQuery =
-        d.registeredQueryFields->Array.some(f => f->String.startsWith(pluginQueryPrefix))
-      expect(hasPluginQuery)->toBe(false)
-    })
+    testPromise(
+      "does NOT contain plugin query fields",
+      async () => {
+        let d = adminGraphQL.diagnostics()
+        let hasPluginQuery =
+          d.registeredQueryFields->Array.some(f => f->String.startsWith(pluginQueryPrefix))
+        expect(hasPluginQuery)->toBe(false)
+      },
+    )
 
-    testPromise("has admin type definitions registered", async () => {
-      let d = adminGraphQL.diagnostics()
-      expect(d.typeCount > 0)->toBe(true)
-    })
+    testPromise(
+      "has admin type definitions registered",
+      async () => {
+        let d = adminGraphQL.diagnostics()
+        expect(d.typeCount > 0)->toBe(true)
+      },
+    )
 
-    testPromise("has no SDL mismatches", async () => {
-      let d = adminGraphQL.diagnostics()
-      expect(d.mismatches->Array.length)->toBe(0)
-    })
+    testPromise(
+      "has no SDL mismatches",
+      async () => {
+        let d = adminGraphQL.diagnostics()
+        expect(d.mismatches->Array.length)->toBe(0)
+      },
+    )
   })
 })