@reventlessdev/reventless-core 3.0.0-alpha.259 → 3.0.0-alpha.261

package/tests/IdentityTest.res

@@ -1,19 +1,27 @@
 open JestGlobals
 
-
 describe("Identity", () => {
   describe("anonymous", () => {
-    testSync("has userId 'anonymous'", () => {
-      expect(Reventless.Identity.anonymous.userId)->toBe("anonymous")
-    })
-
-    testSync("has empty groups", () => {
-      expect(Reventless.Identity.anonymous.groups)->toEqual([])
-    })
-
-    testSync("has InMemory provider", () => {
-      expect(Reventless.Identity.anonymous.provider)->toEqual(Reventless.Identity.InMemory)
-    })
+    testSync(
+      "has userId 'anonymous'",
+      () => {
+        expect(Reventless.Identity.anonymous.userId)->toBe("anonymous")
+      },
+    )
+
+    testSync(
+      "has empty groups",
+      () => {
+        expect(Reventless.Identity.anonymous.groups)->toEqual([])
+      },
+    )
+
+    testSync(
+      "has InMemory provider",
+      () => {
+        expect(Reventless.Identity.anonymous.provider)->toEqual(Reventless.Identity.InMemory)
+      },
+    )
   })
 
   describe("hasGroup", () => {
@@ -24,13 +32,19 @@ describe("Identity", () => {
       provider: Cognito,
     }
 
-    testSync("returns true when group is present", () => {
-      expect(Reventless.Identity.hasGroup(identity, "admin"))->toBe(true)
-    })
-
-    testSync("returns false when group is absent", () => {
-      expect(Reventless.Identity.hasGroup(identity, "viewers"))->toBe(false)
-    })
+    testSync(
+      "returns true when group is present",
+      () => {
+        expect(Reventless.Identity.hasGroup(identity, "admin"))->toBe(true)
+      },
+    )
+
+    testSync(
+      "returns false when group is absent",
+      () => {
+        expect(Reventless.Identity.hasGroup(identity, "viewers"))->toBe(false)
+      },
+    )
   })
 
   describe("getClaim", () => {
@@ -42,113 +56,152 @@ describe("Identity", () => {
       provider: InMemory,
     }
 
-    testSync("returns Some for existing claim", () => {
-      expect(Reventless.Identity.getClaim(identity, "tenant"))->toEqual(Some("acme"))
-    })
-
-    testSync("returns None for missing claim", () => {
-      expect(Reventless.Identity.getClaim(identity, "missing"))->toEqual(None)
-    })
-
-    testSync("returns None when claims are absent", () => {
-      let noClaims: Reventless.Identity.t = {
-        userId: "user-2",
-        username: "bob",
-        groups: [],
-        provider: InMemory,
-      }
-      expect(Reventless.Identity.getClaim(noClaims, "tenant"))->toEqual(None)
-    })
+    testSync(
+      "returns Some for existing claim",
+      () => {
+        expect(Reventless.Identity.getClaim(identity, "tenant"))->toEqual(Some("acme"))
+      },
+    )
+
+    testSync(
+      "returns None for missing claim",
+      () => {
+        expect(Reventless.Identity.getClaim(identity, "missing"))->toEqual(None)
+      },
+    )
+
+    testSync(
+      "returns None when claims are absent",
+      () => {
+        let noClaims: Reventless.Identity.t = {
+          userId: "user-2",
+          username: "bob",
+          groups: [],
+          provider: InMemory,
+        }
+        expect(Reventless.Identity.getClaim(noClaims, "tenant"))->toEqual(None)
+      },
+    )
   })
 
   describe("schema roundtrip", () => {
-    testSync("encode then decode preserves identity", () => {
-      let identity: Reventless.Identity.t = {
-        userId: "user-1",
-        username: "alice",
-        groups: ["admin"],
-        claims: Dict.fromArray([("tenant", "acme")]),
-        provider: Cognito,
-      }
-      let json = identity->Reventless.Util_Sury.toJson(Reventless.Identity.schema)
-      let decoded = json->Reventless.Util_Sury.fromJson(Reventless.Identity.schema)
-      expect(decoded)->toEqual(identity)
-    })
-
-    testSync("roundtrip with Custom provider", () => {
-      let identity: Reventless.Identity.t = {
-        userId: "ext-1",
-        username: "external",
-        groups: [],
-        provider: Custom("oauth2"),
-      }
-      let json = identity->Reventless.Util_Sury.toJson(Reventless.Identity.schema)
-      let decoded = json->Reventless.Util_Sury.fromJson(Reventless.Identity.schema)
-      expect(decoded)->toEqual(identity)
-    })
-
-    testSync("roundtrip without optional claims", () => {
-      let identity: Reventless.Identity.t = {
-        userId: "user-3",
-        username: "charlie",
-        groups: [],
-        provider: InMemory,
-      }
-      let json = identity->Reventless.Util_Sury.toJson(Reventless.Identity.schema)
-      let decoded = json->Reventless.Util_Sury.fromJson(Reventless.Identity.schema)
-      expect(decoded.userId)->toBe("user-3")->ignore
-      expect(decoded.provider)->toEqual(Reventless.Identity.InMemory)
-    })
+    testSync(
+      "encode then decode preserves identity",
+      () => {
+        let identity: Reventless.Identity.t = {
+          userId: "user-1",
+          username: "alice",
+          groups: ["admin"],
+          claims: Dict.fromArray([("tenant", "acme")]),
+          provider: Cognito,
+        }
+        let json = identity->Reventless.Util_Sury.toJson(Reventless.Identity.schema)
+        let decoded = json->Reventless.Util_Sury.fromJson(Reventless.Identity.schema)
+        expect(decoded)->toEqual(identity)
+      },
+    )
+
+    testSync(
+      "roundtrip with Custom provider",
+      () => {
+        let identity: Reventless.Identity.t = {
+          userId: "ext-1",
+          username: "external",
+          groups: [],
+          provider: Custom("oauth2"),
+        }
+        let json = identity->Reventless.Util_Sury.toJson(Reventless.Identity.schema)
+        let decoded = json->Reventless.Util_Sury.fromJson(Reventless.Identity.schema)
+        expect(decoded)->toEqual(identity)
+      },
+    )
+
+    testSync(
+      "roundtrip without optional claims",
+      () => {
+        let identity: Reventless.Identity.t = {
+          userId: "user-3",
+          username: "charlie",
+          groups: [],
+          provider: InMemory,
+        }
+        let json = identity->Reventless.Util_Sury.toJson(Reventless.Identity.schema)
+        let decoded = json->Reventless.Util_Sury.fromJson(Reventless.Identity.schema)
+        expect(decoded.userId)->toBe("user-3")->ignore
+        expect(decoded.provider)->toEqual(Reventless.Identity.InMemory)
+      },
+    )
   })
 })
 
 describe("RequestContext", () => {
   describe("test() constructor", () => {
-    testSync("defaults to anonymous identity", () => {
-      let ctx = RequestContext.test()
-      expect(ctx.identity.userId)->toBe("anonymous")
-    })
-
-    testSync("accepts custom identity", () => {
-      let identity: Reventless.Identity.t = {
-        userId: "user-1",
-        username: "alice",
-        groups: ["admin"],
-        provider: Cognito,
-      }
-      let ctx = RequestContext.test(~identity)
-      expect(ctx.identity.userId)->toBe("user-1")
-    })
-
-    testSync("defaults to empty claims", () => {
-      let ctx = RequestContext.test()
-      expect(ctx.claims->Dict.keysToArray)->toEqual([])
-    })
+    testSync(
+      "defaults to anonymous identity",
+      () => {
+        let ctx = RequestContext.test()
+        expect(ctx.identity.userId)->toBe("anonymous")
+      },
+    )
+
+    testSync(
+      "accepts custom identity",
+      () => {
+        let identity: Reventless.Identity.t = {
+          userId: "user-1",
+          username: "alice",
+          groups: ["admin"],
+          provider: Cognito,
+        }
+        let ctx = RequestContext.test(~identity)
+        expect(ctx.identity.userId)->toBe("user-1")
+      },
+    )
+
+    testSync(
+      "defaults to empty claims",
+      () => {
+        let ctx = RequestContext.test()
+        expect(ctx.claims->Dict.keysToArray)->toEqual([])
+      },
+    )
   })
 
   describe("getClaim", () => {
-    testSync("returns claim value when present", () => {
-      let ctx = RequestContext.test(~claims=Dict.fromArray([("tenant", "acme")]))
-      expect(RequestContext.getClaim(ctx, "tenant"))->toEqual(Some("acme"))
-    })
-
-    testSync("returns None when absent", () => {
-      let ctx = RequestContext.test()
-      expect(RequestContext.getClaim(ctx, "missing"))->toEqual(None)
-    })
+    testSync(
+      "returns claim value when present",
+      () => {
+        let ctx = RequestContext.test(~claims=Dict.fromArray([("tenant", "acme")]))
+        expect(RequestContext.getClaim(ctx, "tenant"))->toEqual(Some("acme"))
+      },
+    )
+
+    testSync(
+      "returns None when absent",
+      () => {
+        let ctx = RequestContext.test()
+        expect(RequestContext.getClaim(ctx, "missing"))->toEqual(None)
+      },
+    )
   })
 
   describe("withClaim", () => {
-    testSync("adds a claim to the context", () => {
-      let ctx = RequestContext.test()
-      let updated = RequestContext.withClaim(ctx, "tenant", "acme")
-      expect(RequestContext.getClaim(updated, "tenant"))->toEqual(Some("acme"))
-    })
-
-    testSync("does not mutate the original context", () => {
-      let ctx = RequestContext.test()
-      let _updated = RequestContext.withClaim(ctx, "tenant", "acme")
-      expect(RequestContext.getClaim(ctx, "tenant"))->toEqual(None)
-    })
+    testSync(
+      "adds a claim to the context",
+      () => {
+        let ctx = RequestContext.test()
+        let updated = RequestContext.withClaim(ctx, "tenant", "acme")
+        expect(RequestContext.getClaim(updated, "tenant"))->toEqual(Some("acme"))
+      },
+    )
+
+    testSync(
+      "does not mutate the original context",
+      () => {
+        let ctx = RequestContext.test()
+        let _updated = RequestContext.withClaim(ctx, "tenant", "acme")
+        expect(RequestContext.getClaim(ctx, "tenant"))->toEqual(None)
+      },
+    )
   })
 })

package/tests/ResourceAttributionTest.res

@@ -104,15 +104,15 @@ describe("ResourceAttribution — carrying the context into deferred work", () =
   testSync("two plugins deferred from one apply are each attributed to themselves", () => {
     let outer = Attribution.enter(~platform="online-shop", ~plugin="Catalog")
     let catalogSaw = ref(None)
-    let catalogFinish = Attribution.deferred(() =>
-      catalogSaw := Attribution.current.contents.plugin
+    let catalogFinish = Attribution.deferred(
+      () => catalogSaw := Attribution.current.contents.plugin,
     )
     Attribution.restore(outer)
 
     let previous = Attribution.enter(~platform="online-shop", ~plugin="Ordering")
     let orderingSaw = ref(None)
-    let orderingFinish = Attribution.deferred(() =>
-      orderingSaw := Attribution.current.contents.plugin
+    let orderingFinish = Attribution.deferred(
+      () => orderingSaw := Attribution.current.contents.plugin,
     )
     Attribution.restore(previous)
 
@@ -126,8 +126,8 @@ describe("ResourceAttribution — carrying the context into deferred work", () =
 
   testSync("a throwing callback still puts the context back", () => {
     let previous = Attribution.enter(~platform="online-shop", ~plugin="Catalog")
-    let finish: unit => unit = Attribution.deferred(() =>
-      JsError.throwWithMessage("finish blew up")
+    let finish: unit => unit = Attribution.deferred(
+      () => JsError.throwWithMessage("finish blew up"),
     )
     Attribution.restore(previous)
 
@@ -164,22 +164,25 @@ describe("ResourceAttribution — carrying the context into deferred work", () =
 // exercises the production choke point: a task side-effect handler registered
 // during construct, then run the way `finishTasks` runs it — from an apply,
 // with nothing attributed.
-describe("Builder_Helpers.registerTaskSideEffectHandler — attribution survives the deferral", () => {
-  testSync("the registered finish sees the plugin that registered it", () => {
-    let before = Builder_Helpers.taskSideEffectFinishFns->Array.length
-    let observed = ref(None)
-
-    let previous = Attribution.enter(~platform="online-shop", ~plugin="Catalog")
-    Builder_Helpers.registerTaskSideEffectHandler(
-      ~gate=Pulumi.Output.make(),
-      ~finish=() => observed := Attribution.current.contents.plugin,
-    )
-    Attribution.restore(previous)
-
-    switch Builder_Helpers.taskSideEffectFinishFns->Array.get(before) {
-    | Some(finish) => finish()
-    | None => JsError.throwWithMessage("handler was not registered")
-    }
-    expect(observed.contents)->toEqual(Some("Catalog"))
-  })
-})
+describe(
+  "Builder_Helpers.registerTaskSideEffectHandler — attribution survives the deferral",
+  () => {
+    testSync("the registered finish sees the plugin that registered it", () => {
+      let before = Builder_Helpers.taskSideEffectFinishFns->Array.length
+      let observed = ref(None)
+
+      let previous = Attribution.enter(~platform="online-shop", ~plugin="Catalog")
+      Builder_Helpers.registerTaskSideEffectHandler(
+        ~gate=Pulumi.Output.make(),
+        ~finish=() => observed := Attribution.current.contents.plugin,
+      )
+      Attribution.restore(previous)
+
+      switch Builder_Helpers.taskSideEffectFinishFns->Array.get(before) {
+      | Some(finish) => finish()
+      | None => JsError.throwWithMessage("handler was not registered")
+      }
+      expect(observed.contents)->toEqual(Some("Catalog"))
+    })
+  },
+)

package/tests/StorePrefixCollisionTest.res

@@ -33,7 +33,8 @@ describe("collisionsFor", () => {
         store(~qualified="Ordering.productImages", ~prefix="productImages"),
       ],
     ) {
-    | [c] => expect((c.first.qualified, c.second.qualified, c.nested))->toEqual((
+    | [c] =>
+      expect((c.first.qualified, c.second.qualified, c.nested))->toEqual((
         "Catalog.productImages",
         "Ordering.productImages",
         false,

package/tests/TaskBucketNamingTest.res

@@ -36,8 +36,9 @@ describe("kebabCase", () => {
 
 describe("bucketResourceName", () => {
   testSync("qualifies a task's default bucket with its plugin", () =>
-    expect(Naming.bucketResourceName(~plugin=Some("Catalog"), ~task="ImportProducts", ~bucketId=None))
-    ->toBe("catalog-import-products")
+    expect(
+      Naming.bucketResourceName(~plugin=Some("Catalog"), ~task="ImportProducts", ~bucketId=None),
+    )->toBe("catalog-import-products")
   )
 
   testSync("appends a declared bucket id", () =>

package/tests/adapter/EventLogProvisioningTest.res

@@ -128,54 +128,57 @@ describe("EventLogProvisioning", () => {
     EventLogProvisioning.reset()
   })
 
-  testSync("notify delivers the ambient plugin/platform inside a construct scope, None outside", () => {
-    let seen: array<(option<string>, option<string>)> = []
-    module OwnerCapture: EventLogProvisioning.Backend = {
-      let onProvisioned = (
-        ~logStyle as _,
-        ~name as _,
-        ~owner as _,
-        ~plugin,
-        ~platform,
-        ~resources as _,
-        ~opts as _,
-      ) => seen->Array.push((plugin, platform))
-    }
-    EventLogProvisioning.use(module(OwnerCapture: EventLogProvisioning.Backend))
-
-    // Outside any plugin construct: both None.
-    EventLogProvisioning.notify(
-      ~logStyle=Classic,
-      ~name="ProductEventLog",
-      ~owner=Some(classicOwner),
-      ~resources=[],
-      ~opts=noOpts,
-    )
-
-    // Inside a construct scope (what Plugin_Builder.construct establishes): both delivered.
-    let prev = ResourceAttribution.enter(~platform="online-shop", ~plugin="Catalog")
-    EventLogProvisioning.notify(
-      ~logStyle=Dcb,
-      ~name="CatalogDcbEventLog",
-      ~owner=Some(dcbOwner),
-      ~resources=[],
-      ~opts=noOpts,
-    )
-    ResourceAttribution.restore(prev)
-
-    // After restore: back to None.
-    EventLogProvisioning.notify(
-      ~logStyle=Classic,
-      ~name="OrderEventLog",
-      ~owner=None,
-      ~resources=[],
-      ~opts=noOpts,
-    )
-
-    expect(seen)->toEqual([(None, None), (Some("Catalog"), Some("online-shop")), (None, None)])
-
-    EventLogProvisioning.reset()
-  })
+  testSync(
+    "notify delivers the ambient plugin/platform inside a construct scope, None outside",
+    () => {
+      let seen: array<(option<string>, option<string>)> = []
+      module OwnerCapture: EventLogProvisioning.Backend = {
+        let onProvisioned = (
+          ~logStyle as _,
+          ~name as _,
+          ~owner as _,
+          ~plugin,
+          ~platform,
+          ~resources as _,
+          ~opts as _,
+        ) => seen->Array.push((plugin, platform))
+      }
+      EventLogProvisioning.use(module(OwnerCapture: EventLogProvisioning.Backend))
+
+      // Outside any plugin construct: both None.
+      EventLogProvisioning.notify(
+        ~logStyle=Classic,
+        ~name="ProductEventLog",
+        ~owner=Some(classicOwner),
+        ~resources=[],
+        ~opts=noOpts,
+      )
+
+      // Inside a construct scope (what Plugin_Builder.construct establishes): both delivered.
+      let prev = ResourceAttribution.enter(~platform="online-shop", ~plugin="Catalog")
+      EventLogProvisioning.notify(
+        ~logStyle=Dcb,
+        ~name="CatalogDcbEventLog",
+        ~owner=Some(dcbOwner),
+        ~resources=[],
+        ~opts=noOpts,
+      )
+      ResourceAttribution.restore(prev)
+
+      // After restore: back to None.
+      EventLogProvisioning.notify(
+        ~logStyle=Classic,
+        ~name="OrderEventLog",
+        ~owner=None,
+        ~resources=[],
+        ~opts=noOpts,
+      )
+
+      expect(seen)->toEqual([(None, None), (Some("Catalog"), Some("online-shop")), (None, None)])
+
+      EventLogProvisioning.reset()
+    },
+  )
 
   testSync("use is single-slot: a second registration throws rather than silently winning", () => {
     module First: EventLogProvisioning.Backend = {