@reventlessdev/reventless-core 3.0.0-alpha.195 → 3.0.0-alpha.197

package/CHANGELOG.md

@@ -3,6 +3,28 @@
 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.197 (2026-08-01)
+
+### Features
+
+* **spec:** add DateRange semantic type ([d85b6cc](https://github.com/ReventlessDev/reventless-core/commit/d85b6cc18241644905241df2abd99949dd758059))
+
+
+# 3.0.0-alpha.196 (2026-07-31)
+
+* feat(rescript)!: one Node bindings package, not two ([1258d8c](https://github.com/ReventlessDev/reventless-core/commit/1258d8c2b2ff2636b36a849fc5bdf9005c6fb0eb))
+### Features
+
+* **spec:** add Money and a closed ISO 4217 Currency ([d4852ab](https://github.com/ReventlessDev/reventless-core/commit/d4852ab63e823e39fac793c4fa5ac31470db9655))
+
+### BREAKING CHANGES
+
+* `@reventlessdev/rescript-node-streams` and
+`@reventlessdev/rescript-node-zlib` are replaced by
+`@reventlessdev/rescript-node`. Module names are unchanged.
+
+
+
 # 3.0.0-alpha.195 (2026-07-30)
 
 ### Bug Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-core",
-  "version": "3.0.0-alpha.195",
+  "version": "3.0.0-alpha.197",
   "description": "Core package for Reventless framework",
   "license": "Apache-2.0",
   "jest": {
@@ -28,17 +28,17 @@
   "dependencies": {
     "sury": "11.0.0-alpha.4",
     "uuid": "^13.0.0",
-    "@reventlessdev/rescript-effect": "0.1.0-alpha.31",
-    "@reventlessdev/rescript-hash-object": "1.2.0-alpha.13",
-    "@reventlessdev/rescript-fast-csv": "1.2.0-alpha.14",
-    "@reventlessdev/rescript-jest": "1.0.0-alpha.9",
-    "@reventlessdev/rescript-node-streams": "1.1.0-alpha.13",
-    "@reventlessdev/rescript-ssh2": "1.1.0-alpha.14",
-    "@reventlessdev/rescript-uuid": "1.1.0-alpha.17",
-    "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.17",
-    "@reventlessdev/reventless-interop": "3.0.0-alpha.29",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.88",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.113"
+    "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
+    "@reventlessdev/rescript-fast-csv": "2.0.0-alpha.0",
+    "@reventlessdev/rescript-hash-object": "1.2.0-alpha.14",
+    "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
+    "@reventlessdev/rescript-node": "2.0.0-alpha.0",
+    "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.18",
+    "@reventlessdev/rescript-ssh2": "2.0.0-alpha.0",
+    "@reventlessdev/reventless-interop": "3.0.0-alpha.30",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.115",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.90",
+    "@reventlessdev/rescript-uuid": "2.0.0-alpha.0"
   },
   "devDependencies": {
     "rescript": "12.3.0",

package/rescript.json

@@ -29,7 +29,7 @@
     "@reventlessdev/rescript-effect",
     "@reventlessdev/rescript-fast-csv",
     "@reventlessdev/rescript-hash-object",
-    "@reventlessdev/rescript-node-streams",
+    "@reventlessdev/rescript-node",
     "@reventlessdev/rescript-pulumi-pulumi",
     "@reventlessdev/rescript-ssh2",
     "@reventlessdev/rescript-uuid",

package/src/plugin/component/Plugin_Helpers.res

@@ -1165,16 +1165,14 @@ let getInteropMeta = (): Pulumi.Output.t<JSON.t> => {
 // Stack metadata export — environment, region, timestamp, actor, git SHA.
 // Called from both exportPluginOutputs and exportPlatformOutputs.
 // ---------------------------------------------------------------------------
-@val external processEnv: dict<string> = "process.env"
-
 let exportDeploymentMetadata = () => {
   let metadata =
     [
       ("environment", Pulumi.Pulumi.getStackName()),
       ("region", Pulumi.Config.make(Some("aws"))->Pulumi.Config.get("region")->Option.getOr("unknown")),
       ("timestamp", Date.make()->Date.toISOString),
-      ("gitSha", processEnv->Dict.get("GITHUB_SHA")->Option.getOr("unknown")),
-      ("actor", processEnv->Dict.get("GITHUB_ACTOR")->Option.getOr("unknown")),
+      ("gitSha", NodeProcess.env->Dict.get("GITHUB_SHA")->Option.getOr("unknown")),
+      ("actor", NodeProcess.env->Dict.get("GITHUB_ACTOR")->Option.getOr("unknown")),
     ]
     ->Dict.fromArray
   Pulumi.Pulumi.export(
@@ -1516,15 +1514,15 @@ let exportPluginOutputs = (pluginOutputs: Plugin.outputs) => {
   | Some(hook) =>
     // Read deployment provenance from env vars synchronously (before Output.apply).
     let actor =
-      processEnv
+      NodeProcess.env
       ->Dict.get("GITHUB_ACTOR")
-      ->Option.orElse(processEnv->Dict.get("CI_COMMIT_AUTHOR"))
-      ->Option.orElse(processEnv->Dict.get("USER"))
+      ->Option.orElse(NodeProcess.env->Dict.get("CI_COMMIT_AUTHOR"))
+      ->Option.orElse(NodeProcess.env->Dict.get("USER"))
       ->Option.getOr("local")
     let deploymentId =
-      processEnv
+      NodeProcess.env
       ->Dict.get("GITHUB_SHA")
-      ->Option.orElse(processEnv->Dict.get("CI_COMMIT_SHA"))
+      ->Option.orElse(NodeProcess.env->Dict.get("CI_COMMIT_SHA"))
       ->Option.getOr(Date.make()->Date.toISOString)
     let schemaFor = name =>
       componentSchemaRegistry->Dict.get(name)->Option.getOr({})

package/src/util/FTPHandler.res.mjs

@@ -2,7 +2,7 @@
 
 import * as SSH2 from "@reventlessdev/rescript-ssh2/src/SSH2.res.mjs";
 import * as Ssh2 from "ssh2";
-import * as Stream from "stream";
+import * as Nodestream from "node:stream";
 import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Effect from "effect/Effect";
@@ -122,7 +122,7 @@ function ftp(connectionParams, ftpAction) {
             let err$1 = new Error("FTPHandler: Error in Write Stream");
             sftp.emit("error", err$1);
           });
-          return await Stream.promises.pipeline(ftpAction._0, ws);
+          return await Nodestream.promises.pipeline(ftpAction._0, ws);
         }
       }
     }, () => {});

package/tests/api/SuryToJsonSchemaTest.res

@@ -677,4 +677,121 @@ describe("SuryToJsonSchema:", () => {
       ))->toEqual((Some(JSON.Encode.string("type")), Some(JSON.Encode.string("type"))))
     )
   })
+
+  // The other half of that claim, stated so it cannot be confused with it.
+  // `Money` is the first semantic type that is *not* a brand: it turns a number
+  // into an object, so the wire shape changes and stored events written against
+  // the old field do not decode. The assertions below are the evidence for that
+  // — a schema diff before and after a retype is exactly this, and it is what
+  // says a deployment needs an upcaster before it can take the change.
+  describe("Money changes the field's shape, and says so:", () => {
+    let json = SuryToJsonSchema.deriveObjectSchema(
+      S.schema(s =>
+        {
+          "price": s.matches(Reventless.Money.schema),
+          "quantity": s.matches(S.float),
+        }
+      )->S.castToUnknown,
+    )
+    let keyOf = (name, key) => getPropertyOf(json, name)->Option.flatMap(s => getProperty(s, key))
+
+    testSync("the field is an object, not a number", () =>
+      expect(keyOf("price", "type"))->toEqual(Some(JSON.Encode.string("object")))
+    )
+
+    testSync("it carries the money id, sourced from the type", () =>
+      expect((keyOf("price", "x-reventless-semantic"), keyOf("price", "x-reventless-semantic-source")))
+      ->toEqual((Some(JSON.Encode.string("money")), Some(JSON.Encode.string("type"))))
+    )
+
+    // The control: an ordinary `float` price is what the field looked like
+    // before, and it emits nothing at all. Without this the assertions above
+    // would pass just as well against a schema that had always said `money`.
+    testSync("a plain numeric field emits no semantic", () =>
+      expect((keyOf("quantity", "type"), keyOf("quantity", "x-reventless-semantic")))->toEqual((
+        Some(JSON.Encode.string("number")),
+        None,
+      ))
+    )
+
+    testSync("the amount and the currency both reach the wire", () => {
+      let inner = getPropertyOf(json, "price")->Option.getOr(JSON.Encode.null)
+      expect((
+        getPropertyOf(inner, "amount")->Option.flatMap(s => getProperty(s, "type")),
+        getPropertyOf(inner, "currency")->Option.flatMap(s => getProperty(s, "type")),
+      ))->toEqual((Some(JSON.Encode.string("number")), Some(JSON.Encode.string("string"))))
+    })
+
+    // The closed currency arrives as an enum rather than a free string, which is
+    // what lets a consumer build a currency picker instead of a text box — and
+    // what makes `"eur"` unrepresentable on the wire as well as in the source.
+    testSync("the currency is an enum of ISO codes", () => {
+      let codes =
+        getPropertyOf(json, "price")
+        ->Option.getOr(JSON.Encode.null)
+        ->getPropertyOf("currency")
+        ->Option.flatMap(s => getProperty(s, "enum"))
+        ->Option.flatMap(JSON.Decode.array)
+        ->Option.getOr([])
+        ->Array.filterMap(JSON.Decode.string)
+      expect((
+        codes->Array.length == Reventless.Currency.all->Array.length,
+        codes->Array.includes("EUR"),
+        codes->Array.includes("JPY"),
+        codes->Array.includes("eur"),
+      ))->toEqual((true, true, true, false))
+    })
+  })
+
+  // The second composite, and the one whose emission the reader's shape rung
+  // depends on. Like `Money` it turns the field into an object — same
+  // shape-changed evidence, same upcaster warning for a collapse. Unlike it, the
+  // two parts keep their own `dateTime` marker, so a walker that only understands
+  // date-times still sees into the composite. That last property is asserted, not
+  // described, because it is what lets the UI's primary rung key on the shape
+  // before the `dateRange` marker reaches it in a release.
+  describe("DateRange is an object whose parts stay date-times:", () => {
+    let json = SuryToJsonSchema.deriveObjectSchema(
+      S.schema(s =>
+        {
+          "deliveryWindow": s.matches(Reventless.DateRange.schema),
+          "orderedAt": s.matches(Reventless.DateTime.string),
+        }
+      )->S.castToUnknown,
+    )
+    let keyOf = (name, key) => getPropertyOf(json, name)->Option.flatMap(s => getProperty(s, key))
+
+    testSync("the field is an object, not a string", () =>
+      expect(keyOf("deliveryWindow", "type"))->toEqual(Some(JSON.Encode.string("object")))
+    )
+
+    testSync("it carries the dateRange id, sourced from the type", () =>
+      expect((
+        keyOf("deliveryWindow", "x-reventless-semantic"),
+        keyOf("deliveryWindow", "x-reventless-semantic-source"),
+      ))->toEqual((Some(JSON.Encode.string("dateRange")), Some(JSON.Encode.string("type"))))
+    )
+
+    // The property that is not incidental: each part keeps its own date-time
+    // marker under the composite. `dateTime` predates the generic marker and
+    // surfaces as `format: "date-time"` (not `x-reventless-semantic`), so that is
+    // what a walker reads to see the two instants without knowing about ranges.
+    testSync("both instants keep their own date-time marker", () => {
+      let inner = getPropertyOf(json, "deliveryWindow")->Option.getOr(JSON.Encode.null)
+      expect((
+        getPropertyOf(inner, "start")->Option.flatMap(s => getProperty(s, "format")),
+        getPropertyOf(inner, "end")->Option.flatMap(s => getProperty(s, "format")),
+      ))->toEqual((Some(JSON.Encode.string("date-time")), Some(JSON.Encode.string("date-time"))))
+    })
+
+    // The control, mirroring the `Money` block's plain-float case: a lone
+    // date-time field stays a string and never becomes an object, so the
+    // object-ness above is the composite's doing and not the walk's.
+    testSync("a lone date-time field stays a string", () =>
+      expect((keyOf("orderedAt", "type"), keyOf("orderedAt", "format")))->toEqual((
+        Some(JSON.Encode.string("string")),
+        Some(JSON.Encode.string("date-time")),
+      ))
+    )
+  })
 })

package/tests/api/SuryToJsonSchemaTest.res.mjs

@@ -5,10 +5,13 @@ 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 Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Email$Reventless from "@reventlessdev/reventless-spec/src/semantic/Email.res.mjs";
+import * as Money$Reventless from "@reventlessdev/reventless-spec/src/semantic/Money.res.mjs";
 import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
 import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
 import * as Percent$Reventless from "@reventlessdev/reventless-spec/src/semantic/Percent.res.mjs";
+import * as Currency$Reventless from "@reventlessdev/reventless-spec/src/semantic/Currency.res.mjs";
 import * as DateTime$Reventless from "@reventlessdev/reventless-spec/src/types/DateTime.res.mjs";
+import * as DateRange$Reventless from "@reventlessdev/reventless-spec/src/semantic/DateRange.res.mjs";
 import * as Reference$Reventless from "@reventlessdev/reventless-spec/src/components/Reference.res.mjs";
 import * as StorageRef$Reventless from "@reventlessdev/reventless-spec/src/semantic/StorageRef.res.mjs";
 import * as StateAnnotations$Reventless from "@reventlessdev/reventless-spec/src/components/StateAnnotations.res.mjs";
@@ -981,6 +984,96 @@ globalThis.describe("SuryToJsonSchema:", () => {
       ]);
     });
   });
+  globalThis.describe("Money changes the field's shape, and says so:", () => {
+    let json = SuryToJsonSchema$ReventlessCore.deriveObjectSchema(S.schema(s => ({
+      price: s.m(Money$Reventless.schema),
+      quantity: s.m(S.float)
+    })));
+    let keyOf = (name, key) => Stdlib_Option.flatMap(getPropertyOf(json, name), s => getProperty(s, key));
+    globalThis.test("the field is an object, not a number", () => {
+      globalThis.expect(keyOf("price", "type")).toEqual("object");
+    });
+    globalThis.test("it carries the money id, sourced from the type", () => {
+      globalThis.expect([
+        keyOf("price", "x-reventless-semantic"),
+        keyOf("price", "x-reventless-semantic-source")
+      ]).toEqual([
+        "money",
+        "type"
+      ]);
+    });
+    globalThis.test("a plain numeric field emits no semantic", () => {
+      globalThis.expect([
+        keyOf("quantity", "type"),
+        keyOf("quantity", "x-reventless-semantic")
+      ]).toEqual([
+        "number",
+        undefined
+      ]);
+    });
+    globalThis.test("the amount and the currency both reach the wire", () => {
+      let inner = Stdlib_Option.getOr(getPropertyOf(json, "price"), null);
+      globalThis.expect([
+        Stdlib_Option.flatMap(getPropertyOf(inner, "amount"), s => getProperty(s, "type")),
+        Stdlib_Option.flatMap(getPropertyOf(inner, "currency"), s => getProperty(s, "type"))
+      ]).toEqual([
+        "number",
+        "string"
+      ]);
+    });
+    globalThis.test("the currency is an enum of ISO codes", () => {
+      let codes = Stdlib_Array.filterMap(Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(getPropertyOf(Stdlib_Option.getOr(getPropertyOf(json, "price"), null), "currency"), s => getProperty(s, "enum")), Stdlib_JSON.Decode.array), []), Stdlib_JSON.Decode.string);
+      globalThis.expect([
+        codes.length === Currency$Reventless.all.length,
+        codes.includes("EUR"),
+        codes.includes("JPY"),
+        codes.includes("eur")
+      ]).toEqual([
+        true,
+        true,
+        true,
+        false
+      ]);
+    });
+  });
+  globalThis.describe("DateRange is an object whose parts stay date-times:", () => {
+    let json = SuryToJsonSchema$ReventlessCore.deriveObjectSchema(S.schema(s => ({
+      deliveryWindow: s.m(DateRange$Reventless.schema),
+      orderedAt: s.m(DateTime$Reventless.string)
+    })));
+    let keyOf = (name, key) => Stdlib_Option.flatMap(getPropertyOf(json, name), s => getProperty(s, key));
+    globalThis.test("the field is an object, not a string", () => {
+      globalThis.expect(keyOf("deliveryWindow", "type")).toEqual("object");
+    });
+    globalThis.test("it carries the dateRange id, sourced from the type", () => {
+      globalThis.expect([
+        keyOf("deliveryWindow", "x-reventless-semantic"),
+        keyOf("deliveryWindow", "x-reventless-semantic-source")
+      ]).toEqual([
+        "dateRange",
+        "type"
+      ]);
+    });
+    globalThis.test("both instants keep their own date-time marker", () => {
+      let inner = Stdlib_Option.getOr(getPropertyOf(json, "deliveryWindow"), null);
+      globalThis.expect([
+        Stdlib_Option.flatMap(getPropertyOf(inner, "start"), s => getProperty(s, "format")),
+        Stdlib_Option.flatMap(getPropertyOf(inner, "end"), s => getProperty(s, "format"))
+      ]).toEqual([
+        "date-time",
+        "date-time"
+      ]);
+    });
+    globalThis.test("a lone date-time field stays a string", () => {
+      globalThis.expect([
+        keyOf("orderedAt", "type"),
+        keyOf("orderedAt", "format")
+      ]).toEqual([
+        "string",
+        "date-time"
+      ]);
+    });
+  });
 });
 
 export {

package/tests/logger/LogFormatTest.res

@@ -7,8 +7,7 @@ S.enableJson()
 // included — to JSON, which no-ops `bold`/`fmtComp`. The human-format
 // assertions below expect ANSI, so force text mode for this file. The
 // "JSON sink" block flips to json and restores text in its own setup.
-@val external _processEnv: Dict.t<string> = "process.env"
-_processEnv->Dict.set("REVENTLESS_LOG_FORMAT", "text")
+NodeProcess.env->Dict.set("REVENTLESS_LOG_FORMAT", "text")
 Reventless.AnsiStyle.reload()
 
 describe("LogFormat", () => {
@@ -193,11 +192,11 @@ describe("JSON sink", () => {
   // Flip to json for the whole block; restore text afterwards so a re-run of the
   // file (or shared module state) keeps the human-format assertions valid.
   beforeAll(() => {
-    _processEnv->Dict.set("REVENTLESS_LOG_FORMAT", "json")
+    NodeProcess.env->Dict.set("REVENTLESS_LOG_FORMAT", "json")
     Reventless.AnsiStyle.reload()
   })
   afterAll(() => {
-    _processEnv->Dict.set("REVENTLESS_LOG_FORMAT", "text")
+    NodeProcess.env->Dict.set("REVENTLESS_LOG_FORMAT", "text")
     Reventless.AnsiStyle.reload()
   })
 
@@ -344,10 +343,10 @@ describe("JSON sink", () => {
   })
 
   testSync("service field is emitted when REVENTLESS_SERVICE is set", () => {
-    _processEnv->Dict.set("REVENTLESS_SERVICE", "TestService")
+    NodeProcess.env->Dict.set("REVENTLESS_SERVICE", "TestService")
     let lines = captureLogs(() => log.info(~comp="Platform", "tick"))
     let got = lines->Array.get(0)->Option.flatMap(l => l->fieldOf("service"))
-    _processEnv->Dict.delete("REVENTLESS_SERVICE")
+    NodeProcess.env->Dict.delete("REVENTLESS_SERVICE")
     expect(got)->toEqual(Some("TestService"))
   })
 

package/tests/util/CsvStreamTest.res

@@ -4,16 +4,13 @@
 
 open JestGlobals
 
-// Write a UTF-8 string to a file synchronously (no return value).
-@module("fs") external writeFileSync: (string, string) => unit = "writeFileSync"
-
 // Counter for unique temp file names — avoids cross-test collisions.
 let fileCounter = ref(0)
 
 let writeTempCsv = (content: string): string => {
   fileCounter := fileCounter.contents + 1
   let path = `/tmp/reventless-csvstream-test-${Int.toString(fileCounter.contents)}.csv`
-  writeFileSync(path, content)
+  NodeFs.writeFileSync(path, content)
   path
 }
 

package/tests/util/CsvStreamTest.res.mjs

@@ -1,7 +1,7 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as Fs from "fs";
 import * as Stream from "@reventlessdev/rescript-effect/src/Stream.res.mjs";
+import * as Nodefs from "node:fs";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Effect from "effect/Effect";
@@ -15,7 +15,7 @@ let fileCounter = {
 function writeTempCsv(content) {
   fileCounter.contents = fileCounter.contents + 1 | 0;
   let path = `/tmp/reventless-csvstream-test-` + fileCounter.contents.toString() + `.csv`;
-  Fs.writeFileSync(path, content);
+  Nodefs.writeFileSync(path, content, "utf8");
   return path;
 }