houdini-react 2.0.0-go.6 → 2.0.0-go.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "houdini-react",
-  "version": "2.0.0-go.6",
+  "version": "2.0.0-go.7",
   "description": "The React plugin for houdini",
   "keywords": [
     "typescript",
@@ -35,7 +35,7 @@
     "express": "^4.18.2",
     "graphql": "^15.8.0",
     "graphql-yoga": "^4.0.4",
-    "houdini": "^2.0.0-go.6",
+    "houdini": "^2.0.0-go.7",
     "react": "^19.0.0",
     "react-dom": "^19.0.0",
     "react-streaming-compat": "^0.3.18",
@@ -80,12 +80,12 @@
     }
   },
   "optionalDependencies": {
-    "houdini-react-darwin-x64": "2.0.0-go.6",
-    "houdini-react-darwin-arm64": "2.0.0-go.6",
-    "houdini-react-linux-x64": "2.0.0-go.6",
-    "houdini-react-linux-arm64": "2.0.0-go.6",
-    "houdini-react-win32-x64": "2.0.0-go.6",
-    "houdini-react-win32-arm64": "2.0.0-go.6"
+    "houdini-react-darwin-x64": "2.0.0-go.7",
+    "houdini-react-darwin-arm64": "2.0.0-go.7",
+    "houdini-react-linux-x64": "2.0.0-go.7",
+    "houdini-react-linux-arm64": "2.0.0-go.7",
+    "houdini-react-win32-x64": "2.0.0-go.7",
+    "houdini-react-win32-arm64": "2.0.0-go.7"
   },
   "bin": "./shim.cjs",
   "scripts": {

package/postInstall.js

@@ -2,9 +2,10 @@ const fs = require('fs')
 const path = require('path')
 const zlib = require('zlib')
 const https = require('https')
+const child_process = require('child_process')
 
 // Adjust the version you want to install. You can also make this dynamic.
-const BINARY_DISTRIBUTION_VERSION = '2.0.0-go.6'
+const BINARY_DISTRIBUTION_VERSION = '2.0.0-go.7'
 
 // Windows binaries end with .exe so we need to special case them.
 const binaryName = process.platform === 'win32' ? 'houdini-react.exe' : 'houdini-react'
@@ -15,6 +16,16 @@ const platformSpecificPackageName = `houdini-react-${process.platform}-${process
 // Compute the path we want to emit the fallback binary to
 const fallbackBinaryPath = path.join(__dirname, binaryName)
 
+// Manual binary path override support
+const MANUAL_BINARY_PATH = process.env.HOUDINI_BINARY_PATH || process.env.HOUDINI_REACT_BINARY_PATH
+
+// Package version for validation
+const packageJSON = require(path.join(__dirname, 'package.json'))
+const expectedVersion = packageJSON.version
+
+// Track if shim is still JavaScript
+let isShimJS = true
+
 function makeRequest(url) {
 	return new Promise((resolve, reject) => {
 		https
@@ -69,7 +80,70 @@ function extractFileFromTarball(tarballBuffer, filepath) {
 	}
 }
 
+function installUsingNPM() {
+	// Erase "npm_config_global" so that "npm install --global" works.
+	// Otherwise this nested "npm install" will also be global, and the install
+	// will deadlock waiting for the global installation lock.
+	const env = { ...process.env, npm_config_global: undefined };
+
+	// Create a temporary directory with an empty package.json
+	const tempDir = path.join(__dirname, 'npm-install-temp');
+
+	try {
+		fs.mkdirSync(tempDir);
+		fs.writeFileSync(path.join(tempDir, 'package.json'), '{}');
+
+		// Run npm install in the temporary directory
+		child_process.execSync(
+			`npm install --loglevel=error --prefer-offline --no-audit --progress=false ${platformSpecificPackageName}@${BINARY_DISTRIBUTION_VERSION}`,
+			{ cwd: tempDir, stdio: 'pipe', env }
+		);
+
+		// Move the downloaded binary to the fallback location
+		const installedBinaryPath = path.join(tempDir, 'node_modules', platformSpecificPackageName, 'bin', binaryName);
+		fs.renameSync(installedBinaryPath, fallbackBinaryPath);
+
+		return true;
+	} catch (err) {
+		console.error(`[${packageJSON.name}] npm install fallback failed: ${err.message}`);
+		return false;
+	} finally {
+		// Clean up temporary directory
+		try {
+			removeRecursive(tempDir);
+		} catch {
+			// Ignore cleanup errors
+		}
+	}
+}
+
+function removeRecursive(dir) {
+	if (!fs.existsSync(dir)) return;
+
+	for (const entry of fs.readdirSync(dir)) {
+		const entryPath = path.join(dir, entry);
+		const stats = fs.lstatSync(entryPath);
+
+		if (stats.isDirectory()) {
+			removeRecursive(entryPath);
+		} else {
+			fs.unlinkSync(entryPath);
+		}
+	}
+
+	fs.rmdirSync(dir);
+}
+
 async function downloadBinaryFromNpm() {
+	// First try nested npm install (like esbuild does)
+	if (installUsingNPM()) {
+		console.log(`[${packageJSON.name}] Downloaded binary via npm install`);
+		return;
+	}
+
+	// Fallback to direct HTTP download
+	console.log(`[${packageJSON.name}] Trying direct download from npm registry...`);
+
 	// Download the tarball of the right binary distribution package
 	const tarballDownloadBuffer = await makeRequest(
 		`https://registry.npmjs.org/${platformSpecificPackageName}/-/${platformSpecificPackageName}-${BINARY_DISTRIBUTION_VERSION}.tgz`
@@ -83,6 +157,8 @@ async function downloadBinaryFromNpm() {
 		extractFileFromTarball(tarballBuffer, `package/bin/${binaryName}`),
 		{ mode: 0o755 } // Make binary file executable
 	)
+
+	console.log(`[${packageJSON.name}] Downloaded binary via direct download`);
 }
 
 function isPlatformSpecificPackageInstalled() {
@@ -102,46 +178,174 @@ if (!platformSpecificPackageName) {
 	throw new Error('Platform not supported!')
 }
 
-// once we've confirmed the required package is installed we want to overwrite the bin entry of our package.json
-// to point to the correct binary for optimal performance (skip Node.js overhead)
-function overwriteBinary() {
-	const packageJsonPath = path.join(__dirname, 'package.json')
-	const packageJson = require(packageJsonPath)
+// Replace the JavaScript shim with the actual binary for optimal performance (skip Node.js overhead)
+// This is inspired by esbuild's approach: https://github.com/evanw/esbuild/blob/main/lib/npm/node-install.ts
+function maybeOptimizePackage() {
+	// This optimization doesn't work on Windows because the binary must be called with .exe extension
+	// It also doesn't work with Yarn due to various compatibility issues
+	if (process.platform === 'win32' || isYarn()) {
+		return
+	}
 
 	let binaryPath = null
 
 	try {
-		// Method 1: Use require.resolve to find the actual path to the platform-specific package
-		// This works with pnpm and other package managers that use symlinks
+		// Method 1: Use require.resolve to find the platform-specific package
 		const platformPackagePath = require.resolve(`${platformSpecificPackageName}/package.json`)
 		const platformPackageDir = path.dirname(platformPackagePath)
 		binaryPath = path.join(platformPackageDir, 'bin', binaryName)
 	} catch (error) {
 		// Method 2: Check if platform package is installed as a sibling directory
-		// This works with npm and local installs
 		const siblingPath = path.join(__dirname, '..', platformSpecificPackageName)
-		const siblingBinaryPath = path.join(siblingPath, 'bin', binaryName)
+		binaryPath = path.join(siblingPath, 'bin', binaryName)
 
-		if (fs.existsSync(siblingBinaryPath)) {
-			binaryPath = siblingBinaryPath
-		} else {
-			// Use shim as fallback
-			return
+		if (!fs.existsSync(binaryPath)) {
+			// Method 3: pnpm-specific structure
+			const pnpmMatch = __dirname.match(/(.+\/node_modules\/)\.pnpm\/([^\/]+)\/node_modules\//)
+			if (pnpmMatch) {
+				const [, nodeModulesRoot] = pnpmMatch
+				const pnpmDir = path.join(nodeModulesRoot, '.pnpm')
+
+				try {
+					const pnpmEntries = fs.readdirSync(pnpmDir)
+					const platformEntry = pnpmEntries.find(entry => entry.startsWith(platformSpecificPackageName + '@'))
+
+					if (platformEntry) {
+						binaryPath = path.join(pnpmDir, platformEntry, 'node_modules', platformSpecificPackageName, 'bin', binaryName)
+					}
+				} catch (err) {
+					// Ignore errors
+				}
+			}
 		}
 	}
 
-	if (binaryPath) {
-		// Make the path relative to the main package directory
-		const relativeBinaryPath = path.relative(__dirname, binaryPath)
-		packageJson.bin = relativeBinaryPath
+	// If we found the binary, try to replace the shim with it
+	if (binaryPath && fs.existsSync(binaryPath)) {
+		// First validate the binary works correctly
+		if (!validateBinaryVersion(binaryPath)) {
+			console.error(`[${packageJSON.name}] Binary validation failed, keeping JavaScript shim`);
+			return;
+		}
+
+		const shimPath = path.join(__dirname, 'shim.cjs')
+		const tempPath = path.join(__dirname, 'shim-temp')
+
+		try {
+			// First create a hard link to avoid taking up additional disk space
+			fs.linkSync(binaryPath, tempPath)
+
+			// Then atomically replace the shim with the binary
+			fs.renameSync(tempPath, shimPath)
+
+			// Make sure it's executable
+			fs.chmodSync(shimPath, 0o755)
+
+			// Update state tracking
+			isShimJS = false
+
+			console.log(`[${packageJSON.name}] Binary optimization successful`);
+		} catch (err) {
+			console.error(`[${packageJSON.name}] Binary optimization failed: ${err.message}`);
+			// If optimization fails, clean up and continue with the shim
+			try {
+				fs.unlinkSync(tempPath)
+			} catch {}
+		}
+	}
+}
 
-		fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2))
+function validateBinaryVersion(binaryPath) {
+	try {
+		// For our Go binaries, we just check if they execute without crashing
+		// We use -h flag which should work and exit cleanly
+		child_process.execFileSync(binaryPath, ['-h'], {
+			stdio: 'pipe',
+			timeout: 5000,
+			encoding: 'utf8'
+		});
+		return true;
+	} catch (err) {
+		// If the binary exits with code 0 or 2 (help), that's fine
+		if (err.status === 0 || err.status === 2) {
+			return true;
+		}
+		console.error(`[${packageJSON.name}] Binary validation failed: ${err.message}`);
+		return false;
+	}
+}
+
+function applyManualBinaryPathOverride(overridePath) {
+	console.log(`[${packageJSON.name}] Using manual binary path: ${overridePath}`);
+
+	const shimPath = path.join(__dirname, 'shim.cjs');
+	const shimContent = `#!/usr/bin/env node
+require('child_process').execFileSync(${JSON.stringify(overridePath)}, process.argv.slice(2), { stdio: 'inherit' });
+`;
+
+	try {
+		fs.writeFileSync(shimPath, shimContent, { mode: 0o755 });
+		isShimJS = true; // Keep as JS since it's a wrapper
+		return true;
+	} catch (err) {
+		console.error(`[${packageJSON.name}] Failed to apply manual binary override: ${err.message}`);
+		return false;
+	}
+}
+
+function isYarn() {
+	const { npm_config_user_agent } = process.env
+	if (npm_config_user_agent) {
+		return /\byarn\//.test(npm_config_user_agent)
+	}
+	return false
+}
+
+// Check for manual binary path override first
+if (MANUAL_BINARY_PATH) {
+	if (fs.existsSync(MANUAL_BINARY_PATH)) {
+		console.log(`[${packageJSON.name}] Using manual binary path override`);
+		if (applyManualBinaryPathOverride(MANUAL_BINARY_PATH)) {
+			process.exit(0);
+		}
+	} else {
+		console.warn(`[${packageJSON.name}] Ignoring invalid manual binary path: ${MANUAL_BINARY_PATH}`);
 	}
 }
 
 // Skip downloading the binary if it was already installed via optionalDependencies
 if (!isPlatformSpecificPackageInstalled()) {
-	downloadBinaryFromNpm().then(overwriteBinary)
+	console.log(`[${packageJSON.name}] Platform package not found, downloading binary...`);
+	downloadBinaryFromNpm().then(() => {
+		maybeOptimizePackage();
+
+		// Final validation
+		const shimPath = path.join(__dirname, 'shim.cjs');
+		if (isShimJS) {
+			// Validate the JavaScript shim can find and run the binary
+			if (!validateBinaryVersion(shimPath)) {
+				console.error(`[${packageJSON.name}] Installation may be incomplete`);
+			}
+		}
+	}).catch(err => {
+		console.error(`[${packageJSON.name}] Failed to download binary: ${err.message}`);
+		process.exit(1);
+	});
 } else {
-	overwriteBinary()
+	console.log(`[${packageJSON.name}] Platform package found, optimizing...`);
+	maybeOptimizePackage();
+
+	// Final validation
+	const shimPath = path.join(__dirname, 'shim.cjs');
+	if (isShimJS) {
+		// Validate the JavaScript shim can find and run the binary
+		if (!validateBinaryVersion(shimPath)) {
+			console.error(`[${packageJSON.name}] Installation may be incomplete`);
+		}
+	} else {
+		// Binary was optimized, validate it directly
+		if (!validateBinaryVersion(shimPath)) {
+			console.error(`[${packageJSON.name}] Binary optimization may have failed`);
+		}
+	}
 }

package/shim.cjs

@@ -1,7 +1,23 @@
 #!/usr/bin/env node
 
+// Simple shim that can be replaced with the actual binary for optimal performance
+// This follows esbuild's approach: the postInstall script will replace this entire file
+// with the native binary when possible, eliminating Node.js startup overhead
+
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+// Manual binary path override support
+const MANUAL_BINARY_PATH = process.env.HOUDINI_BINARY_PATH || process.env.HOUDINI_REACT_BINARY_PATH;
+
 function getBinaryPath() {
-	// lookup table for all platforms and binary distribution packages
+	// Check for manual override first
+	if (MANUAL_BINARY_PATH && fs.existsSync(MANUAL_BINARY_PATH)) {
+		return MANUAL_BINARY_PATH;
+	}
+
+	// Platform-specific package lookup
 	const BINARY_DISTRIBUTION_PACKAGES = {
 		'linux-x64': 'houdini-react-linux-x64',
 		'linux-arm64': 'houdini-react-linux-arm64',
@@ -11,54 +27,58 @@ function getBinaryPath() {
 		'darwin-arm64': 'houdini-react-darwin-arm64',
 	}
 
-	// windows binaries end with .exe so we need to special case them
 	const binaryName = process.platform === 'win32' ? 'houdini-react.exe' : 'houdini-react'
+	const platformSpecificPackageName = BINARY_DISTRIBUTION_PACKAGES[`${process.platform}-${process.arch}`]
 
-	// determine package name for this platform
-	const platformSpecificPackageName =
-		BINARY_DISTRIBUTION_PACKAGES[`${process.platform}-${process.arch}`]
+	if (!platformSpecificPackageName) {
+		// Fallback to downloaded binary if platform not supported
+		return path.join(__dirname, binaryName)
+	}
 
 	try {
-		// resolving will fail if the optionalDependency was not installed
-		return require.resolve(`../${platformSpecificPackageName}/bin/${binaryName}`)
-	} catch (e) {
-		return require('path').join(__dirname, binaryName)
-	}
-}
-// instead of execFileSync, use spawn to handle the process more gracefully
-const childProcess = require('child_process').spawn(getBinaryPath(), process.argv.slice(2), {
-	stdio: 'inherit',
-})
+		// Method 1: Use require.resolve to find the platform-specific package
+		const platformPackagePath = require.resolve(`${platformSpecificPackageName}/package.json`)
+		const platformPackageDir = path.dirname(platformPackagePath)
+		return path.join(platformPackageDir, 'bin', binaryName)
+	} catch (error) {
+		// Method 2: Check sibling directory (npm structure)
+		const siblingPath = path.join(__dirname, '..', platformSpecificPackageName)
+		const siblingBinaryPath = path.join(siblingPath, 'bin', binaryName)
+
+		if (fs.existsSync(siblingBinaryPath)) {
+			return siblingBinaryPath
+		}
+
+		// Method 3: Check pnpm structure
+		const pnpmMatch = __dirname.match(/(.+\/node_modules\/)\.pnpm\/([^\/]+)\/node_modules\//)
+		if (pnpmMatch) {
+			const [, nodeModulesRoot] = pnpmMatch
+			const pnpmDir = path.join(nodeModulesRoot, '.pnpm')
 
-// array of signals we want to handle
-const signals = ['SIGTERM', 'SIGINT', 'SIGQUIT', 'SIGHUP']
+			try {
+				const pnpmEntries = fs.readdirSync(pnpmDir)
+				const platformEntry = pnpmEntries.find(entry => entry.startsWith(platformSpecificPackageName + '@'))
 
-// handle each signal
-signals.forEach((signal) => {
-	process.on(signal, () => {
-		if (childProcess) {
-			// on windows, we need to use taskkill for proper tree killing
-			if (process.platform === 'win32') {
-				require('child_process').spawn('taskkill', ['/pid', childProcess.pid, '/f', '/t'])
-			} else {
-				try {
-					childProcess.kill(signal)
-				} catch (err) {
-					// if the process is already gone, that's fine
-					if (err.code !== 'ESRCH') throw err
+				if (platformEntry) {
+					const pnpmBinaryPath = path.join(pnpmDir, platformEntry, 'node_modules', platformSpecificPackageName, 'bin', binaryName)
+					if (fs.existsSync(pnpmBinaryPath)) {
+						return pnpmBinaryPath
+					}
 				}
+			} catch (err) {
+				// Ignore pnpm detection errors
 			}
 		}
-		process.exit(0)
-	})
-})
 
-// handle child process exit
-childProcess.on('exit', (code, signal) => {
-	// if the child was terminated due to a signal, exit with the same signal
-	if (signal) {
-		process.exit(0)
-	} else {
-		process.exit(code)
+		// Method 4: Fallback to downloaded binary in main package
+		return path.join(__dirname, binaryName)
 	}
-})
+}
+
+// Execute the binary directly (this entire file may be replaced with the actual binary)
+try {
+	execFileSync(getBinaryPath(), process.argv.slice(2), { stdio: 'inherit' });
+} catch (error) {
+	// If execFileSync fails, exit with the same code
+	process.exit(error.status || 1);
+}