@reventlessdev/reventless-local 3.0.0-alpha.167 → 3.0.0-alpha.169

package/tests/adapter/ServedBucketHttpTest.res

@@ -0,0 +1,174 @@
+// End-to-end test for the local served-bucket HTTP routes on DomainGraphQL_Server
+// (the dev analogue of the AWS CloudFront read path). Boots a real server on a
+// private port, then exercises the full upload → store → serve loop:
+//   POST /__inmemory/upload → {uploadUrl, storageRef}
+//   PUT  /{prefix}/{key}    → 200 (store)
+//   GET  /{prefix}/{key}    → the stored bytes + content-type
+// Talks to the server over node:http (Jest 27's VM strips global fetch), same
+// as LocalAuthHttpTest.
+
+@@warning("-44")
+
+open JestGlobals
+
+let _ = TestRunner.setup()
+
+// High ephemeral port, clear of dev-server defaults and the auth HTTP test.
+let port = 49322
+
+// ── Minimal node:http helpers ───────────────────────────────────────────────
+
+type httpRequestOptions = {
+  hostname: string,
+  port: int,
+  path: string,
+  method: string,
+  headers: dict<string>,
+}
+type httpReq
+type httpRes
+@module("node:http") external _request: (httpRequestOptions, httpRes => unit) => httpReq = "request"
+@send external _reqWrite: (httpReq, string) => unit = "write"
+@send external _reqEnd: (httpReq, @as(json`null`) _) => unit = "end"
+@send external _reqOnError: (httpReq, @as("error") _, 'err => unit) => unit = "on"
+@send external _resOnData: (httpRes, @as("data") _, 'chunk => unit) => unit = "on"
+@send external _resOnEnd: (httpRes, @as("end") _, unit => unit) => unit = "on"
+@send external _resSetEncoding: (httpRes, string) => unit = "setEncoding"
+@get external _resStatusCode: httpRes => int = "statusCode"
+@get external _resHeaders: httpRes => dict<string> = "headers"
+
+let postJson = (path: string, body: dict<JSON.t>): promise<(int, JSON.t)> =>
+  Promise.make((resolve, reject) => {
+    let bodyStr = body->JSON.Encode.object->JSON.stringify
+    let req =
+      _request(
+        {
+          hostname: "localhost",
+          port,
+          path,
+          method: "POST",
+          headers: Dict.fromArray([
+            ("content-type", "application/json"),
+            ("content-length", bodyStr->String.length->Int.toString),
+          ]),
+        },
+        res => {
+          let status = _resStatusCode(res)
+          let buf = ref("")
+          res->_resSetEncoding("utf8")
+          res->_resOnData(chunk => buf := buf.contents ++ Obj.magic(chunk))
+          res->_resOnEnd(() => {
+            let parsed = try buf.contents->JSON.parseOrThrow catch {
+            | _ => JSON.Encode.null
+            }
+            resolve((status, parsed))
+          })
+        },
+      )
+    req->_reqOnError(err => reject(Obj.magic(err)))
+    req->_reqWrite(bodyStr)
+    req->_reqEnd
+  })
+
+// PUT a raw (ASCII) body to a served-object path. Content-length is byte-safe
+// only for ASCII payloads, which the SVG fixture below is.
+let putRaw = (path: string, body: string, ~contentType: string): promise<int> =>
+  Promise.make((resolve, reject) => {
+    let req =
+      _request(
+        {
+          hostname: "localhost",
+          port,
+          path,
+          method: "PUT",
+          headers: Dict.fromArray([
+            ("content-type", contentType),
+            ("content-length", body->String.length->Int.toString),
+          ]),
+        },
+        res => {
+          let status = _resStatusCode(res)
+          res->_resOnData(_ => ())
+          res->_resOnEnd(() => resolve(status))
+        },
+      )
+    req->_reqOnError(err => reject(Obj.magic(err)))
+    req->_reqWrite(body)
+    req->_reqEnd
+  })
+
+let getRaw = (path: string): promise<(int, string, string)> =>
+  Promise.make((resolve, reject) => {
+    let req =
+      _request(
+        {hostname: "localhost", port, path, method: "GET", headers: Dict.make()},
+        res => {
+          let status = _resStatusCode(res)
+          let contentType = _resHeaders(res)->Dict.get("content-type")->Option.getOr("")
+          let buf = ref("")
+          res->_resSetEncoding("utf8")
+          res->_resOnData(chunk => buf := buf.contents ++ Obj.magic(chunk))
+          res->_resOnEnd(() => resolve((status, buf.contents, contentType)))
+        },
+      )
+    req->_reqOnError(err => reject(Obj.magic(err)))
+    req->_reqEnd
+  })
+
+let getString = (j: JSON.t, k: string): string =>
+  j->JSON.Decode.object->Option.flatMap(d => d->Dict.get(k))->Option.flatMap(JSON.Decode.string)->Option.getOr("")
+
+// ── Lifecycle ────────────────────────────────────────────────────────────────
+
+beforeAllAsync(async () => {
+  DomainGraphQL_Server.reset()
+  DomainGraphQL_Server.start(~port, ())
+  await Promise.make((resolve, _) => setTimeout(() => resolve(), 50)->ignore)
+})
+
+afterAll(() => {
+  DomainGraphQL_Server.stop()
+})
+
+// ── Tests ──────────────────────────────────────────────────────────────────
+
+testPromise("POST /__inmemory/upload returns matching uploadUrl + storageRef under the prefix", async () => {
+  let (status, body) =
+    await postJson(
+      "/__inmemory/upload",
+      Dict.fromArray([
+        ("fileName", JSON.Encode.string("logo.svg")),
+        ("contentType", JSON.Encode.string("image/svg+xml")),
+      ]),
+    )
+  expect(status)->toEqual(200)
+  let uploadUrl = getString(body, "uploadUrl")
+  let storageRef = getString(body, "storageRef")
+  // Same same-origin ref serves as both the PUT target and the stored value.
+  expect(uploadUrl)->toEqual(storageRef)
+  expect(storageRef->String.startsWith("/uploads/"))->toEqual(true)
+  expect(storageRef->String.endsWith("/logo.svg"))->toEqual(true)
+})
+
+testPromise("PUT then GET round-trips the bytes and content-type", async () => {
+  let (_, body) =
+    await postJson(
+      "/__inmemory/upload",
+      Dict.fromArray([("fileName", JSON.Encode.string("pixel.svg"))]),
+    )
+  let ref = getString(body, "storageRef")
+  let svg = "<svg xmlns='http://www.w3.org/2000/svg' width='1' height='1'></svg>"
+
+  let putStatus = await putRaw(ref, svg, ~contentType="image/svg+xml")
+  expect(putStatus)->toEqual(200)
+
+  let (getStatus, gotBody, gotContentType) = await getRaw(ref)
+  expect(getStatus)->toEqual(200)
+  expect(gotBody)->toEqual(svg)
+  expect(gotContentType)->toEqual("image/svg+xml")
+})
+
+testPromise("GET a missing served object returns 404", async () => {
+  let (status, _, _) = await getRaw("/uploads/missing/none.svg")
+  expect(status)->toEqual(404)
+})

package/tests/adapter/ServedBucketHttpTest.res.mjs

@@ -0,0 +1,177 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Nodehttp from "node:http";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as TestRunner$ReventlessLocal from "../../src/test/TestRunner.res.mjs";
+import * as DomainGraphQL_Server$ReventlessLocal from "../../src/adapter/DomainGraphQL_Server.res.mjs";
+
+TestRunner$ReventlessLocal.setup();
+
+function postJson(path, body) {
+  return new Promise((resolve, reject) => {
+    let bodyStr = JSON.stringify(body);
+    let req = Nodehttp.request({
+      hostname: "localhost",
+      port: 49322,
+      path: path,
+      method: "POST",
+      headers: Object.fromEntries([
+        [
+          "content-type",
+          "application/json"
+        ],
+        [
+          "content-length",
+          bodyStr.length.toString()
+        ]
+      ])
+    }, res => {
+      let status = res.statusCode;
+      let buf = {
+        contents: ""
+      };
+      res.setEncoding("utf8");
+      res.on("data", chunk => {
+        buf.contents = buf.contents + chunk;
+      });
+      res.on("end", () => {
+        let parsed;
+        try {
+          parsed = JSON.parse(buf.contents);
+        } catch (exn) {
+          parsed = null;
+        }
+        resolve([
+          status,
+          parsed
+        ]);
+      });
+    });
+    req.on("error", err => reject(err));
+    req.write(bodyStr);
+    req.end(null);
+  });
+}
+
+function putRaw(path, body, contentType) {
+  return new Promise((resolve, reject) => {
+    let req = Nodehttp.request({
+      hostname: "localhost",
+      port: 49322,
+      path: path,
+      method: "PUT",
+      headers: Object.fromEntries([
+        [
+          "content-type",
+          contentType
+        ],
+        [
+          "content-length",
+          body.length.toString()
+        ]
+      ])
+    }, res => {
+      let status = res.statusCode;
+      res.on("data", param => {});
+      res.on("end", () => resolve(status));
+    });
+    req.on("error", err => reject(err));
+    req.write(body);
+    req.end(null);
+  });
+}
+
+function getRaw(path) {
+  return new Promise((resolve, reject) => {
+    let req = Nodehttp.request({
+      hostname: "localhost",
+      port: 49322,
+      path: path,
+      method: "GET",
+      headers: {}
+    }, res => {
+      let status = res.statusCode;
+      let contentType = Stdlib_Option.getOr(res.headers["content-type"], "");
+      let buf = {
+        contents: ""
+      };
+      res.setEncoding("utf8");
+      res.on("data", chunk => {
+        buf.contents = buf.contents + chunk;
+      });
+      res.on("end", () => resolve([
+        status,
+        buf.contents,
+        contentType
+      ]));
+    });
+    req.on("error", err => reject(err));
+    req.end(null);
+  });
+}
+
+function getString(j, k) {
+  return Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(j), d => d[k]), Stdlib_JSON.Decode.string), "");
+}
+
+globalThis.beforeAll(async () => {
+  DomainGraphQL_Server$ReventlessLocal.reset();
+  DomainGraphQL_Server$ReventlessLocal.start(49322, undefined, undefined);
+  return await new Promise((resolve, param) => {
+    setTimeout(() => resolve(), 50);
+  });
+});
+
+globalThis.afterAll(() => DomainGraphQL_Server$ReventlessLocal.stop());
+
+globalThis.test("POST /__inmemory/upload returns matching uploadUrl + storageRef under the prefix", async () => {
+  let match = await postJson("/__inmemory/upload", Object.fromEntries([
+    [
+      "fileName",
+      "logo.svg"
+    ],
+    [
+      "contentType",
+      "image/svg+xml"
+    ]
+  ]));
+  let body = match[1];
+  globalThis.expect(match[0]).toEqual(200);
+  let uploadUrl = getString(body, "uploadUrl");
+  let storageRef = getString(body, "storageRef");
+  globalThis.expect(uploadUrl).toEqual(storageRef);
+  globalThis.expect(storageRef.startsWith("/uploads/")).toEqual(true);
+  globalThis.expect(storageRef.endsWith("/logo.svg")).toEqual(true);
+});
+
+globalThis.test("PUT then GET round-trips the bytes and content-type", async () => {
+  let match = await postJson("/__inmemory/upload", Object.fromEntries([[
+      "fileName",
+      "pixel.svg"
+    ]]));
+  let ref = getString(match[1], "storageRef");
+  let svg = "<svg xmlns='http://www.w3.org/2000/svg' width='1' height='1'></svg>";
+  let putStatus = await putRaw(ref, svg, "image/svg+xml");
+  globalThis.expect(putStatus).toEqual(200);
+  let match$1 = await getRaw(ref);
+  globalThis.expect(match$1[0]).toEqual(200);
+  globalThis.expect(match$1[1]).toEqual(svg);
+  globalThis.expect(match$1[2]).toEqual("image/svg+xml");
+});
+
+globalThis.test("GET a missing served object returns 404", async () => {
+  let match = await getRaw("/uploads/missing/none.svg");
+  globalThis.expect(match[0]).toEqual(404);
+});
+
+let port = 49322;
+
+export {
+  port,
+  postJson,
+  putRaw,
+  getRaw,
+  getString,
+}
+/*  Not a pure module */

package/tests/components/inboundtranslationslice/InboundTranslationSliceCallbackTest.res

@@ -34,9 +34,11 @@ describe("InboundTranslationSlice Callback", () => {
       let result = await Callback.receive(mockPublish, inputJson)
 
       switch result {
-      | Ok(targetIds) =>
-        expect(targetIds->Array.length)->toBe(1)
-        expect(targetIds->Array.getUnsafe(0))->toBe("ord-1")
+      | Ok({requestId, targetIds, commandCount}) =>
+        expect(targetIds)->toEqual(["ord-1"])
+        expect(commandCount)->toBe(1)
+        // requestId keys the audit row, so the caller can correlate the response.
+        expect(Callback.auditLog->Dict.get(requestId)->Option.isSome)->toBe(true)
       | Error(_) => expect(true)->toBe(false)
       }
       expect(publishedCommands.contents->Array.length)->toBe(1)
@@ -67,7 +69,7 @@ describe("InboundTranslationSlice Callback", () => {
       let result = await Callback.receive(mockPublish, inputJson)
 
       switch result {
-      | Error(msg) => expect(msg)->toBe("Unknown payment status: pending")
+      | Error({error}) => expect(error)->toBe("Unknown payment status: pending")
       | Ok(_) => expect(true)->toBe(false)
       }
       expect(publishedCommands.contents->Array.length)->toBe(0)
@@ -112,7 +114,7 @@ describe("InboundTranslationSlice Callback", () => {
       let result = await Callback.receive(failingPublish, inputJson)
 
       switch result {
-      | Error(msg) => expect(msg)->toBe("publish failed")
+      | Error({error}) => expect(error)->toBe("publish failed")
       | Ok(_) => expect(true)->toBe(false)
       }
 
@@ -177,9 +179,9 @@ describe("InboundTranslationSlice Callback", () => {
       let result = await MultiCallback.receive(mockPublish, inputJson)
 
       switch result {
-      | Ok(targetIds) =>
-        expect(targetIds->Array.length)->toBe(3)
-        expect(targetIds->Array.getUnsafe(0))->toBe("ord-1")
+      | Ok({targetIds, commandCount}) =>
+        expect(targetIds)->toEqual(["ord-1", "ord-1", "ord-1"])
+        expect(commandCount)->toBe(3)
       | Error(_) => expect(true)->toBe(false)
       }
       // All 3 commands published in one batch
@@ -234,7 +236,9 @@ describe("InboundTranslationSlice Callback", () => {
       let result = await EmptyCallback.receive(mockPublish, inputJson)
 
       switch result {
-      | Ok(targetIds) => expect(targetIds->Array.length)->toBe(0)
+      | Ok({targetIds, commandCount}) =>
+        expect(targetIds)->toEqual([])
+        expect(commandCount)->toBe(0)
       | Error(_) => expect(true)->toBe(false)
       }
       expect(publishedCommands.contents->Array.length)->toBe(0)

package/tests/components/inboundtranslationslice/InboundTranslationSliceCallbackTest.res.mjs

@@ -2,6 +2,7 @@
 
 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 Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
 import * as InboundTranslationSliceFixtures$ReventlessLocal from "./InboundTranslationSliceFixtures.res.mjs";
@@ -45,9 +46,10 @@ globalThis.describe("InboundTranslationSlice Callback", () => {
       };
       let result = await Callback.receive(mockPublish, inputJson);
       if (result.TAG === "Ok") {
-        let targetIds = result._0;
-        globalThis.expect(targetIds.length).toBe(1);
-        globalThis.expect(targetIds[0]).toBe("ord-1");
+        let match = result._0;
+        globalThis.expect(match.targetIds).toEqual(["ord-1"]);
+        globalThis.expect(match.commandCount).toBe(1);
+        globalThis.expect(Stdlib_Option.isSome(Callback.auditLog[match.requestId])).toBe(true);
       } else {
         globalThis.expect(true).toBe(false);
       }
@@ -56,8 +58,8 @@ globalThis.describe("InboundTranslationSlice Callback", () => {
       globalThis.expect(cmd.id).toBe("ord-1");
       let auditEntries = Object.entries(Callback.auditLog);
       globalThis.expect(auditEntries.length).toBe(1);
-      let match = auditEntries[0];
-      let auditRow = match[1];
+      let match$1 = auditEntries[0];
+      let auditRow = match$1[1];
       globalThis.expect(auditRow.status).toBe("Success");
       globalThis.expect(auditRow.commandCount).toBe(1);
     });
@@ -77,7 +79,7 @@ globalThis.describe("InboundTranslationSlice Callback", () => {
       if (result.TAG === "Ok") {
         globalThis.expect(true).toBe(false);
       } else {
-        globalThis.expect(result._0).toBe("Unknown payment status: pending");
+        globalThis.expect(result._0.error).toBe("Unknown payment status: pending");
       }
       globalThis.expect(publishedCommands.contents.length).toBe(0);
       let auditEntries = Object.entries(Callback.auditLog);
@@ -112,7 +114,7 @@ globalThis.describe("InboundTranslationSlice Callback", () => {
       if (result.TAG === "Ok") {
         globalThis.expect(true).toBe(false);
       } else {
-        globalThis.expect(result._0).toBe("publish failed");
+        globalThis.expect(result._0.error).toBe("publish failed");
       }
       let auditEntries = Object.entries(Callback.auditLog);
       globalThis.expect(auditEntries.length).toBe(1);
@@ -173,17 +175,21 @@ globalThis.describe("InboundTranslationSlice Callback", () => {
       };
       let result = await MultiCallback.receive(mockPublish, inputJson);
       if (result.TAG === "Ok") {
-        let targetIds = result._0;
-        globalThis.expect(targetIds.length).toBe(3);
-        globalThis.expect(targetIds[0]).toBe("ord-1");
+        let match = result._0;
+        globalThis.expect(match.targetIds).toEqual([
+          "ord-1",
+          "ord-1",
+          "ord-1"
+        ]);
+        globalThis.expect(match.commandCount).toBe(3);
       } else {
         globalThis.expect(true).toBe(false);
       }
       globalThis.expect(publishedCommands.contents.length).toBe(3);
       let auditEntries = Object.entries(MultiCallback.auditLog);
       globalThis.expect(auditEntries.length).toBe(1);
-      let match = auditEntries[0];
-      let auditRow = match[1];
+      let match$1 = auditEntries[0];
+      let auditRow = match$1[1];
       globalThis.expect(auditRow.status).toBe("Success");
       globalThis.expect(auditRow.commandCount).toBe(3);
     });
@@ -226,7 +232,9 @@ globalThis.describe("InboundTranslationSlice Callback", () => {
       };
       let result = await EmptyCallback.receive(mockPublish, inputJson);
       if (result.TAG === "Ok") {
-        globalThis.expect(result._0.length).toBe(0);
+        let match = result._0;
+        globalThis.expect(match.targetIds).toEqual([]);
+        globalThis.expect(match.commandCount).toBe(0);
       } else {
         globalThis.expect(true).toBe(false);
       }