@reventlessdev/reventless-local 3.0.0-alpha.317 → 3.0.0-alpha.319

package/src/adapter/LocalTapLines.res.mjs

@@ -0,0 +1,232 @@
+// 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)).concat(optional("causationId", r.causationId));
+  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;
+  });
+  Stdlib_Option.forEach(r.causationId, id => {
+    annotations["causationId"] = 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/adapter/ProjectionCheckpoint.res.mjs

@@ -273,7 +273,7 @@ async function runCatchup(db, upperBound, dcbUpperBound, handlers) {
       if (checkpoint < bound) {
         let rows = missedRows(db, axis, checkpoint, bound);
         if (rows.length !== 0) {
-          Effect.runSync(EffectLogger$ReventlessCore.logInfo(comp, undefined, `catch-up: delivering ` + rows.length.toString() + ` missed ` + axisLabel(axis) + ` event(s) (positions ` + checkpoint.toString() + `..` + bound.toString() + `] to ` + name));
+          Effect.runSync(EffectLogger$ReventlessCore.logInfo(comp, undefined, undefined, `catch-up: delivering ` + rows.length.toString() + ` missed ` + axisLabel(axis) + ` event(s) (positions ` + checkpoint.toString() + `..` + bound.toString() + `] to ` + name));
         }
         for (let j = 0, j_finish = rows.length; j < j_finish; ++j) {
           let match$2 = rows[j];
@@ -283,10 +283,10 @@ async function runCatchup(db, upperBound, dcbUpperBound, handlers) {
             try {
               await handler(envelope, undefined);
             } catch (exn) {
-              Effect.runSync(EffectLogger$ReventlessCore.logWarn(comp, undefined, `catch-up: ` + name + ` failed on stored ` + axisLabel(axis) + ` event at position ` + pos.toString() + ` — skipped`));
+              Effect.runSync(EffectLogger$ReventlessCore.logWarn(comp, undefined, undefined, `catch-up: ` + name + ` failed on stored ` + axisLabel(axis) + ` event at position ` + pos.toString() + ` — skipped`));
             }
           } else {
-            Effect.runSync(EffectLogger$ReventlessCore.logWarn(comp, undefined, `catch-up: unreadable stored ` + axisLabel(axis) + ` event at position ` + pos.toString() + ` — skipped`));
+            Effect.runSync(EffectLogger$ReventlessCore.logWarn(comp, undefined, undefined, `catch-up: unreadable stored ` + axisLabel(axis) + ` event at position ` + pos.toString() + ` — skipped`));
           }
         }
       }

package/src/components/AutomationSlice_Builder.res.mjs

@@ -59,7 +59,7 @@ function Make(Bus) {
         return await ops.tick(key, at);
       });
       Stdlib_Promise.$$catch(TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(component)).then(ops => ops.reconcileSchedules()), exn => {
-        Effect.runSync(EffectLogger$ReventlessCore.logError(`AutomationSlice(` + Spec.name + `)`, undefined, `the schedules could not be reconciled: ` + Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "unknown")));
+        Effect.runSync(EffectLogger$ReventlessCore.logError(`AutomationSlice(` + Spec.name + `)`, undefined, undefined, `the schedules could not be reconciled: ` + Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "unknown")));
         return Promise.resolve();
       });
       return component;

package/src/components/LocalAutomationSchedules.res.mjs

@@ -18,7 +18,7 @@ function timerName(slice, key) {
 }
 
 function tickFailed(slice, key, message) {
-  Effect.runSync(EffectLogger$ReventlessCore.logError("LocalAutomationSchedules", undefined, `tick ` + key + ` of ` + slice + ` failed: ` + message));
+  Effect.runSync(EffectLogger$ReventlessCore.logError("LocalAutomationSchedules", undefined, undefined, `tick ` + key + ` of ` + slice + ` failed: ` + message));
 }
 
 function register(slice, tick) {

package/src/components/LocalAutomationSweep.res.mjs

@@ -40,7 +40,7 @@ async function sweepOnce() {
       } catch (raw_exn) {
         let exn = Primitive_exceptions.internalToException(raw_exn);
         let message = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "unknown");
-        return Effect.runSync(EffectLogger$ReventlessCore.logError("LocalAutomationSweep", undefined, `sweep of ` + param[0] + ` failed: ` + message));
+        return Effect.runSync(EffectLogger$ReventlessCore.logError("LocalAutomationSweep", undefined, undefined, `sweep of ` + param[0] + ` failed: ` + message));
       }
     });
     running.contents = false;

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/LocalPlatformRegistryTest.res

@@ -199,4 +199,21 @@ describe("LocalPlatformRegistry.tapPort", () => {
 
     expect(LocalPlatformRegistry.list(~cwd, ())->Array.map(e => e.tapPort))->toEqual([Some(4100)])
   })
+
+  testSync("names where the platform API is served, and keeps it when a port is published", () => {
+    let cwd = tempRoot()
+    let _ = LocalPlatformRegistry.write(
+      ~port=4000,
+      ~endpoint="http://localhost:4000/graphql",
+      ~loginEndpoint="http://localhost:4000/__inmemory/login",
+      ~store=memoryStore,
+      ~platformEndpoint="http://localhost:4001/graphql",
+      ~cwd,
+    )
+    LocalPlatformRegistry.publishTapPort(~port=4000, ~tapPort=4100, ~cwd)
+
+    expect(
+      LocalPlatformRegistry.list(~cwd, ())->Array.map(e => (e.platformEndpoint, e.tapPort)),
+    )->toEqual([(Some("http://localhost:4001/graphql"), Some(4100))])
+  })
 })

package/tests/LocalPlatformRegistryTest.res.mjs

@@ -24,7 +24,7 @@ let memoryStore = {
 
 function writeAt(cwd, port, store, pidOpt) {
   let pid = pidOpt !== undefined ? pidOpt : process.pid;
-  return LocalPlatformRegistry$ReventlessLocal.write(port, `http://localhost:` + port.toString() + `/graphql`, `http://localhost:` + port.toString() + `/__inmemory/login`, store, undefined, pid, cwd);
+  return LocalPlatformRegistry$ReventlessLocal.write(port, `http://localhost:` + port.toString() + `/graphql`, `http://localhost:` + port.toString() + `/__inmemory/login`, store, undefined, undefined, pid, cwd);
 }
 
 globalThis.describe("LocalPlatformRegistry", () => {
@@ -173,9 +173,21 @@ globalThis.describe("LocalPlatformRegistry.tapPort", () => {
   globalThis.test("ignores a platform that never published an entry", () => LocalPlatformRegistry$ReventlessLocal.publishTapPort(4000, 1, tempRoot()));
   globalThis.test("round-trips the port a platform serving a tap publishes", () => {
     let cwd = tempRoot();
-    LocalPlatformRegistry$ReventlessLocal.write(4000, "http://localhost:4000/graphql", "http://localhost:4000/__inmemory/login", memoryStore, 4100, undefined, cwd);
+    LocalPlatformRegistry$ReventlessLocal.write(4000, "http://localhost:4000/graphql", "http://localhost:4000/__inmemory/login", memoryStore, 4100, undefined, undefined, cwd);
     globalThis.expect(LocalPlatformRegistry$ReventlessLocal.list(cwd, undefined).map(e => e.tapPort)).toEqual([4100]);
   });
+  globalThis.test("names where the platform API is served, and keeps it when a port is published", () => {
+    let cwd = tempRoot();
+    LocalPlatformRegistry$ReventlessLocal.write(4000, "http://localhost:4000/graphql", "http://localhost:4000/__inmemory/login", memoryStore, undefined, "http://localhost:4001/graphql", undefined, cwd);
+    LocalPlatformRegistry$ReventlessLocal.publishTapPort(4000, 4100, cwd);
+    globalThis.expect(LocalPlatformRegistry$ReventlessLocal.list(cwd, undefined).map(e => [
+      e.platformEndpoint,
+      e.tapPort
+    ])).toEqual([[
+        "http://localhost:4001/graphql",
+        4100
+      ]]);
+  });
 });
 
 let deadPid = 2147483646;

package/tests/LocalPlatformStartTest.res.mjs

@@ -28,7 +28,7 @@ let memoryStore = {
 
 function writeAt(cwd, port, store, pidOpt) {
   let pid = pidOpt !== undefined ? pidOpt : process.pid;
-  return LocalPlatformRegistry$ReventlessLocal.write(port, `http://localhost:` + port.toString() + `/graphql`, `http://localhost:` + port.toString() + `/__inmemory/login`, store, undefined, pid, cwd);
+  return LocalPlatformRegistry$ReventlessLocal.write(port, `http://localhost:` + port.toString() + `/graphql`, `http://localhost:` + port.toString() + `/__inmemory/login`, store, undefined, undefined, pid, cwd);
 }
 
 function withoutBypass(f) {

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),
+      },
+    )
+  })