@effectionx/process 0.7.2 → 0.7.4

package/package.json

@@ -1,13 +1,22 @@
 {
   "name": "@effectionx/process",
   "description": "Spawn and manage child processes with structured concurrency",
-  "version": "0.7.2",
+  "version": "0.7.4",
+  "keywords": [
+    "effection",
+    "effectionx",
+    "process",
+    "spawn",
+    "exec",
+    "child-process"
+  ],
   "type": "module",
   "main": "./dist/mod.js",
   "types": "./dist/mod.d.ts",
   "exports": {
     ".": {
-      "development": "./mod.ts",
+      "types": "./dist/mod.d.ts",
+      "import": "./dist/mod.js",
       "default": "./dist/mod.js"
     }
   },
@@ -23,19 +32,17 @@
   "bugs": {
     "url": "https://github.com/thefrontside/effectionx/issues"
   },
-  "engines": {
-    "node": ">= 22"
-  },
   "sideEffects": false,
   "dependencies": {
     "cross-spawn": "^7",
     "ctrlc-windows": "^2",
     "shellwords-ts": "^3.0.1",
-    "@effectionx/node": "0.2.1"
+    "@effectionx/node": "0.2.4"
   },
   "devDependencies": {
     "@types/cross-spawn": "^6",
-    "@effectionx/bdd": "0.4.2",
-    "@effectionx/stream-helpers": "0.7.2"
+    "effection": "^4",
+    "@effectionx/bdd": "0.5.2",
+    "@effectionx/stream-helpers": "0.8.2"
   }
 }

package/test/daemon.test.ts

@@ -1,6 +1,6 @@
 import process from "node:process";
 import { beforeEach, describe, it } from "@effectionx/bdd";
-import { type Task, spawn, until, withResolvers } from "effection";
+import { type Task, sleep, spawn, until, withResolvers } from "effection";
 import { expect } from "expect";
 
 import { lines } from "@effectionx/stream-helpers";
@@ -10,14 +10,13 @@ import { captureError, expectMatch, fetchText } from "./helpers.ts";
 const SystemRoot = process.env.SystemRoot;
 
 describe("daemon", () => {
-  let task: Task<void>;
-  let proc: Daemon;
-
   describe("controlling from outside", () => {
+    let task: Task<void>;
+    let proc: Daemon;
     beforeEach(function* () {
       const result = withResolvers<Daemon>();
       task = yield* spawn<void>(function* () {
-        let proc = yield* daemon("node", {
+        proc = yield* daemon("node", {
           arguments: [
             "--experimental-strip-types",
             "./fixtures/echo-server.ts",
@@ -35,7 +34,8 @@ describe("daemon", () => {
 
       proc = yield* result.operation;
 
-      yield* expectMatch(/listening/, lines()(proc.stdout));
+      const listening = yield* expectMatch(/listening/, lines()(proc.stdout));
+      expect(listening).toBe(true);
     });
 
     it("starts the given child", function* () {
@@ -89,7 +89,8 @@ describe("daemon", () => {
         return new Error(`this shouldn't happen`);
       });
 
-      yield* expectMatch(/listening/, lines()(proc.stdout));
+      const listening = yield* expectMatch(/listening/, lines()(proc.stdout));
+      expect(listening).toBe(true);
 
       yield* fetchText("http://localhost:29001", {
         method: "POST",
@@ -103,4 +104,40 @@ describe("daemon", () => {
       );
     });
   });
+
+  describe("shutting down an effection-based daemon process prematurely", () => {
+    let task: Task<void>;
+    let proc: Daemon;
+    beforeEach(function* () {
+      const ready = withResolvers<void>();
+      task = yield* spawn(function* () {
+        try {
+          proc = yield* daemon("node", {
+            arguments: ["--experimental-strip-types", "fixtures/forever.ts"],
+            cwd: import.meta.dirname,
+          });
+          ready.resolve();
+          yield* proc;
+        } catch (e) {
+          // ignore the error from the process exiting
+          //  we just want to check that the finally block runs
+        }
+      });
+
+      yield* ready.operation;
+      const suspending = yield* expectMatch(/suspending/, lines()(proc.stdout));
+      expect(suspending).toBe(true);
+    });
+
+    it("still executes process finally block on kill", function* () {
+      const finallyCheck = yield* spawn(() =>
+        expectMatch(/shutting/, lines()(proc.stdout)),
+      );
+      // ensure that spawn has kicked off
+      yield* sleep(0);
+      yield* task.halt();
+      const completed = yield* finallyCheck;
+      expect(completed).toBe(true);
+    });
+  });
 });

package/test/exec.test.ts

@@ -1,9 +1,9 @@
 import process from "node:process";
 import { beforeEach, describe, it } from "@effectionx/bdd";
-import { type Task, spawn, withResolvers } from "effection";
+import { type Task, sleep, spawn, withResolvers } from "effection";
 import { expect } from "expect";
 
-import { captureError, fetchText } from "./helpers.ts";
+import { captureError, expectMatch, fetchText } from "./helpers.ts";
 
 import { lines } from "@effectionx/stream-helpers";
 import { type Process, type ProcessResult, exec } from "../mod.ts";
@@ -102,6 +102,7 @@ describe("exec", () => {
         }
         expect(error).toBeInstanceOf(Error);
       });
+
       it("calling expect() throws an exception", function* () {
         let error: unknown;
         let proc = yield* exec("argle", { arguments: ["bargle"] });
@@ -114,7 +115,49 @@ describe("exec", () => {
         expect(error).toBeDefined();
       });
     });
+
+    describe("process can gracefully shut down if killed before completed", () => {
+      it("runs process finally block on kill", function* () {
+        let status: unknown;
+        let proc: Process | undefined;
+        let ready = withResolvers<void>();
+        let task = yield* spawn(function* () {
+          try {
+            proc = yield* exec("node", {
+              // using fixture that suspends so we can kill before it "completes"
+              arguments: ["--experimental-strip-types", "fixtures/forever.ts"],
+              cwd: import.meta.dirname,
+            });
+            ready.resolve();
+            status = yield* proc.join();
+          } catch (error: unknown) {
+            ready.reject(error as Error);
+          }
+        });
+
+        yield* ready.operation;
+        const suspending = yield* expectMatch(
+          /suspending/,
+          lines()(proc!.stdout),
+        );
+        expect(suspending).toBe(true);
+
+        // kill the process before it finishes and make sure it runs the finally block
+        const finallyCheck = yield* spawn(() =>
+          expectMatch(/shutting down/, lines()(proc!.stdout)),
+        );
+        // ensure that spawn has kicked off
+        yield* sleep(0);
+        yield* task.halt();
+
+        const completed = yield* finallyCheck;
+        expect(completed).toBe(true);
+
+        expect(status).toBeUndefined();
+      });
+    });
   });
+
   describe("successfully", () => {
     let proc: Process;
     let stdoutTask: Task<{ sawData: boolean; matched: boolean }>;

package/test/fixtures/forever.ts

@@ -0,0 +1,26 @@
+import { main, suspend, spawn, sleep, type Task } from "effection";
+
+await main(function* () {
+  try {
+    let tasks: Task<string>[] = [];
+    for (let i = 1; i <= 5; i++) {
+      let task = yield* spawn(function* () {
+        yield* sleep(50 * i);
+        return `child ${i} done`;
+      });
+      tasks.push(task);
+    }
+
+    for (let t of tasks) {
+      yield* t.halt();
+    }
+
+    console.log("suspending");
+
+    // never finish; keeps the loader running which keeps the UI server up during tests
+    // but also simulates a long-running process that we can attach to
+    yield* suspend();
+  } finally {
+    console.log("shutting down, forever was a fallacy");
+  }
+});

package/test/helpers.ts

@@ -1,4 +1,4 @@
-import { type Operation, type Stream, until } from "effection";
+import { type Operation, race, sleep, type Stream, until } from "effection";
 
 export function* captureError(op: Operation<unknown>): Operation<Error> {
   try {
@@ -54,14 +54,24 @@ export function streamClose<TClose>(
 }
 
 export function* expectMatch(pattern: RegExp, stream: Stream<string, unknown>) {
-  const subscription = yield* stream;
-  let next = yield* subscription.next();
-  while (!next.done) {
-    if (pattern.test(next.value)) {
-      return true;
-    }
-    next = yield* subscription.next();
-  }
-
-  return false;
+  const prevLogs: string[] = [];
+  return yield* race([
+    (function* (): Operation<boolean> {
+      yield* sleep(8000);
+      console.log(`saw logs: ${prevLogs.join("")}`);
+      return false;
+    })(),
+    (function* (): Operation<boolean> {
+      const subscription = yield* stream;
+      let next = yield* subscription.next();
+      while (!next.done) {
+        prevLogs.push(next.value);
+        if (pattern.test(next.value)) {
+          return true;
+        }
+        next = yield* subscription.next();
+      }
+      return false;
+    })(),
+  ]);
 }