fix(compiler): equality and external libraries bugs in simulator (#5554)

This pull request fixes a range of funky JavaScript issues we've had running inflight code in the Wing simulator by switching internally from running JS code in a `vm` to running JS code using Node.js child processes.

The main issues with `vm` are:
- several third-party JavaScript dependencies behave differently when executed inside a `vm` and outside. This may be related to differences in vm behavior as described in nodejs/node#28823
- we cannot easily stop/kill code executing in a `vm` process, making it impossible to simulate cloud.Function timeouts

Fixes #1980
Fixes #4131
Fixes #4118
Fixes #4792

Closes #4725

## Checklist

- [x] Title matches [Winglang's style guide](https://www.winglang.io/contributing/start-here/pull_requests#how-are-pull-request-titles-formatted)
- [x] Description explains motivation and solution
- [x] Tests added (always)
- [ ] Docs updated (only required for features)
- [ ] Added `pr/e2e-full` label if this feature requires end-to-end testing

*By submitting this pull request, I confirm that my contribution is made under the terms of the [Wing Cloud Contribution License](https://github.com/winglang/wing/blob/main/CONTRIBUTION_LICENSE.md)*.

examples/tests/sdk_tests/function/timeout.test.w

@@ -35,9 +35,7 @@ new std.Test(inflight () => {
     assert(e.contains("Task timed out after"));
   }
 
-  if (util.env("WING_TARGET") != "sim") {
-    assert(c.peek() == 0);
-  }
+  assert(c.peek() == 0);
 
   try {
     f2.invoke("");
@@ -49,8 +47,6 @@ new std.Test(inflight () => {
     assert(e.contains("Task timed out after"));
   }
 
-  if (util.env("WING_TARGET") != "sim") {
-    assert(c.peek() == 1);
-  }
+  assert(c.peek() == 1);
 
 }, std.TestProps {timeout: 2m}) as "timeout";

examples/tests/valid/deep_equality.test.w

@@ -39,6 +39,11 @@ test "Json with different values" {
   assert(!(jsonA != jsonB));
 }
 
+test "Json.values equality" {
+  let j = Json { hello: 123, world: [1, 2, 3] };
+  assert(Json.values(j) == [Json 123, Json [1, 2, 3]]);
+}
+
 //-----------------------------------------------------------------------------
 // Set
 //-----------------------------------------------------------------------------

examples/tests/valid/inflight_handler_singleton.test.w

@@ -36,11 +36,7 @@ test "single instance of Foo" {
   expect.equal(x, "100");
   expect.equal(z, "100-fn2"); // fn2 should have a separate instance
 
-  // the simulator intentionally reuses the sandbox across invocations
-  // but we can't trust that this will always happen on the cloud
-  if sim {
-    expect.equal(y, "101");
-    expect.equal(z, "100-fn2"); // fn2 should have a separate instance
-    log("client has been reused");
-  }
+  // y could be 100 or 101 depending on whether the execution environment
+  // was reused or not between the two calls.
+  assert(y == "100" || y == "101");
 }

libs/wingsdk/.projenrc.ts

@@ -75,7 +75,6 @@ const project = new cdk.JsiiProject({
     // simulator dependencies
     "express",
     "uuid",
-    "undici",
     // using version 3 because starting from version 4, it no longer works with CommonJS.
     "nanoid@^3.3.6",
     "cron-parser",

libs/wingsdk/src/shared/bundling.ts

@@ -1,6 +1,6 @@
 import * as crypto from "crypto";
-import { mkdirSync, writeFileSync } from "fs";
-import { join, resolve } from "path";
+import { mkdirSync, realpathSync, writeFileSync } from "fs";
+import { posix, resolve } from "path";
 import { normalPath } from "./misc";
 
 const SDK_PATH = normalPath(resolve(__dirname, "..", ".."));
@@ -25,21 +25,24 @@ export function createBundle(
   external: string[] = [],
   outputDir?: string
 ): Bundle {
-  const outdir = resolve(outputDir ?? entrypoint + ".bundle");
+  const normalEntrypoint = normalPath(realpathSync(entrypoint));
+  const outdir = outputDir
+    ? normalPath(realpathSync(outputDir))
+    : `${normalEntrypoint}.bundle`;
   mkdirSync(outdir, { recursive: true });
 
   const outfileName = "index.js";
   const soucemapFilename = `${outfileName}.map`;
 
-  const outfile = join(outdir, outfileName);
-  const outfileMap = join(outdir, soucemapFilename);
+  const outfile = posix.join(outdir, outfileName);
+  const outfileMap = posix.join(outdir, soucemapFilename);
 
   // eslint-disable-next-line import/no-extraneous-dependencies,@typescript-eslint/no-require-imports
   const esbuilder: typeof import("esbuild") = require("esbuild");
 
   let esbuild = esbuilder.buildSync({
     bundle: true,
-    entryPoints: [normalPath(resolve(entrypoint))],
+    entryPoints: [normalEntrypoint],
     outfile,
     // otherwise there are problems with running azure cloud functions:
     // https://stackoverflow.com/questions/70332883/webpack-azure-storage-blob-node-fetch-abortsignal-issue

libs/wingsdk/src/shared/legacy-sandbox.ts

@@ -0,0 +1,143 @@
+import { mkdtemp, readFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import * as util from "node:util";
+import * as vm from "node:vm";
+import { createBundle } from "./bundling";
+import { SandboxOptions } from "./sandbox";
+
+export class LegacySandbox {
+  private createBundlePromise: Promise<void>;
+  private entrypoint: string;
+  private code: string | undefined;
+  private readonly options: SandboxOptions;
+  private readonly context: any = {};
+
+  constructor(entrypoint: string, options: SandboxOptions = {}) {
+    this.entrypoint = entrypoint;
+    this.options = options;
+    this.context = this.createContext();
+    this.createBundlePromise = this.createBundle();
+  }
+
+  private createContext() {
+    const sandboxProcess = {
+      ...process,
+
+      // override process.exit to throw an exception instead of exiting the process
+      exit: (exitCode: number) => {
+        throw new Error("process.exit() was called with exit code " + exitCode);
+      },
+
+      env: this.options.env,
+    };
+
+    const sandboxConsole: any = {};
+    const levels = ["debug", "info", "log", "warn", "error"];
+    for (const level of levels) {
+      sandboxConsole[level] = (...args: any[]) => {
+        const message = util.format(...args);
+        this.options.log?.(false, level, message);
+        // also log to stderr if DEBUG is set
+        if (process.env.DEBUG) {
+          console.error(message);
+        }
+      };
+    }
+
+    const ctx: any = {};
+
+    // create a copy of all the globals from our current context.
+    for (const k of Object.getOwnPropertyNames(global)) {
+      try {
+        ctx[k] = (global as any)[k];
+      } catch {
+        // ignore unresolvable globals (see https://github.com/winglang/wing/pull/1923)
+      }
+    }
+
+    // append the user's context
+    for (const [k, v] of Object.entries(this.options.context ?? {})) {
+      ctx[k] = v;
+    }
+
+    const context = vm.createContext({
+      ...ctx,
+      process: sandboxProcess,
+      console: sandboxConsole,
+      exports: {},
+      require, // to support requiring node.js sdk modules (others will be bundled)
+    });
+
+    // emit an explicit error when trying to access `__dirname` and `__filename` because we cannot
+    // resolve these when bundling (this is true both for simulator and the cloud since we are
+    // bundling there as well).
+    const forbidGlobal = (name: string) => {
+      Object.defineProperty(context, name, {
+        get: () => {
+          throw new Error(
+            `${name} cannot be used within bundled cloud functions`
+          );
+        },
+      });
+    };
+
+    forbidGlobal("__dirname");
+    forbidGlobal("__filename");
+
+    return context;
+  }
+
+  private async createBundle() {
+    // load bundle into context on first run
+    const workdir = await mkdtemp(path.join(tmpdir(), "wing-bundles-"));
+    const bundle = createBundle(this.entrypoint, [], workdir);
+    this.entrypoint = bundle.entrypointPath;
+
+    this.code = await readFile(this.entrypoint, "utf-8");
+
+    if (process.env.DEBUG) {
+      const bundleSize = Buffer.byteLength(this.code, "utf-8");
+      this.options.log?.(true, "log", `Bundled code (${bundleSize} bytes).`);
+    }
+  }
+
+  public async call(fn: string, ...args: any[]): Promise<any> {
+    // wait for the bundle to finish creation
+    await this.createBundlePromise;
+
+    if (!this.code) {
+      throw new Error("Bundle not created yet - please report this as a bug");
+    }
+
+    // this will add stuff to the "exports" object within our context
+    vm.runInContext(this.code!, this.context, {
+      filename: this.entrypoint,
+    });
+
+    return new Promise(($resolve, $reject) => {
+      const cleanup = () => {
+        delete this.context.$resolve;
+        delete this.context.$reject;
+      };
+
+      this.context.$resolve = (value: any) => {
+        cleanup();
+        $resolve(value);
+      };
+
+      this.context.$reject = (reason?: any) => {
+        cleanup();
+        $reject(reason);
+      };
+
+      const code = `exports.${fn}(${args
+        .map((arg) => JSON.stringify(arg))
+        .join(",")}).then($resolve).catch($reject);`;
+      vm.runInContext(code, this.context, {
+        filename: this.entrypoint,
+        timeout: this.options.timeout,
+      });
+    });
+  }
+}