@reventlessdev/reventless-local 3.0.0-alpha.216 → 3.0.0-alpha.218

package/src/adapter/CommandGenerator/CommandGeneratorResolvers_GraphQL.res.mjs

@@ -1,14 +1,18 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Effect from "effect/Effect";
 import * as Pulumi from "@pulumi/pulumi";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
 import * as Identity$Reventless from "@reventlessdev/reventless-spec/src/types/Identity.res.mjs";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Message.res.mjs";
 import * as Authorization$Reventless from "@reventlessdev/reventless-spec/src/types/Authorization.res.mjs";
 import * as CommandTopic$ReventlessCore from "@reventlessdev/reventless-core/src/components/CommandTopic/CommandTopic.res.mjs";
+import * as GraphQL_CallerError$ReventlessLocal from "../GraphQL_CallerError.res.mjs";
+import * as Plugin_ResolverError$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/component/Plugin_ResolverError.res.mjs";
 import * as GraphQL_FragmentGenerator$ReventlessCore from "@reventlessdev/reventless-core/src/components/Api/GraphQL_FragmentGenerator.res.mjs";
 
 function extractIdentity(ctx) {
@@ -140,6 +144,18 @@ function deriveSdlField(fieldName, variantSchema) {
 
 let handlerRefs = {};
 
+async function runCommand(generateCommand, payload) {
+  try {
+    return await Effect.runPromise(generateCommand(payload));
+  } catch (raw_e) {
+    let e = Primitive_exceptions.internalToException(raw_e);
+    if (Plugin_ResolverError$ReventlessCore.isCallerFault(e)) {
+      throw GraphQL_CallerError$ReventlessLocal.badUserInput(Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(e), Stdlib_JsExn.message), "invalid command"));
+    }
+    throw e;
+  }
+}
+
 function register(fields, commandSchema, commandAuthorization, server) {
   server.registerTypes([commandResultSdl]);
   let sdlFields = fields.map(field => {
@@ -187,7 +203,7 @@ function register(fields, commandSchema, commandAuthorization, server) {
         meta: payload_meta,
         identity: identity
       };
-      return CommandTopic$ReventlessCore.commandOutcomeToJson(await Effect.runPromise(generateCommand(payload)));
+      return CommandTopic$ReventlessCore.commandOutcomeToJson(await runCommand(generateCommand, payload));
     };
     resolvers[field] = resolver;
   });
@@ -231,7 +247,7 @@ function registerDcb(fieldName, commandSchema, commandAuthorization, server) {
       meta: payload_meta,
       identity: identity
     };
-    return CommandTopic$ReventlessCore.commandOutcomeToJson(await Effect.runPromise(generateCommand(payload)));
+    return CommandTopic$ReventlessCore.commandOutcomeToJson(await runCommand(generateCommand, payload));
   };
   let resolvers = {};
   resolvers[fieldName] = resolver;
@@ -290,6 +306,7 @@ export {
   variantIndexForField,
   deriveSdlField,
   handlerRefs,
+  runCommand,
   register,
   registerDcb,
   bindHandler,

package/src/adapter/DomainGraphQL_Server.res

@@ -79,7 +79,9 @@ let _loginRejected = (res: nodeResponse, ~error: string): unit =>
     JSON.Encode.object(Dict.fromArray([("error", JSON.Encode.string(error))])),
   )
 
-type _loginBody = {username: string, password: string}
+// `activeRole` narrows the minted token to one of the caller's own groups. Its
+// absence is the ordinary login and mints what it always did.
+type _loginBody = {username: string, password: string, activeRole?: string}
 
 let handleLogin = (req: nodeRequest, res: nodeResponse): unit =>
   readBody(req, body => {
@@ -90,14 +92,20 @@ let handleLogin = (req: nodeRequest, res: nodeResponse): unit =>
     }
     switch parsed {
     | None => _loginRejected(res, ~error="Invalid JSON body")
-    | Some({username, password}) =>
-      let _ = LocalAuth.Login.issue(~username, ~password)->Promise.then(result => {
+    | Some({username, password, ?activeRole}) =>
+      let _ = LocalAuth.Login.issue(~username, ~password, ~activeRole?)->Promise.then(result => {
         switch result {
         | Error(msg) => _loginRejected(res, ~error=msg)
         | Ok(token) =>
           // Echo back the identity the client will see in subsequent
           // ctx.identity values, so the SPA doesn't need a second round-trip.
-          let identity = switch LocalAuth.lookupUser(username) {
+          //
+          // Read from the mint rather than the store: the two differ exactly
+          // when the token is narrowed, and a response that described the wider
+          // stored identity would put the client a step behind the server from
+          // its first request — showing a menu for groups its own token no
+          // longer carries.
+          let identity = switch LocalAuth.Login.mintedIdentity(~username, ~activeRole) {
           | Some(i) => i
           | None => Reventless.Identity.anonymous
           }
@@ -119,6 +127,59 @@ let handleLogin = (req: nodeRequest, res: nodeResponse): unit =>
     }
   })
 
+// `activeRole` absent widens back to the caller's full membership — see
+// `LocalAuth.Login.reissue` for why that is not an escalation.
+type _switchBody = {activeRole?: string}
+
+// Re-mints the presented session as one of the caller's roles.
+//
+// Separate from login because a switch is not a re-authentication: the client
+// holds a token, not a password. The bearer is already verified by the dispatch
+// rule above — every path but login rejects an unverifiable one — so reaching
+// here means the token is this server's own.
+let handleSwitchRole = (req: nodeRequest, res: nodeResponse): unit =>
+  readBody(req, body => {
+    let requested = switch body->JSON.parseOrThrow {
+    | json => (json->Obj.magic: _switchBody).activeRole
+    | exception _ => None
+    }
+    let presented =
+      req.headers
+      ->Dict.get("authorization")
+      ->Option.flatMap(h =>
+        String.startsWith(h, "Bearer ")
+          ? Some(String.slice(h, ~start=7, ~end=String.length(h))->String.trim)
+          : None
+      )
+    switch presented {
+    | None => _loginRejected(res, ~error="Missing bearer token")
+    | Some(token) =>
+      switch LocalAuth.Login.reissue(~token, ~activeRole=requested) {
+      | Error(msg) => _loginRejected(res, ~error=msg)
+      | Ok(newToken) =>
+        // Same shape as login, so the client stores the result the same way and
+        // a switch is indistinguishable from a fresh session downstream.
+        let identity = switch LocalAuth.Login.verifyAndDecode(newToken) {
+        | Some(i) => i
+        | None => Reventless.Identity.anonymous
+        }
+        _writeJson(
+          res,
+          ~status=200,
+          JSON.Encode.object(
+            Dict.fromArray([
+              ("token", JSON.Encode.string(newToken)),
+              (
+                "identity",
+                identity->S.reverseConvertToJsonOrThrow(Reventless.Identity.schema),
+              ),
+            ]),
+          ),
+        )
+      }
+    }
+  })
+
 let handleLogout = (_req: nodeRequest, res: nodeResponse): unit => {
   res->writeHead(204, {"Access-Control-Allow-Origin": "*"})
   res->endEmpty
@@ -205,6 +266,8 @@ let _dispatch = (req: nodeRequest, res: nodeResponse, yoga: YG.yoga, getSdl: uni
     res->end_(getSdl())
   } else if path == "/__inmemory/login" && req.method == "POST" {
     handleLogin(req, res)
+  } else if path == "/__inmemory/switch-role" && req.method == "POST" {
+    handleSwitchRole(req, res)
   } else if path == "/__inmemory/logout" && req.method == "POST" {
     handleLogout(req, res)
   } else if path == "/events" && req.method == "POST" {

package/src/adapter/DomainGraphQL_Server.res.mjs

@@ -69,10 +69,11 @@ function handleLogin(req, res) {
     if (parsed === undefined) {
       return _loginRejected(res, "Invalid JSON body");
     }
+    let activeRole = parsed.activeRole;
     let username = parsed.username;
-    LocalAuth$ReventlessLocal.Login.issue(username, parsed.password).then(result => {
+    LocalAuth$ReventlessLocal.Login.issue(username, parsed.password, activeRole).then(result => {
       if (result.TAG === "Ok") {
-        let i = LocalAuth$ReventlessLocal.lookupUser(username);
+        let i = LocalAuth$ReventlessLocal.Login.mintedIdentity(username, activeRole);
         let identity = i !== undefined ? i : Identity$Reventless.anonymous;
         let identityJson = S.reverseConvertToJsonOrThrow(identity, Identity$Reventless.schema);
         _writeJson(res, 200, Object.fromEntries([
@@ -93,6 +94,48 @@ function handleLogin(req, res) {
   });
 }
 
+function handleSwitchRole(req, res) {
+  readBody(req, body => {
+    let requested;
+    let exit = 0;
+    let json;
+    try {
+      json = JSON.parse(body);
+      exit = 1;
+    } catch (exn) {
+      requested = undefined;
+    }
+    if (exit === 1) {
+      requested = json.activeRole;
+    }
+    let presented = Stdlib_Option.flatMap(req.headers["authorization"], h => {
+      if (h.startsWith("Bearer ")) {
+        return h.slice(7, h.length).trim();
+      }
+    });
+    if (presented === undefined) {
+      return _loginRejected(res, "Missing bearer token");
+    }
+    let msg = LocalAuth$ReventlessLocal.Login.reissue(presented, requested);
+    if (msg.TAG !== "Ok") {
+      return _loginRejected(res, msg._0);
+    }
+    let newToken = msg._0;
+    let i = LocalAuth$ReventlessLocal.Login.verifyAndDecode(newToken);
+    let identity = i !== undefined ? i : Identity$Reventless.anonymous;
+    _writeJson(res, 200, Object.fromEntries([
+      [
+        "token",
+        newToken
+      ],
+      [
+        "identity",
+        S.reverseConvertToJsonOrThrow(identity, Identity$Reventless.schema)
+      ]
+    ]));
+  });
+}
+
 function handleLogout(_req, res) {
   res.writeHead(204, {
     "Access-Control-Allow-Origin": "*"
@@ -163,6 +206,9 @@ function _dispatch(req, res, yoga, getSdl) {
   if (path === "/__inmemory/login" && req.method === "POST") {
     return handleLogin(req, res);
   }
+  if (path === "/__inmemory/switch-role" && req.method === "POST") {
+    return handleSwitchRole(req, res);
+  }
   if (path === "/__inmemory/logout" && req.method === "POST") {
     return handleLogout(req, res);
   }
@@ -729,6 +775,7 @@ export {
   _writeJson,
   _loginRejected,
   handleLogin,
+  handleSwitchRole,
   handleLogout,
   _corsWriteHeaders,
   handleObjectPut,

package/src/adapter/GraphQL_CallerError.res

@@ -0,0 +1,19 @@
+// A failure the caller is allowed to read.
+//
+// graphql-yoga's `maskedErrors` replaces any thrown value that is not a
+// `GraphQLError` with "Unexpected error / INTERNAL_SERVER_ERROR". That is the
+// right default — an internal failure's message is not the caller's business —
+// but it also hides the failures that describe the caller's own request, which
+// are the ones they can do something about. Constructing the error through this
+// module is how a resolver says "this one is theirs to read".
+//
+// Mirrors what AppSync surfaces in production, where a resolver's thrown message
+// is returned as the field error.
+
+@new @module("graphql")
+external make: (string, {"extensions": {"code": string}}) => exn = "GraphQLError"
+
+/** A request the server understood and refused — bad input, in GraphQL's own
+    `BAD_USER_INPUT` sense. */
+let badUserInput = (message: string): exn =>
+  make(message, {"extensions": {"code": "BAD_USER_INPUT"}})

package/src/adapter/GraphQL_CallerError.res.mjs

@@ -0,0 +1,16 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Graphql from "graphql";
+
+function badUserInput(message) {
+  return new Graphql.GraphQLError(message, {
+    extensions: {
+      code: "BAD_USER_INPUT"
+    }
+  });
+}
+
+export {
+  badUserInput,
+}
+/* graphql Not a pure module */

package/src/adapter/GraphQL_Server.res.mjs

@@ -16,6 +16,8 @@ let _loginRejected = DomainGraphQL_Server$ReventlessLocal._loginRejected;
 
 let handleLogin = DomainGraphQL_Server$ReventlessLocal.handleLogin;
 
+let handleSwitchRole = DomainGraphQL_Server$ReventlessLocal.handleSwitchRole;
+
 let handleLogout = DomainGraphQL_Server$ReventlessLocal.handleLogout;
 
 let _corsWriteHeaders = DomainGraphQL_Server$ReventlessLocal._corsWriteHeaders;
@@ -132,6 +134,7 @@ export {
   _writeJson,
   _loginRejected,
   handleLogin,
+  handleSwitchRole,
   handleLogout,
   _corsWriteHeaders,
   handleObjectPut,

package/tests/BakedManifestFilesTest.res

@@ -0,0 +1,68 @@
+open JestGlobals
+
+// Which files a bake declaration produces, and under which names. The write
+// itself needs a host-shell package on disk; this is the part that decides what
+// gets written, so it is worth pinning without one.
+
+let _ = TestRunner.setup()
+
+let sel = (plugin): ReventlessInfra.Platform.bakedManifestSelection => {
+  plugin,
+  views: [],
+  commands: [],
+}
+
+let keysOf = (config: ReventlessInfra.Platform.bakedManifest) =>
+  BakedManifest.files(~config)->Array.map(((key, _)) => key)
+
+describe("BakedManifest.files", () => {
+  open Expect
+
+  // 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", () => {
+    expect(keysOf({components: [sel("Catalog")]}))->toEqual(["component-manifest.json"])
+  })
+
+  testSync("a renamed default is honoured", () => {
+    expect(keysOf({components: [sel("Catalog")], key: "shop.json"}))->toEqual(["shop.json"])
+  })
+
+  // The default comes first and stays: it is what a caller matching no declared
+  // group gets, which locally includes the no-bearer identity every dev session
+  // starts from.
+  testSync("journeys are written beside the default, not instead of it", () => {
+    expect(
+      keysOf({
+        components: [sel("Catalog")],
+        journeys: [
+          {group: "Shopper", components: [sel("Catalog")]},
+          {group: "Fulfilment", components: [sel("Ordering")], key: "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
+  // derivation folds anything that is neither a letter nor a digit.
+  testSync("derives a URL-safe key from an awkward group name", () => {
+    expect(
+      keysOf({components: [sel("Catalog")], journeys: [{group: "Ops Team/EU", components: []}]}),
+    )->toEqual(["component-manifest.json", "component-manifest-ops-team-eu.json"])
+  })
+
+  testSync("carries each journey's own selections", () => {
+    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/BakedManifestFilesTest.res.mjs

@@ -0,0 +1,115 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as TestRunner$ReventlessLocal from "../src/test/TestRunner.res.mjs";
+import * as BakedManifest$ReventlessLocal from "../src/BakedManifest.res.mjs";
+
+TestRunner$ReventlessLocal.setup();
+
+function sel(plugin) {
+  return {
+    plugin: plugin,
+    views: [],
+    commands: []
+  };
+}
+
+function keysOf(config) {
+  return BakedManifest$ReventlessLocal.files(config).map(param => param[0]);
+}
+
+globalThis.describe("BakedManifest.files", () => {
+  globalThis.test("a declaration with no journeys produces exactly one file", () => {
+    globalThis.expect(keysOf({
+      components: [{
+          plugin: "Catalog",
+          views: [],
+          commands: []
+        }]
+    })).toEqual(["component-manifest.json"]);
+  });
+  globalThis.test("a renamed default is honoured", () => {
+    globalThis.expect(keysOf({
+      components: [{
+          plugin: "Catalog",
+          views: [],
+          commands: []
+        }],
+      key: "shop.json"
+    })).toEqual(["shop.json"]);
+  });
+  globalThis.test("journeys are written beside the default, not instead of it", () => {
+    globalThis.expect(keysOf({
+      components: [{
+          plugin: "Catalog",
+          views: [],
+          commands: []
+        }],
+      journeys: [
+        {
+          group: "Shopper",
+          components: [{
+              plugin: "Catalog",
+              views: [],
+              commands: []
+            }]
+        },
+        {
+          group: "Fulfilment",
+          components: [{
+              plugin: "Ordering",
+              views: [],
+              commands: []
+            }],
+          key: "fulfil.json"
+        }
+      ]
+    })).toEqual([
+      "component-manifest.json",
+      "component-manifest-shopper.json",
+      "fulfil.json"
+    ]);
+  });
+  globalThis.test("derives a URL-safe key from an awkward group name", () => {
+    globalThis.expect(keysOf({
+      components: [{
+          plugin: "Catalog",
+          views: [],
+          commands: []
+        }],
+      journeys: [{
+          group: "Ops Team/EU",
+          components: []
+        }]
+    })).toEqual([
+      "component-manifest.json",
+      "component-manifest-ops-team-eu.json"
+    ]);
+  });
+  globalThis.test("carries each journey's own selections", () => {
+    let files = BakedManifest$ReventlessLocal.files({
+      components: [{
+          plugin: "Catalog",
+          views: [],
+          commands: []
+        }],
+      journeys: [{
+          group: "Fulfilment",
+          components: [{
+              plugin: "Ordering",
+              views: [],
+              commands: []
+            }]
+        }]
+    });
+    globalThis.expect(files.map(param => param[1].map(s => s.plugin))).toEqual([
+      ["Catalog"],
+      ["Ordering"]
+    ]);
+  });
+});
+
+export {
+  sel,
+  keysOf,
+}
+/*  Not a pure module */