@reventlessdev/reventless-seed 1.0.0-alpha.2 → 1.0.0-alpha.4

package/CHANGELOG.md

@@ -3,6 +3,20 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 1.0.0-alpha.4 (2026-07-27)
+
+### Features
+
+* **seed:** guarded AWS store reset (seed:reset) with per-project scope selection ([8446172](https://github.com/ReventlessDev/reventless-core/commit/8446172cbb53776a58f53220d19e96d96ce94508))
+
+
+# 1.0.0-alpha.3 (2026-07-27)
+
+### Features
+
+* **seed:** refuse to seed onto a non-empty store (fresh-store guard) ([987613f](https://github.com/ReventlessDev/reventless-core/commit/987613f0767fc4391297dfeed3a6b19cd76d8157))
+
+
 # 1.0.0-alpha.2 (2026-07-26)
 
 ### Features

package/lib/bs/.compiler.log

@@ -1,2 +1,2 @@
-#Start(1785092483117)
-#Done(1785092488019)
+#Start(1785181007705)
+#Done(1785181012323)

package/lib/bs/compiler-info.json

@@ -4,5 +4,5 @@
   "bsc_hash": "75e3a59c95cc953608fd3dd6ea6ed68141bba4414a20a52f114261b8a48385fa",
   "rescript_config_hash": "ad3a9d479584c1d6e4fe10cd993d9e290f74732e9b0cb3dd5d7429e88b4bba38",
   "runtime_path": "/home/runner/work/reventless-core/reventless-core/node_modules/@rescript/runtime",
-  "generated_at": "1785092488035"
+  "generated_at": "1785181012338"
 }

package/lib/bs/src/Seed.res

@@ -27,6 +27,7 @@ type dataSet = Seed_Runner.dataSet = {
   name: string,
   label: string,
   seed: connection => promise<unit>,
+  probeViews?: array<string>,
 }
 
 type rec value = Seed_Types.value =

package/lib/bs/src/Seed_Client.res

@@ -216,6 +216,42 @@ let queryAllNodes = async (t: t, ~field as fieldName: string, ~selection: string
 let countNodes = async (t: t, ~field: string): int =>
   (await queryAllNodes(t, ~field, ~selection="id"))->Array.length
 
+/**
+ * Polls a connection field until the collected nodes satisfy `satisfied`, or the
+ * timeout elapses. Read models are eventually consistent: a view queried the
+ * instant after the writes that feed it can still read empty or partial (a
+ * DynamoDB connection scan is eventually consistent by default, and the write and
+ * read-back can land on different replicas), so a cross-check that asserts on a
+ * single immediate read races the projection. Same rationale as `waitForIds`,
+ * for the "observe the whole connection" case rather than a fixed id set.
+ *
+ * On timeout, throws `Failed(onTimeout(finalNodes))` so the caller can report
+ * what the view actually settled on — distinguishing a still-empty view from a
+ * genuine count mismatch — instead of a bare assertion.
+ */
+let queryAllNodesUntil = async (
+  t: t,
+  ~field: string,
+  ~selection: string,
+  ~satisfied: array<JSON.t> => bool,
+  ~onTimeout: array<JSON.t> => string,
+  ~timeoutMs: int=60000,
+): array<JSON.t> => {
+  let deadline = nowMs() +. Int.toFloat(timeoutMs)
+  let result = ref(None)
+  while result.contents == None {
+    let nodes = await queryAllNodes(t, ~field, ~selection)
+    if satisfied(nodes) {
+      result := Some(nodes)
+    } else if nowMs() > deadline {
+      throw(Failed(onTimeout(nodes)))
+    } else {
+      await sleep(500)
+    }
+  }
+  result.contents->Option.getOr([])
+}
+
 /**
  * Polls a `<View>ByIds` field until every id is present.
  *

package/lib/bs/src/Seed_Client.res.mjs

@@ -208,6 +208,28 @@ async function countNodes(t, field) {
   return (await queryAllNodes(t, field, "id")).length;
 }
 
+async function queryAllNodesUntil(t, field, selection, satisfied, onTimeout, timeoutMsOpt) {
+  let timeoutMs = timeoutMsOpt !== undefined ? timeoutMsOpt : 60000;
+  let deadline = Date.now() + timeoutMs;
+  let result;
+  while (result === undefined) {
+    let nodes = await queryAllNodes(t, field, selection);
+    if (satisfied(nodes)) {
+      result = nodes;
+    } else {
+      if (Date.now() > deadline) {
+        throw {
+          RE_EXN_ID: Seed_Types$ReventlessSeed.Failed,
+          _1: onTimeout(nodes),
+          Error: new Error()
+        };
+      }
+      await sleep(500);
+    }
+  };
+  return Stdlib_Option.getOr(result, []);
+}
+
 async function waitForIds(t, fieldName, ids, timeoutMsOpt) {
   let timeoutMs = timeoutMsOpt !== undefined ? timeoutMsOpt : 60000;
   let deadline = Date.now() + timeoutMs;
@@ -255,6 +277,7 @@ export {
   sendAll,
   queryAllNodes,
   countNodes,
+  queryAllNodesUntil,
   waitForIds,
 }
 /* No side effect */

package/lib/bs/src/Seed_Runner.res

@@ -90,6 +90,33 @@ let warn = (warnings: array<string>): unit =>
     warnings->Array.forEach(w => Console.log(`  - ${w}`))
   }
 
+/**
+ * Pre-flight: refuse to seed onto a store that already holds data.
+ *
+ * The harness is a one-shot against a fresh store — a re-run would hit the
+ * domain's own duplicate rejections (`CategoryAlreadyExists`, …) and abort
+ * mid-phase. Catching it here, before any command is sent, turns that into an
+ * honest "nothing was written" startup abort instead of a misleading
+ * half-seeded one. It is the inverse of `verifyViews`: seeding refuses to start
+ * unless the store reads empty. Stops at the first non-empty probe view, so a
+ * populated store aborts after a single query.
+ */
+let assertStoreEmpty = async (client: Seed_Client.t, ~probeViews: array<string>): unit =>
+  for i in 0 to probeViews->Array.length - 1 {
+    switch probeViews->Array.get(i) {
+    | Some(name) =>
+      let count = await Seed_Client.countNodes(client, ~field=name)
+      if count > 0 {
+        throw(
+          Failed(
+            `the target store is not empty — "${name}" already holds ${count->Int.toString} row(s). Seeding is a one-shot against a fresh store; reset the store before re-running.`,
+          ),
+        )
+      }
+    | None => ()
+    }
+  }
+
 /**
  * Wraps a seed run. On failure it prints the cause and exits non-zero, saying
  * plainly that the store is now half-seeded — recovery is a reset, not a re-run.
@@ -128,6 +155,9 @@ type dataSet = {
   name: string,
   label: string,
   seed: Seed_Connect.connection => promise<unit>,
+  // View names probed by the fresh-store guard before any command is sent; a
+  // non-empty one aborts the run at startup. Omit to skip the guard.
+  probeViews?: array<string>,
 }
 
 /**
@@ -179,6 +209,9 @@ let seed = (~sets: array<dataSet>, ~connect: unit => promise<Seed_Connect.connec
       }
       let connection = await connect()
       Seed_Prompt.close()
+      // Runs inside this pre-seed `try`, so refusing a non-empty store (or a
+      // failed probe query) is reported as "did not start", not "half-seeded".
+      await assertStoreEmpty(connection.client, ~probeViews=chosen.probeViews->Option.getOr([]))
       Some((chosen, connection))
     } catch {
     | Failed(message) =>

package/lib/bs/src/Seed_Runner.res.mjs

@@ -83,6 +83,22 @@ function warn(warnings) {
   }
 }
 
+async function assertStoreEmpty(client, probeViews) {
+  for (let i = 0, i_finish = probeViews.length; i < i_finish; ++i) {
+    let name = probeViews[i];
+    if (name !== undefined) {
+      let count = await Seed_Client$ReventlessSeed.countNodes(client, name);
+      if (count > 0) {
+        throw {
+          RE_EXN_ID: Seed_Types$ReventlessSeed.Failed,
+          _1: `the target store is not empty — "` + name + `" already holds ` + count.toString() + ` row(s). Seeding is a one-shot against a fresh store; reset the store before re-running.`,
+          Error: new Error()
+        };
+      }
+    }
+  }
+}
+
 async function run(main) {
   try {
     await main();
@@ -146,6 +162,7 @@ function seed(sets, connect) {
       }
       let connection = await connect();
       Seed_Prompt$ReventlessSeed.close();
+      await assertStoreEmpty(connection.client, Stdlib_Option.getOr(chosen.probeViews, []));
       started = [
         chosen,
         connection
@@ -179,6 +196,7 @@ export {
   verifyViews,
   unfillableWarnings,
   warn,
+  assertStoreEmpty,
   run,
   abortStartup,
   seed,

package/lib/ocaml/.compiler.log

@@ -1,2 +1,2 @@
-#Start(1785092483117)
-#Done(1785092488019)
+#Start(1785181007705)
+#Done(1785181012323)

package/lib/ocaml/Seed.res

@@ -27,6 +27,7 @@ type dataSet = Seed_Runner.dataSet = {
   name: string,
   label: string,
   seed: connection => promise<unit>,
+  probeViews?: array<string>,
 }
 
 type rec value = Seed_Types.value =

package/lib/ocaml/Seed_Client.res

@@ -216,6 +216,42 @@ let queryAllNodes = async (t: t, ~field as fieldName: string, ~selection: string
 let countNodes = async (t: t, ~field: string): int =>
   (await queryAllNodes(t, ~field, ~selection="id"))->Array.length
 
+/**
+ * Polls a connection field until the collected nodes satisfy `satisfied`, or the
+ * timeout elapses. Read models are eventually consistent: a view queried the
+ * instant after the writes that feed it can still read empty or partial (a
+ * DynamoDB connection scan is eventually consistent by default, and the write and
+ * read-back can land on different replicas), so a cross-check that asserts on a
+ * single immediate read races the projection. Same rationale as `waitForIds`,
+ * for the "observe the whole connection" case rather than a fixed id set.
+ *
+ * On timeout, throws `Failed(onTimeout(finalNodes))` so the caller can report
+ * what the view actually settled on — distinguishing a still-empty view from a
+ * genuine count mismatch — instead of a bare assertion.
+ */
+let queryAllNodesUntil = async (
+  t: t,
+  ~field: string,
+  ~selection: string,
+  ~satisfied: array<JSON.t> => bool,
+  ~onTimeout: array<JSON.t> => string,
+  ~timeoutMs: int=60000,
+): array<JSON.t> => {
+  let deadline = nowMs() +. Int.toFloat(timeoutMs)
+  let result = ref(None)
+  while result.contents == None {
+    let nodes = await queryAllNodes(t, ~field, ~selection)
+    if satisfied(nodes) {
+      result := Some(nodes)
+    } else if nowMs() > deadline {
+      throw(Failed(onTimeout(nodes)))
+    } else {
+      await sleep(500)
+    }
+  }
+  result.contents->Option.getOr([])
+}
+
 /**
  * Polls a `<View>ByIds` field until every id is present.
  *

package/lib/ocaml/Seed_Runner.res

@@ -90,6 +90,33 @@ let warn = (warnings: array<string>): unit =>
     warnings->Array.forEach(w => Console.log(`  - ${w}`))
   }
 
+/**
+ * Pre-flight: refuse to seed onto a store that already holds data.
+ *
+ * The harness is a one-shot against a fresh store — a re-run would hit the
+ * domain's own duplicate rejections (`CategoryAlreadyExists`, …) and abort
+ * mid-phase. Catching it here, before any command is sent, turns that into an
+ * honest "nothing was written" startup abort instead of a misleading
+ * half-seeded one. It is the inverse of `verifyViews`: seeding refuses to start
+ * unless the store reads empty. Stops at the first non-empty probe view, so a
+ * populated store aborts after a single query.
+ */
+let assertStoreEmpty = async (client: Seed_Client.t, ~probeViews: array<string>): unit =>
+  for i in 0 to probeViews->Array.length - 1 {
+    switch probeViews->Array.get(i) {
+    | Some(name) =>
+      let count = await Seed_Client.countNodes(client, ~field=name)
+      if count > 0 {
+        throw(
+          Failed(
+            `the target store is not empty — "${name}" already holds ${count->Int.toString} row(s). Seeding is a one-shot against a fresh store; reset the store before re-running.`,
+          ),
+        )
+      }
+    | None => ()
+    }
+  }
+
 /**
  * Wraps a seed run. On failure it prints the cause and exits non-zero, saying
  * plainly that the store is now half-seeded — recovery is a reset, not a re-run.
@@ -128,6 +155,9 @@ type dataSet = {
   name: string,
   label: string,
   seed: Seed_Connect.connection => promise<unit>,
+  // View names probed by the fresh-store guard before any command is sent; a
+  // non-empty one aborts the run at startup. Omit to skip the guard.
+  probeViews?: array<string>,
 }
 
 /**
@@ -179,6 +209,9 @@ let seed = (~sets: array<dataSet>, ~connect: unit => promise<Seed_Connect.connec
       }
       let connection = await connect()
       Seed_Prompt.close()
+      // Runs inside this pre-seed `try`, so refusing a non-empty store (or a
+      // failed probe query) is reported as "did not start", not "half-seeded".
+      await assertStoreEmpty(connection.client, ~probeViews=chosen.probeViews->Option.getOr([]))
       Some((chosen, connection))
     } catch {
     | Failed(message) =>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-seed",
-  "version": "1.0.0-alpha.2",
+  "version": "1.0.0-alpha.4",
   "description": "Reusable harness for seeding a Reventless platform through its public GraphQL command API",
   "license": "Apache-2.0",
   "devDependencies": {

package/src/Seed.res

@@ -27,6 +27,7 @@ type dataSet = Seed_Runner.dataSet = {
   name: string,
   label: string,
   seed: connection => promise<unit>,
+  probeViews?: array<string>,
 }
 
 type rec value = Seed_Types.value =

package/src/Seed_Client.res

@@ -216,6 +216,42 @@ let queryAllNodes = async (t: t, ~field as fieldName: string, ~selection: string
 let countNodes = async (t: t, ~field: string): int =>
   (await queryAllNodes(t, ~field, ~selection="id"))->Array.length
 
+/**
+ * Polls a connection field until the collected nodes satisfy `satisfied`, or the
+ * timeout elapses. Read models are eventually consistent: a view queried the
+ * instant after the writes that feed it can still read empty or partial (a
+ * DynamoDB connection scan is eventually consistent by default, and the write and
+ * read-back can land on different replicas), so a cross-check that asserts on a
+ * single immediate read races the projection. Same rationale as `waitForIds`,
+ * for the "observe the whole connection" case rather than a fixed id set.
+ *
+ * On timeout, throws `Failed(onTimeout(finalNodes))` so the caller can report
+ * what the view actually settled on — distinguishing a still-empty view from a
+ * genuine count mismatch — instead of a bare assertion.
+ */
+let queryAllNodesUntil = async (
+  t: t,
+  ~field: string,
+  ~selection: string,
+  ~satisfied: array<JSON.t> => bool,
+  ~onTimeout: array<JSON.t> => string,
+  ~timeoutMs: int=60000,
+): array<JSON.t> => {
+  let deadline = nowMs() +. Int.toFloat(timeoutMs)
+  let result = ref(None)
+  while result.contents == None {
+    let nodes = await queryAllNodes(t, ~field, ~selection)
+    if satisfied(nodes) {
+      result := Some(nodes)
+    } else if nowMs() > deadline {
+      throw(Failed(onTimeout(nodes)))
+    } else {
+      await sleep(500)
+    }
+  }
+  result.contents->Option.getOr([])
+}
+
 /**
  * Polls a `<View>ByIds` field until every id is present.
  *

package/src/Seed_Client.res.mjs

@@ -208,6 +208,28 @@ async function countNodes(t, field) {
   return (await queryAllNodes(t, field, "id")).length;
 }
 
+async function queryAllNodesUntil(t, field, selection, satisfied, onTimeout, timeoutMsOpt) {
+  let timeoutMs = timeoutMsOpt !== undefined ? timeoutMsOpt : 60000;
+  let deadline = Date.now() + timeoutMs;
+  let result;
+  while (result === undefined) {
+    let nodes = await queryAllNodes(t, field, selection);
+    if (satisfied(nodes)) {
+      result = nodes;
+    } else {
+      if (Date.now() > deadline) {
+        throw {
+          RE_EXN_ID: Seed_Types$ReventlessSeed.Failed,
+          _1: onTimeout(nodes),
+          Error: new Error()
+        };
+      }
+      await sleep(500);
+    }
+  };
+  return Stdlib_Option.getOr(result, []);
+}
+
 async function waitForIds(t, fieldName, ids, timeoutMsOpt) {
   let timeoutMs = timeoutMsOpt !== undefined ? timeoutMsOpt : 60000;
   let deadline = Date.now() + timeoutMs;
@@ -255,6 +277,7 @@ export {
   sendAll,
   queryAllNodes,
   countNodes,
+  queryAllNodesUntil,
   waitForIds,
 }
 /* No side effect */

package/src/Seed_Runner.res

@@ -90,6 +90,33 @@ let warn = (warnings: array<string>): unit =>
     warnings->Array.forEach(w => Console.log(`  - ${w}`))
   }
 
+/**
+ * Pre-flight: refuse to seed onto a store that already holds data.
+ *
+ * The harness is a one-shot against a fresh store — a re-run would hit the
+ * domain's own duplicate rejections (`CategoryAlreadyExists`, …) and abort
+ * mid-phase. Catching it here, before any command is sent, turns that into an
+ * honest "nothing was written" startup abort instead of a misleading
+ * half-seeded one. It is the inverse of `verifyViews`: seeding refuses to start
+ * unless the store reads empty. Stops at the first non-empty probe view, so a
+ * populated store aborts after a single query.
+ */
+let assertStoreEmpty = async (client: Seed_Client.t, ~probeViews: array<string>): unit =>
+  for i in 0 to probeViews->Array.length - 1 {
+    switch probeViews->Array.get(i) {
+    | Some(name) =>
+      let count = await Seed_Client.countNodes(client, ~field=name)
+      if count > 0 {
+        throw(
+          Failed(
+            `the target store is not empty — "${name}" already holds ${count->Int.toString} row(s). Seeding is a one-shot against a fresh store; reset the store before re-running.`,
+          ),
+        )
+      }
+    | None => ()
+    }
+  }
+
 /**
  * Wraps a seed run. On failure it prints the cause and exits non-zero, saying
  * plainly that the store is now half-seeded — recovery is a reset, not a re-run.
@@ -128,6 +155,9 @@ type dataSet = {
   name: string,
   label: string,
   seed: Seed_Connect.connection => promise<unit>,
+  // View names probed by the fresh-store guard before any command is sent; a
+  // non-empty one aborts the run at startup. Omit to skip the guard.
+  probeViews?: array<string>,
 }
 
 /**
@@ -179,6 +209,9 @@ let seed = (~sets: array<dataSet>, ~connect: unit => promise<Seed_Connect.connec
       }
       let connection = await connect()
       Seed_Prompt.close()
+      // Runs inside this pre-seed `try`, so refusing a non-empty store (or a
+      // failed probe query) is reported as "did not start", not "half-seeded".
+      await assertStoreEmpty(connection.client, ~probeViews=chosen.probeViews->Option.getOr([]))
       Some((chosen, connection))
     } catch {
     | Failed(message) =>

package/src/Seed_Runner.res.mjs

@@ -83,6 +83,22 @@ function warn(warnings) {
   }
 }
 
+async function assertStoreEmpty(client, probeViews) {
+  for (let i = 0, i_finish = probeViews.length; i < i_finish; ++i) {
+    let name = probeViews[i];
+    if (name !== undefined) {
+      let count = await Seed_Client$ReventlessSeed.countNodes(client, name);
+      if (count > 0) {
+        throw {
+          RE_EXN_ID: Seed_Types$ReventlessSeed.Failed,
+          _1: `the target store is not empty — "` + name + `" already holds ` + count.toString() + ` row(s). Seeding is a one-shot against a fresh store; reset the store before re-running.`,
+          Error: new Error()
+        };
+      }
+    }
+  }
+}
+
 async function run(main) {
   try {
     await main();
@@ -146,6 +162,7 @@ function seed(sets, connect) {
       }
       let connection = await connect();
       Seed_Prompt$ReventlessSeed.close();
+      await assertStoreEmpty(connection.client, Stdlib_Option.getOr(chosen.probeViews, []));
       started = [
         chosen,
         connection
@@ -179,6 +196,7 @@ export {
   verifyViews,
   unfillableWarnings,
   warn,
+  assertStoreEmpty,
   run,
   abortStartup,
   seed,