@reventlessdev/reventless-local 3.0.0-alpha.233 → 3.0.0-alpha.235

package/tests/adapter/QueryDbResolvedFieldsTest.res.mjs

@@ -0,0 +1,291 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Sury from "sury";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Pulumi from "@pulumi/pulumi";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Identity$Reventless from "@reventlessdev/reventless-spec/src/types/Identity.res.mjs";
+import * as ReadModel$Reventless from "@reventlessdev/reventless-spec/src/components/ReadModel.res.mjs";
+import * as Component$ReventlessCore from "@reventlessdev/reventless-core/src/components/Component.res.mjs";
+import * as LocalBus$ReventlessLocal from "../../src/adapter/LocalBus.res.mjs";
+import * as TestRunner$ReventlessLocal from "../../src/test/TestRunner.res.mjs";
+import * as StateAnnotations$Reventless from "@reventlessdev/reventless-spec/src/components/StateAnnotations.res.mjs";
+import * as Plugin_Helpers$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/component/Plugin_Helpers.res.mjs";
+import * as QueryDb_Adapter$ReventlessCore from "@reventlessdev/reventless-core/src/components/QueryDb/QueryDb_Adapter.res.mjs";
+import * as QueryDb_Builder$ReventlessCore from "@reventlessdev/reventless-core/src/components/QueryDb/QueryDb_Builder.res.mjs";
+import * as LocalQueryDbStorage$ReventlessLocal from "../../src/adapter/QueryDb/LocalQueryDbStorage.res.mjs";
+import * as DomainGraphQL_Server$ReventlessLocal from "../../src/adapter/DomainGraphQL_Server.res.mjs";
+import * as QueryDbResolvers_GraphQL$ReventlessLocal from "../../src/adapter/QueryDb/QueryDbResolvers_GraphQL.res.mjs";
+
+TestRunner$ReventlessLocal.setup();
+
+let productRowSchema = Sury.$schema(s => ({
+  productId: s.m(Sury.string),
+  name: s.m(Sury.string),
+  archived: s.m(Sury.bool)
+}));
+
+let orderRowSchema = Sury.$schema(s => ({
+  orderId: s.m(Sury.string),
+  productId: s.m(Sury.string),
+  productIds: s.m(Sury.array(Sury.string))
+}));
+
+function annotations(retired) {
+  return {
+    ids: [],
+    compositeIds: [],
+    subIds: [],
+    compositeSubIds: [],
+    indexes: [],
+    hidden: [],
+    summary: [],
+    drillTargets: [],
+    drillTargetKeys: [],
+    collapsed: [],
+    scan: [],
+    scanSort: [],
+    semantic: [],
+    metric: [],
+    lifecycle: undefined,
+    groupBy: undefined,
+    visibility: undefined,
+    live: undefined,
+    retired: retired
+  };
+}
+
+function ctxFor(groups) {
+  let newrecord = {...Identity$Reventless.anonymous};
+  return Object.fromEntries([
+    [
+      "request",
+      Object.fromEntries([[
+          "headers",
+          {}
+        ]])
+    ],
+    [
+      "identity",
+      (newrecord.groups = groups, newrecord.username = "test-user", newrecord.userId = "test-user", newrecord)
+    ]
+  ]);
+}
+
+let plainCtx = ctxFor(["User"]);
+
+let noArgs = {};
+
+function getString(json, key) {
+  return Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(json), d => d[key]), Stdlib_JSON.Decode.string);
+}
+
+function names(json) {
+  return Stdlib_Array.filterMap(Stdlib_Option.getOr(Stdlib_JSON.Decode.array(json), []), item => getString(item, "name"));
+}
+
+async function buildFixture(suffix, retired) {
+  let Bus = LocalBus$ReventlessLocal.Make({});
+  let Storage = LocalQueryDbStorage$ReventlessLocal.Make(Bus);
+  let Resolvers = QueryDbResolvers_GraphQL$ReventlessLocal.Make(Bus);
+  let productsName = "Products" + suffix;
+  let ordersName = "Orders" + suffix;
+  let orderTypeName = "Shop_Order" + suffix;
+  let moduleUrl = import.meta.url;
+  let config = ReadModel$Reventless.config(undefined, undefined, undefined);
+  let moduleUrl$1 = import.meta.url;
+  let config$1 = ReadModel$Reventless.config([{
+      source: {
+        idField: "productId",
+        subId: "NoSubId",
+        resolvedField: {
+          TAG: "Single",
+          _0: "product"
+        }
+      },
+      target: {
+        tableName: productsName,
+        idField: "Id"
+      }
+    }], [{
+      source: {
+        idsField: "productIds",
+        resolvedField: "products"
+      },
+      target: {
+        tableName: productsName
+      }
+    }], undefined);
+  let NoResolvers = QueryDb_Adapter$ReventlessCore.NoResolvers({
+    make: Storage.make
+  });
+  let ProductsDb = QueryDb_Builder$ReventlessCore.Make({
+    Id: {
+      schema: Id$Reventless.StringPure.schema,
+      make: prim => prim,
+      makeFromString: prim => prim,
+      toString: prim => prim,
+      cmp: Id$Reventless.StringPure.cmp
+    },
+    name: productsName,
+    moduleUrl: moduleUrl,
+    stateSchema: productRowSchema,
+    config: config,
+    subIdConfig: undefined,
+    authorization: "AllowAuthenticated",
+    visibility: "Public"
+  })({
+    make: Storage.make
+  })(NoResolvers);
+  let OrdersDb = QueryDb_Builder$ReventlessCore.Make({
+    Id: {
+      schema: Id$Reventless.StringPure.schema,
+      make: prim => prim,
+      makeFromString: prim => prim,
+      toString: prim => prim,
+      cmp: Id$Reventless.StringPure.cmp
+    },
+    name: ordersName,
+    moduleUrl: moduleUrl$1,
+    stateSchema: orderRowSchema,
+    config: config$1,
+    subIdConfig: undefined,
+    authorization: "AllowAuthenticated",
+    visibility: "Public"
+  })({
+    make: Storage.make
+  })(NoResolvers);
+  let register = (viewName, returnTypeName) => {
+    Plugin_Helpers$ReventlessCore.queryFieldNamesRegistry[viewName] = {
+      singleFieldName: returnTypeName,
+      listFieldName: returnTypeName + "s",
+      returnTypeName: returnTypeName,
+      pluralTypeName: returnTypeName + "s",
+      includeIdParam: true,
+      connectionSpec: true
+    };
+  };
+  register(productsName, "Shop_Product" + suffix);
+  register(ordersName, orderTypeName);
+  Plugin_Helpers$ReventlessCore.stateSchemaRegistry[productsName] = Sury.$Metadata_set(productRowSchema, StateAnnotations$Reventless.stateAnnotationsId, annotations(retired));
+  let productsDb = ProductsDb.make(undefined, undefined, undefined, undefined, undefined);
+  let productOps = await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(productsDb));
+  let ordersDb = OrdersDb.make(undefined, undefined, undefined, undefined, undefined);
+  let orderOps = await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(ordersDb));
+  Resolvers.make(ordersName, undefined, undefined, Pulumi.output(""), [], undefined, config$1.idResolvers, config$1.idsResolvers, "AllowAuthenticated", {});
+  await productOps.save("p-1", {
+    productId: "p-1",
+    name: "Book",
+    archived: false
+  }, "Init", undefined);
+  await productOps.save("p-2", {
+    productId: "p-2",
+    name: "Pen",
+    archived: true
+  }, "Init", undefined);
+  await orderOps.save("o-1", {
+    orderId: "o-1",
+    productId: "p-1",
+    productIds: [
+      "p-1",
+      "gone",
+      "p-2"
+    ]
+  }, "Init", undefined);
+  let resolverFor = field => {
+    let r = DomainGraphQL_Server$ReventlessLocal.getFieldResolver(orderTypeName, field);
+    if (r !== undefined) {
+      return r;
+    } else {
+      return Stdlib_JsError.throwWithMessage("field resolver not registered: " + field);
+    }
+  };
+  let order = Object.fromEntries([
+    [
+      "orderId",
+      "o-1"
+    ],
+    [
+      "productId",
+      "p-1"
+    ],
+    [
+      "productIds",
+      [
+        "p-1",
+        "gone",
+        "p-2"
+      ].map(prim => prim)
+    ]
+  ]);
+  return [
+    resolverFor,
+    order
+  ];
+}
+
+globalThis.describe("QueryDb cross-table field resolvers", () => {
+  globalThis.beforeEach(() => DomainGraphQL_Server$ReventlessLocal.reset());
+  globalThis.test("@resolves follows the foreign key into the target's row", async () => {
+    let match = await buildFixture("A", undefined);
+    let product = await match[0]("product")(match[1], noArgs, plainCtx);
+    globalThis.expect([
+      getString(product, "name"),
+      getString(product, "id")
+    ]).toEqual([
+      "Book",
+      "p-1"
+    ]);
+  });
+  globalThis.test("@resolvesMany batch-follows the id array", async () => {
+    let match = await buildFixture("B", undefined);
+    let products = await match[0]("products")(match[1], noArgs, plainCtx);
+    globalThis.expect(names(products)).toEqual([
+      "Book",
+      "Pen"
+    ]);
+  });
+  globalThis.test("a foreign key naming no row resolves to nothing", async () => {
+    let match = await buildFixture("C", undefined);
+    let orphan = Object.fromEntries([[
+        "productId",
+        "nope"
+      ]]);
+    let product = await match[0]("product")(orphan, noArgs, plainCtx);
+    globalThis.expect(product).toBe(null);
+  });
+  globalThis.test("a retired target row is withheld from both forms", async () => {
+    let match = await buildFixture("D", {
+      field: "archived",
+      label: "",
+      showWhenFalse: false,
+      values: undefined,
+      namedWhenRetired: false
+    });
+    let resolverFor = match[0];
+    let products = await resolverFor("products")(match[1], noArgs, plainCtx);
+    globalThis.expect(names(products)).toEqual(["Book"]);
+    let archivedOnly = Object.fromEntries([[
+        "productId",
+        "p-2"
+      ]]);
+    let product = await resolverFor("product")(archivedOnly, noArgs, plainCtx);
+    globalThis.expect(product).toBe(null);
+  });
+});
+
+export {
+  productRowSchema,
+  orderRowSchema,
+  annotations,
+  ctxFor,
+  plainCtx,
+  noArgs,
+  getString,
+  names,
+  buildFixture,
+}
+/*  Not a pure module */

package/tests/components/automationslice/AutomationSliceCallbackTest.res

@@ -179,6 +179,70 @@ describe("AutomationSlice Callback (mixed-source)", () => {
     })
   })
 
+  // A row used to leave the retry budget by falling out of phase2's filter, so
+  // `Failed` meant both "will be retried" and "never again" and only the count
+  // told them apart — against a ceiling that lives in the Spec, not in the row.
+  describe("retry exhaustion", () => {
+    let failingPublish: ReventlessInfra.CommandTopic.publishJsons = async _cmds =>
+      JsError.throwWithMessage("publish failed")
+
+    let collectOne = () =>
+      Callback.phase1(
+        [encodeShipOrderEvent(OrderPlaced({orderId: "ord-1", address: "123 Main St"}))],
+        testContext,
+      )
+
+    let statusOf = id => (Callback.todoItems->Dict.get(id)->Option.getOrThrow).status
+
+    testPromise("the attempt that spends the budget writes Abandoned, not Failed", async () => {
+      collectOne()
+      // ShipOrderSpec.maxRetries is 3: attempts at retryCount 0, 1 and 2 leave the
+      // row retriable, and the third failure is the one that ends it.
+      await Callback.phase2(failingPublish)
+      expect(statusOf("ord-1"))->toBe(Failed)
+      await Callback.phase2(failingPublish)
+      expect(statusOf("ord-1"))->toBe(Failed)
+      await Callback.phase2(failingPublish)
+      expect(statusOf("ord-1"))->toBe(Abandoned)
+      expect((Callback.todoItems->Dict.get("ord-1")->Option.getOrThrow).retryCount)->toBe(3)
+    })
+
+    testPromise("an abandoned row is not picked up again", async () => {
+      collectOne()
+      await Callback.phase2(failingPublish)
+      await Callback.phase2(failingPublish)
+      await Callback.phase2(failingPublish)
+      expect(statusOf("ord-1"))->toBe(Abandoned)
+
+      // A pass that would have succeeded: the row must still not be attempted,
+      // which is what makes the status a decision rather than a label.
+      let published = ref([])
+      await Callback.phase2(async cmds => published := cmds)
+      expect(published.contents->Array.length)->toBe(0)
+      expect(statusOf("ord-1"))->toBe(Abandoned)
+      expect((Callback.todoItems->Dict.get("ord-1")->Option.getOrThrow).retryCount)->toBe(3)
+    })
+
+    testPromise("a row left stranded at the ceiling is normalised on the next pass", async () => {
+      collectOne()
+      // What an older build wrote, and what a Spec that lowered maxRetries leaves
+      // behind: Failed at the ceiling, which no pass would ever pick up or mark.
+      let row = Callback.todoItems->Dict.get("ord-1")->Option.getOrThrow
+      Callback.todoItems->Dict.set("ord-1", {...row, status: Failed, retryCount: 3})
+
+      let published = ref([])
+      await Callback.phase2(async cmds => published := cmds)
+      expect(published.contents->Array.length)->toBe(0)
+      expect(statusOf("ord-1"))->toBe(Abandoned)
+    })
+
+    testPromise("the row carries the ceiling its count is racing", async () => {
+      collectOne()
+      expect((Callback.todoItems->Dict.get("ord-1")->Option.getOrThrow).maxRetries)
+      ->toEqual(Some(ShipOrderSpec.maxRetries))
+    })
+  })
+
   describe("full lifecycle", () => {
     testPromise("collect → process → resolve completes the TODO item", async () => {
       Callback.phase1(

package/tests/components/automationslice/AutomationSliceCallbackTest.res.mjs

@@ -192,6 +192,61 @@ globalThis.describe("AutomationSlice Callback (mixed-source)", () => {
       globalThis.expect(row2.status).toBe("Processing");
     });
   });
+  globalThis.describe("retry exhaustion", () => {
+    let failingPublish = async _cmds => Stdlib_JsError.throwWithMessage("publish failed");
+    let collectOne = () => Callback.phase1([AutomationSliceFixtures$ReventlessLocal.encodeShipOrderEvent({
+        TAG: "OrderPlaced",
+        orderId: "ord-1",
+        address: "123 Main St"
+      })], AutomationSliceFixtures$ReventlessLocal.testContext);
+    let statusOf = id => Stdlib_Option.getOrThrow(Callback.todoItems[id], undefined).status;
+    globalThis.test("the attempt that spends the budget writes Abandoned, not Failed", async () => {
+      collectOne();
+      await Callback.phase2(failingPublish);
+      globalThis.expect(statusOf("ord-1")).toBe("Failed");
+      await Callback.phase2(failingPublish);
+      globalThis.expect(statusOf("ord-1")).toBe("Failed");
+      await Callback.phase2(failingPublish);
+      globalThis.expect(statusOf("ord-1")).toBe("Abandoned");
+      globalThis.expect(Stdlib_Option.getOrThrow(Callback.todoItems["ord-1"], undefined).retryCount).toBe(3);
+    });
+    globalThis.test("an abandoned row is not picked up again", async () => {
+      collectOne();
+      await Callback.phase2(failingPublish);
+      await Callback.phase2(failingPublish);
+      await Callback.phase2(failingPublish);
+      globalThis.expect(statusOf("ord-1")).toBe("Abandoned");
+      let published = {
+        contents: []
+      };
+      await Callback.phase2(async cmds => {
+        published.contents = cmds;
+      });
+      globalThis.expect(published.contents.length).toBe(0);
+      globalThis.expect(statusOf("ord-1")).toBe("Abandoned");
+      globalThis.expect(Stdlib_Option.getOrThrow(Callback.todoItems["ord-1"], undefined).retryCount).toBe(3);
+    });
+    globalThis.test("a row left stranded at the ceiling is normalised on the next pass", async () => {
+      collectOne();
+      let row = Stdlib_Option.getOrThrow(Callback.todoItems["ord-1"], undefined);
+      let newrecord = {...row};
+      newrecord.retryCount = 3;
+      newrecord.status = "Failed";
+      Callback.todoItems["ord-1"] = newrecord;
+      let published = {
+        contents: []
+      };
+      await Callback.phase2(async cmds => {
+        published.contents = cmds;
+      });
+      globalThis.expect(published.contents.length).toBe(0);
+      globalThis.expect(statusOf("ord-1")).toBe("Abandoned");
+    });
+    globalThis.test("the row carries the ceiling its count is racing", async () => {
+      collectOne();
+      globalThis.expect(Stdlib_Option.getOrThrow(Callback.todoItems["ord-1"], undefined).maxRetries).toEqual(AutomationSliceFixtures$ReventlessLocal.ShipOrderSpec.maxRetries);
+    });
+  });
   globalThis.describe("full lifecycle", () => {
     globalThis.test("collect → process → resolve completes the TODO item", async () => {
       Callback.phase1([AutomationSliceFixtures$ReventlessLocal.encodeShipOrderEvent({

package/tests/components/automationslice/AutomationSliceFixtures.res

@@ -108,6 +108,7 @@ module ShipOrderAutomation: Reventless.AutomationSlice.Automation
   with module Spec := ShipOrderSpec = {
   let process = (id, _item: ShipOrderSpec.todoItem) =>
     Some((id, ShipOrderSpec.CreateShipment({orderId: id})))
+  let onExhausted = (_id, _item: ShipOrderSpec.todoItem) => None
   let moduleUrl: string = %raw(`import.meta.url`)
   module M = Reventless.AutomationSlice.Mappings.Make(ShipOrderSpec)
   module type Mapping = M.Mapping
@@ -117,6 +118,7 @@ module ShipOrderAutomation: Reventless.AutomationSlice.Automation
 module SkipProcessAutomation: Reventless.AutomationSlice.Automation
   with module Spec := SkipProcessSpec = {
   let process = (_id, _item: SkipProcessSpec.todoItem) => None
+  let onExhausted = (_id, _item: SkipProcessSpec.todoItem) => None
   let moduleUrl: string = %raw(`import.meta.url`)
   module M = Reventless.AutomationSlice.Mappings.Make(SkipProcessSpec)
   module type Mapping = M.Mapping

package/tests/components/automationslice/AutomationSliceFixtures.res.mjs

@@ -168,6 +168,10 @@ function process(id, _item) {
   ];
 }
 
+function onExhausted(_id, _item) {
+  
+}
+
 let moduleUrl$2 = import.meta.url;
 
 AutomationSlice$Reventless.Mappings.Make(ShipOrderSpec);
@@ -176,6 +180,7 @@ let mappings = [ShipOrderMapping];
 
 let ShipOrderAutomation = {
   process: process,
+  onExhausted: onExhausted,
   moduleUrl: moduleUrl$2,
   mappings: mappings
 };
@@ -184,6 +189,10 @@ function process$1(_id, _item) {
   
 }
 
+function onExhausted$1(_id, _item) {
+  
+}
+
 let moduleUrl$3 = import.meta.url;
 
 AutomationSlice$Reventless.Mappings.Make(SkipProcessSpec);
@@ -192,6 +201,7 @@ let mappings$1 = [SkipProcessMapping];
 
 let SkipProcessAutomation = {
   process: process$1,
+  onExhausted: onExhausted$1,
   moduleUrl: moduleUrl$3,
   mappings: mappings$1
 };

package/tests/components/automationslice/AutomationSliceSelfDeadlockFixtures.res

@@ -158,6 +158,7 @@ module FromDcb = AutomationSlice.Mapping.Make(
 module AutoShipAutomation: AutomationSlice.Automation with module Spec := AutoShipSpec = {
   let process = (id, _item: AutoShipSpec.todoItem) =>
     Some((id, AutoShipSpec.Ship({orderId: id})))
+  let onExhausted = (_id, _item: AutoShipSpec.todoItem) => None
   let moduleUrl: string = %raw(`import.meta.url`)
   module M = AutomationSlice.Mappings.Make(AutoShipSpec)
   module type Mapping = M.Mapping

package/tests/components/automationslice/AutomationSliceSelfDeadlockFixtures.res.mjs

@@ -264,6 +264,10 @@ function process(id, _item) {
   ];
 }
 
+function onExhausted(_id, _item) {
+  
+}
+
 let moduleUrl$5 = import.meta.url;
 
 AutomationSlice$Reventless.Mappings.Make(AutoShipSpec);
@@ -272,6 +276,7 @@ let mappings = [FromDcb];
 
 let AutoShipAutomation = {
   process: process,
+  onExhausted: onExhausted,
   moduleUrl: moduleUrl$5,
   mappings: mappings
 };

package/tests/components/automationslice/MixedSourceAutomationSliceFixtures.res

@@ -117,6 +117,7 @@ module AutoFulfillAutomation: AutomationSlice.Automation
   with module Spec := AutoFulfillSpec = {
   let process = (id, item: AutoFulfillSpec.todoItem) =>
     Some((id, AutoFulfillSpec.MarkFulfilled({orderId: item.orderId, productId: item.productId})))
+  let onExhausted = (_id, _item: AutoFulfillSpec.todoItem) => None
   let moduleUrl: string = %raw(`import.meta.url`)
   module M = AutomationSlice.Mappings.Make(AutoFulfillSpec)
   module type Mapping = M.Mapping

package/tests/components/automationslice/MixedSourceAutomationSliceFixtures.res.mjs

@@ -149,6 +149,10 @@ function process(id, item) {
   ];
 }
 
+function onExhausted(_id, _item) {
+  
+}
+
 let moduleUrl$1 = import.meta.url;
 
 AutomationSlice$Reventless.Mappings.Make(AutoFulfillSpec);
@@ -160,6 +164,7 @@ let mappings = [
 
 let AutoFulfillAutomation = {
   process: process,
+  onExhausted: onExhausted,
   moduleUrl: moduleUrl$1,
   mappings: mappings
 };