@reventlessdev/reventless-core 3.0.0-alpha.189 → 3.0.0-alpha.190

package/CHANGELOG.md

@@ -3,6 +3,13 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 3.0.0-alpha.190 (2026-07-28)
+
+### Features
+
+* **platform:** provision object stores from the fields that declare them ([b5e2a1e](https://github.com/ReventlessDev/reventless-core/commit/b5e2a1ec88099941c113e4963f9c4b346b96b0d6))
+
+
 # 3.0.0-alpha.189 (2026-07-28)
 
 **Note:** Version bump only for package @reventlessdev/reventless-core

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-core",
-  "version": "3.0.0-alpha.189",
+  "version": "3.0.0-alpha.190",
   "description": "Core package for Reventless framework",
   "license": "Apache-2.0",
   "jest": {
@@ -31,14 +31,14 @@
     "@reventlessdev/rescript-effect": "0.1.0-alpha.31",
     "@reventlessdev/rescript-fast-csv": "1.2.0-alpha.14",
     "@reventlessdev/rescript-hash-object": "1.2.0-alpha.13",
-    "@reventlessdev/rescript-node-streams": "1.1.0-alpha.13",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.9",
+    "@reventlessdev/rescript-node-streams": "1.1.0-alpha.13",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.17",
     "@reventlessdev/rescript-ssh2": "1.1.0-alpha.14",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.108",
     "@reventlessdev/rescript-uuid": "1.1.0-alpha.17",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.107",
     "@reventlessdev/reventless-interop": "3.0.0-alpha.29",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.82"
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.83"
   },
   "devDependencies": {
     "rescript": "12.3.0",

package/src/admin/Platform_Admin_Structure.res

@@ -126,4 +126,5 @@ let structure: pluginStructure = {
   inboundTranslationSlices: [],
   extensions: [],
   extensionPoints: None,
+  requiredStores: None,
 }

package/src/admin/Platform_Admin_Structure.res.mjs

@@ -166,7 +166,8 @@ let structure = {
   outboundTranslationSlices: structure_outboundTranslationSlices,
   inboundTranslationSlices: structure_inboundTranslationSlices,
   extensions: structure_extensions,
-  extensionPoints: undefined
+  extensionPoints: undefined,
+  requiredStores: undefined
 };
 
 let pluginName = pluginId;

package/src/plugin/component/Plugin_Structure.res

@@ -387,6 +387,73 @@ let make = (
     }
   }
 
+  // ── Declared object stores ─────────────────────────────────────────────────
+  //
+  // A field typed as a storage ref states that the deployment needs the named
+  // store to exist. Read that declaration the same way `Reference.getTarget` is
+  // read for entity references, so the requirement travels with the plugin's
+  // structure instead of living only inside a field's schema, where the deploy
+  // would have to re-walk every component to find it.
+  //
+  // An unqualified store belongs to the declaring plugin, so every collected
+  // entry is qualified to `{plugin}.{store}` — one shape, and the string is
+  // directly the store's identity. Many fields legitimately name one store, so
+  // the result is deduplicated.
+
+  let storesFromProperties = (properties: dict<S.t<unknown>>): array<string> =>
+    properties
+    ->Dict.toArray
+    ->Array.filterMap(((_, fieldSchema)) =>
+      Reventless.StorageRef.getStore(fieldSchema)->Option.map(target =>
+        target.plugin->Option.getOr(name) ++ "." ++ target.store
+      )
+    )
+
+  // Commands and events are unions of per-variant objects; state is a single
+  // object. Both reduce to "the properties of every object in this schema".
+  let storesFromSchema = (schema: S.t<unknown>): array<string> => {
+    let fromVariant = v =>
+      switch v {
+      | S.Object({properties}) => storesFromProperties(properties)
+      | _ => []
+      }
+    switch schema {
+    | Union({anyOf}) => anyOf->Array.flatMap(fromVariant)
+    | other => fromVariant(other)
+    }
+  }
+
+  let requiredStores =
+    [
+      aggregates->Array.flatMap((module(A: ReventlessInfra.Aggregate.T with type api = api)) =>
+        Array.concat(
+          storesFromSchema(A.Spec.commandSchema->S.castToUnknown),
+          storesFromSchema(A.Spec.eventSchema->S.castToUnknown),
+        )
+      ),
+      stateChangeSlices->Array.flatMap((module(SCS: ReventlessInfra.StateChangeSlice.T)) =>
+        Array.concat(
+          storesFromSchema(SCS.Spec.commandSchema->S.castToUnknown),
+          storesFromSchema(SCS.Spec.eventSchema->S.castToUnknown),
+        )
+      ),
+      stateViewSlices->Array.flatMap((module(SVS: ReventlessInfra.StateViewSlice.T)) =>
+        storesFromSchema(SVS.Spec.stateSchema->S.castToUnknown)
+      ),
+      readModels->Array.flatMap((
+        module(R: ReventlessInfra.ReadModel.T with type api = api and type role = role),
+      ) => storesFromSchema(R.Spec.stateSchema->S.castToUnknown)),
+      automationSlices->Array.flatMap((module(AS: ReventlessInfra.AutomationSlice.T)) =>
+        storesFromSchema(AS.Spec.commandSchema->S.castToUnknown)
+      ),
+      inboundTranslationSlices->Array.flatMap((
+        module(ITS: ReventlessInfra.InboundTranslationSlice.T),
+      ) => storesFromSchema(ITS.Spec.commandSchema->S.castToUnknown)),
+    ]
+    ->Array.flat
+    ->Belt.Set.String.fromArray
+    ->Belt.Set.String.toArray
+
   // ── Build queryable defs ───────────────────────────────────────────────────
   //
   // Internal ReadModels and StateViewSlices (marked `@@reventless.visibility(Internal)`)
@@ -608,5 +675,6 @@ let make = (
     inboundTranslationSlices: inboundTranslationSliceDefs,
     extensions: extensionDefs,
     extensionPoints: Some(extensionPointDefs),
+    requiredStores: Some(requiredStores),
   }
 }

package/src/plugin/component/Plugin_Structure.res.mjs

@@ -8,6 +8,7 @@ import * as Belt_SetString from "@rescript/runtime/lib/es6/Belt_SetString.js";
 import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
 import * as Reference$Reventless from "@reventlessdev/reventless-spec/src/components/Reference.res.mjs";
 import * as Logger$ReventlessCore from "../../util/Logger.res.mjs";
+import * as StorageRef$Reventless from "@reventlessdev/reventless-spec/src/semantic/StorageRef.res.mjs";
 import * as DisplayName$Reventless from "@reventlessdev/reventless-spec/src/components/DisplayName.res.mjs";
 import * as Api_Naming$ReventlessCore from "../../components/Api/Api_Naming.res.mjs";
 import * as StateAnnotations$Reventless from "@reventlessdev/reventless-spec/src/components/StateAnnotations.res.mjs";
@@ -316,6 +317,29 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
     let match$3 = scored[0];
     return match$3[0];
   };
+  let storesFromSchema = schema => {
+    let fromVariant = v => {
+      if (v.type === "object") {
+        let properties = v.properties;
+        return Stdlib_Array.filterMap(Object.entries(properties), param => Stdlib_Option.map(StorageRef$Reventless.getStore(param[1]), target => Stdlib_Option.getOr(target.plugin, name) + "." + target.store));
+      } else {
+        return [];
+      }
+    };
+    if (schema.type === "union") {
+      return schema.anyOf.flatMap(fromVariant);
+    } else {
+      return fromVariant(schema);
+    }
+  };
+  let requiredStores = Belt_SetString.toArray(Belt_SetString.fromArray([
+    aggregates.flatMap(A => storesFromSchema(A.Spec.commandSchema).concat(storesFromSchema(A.Spec.eventSchema))),
+    stateChangeSlices.flatMap(SCS => storesFromSchema(SCS.Spec.commandSchema).concat(storesFromSchema(SCS.Spec.eventSchema))),
+    stateViewSlices.flatMap(SVS => storesFromSchema(SVS.Spec.stateSchema)),
+    readModels.flatMap(R => storesFromSchema(R.Spec.stateSchema)),
+    automationSlices.flatMap(AS => storesFromSchema(AS.Spec.commandSchema)),
+    inboundTranslationSlices.flatMap(ITS => storesFromSchema(ITS.Spec.commandSchema))
+  ].flat()));
   let visibilityTag = v => {
     if (v === "Public") {
       return;
@@ -458,7 +482,8 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
     outboundTranslationSlices: outboundTranslationSliceDefs,
     inboundTranslationSlices: inboundTranslationSliceDefs,
     extensions: extensionDefs,
-    extensionPoints: extensionPointDefs
+    extensionPoints: extensionPointDefs,
+    requiredStores: requiredStores
   };
 }
 

package/tests/admin/Platform_ComponentDefinitionsApiTest.res

@@ -85,6 +85,7 @@ let structure: pluginStructure = {
     },
   ],
   extensionPoints: None,
+  requiredStores: None,
 }
 
 let encoded = Platform_ComponentDefinitionsApi.encodePluginStructureEntry(
@@ -295,6 +296,7 @@ describe("allowedStates + statusField populated", () => {
     inboundTranslationSlices: [],
     extensions: [],
     extensionPoints: None,
+    requiredStores: None,
   }
 
   let json =

package/tests/admin/Platform_ComponentDefinitionsApiTest.res.mjs

@@ -118,7 +118,8 @@ let structure = {
   outboundTranslationSlices: structure_outboundTranslationSlices,
   inboundTranslationSlices: structure_inboundTranslationSlices,
   extensions: structure_extensions,
-  extensionPoints: undefined
+  extensionPoints: undefined,
+  requiredStores: undefined
 };
 
 let encoded = Platform_ComponentDefinitionsApi$ReventlessCore.encodePluginStructureEntry("Catalog", structure);
@@ -216,7 +217,8 @@ globalThis.describe("translation-slice externalSystem round-trip", () => {
     outboundTranslationSlices: externalStructure_outboundTranslationSlices,
     inboundTranslationSlices: externalStructure_inboundTranslationSlices,
     extensions: externalStructure_extensions,
-    extensionPoints: undefined
+    extensionPoints: undefined,
+    requiredStores: undefined
   };
   let externalJson = JSON.stringify(Platform_ComponentDefinitionsApi$ReventlessCore.encodePluginStructureEntry("Catalog", externalStructure));
   globalThis.test("surfaces Some outbound externalSystem as its inner string", () => {
@@ -264,7 +266,8 @@ globalThis.describe("visibility filtering (deployed AutoUI hides Internal)", ()
     outboundTranslationSlices: mixed_outboundTranslationSlices,
     inboundTranslationSlices: mixed_inboundTranslationSlices,
     extensions: mixed_extensions,
-    extensionPoints: undefined
+    extensionPoints: undefined,
+    requiredStores: undefined
   };
   let mixedJson = JSON.stringify(Platform_ComponentDefinitionsApi$ReventlessCore.encodePluginStructureEntry("Ordering", mixed));
   globalThis.test("excludes an Internal queryableDef from the encoded read-side", () => {
@@ -340,7 +343,8 @@ globalThis.describe("allowedStates + statusField populated", () => {
     outboundTranslationSlices: structureWithStates_outboundTranslationSlices,
     inboundTranslationSlices: structureWithStates_inboundTranslationSlices,
     extensions: structureWithStates_extensions,
-    extensionPoints: undefined
+    extensionPoints: undefined,
+    requiredStores: undefined
   };
   let json = JSON.stringify(Platform_ComponentDefinitionsApi$ReventlessCore.encodePluginStructureEntry("Platform", structureWithStates));
   globalThis.test("encodes populated allowedStates as a JSON array", () => {

package/tests/message/MessageTest.res

@@ -130,6 +130,7 @@ describe("Message should", () => {
         inboundTranslationSlices: [],
         extensions: [],
         extensionPoints: None,
+        requiredStores: None,
       }),
       dcbEventLog: None,
       kind: Domain,

package/tests/message/MessageTest.res.mjs

@@ -117,7 +117,8 @@ globalThis.describe("Message should", () => {
         outboundTranslationSlices: [],
         inboundTranslationSlices: [],
         extensions: [],
-        extensionPoints: undefined
+        extensionPoints: undefined,
+        requiredStores: undefined
       },
       dcbEventLog: undefined,
       kind: "Domain"

package/tests/plugin/PluginStructureTest.res

@@ -79,6 +79,20 @@ module PsAnnotatedViewSlice: ReventlessInfra.StateViewSlice.T = {
   let make = (~dcbEventLog as _, ~runtime as _=?, ~opts as _=?): component => Obj.magic(0)
 }
 
+module PsAttachInvoiceSlice: ReventlessInfra.StateChangeSlice.T = {
+  module Spec = PsAttachInvoice
+  module Behavior = {
+    type state = PsAttachInvoice.state
+    let initialState = PsAttachInvoice.initialState
+    let evolve = PsAttachInvoice.evolve
+    let decide = PsAttachInvoice.decide
+    let moduleUrl = PsAttachInvoice.moduleUrl
+  }
+  let isAsync = false
+  type component = scsComponent
+  let make = (~dcbEventLog as _, ~publishJsons as _, ~tagKeysByEventType as _=?, ~crossPartitionTagKeys as _=?, ~runtime as _=?, ~opts as _=?): component => Obj.magic(0)
+}
+
 let structure = Plugin_Structure.make(
   ~name="TestPlugin",
   ~stateChangeSlices=[module(PsPlaceOrderSlice), module(PsShipOrderSlice)],
@@ -384,4 +398,36 @@ describe("Plugin_Structure.make — Phase 2 graph fields", () => {
       expect(placeOrder.chapter)->toEqual(None)
     })
   })
+
+  // A field typed as a storage ref states that the deployment needs that store
+  // to exist. Collecting the requirement onto the structure is what lets the
+  // deploy read it without re-walking every component's schema.
+  describe("requiredStores", () => {
+    let withStores = Plugin_Structure.make(
+      ~name="TestPlugin",
+      ~stateChangeSlices=[module(PsAttachInvoiceSlice)],
+    )
+    let stores = withStores.requiredStores->Option.getOr([])
+
+    testSync("an unqualified store resolves against the declaring plugin", () =>
+      expect(stores->Array.includes("TestPlugin.documents"))->toBe(true)
+    )
+
+    testSync("a qualified store keeps its own plugin", () =>
+      expect(stores->Array.includes("branding.logos"))->toBe(true)
+    )
+
+    // `documents` is declared on both a command field and an event field.
+    testSync("a store declared by several fields is collected once", () =>
+      expect(stores->Array.filter(s => s == "TestPlugin.documents")->Array.length)->toBe(1)
+    )
+
+    testSync("only the declared stores are collected", () =>
+      expect(stores->Array.length)->toBe(2)
+    )
+
+    testSync("a plugin declaring no stores collects none — not None", () =>
+      expect(structure.requiredStores)->toEqual(Some([]))
+    )
+  })
 })

package/tests/plugin/PluginStructureTest.res.mjs

@@ -7,6 +7,7 @@ import * as PsShipOrder$ReventlessCore from "./StateChangeSlice/PsShipOrder.res.
 import * as PsOrdersView$ReventlessCore from "./StateViewSlice/PsOrdersView.res.mjs";
 import * as PsPlaceOrder$ReventlessCore from "./StateChangeSlice/PsPlaceOrder.res.mjs";
 import * as PsAnnotatedView$ReventlessCore from "./StateViewSlice/PsAnnotatedView.res.mjs";
+import * as PsAttachInvoice$ReventlessCore from "./StateChangeSlice/PsAttachInvoice.res.mjs";
 import * as PsCustomersView$ReventlessCore from "./StateViewSlice/PsCustomersView.res.mjs";
 import * as Plugin_Structure$ReventlessCore from "../../src/plugin/component/Plugin_Structure.res.mjs";
 import * as PsAvailableProductsView$ReventlessCore from "./StateViewSlice/PsAvailableProductsView.res.mjs";
@@ -175,6 +176,36 @@ let PsAnnotatedViewSlice = {
   make: make$5
 };
 
+let Behavior$2 = {
+  initialState: false,
+  evolve: PsAttachInvoice$ReventlessCore.evolve,
+  decide: PsAttachInvoice$ReventlessCore.decide,
+  moduleUrl: PsAttachInvoice$ReventlessCore.moduleUrl
+};
+
+function make$6(param, param$1, param$2, param$3, param$4, param$5) {
+  return 0;
+}
+
+let PsAttachInvoiceSlice_Spec = {
+  name: PsAttachInvoice$ReventlessCore.name,
+  moduleUrl: PsAttachInvoice$ReventlessCore.moduleUrl,
+  Id: Id$Reventless.$$String,
+  consumedEventSchema: PsAttachInvoice$ReventlessCore.consumedEventSchema,
+  errorSchema: PsAttachInvoice$ReventlessCore.errorSchema,
+  eventSchema: PsAttachInvoice$ReventlessCore.eventSchema,
+  commandSchema: PsAttachInvoice$ReventlessCore.commandSchema,
+  commandAuthorization: PsAttachInvoice$ReventlessCore.commandAuthorization,
+  readConsistency: PsAttachInvoice$ReventlessCore.readConsistency
+};
+
+let PsAttachInvoiceSlice = {
+  Spec: PsAttachInvoiceSlice_Spec,
+  Behavior: Behavior$2,
+  isAsync: false,
+  make: make$6
+};
+
 let structure = Plugin_Structure$ReventlessCore.make("TestPlugin", undefined, undefined, [
   PsOrdersViewSlice,
   PsAvailableProductsViewSlice,
@@ -453,6 +484,25 @@ globalThis.describe("Plugin_Structure.make — Phase 2 graph fields", () => {
       globalThis.expect(placeOrder.chapter).toEqual(undefined);
     });
   });
+  globalThis.describe("requiredStores", () => {
+    let withStores = Plugin_Structure$ReventlessCore.make("TestPlugin", undefined, undefined, undefined, [PsAttachInvoiceSlice], undefined, undefined, undefined, undefined, undefined, undefined);
+    let stores = Stdlib_Option.getOr(withStores.requiredStores, []);
+    globalThis.test("an unqualified store resolves against the declaring plugin", () => {
+      globalThis.expect(stores.includes("TestPlugin.documents")).toBe(true);
+    });
+    globalThis.test("a qualified store keeps its own plugin", () => {
+      globalThis.expect(stores.includes("branding.logos")).toBe(true);
+    });
+    globalThis.test("a store declared by several fields is collected once", () => {
+      globalThis.expect(stores.filter(s => s === "TestPlugin.documents").length).toBe(1);
+    });
+    globalThis.test("only the declared stores are collected", () => {
+      globalThis.expect(stores.length).toBe(2);
+    });
+    globalThis.test("a plugin declaring no stores collects none — not None", () => {
+      globalThis.expect(structure.requiredStores).toEqual([]);
+    });
+  });
 });
 
 export {
@@ -462,6 +512,7 @@ export {
   PsAvailableProductsViewSlice,
   PsCustomersViewSlice,
   PsAnnotatedViewSlice,
+  PsAttachInvoiceSlice,
   structure,
 }
 /* structure Not a pure module */

package/tests/plugin/StateChangeSlice/PsAttachInvoice.res

@@ -0,0 +1,39 @@
+// Test fixture spec for declared-object-store collection.
+//
+// Carries `@storageRef` on a command field, on an event field, and once in the
+// qualified `"<plugin>.<store>"` form — the three shapes Plugin_Structure has to
+// resolve into one qualified identity per store. `documents` is declared twice
+// on purpose so the deduplication is exercised by data rather than asserted in
+// the abstract.
+
+@@reventless.spec("AttachInvoice")
+
+type state = bool
+let initialState = false
+
+@schema
+type consumedEvent = OrderPlaced
+
+let evolve = (_state, _event) => true
+
+// Note the attribute position: `@storageRef(…)` precedes the field NAME. Placed
+// after the colon it attaches to the type expression instead of the field, and
+// the ppx ignores it silently — a declaration that compiles, deploys green, and
+// provisions nothing.
+@schema
+type command =
+  | AttachInvoice({
+      orderId: string,
+      @storageRef("documents") documentUrl: string,
+      // Another plugin's store — qualified, so it must NOT resolve to this
+      // plugin.
+      @storageRef("branding.logos") logoUrl: string,
+    })
+
+@schema
+type error = OrderNotFound
+
+@schema
+type event = InvoiceAttached({orderId: string, @storageRef("documents") documentUrl: string})
+
+let decide = (_state, _command): result<array<event>, error> => Ok([])

package/tests/plugin/StateChangeSlice/PsAttachInvoice.res.mjs

@@ -0,0 +1,63 @@
+// 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 StorageRef$Reventless from "@reventlessdev/reventless-spec/src/semantic/StorageRef.res.mjs";
+
+let consumedEventSchema = S.literal("OrderPlaced");
+
+function evolve(_state, _event) {
+  return true;
+}
+
+let commandSchema = S.schema(s => ({
+  TAG: "AttachInvoice",
+  orderId: s.m(DcbTag$Reventless.string),
+  documentUrl: s.m(StorageRef$Reventless.forStore(undefined, "documents")),
+  logoUrl: s.m(StorageRef$Reventless.forStore("branding", "logos"))
+}));
+
+let errorSchema = S.literal("OrderNotFound");
+
+let eventSchema = S.schema(s => ({
+  TAG: "InvoiceAttached",
+  orderId: s.m(DcbTag$Reventless.string),
+  documentUrl: s.m(StorageRef$Reventless.forStore(undefined, "documents"))
+}));
+
+function decide(_state, _command) {
+  return {
+    TAG: "Ok",
+    _0: []
+  };
+}
+
+function commandAuthorization(param) {
+  return "AllowAuthenticated";
+}
+
+let name = "AttachInvoice";
+
+let Id;
+
+let initialState = false;
+
+let moduleUrl = "@reventlessdev/reventless-core/tests/plugin/StateChangeSlice/PsAttachInvoice.res.mjs";
+
+let readConsistency = "EscalateOnRetry";
+
+export {
+  name,
+  Id,
+  initialState,
+  consumedEventSchema,
+  evolve,
+  commandSchema,
+  errorSchema,
+  eventSchema,
+  decide,
+  moduleUrl,
+  commandAuthorization,
+  readConsistency,
+}
+/* consumedEventSchema Not a pure module */