@parallel-park/in-child-process 0.3.0 → 0.3.1

package/dist/child-process-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/in-child-process.d.ts

@@ -0,0 +1,8 @@
+type InChildProcess = {
+    <Inputs extends {
+        [key: string]: any;
+    }, Result>(inputs: Inputs, functionToRun: (inputs: Inputs) => Result | Promise<Result>): Promise<Result>;
+    <Result>(functionToRun: () => Result | Promise<Result>): Promise<Result>;
+};
+export declare const inChildProcess: InChildProcess;
+export {};

package/dist/read-until-end.d.ts

@@ -0,0 +1,2 @@
+import type stream from "stream";
+export declare function readUntilEnd(stream: stream.Readable): Promise<string>;

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@parallel-park/in-child-process",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Run code within a child process",
   "main": "dist/index.js",
-  "types": "src/index.ts",
+  "types": "dist/index.d.ts",
   "scripts": {
     "test": "vitest run",
     "build": "rm -rf ./dist && tsc"

package/src/child-process-worker.ts

@@ -1,86 +0,0 @@
-import fs from "fs";
-import vm from "vm";
-import makeModuleEnv from "make-module-env";
-import makeDebug from "debug";
-import { readUntilEnd } from "./read-until-end";
-import path from "path";
-
-const debug = makeDebug("parallel-park:child-process-worker");
-
-const commsIn = fs.createReadStream(
-  // @ts-ignore
-  null,
-  { fd: 3 }
-);
-const commsOut = fs.createWriteStream(
-  // @ts-ignore
-  null,
-  { fd: 4 }
-);
-
-debug("reading input data...");
-readUntilEnd(commsIn)
-  .then((data) => {
-    debug("parsing input data...");
-    try {
-      const [inputs, fnString, callingFile] = JSON.parse(data);
-      onReady(inputs, fnString, callingFile);
-    } catch (err) {
-      onError(err as Error);
-    }
-  })
-  .catch(onError);
-
-function onReady(inputs: any, fnString: string, callingFile: string) {
-  debug("in onReady %o", { inputs, fnString, callingFile });
-
-  // Relevant when callingFile is eg. "REPL2" (from Node.js repl)
-  if (!path.isAbsolute(callingFile)) {
-    callingFile = path.join(process.cwd(), "fake-path.js");
-  }
-
-  const wrapperFn = vm.runInThisContext(
-    `(function moduleWrapper(exports, require, module, __filename, __dirname) {
-  return ${fnString};})`
-  );
-  const env = makeModuleEnv(callingFile);
-  const fn = wrapperFn(
-    env.exports,
-    env.require,
-    env.module,
-    env.__filename,
-    env.__dirname
-  );
-  const result = fn(inputs);
-
-  if (
-    typeof result === "object" &&
-    result != null &&
-    typeof result.then === "function"
-  ) {
-    result.then(onSuccess, onError);
-  } else {
-    onSuccess(result);
-  }
-}
-
-function onSuccess(data: any) {
-  debug("in onSuccess %o", { data });
-
-  commsOut.end(JSON.stringify({ type: "success", data }));
-}
-
-function onError(error: Error) {
-  debug("in onError %o", { error });
-
-  commsOut.end(
-    JSON.stringify({
-      type: "error",
-      error: {
-        name: error.name,
-        message: error.message,
-        stack: error.stack,
-      },
-    })
-  );
-}

package/src/in-child-process.ts

@@ -1,180 +0,0 @@
-import child_process from "child_process";
-import type * as stream from "stream";
-import { ParsedError } from "@suchipi/error-utils";
-import makeDebug from "debug";
-import util from "util";
-import { readUntilEnd } from "./read-until-end";
-
-const debug = makeDebug("parallel-park:in-child-process");
-
-const runnerPath = require.resolve("../dist/child-process-worker");
-
-type InChildProcess = {
-  <Inputs extends { [key: string]: any }, Result>(
-    inputs: Inputs,
-    functionToRun: (inputs: Inputs) => Result | Promise<Result>
-  ): Promise<Result>;
-
-  <Result>(functionToRun: () => Result | Promise<Result>): Promise<Result>;
-};
-
-export const inChildProcess: InChildProcess = (...args: Array<any>) => {
-  const inputs = typeof args[0] === "function" ? {} : args[0];
-  const functionToRun = typeof args[0] === "function" ? args[0] : args[1];
-
-  if (typeof inputs !== "object") {
-    throw new Error(
-      "The first argument to inChildProcess should be an object of input data to pass to the child process."
-    );
-  }
-
-  if (typeof functionToRun !== "function") {
-    throw new Error(
-      "The second argument to inChildProcess should be a function to run in the child process."
-    );
-  }
-
-  const here = new ParsedError(new Error("here"));
-
-  const callingFrame = here.stackFrames[1];
-  const callingFile = callingFrame?.fileName ?? "unknown file";
-
-  debug("spawning child process: %o", [process.argv[0], runnerPath]);
-
-  const child = child_process.spawn(process.argv[0], [runnerPath], {
-    stdio: ["inherit", "inherit", "inherit", "pipe", "pipe"],
-  });
-
-  return new Promise((resolve, reject) => {
-    child.on("error", reject);
-
-    const commsOut: stream.Writable = child.stdio![3] as any;
-    const commsIn: stream.Readable = child.stdio![4] as any;
-
-    child.on("spawn", () => {
-      const dataToSend = JSON.stringify([
-        inputs,
-        functionToRun.toString(),
-        callingFile,
-      ]);
-      debug("sending inputs to child process: %o", dataToSend);
-      commsOut.end(dataToSend, "utf-8");
-    });
-
-    let receivedData = "";
-    readUntilEnd(commsIn).then((data) => {
-      debug("received data from child process: %o", data);
-      receivedData = data;
-    });
-
-    child.on("close", (code, signal) => {
-      debug("child process closed: %o", { code, signal });
-
-      if (code !== 0) {
-        reject(
-          new Error(
-            `Child process exited with nonzero status code: ${JSON.stringify({
-              code,
-              signal,
-            })}`
-          )
-        );
-      } else {
-        debug("parsing received data from child process...");
-        let result: any;
-        try {
-          result = JSON.parse(receivedData);
-        } catch (err) {
-          reject(
-            new Error(
-              `parallel-park error: failed to parse received data as JSON. data was: ${util.inspect(
-                receivedData,
-                { colors: true, depth: Infinity }
-              )}`
-            )
-          );
-          return;
-        }
-        switch (result.type) {
-          case "success": {
-            debug(
-              "child process finished successfully with result: %o",
-              result.data
-            );
-            resolve(result.data);
-            break;
-          }
-          case "error": {
-            debug("child process errored: %o", result.error);
-            const error = new Error(result.error.message);
-            Object.defineProperty(error, "name", { value: result.error.name });
-            Object.defineProperty(error, "stack", {
-              value:
-                result.error.name +
-                ": " +
-                result.error.message +
-                "\n" +
-                result.error.stack
-                  .split("\n")
-                  .slice(1)
-                  .filter((line) => !/node:internal|node:events/.test(line))
-                  .map((line) => {
-                    if (/evalmachine/.test(line)) {
-                      const lineWithoutEvalMachine = line.replace(
-                        /evalmachine(?:\.<anonymous>)?/,
-                        "<function passed into inChildProcess>"
-                      );
-
-                      const matches = line.match(/:(\d+):(\d+)\)?$/);
-                      if (!matches) {
-                        return lineWithoutEvalMachine;
-                      } else {
-                        let [_, row, col] = matches;
-                        // subtract 1 from row to skip the module wrapper function line
-                        row = row - 1;
-
-                        // subtract the length of the `return ` keywords in front of the function
-                        if (row === 1) {
-                          col = col - `return `.length;
-                        }
-
-                        const hadParen = /\)$/.test(lineWithoutEvalMachine);
-
-                        return lineWithoutEvalMachine.replace(
-                          /:\d+:\d+\)?$/,
-                          `:${row}:${col - 1}${hadParen ? ")" : ""}`
-                        );
-                      }
-                    } else {
-                      return line;
-                    }
-                  })
-                  .join("\n") +
-                "\n" +
-                error
-                  .stack!.split("\n")
-                  .slice(1)
-                  .filter((line) => !/node:internal|node:events/.test(line))
-                  .join("\n") +
-                "\n" +
-                here
-                  .stack!.split("\n")
-                  .slice(2)
-                  .filter((line) => !/node:internal|node:events/.test(line))
-                  .join("\n"),
-            });
-            reject(error);
-            break;
-          }
-          default: {
-            reject(
-              new Error(
-                `Internal parallel-park error: unhandled result type: ${result.type}`
-              )
-            );
-          }
-        }
-      }
-    });
-  });
-};

package/src/read-until-end.ts

@@ -1,25 +0,0 @@
-import type stream from "stream";
-import makeDebug from "debug";
-const debug = makeDebug("parallel-park:read-until-end");
-
-let streamId = 0;
-
-export function readUntilEnd(stream: stream.Readable): Promise<string> {
-  const id = `${process.pid}-${streamId}`;
-  streamId++;
-
-  return new Promise((resolve) => {
-    let data = "";
-
-    stream.on("data", (chunk) => {
-      const chunkStr = chunk.toString("utf-8");
-      debug("received data chunk from stream %s: %o", id, chunkStr);
-      data += chunkStr;
-    });
-
-    stream.on("close", () => {
-      debug("stream %s closed; resolving with: %o", id, data);
-      resolve(data);
-    });
-  });
-}