@reventlessdev/reventless-core 3.0.0-alpha.134

package/tests/plugin/StateViewSlice/PsOrdersView.res.mjs

@@ -0,0 +1,81 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+import * as ReadModel$Reventless from "@reventlessdev/reventless-spec/src/components/ReadModel.res.mjs";
+
+let consumedEventSchema = S.union([
+  S.schema(s => ({
+    TAG: "OrderPlaced",
+    orderId: s.m(DcbTag$Reventless.string),
+    customerName: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "OrderShipped",
+    orderId: s.m(DcbTag$Reventless.string)
+  })),
+  S.schema(s => ({
+    TAG: "OrderCancelled",
+    orderId: s.m(DcbTag$Reventless.string)
+  }))
+]);
+
+let stateSchema = S.schema(s => ({
+  orderId: s.m(S.string),
+  customerName: s.m(S.string)
+}));
+
+function project(event) {
+  switch (event.TAG) {
+    case "OrderPlaced" :
+      let orderId = event.orderId;
+      return [{
+          TAG: "Set",
+          _0: orderId,
+          _1: {
+            orderId: orderId,
+            customerName: event.customerName
+          }
+        }];
+    case "OrderShipped" :
+      return [{
+          TAG: "Update",
+          _0: event.orderId,
+          _1: s => s
+        }];
+    case "OrderCancelled" :
+      return [{
+          TAG: "Update",
+          _0: event.orderId,
+          _1: s => s
+        }];
+  }
+}
+
+let config = ReadModel$Reventless.config(undefined, undefined, undefined);
+
+let name = "Orders";
+
+let Id;
+
+let subIdConfig;
+
+let moduleUrl = "@reventlessdev/reventless-core/tests/plugin/StateViewSlice/PsOrdersView.res.mjs";
+
+let authorization = "AllowAuthenticated";
+
+let visibility = "Public";
+
+export {
+  name,
+  Id,
+  consumedEventSchema,
+  stateSchema,
+  project,
+  config,
+  subIdConfig,
+  moduleUrl,
+  authorization,
+  visibility,
+}
+/* consumedEventSchema Not a pure module */

package/tests/poc/StructuralSubtypingPoc.res

@@ -0,0 +1,211 @@
+// Phase 0 Proof-of-Concept: Validate structural subtyping for platform-to-reventless-spec migration
+//
+// This file tests the critical assumption from plans/platform-to-reventless-spec.md:
+// Can a module satisfying a superset module type (with AggregateRuntimeBuilder)
+// be used where a subset module type (without AggregateRuntimeBuilder) is expected?
+//
+// Tests:
+// 1. Basic structural subtyping: superset module satisfies subset module type
+// 2. `with type` constraints work across subset/superset boundary
+// 3. Array of first-class superset modules can be passed where subset is expected
+// 4. The "finish" pattern: internal fields accessible when needed, hidden from spec users
+
+// ============================================================================
+// Simulated "spec" types (what would live in reventless-spec)
+// ============================================================================
+
+module type SpecLike = {
+  module Id: Reventless.Id.T
+  let name: string
+  @schema
+  type command
+  @schema
+  type event
+  @schema
+  type error
+}
+
+// Simplified component output type — what app developers would see
+// This is the "Subset" — no AggregateRuntimeBuilder
+module type Aggregate_Subset = {
+  module Spec: SpecLike
+  type api
+  let make: (~api: api, ~opts: Pulumi.ComponentResource.options=?) => Aggregate.component
+}
+
+// ============================================================================
+// Simulated "reventless" types (what would stay in reventless)
+// ============================================================================
+
+// Full component output type — includes internal adapter module
+// This is the "Superset" — has AggregateRuntimeBuilder
+module type Aggregate_Superset = {
+  module Spec: SpecLike
+  type api
+  let make: (~api: api, ~opts: Pulumi.ComponentResource.options=?) => Aggregate.component
+  module AggregateRuntimeBuilder: AggregateRuntime_Builder.T
+}
+
+// ============================================================================
+// Test 1: Basic coercion — can a Superset module be used as a Subset?
+// ============================================================================
+
+// This function accepts the subset type
+let acceptSubset = (module(M: Aggregate_Subset)): string => {
+  M.Spec.name
+}
+
+// This function tries to pass a superset where subset is expected
+let coerceSuperset = (module(M: Aggregate_Superset)): module(Aggregate_Subset) => {
+  module(M: Aggregate_Subset)
+}
+
+// ============================================================================
+// Test 2: `with type` constraints across the boundary
+// ============================================================================
+
+// Simulated Plugin.T.make signature using subset types
+module type PluginMaker_WithSubset = {
+  type api
+  let make: (~aggregates: array<module(Aggregate_Subset with type api = api)>) => unit
+}
+
+// Can we pass superset modules where subset with type constraint is expected?
+let passSupersetsAsSubsets = (
+  type a,
+  aggregates: array<module(Aggregate_Superset with type api = a)>,
+): array<module(Aggregate_Subset with type api = a)> => {
+  aggregates->Array.map((
+    module(M: Aggregate_Superset with type api = a),
+  ): module(Aggregate_Subset with type api = a) => module(M))
+}
+
+// ============================================================================
+// Test 3: The "finish" pattern — can we keep internal access when needed?
+// ============================================================================
+
+// The plugin builder internally needs AggregateRuntimeBuilder.finish()
+// but the Platform.T signature only exposes the subset.
+// Solution: Plugin_Builder accepts the full type internally,
+// but Platform.T returns the subset to app developers.
+
+// This simulates what Plugin_Helpers.finishAggregates does
+let finishAggregates = (
+  type a,
+  aggregates: array<module(Aggregate_Superset with type api = a)>,
+) => {
+  aggregates->Array.forEach((module(M: Aggregate_Superset with type api = a)) => {
+    M.AggregateRuntimeBuilder.finish()
+  })
+}
+
+// ============================================================================
+// Test 4: Platform.T pattern — builder returns subset, internal uses superset
+// ============================================================================
+
+// What Platform.T would look like in spec (returns subset)
+module type Platform_Spec = {
+  module Aggregate: {
+    module Make: (Spec: SpecLike) => Aggregate_Subset
+  }
+}
+
+// What the actual platform implementation returns (superset)
+module type Platform_Impl = {
+  module Aggregate: {
+    module Make: (Spec: SpecLike) => Aggregate_Superset
+  }
+}
+
+// Can Platform_Impl satisfy Platform_Spec?
+// This is the KEY test — if this compiles, the whole approach works
+let platformImplSatisfiesSpec = (module(P: Platform_Impl)): module(Platform_Spec) => {
+  module(P: Platform_Spec)
+}
+
+// ============================================================================
+// Test 5: ReadModel pattern (has EventCollectorRuntimeBuilder)
+// ============================================================================
+
+module type ReadModel_Subset = {
+  module Spec: ReventlessInfra.ReadModel.T
+  type api
+  type role
+  let make: (
+    ~api: api,
+    ~apiRole: role,
+    ~allEventTopics: EventTopic.allOutputs,
+    ~opts: Pulumi.ComponentResource.options=?,
+  ) => ReadModel.component
+}
+
+module type ReadModel_Superset = {
+  module Spec: ReventlessInfra.ReadModel.T
+  type api
+  type role
+  let make: (
+    ~api: api,
+    ~apiRole: role,
+    ~allEventTopics: EventTopic.allOutputs,
+    ~opts: Pulumi.ComponentResource.options=?,
+  ) => ReadModel.component
+  module EventCollectorRuntimeBuilder: EventCollectorRuntime_Builder.T
+}
+
+let coerceReadModelSuperset = (module(M: ReadModel_Superset)): module(ReadModel_Subset) => {
+  module(M: ReadModel_Subset)
+}
+
+// ============================================================================
+// Test 6: include-based definition (the actual approach from the plan)
+// ============================================================================
+
+// In the plan, the superset would be defined using `include`:
+//   module type Superset = { include Subset; module Extra: ... }
+// Let's verify this works too
+
+module type Aggregate_Subset_V2 = {
+  module Spec: SpecLike
+  type api
+  let make: (~api: api, ~opts: Pulumi.ComponentResource.options=?) => Aggregate.component
+}
+
+module type Aggregate_Superset_V2 = {
+  include Aggregate_Subset_V2
+  module AggregateRuntimeBuilder: AggregateRuntime_Builder.T
+}
+
+let coerceSupersetV2 = (module(M: Aggregate_Superset_V2)): module(Aggregate_Subset_V2) => {
+  module(M: Aggregate_Subset_V2)
+}
+
+let passSupersetsAsSubsetsV2 = (
+  type a,
+  aggregates: array<module(Aggregate_Superset_V2 with type api = a)>,
+): array<module(Aggregate_Subset_V2 with type api = a)> => {
+  aggregates->Array.map((
+    module(M: Aggregate_Superset_V2 with type api = a),
+  ): module(Aggregate_Subset_V2 with type api = a) => module(M))
+}
+
+let platformImplSatisfiesSpecV2 = (module(P: Platform_Impl)): module(Platform_Spec) => {
+  module(P: Platform_Spec)
+}
+
+// ============================================================================
+// Summary
+// ============================================================================
+// If this file compiles, it proves:
+// 1. ✅ Superset modules can be coerced to subset module types
+// 2. ✅ `with type` constraints work across the boundary
+// 3. ✅ Arrays of first-class modules can be mapped from superset to subset
+// 4. ✅ Platform_Impl (returning superset) satisfies Platform_Spec (returning subset)
+// 5. ✅ ReadModel pattern works the same way
+// 6. ✅ `include`-based superset definition works
+//
+// Key insight for the plan:
+// - Plugin_Builder.res DOES use AggregateRuntimeBuilder.finish() internally
+//   (see Plugin_Helpers.res:136-143)
+// - This means Plugin_Builder must continue to accept the full Aggregate.T internally
+// - But Platform.T can return the subset type to app developers
+// - The coercion happens at the Platform.T boundary, not at Plugin_Builder

package/tests/poc/StructuralSubtypingPoc.res.mjs

@@ -0,0 +1,61 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+function acceptSubset(M) {
+  return M.Spec.name;
+}
+
+function coerceSuperset(M) {
+  return M;
+}
+
+function passSupersetsAsSubsets(aggregates) {
+  return aggregates.map(M => M);
+}
+
+function finishAggregates(aggregates) {
+  aggregates.forEach(M => M.AggregateRuntimeBuilder.finish());
+}
+
+function platformImplSatisfiesSpec(P) {
+  let $$let = P.Aggregate.Make;
+  return {
+    Aggregate: {
+      Make: funarg => $$let(funarg)
+    }
+  };
+}
+
+function coerceReadModelSuperset(M) {
+  return M;
+}
+
+function coerceSupersetV2(M) {
+  return M;
+}
+
+function passSupersetsAsSubsetsV2(aggregates) {
+  return aggregates.map(M => M);
+}
+
+function platformImplSatisfiesSpecV2(P) {
+  let $$let = P.Aggregate.Make;
+  return {
+    Aggregate: {
+      Make: funarg => $$let(funarg)
+    }
+  };
+}
+
+export {
+  acceptSubset,
+  coerceSuperset,
+  passSupersetsAsSubsets,
+  finishAggregates,
+  platformImplSatisfiesSpec,
+  coerceReadModelSuperset,
+  coerceSupersetV2,
+  passSupersetsAsSubsetsV2,
+  platformImplSatisfiesSpecV2,
+}
+/* No side effect */

package/tests/querydb/QueryDbFixtures.res

@@ -0,0 +1,65 @@
+S.enableJson()
+
+// ─────────────────────────────────────────────────────────────
+// Test state spec
+// ─────────────────────────────────────────────────────────────
+
+module ItemQueryDbSpec = {
+  module Id = Reventless.Id.StringPure
+  let name = "TestItemQueryDb"
+  let moduleUrl: string = %raw(`import.meta.url`)
+
+  @schema
+  type state = {name: string, count: int}
+
+  let config = Reventless.ReadModel.config()
+  let subIdConfig = None
+}
+
+// ─────────────────────────────────────────────────────────────
+// Mock JSON storage operations
+// ─────────────────────────────────────────────────────────────
+
+let store: ref<dict<array<JSON.t>>> = ref(Dict.make())
+let failNextWrite = ref(false)
+
+let mockJsonOps: QueryDb.operations<string, JSON.t> = {
+  load: async id => Ok(store.contents->Dict.get(id)->Option.getOr([])),
+  loadStream: id => store.contents->Dict.get(id)->Option.getOr([])->Stream.fromIterable,
+  save: async (id, state, _saveMode, _ttl) => {
+    if failNextWrite.contents {
+      failNextWrite := false
+      Error(ReventlessInfra.QueryDb.NotSavedToStorage("mock failure"))
+    } else {
+      store.contents->Dict.set(id, [state])
+      Ok()
+    }
+  },
+  saveBatch: async batch => {
+    if failNextWrite.contents {
+      failNextWrite := false
+      Error(ReventlessInfra.QueryDb.BatchNotFullyWrittenToStorage("mock failure"))
+    } else {
+      batch->Array.forEach(((id, state, _ttl)) => {
+        store.contents->Dict.set(id, [state])
+      })
+      Ok()
+    }
+  },
+  count: async (_id, _field, inc) => Ok(inc),
+  delete: async (id, _subId) => {
+    store.contents->Dict.delete(id)
+    Ok()
+  },
+  deleteBatch: async ids => {
+    ids->Array.forEach(((id, _subId)) => {
+      store.contents->Dict.delete(id)
+    })
+    Ok()
+  },
+}
+
+let reset = () => {
+  store := Dict.make()
+  failNextWrite := false
+}

package/tests/querydb/QueryDbFixtures.res.mjs

@@ -0,0 +1,135 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Stream from "effect/Stream";
+import * as ReadModel$Reventless from "@reventlessdev/reventless-spec/src/components/ReadModel.res.mjs";
+
+S.enableJson();
+
+let moduleUrl = import.meta.url;
+
+let stateSchema = S.schema(s => ({
+  name: s.m(S.string),
+  count: s.m(S.int)
+}));
+
+let config = ReadModel$Reventless.config(undefined, undefined, undefined);
+
+let ItemQueryDbSpec = {
+  Id: undefined,
+  name: "TestItemQueryDb",
+  moduleUrl: moduleUrl,
+  stateSchema: stateSchema,
+  config: config,
+  subIdConfig: undefined,
+  authorization: "AllowAuthenticated",
+  visibility: "Public"
+};
+
+let store = {
+  contents: {}
+};
+
+let failNextWrite = {
+  contents: false
+};
+
+async function mockJsonOps_load(id) {
+  return {
+    TAG: "Ok",
+    _0: Stdlib_Option.getOr(store.contents[id], [])
+  };
+}
+
+function mockJsonOps_loadStream(id) {
+  return Stream.fromIterable(Stdlib_Option.getOr(store.contents[id], []));
+}
+
+async function mockJsonOps_save(id, state, _saveMode, _ttl) {
+  if (failNextWrite.contents) {
+    failNextWrite.contents = false;
+    return {
+      TAG: "Error",
+      _0: {
+        TAG: "NotSavedToStorage",
+        _0: "mock failure"
+      }
+    };
+  } else {
+    store.contents[id] = [state];
+    return {
+      TAG: "Ok",
+      _0: undefined
+    };
+  }
+}
+
+async function mockJsonOps_saveBatch(batch) {
+  if (failNextWrite.contents) {
+    failNextWrite.contents = false;
+    return {
+      TAG: "Error",
+      _0: {
+        TAG: "BatchNotFullyWrittenToStorage",
+        _0: "mock failure"
+      }
+    };
+  } else {
+    batch.forEach(param => {
+      store.contents[param[0]] = [param[1]];
+    });
+    return {
+      TAG: "Ok",
+      _0: undefined
+    };
+  }
+}
+
+async function mockJsonOps_count(_id, _field, inc) {
+  return {
+    TAG: "Ok",
+    _0: inc
+  };
+}
+
+async function mockJsonOps_delete(id, _subId) {
+  Stdlib_Dict.$$delete(store.contents, id);
+  return {
+    TAG: "Ok",
+    _0: undefined
+  };
+}
+
+async function mockJsonOps_deleteBatch(ids) {
+  ids.forEach(param => Stdlib_Dict.$$delete(store.contents, param[0]));
+  return {
+    TAG: "Ok",
+    _0: undefined
+  };
+}
+
+let mockJsonOps = {
+  load: mockJsonOps_load,
+  loadStream: mockJsonOps_loadStream,
+  save: mockJsonOps_save,
+  saveBatch: mockJsonOps_saveBatch,
+  count: mockJsonOps_count,
+  delete: mockJsonOps_delete,
+  deleteBatch: mockJsonOps_deleteBatch
+};
+
+function reset() {
+  store.contents = {};
+  failNextWrite.contents = false;
+}
+
+export {
+  ItemQueryDbSpec,
+  store,
+  failNextWrite,
+  mockJsonOps,
+  reset,
+}
+/*  Not a pure module */

package/tests/querydb/QueryDbOperationsTest.res

@@ -0,0 +1,94 @@
+open JestGlobals
+open QueryDbFixtures
+
+module Ops = QueryDb_Operations.Make(
+  ItemQueryDbSpec,
+  {
+    let jsonOps = mockJsonOps
+  },
+)
+
+let _ = beforeEach(() => reset())
+
+describe("QueryDb_Operations:", () => {
+  describe("loadStream", () => {
+    testPromise("returns empty stream for unknown id", async () => {
+      let result = await Ops.loadStream("unknown-id")->Stream.runCollect->Effect.runPromise
+      expect(result)->toEqual([])
+    })
+
+    testPromise("decodes saved state back to typed state", async () => {
+      let state: ItemQueryDbSpec.state = {name: "Widget", count: 5}
+      let _ = await Ops.save("item-1", state, Init, None)
+      let result = await Ops.loadStream("item-1")->Stream.runCollect->Effect.runPromise
+      switch result {
+      | [s] => expect((s.name, s.count))->toEqual(("Widget", 5))
+      | _ => expect("unexpected result")->toEqual("Ok([state])")
+      }
+    })
+
+    testPromise("returns updated state after overwrite", async () => {
+      let _ = await Ops.save("item-1", {name: "Widget", count: 1}, Init, None)
+      let _ = await Ops.save("item-1", {name: "Widget Updated", count: 2}, Overwrite, None)
+      let result = await Ops.loadStream("item-1")->Stream.runCollect->Effect.runPromise
+      switch result {
+      | [s] => expect(s.name)->toBe("Widget Updated")
+      | _ => expect("unexpected result")->toEqual("Ok([state])")
+      }
+    })
+  })
+
+  describe("save", () => {
+    testPromise("returns Ok on success", async () => {
+      let result = await Ops.save("item-1", {name: "Widget", count: 1}, Init, None)
+      expect(Result.isOk(result))->toBe(true)
+    })
+
+    testPromise("stores id field in JSON", async () => {
+      let _ = await Ops.save("item-42", {name: "Widget", count: 0}, Init, None)
+      let stored = store.contents->Dict.get("item-42")->Option.getOr([])
+      expect(stored->Array.length)->toBe(1)
+      let json = stored->Array.getUnsafe(0)
+      let idField =
+        json
+        ->JSON.Decode.object
+        ->Option.flatMap(d => d->Dict.get("id"))
+        ->Option.flatMap(j => switch j { | JSON.String(s) => Some(s) | _ => None })
+      expect(idField)->toEqual(Some("item-42"))
+    })
+
+    testPromise("returns Error when storage fails", async () => {
+      failNextWrite := true
+      let result = await Ops.save("item-1", {name: "Widget", count: 1}, Init, None)
+      expect(Result.isError(result))->toBe(true)
+    })
+  })
+
+  describe("saveBatch", () => {
+    testPromise("saves multiple states", async () => {
+      let batch = [
+        ("item-1", ({name: "A", count: 1}: ItemQueryDbSpec.state), None),
+        ("item-2", ({name: "B", count: 2}: ItemQueryDbSpec.state), None),
+      ]
+      let _ = await Ops.saveBatch(batch)
+      let r1 = await Ops.loadStream("item-1")->Stream.runCollect->Effect.runPromise
+      let r2 = await Ops.loadStream("item-2")->Stream.runCollect->Effect.runPromise
+      expect((r1->Array.length > 0, r2->Array.length > 0))->toEqual((true, true))
+    })
+
+    testPromise("returns Error when storage fails", async () => {
+      failNextWrite := true
+      let result = await Ops.saveBatch([("item-1", ({name: "A", count: 1}: ItemQueryDbSpec.state), None)])
+      expect(Result.isError(result))->toBe(true)
+    })
+  })
+
+  describe("delete", () => {
+    testPromise("removes state from storage", async () => {
+      let _ = await Ops.save("item-1", {name: "Widget", count: 1}, Init, None)
+      let _ = await Ops.delete("item-1", None)
+      let result = await Ops.loadStream("item-1")->Stream.runCollect->Effect.runPromise
+      expect(result)->toEqual([])
+    })
+  })
+})