@reventlessdev/reventless-local 3.0.0-alpha.298 → 3.0.0-alpha.300

package/tests/adapter/LocalAuthUserStoreTest.res

@@ -233,3 +233,91 @@ describe("UserStore.providedGroups", () => {
     expect(loaded)->toBe(true)
   })
 })
+
+describe("UserStore.reload", () => {
+  let signsIn = async (~username, ~password) =>
+    switch await LocalAuth.Login.issue(~username, ~password) {
+    | Ok(_) => true
+    | Error(_) => false
+    }
+
+  testPromise("adds, changes and forgets accounts as the file now says", async () => {
+    resetAll()
+    let path = _writeYamlFile(`
+- username: alice
+  password: a1
+  groups: [Editor]
+- username: bob
+  password: b1
+  groups: []
+`)
+    let _ = UserStore.load(~usersFile=path, ())
+    NodeFs.writeFileSync(
+      path,
+      `
+- username: alice
+  password: a2
+  groups: [Editor]
+- username: driver
+  password: driver
+  groups: [Driver]
+`,
+    )
+    switch UserStore.reload(path) {
+    | Ok(said) => expect(said)->toEqual("2 accounts, removed: bob")
+    | Error(e) => JsError.throwWithMessage(e)
+    }
+    expect(await signsIn(~username="driver", ~password="driver"))->toBe(true)
+    expect(await signsIn(~username="alice", ~password="a2"))->toBe(true)
+    expect(await signsIn(~username="alice", ~password="a1"))->toBe(false)
+    expect(await signsIn(~username="bob", ~password="b1"))->toBe(false)
+    expect(LocalAuth.lookupUser("bob"))->toEqual(None)
+  })
+
+  testPromise("a file that does not parse changes nothing", async () => {
+    resetAll()
+    let path = _writeYamlFile(`
+- username: alice
+  password: a1
+  groups: [Editor]
+`)
+    let _ = UserStore.load(~usersFile=path, ())
+    NodeFs.writeFileSync(path, "- username: alice\n  groups: [Editor]\n")
+    expect(UserStore.reload(path)->Result.isError)->toBe(true)
+    expect(await signsIn(~username="alice", ~password="a1"))->toBe(true)
+  })
+
+  testPromise("watch reads the file again once it is saved", async () => {
+    resetAll()
+    let path = _writeYamlFile(`
+- username: alice
+  password: a1
+  groups: [Editor]
+`)
+    let _ = UserStore.load(~usersFile=path, ())
+    UserStore.watch(path)
+    NodeFs.writeFileSync(
+      path,
+      `
+- username: alice
+  password: a1
+  groups: [Editor]
+- username: driver
+  password: driver
+  groups: [Driver]
+`,
+    )
+    let rec waitFor = async (tries: int) =>
+      if await signsIn(~username="driver", ~password="driver") {
+        true
+      } else if tries == 0 {
+        false
+      } else {
+        await Promise.make((resolve, _) => setTimeout(() => resolve(), 50)->ignore)
+        await waitFor(tries - 1)
+      }
+    let added = await waitFor(60)
+    UserStore.unwatch()
+    expect(added)->toBe(true)
+  })
+})

package/tests/adapter/LocalAuthUserStoreTest.res.mjs

@@ -293,6 +293,89 @@ globalThis.describe("UserStore.providedGroups", () => {
   });
 });
 
+globalThis.describe("UserStore.reload", () => {
+  let signsIn = async (username, password) => {
+    let match = await LocalAuth$ReventlessLocal.Login.issue(username, password, undefined);
+    return match.TAG === "Ok";
+  };
+  globalThis.test("adds, changes and forgets accounts as the file now says", async () => {
+    resetAll();
+    let path = _writeYamlFile(`
+- username: alice
+  password: a1
+  groups: [Editor]
+- username: bob
+  password: b1
+  groups: []
+`);
+    UserStore$ReventlessLocal.load(undefined, path, undefined);
+    Nodefs.writeFileSync(path, `
+- username: alice
+  password: a2
+  groups: [Editor]
+- username: driver
+  password: driver
+  groups: [Driver]
+`, "utf8");
+    let said = UserStore$ReventlessLocal.reload(path);
+    if (said.TAG === "Ok") {
+      globalThis.expect(said._0).toEqual("2 accounts, removed: bob");
+    } else {
+      Stdlib_JsError.throwWithMessage(said._0);
+    }
+    globalThis.expect(await signsIn("driver", "driver")).toBe(true);
+    globalThis.expect(await signsIn("alice", "a2")).toBe(true);
+    globalThis.expect(await signsIn("alice", "a1")).toBe(false);
+    globalThis.expect(await signsIn("bob", "b1")).toBe(false);
+    globalThis.expect(LocalAuth$ReventlessLocal.lookupUser("bob")).toEqual(undefined);
+  });
+  globalThis.test("a file that does not parse changes nothing", async () => {
+    resetAll();
+    let path = _writeYamlFile(`
+- username: alice
+  password: a1
+  groups: [Editor]
+`);
+    UserStore$ReventlessLocal.load(undefined, path, undefined);
+    Nodefs.writeFileSync(path, "- username: alice\n  groups: [Editor]\n", "utf8");
+    globalThis.expect(Stdlib_Result.isError(UserStore$ReventlessLocal.reload(path))).toBe(true);
+    globalThis.expect(await signsIn("alice", "a1")).toBe(true);
+  });
+  globalThis.test("watch reads the file again once it is saved", async () => {
+    resetAll();
+    let path = _writeYamlFile(`
+- username: alice
+  password: a1
+  groups: [Editor]
+`);
+    UserStore$ReventlessLocal.load(undefined, path, undefined);
+    UserStore$ReventlessLocal.watch(path);
+    Nodefs.writeFileSync(path, `
+- username: alice
+  password: a1
+  groups: [Editor]
+- username: driver
+  password: driver
+  groups: [Driver]
+`, "utf8");
+    let waitFor = async tries => {
+      if (await signsIn("driver", "driver")) {
+        return true;
+      } else if (tries === 0) {
+        return false;
+      } else {
+        await new Promise((resolve, param) => {
+          setTimeout(() => resolve(), 50);
+        });
+        return await waitFor(tries - 1 | 0);
+      }
+    };
+    let added = await waitFor(60);
+    UserStore$ReventlessLocal.unwatch();
+    globalThis.expect(added).toBe(true);
+  });
+});
+
 export {
   resetAll,
   _writeYamlFile,

package/tests/capability/LocalCapabilitiesTest.res

@@ -18,7 +18,7 @@ let reset = () => {
 describe("LocalCapabilities.unmetWarning", () => {
   testSync("a bare platform provisions nothing, and the warning names each need once", () => {
     reset()
-    expect(LocalCapabilities.provisioned())->toEqual([])
+    expect(LocalCapabilities.provisioned())->toEqual([Reventless.CapabilityNeed.Stash])
     let message = LocalCapabilities.unmetWarning(~declared)->Option.getOr("")
     expect(message->String.includes("Geocoding (GeocodeAddress)"))->toBe(true)
     expect(message->String.includes("Capability_Messaging_Log.make()"))->toBe(true)
@@ -34,6 +34,7 @@ describe("LocalCapabilities.unmetWarning", () => {
     expect(LocalCapabilities.provisioned())->toEqual([
       Reventless.CapabilityNeed.Messaging,
       IdentityProvider,
+      Stash,
     ])
     let message = LocalCapabilities.unmetWarning(~declared)->Option.getOr("")
     expect(message->String.includes("Messaging"))->toBe(false)

package/tests/capability/LocalCapabilitiesTest.res.mjs

@@ -28,7 +28,7 @@ function reset() {
 globalThis.describe("LocalCapabilities.unmetWarning", () => {
   globalThis.test("a bare platform provisions nothing, and the warning names each need once", () => {
     reset();
-    globalThis.expect(LocalCapabilities$ReventlessLocal.provisioned()).toEqual([]);
+    globalThis.expect(LocalCapabilities$ReventlessLocal.provisioned()).toEqual(["Stash"]);
     let message = Stdlib_Option.getOr(LocalCapabilities$ReventlessLocal.unmetWarning(declared), "");
     globalThis.expect(message.includes("Geocoding (GeocodeAddress)")).toBe(true);
     globalThis.expect(message.includes("Capability_Messaging_Log.make()")).toBe(true);
@@ -40,7 +40,8 @@ globalThis.describe("LocalCapabilities.unmetWarning", () => {
     LocalCapabilities$ReventlessLocal.registerIdentityProvider(Capability_IdentityProvider_UserStore$ReventlessLocal.make("/nonexistent/users.yaml", undefined));
     globalThis.expect(LocalCapabilities$ReventlessLocal.provisioned()).toEqual([
       "Messaging",
-      "IdentityProvider"
+      "IdentityProvider",
+      "Stash"
     ]);
     let message = Stdlib_Option.getOr(LocalCapabilities$ReventlessLocal.unmetWarning(declared), "");
     globalThis.expect(message.includes("Messaging")).toBe(false);

package/tests/components/inboundtranslationslice/InboundTranslationCredentialTest.res

@@ -0,0 +1,136 @@
+// An inbound door that takes a credential: `translate` reaches a capability with
+// it, and the audit row never holds it. The shape a registration's
+// set-a-password step has.
+
+open JestGlobals
+
+module SignUpSpec = {
+  let name = "SignUp"
+  let moduleUrl = "test://sign-up"
+
+  // Hand-written marker: this inline module has no `@@reventless.spec` pass.
+  @schema
+  type externalInput = {
+    email: string,
+    password: @s.matches(Reventless.Sensitive.string) string,
+  }
+
+  @schema
+  type command = AccountOpened({email: string, principal: string})
+
+  let targetName = "Accounts"
+  let externalSystem = None
+  let capabilityNeeds = [Reventless.CapabilityNeed.IdentityProvider]
+  let endpoint = None
+  type role = Reventless.Role.name
+  let authorizationOf = (_: string): Reventless.Authorization.rule<role> => AllowAnonymous
+}
+
+module SignUpTranslation = {
+  let moduleUrl = SignUpSpec.moduleUrl
+  let translate = async (
+    input: SignUpSpec.externalInput,
+    ~capabilities: Reventless.Capabilities.t,
+    ~caller as _: option<Reventless.Identity.t>,
+  ) =>
+    switch await capabilities.identityProvider.createPrincipal(
+      ~contact=ToEmail(Reventless.Email.unsafe(input.email)),
+      ~credential=Password(input.password),
+      ~groups=[],
+    ) {
+    | Ok({providerId}) =>
+      Ok([(input.email, SignUpSpec.AccountOpened({email: input.email, principal: providerId}))])
+    | Error(Conflict) => Error("taken")
+    | Error(Unavailable(why) | Refused(why)) => Error(why)
+    }
+}
+
+module Callback = ReventlessCore.InboundTranslationSlice_Callback.Make(
+  SignUpSpec,
+  SignUpTranslation,
+)
+
+let input = (~password) =>
+  JSON.Encode.object(
+    Dict.fromArray([
+      ("email", JSON.Encode.string("new@example.com")),
+      ("password", JSON.Encode.string(password)),
+    ]),
+  )
+
+let auditOf = result =>
+  Callback.auditLog->Dict.get(result->ReventlessCore.InboundTranslationSlice_Callback.requestIdOf)
+
+let publishNothing: ReventlessInfra.CommandTopic.publishJsons = async _ => ()
+
+describe("an inbound door taking a credential", () => {
+  testPromise("translate is handed the platform's capabilities", async () => {
+    let created = ref(None)
+    let fakes = ReventlessGwt.Capabilities_Fake.make(
+      ~createPrincipal=async (~contact as _, ~credential, ~groups as _) => {
+        created := Some(credential)
+        Ok({Reventless.IdentityProvider.providerId: "p-1"})
+      },
+      (),
+    )
+    let result = await Callback.receive(
+      publishNothing,
+      input(~password="correct horse"),
+      ~capabilities=fakes.capabilities,
+    )
+    expect(result->Result.isOk)->toBe(true)
+    expect(created.contents)->toEqual(Some(Reventless.IdentityProvider.Password("correct horse")))
+  })
+
+  testPromise("the audit row withholds the credential on success", async () => {
+    let result = await Callback.receive(
+      publishNothing,
+      input(~password="correct horse"),
+      ~capabilities=ReventlessGwt.Capabilities_Fake.make().capabilities,
+    )
+    let row = auditOf(result)->Option.map(r => r.input)->Option.getOr("")
+    expect(row->String.includes("correct horse"))->toBe(false)
+    expect(row->String.includes("[withheld]"))->toBe(true)
+    expect(row->String.includes("new@example.com"))->toBe(true)
+  })
+
+  // The refusal path writes its own row, and a refused request is the one most
+  // likely to be read by an operator chasing a complaint.
+  testPromise("the audit row withholds the credential on a refusal too", async () => {
+    let result = await Callback.receive(
+      publishNothing,
+      input(~password="correct horse"),
+      ~capabilities=Reventless.Capabilities.none,
+    )
+    expect(result->Result.isError)->toBe(true)
+    let row = auditOf(result)->Option.map(r => r.input)->Option.getOr("")
+    expect(row->String.includes("correct horse"))->toBe(false)
+  })
+
+  testSync("a webhook body that cannot be read keeps none of itself", () => {
+    let result = Callback.refuse(
+      ~body=`{"email": "new@example.com", "password": "correct horse"`,
+      ~errorCode="InvalidSignature",
+      "unsigned",
+    )
+    let row = auditOf(result)->Option.map(r => r.input)->Option.getOr("")
+    expect(row->String.includes("correct horse"))->toBe(false)
+  })
+
+  testSync("a webhook body that can be read keeps everything but the credential", () => {
+    let result = Callback.refuse(
+      ~body=`{"email": "new@example.com", "password": "correct horse"}`,
+      ~errorCode="InvalidSignature",
+      "unsigned",
+    )
+    let row = auditOf(result)->Option.map(r => r.input)->Option.getOr("")
+    expect(row->String.includes("correct horse"))->toBe(false)
+    expect(row->String.includes("new@example.com"))->toBe(true)
+  })
+
+  testSync("a slice with no sensitive field keeps its body as received", () =>
+    expect(
+      ReventlessCore.InboundTranslationSlice_Callback.redactBody("not json", ~sensitive=[]),
+    )->toBe("not json")
+  )
+})

package/tests/components/inboundtranslationslice/InboundTranslationCredentialTest.res.mjs

@@ -0,0 +1,183 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Sury from "sury";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Stdlib_Result from "@rescript/runtime/lib/es6/Stdlib_Result.js";
+import * as Sensitive$Reventless from "@reventlessdev/reventless-spec/src/components/Sensitive.res.mjs";
+import * as Capabilities$Reventless from "@reventlessdev/reventless-spec/src/semantic/Capabilities.res.mjs";
+import * as Capabilities_Fake$ReventlessGwt from "@reventlessdev/reventless-gwt/src/Capabilities_Fake.res.mjs";
+import * as InboundTranslationSlice_Callback$ReventlessCore from "@reventlessdev/reventless-core/src/components/InboundTranslationSlice/InboundTranslationSlice_Callback.res.mjs";
+
+let name = "SignUp";
+
+let moduleUrl = "test://sign-up";
+
+let externalInputSchema = Sury.$schema(s => ({
+  email: s.m(Sury.string),
+  password: s.m(Sensitive$Reventless.string)
+}));
+
+let commandSchema = Sury.$schema(s => ({
+  TAG: "AccountOpened",
+  email: s.m(Sury.string),
+  principal: s.m(Sury.string)
+}));
+
+let targetName = "Accounts";
+
+let capabilityNeeds = ["IdentityProvider"];
+
+function authorizationOf(param) {
+  return "AllowAnonymous";
+}
+
+let traits = [];
+
+let SignUpSpec = {
+  name: name,
+  moduleUrl: moduleUrl,
+  externalInputSchema: externalInputSchema,
+  commandSchema: commandSchema,
+  targetName: targetName,
+  externalSystem: undefined,
+  capabilityNeeds: capabilityNeeds,
+  endpoint: undefined,
+  authorizationOf: authorizationOf,
+  traits: traits
+};
+
+async function translate(input, capabilities, param) {
+  let match = await capabilities.identityProvider.createPrincipal({
+    TAG: "ToEmail",
+    _0: input.email
+  }, {
+    TAG: "Password",
+    _0: input.password
+  }, []);
+  if (match.TAG === "Ok") {
+    return {
+      TAG: "Ok",
+      _0: [[
+          input.email,
+          {
+            TAG: "AccountOpened",
+            email: input.email,
+            principal: match._0.providerId
+          }
+        ]]
+    };
+  }
+  let match$1 = match._0;
+  if (typeof match$1 !== "object") {
+    return {
+      TAG: "Error",
+      _0: "taken"
+    };
+  } else {
+    return {
+      TAG: "Error",
+      _0: match$1._0
+    };
+  }
+}
+
+let SignUpTranslation = {
+  moduleUrl: moduleUrl,
+  translate: translate
+};
+
+let Callback = InboundTranslationSlice_Callback$ReventlessCore.Make({
+  name: name,
+  moduleUrl: moduleUrl,
+  externalInputSchema: externalInputSchema,
+  commandSchema: commandSchema,
+  targetName: targetName,
+  externalSystem: undefined,
+  authorizationOf: authorizationOf,
+  endpoint: undefined,
+  capabilityNeeds: capabilityNeeds
+})({
+  translate: translate,
+  moduleUrl: moduleUrl
+});
+
+function input(password) {
+  return Object.fromEntries([
+    [
+      "email",
+      "new@example.com"
+    ],
+    [
+      "password",
+      password
+    ]
+  ]);
+}
+
+function auditOf(result) {
+  return Callback.auditLog[InboundTranslationSlice_Callback$ReventlessCore.requestIdOf(result)];
+}
+
+async function publishNothing(param) {
+  
+}
+
+globalThis.describe("an inbound door taking a credential", () => {
+  globalThis.test("translate is handed the platform's capabilities", async () => {
+    let created = {
+      contents: undefined
+    };
+    let fakes = Capabilities_Fake$ReventlessGwt.make(undefined, undefined, undefined, undefined, async (param, credential, param$1) => {
+      created.contents = credential;
+      return {
+        TAG: "Ok",
+        _0: {
+          providerId: "p-1"
+        }
+      };
+    }, undefined, undefined, undefined, undefined, undefined, undefined);
+    let result = await Callback.receive(publishNothing, input("correct horse"), fakes.capabilities, undefined, undefined);
+    globalThis.expect(Stdlib_Result.isOk(result)).toBe(true);
+    globalThis.expect(created.contents).toEqual({
+      TAG: "Password",
+      _0: "correct horse"
+    });
+  });
+  globalThis.test("the audit row withholds the credential on success", async () => {
+    let result = await Callback.receive(publishNothing, input("correct horse"), Capabilities_Fake$ReventlessGwt.make(undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined).capabilities, undefined, undefined);
+    let row = Stdlib_Option.getOr(Stdlib_Option.map(Callback.auditLog[InboundTranslationSlice_Callback$ReventlessCore.requestIdOf(result)], r => r.input), "");
+    globalThis.expect(row.includes("correct horse")).toBe(false);
+    globalThis.expect(row.includes("[withheld]")).toBe(true);
+    globalThis.expect(row.includes("new@example.com")).toBe(true);
+  });
+  globalThis.test("the audit row withholds the credential on a refusal too", async () => {
+    let result = await Callback.receive(publishNothing, input("correct horse"), Capabilities$Reventless.none, undefined, undefined);
+    globalThis.expect(Stdlib_Result.isError(result)).toBe(true);
+    let row = Stdlib_Option.getOr(Stdlib_Option.map(Callback.auditLog[InboundTranslationSlice_Callback$ReventlessCore.requestIdOf(result)], r => r.input), "");
+    globalThis.expect(row.includes("correct horse")).toBe(false);
+  });
+  globalThis.test("a webhook body that cannot be read keeps none of itself", () => {
+    let result = Callback.refuse(`{"email": "new@example.com", "password": "correct horse"`, "InvalidSignature", "unsigned");
+    let row = Stdlib_Option.getOr(Stdlib_Option.map(Callback.auditLog[InboundTranslationSlice_Callback$ReventlessCore.requestIdOf(result)], r => r.input), "");
+    globalThis.expect(row.includes("correct horse")).toBe(false);
+  });
+  globalThis.test("a webhook body that can be read keeps everything but the credential", () => {
+    let result = Callback.refuse(`{"email": "new@example.com", "password": "correct horse"}`, "InvalidSignature", "unsigned");
+    let row = Stdlib_Option.getOr(Stdlib_Option.map(Callback.auditLog[InboundTranslationSlice_Callback$ReventlessCore.requestIdOf(result)], r => r.input), "");
+    globalThis.expect(row.includes("correct horse")).toBe(false);
+    globalThis.expect(row.includes("new@example.com")).toBe(true);
+  });
+  globalThis.test("a slice with no sensitive field keeps its body as received", () => {
+    globalThis.expect(InboundTranslationSlice_Callback$ReventlessCore.redactBody("not json", [])).toBe("not json");
+  });
+});
+
+export {
+  SignUpSpec,
+  SignUpTranslation,
+  Callback,
+  input,
+  auditOf,
+  publishNothing,
+}
+/* externalInputSchema Not a pure module */