@reventlessdev/reventless-core 3.0.0-alpha.179 → 3.0.0-alpha.181

package/tests/extensionpoint/ExtensionPointCallbackTest.res.mjs

@@ -0,0 +1,94 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import * as ExtensionPointFixtures$ReventlessCore from "./ExtensionPointFixtures.res.mjs";
+
+globalThis.beforeEach(() => ExtensionPointFixtures$ReventlessCore.reset());
+
+globalThis.describe("ExtensionPoint_Callback.handleIncomingCommands:", () => {
+  globalThis.describe("AbstractPublishCommand — known aggregate", () => {
+    globalThis.test("dispatches to aggregate publishJsons, returns Ok(reference)", async () => {
+      let results = await Effect.runPromise(ExtensionPointFixtures$ReventlessCore.TestHandler.handleIncomingCommands(Stream.fromIterable([ExtensionPointFixtures$ReventlessCore.makeTopicItem("ref-1", {
+          TAG: "RouteToAgg",
+          aggId: "agg-1"
+        })])));
+      globalThis.expect([
+        results,
+        ExtensionPointFixtures$ReventlessCore.capturedPublishedCmds.contents.length
+      ]).toEqual([
+        [{
+            TAG: "Ok",
+            _0: "ref-1"
+          }],
+        1
+      ]);
+    });
+  });
+  globalThis.describe("AbstractPublishCommand — unknown aggregate", () => {
+    globalThis.test("throws internally, returns Error(reference)", async () => {
+      let results = await Effect.runPromise(ExtensionPointFixtures$ReventlessCore.TestHandler.handleIncomingCommands(Stream.fromIterable([
+        ExtensionPointFixtures$ReventlessCore.makeTopicItem("ref-a", {
+          TAG: "RouteToAgg",
+          aggId: "agg-1"
+        }),
+        ExtensionPointFixtures$ReventlessCore.makeTopicItem("ref-b", {
+          TAG: "RouteToAgg",
+          aggId: "agg-2"
+        })
+      ])));
+      globalThis.expect(results.length).toBe(2);
+      let allOk = results.every(r => r.TAG === "Ok");
+      globalThis.expect(allOk).toBe(true);
+    });
+  });
+  globalThis.describe("AbstractHandleDirective handler succeeds", () => {
+    globalThis.test("handler called, returns Ok(reference)", async () => {
+      let results = await Effect.runPromise(ExtensionPointFixtures$ReventlessCore.TestHandler.handleIncomingCommands(Stream.fromIterable([ExtensionPointFixtures$ReventlessCore.makeTopicItem("ref-1", {
+          TAG: "TriggerDirective",
+          value: "test"
+        })])));
+      globalThis.expect([
+        results,
+        ExtensionPointFixtures$ReventlessCore.capturedCallCount.contents
+      ]).toEqual([
+        [{
+            TAG: "Ok",
+            _0: "ref-1"
+          }],
+        1
+      ]);
+    });
+  });
+  globalThis.describe("mixed actions", () => {
+    globalThis.test("AbstractPublishCommand and AbstractHandleDirective both resolved", async () => {
+      let results = await Effect.runPromise(ExtensionPointFixtures$ReventlessCore.TestHandler.handleIncomingCommands(Stream.fromIterable([
+        ExtensionPointFixtures$ReventlessCore.makeTopicItem("ref-pub", {
+          TAG: "RouteToAgg",
+          aggId: "agg-1"
+        }),
+        ExtensionPointFixtures$ReventlessCore.makeTopicItem("ref-call", {
+          TAG: "TriggerDirective",
+          value: "v"
+        })
+      ])));
+      globalThis.expect([
+        results.length,
+        ExtensionPointFixtures$ReventlessCore.capturedPublishedCmds.contents.length,
+        ExtensionPointFixtures$ReventlessCore.capturedCallCount.contents
+      ]).toEqual([
+        2,
+        1,
+        1
+      ]);
+    });
+  });
+  globalThis.describe("empty batch", () => {
+    globalThis.test("returns empty array", async () => {
+      let results = await Effect.runPromise(ExtensionPointFixtures$ReventlessCore.TestHandler.handleIncomingCommands(Stream.fromIterable([])));
+      globalThis.expect(results).toEqual([]);
+    });
+  });
+});
+
+/*  Not a pure module */

package/tests/extensionpoint/ExtensionPointFixtures.res.mjs

@@ -0,0 +1,205 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+import * as ExtensionPoint_Callback$ReventlessCore from "../../src/components/ExtensionPoint/ExtensionPoint_Callback.res.mjs";
+
+S.enableJson();
+
+let name = "TestExtensionPoint";
+
+let commandSchema = S.union([
+  S.schema(s => ({
+    TAG: "RouteToAgg",
+    aggId: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "TriggerDirective",
+    value: s.m(S.string)
+  }))
+]);
+
+let eventSchema = S.schema(s => ({
+  TAG: "Done",
+  result: s.m(S.string)
+}));
+
+let directiveSchema = S.literal("DirectiveA");
+
+let moduleUrl = import.meta.url;
+
+function commandAuthorization(param) {
+  return "AllowAuthenticated";
+}
+
+let TestEPSpec = {
+  name: name,
+  commandSchema: commandSchema,
+  eventSchema: eventSchema,
+  directiveSchema: directiveSchema,
+  moduleUrl: moduleUrl,
+  commandAuthorization: commandAuthorization
+};
+
+let capturedPublishedCmds = {
+  contents: []
+};
+
+let capturedCallCount = {
+  contents: 0
+};
+
+let delegateName = "TestTargetAgg";
+
+function mapIncomingCommands(topicItems, _createSchedule, _deleteSchedule, _queryEngine) {
+  return topicItems.flatMap(topicItem => {
+    let match = topicItem.command.command;
+    if (match.TAG === "RouteToAgg") {
+      return [{
+          TAG: "AbstractPublishCommand",
+          _0: "TestTargetAgg",
+          _1: topicItem.reference,
+          _2: {
+            id: match.aggId,
+            meta: topicItem.command.meta,
+            commandJson: "Create"
+          }
+        }];
+    } else {
+      return [{
+          TAG: "AbstractHandleDirective",
+          _0: topicItem.reference,
+          _1: async () => {
+            capturedCallCount.contents = capturedCallCount.contents + 1 | 0;
+          }
+        }];
+    }
+  });
+}
+
+let TestMapping = {
+  ExtensionPoint: undefined,
+  delegateName: delegateName,
+  mapIncomingCommands: mapIncomingCommands,
+  mapOutgoingEvent: undefined
+};
+
+let moduleUrl$1 = import.meta.url;
+
+let mappings = [{
+    delegateName: delegateName,
+    mapIncomingCommands: mapIncomingCommands,
+    mapOutgoingEvent: undefined
+  }];
+
+let TestMappings = {
+  Spec: undefined,
+  name: "TestMappings",
+  moduleUrl: moduleUrl$1,
+  mappings: mappings
+};
+
+let publishToAggregates = Object.fromEntries([[
+    "TestTargetAgg",
+    async cmds => {
+      capturedPublishedCmds.contents = capturedPublishedCmds.contents.concat(cmds);
+    }
+  ]]);
+
+let commandTopicResources = [];
+
+async function scheduler_createSchedule(_resources, _schedule) {
+  
+}
+
+async function scheduler_deleteSchedule(_resources, _name) {
+  
+}
+
+let scheduler = {
+  createSchedule: scheduler_createSchedule,
+  deleteSchedule: scheduler_deleteSchedule
+};
+
+async function queryEngine_scan(param, param$1, param$2) {
+  return [];
+}
+
+async function queryEngine_query(param, param$1, param$2, param$3, param$4, param$5, param$6) {
+  return [];
+}
+
+let queryEngine = {
+  scan: queryEngine_scan,
+  query: queryEngine_query
+};
+
+function resourceNaming_validateName(name) {
+  return name;
+}
+
+function resourceNaming_urnName(name) {
+  return name;
+}
+
+let resourceNaming = {
+  validateName: resourceNaming_validateName,
+  urnName: resourceNaming_urnName
+};
+
+let TestCallbackSpec = {
+  publishToAggregates: publishToAggregates,
+  commandTopicResources: commandTopicResources,
+  scheduler: scheduler,
+  queryEngine: queryEngine,
+  resourceNaming: resourceNaming
+};
+
+let TestHandler = ExtensionPoint_Callback$ReventlessCore.Make(TestCallbackSpec)({
+  name: name,
+  moduleUrl: moduleUrl,
+  commandSchema: commandSchema,
+  eventSchema: eventSchema,
+  directiveSchema: directiveSchema
+})({
+  mappings: mappings
+});
+
+let testMeta = {
+  service: "TestExtensionPoint",
+  time: "2024-01-01T00:00:00Z",
+  ip: "127.0.0.1",
+  user: "test-user",
+  msgId: "ep-msg-1",
+  correlationId: "ep-corr-1"
+};
+
+function makeTopicItem(reference, command) {
+  return {
+    command: {
+      id: Id$Reventless.$$String.makeFromString(reference),
+      meta: testMeta,
+      command: command
+    },
+    reference: reference
+  };
+}
+
+function reset() {
+  capturedPublishedCmds.contents = [];
+  capturedCallCount.contents = 0;
+}
+
+export {
+  TestEPSpec,
+  capturedPublishedCmds,
+  capturedCallCount,
+  TestMapping,
+  TestMappings,
+  TestCallbackSpec,
+  TestHandler,
+  testMeta,
+  makeTopicItem,
+  reset,
+}
+/*  Not a pure module */

package/tests/extensionpoint/ExtensionPointOperationsTest.res.mjs

@@ -0,0 +1,304 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Message$Reventless from "@reventlessdev/reventless-spec/src/types/Message.res.mjs";
+import * as ExtensionPoint_Operations$ReventlessCore from "../../src/components/ExtensionPoint/ExtensionPoint_Operations.res.mjs";
+
+S.enableJson();
+
+let name = "OpsTestEP";
+
+let commandSchema = S.schema(s => ({
+  TAG: "OpsEPCmd",
+  id: s.m(S.string)
+}));
+
+let eventSchema = S.schema(s => ({
+  TAG: "OpsEPEvent",
+  result: s.m(S.string)
+}));
+
+let directiveSchema = S.literal("OpsEPNoDirective");
+
+let moduleUrl = import.meta.url;
+
+function commandAuthorization(param) {
+  return "AllowAuthenticated";
+}
+
+let OpsEPSpec = {
+  name: name,
+  commandSchema: commandSchema,
+  eventSchema: eventSchema,
+  directiveSchema: directiveSchema,
+  moduleUrl: moduleUrl,
+  commandAuthorization: commandAuthorization
+};
+
+let capturedPublished = {
+  contents: []
+};
+
+let capturedCallCount = {
+  contents: 0
+};
+
+let outgoingMeta = {
+  service: "PublishAgg",
+  time: "2024-01-01T00:00:00Z",
+  ip: "127.0.0.1",
+  user: "tester",
+  msgId: "ops-msg-1",
+  correlationId: "ops-corr-1"
+};
+
+let delegateName = "PublishAgg";
+
+function mapIncomingCommands(_topicItems, _createSchedule, _deleteSchedule, _queryEngine) {
+  return [];
+}
+
+let mapOutgoingEvent = (eventJson, _createSchedule, _deleteSchedule, _queryEngine) => [{
+    TAG: "AbstractPublishEvent",
+    _0: "ep-dest",
+    _1: outgoingMeta,
+    _2: eventJson
+  }];
+
+let TestPublishMapping = {
+  ExtensionPoint: undefined,
+  delegateName: delegateName,
+  mapIncomingCommands: mapIncomingCommands,
+  mapOutgoingEvent: mapOutgoingEvent
+};
+
+let delegateName$1 = "CallAgg";
+
+function mapIncomingCommands$1(_topicItems, _createSchedule, _deleteSchedule, _queryEngine) {
+  return [];
+}
+
+let mapOutgoingEvent$1 = (_eventJson, _createSchedule, _deleteSchedule, _queryEngine) => [{
+    TAG: "AbstractHandleDirective",
+    _0: async () => {
+      capturedCallCount.contents = capturedCallCount.contents + 1 | 0;
+    }
+  }];
+
+let TestCallMapping = {
+  ExtensionPoint: undefined,
+  delegateName: delegateName$1,
+  mapIncomingCommands: mapIncomingCommands$1,
+  mapOutgoingEvent: mapOutgoingEvent$1
+};
+
+let delegateName$2 = "AsyncAgg";
+
+function mapIncomingCommands$2(_topicItems, _createSchedule, _deleteSchedule, _queryEngine) {
+  return [];
+}
+
+let mapOutgoingEvent$2 = (eventJson, _createSchedule, _deleteSchedule, _queryEngine) => {
+  let asyncResult = Promise.resolve([
+    "ep-async-dest",
+    outgoingMeta,
+    eventJson
+  ]);
+  return [{
+      TAG: "AbstractPublishEventAsync",
+      _0: asyncResult
+    }];
+};
+
+let TestAsyncMapping = {
+  ExtensionPoint: undefined,
+  delegateName: delegateName$2,
+  mapIncomingCommands: mapIncomingCommands$2,
+  mapOutgoingEvent: mapOutgoingEvent$2
+};
+
+let moduleUrl$1 = import.meta.url;
+
+let mappings = [
+  {
+    delegateName: delegateName,
+    mapIncomingCommands: mapIncomingCommands,
+    mapOutgoingEvent: mapOutgoingEvent
+  },
+  {
+    delegateName: delegateName$1,
+    mapIncomingCommands: mapIncomingCommands$1,
+    mapOutgoingEvent: mapOutgoingEvent$1
+  },
+  {
+    delegateName: delegateName$2,
+    mapIncomingCommands: mapIncomingCommands$2,
+    mapOutgoingEvent: mapOutgoingEvent$2
+  }
+];
+
+let TestOpsMappings = {
+  Spec: undefined,
+  name: "TestOpsMappings",
+  moduleUrl: moduleUrl$1,
+  mappings: mappings
+};
+
+async function publishToEventTopic(id, meta, eventJson) {
+  capturedPublished.contents = capturedPublished.contents.concat([[
+      id,
+      meta,
+      eventJson
+    ]]);
+}
+
+let commandTopicResources = [];
+
+async function scheduler_createSchedule(param, param$1) {
+  
+}
+
+async function scheduler_deleteSchedule(param, param$1) {
+  
+}
+
+let scheduler = {
+  createSchedule: scheduler_createSchedule,
+  deleteSchedule: scheduler_deleteSchedule
+};
+
+async function queryEngine_scan(param, param$1, param$2) {
+  return [];
+}
+
+async function queryEngine_query(param, param$1, param$2, param$3, param$4, param$5, param$6) {
+  return [];
+}
+
+let queryEngine = {
+  scan: queryEngine_scan,
+  query: queryEngine_query
+};
+
+function resourceNaming_validateName(n) {
+  return n;
+}
+
+function resourceNaming_urnName(n) {
+  return n;
+}
+
+let resourceNaming = {
+  validateName: resourceNaming_validateName,
+  urnName: resourceNaming_urnName
+};
+
+let TestOps = {
+  publishToEventTopic: publishToEventTopic,
+  commandTopicResources: commandTopicResources,
+  scheduler: scheduler,
+  queryEngine: queryEngine,
+  resourceNaming: resourceNaming
+};
+
+let EpOps = ExtensionPoint_Operations$ReventlessCore.Make({
+  name: name,
+  moduleUrl: moduleUrl,
+  commandSchema: commandSchema,
+  eventSchema: eventSchema,
+  directiveSchema: directiveSchema
+})({
+  mappings: mappings
+})(TestOps);
+
+function makeEventJsonForAgg(aggregateName) {
+  let meta_ip = "127.0.0.1";
+  let meta_user = "tester";
+  let meta = {
+    service: aggregateName,
+    time: "2024-01-01T00:00:00Z",
+    ip: meta_ip,
+    user: meta_user,
+    msgId: "msg-test",
+    correlationId: "corr-test"
+  };
+  return Object.fromEntries([
+    [
+      "meta",
+      S.reverseConvertToJsonOrThrow(meta, Message$Reventless.metaSchema)
+    ],
+    [
+      "event",
+      "SomeEvent"
+    ]
+  ]);
+}
+
+function reset() {
+  capturedPublished.contents = [];
+  capturedCallCount.contents = 0;
+}
+
+globalThis.describe("ExtensionPoint_Operations.Make:", () => {
+  globalThis.beforeEach(() => reset());
+  globalThis.describe("outgoingJsonEventsHandler — AbstractPublishEvent:", () => {
+    globalThis.test("known aggregate calls publishToEventTopic with correct destination id", async () => {
+      let eventJson = makeEventJsonForAgg("PublishAgg");
+      await EpOps.outgoingJsonEventsHandler(eventJson, undefined);
+      globalThis.expect(capturedPublished.contents.length).toBe(1);
+      let item = capturedPublished.contents[0];
+      globalThis.expect(item[0]).toBe("ep-dest");
+    });
+    globalThis.test("publishToEventTopic receives the original event JSON", async () => {
+      let eventJson = makeEventJsonForAgg("PublishAgg");
+      await EpOps.outgoingJsonEventsHandler(eventJson, undefined);
+      let item = capturedPublished.contents[0];
+      globalThis.expect(item[2]).toEqual(eventJson);
+    });
+  });
+  globalThis.describe("outgoingJsonEventsHandler — AbstractHandleDirective:", () => {
+    globalThis.test("known aggregate with AbstractHandleDirective invokes the handler", async () => {
+      let eventJson = makeEventJsonForAgg("CallAgg");
+      await EpOps.outgoingJsonEventsHandler(eventJson, undefined);
+      globalThis.expect(capturedCallCount.contents).toBe(1);
+      globalThis.expect(capturedPublished.contents.length).toBe(0);
+    });
+  });
+  globalThis.describe("outgoingJsonEventsHandler — AbstractPublishEventAsync:", () => {
+    globalThis.test("async mapping resolves and calls publishToEventTopic", async () => {
+      let eventJson = makeEventJsonForAgg("AsyncAgg");
+      await EpOps.outgoingJsonEventsHandler(eventJson, undefined);
+      globalThis.expect(capturedPublished.contents.length).toBe(1);
+      let item = capturedPublished.contents[0];
+      globalThis.expect(item[0]).toBe("ep-async-dest");
+    });
+  });
+  globalThis.describe("outgoingJsonEventsHandler — no matching mapping:", () => {
+    globalThis.test("event from unknown aggregate throws", async () => {
+      let eventJson = makeEventJsonForAgg("UnknownAgg");
+      let didThrow = false;
+      try {
+        await EpOps.outgoingJsonEventsHandler(eventJson, undefined);
+      } catch (exn) {
+        didThrow = true;
+      }
+      globalThis.expect(didThrow).toBe(true);
+    });
+  });
+});
+
+export {
+  OpsEPSpec,
+  capturedPublished,
+  capturedCallCount,
+  outgoingMeta,
+  TestPublishMapping,
+  TestCallMapping,
+  TestAsyncMapping,
+  TestOpsMappings,
+  TestOps,
+  EpOps,
+  makeEventJsonForAgg,
+  reset,
+}
+/*  Not a pure module */

package/tests/extensionpoint/PluginDisconnectScheduleTest.res.mjs

@@ -0,0 +1,92 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as PluginExtensionPoint_Plugin$ReventlessCore from "../../src/plugin/connect/PluginExtensionPoint_Plugin.res.mjs";
+
+let created = {
+  contents: []
+};
+
+let deleted = {
+  contents: []
+};
+
+let runtimeOps = {
+  messagePublish: {
+    sendMessageToChannel: async (param, param$1) => {}
+  }
+};
+
+let DisconnectSpec = {
+  runtimeOps: runtimeOps,
+  environment: "teststack",
+  updateApiSchema: undefined,
+  manageSubscriptions: undefined
+};
+
+let EP = PluginExtensionPoint_Plugin$ReventlessCore.Make(DisconnectSpec);
+
+async function createSchedule(schedule) {
+  created.contents = created.contents.concat([schedule.name]);
+}
+
+async function deleteSchedule(name) {
+  deleted.contents = deleted.contents.concat([name]);
+}
+
+async function queryEngine_scan(param, param$1, param$2) {
+  return [];
+}
+
+async function queryEngine_query(param, param$1, param$2, param$3, param$4, param$5, param$6) {
+  return [];
+}
+
+let queryEngine = {
+  scan: queryEngine_scan,
+  query: queryEngine_query
+};
+
+let pluginId = "Catalog_1.0.0-alpha.169";
+
+function handle(directive) {
+  return EP.directiveHandler(createSchedule, deleteSchedule, queryEngine, directive);
+}
+
+globalThis.describe("plugin disconnect schedule", () => {
+  globalThis.test("create and delete address the same rule name", async () => {
+    created.contents = [];
+    deleted.contents = [];
+    await handle({
+      TAG: "CreateDisconnectSchedule",
+      _0: pluginId,
+      _1: 5
+    });
+    await handle({
+      TAG: "DeleteDisconnectSchedule",
+      _0: pluginId
+    });
+    globalThis.expect(deleted.contents).toEqual(created.contents);
+  });
+  globalThis.test("the rule name is namespaced by stack", async () => {
+    created.contents = [];
+    await handle({
+      TAG: "CreateDisconnectSchedule",
+      _0: pluginId,
+      _1: 5
+    });
+    globalThis.expect(created.contents).toEqual(["teststack-" + pluginId]);
+  });
+});
+
+export {
+  created,
+  deleted,
+  DisconnectSpec,
+  EP,
+  createSchedule,
+  deleteSchedule,
+  queryEngine,
+  pluginId,
+  handle,
+}
+/* EP Not a pure module */