@reventlessdev/reventless-gwt 1.0.0-alpha.238 → 1.0.0-alpha.240

package/src/Capabilities_Fake.res.mjs

@@ -0,0 +1,254 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Belt_Array from "@rescript/runtime/lib/es6/Belt_Array.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Messaging$Reventless from "@reventlessdev/reventless-spec/src/semantic/Messaging.res.mjs";
+import * as IdentityProvider$Reventless from "@reventlessdev/reventless-spec/src/semantic/IdentityProvider.res.mjs";
+
+function make(geocode, send, channelsOpt, pushServicesOpt, createPrincipal, token, hash, secrets, param) {
+  let channels = channelsOpt !== undefined ? channelsOpt : [
+      "Email",
+      "Sms"
+    ];
+  let pushServices = pushServicesOpt !== undefined ? pushServicesOpt : [];
+  let log = [];
+  let geocode$1 = async text => {
+    log.push({
+      TAG: "Geocoded",
+      text: text
+    });
+    if (geocode !== undefined) {
+      return await geocode(text);
+    } else {
+      return {
+        TAG: "Ok",
+        _0: []
+      };
+    }
+  };
+  let send$1 = async (recipient, message) => {
+    log.push({
+      TAG: "Sent",
+      recipient: recipient,
+      message: message
+    });
+    if (send !== undefined) {
+      return await send(recipient, message);
+    } else {
+      return {
+        TAG: "Ok",
+        _0: {
+          ref: `receipt-` + log.length.toString()
+        }
+      };
+    }
+  };
+  let createPrincipal$1 = async (contact, credential, groups) => {
+    log.push({
+      TAG: "PrincipalCreated",
+      contact: contact,
+      credential: credential,
+      groups: groups
+    });
+    if (createPrincipal !== undefined) {
+      return await createPrincipal(contact, credential, groups);
+    } else {
+      return {
+        TAG: "Ok",
+        _0: {
+          providerId: `principal-` + log.length.toString()
+        }
+      };
+    }
+  };
+  let capabilities_messaging = Messaging$Reventless.makeProvider(channels, pushServices, send$1);
+  let capabilities_identityProvider = IdentityProvider$Reventless.make(createPrincipal$1, async (principal, group) => {
+    log.push({
+      TAG: "AddedToGroup",
+      principal: principal,
+      group: group
+    });
+    return {
+      TAG: "Ok",
+      _0: undefined
+    };
+  }, async (principal, group) => {
+    log.push({
+      TAG: "RemovedFromGroup",
+      principal: principal,
+      group: group
+    });
+    return {
+      TAG: "Ok",
+      _0: undefined
+    };
+  }, async principal => {
+    log.push({
+      TAG: "PrincipalDeleted",
+      principal: principal
+    });
+    return {
+      TAG: "Ok",
+      _0: undefined
+    };
+  }, [
+    "CreatePrincipal",
+    "AddToGroup",
+    "RemoveFromGroup",
+    "DeletePrincipal"
+  ]);
+  let capabilities_secrets = {
+    randomToken: (length, alphabet) => {
+      log.push({
+        TAG: "TokenDrawn",
+        length: length,
+        alphabet: alphabet
+      });
+      if (secrets !== undefined) {
+        return secrets.randomToken(length, alphabet);
+      } else {
+        return {
+          TAG: "Ok",
+          _0: Stdlib_Option.getOr(token, "t".repeat(length))
+        };
+      }
+    },
+    hash: input => {
+      log.push({
+        TAG: "Hashed",
+        input: input
+      });
+      if (secrets !== undefined) {
+        return secrets.hash(input);
+      } else {
+        return {
+          TAG: "Ok",
+          _0: Stdlib_Option.mapOr(hash, `hash:` + input, f => f(input))
+        };
+      }
+    }
+  };
+  let capabilities = {
+    geocode: geocode$1,
+    messaging: capabilities_messaging,
+    identityProvider: capabilities_identityProvider,
+    secrets: capabilities_secrets
+  };
+  return {
+    capabilities: capabilities,
+    calls: () => log.slice()
+  };
+}
+
+function toJson(c) {
+  let recipientText = r => {
+    switch (r.TAG) {
+      case "ToEmail" :
+        return `email:` + r._0;
+      case "ToSms" :
+        return `sms:` + r._0;
+      case "ToPush" :
+        return `push:` + Messaging$Reventless.pushServiceToString(Messaging$Reventless.serviceOf(r._0));
+    }
+  };
+  let obj = (tag, fields) => Object.fromEntries(Belt_Array.concatMany([
+    [[
+        "TAG",
+        tag
+      ]],
+    fields
+  ]));
+  let str = prim => prim;
+  switch (c.TAG) {
+    case "Geocoded" :
+      return obj("Geocoded", [[
+          "text",
+          c.text
+        ]]);
+    case "Sent" :
+      let message = c.message;
+      return obj("Sent", [
+        [
+          "recipient",
+          recipientText(c.recipient)
+        ],
+        [
+          "subject",
+          Stdlib_Option.mapOr(message.subject, null, str)
+        ],
+        [
+          "body",
+          message.body
+        ]
+      ]);
+    case "PrincipalCreated" :
+      return obj("PrincipalCreated", [
+        [
+          "contact",
+          recipientText(c.contact)
+        ],
+        [
+          "groups",
+          c.groups.map(str)
+        ]
+      ]);
+    case "AddedToGroup" :
+      return obj("AddedToGroup", [
+        [
+          "principal",
+          c.principal.providerId
+        ],
+        [
+          "group",
+          c.group
+        ]
+      ]);
+    case "RemovedFromGroup" :
+      return obj("RemovedFromGroup", [
+        [
+          "principal",
+          c.principal.providerId
+        ],
+        [
+          "group",
+          c.group
+        ]
+      ]);
+    case "PrincipalDeleted" :
+      return obj("PrincipalDeleted", [[
+          "principal",
+          c.principal.providerId
+        ]]);
+    case "TokenDrawn" :
+      return obj("TokenDrawn", [[
+          "length",
+          c.length
+        ]]);
+    case "Hashed" :
+      return obj("Hashed", [[
+          "input",
+          c.input
+        ]]);
+  }
+}
+
+let Capabilities;
+
+let Geocoding;
+
+let Messaging;
+
+let IdentityProvider;
+
+let Secrets;
+
+export {
+  Capabilities,
+  Geocoding,
+  Messaging,
+  IdentityProvider,
+  Secrets,
+  make,
+  toJson,
+}
+/* No side effect */

package/src/Flow_GWT.res

@@ -20,7 +20,7 @@ open ReventlessCore
 // pipe-first so it reads top-to-bottom:
 //
 //   module Place = Flow_GWT.CommandStep(PlaceOrder, PlaceOrder_Behavior)
-//   module Auto  = Flow_GWT.AutomationStep(AutoShipOrderSlice)
+//   module Auto  = Flow_GWT.AutomationSlice(AutoShipOrder, AutoShipOrder_Automation)
 //   module Ship  = Flow_GWT.CommandStep(ShipOrder, ShipOrder_Behavior)
 //   module View  = Flow_GWT.ViewStep(Orders, Orders_Projection)
 //
@@ -77,6 +77,8 @@ type flowState = {
   // step falls back to the synthetic `gwt-id` so the existing DCB Flow tests
   // are unchanged.
   lastAggregateId: option<string>,
+  // Why the last inbound step produced no commands, when it was refused.
+  lastRefusal: option<string>,
 }
 
 type flow = promise<flowState>
@@ -89,6 +91,7 @@ let emptyState = {
   lastCommands: [],
   lastPublic: [],
   lastAggregateId: None,
+  lastRefusal: None,
 }
 
 // Entry point for a chain — an empty flow with no prior history.
@@ -489,6 +492,8 @@ module AggregateCommandStep = (
 
 // -- AutomationStep: a policy that reacts to log events and issues a command --
 
+// Deprecated: takes an adapter. Use `AutomationSlice`; this goes one release
+// after the examples have moved.
 module AutomationStep = (Spec: Automation_GWT.SliceSpec) => {
   let consumedDecoder = Reventless.DcbDecode.makeDecoder(Spec.consumedEventSchema)
 
@@ -558,6 +563,8 @@ module ViewStep = (
 
 // -- OutboundStep: an OutboundTranslationSlice's `collect` over the log -------
 
+// Deprecated: takes an adapter. Use `OutboundSlice`; this goes one release
+// after the examples have moved.
 module OutboundStep = (Spec: OutboundTranslation_GWT.SliceSpec) => {
   let consumedDecoder = Reventless.DcbDecode.makeDecoder(Spec.consumedEventSchema)
 
@@ -587,6 +594,110 @@ module OutboundStep = (Spec: OutboundTranslation_GWT.SliceSpec) => {
   let thenOutboundNothing = flowP => thenOutbound(flowP, [])
 }
 
+// -- Slice-as-written steps --------------------------------------------------
+//
+// The same steps over a slice's `Spec` and body, with no adapter. The log keeps
+// no source name, so every mapping is offered every entry; the source id is the
+// producing aggregate's, or "" for a DCB event, which names its own subject.
+
+let sourceIdOf = (entry: logEntry) => entry.aggregateId->Option.getOr("")
+
+let encodedCommandsMatch = async (flowP: flow, expJson: array<JSON.t>) => {
+  let s = await flowP
+  let o = switch s.lastRefusal {
+  | Some(reason) => Outcome.fail(TranslateError({expected: "(commands)", actual: Some(reason)}))
+  | None =>
+    s.lastCommands == expJson
+      ? Outcome.pass
+      : Outcome.fail(EventsMismatch({expected: expJson, actual: s.lastCommands}))
+  }
+  s->recordOutcome(o)
+}
+
+module AutomationSlice = (
+  Spec: Reventless.AutomationSlice.Spec,
+  Automation: Reventless.AutomationSlice.Automation with module Spec := Spec,
+) => {
+  module A = Automation_GWT.FromSlice(Spec, Automation)
+
+  let whenReacts = async (flowP: flow) => {
+    let s = await flowP
+    let routed =
+      s.log->Array.flatMap(entry =>
+        A.Route.dispatches->Array.filterMap(d =>
+          d.handle(entry.json, ~sourceId=entry->sourceIdOf, A.testContext)
+        )
+      )
+    let {commands, _} = A.sweep(routed)
+    {
+      ...s,
+      lastCommands: commands->Array.map(((_id, cmd)) => cmd->Message.encode(Spec.commandSchema)),
+      lastRefusal: None,
+    }
+  }
+
+  let thenIssuesCommands = (flowP, expected: array<Spec.command>) =>
+    encodedCommandsMatch(flowP, expected->Array.map(c => c->Message.encode(Spec.commandSchema)))
+  let thenIssuesCommand = (flowP, command) => thenIssuesCommands(flowP, [command])
+  let thenIssuesNoCommand = flowP => thenIssuesCommands(flowP, [])
+}
+
+module OutboundSlice = (
+  Spec: Reventless.OutboundTranslationSlice.Spec,
+  Translation: Reventless.OutboundTranslationSlice.Translation with module Spec := Spec,
+) => {
+  let consumedDecoder = Reventless.DcbDecode.makeDecoder(Spec.consumedEventSchema)
+
+  let encItems = (arr: array<(string, Spec.outboundItem)>) =>
+    arr->Array.map(((id, item)) => (id, item->Message.encode(Spec.outboundItemSchema)))
+
+  // Asserts what `collect` queues; `translate` is the slice test's to run.
+  let thenOutbound = async (flowP: flow, expected: array<(string, Spec.outboundItem)>) => {
+    let s = await flowP
+    let collected =
+      s.log->Array.flatMap(entry =>
+        decodeMatching([entry], consumedDecoder, [])->Array.flatMap(e =>
+          Translation.collect(e, ~sourceId=entry->sourceIdOf)
+        )
+      )
+    let actual = encItems(collected)
+    let expectedJson = encItems(expected)
+    let o =
+      actual == expectedJson
+        ? Outcome.pass
+        : Outcome.fail(TodoMismatch({expected: expectedJson, actual}))
+    s->recordOutcome(o)
+  }
+
+  let thenOutboundNothing = flowP => thenOutbound(flowP, [])
+}
+
+module InboundSlice = (
+  Spec: Reventless.InboundTranslationSlice.Spec,
+  Translation: Reventless.InboundTranslationSlice.Translation with module Spec := Spec,
+) => {
+  module I = InboundTranslation_GWT.FromSlice(Spec, Translation)
+
+  // Received input becomes the flow's next commands, as an automation's do.
+  let whenReceived = async (flowP: flow, json: JSON.t) => {
+    let s = await flowP
+    switch I.whenReceived(json) {
+    | Translated(pairs) => {
+        ...s,
+        lastCommands: pairs->Array.map(((_id, cmd)) => cmd->Message.encode(Spec.commandSchema)),
+        lastRefusal: None,
+      }
+    | NotUnderstood(msg) => {...s, lastCommands: [], lastRefusal: Some(`not understood: ${msg}`)}
+    | InputRefused(msg) => {...s, lastCommands: [], lastRefusal: Some(`input refused: ${msg}`)}
+    }
+  }
+
+  let thenIssuesCommands = (flowP, expected: array<Spec.command>) =>
+    encodedCommandsMatch(flowP, expected->Array.map(c => c->Message.encode(Spec.commandSchema)))
+  let thenIssuesCommand = (flowP, command) => thenIssuesCommands(flowP, [command])
+  let thenIssuesNoCommand = flowP => thenIssuesCommands(flowP, [])
+}
+
 // -- Cross-plugin boundary steps (Phase 3) -----------------------------------
 
 // Order-independent comparison for published actions — fan-out order is

package/src/Flow_GWT.res.mjs

@@ -14,8 +14,10 @@ import * as JestBind$ReventlessGwt from "./JestBind.res.mjs";
 import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Message.res.mjs";
 import * as DcbValidation$Reventless from "@reventlessdev/reventless-spec/src/components/DcbValidation.res.mjs";
 import * as StubRuntime$ReventlessGwt from "./StubRuntime.res.mjs";
+import * as Automation_GWT$ReventlessGwt from "./Automation_GWT.res.mjs";
 import * as DcbScopeInference$Reventless from "@reventlessdev/reventless-spec/src/components/DcbScopeInference.res.mjs";
 import * as Projection_GWT$ReventlessGwt from "./Projection_GWT.res.mjs";
+import * as InboundTranslation_GWT$ReventlessGwt from "./InboundTranslation_GWT.res.mjs";
 
 let emptyState_log = [];
 
@@ -32,7 +34,8 @@ let emptyState = {
   lastError: undefined,
   lastCommands: emptyState_lastCommands,
   lastPublic: emptyState_lastPublic,
-  lastAggregateId: undefined
+  lastAggregateId: undefined,
+  lastRefusal: undefined
 };
 
 let start = Promise.resolve(emptyState);
@@ -47,7 +50,8 @@ function recordOutcome(s, o) {
       lastError: s.lastError,
       lastCommands: s.lastCommands,
       lastPublic: s.lastPublic,
-      lastAggregateId: s.lastAggregateId
+      lastAggregateId: s.lastAggregateId,
+      lastRefusal: s.lastRefusal
     };
   } else {
     return s;
@@ -179,7 +183,8 @@ function CommandStep(Spec) {
         lastError: s.lastError,
         lastCommands: s.lastCommands,
         lastPublic: s.lastPublic,
-        lastAggregateId: s.lastAggregateId
+        lastAggregateId: s.lastAggregateId,
+        lastRefusal: s.lastRefusal
       };
     };
     let scopeShape = DcbTag$Reventless.sliceShapeFromSchemas("", Spec.commandSchema, Spec.consumedEventSchema, Spec.eventSchema, undefined);
@@ -212,7 +217,8 @@ function CommandStep(Spec) {
           lastError: Message$ReventlessCore.encode(events._0, Spec.errorSchema),
           lastCommands: s.lastCommands,
           lastPublic: s.lastPublic,
-          lastAggregateId: undefined
+          lastAggregateId: undefined,
+          lastRefusal: s.lastRefusal
         };
       }
       let events$1 = events._0;
@@ -223,7 +229,8 @@ function CommandStep(Spec) {
         lastError: undefined,
         lastCommands: s.lastCommands,
         lastPublic: s.lastPublic,
-        lastAggregateId: undefined
+        lastAggregateId: undefined,
+        lastRefusal: s.lastRefusal
       };
     };
     let thenEvents = async (flowP, expected) => {
@@ -292,7 +299,8 @@ function AggregateCommandStep(Spec) {
         lastError: s.lastError,
         lastCommands: s.lastCommands,
         lastPublic: s.lastPublic,
-        lastAggregateId: s.lastAggregateId
+        lastAggregateId: s.lastAggregateId,
+        lastRefusal: s.lastRefusal
       };
     };
     let whenCommand = async (flowP, id, command) => {
@@ -308,7 +316,8 @@ function AggregateCommandStep(Spec) {
           lastError: Message$ReventlessCore.encode(events._0, Spec.errorSchema),
           lastCommands: s.lastCommands,
           lastPublic: s.lastPublic,
-          lastAggregateId: id
+          lastAggregateId: id,
+          lastRefusal: s.lastRefusal
         };
       }
       let events$1 = events._0;
@@ -319,7 +328,8 @@ function AggregateCommandStep(Spec) {
         lastError: undefined,
         lastCommands: s.lastCommands,
         lastPublic: s.lastPublic,
-        lastAggregateId: id
+        lastAggregateId: id,
+        lastRefusal: s.lastRefusal
       };
     };
     let thenEvents = async (flowP, expected) => {
@@ -404,7 +414,8 @@ function AutomationStep(Spec) {
       lastError: s.lastError,
       lastCommands: commands.map(param => Message$ReventlessCore.encode(param[1], Spec.commandSchema)),
       lastPublic: s.lastPublic,
-      lastAggregateId: s.lastAggregateId
+      lastAggregateId: s.lastAggregateId,
+      lastRefusal: s.lastRefusal
     };
   };
   let thenIssuesCommands = async (flowP, expected) => {
@@ -486,6 +497,142 @@ function OutboundStep(Spec) {
   };
 }
 
+function sourceIdOf(entry) {
+  return Stdlib_Option.getOr(entry.aggregateId, "");
+}
+
+async function encodedCommandsMatch(flowP, expJson) {
+  let s = await flowP;
+  let reason = s.lastRefusal;
+  let o = reason !== undefined ? Outcome$ReventlessGwt.fail({
+      TAG: "TranslateError",
+      expected: "(commands)",
+      actual: reason
+    }) : (
+      Primitive_object.equal(s.lastCommands, expJson) ? Outcome$ReventlessGwt.pass : Outcome$ReventlessGwt.fail({
+          TAG: "EventsMismatch",
+          expected: expJson,
+          actual: s.lastCommands
+        })
+    );
+  return recordOutcome(s, o);
+}
+
+function AutomationSlice(Spec) {
+  return Automation => {
+    let A = Automation_GWT$ReventlessGwt.FromSlice(Spec)(Automation);
+    let whenReacts = async flowP => {
+      let s = await flowP;
+      let routed = s.log.flatMap(entry => Stdlib_Array.filterMap(A.Route.dispatches, d => d.handle(entry.json, Stdlib_Option.getOr(entry.aggregateId, ""), A.testContext)));
+      let match = A.sweep(routed);
+      return {
+        log: s.log,
+        outcome: s.outcome,
+        lastEvents: s.lastEvents,
+        lastError: s.lastError,
+        lastCommands: match.commands.map(param => Message$ReventlessCore.encode(param[1], Spec.commandSchema)),
+        lastPublic: s.lastPublic,
+        lastAggregateId: s.lastAggregateId,
+        lastRefusal: undefined
+      };
+    };
+    let thenIssuesCommands = (flowP, expected) => encodedCommandsMatch(flowP, expected.map(c => Message$ReventlessCore.encode(c, Spec.commandSchema)));
+    let thenIssuesCommand = (flowP, command) => thenIssuesCommands(flowP, [command]);
+    let thenIssuesNoCommand = flowP => thenIssuesCommands(flowP, []);
+    return {
+      A: A,
+      whenReacts: whenReacts,
+      thenIssuesCommands: thenIssuesCommands,
+      thenIssuesCommand: thenIssuesCommand,
+      thenIssuesNoCommand: thenIssuesNoCommand
+    };
+  };
+}
+
+function OutboundSlice(Spec) {
+  return Translation => {
+    let consumedDecoder = DcbDecode$Reventless.makeDecoder(Spec.consumedEventSchema);
+    let encItems = arr => arr.map(param => [
+      param[0],
+      Message$ReventlessCore.encode(param[1], Spec.outboundItemSchema)
+    ]);
+    let thenOutbound = async (flowP, expected) => {
+      let s = await flowP;
+      let collected = s.log.flatMap(entry => decodeMatching([entry], consumedDecoder, []).flatMap(e => Translation.collect(e, Stdlib_Option.getOr(entry.aggregateId, ""))));
+      let actual = encItems(collected);
+      let expectedJson = encItems(expected);
+      let o = Primitive_object.equal(actual, expectedJson) ? Outcome$ReventlessGwt.pass : Outcome$ReventlessGwt.fail({
+          TAG: "TodoMismatch",
+          expected: expectedJson,
+          actual: actual
+        });
+      return recordOutcome(s, o);
+    };
+    let thenOutboundNothing = flowP => thenOutbound(flowP, []);
+    return {
+      consumedDecoder: consumedDecoder,
+      encItems: encItems,
+      thenOutbound: thenOutbound,
+      thenOutboundNothing: thenOutboundNothing
+    };
+  };
+}
+
+function InboundSlice(Spec) {
+  return Translation => {
+    let I = InboundTranslation_GWT$ReventlessGwt.FromSlice(Spec)(Translation);
+    let whenReceived = async (flowP, json) => {
+      let s = await flowP;
+      let pairs = I.whenReceived(json);
+      switch (pairs.TAG) {
+        case "Translated" :
+          return {
+            log: s.log,
+            outcome: s.outcome,
+            lastEvents: s.lastEvents,
+            lastError: s.lastError,
+            lastCommands: pairs._0.map(param => Message$ReventlessCore.encode(param[1], Spec.commandSchema)),
+            lastPublic: s.lastPublic,
+            lastAggregateId: s.lastAggregateId,
+            lastRefusal: undefined
+          };
+        case "NotUnderstood" :
+          return {
+            log: s.log,
+            outcome: s.outcome,
+            lastEvents: s.lastEvents,
+            lastError: s.lastError,
+            lastCommands: [],
+            lastPublic: s.lastPublic,
+            lastAggregateId: s.lastAggregateId,
+            lastRefusal: `not understood: ` + pairs._0
+          };
+        case "InputRefused" :
+          return {
+            log: s.log,
+            outcome: s.outcome,
+            lastEvents: s.lastEvents,
+            lastError: s.lastError,
+            lastCommands: [],
+            lastPublic: s.lastPublic,
+            lastAggregateId: s.lastAggregateId,
+            lastRefusal: `input refused: ` + pairs._0
+          };
+      }
+    };
+    let thenIssuesCommands = (flowP, expected) => encodedCommandsMatch(flowP, expected.map(c => Message$ReventlessCore.encode(c, Spec.commandSchema)));
+    let thenIssuesCommand = (flowP, command) => thenIssuesCommands(flowP, [command]);
+    let thenIssuesNoCommand = flowP => thenIssuesCommands(flowP, []);
+    return {
+      I: I,
+      whenReceived: whenReceived,
+      thenIssuesCommands: thenIssuesCommands,
+      thenIssuesCommand: thenIssuesCommand,
+      thenIssuesNoCommand: thenIssuesNoCommand
+    };
+  };
+}
+
 function sortJson(arr) {
   return arr.toSorted((a, b) => Primitive_string.compare(JSON.stringify(a), JSON.stringify(b)));
 }
@@ -526,7 +673,8 @@ function ExtensionPointStep(M) {
       lastError: s.lastError,
       lastCommands: s.lastCommands,
       lastPublic: publicEvents.map(e => Message$ReventlessCore.encode(e, M.ExtensionPoint.eventSchema)),
-      lastAggregateId: s.lastAggregateId
+      lastAggregateId: s.lastAggregateId,
+      lastRefusal: s.lastRefusal
     };
   };
   let thenPublicEvents = async (flowP, expected) => {
@@ -587,7 +735,8 @@ function ExtensionStep(M) {
       lastError: s.lastError,
       lastCommands: nested.flat(),
       lastPublic: s.lastPublic,
-      lastAggregateId: s.lastAggregateId
+      lastAggregateId: s.lastAggregateId,
+      lastRefusal: s.lastRefusal
     };
   };
   let thenIssuesCommands = async (flowP, expected) => {
@@ -637,6 +786,11 @@ export {
   AutomationStep,
   ViewStep,
   OutboundStep,
+  sourceIdOf,
+  encodedCommandsMatch,
+  AutomationSlice,
+  OutboundSlice,
+  InboundSlice,
   sortJson,
   ExtensionPointStep,
   ExtensionStep,