@reventlessdev/reventless-core 3.0.0-alpha.134

package/src/util/Util_QueryDbRuntime.res

@@ -0,0 +1,11 @@
+let getRuntimeResource = (allQueryDbs: dict<Adapter.resolvedResource>, queryDbName) =>
+  try allQueryDbs->Dict.get(queryDbName)->Option.getOrThrow catch {
+  | exn =>
+    EffectLogger.logError(
+      ~comp=__MODULE__,
+      `getRuntimeResource: Couldn't find QueryDb ${queryDbName} in ${allQueryDbs
+        ->Dict.keysToArray
+        ->Array.joinUnsafe(", ")}`,
+    )->Effect.runSync
+    throw(exn)
+  }

package/src/util/Util_QueryDbRuntime.res.mjs

@@ -0,0 +1,19 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect from "effect/Effect";
+import * as EffectLogger$ReventlessCore from "./EffectLogger.res.mjs";
+
+function getRuntimeResource(allQueryDbs, queryDbName) {
+  try {
+    return Stdlib_Option.getOrThrow(allQueryDbs[queryDbName], undefined);
+  } catch (exn) {
+    Effect.runSync(EffectLogger$ReventlessCore.logError("Util_QueryDbRuntime-ReventlessCore", undefined, `getRuntimeResource: Couldn't find QueryDb ` + queryDbName + ` in ` + Object.keys(allQueryDbs).join(", ")));
+    throw exn;
+  }
+}
+
+export {
+  getRuntimeResource,
+}
+/* effect/Effect Not a pure module */

package/src/util/Util_ReadModel.res

@@ -0,0 +1,2 @@
+let queryDbStorageResources = (queryDbs, readModelName) =>
+  queryDbs->Util_QueryDb.getLocalStorageResources(readModelName)

package/src/util/Util_ReadModel.res.mjs

@@ -0,0 +1,10 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Util_QueryDb$ReventlessCore from "./Util_QueryDb.res.mjs";
+
+let queryDbStorageResources = Util_QueryDb$ReventlessCore.getLocalStorageResources;
+
+export {
+  queryDbStorageResources,
+}
+/* Util_QueryDb-ReventlessCore Not a pure module */

package/src/util/Util_StackRefs.res

@@ -0,0 +1,24 @@
+let stackRefs: dict<Pulumi.StackReference.t> = Dict.make()
+
+let coreStackName = Pulumi.Config.make(Some("platform"))->Pulumi.Config.get("stack")
+
+let stackName = pluginName =>
+  coreStackName->Option.map(name => {
+    let parts = name->String.split("/")
+    parts->Array.set(1, pluginName)
+    parts->Array.joinUnsafe("/")
+  })
+
+let get = pluginName =>
+  switch stackRefs->Dict.get(pluginName) {
+  | None =>
+    let stackRef = pluginName->stackName->Option.map(stack => stack->Pulumi.StackReference.make)
+
+    switch stackRef {
+    | Some(stackRef) =>
+      stackRefs->Dict.set(pluginName, stackRef)
+      Some(stackRef)
+    | None => None
+    }
+  | stackRef => stackRef
+  }

package/src/util/Util_StackRefs.res.mjs

@@ -0,0 +1,39 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Pulumi from "@pulumi/pulumi";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+
+let stackRefs = {};
+
+let coreStackName = new Pulumi.Config("platform").get("stack");
+
+function stackName(pluginName) {
+  return Stdlib_Option.map(coreStackName, name => {
+    let parts = name.split("/");
+    parts[1] = pluginName;
+    return parts.join("/");
+  });
+}
+
+function get(pluginName) {
+  let stackRef = stackRefs[pluginName];
+  if (stackRef !== undefined) {
+    return stackRef;
+  }
+  let stackRef$1 = Stdlib_Option.map(stackName(pluginName), stack => new Pulumi.StackReference(stack));
+  if (stackRef$1 === undefined) {
+    return;
+  }
+  let stackRef$2 = Primitive_option.valFromOption(stackRef$1);
+  stackRefs[pluginName] = stackRef$2;
+  return Primitive_option.some(stackRef$2);
+}
+
+export {
+  stackRefs,
+  coreStackName,
+  stackName,
+  get,
+}
+/* coreStackName Not a pure module */

package/src/util/Validation.res

@@ -0,0 +1,75 @@
+type error = string
+
+type t<'a, 'b> =
+  | Success('a)
+  | Successes(array<'a>)
+  | Failure('b)
+  | Failures(array<'b>)
+
+type async<'a, 'b> = promise<t<'a, 'b>>
+
+let merge: (t<'a, 'b>, t<'a, 'b>) => t<'a, 'b> = (v1, v2) => {
+  open Array
+  switch (v1, v2) {
+  | (Successes(as1), Successes(as2)) => Successes(as1->concat(as2))
+  | (Successes(as1), Success(a2)) => Successes(as1->concat([a2]))
+  | (Success(a1), Successes(as2)) => Successes([a1]->concat(as2))
+  | (Success(a1), Success(a2)) => Successes([a1, a2])
+  | (Success(_), Failure(b2)) => Failure(b2)
+  | (Success(_), Failures(bs2)) => Failures(bs2)
+  | (Successes(_), Failure(b2)) => Failure(b2)
+  | (Successes(_), Failures(bs2)) => Failures(bs2)
+  | (Failure(b1), Success(_)) => Failure(b1)
+  | (Failure(b1), Successes(_)) => Failure(b1)
+  | (Failures(bs1), Success(_)) => Failures(bs1)
+  | (Failures(bs1), Successes(_)) => Failures(bs1)
+  | (Failure(b1), Failure(b2)) => Failures([b1, b2])
+  | (Failure(b1), Failures(bs2)) => Failures([b1]->concat(bs2))
+  | (Failures(bs1), Failure(b2)) => Failures(bs1->concat([b2]))
+  | (Failures(bs1), Failures(bs2)) => Failures(bs1->concat(bs2))
+  }
+}
+
+let defaultErrorHandler = err => {
+  EffectLogger.logError(~comp=__MODULE__, err->JSON.stringifyAny->Option.getOr("unknown"))->Effect.runSync
+  Failure("Couldn't resolve promise.")
+}
+
+let \"<+>" = merge
+
+let mergeAsync: (async<'a, 'b>, async<'a, 'b>, exn => t<'a, 'b>) => async<'a, 'b> = (
+  a1,
+  a2,
+  handle,
+) =>
+  Promise.all2((a1, a2))
+  ->Promise.then(((v1, v2)) => Promise.resolve(\"<+>"(v1, v2)))
+  ->Promise.catch(err => Promise.resolve(err->handle))
+
+let \"<?>" = (a1, a2) => mergeAsync(a1, a2, defaultErrorHandler)
+
+let mergeAsyncLeft: (async<'a, 'b>, t<'a, 'b>, exn => t<'a, 'b>) => async<'a, 'b> = (
+  a1,
+  v2,
+  handler,
+) => mergeAsync(a1, Promise.resolve(v2), handler)
+
+let \"<?+>" = (a1, v2) => mergeAsyncLeft(a1, v2, defaultErrorHandler)
+
+let mergeAsyncRight: (t<'a, 'b>, async<'a, 'b>, exn => t<'a, 'b>) => async<'a, 'b> = (
+  v1,
+  a2,
+  handler,
+) => mergeAsync(Promise.resolve(v1), a2, handler)
+
+let \"<+?>" = (v1, a2) => mergeAsyncRight(v1, a2, defaultErrorHandler)
+
+// Belt.Result removed — Ok/Error are global in RescriptCore
+
+let toResult = x =>
+  switch x {
+  | Success(s) => Ok([s])
+  | Successes(ss) => Ok(ss)
+  | Failure(f) => Error([f])
+  | Failures(fs) => Error(fs)
+  }

package/src/util/Validation.res.mjs

@@ -0,0 +1,181 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect from "effect/Effect";
+import * as Stdlib_Promise from "@rescript/runtime/lib/es6/Stdlib_Promise.js";
+import * as EffectLogger$ReventlessCore from "./EffectLogger.res.mjs";
+
+function merge(v1, v2) {
+  switch (v1.TAG) {
+    case "Success" :
+      let a1 = v1._0;
+      switch (v2.TAG) {
+        case "Success" :
+          return {
+            TAG: "Successes",
+            _0: [
+              a1,
+              v2._0
+            ]
+          };
+        case "Successes" :
+          return {
+            TAG: "Successes",
+            _0: [a1].concat(v2._0)
+          };
+        case "Failure" :
+          return {
+            TAG: "Failure",
+            _0: v2._0
+          };
+        case "Failures" :
+          return {
+            TAG: "Failures",
+            _0: v2._0
+          };
+      }
+    case "Successes" :
+      let as1 = v1._0;
+      switch (v2.TAG) {
+        case "Success" :
+          return {
+            TAG: "Successes",
+            _0: as1.concat([v2._0])
+          };
+        case "Successes" :
+          return {
+            TAG: "Successes",
+            _0: as1.concat(v2._0)
+          };
+        case "Failure" :
+          return {
+            TAG: "Failure",
+            _0: v2._0
+          };
+        case "Failures" :
+          return {
+            TAG: "Failures",
+            _0: v2._0
+          };
+      }
+    case "Failure" :
+      let b1 = v1._0;
+      switch (v2.TAG) {
+        case "Success" :
+        case "Successes" :
+          return {
+            TAG: "Failure",
+            _0: b1
+          };
+        case "Failure" :
+          return {
+            TAG: "Failures",
+            _0: [
+              b1,
+              v2._0
+            ]
+          };
+        case "Failures" :
+          return {
+            TAG: "Failures",
+            _0: [b1].concat(v2._0)
+          };
+      }
+    case "Failures" :
+      let bs1 = v1._0;
+      switch (v2.TAG) {
+        case "Success" :
+        case "Successes" :
+          return {
+            TAG: "Failures",
+            _0: bs1
+          };
+        case "Failure" :
+          return {
+            TAG: "Failures",
+            _0: bs1.concat([v2._0])
+          };
+        case "Failures" :
+          return {
+            TAG: "Failures",
+            _0: bs1.concat(v2._0)
+          };
+      }
+  }
+}
+
+function defaultErrorHandler(err) {
+  Effect.runSync(EffectLogger$ReventlessCore.logError("Validation-ReventlessCore", undefined, Stdlib_Option.getOr(JSON.stringify(err), "unknown")));
+  return {
+    TAG: "Failure",
+    _0: "Couldn't resolve promise."
+  };
+}
+
+function mergeAsync(a1, a2, handle) {
+  return Stdlib_Promise.$$catch(Promise.all([
+    a1,
+    a2
+  ]).then(param => Promise.resolve(merge(param[0], param[1]))), err => Promise.resolve(handle(err)));
+}
+
+function $less$question$great(a1, a2) {
+  return mergeAsync(a1, a2, defaultErrorHandler);
+}
+
+function mergeAsyncLeft(a1, v2, handler) {
+  return mergeAsync(a1, Promise.resolve(v2), handler);
+}
+
+function $less$question$plus$great(a1, v2) {
+  return mergeAsyncLeft(a1, v2, defaultErrorHandler);
+}
+
+function mergeAsyncRight(v1, a2, handler) {
+  return mergeAsync(Promise.resolve(v1), a2, handler);
+}
+
+function $less$plus$question$great(v1, a2) {
+  return mergeAsyncRight(v1, a2, defaultErrorHandler);
+}
+
+function toResult(x) {
+  switch (x.TAG) {
+    case "Success" :
+      return {
+        TAG: "Ok",
+        _0: [x._0]
+      };
+    case "Successes" :
+      return {
+        TAG: "Ok",
+        _0: x._0
+      };
+    case "Failure" :
+      return {
+        TAG: "Error",
+        _0: [x._0]
+      };
+    case "Failures" :
+      return {
+        TAG: "Error",
+        _0: x._0
+      };
+  }
+}
+
+let $less$plus$great = merge;
+
+export {
+  merge,
+  defaultErrorHandler,
+  $less$plus$great,
+  mergeAsync,
+  $less$question$great,
+  mergeAsyncLeft,
+  $less$question$plus$great,
+  mergeAsyncRight,
+  $less$plus$question$great,
+  toResult,
+}
+/* effect/Effect Not a pure module */

package/tests/IdentityTest.res

@@ -0,0 +1,155 @@
+open JestGlobals
+
+S.enableJson()
+
+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)
+    })
+  })
+
+  describe("hasGroup", () => {
+    let identity: Reventless.Identity.t = {
+      userId: "user-1",
+      username: "alice",
+      groups: ["admin", "editors"],
+      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)
+    })
+  })
+
+  describe("getClaim", () => {
+    let identity: Reventless.Identity.t = {
+      userId: "user-1",
+      username: "alice",
+      groups: [],
+      claims: Dict.fromArray([("tenant", "acme"), ("role", "manager")]),
+      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)
+    })
+  })
+
+  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->S.reverseConvertToJsonOrThrow(Reventless.Identity.schema)
+      let decoded = json->S.parseJsonOrThrow(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->S.reverseConvertToJsonOrThrow(Reventless.Identity.schema)
+      let decoded = json->S.parseJsonOrThrow(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->S.reverseConvertToJsonOrThrow(Reventless.Identity.schema)
+      let decoded = json->S.parseJsonOrThrow(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([])
+    })
+  })
+
+  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)
+    })
+  })
+
+  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)
+    })
+  })
+})