@reventlessdev/reventless-local 3.0.0-alpha.316 → 3.0.0-alpha.318

package/src/adapter/LocalTapLines.res.mjs

@@ -0,0 +1,229 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+import * as Logger$ReventlessCore from "@reventlessdev/reventless-core/src/util/Logger.res.mjs";
+import * as LogRedaction$Reventless from "@reventlessdev/reventless-spec/src/util/LogRedaction.res.mjs";
+import * as ViewChange$ReventlessCore from "@reventlessdev/reventless-core/src/ViewChange.res.mjs";
+import * as LocalLogFeed$ReventlessLocal from "./LocalLogFeed.res.mjs";
+import * as LocalEventTap$ReventlessLocal from "./LocalEventTap.res.mjs";
+import * as CommandTopic_Helpers$ReventlessCore from "@reventlessdev/reventless-core/src/components/CommandTopic/CommandTopic_Helpers.res.mjs";
+
+function str(prim) {
+  return prim;
+}
+
+function now() {
+  return new Date().toISOString();
+}
+
+function lineOf(fields) {
+  return JSON.stringify(Object.fromEntries(fields));
+}
+
+function optional(name, value) {
+  return Stdlib_Option.mapOr(value, [], v => [[
+      name,
+      v
+    ]]);
+}
+
+function compOf(r) {
+  return `CommandTopic(` + r.component + `)`;
+}
+
+function pluginOf(r) {
+  return Logger$ReventlessCore.resolvePlugin(compOf(r), undefined);
+}
+
+function outcomeLine(r) {
+  let plugin = pluginOf(r);
+  let head = [
+    [
+      "kind",
+      "commandOutcome"
+    ],
+    [
+      "component",
+      r.component
+    ]
+  ].concat(optional("plugin", plugin)).concat([[
+      "msgId",
+      r.reference
+    ]]).concat(optional("correlationId", r.correlationId));
+  let match = r.outcome;
+  let body;
+  body = match.TAG === "OutcomeAccepted" ? [[
+        "outcome",
+        "accepted"
+      ]].concat(optional("entityId", match.entityId)).concat([[
+        "eventCount",
+        match.eventCount
+      ]]) : [
+      [
+        "outcome",
+        "rejected"
+      ],
+      [
+        "errorCode",
+        match.errorCode
+      ],
+      [
+        "cause",
+        CommandTopic_Helpers$ReventlessCore.refusalCauseToGraphQL(match.cause)
+      ]
+    ];
+  return lineOf(head.concat(body).concat([[
+      "ts",
+      new Date().toISOString()
+    ]]));
+}
+
+function rejectionRecord(r) {
+  let match = r.outcome;
+  if (match.TAG === "OutcomeAccepted") {
+    return;
+  }
+  let cause = match.cause;
+  let errorDetail = match.errorDetail;
+  let level;
+  switch (cause) {
+    case "InfrastructureFailure" :
+      level = "Error";
+      break;
+    case "DomainRejection" :
+    case "AccessRefusal" :
+      level = "Warn";
+      break;
+  }
+  let detailJson;
+  if (errorDetail === "") {
+    detailJson = [];
+  } else {
+    let parsed;
+    try {
+      parsed = JSON.parse(errorDetail);
+    } catch (exn) {
+      parsed = errorDetail;
+    }
+    detailJson = [[
+        "errorDetail",
+        Logger$ReventlessCore.truncateDetail(LogRedaction$Reventless.redactJson(parsed))
+      ]];
+  }
+  let annotations = Object.fromEntries([[
+      "msgId",
+      r.reference
+    ]]);
+  Stdlib_Option.forEach(r.correlationId, id => {
+    annotations["correlationId"] = id;
+  });
+  return {
+    time: new Date().toISOString(),
+    level: level,
+    message: "command rejected",
+    service: Logger$ReventlessCore.serviceName(),
+    plugin: pluginOf(r),
+    comp: compOf(r),
+    annotations: annotations,
+    detail: Object.fromEntries([
+      [
+        "component",
+        r.component
+      ],
+      [
+        "errorCode",
+        match.errorCode
+      ],
+      [
+        "cause",
+        CommandTopic_Helpers$ReventlessCore.refusalCauseToGraphQL(cause)
+      ]
+    ].concat(detailJson))
+  };
+}
+
+function onOutcome(r) {
+  Stdlib_Option.forEach(rejectionRecord(r), LocalLogFeed$ReventlessLocal.keepProblem);
+  if (LocalEventTap$ReventlessLocal.hasReaders()) {
+    return LocalEventTap$ReventlessLocal.publish({
+      line: outcomeLine(r),
+      facets: {
+        plugin: pluginOf(r),
+        correlationId: r.correlationId
+      }
+    });
+  }
+}
+
+function viewChangeLine(c) {
+  let side = (name, value) => Stdlib_Option.mapOr(value, [], v => [[
+      name,
+      Logger$ReventlessCore.truncateDetail(LogRedaction$Reventless.redactJson(v))
+    ]]);
+  return lineOf([[
+      "kind",
+      "viewChange"
+    ]].concat(ViewChange$ReventlessCore.summaryFields(c)).concat(optional("correlationId", c.correlationId)).concat(side("before", c.before)).concat(side("after", c.after)).concat([[
+      "ts",
+      new Date().toISOString()
+    ]]));
+}
+
+function onViewChange(c) {
+  if (LocalEventTap$ReventlessLocal.hasReaders()) {
+    return LocalEventTap$ReventlessLocal.publish({
+      line: viewChangeLine(c),
+      facets: {
+        plugin: Logger$ReventlessCore.resolvePlugin(`View(` + c.view + `)`, undefined),
+        correlationId: c.correlationId
+      }
+    });
+  }
+}
+
+let removals = {
+  contents: []
+};
+
+function install() {
+  if (Primitive_object.equal(removals.contents, [])) {
+    removals.contents = [
+      CommandTopic_Helpers$ReventlessCore.registerCommandOutcome(onOutcome),
+      ViewChange$ReventlessCore.register(onViewChange)
+    ];
+    return;
+  }
+}
+
+function resetForTests() {
+  removals.contents.forEach(remove => remove());
+  removals.contents = [];
+}
+
+let Logger;
+
+let Outcome;
+
+let ViewChange;
+
+export {
+  Logger,
+  Outcome,
+  ViewChange,
+  str,
+  now,
+  lineOf,
+  optional,
+  compOf,
+  pluginOf,
+  outcomeLine,
+  rejectionRecord,
+  onOutcome,
+  viewChangeLine,
+  onViewChange,
+  removals,
+  install,
+  resetForTests,
+}
+/* Logger-ReventlessCore Not a pure module */

package/src/adapter/PlatformGraphQL_Server.res

@@ -8,8 +8,8 @@
 // Does NOT include Relay-specific features (encodeGlobalId, node resolver)
 // since admin queries are not Relay-paginated.
 //
-// Authorization: every query AND mutation resolver registered here is
-// wrapped with `Auth_GraphqlContext.requireGroup(~group="Admin")` so
+// Authorization: every query, mutation AND subscription resolver registered
+// here is wrapped with `Auth_GraphqlContext.requireGroup(~group="Admin")` so
 // non-Admin identities are refused before the underlying resolver runs.
 // Mirrors AppSync's `@aws_cognito_user_pools(cognito_groups: ["Admin"])`
 // directive that gates Platform_* fields in the AWS adapter.
@@ -46,11 +46,44 @@ let wrapAdmin = (resolvers: dict<ReventlessGraphqlServer.GraphQL_ServerInstance.
   wrapped
 }
 
+// A subscription field's resolver is an object: `subscribe` starts the stream,
+// `resolve` maps each payload. The group check goes on `subscribe`, so a caller
+// without the group is refused before anything is streamed to it.
+type subscriptionResolver = {
+  subscribe: ReventlessGraphqlServer.GraphQL_ServerInstance.resolverFn,
+  resolve?: JSON.t => JSON.t,
+}
+external asSubscription: ReventlessGraphqlServer.GraphQL_ServerInstance.resolverFn => subscriptionResolver =
+  "%identity"
+external ofSubscription: subscriptionResolver => ReventlessGraphqlServer.GraphQL_ServerInstance.resolverFn =
+  "%identity"
+
+let wrapAdminSubscriptions = (
+  resolvers: dict<ReventlessGraphqlServer.GraphQL_ServerInstance.resolverFn>,
+): dict<ReventlessGraphqlServer.GraphQL_ServerInstance.resolverFn> =>
+  resolvers
+  ->Dict.toArray
+  ->Array.map(((k, v)) => {
+    let sub = asSubscription(v)
+    (
+      k,
+      ofSubscription({
+        ...sub,
+        subscribe: Auth_GraphqlContext.requireGroup(
+          ~group=Reventless.Role.adminGroup(),
+          sub.subscribe,
+        ),
+      }),
+    )
+  })
+  ->Dict.fromArray
+
 let registerMutations = (~sdlFields, ~resolvers) =>
   instance.registerMutations(~sdlFields, ~resolvers=wrapAdmin(resolvers))
 let registerQueries = (~sdlFields, ~resolvers) =>
   instance.registerQueries(~sdlFields, ~resolvers=wrapAdmin(resolvers))
-let registerSubscriptions = instance.registerSubscriptions
+let registerSubscriptions = (~sdlFields, ~resolvers) =>
+  instance.registerSubscriptions(~sdlFields, ~resolvers=wrapAdminSubscriptions(resolvers))
 let registerTypes = instance.registerTypes
 // Not admin-wrapped: a field resolver is only reached through a parent field
 // that already met the group check, so wrapping would re-refuse a caller the

package/src/adapter/PlatformGraphQL_Server.res.mjs

@@ -14,6 +14,17 @@ function wrapAdmin(resolvers) {
   return wrapped;
 }
 
+function wrapAdminSubscriptions(resolvers) {
+  return Object.fromEntries(Object.entries(resolvers).map(param => {
+    let v = param[1];
+    let newrecord = {...v};
+    return [
+      param[0],
+      (newrecord.subscribe = Auth_GraphqlContext$ReventlessLocal.requireGroup(Role$Reventless.adminGroup(), v.subscribe), newrecord)
+    ];
+  }));
+}
+
 function registerMutations(sdlFields, resolvers) {
   instance.registerMutations(sdlFields, wrapAdmin(resolvers));
 }
@@ -22,7 +33,9 @@ function registerQueries(sdlFields, resolvers) {
   instance.registerQueries(sdlFields, wrapAdmin(resolvers));
 }
 
-let registerSubscriptions = instance.registerSubscriptions;
+function registerSubscriptions(sdlFields, resolvers) {
+  instance.registerSubscriptions(sdlFields, wrapAdminSubscriptions(resolvers));
+}
 
 let registerTypes = instance.registerTypes;
 
@@ -69,6 +82,7 @@ let asInterface = {
 export {
   instance,
   wrapAdmin,
+  wrapAdminSubscriptions,
   registerMutations,
   registerQueries,
   registerSubscriptions,

package/src/reexport/CommandTopic.res.mjs

@@ -8,7 +8,9 @@ let NotPublishedToChannel = CommandTopic$ReventlessCore.NotPublishedToChannel;
 
 let refusalCauseToGraphQL = CommandTopic$ReventlessCore.refusalCauseToGraphQL;
 
-let commandOutcomeHook = CommandTopic$ReventlessCore.commandOutcomeHook;
+let commandOutcomeHooks = CommandTopic$ReventlessCore.commandOutcomeHooks;
+
+let nextOutcomeHookId = CommandTopic$ReventlessCore.nextOutcomeHookId;
 
 let registerCommandOutcome = CommandTopic$ReventlessCore.registerCommandOutcome;
 
@@ -50,7 +52,8 @@ export {
   componentType,
   NotPublishedToChannel,
   refusalCauseToGraphQL,
-  commandOutcomeHook,
+  commandOutcomeHooks,
+  nextOutcomeHookId,
   registerCommandOutcome,
   clearCommandOutcome,
   fireCommandOutcome,

package/tests/adapter/GraphQLWsFixtures.mjs

@@ -0,0 +1,46 @@
+// A graphql-ws client for the subscription tests, here rather than in an
+// `Obj.magic` inside the test, per the repo convention that untyped reflection
+// lives in a companion `.mjs`.
+import { createClient } from 'graphql-ws'
+import WebSocket from 'ws'
+
+/** Subscribes, collects values until `count` arrive (or an error or `timeoutMs`),
+    calling `onStarted` once the server acknowledged the connection. Resolves
+    `{ values, error }`; `error` is the first error message, if any. */
+export const collect = (url, query, connectionParams, count, timeoutMs, onStarted) =>
+  new Promise(resolve => {
+    const values = []
+    let settled = false
+    const client = createClient({
+      url,
+      webSocketImpl: WebSocket,
+      connectionParams,
+      lazy: false,
+      retryAttempts: 0,
+      on: { connected: () => onStarted() },
+    })
+    const finish = error => {
+      if (settled) return
+      settled = true
+      clearTimeout(timer)
+      dispose()
+      client.dispose()
+      resolve({ values, error })
+    }
+    const timer = setTimeout(() => finish(undefined), timeoutMs)
+    const dispose = client.subscribe(
+      { query },
+      {
+        next: msg => {
+          if (msg.errors && msg.errors.length > 0) return finish(String(msg.errors[0].message))
+          values.push(Object.values(msg.data)[0])
+          if (values.length >= count) finish(undefined)
+        },
+        error: err => {
+          const m = Array.isArray(err) ? err[0]?.message : err?.message ?? err?.reason ?? String(err)
+          finish(String(m))
+        },
+        complete: () => finish(undefined),
+      },
+    )
+  })