@reventlessdev/reventless-core 3.0.0-alpha.134

package/tests/querydb/QueryDbOperationsTest.res.mjs

@@ -0,0 +1,168 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stream from "@reventlessdev/rescript-effect/src/Stream.res.mjs";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Stdlib_Result from "@rescript/runtime/lib/es6/Stdlib_Result.js";
+import * as Effect from "effect/Effect";
+import * as QueryDbFixtures$ReventlessCore from "./QueryDbFixtures.res.mjs";
+import * as QueryDb_Operations$ReventlessCore from "../../src/components/QueryDb/QueryDb_Operations.res.mjs";
+
+let Ops = QueryDb_Operations$ReventlessCore.Make({
+  Id: {
+    schema: Id$Reventless.StringPure.schema,
+    make: prim => prim,
+    makeFromString: prim => prim,
+    toString: prim => prim,
+    cmp: Id$Reventless.StringPure.cmp
+  },
+  name: QueryDbFixtures$ReventlessCore.ItemQueryDbSpec.name,
+  moduleUrl: QueryDbFixtures$ReventlessCore.ItemQueryDbSpec.moduleUrl,
+  stateSchema: QueryDbFixtures$ReventlessCore.ItemQueryDbSpec.stateSchema,
+  config: QueryDbFixtures$ReventlessCore.ItemQueryDbSpec.config,
+  subIdConfig: QueryDbFixtures$ReventlessCore.ItemQueryDbSpec.subIdConfig,
+  authorization: QueryDbFixtures$ReventlessCore.ItemQueryDbSpec.authorization,
+  visibility: QueryDbFixtures$ReventlessCore.ItemQueryDbSpec.visibility
+})({
+  jsonOps: QueryDbFixtures$ReventlessCore.mockJsonOps
+});
+
+globalThis.beforeEach(() => QueryDbFixtures$ReventlessCore.reset());
+
+globalThis.describe("QueryDb_Operations:", () => {
+  globalThis.describe("loadStream", () => {
+    globalThis.test("returns empty stream for unknown id", async () => {
+      let result = await Effect.runPromise(Stream.runCollect(Ops.loadStream("unknown-id")));
+      globalThis.expect(result).toEqual([]);
+    });
+    globalThis.test("decodes saved state back to typed state", async () => {
+      await Ops.save("item-1", {
+        name: "Widget",
+        count: 5
+      }, "Init", undefined);
+      let result = await Effect.runPromise(Stream.runCollect(Ops.loadStream("item-1")));
+      if (result.length !== 1) {
+        globalThis.expect("unexpected result").toEqual("Ok([state])");
+        return;
+      }
+      let s = result[0];
+      globalThis.expect([
+        s.name,
+        s.count
+      ]).toEqual([
+        "Widget",
+        5
+      ]);
+    });
+    globalThis.test("returns updated state after overwrite", async () => {
+      await Ops.save("item-1", {
+        name: "Widget",
+        count: 1
+      }, "Init", undefined);
+      await Ops.save("item-1", {
+        name: "Widget Updated",
+        count: 2
+      }, "Overwrite", undefined);
+      let result = await Effect.runPromise(Stream.runCollect(Ops.loadStream("item-1")));
+      if (result.length !== 1) {
+        globalThis.expect("unexpected result").toEqual("Ok([state])");
+        return;
+      }
+      let s = result[0];
+      globalThis.expect(s.name).toBe("Widget Updated");
+    });
+  });
+  globalThis.describe("save", () => {
+    globalThis.test("returns Ok on success", async () => {
+      let result = await Ops.save("item-1", {
+        name: "Widget",
+        count: 1
+      }, "Init", undefined);
+      globalThis.expect(Stdlib_Result.isOk(result)).toBe(true);
+    });
+    globalThis.test("stores id field in JSON", async () => {
+      await Ops.save("item-42", {
+        name: "Widget",
+        count: 0
+      }, "Init", undefined);
+      let stored = Stdlib_Option.getOr(QueryDbFixtures$ReventlessCore.store.contents["item-42"], []);
+      globalThis.expect(stored.length).toBe(1);
+      let json = stored[0];
+      let idField = Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(json), d => d["id"]), j => {
+        if (typeof j === "string") {
+          return j;
+        }
+      });
+      globalThis.expect(idField).toEqual("item-42");
+    });
+    globalThis.test("returns Error when storage fails", async () => {
+      QueryDbFixtures$ReventlessCore.failNextWrite.contents = true;
+      let result = await Ops.save("item-1", {
+        name: "Widget",
+        count: 1
+      }, "Init", undefined);
+      globalThis.expect(Stdlib_Result.isError(result)).toBe(true);
+    });
+  });
+  globalThis.describe("saveBatch", () => {
+    globalThis.test("saves multiple states", async () => {
+      let batch = [
+        [
+          "item-1",
+          {
+            name: "A",
+            count: 1
+          },
+          undefined
+        ],
+        [
+          "item-2",
+          {
+            name: "B",
+            count: 2
+          },
+          undefined
+        ]
+      ];
+      await Ops.saveBatch(batch);
+      let r1 = await Effect.runPromise(Stream.runCollect(Ops.loadStream("item-1")));
+      let r2 = await Effect.runPromise(Stream.runCollect(Ops.loadStream("item-2")));
+      globalThis.expect([
+        r1.length !== 0,
+        r2.length !== 0
+      ]).toEqual([
+        true,
+        true
+      ]);
+    });
+    globalThis.test("returns Error when storage fails", async () => {
+      QueryDbFixtures$ReventlessCore.failNextWrite.contents = true;
+      let result = await Ops.saveBatch([[
+          "item-1",
+          {
+            name: "A",
+            count: 1
+          },
+          undefined
+        ]]);
+      globalThis.expect(Stdlib_Result.isError(result)).toBe(true);
+    });
+  });
+  globalThis.describe("delete", () => {
+    globalThis.test("removes state from storage", async () => {
+      await Ops.save("item-1", {
+        name: "Widget",
+        count: 1
+      }, "Init", undefined);
+      await Ops.$$delete("item-1", undefined);
+      let result = await Effect.runPromise(Stream.runCollect(Ops.loadStream("item-1")));
+      globalThis.expect(result).toEqual([]);
+    });
+  });
+});
+
+export {
+  Ops,
+}
+/* Ops Not a pure module */

package/tests/sideeffecthandler/SideEffectHandlerCallbackTest.res

@@ -0,0 +1,56 @@
+open JestGlobals
+open SideEffectHandlerFixtures
+
+let _ = beforeEach(() => reset())
+
+describe("SideEffectHandler_Callback.handleJsonEvents:", () => {
+  describe("event matching registered side effect", () => {
+    testPromise("execute called with decoded id and event", async () => {
+      let event = TestSource.SomethingHappened({value: "hello"})
+      let eventJson = makeEventJson("entity-1", event)
+      await TestHandler.handleJsonEvents(Stream.fromIterable([eventJson]))->Effect.runPromise
+      let call = capturedExecuteCalls.contents->Array.getUnsafe(0)
+      expect((call.id, call.event))->toEqual(("entity-1", event))
+    })
+  })
+
+  describe("event with no matching source name", () => {
+    testPromise("execute not called, no error", async () => {
+      let event = TestSource.SomethingHappened({value: "ignored"})
+      let eventJson = makeEventJson(~service="UnknownService", "entity-1", event)
+      await TestHandler.handleJsonEvents(Stream.fromIterable([eventJson]))->Effect.runPromise
+      expect(capturedExecuteCalls.contents->Array.length)->toBe(0)
+    })
+  })
+
+  describe("event with malformed JSON", () => {
+    testPromise("caught gracefully — does not throw, execute not called", async () => {
+      let invalidJson = JSON.Encode.string("not-an-object")
+      await TestHandler.handleJsonEvents(Stream.fromIterable([invalidJson]))->Effect.runPromise
+      expect(capturedExecuteCalls.contents->Array.length)->toBe(0)
+    })
+  })
+
+  describe("execute throws", () => {
+    testPromise("error caught per-event, other events still processed", async () => {
+      // First event causes execute to throw; second event processes normally
+      executeThrowOnCall := 1
+      let event = TestSource.SomethingHappened({value: "v"})
+      let event1 = makeEventJson("entity-1", event)
+      let event2 = makeEventJson("entity-2", event)
+      await TestHandler.handleJsonEvents(Stream.fromIterable([event1, event2]))->Effect.runPromise
+      // entity-2 should still be captured (first event threw)
+      expect(capturedExecuteCalls.contents->Array.length)->toBe(1)
+      expect((capturedExecuteCalls.contents->Array.getUnsafe(0)).id)->toBe("entity-2")
+    })
+  })
+
+  describe("multiple events in batch", () => {
+    testPromise("each handled independently", async () => {
+      let event = TestSource.SomethingHappened({value: "v"})
+      let events = ["entity-1", "entity-2", "entity-3"]->Array.map(id => makeEventJson(id, event))
+      await TestHandler.handleJsonEvents(Stream.fromIterable(events))->Effect.runPromise
+      expect(capturedExecuteCalls.contents->Array.length)->toBe(3)
+    })
+  })
+})

package/tests/sideeffecthandler/SideEffectHandlerCallbackTest.res.mjs

@@ -0,0 +1,77 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import * as SideEffectHandlerFixtures$ReventlessCore from "./SideEffectHandlerFixtures.res.mjs";
+
+globalThis.beforeEach(() => SideEffectHandlerFixtures$ReventlessCore.reset());
+
+globalThis.describe("SideEffectHandler_Callback.handleJsonEvents:", () => {
+  globalThis.describe("event matching registered side effect", () => {
+    globalThis.test("execute called with decoded id and event", async () => {
+      let event = {
+        TAG: "SomethingHappened",
+        value: "hello"
+      };
+      let eventJson = SideEffectHandlerFixtures$ReventlessCore.makeEventJson(undefined, "entity-1", event);
+      await Effect.runPromise(SideEffectHandlerFixtures$ReventlessCore.TestHandler.handleJsonEvents(Stream.fromIterable([eventJson])));
+      let call = SideEffectHandlerFixtures$ReventlessCore.capturedExecuteCalls.contents[0];
+      globalThis.expect([
+        call.id,
+        call.event
+      ]).toEqual([
+        "entity-1",
+        event
+      ]);
+    });
+  });
+  globalThis.describe("event with no matching source name", () => {
+    globalThis.test("execute not called, no error", async () => {
+      let eventJson = SideEffectHandlerFixtures$ReventlessCore.makeEventJson("UnknownService", "entity-1", {
+        TAG: "SomethingHappened",
+        value: "ignored"
+      });
+      await Effect.runPromise(SideEffectHandlerFixtures$ReventlessCore.TestHandler.handleJsonEvents(Stream.fromIterable([eventJson])));
+      globalThis.expect(SideEffectHandlerFixtures$ReventlessCore.capturedExecuteCalls.contents.length).toBe(0);
+    });
+  });
+  globalThis.describe("event with malformed JSON", () => {
+    globalThis.test("caught gracefully — does not throw, execute not called", async () => {
+      await Effect.runPromise(SideEffectHandlerFixtures$ReventlessCore.TestHandler.handleJsonEvents(Stream.fromIterable(["not-an-object"])));
+      globalThis.expect(SideEffectHandlerFixtures$ReventlessCore.capturedExecuteCalls.contents.length).toBe(0);
+    });
+  });
+  globalThis.describe("execute throws", () => {
+    globalThis.test("error caught per-event, other events still processed", async () => {
+      SideEffectHandlerFixtures$ReventlessCore.executeThrowOnCall.contents = 1;
+      let event = {
+        TAG: "SomethingHappened",
+        value: "v"
+      };
+      let event1 = SideEffectHandlerFixtures$ReventlessCore.makeEventJson(undefined, "entity-1", event);
+      let event2 = SideEffectHandlerFixtures$ReventlessCore.makeEventJson(undefined, "entity-2", event);
+      await Effect.runPromise(SideEffectHandlerFixtures$ReventlessCore.TestHandler.handleJsonEvents(Stream.fromIterable([
+        event1,
+        event2
+      ])));
+      globalThis.expect(SideEffectHandlerFixtures$ReventlessCore.capturedExecuteCalls.contents.length).toBe(1);
+      globalThis.expect(SideEffectHandlerFixtures$ReventlessCore.capturedExecuteCalls.contents[0].id).toBe("entity-2");
+    });
+  });
+  globalThis.describe("multiple events in batch", () => {
+    globalThis.test("each handled independently", async () => {
+      let events = [
+        "entity-1",
+        "entity-2",
+        "entity-3"
+      ].map(id => SideEffectHandlerFixtures$ReventlessCore.makeEventJson(undefined, id, {
+        TAG: "SomethingHappened",
+        value: "v"
+      }));
+      await Effect.runPromise(SideEffectHandlerFixtures$ReventlessCore.TestHandler.handleJsonEvents(Stream.fromIterable(events)));
+      globalThis.expect(SideEffectHandlerFixtures$ReventlessCore.capturedExecuteCalls.contents.length).toBe(3);
+    });
+  });
+});
+
+/*  Not a pure module */

package/tests/sideeffecthandler/SideEffectHandlerFixtures.res

@@ -0,0 +1,96 @@
+S.enableJson()
+
+// ─────────────────────────────────────────────────────────────
+// Event source spec for SideEffect
+// ─────────────────────────────────────────────────────────────
+
+module TestSource = {
+  module Id = Reventless.Id.StringPure
+  let name = "TestSideEffectSource"
+
+  @schema
+  type event = | SomethingHappened({value: string})
+}
+
+// ─────────────────────────────────────────────────────────────
+// Captures
+// ─────────────────────────────────────────────────────────────
+
+type executeCall = {id: string, event: TestSource.event}
+
+let capturedExecuteCalls: ref<array<executeCall>> = ref([])
+let executeThrowOnCall = ref(0)  // throw on this call number (1-based); 0 = never throw
+let executeCallCount = ref(0)
+
+// ─────────────────────────────────────────────────────────────
+// SideEffect module
+// ─────────────────────────────────────────────────────────────
+
+module TestSideEffect: Reventless.SideEffect.T = {
+  module Source = TestSource
+  let moduleUrl: string = %raw(`import.meta.url`)
+
+  let execute = async (id, _meta, event, _queryEngine) => {
+    executeCallCount := executeCallCount.contents + 1
+    if executeThrowOnCall.contents > 0 && executeCallCount.contents == executeThrowOnCall.contents {
+      JsError.throwWithMessage("side effect failed")
+    }
+    capturedExecuteCalls :=
+      capturedExecuteCalls.contents->Array.concat([
+        {id: id->TestSource.Id.toString, event},
+      ])
+  }
+}
+
+// ─────────────────────────────────────────────────────────────
+// SideEffectHandler_Callback spec and handler under test
+// ─────────────────────────────────────────────────────────────
+
+module TestSpec: SideEffectHandler_Callback.Spec = {
+  let sideEffects: array<module(Reventless.SideEffect.T)> = [module(TestSideEffect)]
+  let queryEngine: Reventless.QueryEngine.operations = {
+    scan: async (~readModelName as _, ~filterConfigs as _, ~limit as _) => [],
+    query: async (
+      ~readModelName as _,
+      ~key as _=?,
+      ~id as _,
+      ~subIdConfig as _=?,
+      ~filterConfigs as _=?,
+      ~ascending as _=?,
+      ~limit as _=?,
+    ) => [],
+  }
+}
+
+module TestHandler = SideEffectHandler_Callback.Make(TestSpec)
+
+// ─────────────────────────────────────────────────────────────
+// Test helpers
+// ─────────────────────────────────────────────────────────────
+
+let testMeta: Message.meta = {
+  service: TestSource.name,
+  time: "2024-01-01T00:00:00Z",
+  ip: "127.0.0.1",
+  user: "test-user",
+  msgId: "se-msg-1",
+  correlationId: "se-corr-1",
+}
+
+let makeEventJson = (~service=TestSource.name, id, event): JSON.t =>
+  [
+    ("id", JSON.Encode.string(id)),
+    (
+      "meta",
+      {...testMeta, service: service}->Message.encode(Message.metaSchema),
+    ),
+    ("event", event->Message.encode(TestSource.eventSchema)),
+  ]
+  ->Dict.fromArray
+  ->JSON.Encode.object
+
+let reset = () => {
+  capturedExecuteCalls := []
+  executeThrowOnCall := 0
+  executeCallCount := 0
+}

package/tests/sideeffecthandler/SideEffectHandlerFixtures.res.mjs

@@ -0,0 +1,139 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Message$ReventlessCore from "../../src/Message.res.mjs";
+import * as SideEffectHandler_Callback$ReventlessCore from "../../src/components/SideEffectHandler/SideEffectHandler_Callback.res.mjs";
+
+S.enableJson();
+
+let name = "TestSideEffectSource";
+
+let eventSchema = S.schema(s => ({
+  TAG: "SomethingHappened",
+  value: s.m(S.string)
+}));
+
+let TestSource = {
+  Id: undefined,
+  name: name,
+  eventSchema: eventSchema
+};
+
+let capturedExecuteCalls = {
+  contents: []
+};
+
+let executeThrowOnCall = {
+  contents: 0
+};
+
+let executeCallCount = {
+  contents: 0
+};
+
+let moduleUrl = import.meta.url;
+
+async function execute(id, _meta, event, _queryEngine) {
+  executeCallCount.contents = executeCallCount.contents + 1 | 0;
+  if (executeThrowOnCall.contents > 0 && executeCallCount.contents === executeThrowOnCall.contents) {
+    Stdlib_JsError.throwWithMessage("side effect failed");
+  }
+  capturedExecuteCalls.contents = capturedExecuteCalls.contents.concat([{
+      id: id,
+      event: event
+    }]);
+}
+
+let TestSideEffect_Source = {
+  name: name,
+  Id: {
+    schema: Id$Reventless.StringPure.schema,
+    make: prim => prim,
+    makeFromString: prim => prim,
+    toString: prim => prim,
+    cmp: Id$Reventless.StringPure.cmp
+  },
+  eventSchema: eventSchema
+};
+
+let TestSideEffect = {
+  Source: TestSideEffect_Source,
+  moduleUrl: moduleUrl,
+  execute: execute
+};
+
+let sideEffects = [TestSideEffect];
+
+async function queryEngine_scan(param, param$1, param$2) {
+  return [];
+}
+
+async function queryEngine_query(param, param$1, param$2, param$3, param$4, param$5, param$6) {
+  return [];
+}
+
+let queryEngine = {
+  scan: queryEngine_scan,
+  query: queryEngine_query
+};
+
+let TestSpec = {
+  sideEffects: sideEffects,
+  queryEngine: queryEngine
+};
+
+let TestHandler = SideEffectHandler_Callback$ReventlessCore.Make(TestSpec);
+
+let testMeta_ip = "127.0.0.1";
+
+let testMeta_user = "test-user";
+
+let testMeta = {
+  service: name,
+  time: "2024-01-01T00:00:00Z",
+  ip: testMeta_ip,
+  user: testMeta_user,
+  msgId: "se-msg-1",
+  correlationId: "se-corr-1"
+};
+
+function makeEventJson(serviceOpt, id, event) {
+  let service = serviceOpt !== undefined ? serviceOpt : name;
+  let newrecord = {...testMeta};
+  return Object.fromEntries([
+    [
+      "id",
+      id
+    ],
+    [
+      "meta",
+      Message$ReventlessCore.encode((newrecord.service = service, newrecord), Message$ReventlessCore.metaSchema)
+    ],
+    [
+      "event",
+      Message$ReventlessCore.encode(event, eventSchema)
+    ]
+  ]);
+}
+
+function reset() {
+  capturedExecuteCalls.contents = [];
+  executeThrowOnCall.contents = 0;
+  executeCallCount.contents = 0;
+}
+
+export {
+  TestSource,
+  capturedExecuteCalls,
+  executeThrowOnCall,
+  executeCallCount,
+  TestSideEffect,
+  TestSpec,
+  TestHandler,
+  testMeta,
+  makeEventJson,
+  reset,
+}
+/*  Not a pure module */

package/tests/util/CsvStreamTest.res

@@ -0,0 +1,54 @@
+// CsvStreamTest.res
+// Tests for CsvStream.parseRows — Effect Stream bridge for FastCSV.
+// See docs/plans/effect-stream-integration.md Phase E.
+
+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)
+  path
+}
+
+describe("CsvStream.parseRows", () => {
+  testPromise("parses all rows from a small CSV file", async () => {
+    let path = writeTempCsv("name,age\nAlice,30\nBob,25")
+    let rows = await CsvStream.parseRows(~path)->Stream.runCollect->Effect.runPromise
+    expect(rows->Array.length)->toBe(2)
+  })
+
+  testPromise("emits rows in file order", async () => {
+    let path = writeTempCsv("name\nfirst\nsecond\nthird")
+    let first = await CsvStream.parseRows(~path)->Stream.runHead->Effect.runPromise
+    // first: option<CSV.row> — unwrap and check the "name" field
+    let name = first->Option.flatMap(row => row->Dict.get("name"))
+    expect(name)->toEqual(Some("first"))
+  })
+
+  testPromise("take(2) returns only 2 rows", async () => {
+    // Build a CSV with 10 data rows; take(2) must return exactly 2
+    let dataRows =
+      Array.make(~length=10, 0)
+      ->Array.mapWithIndex((i, _) => `row-${Int.toString(i)}`)
+      ->Array.join("\n")
+    let path = writeTempCsv("name\n" ++ dataRows)
+    let result = await CsvStream.parseRows(~path)
+      ->Stream.take(2)
+      ->Stream.runCollect
+      ->Effect.runPromise
+    expect(result->Array.length)->toBe(2)
+  })
+
+  testPromise("empty CSV file (header only) returns empty stream", async () => {
+    let path = writeTempCsv("name")
+    let rows = await CsvStream.parseRows(~path)->Stream.runCollect->Effect.runPromise
+    expect(rows->Array.length)->toBe(0)
+  })
+})

package/tests/util/CsvStreamTest.res.mjs

@@ -0,0 +1,51 @@
+// 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 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";
+import * as Stream$1 from "effect/Stream";
+import * as CsvStream$ReventlessCore from "../../src/util/CsvStream.res.mjs";
+
+let fileCounter = {
+  contents: 0
+};
+
+function writeTempCsv(content) {
+  fileCounter.contents = fileCounter.contents + 1 | 0;
+  let path = `/tmp/reventless-csvstream-test-` + fileCounter.contents.toString() + `.csv`;
+  Fs.writeFileSync(path, content);
+  return path;
+}
+
+globalThis.describe("CsvStream.parseRows", () => {
+  globalThis.test("parses all rows from a small CSV file", async () => {
+    let path = writeTempCsv("name,age\nAlice,30\nBob,25");
+    let rows = await Effect.runPromise(Stream.runCollect(CsvStream$ReventlessCore.parseRows(path)));
+    globalThis.expect(rows.length).toBe(2);
+  });
+  globalThis.test("emits rows in file order", async () => {
+    let path = writeTempCsv("name\nfirst\nsecond\nthird");
+    let first = await Effect.runPromise(Stream.runHead(CsvStream$ReventlessCore.parseRows(path)));
+    let name = Stdlib_Option.flatMap(first, row => row["name"]);
+    globalThis.expect(name).toEqual("first");
+  });
+  globalThis.test("take(2) returns only 2 rows", async () => {
+    let dataRows = Stdlib_Array.make(10, 0).map((i, param) => `row-` + i.toString()).join("\n");
+    let path = writeTempCsv("name\n" + dataRows);
+    let result = await Effect.runPromise(Stream.runCollect(Stream$1.take(CsvStream$ReventlessCore.parseRows(path), 2)));
+    globalThis.expect(result.length).toBe(2);
+  });
+  globalThis.test("empty CSV file (header only) returns empty stream", async () => {
+    let path = writeTempCsv("name");
+    let rows = await Effect.runPromise(Stream.runCollect(CsvStream$ReventlessCore.parseRows(path)));
+    globalThis.expect(rows.length).toBe(0);
+  });
+});
+
+export {
+  fileCounter,
+  writeTempCsv,
+}
+/*  Not a pure module */