chore: remove source loading indirection MONGOSH-1343 (#33)

Instead of writing a module that exports the main JS source to
the generated binary, just include the string as a C++ string.
This avoids an extra parsing pass and reduces binary size.

Author: addaleax

resources/entry-point-trampoline.js

@@ -3,11 +3,9 @@ const Module = require('module');
 const vm = require('vm');
 const path = require('path');
 const {
-  srcMod,
   requireMappings,
   enableBindingsPatch
 } = REPLACE_WITH_BOXEDNODE_CONFIG;
-const src = require(srcMod);
 const hydatedRequireMappings =
   requireMappings.map(([re, reFlags, linked]) => [new RegExp(re, reFlags), linked]);
 
@@ -51,7 +49,7 @@ if (enableBindingsPatch) {
   });
 }
 
-module.exports = (() => {
+module.exports = (src) => {
   const __filename = process.execPath;
   const __dirname = path.dirname(process.execPath);
   const innerRequire = Module.createRequire(__filename);
@@ -85,4 +83,4 @@ module.exports = (() => {
     filename: __filename
   })(__filename, __dirname, require, exports, module);
   return module.exports;
-})();
+};

resources/main-template.cc

@@ -30,6 +30,9 @@ void InitializeOncePerProcess();
 void TearDownOncePerProcess();
 }
 #endif
+namespace boxednode {
+Local<String> GetBoxednodeMainScriptSource(Isolate* isolate);
+}
 
 extern "C" {
 typedef void (*register_boxednode_linked_module)(const void**, const void**);
@@ -122,14 +125,18 @@ static int RunNodeInstance(MultiIsolatePlatform* platform,
     // `module.createRequire()` is being used to create one that is able to
     // load files from the disk, and uses the standard CommonJS file loader
     // instead of the internal-only `require` function.
-    MaybeLocal<Value> loadenv_ret = node::LoadEnvironment(
+    Local<Value> loadenv_ret;
+    if (!node::LoadEnvironment(
         env.get(),
         "const path = require('path');\n"
         "if (process.argv[2] === '--') process.argv.splice(2, 1);\n"
-        "require(" REPLACE_WITH_ENTRY_POINT ")");
-
-    if (loadenv_ret.IsEmpty())  // There has been a JS exception.
-      return 1;
+        "return require(" REPLACE_WITH_ENTRY_POINT ")").ToLocal(&loadenv_ret)) {
+      return 1; // There has been a JS exception.
+    }
+    assert(loadenv_ret->IsFunction());
+    Local<Value> source = boxednode::GetBoxednodeMainScriptSource(isolate);
+    if (loadenv_ret.As<Function>()->Call(context, Null(isolate), 1, &source).IsEmpty())
+      return 1; // JS exception.
 
     {
       // SealHandleScope protects against handle leaks from callbacks.
@@ -658,4 +665,8 @@ void TearDownOncePerProcess() {
 
 }  // namespace boxednode
 
-#endif  // USE_OWN_LEGACY_PROCESS_INITIALIZATION
+#endif  // USE_OWN_LEGACY_PROCESS_INITIALIZATION
+
+namespace boxednode {
+REPLACE_WITH_MAIN_SCRIPT_SOURCE_GETTER
+}

src/helpers.ts

@@ -75,3 +75,29 @@ export function npm (): string[] {
     return ['npm'];
   }
 }
+
+export function createCppJsStringDefinition (fnName: string, source: string): string {
+  const sourceAsCharCodeArray = new Uint16Array(source.length);
+  let isAllLatin1 = true;
+  for (let i = 0; i < source.length; i++) {
+    const charCode = source.charCodeAt(i);
+    sourceAsCharCodeArray[i] = charCode;
+    isAllLatin1 &&= charCode <= 0xFF;
+  }
+
+  return `
+  static const ${isAllLatin1 ? 'uint8_t' : 'uint16_t'} ${fnName}_source_[] = {
+    ${sourceAsCharCodeArray}
+  };
+  static_assert(
+    ${sourceAsCharCodeArray.length} <= v8::String::kMaxLength,
+    "main script source exceeds max string length");
+  Local<String> ${fnName}(Isolate* isolate) {
+    return v8::String::NewFrom${isAllLatin1 ? 'One' : 'Two'}Byte(
+      isolate,
+      ${fnName}_source_,
+      v8::NewStringType::kNormal,
+      ${sourceAsCharCodeArray.length}).ToLocalChecked();
+  }
+  `;
+}

src/index.ts

@@ -11,7 +11,7 @@ import { promisify } from 'util';
 import { promises as fs, createReadStream, createWriteStream } from 'fs';
 import { AddonConfig, loadGYPConfig, storeGYPConfig, modifyAddonGyp } from './native-addons';
 import { ExecutableMetadata, generateRCFile } from './executable-metadata';
-import { spawnBuildCommand, ProcessEnv, pipeline } from './helpers';
+import { spawnBuildCommand, ProcessEnv, pipeline, createCppJsStringDefinition } from './helpers';
 import { Readable } from 'stream';
 import nv from '@pkgjs/nv';
 
@@ -209,6 +209,8 @@ async function compileJSFileAsBinaryImpl (options: CompilationOptions, logger: L
   const extraJSSourceFiles: string[] = [];
   const enableBindingsPatch = options.enableBindingsPatch ?? options.addons?.length > 0;
 
+  const jsMainSource = await fs.readFile(options.sourceFile, 'utf8');
+
   // We use the official embedder API for stability, which is available in all
   // supported versions of Node.js.
   {
@@ -250,32 +252,26 @@ async function compileJSFileAsBinaryImpl (options: CompilationOptions, logger: L
       registerFunctions.map((fn) => `void ${fn}(const void**,const void**);\n`).join(''));
     mainSource = mainSource.replace(/\bREPLACE_DEFINE_LINKED_MODULES\b/g,
       registerFunctions.map((fn) => `${fn},`).join(''));
+    mainSource = mainSource.replace(/\bREPLACE_WITH_MAIN_SCRIPT_SOURCE_GETTER\b/g,
+      createCppJsStringDefinition('GetBoxednodeMainScriptSource', jsMainSource));
     await fs.writeFile(path.join(nodeSourcePath, 'src', 'node_main.cc'), mainSource);
     logger.stepCompleted();
   }
 
   logger.stepStarting('Inserting custom code into Node.js source');
   await fs.mkdir(path.join(nodeSourcePath, 'lib', namespace), { recursive: true });
-  const source = await fs.readFile(options.sourceFile, 'utf8');
-  await fs.writeFile(
-    path.join(nodeSourcePath, 'lib', namespace, `${namespace}_src.js`),
-    `module.exports = ${JSON.stringify(source)}`);
   let entryPointTrampolineSource = await fs.readFile(
     path.join(__dirname, '..', 'resources', 'entry-point-trampoline.js'), 'utf8');
   entryPointTrampolineSource = entryPointTrampolineSource.replace(
     /\bREPLACE_WITH_BOXEDNODE_CONFIG\b/g,
     JSON.stringify({
-      srcMod: `${namespace}/${namespace}_src`,
       requireMappings: requireMappings.map(([re, linked]) => [re.source, re.flags, linked]),
       enableBindingsPatch
     }));
   await fs.writeFile(
     path.join(nodeSourcePath, 'lib', namespace, `${namespace}.js`),
     entryPointTrampolineSource);
-  extraJSSourceFiles.push(
-    `./lib/${namespace}/${namespace}.js`,
-    `./lib/${namespace}/${namespace}_src.js`
-  );
+  extraJSSourceFiles.push(`./lib/${namespace}/${namespace}.js`);
   logger.stepCompleted();
 
   logger.stepStarting('Storing executable metadata');