@wiremock/npm-jar-wrapper-maker 1.0.0

package/lib/generator.js

@@ -0,0 +1,711 @@
+/**
+ * NPM Wrapper Generator
+ *
+ * Generates NPM wrapper projects for Java JARs.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+/**
+ * Default configuration
+ */
+const defaults = {
+  targetJavaVersion: 17,
+  javaOpts: [],
+  enableNativeAccess: false,
+};
+
+/**
+ * Generate package.json for the wrapper
+ */
+function generatePackageJson(config) {
+  const {
+    packageName,
+    version = '1.0.0',
+    description = '',
+    author = '',
+    license = 'Apache-2.0',
+    cliName,
+    jarFileName,
+    repository = {},
+    keywords = [],
+    homepage = '',
+    bugs = {},
+    enablePostinstall = false,
+    postinstallCommand = '',
+  } = config;
+
+  const pkg = {
+    name: packageName,
+    version,
+    description,
+    main: 'index.js',
+    bin: {},
+    files: ['index.js', 'cli.js', jarFileName],
+    scripts: {
+      test: 'echo "No tests specified"',
+    },
+    keywords: ['java', 'cli', ...keywords],
+    author,
+    license,
+    dependencies: {
+      decompress: '^4.2.1',
+    },
+    engines: {
+      node: '>=18.0.0',
+    },
+  };
+
+  // Set bin entry
+  pkg.bin[cliName] = 'index.js';
+
+  // Add postinstall if enabled
+  if (enablePostinstall) {
+    pkg.scripts.postinstall = 'node ./postinstall.js';
+    pkg.files.push('postinstall.js');
+  }
+
+  // Add optional fields if provided
+  if (Object.keys(repository).length > 0) {
+    pkg.repository = repository;
+  }
+  if (homepage) {
+    pkg.homepage = homepage;
+  }
+  if (Object.keys(bugs).length > 0) {
+    pkg.bugs = bugs;
+  }
+
+  return JSON.stringify(pkg, null, 2);
+}
+
+/**
+ * Generate the CLI entry point (index.js)
+ */
+function generateIndexJs(config) {
+  const {
+    cliName,
+    jarFileName,
+    targetJavaVersion = defaults.targetJavaVersion,
+    javaOpts = defaults.javaOpts,
+    enableNativeAccess = defaults.enableNativeAccess,
+    configDirName,
+  } = config;
+
+  // Use the CLI name as config dir name if not specified
+  const configDir = configDirName || cliName;
+
+  return `#!/usr/bin/env node
+
+const path = require('node:path');
+const os = require('node:os');
+const { runCli } = require('./cli');
+
+const targetJavaVersion = ${targetJavaVersion};
+const jarPath = path.join(__dirname, '${jarFileName}');
+const jreDir = path.join(userConfigDir(), '${configDir}', 'jre');
+
+const config = {
+  env: process.env,
+  targetJavaVersion,
+  jreDir,
+  jarPath,
+  cmdArgs: process.argv.slice(2),
+  platform: process.platform,
+  arch: process.arch,
+  spawnOptions: { stdio: 'inherit' },
+  javaOpts: ${JSON.stringify(javaOpts)},
+  enableNativeAccess: ${enableNativeAccess},
+};
+
+runCli(config).then((ret) => {
+  if (ret.error) {
+    console.error(\`Failed to run: \${ret.error.message}\`);
+  }
+  process.exit(ret.status ?? 1);
+});
+
+function userConfigDir() {
+  switch (process.platform) {
+    case 'darwin':
+      return path.join(os.homedir(), '.config');
+    case 'win32':
+      return process.env['LOCALAPPDATA'] || path.join(os.homedir(), 'AppData', 'Local');
+    default:
+      return process.env['XDG_CONFIG_HOME'] || path.join(os.homedir(), '.config');
+  }
+}
+`;
+}
+
+/**
+ * Generate the CLI runtime (cli.js)
+ */
+function generateCliJs() {
+  return `/**
+ * CLI Runtime
+ *
+ * Manages Java JRE discovery/download and JAR execution.
+ */
+
+const { spawnSync } = require('node:child_process');
+const fs = require('node:fs');
+const path = require('node:path');
+const https = require('node:https');
+const crypto = require('node:crypto');
+
+/**
+ * Map Node.js platform to JRE OS name
+ */
+function mapPlatformToOs(platform) {
+  switch (platform) {
+    case 'darwin':
+      return 'mac';
+    case 'win32':
+      return 'windows';
+    default:
+      return 'linux';
+  }
+}
+
+/**
+ * Map Node.js architecture to JRE architecture name
+ */
+function mapArchToJreArch(arch) {
+  switch (arch) {
+    case 'arm64':
+      return 'aarch64';
+    case 'x64':
+      return 'x64';
+    case 'ia32':
+      return 'x32';
+    default:
+      return arch;
+  }
+}
+
+/**
+ * Check if a path is valid (no path traversal attacks)
+ */
+function isValidArchivePath(filePath) {
+  if (path.isAbsolute(filePath)) {
+    return false;
+  }
+  const segments = filePath.split(path.sep);
+  return !segments.some((segment) => segment === '..');
+}
+
+/**
+ * Verify file checksum
+ */
+function verifyChecksum(filePath, expectedChecksum, algorithm = 'sha256') {
+  const fileBuffer = fs.readFileSync(filePath);
+  const hash = crypto.createHash(algorithm);
+  hash.update(fileBuffer);
+  const actualChecksum = hash.digest('hex');
+  return actualChecksum === expectedChecksum;
+}
+
+/**
+ * Download a file from URL to destination
+ */
+function downloadFile(url, dest) {
+  return new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(dest);
+
+    const request = (url) => {
+      https.get(url, (response) => {
+        if (response.statusCode === 301 || response.statusCode === 302) {
+          request(response.headers.location);
+          return;
+        }
+
+        if (response.statusCode !== 200) {
+          reject(new Error(\`Failed to download: HTTP \${response.statusCode}\`));
+          return;
+        }
+
+        response.pipe(file);
+        file.on('finish', () => {
+          file.close(resolve);
+        });
+      }).on('error', (err) => {
+        fs.unlink(dest, () => {});
+        reject(err);
+      });
+    };
+
+    request(url);
+  });
+}
+
+/**
+ * Fetch JSON from URL
+ */
+function fetchJson(url) {
+  return new Promise((resolve, reject) => {
+    const request = (url) => {
+      https.get(url, (response) => {
+        if (response.statusCode === 301 || response.statusCode === 302) {
+          request(response.headers.location);
+          return;
+        }
+
+        if (response.statusCode !== 200) {
+          reject(new Error(\`Failed to fetch: HTTP \${response.statusCode}\`));
+          return;
+        }
+
+        let data = '';
+        response.on('data', (chunk) => (data += chunk));
+        response.on('end', () => {
+          try {
+            resolve(JSON.parse(data));
+          } catch (e) {
+            reject(new Error(\`Failed to parse JSON: \${e.message}\`));
+          }
+        });
+      }).on('error', reject);
+    };
+
+    request(url);
+  });
+}
+
+/**
+ * Check if Java is available at JAVA_HOME
+ */
+function checkJavaHome(env) {
+  const javaHome = env.JAVA_HOME;
+  if (!javaHome) {
+    return null;
+  }
+
+  const javaBin = path.join(javaHome, 'bin', 'java');
+  try {
+    if (fs.existsSync(javaBin) || fs.existsSync(javaBin + '.exe')) {
+      return javaHome;
+    }
+  } catch (e) {
+    // Ignore errors
+  }
+  return null;
+}
+
+/**
+ * Check if Java is available on PATH
+ */
+function checkSystemJava() {
+  try {
+    const result = spawnSync('java', ['-version'], {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      timeout: 5000,
+    });
+
+    if (result.status === 0) {
+      const whichResult = spawnSync(process.platform === 'win32' ? 'where' : 'which', ['java'], {
+        stdio: ['ignore', 'pipe', 'pipe'],
+      });
+
+      if (whichResult.status === 0) {
+        const javaPath = whichResult.stdout.toString().trim().split('\\n')[0];
+        return path.dirname(path.dirname(javaPath));
+      }
+    }
+  } catch (e) {
+    // Ignore errors
+  }
+  return null;
+}
+
+/**
+ * Check if JRE exists in managed directory
+ */
+function checkManagedJre(jreDir) {
+  if (!fs.existsSync(jreDir)) {
+    return null;
+  }
+
+  const entries = fs.readdirSync(jreDir);
+  for (const entry of entries) {
+    const entryPath = path.join(jreDir, entry);
+    const stat = fs.statSync(entryPath);
+
+    if (stat.isDirectory()) {
+      const possiblePaths = [
+        path.join(entryPath, 'bin', 'java'),
+        path.join(entryPath, 'Contents', 'Home', 'bin', 'java'),
+      ];
+
+      for (const javaBin of possiblePaths) {
+        if (fs.existsSync(javaBin) || fs.existsSync(javaBin + '.exe')) {
+          return javaBin.includes('Contents/Home')
+            ? path.join(entryPath, 'Contents', 'Home')
+            : entryPath;
+        }
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Download JRE from Adoptium
+ */
+async function downloadJre(targetVersion, jreDir, platform, arch) {
+  const jreOs = mapPlatformToOs(platform);
+  const jreArch = mapArchToJreArch(arch);
+
+  const apiUrl = \`https://api.adoptium.net/v3/assets/latest/\${targetVersion}/hotspot?architecture=\${jreArch}&image_type=jre&os=\${jreOs}\`;
+
+  console.log('Fetching JRE metadata from Adoptium...');
+  const assets = await fetchJson(apiUrl);
+
+  if (!assets || assets.length === 0) {
+    throw new Error(\`No JRE found for Java \${targetVersion} on \${jreOs}/\${jreArch}\`);
+  }
+
+  const asset = assets[0];
+  const binary = asset.binary;
+  const downloadUrl = binary.package.link;
+  const checksum = binary.package.checksum;
+  const filename = binary.package.name;
+
+  fs.mkdirSync(jreDir, { recursive: true });
+
+  const downloadPath = path.join(jreDir, filename);
+
+  console.log(\`Downloading JRE from Adoptium (\${binary.package.size / 1024 / 1024 | 0} MB)...\`);
+  await downloadFile(downloadUrl, downloadPath);
+
+  console.log('Verifying checksum...');
+  if (!verifyChecksum(downloadPath, checksum)) {
+    fs.unlinkSync(downloadPath);
+    throw new Error('Checksum verification failed');
+  }
+
+  console.log('Extracting JRE...');
+  const decompress = require('decompress');
+  await decompress(downloadPath, jreDir, {
+    filter: (file) => isValidArchivePath(file.path),
+  });
+
+  fs.unlinkSync(downloadPath);
+  console.log('JRE installation complete.');
+
+  return checkManagedJre(jreDir);
+}
+
+/**
+ * Find or download Java JRE
+ */
+async function findOrDownloadJava(targetVersion, jreDir, platform, arch, env) {
+  let javaHome = checkJavaHome(env);
+  if (javaHome) {
+    return javaHome;
+  }
+
+  javaHome = checkSystemJava();
+  if (javaHome) {
+    return javaHome;
+  }
+
+  javaHome = checkManagedJre(jreDir);
+  if (javaHome) {
+    return javaHome;
+  }
+
+  return downloadJre(targetVersion, jreDir, platform, arch);
+}
+
+/**
+ * Run the CLI
+ */
+async function runCli(config) {
+  const {
+    env,
+    targetJavaVersion,
+    jreDir,
+    jarPath,
+    cmdArgs,
+    platform,
+    arch,
+    spawnOptions,
+    javaOpts = [],
+    enableNativeAccess = false,
+  } = config;
+
+  try {
+    const javaHome = await findOrDownloadJava(targetJavaVersion, jreDir, platform, arch, env);
+
+    if (!javaHome) {
+      return { error: new Error('Failed to find or download Java'), status: 1 };
+    }
+
+    const javaBin = path.join(javaHome, 'bin', 'java');
+
+    const javaArgs = [
+      '-Dsun.misc.URLClassPath.disableJarChecking=true',
+      ...javaOpts,
+    ];
+
+    if (enableNativeAccess) {
+      javaArgs.push('--enable-native-access=ALL-UNNAMED');
+    }
+
+    if (env.JAVA_OPTS) {
+      const extraOpts = env.JAVA_OPTS.split(' ').filter(Boolean);
+      javaArgs.push(...extraOpts);
+    }
+
+    javaArgs.push('-jar', jarPath, ...cmdArgs);
+
+    const result = spawnSync(javaBin, javaArgs, {
+      ...spawnOptions,
+      env,
+    });
+
+    return { status: result.status, error: result.error };
+  } catch (error) {
+    return { error, status: 1 };
+  }
+}
+
+module.exports = {
+  runCli,
+  findOrDownloadJava,
+  mapPlatformToOs,
+  mapArchToJreArch,
+  isValidArchivePath,
+};
+`;
+}
+
+/**
+ * Generate postinstall.js
+ */
+function generatePostinstallJs(config) {
+  const { postinstallCommand = '', cliName } = config;
+
+  if (!postinstallCommand) {
+    return `/**
+ * Post-install hook
+ *
+ * Runs after npm install.
+ */
+
+// Add custom post-install logic here
+console.log('${cliName} installed successfully.');
+`;
+  }
+
+  return `/**
+ * Post-install hook
+ *
+ * Runs after npm install.
+ */
+
+const { execSync } = require('node:child_process');
+const path = require('node:path');
+
+try {
+  // Check if installed globally
+  const globalPrefix = execSync('npm config get prefix', { encoding: 'utf-8' }).trim();
+  const isGlobal = __dirname.startsWith(globalPrefix);
+
+  if (isGlobal) {
+    ${postinstallCommand}
+  }
+} catch (e) {
+  // Ignore errors during postinstall
+}
+`;
+}
+
+/**
+ * Generate .gitignore
+ */
+function generateGitignore(config) {
+  const { jarFileName } = config;
+
+  return `# Dependencies
+node_modules/
+
+# Build artifacts
+${jarFileName}
+
+# IDE
+.idea/
+.vscode/
+*.iml
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+npm-debug.log*
+
+# Test coverage
+coverage/
+`;
+}
+
+/**
+ * Generate .npmignore
+ */
+function generateNpmignore() {
+  return `# Development files
+.gitignore
+.prettierrc
+.editorconfig
+
+# Test files
+test/
+*.test.js
+
+# IDE
+.idea/
+.vscode/
+*.iml
+
+# CI/CD
+.github/
+.gitlab-ci.yml
+Jenkinsfile
+
+# Documentation source
+docs/
+`;
+}
+
+/**
+ * Generate README.md
+ */
+function generateReadme(config) {
+  const {
+    packageName,
+    description = '',
+    cliName,
+    jarFileName,
+    targetJavaVersion = defaults.targetJavaVersion,
+  } = config;
+
+  return `# ${packageName}
+
+${description}
+
+## Installation
+
+\`\`\`bash
+npm install -g ${packageName}
+\`\`\`
+
+## Usage
+
+\`\`\`bash
+${cliName} [options]
+\`\`\`
+
+## Requirements
+
+- Node.js >= 18.0.0
+- Java ${targetJavaVersion}+ (will be downloaded automatically if not found)
+
+## How it works
+
+This package wraps a Java JAR file (\`${jarFileName}\`) and provides a convenient CLI interface.
+When you run the CLI, it will:
+
+1. Check for Java in \`JAVA_HOME\`
+2. Check for Java on your system PATH
+3. If no Java is found, automatically download and cache a JRE from Adoptium
+
+## License
+
+Apache-2.0
+`;
+}
+
+/**
+ * Generate the wrapper project
+ */
+function generateWrapper(config, outputDir) {
+  const files = {
+    'package.json': generatePackageJson(config),
+    'index.js': generateIndexJs(config),
+    'cli.js': generateCliJs(),
+    '.gitignore': generateGitignore(config),
+    '.npmignore': generateNpmignore(),
+    'README.md': generateReadme(config),
+  };
+
+  if (config.enablePostinstall) {
+    files['postinstall.js'] = generatePostinstallJs(config);
+  }
+
+  // Create output directory if it doesn't exist
+  fs.mkdirSync(outputDir, { recursive: true });
+
+  // Write all files
+  const writtenFiles = [];
+  for (const [filename, content] of Object.entries(files)) {
+    const filePath = path.join(outputDir, filename);
+    fs.writeFileSync(filePath, content, 'utf-8');
+    writtenFiles.push(filePath);
+  }
+
+  return {
+    outputDir,
+    files: writtenFiles,
+    jarPlaceholder: path.join(outputDir, config.jarFileName),
+  };
+}
+
+/**
+ * Validate configuration
+ */
+function validateConfig(config) {
+  const errors = [];
+
+  if (!config.packageName) {
+    errors.push('packageName is required');
+  } else if (!/^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/.test(config.packageName)) {
+    errors.push('packageName must be a valid npm package name');
+  }
+
+  if (!config.cliName) {
+    errors.push('cliName is required');
+  } else if (!/^[a-z0-9-]+$/.test(config.cliName)) {
+    errors.push('cliName must contain only lowercase letters, numbers, and hyphens');
+  }
+
+  if (!config.jarFileName) {
+    errors.push('jarFileName is required');
+  }
+
+  if (config.targetJavaVersion && (typeof config.targetJavaVersion !== 'number' || config.targetJavaVersion < 8)) {
+    errors.push('targetJavaVersion must be a number >= 8');
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors,
+  };
+}
+
+module.exports = {
+  generateWrapper,
+  generatePackageJson,
+  generateIndexJs,
+  generateCliJs,
+  generatePostinstallJs,
+  generateGitignore,
+  generateNpmignore,
+  generateReadme,
+  validateConfig,
+  defaults,
+};