import_npm_tarballs.js

#!/usr/bin/env node

const { execSync } = require("node:child_process");
const { existsSync, mkdirSync } = require("node:fs");
const path = require("node:path");
const filename = path.basename(__filename);

function showHelp() {
	console.log(`
Usage: ${filename} [options]

Packages all dependencies into tarballs in specified directory.

Options:
  -h, --help       Show this help message
  -p, --path       Output directory for tarballs (required)
  -t, --target     Path to package.json (default: ./package.json)

Examples:
  ${filename} -p ./artifacts
  ${filename} -p ./output -t ../project/package.json
`);
	process.exit(0);
}

function parseArgs() {
	const args = process.argv.slice(2);

	if (args.length === 0) showHelp();

	let outputPath = null;
	let packageJsonPath = "./package.json";

	for (let i = 0; i < args.length; i++) {
		const arg = args[i];
		switch (arg) {
			case "-h":
			case "--help":
				showHelp();
				break;
			case "-p":
			case "--path":
				outputPath = args[i + 1];
				if (!outputPath) {
					console.error("[Error]: Output path not specified");
					process.exit(1);
				}
				i++;
				break;
			case "-t":
			case "--target":
				packageJsonPath = args[i + 1];
				if (!packageJsonPath) {
					console.error("[Error]: package.json path not specified");
					process.exit(1);
				}
				i++;
				break;
			default:
				console.error(`[Error]: Unknown option '${arg}'`);
				showHelp();
		}
	}

	if (!outputPath) {
		console.error("[Error]: Output path is required");
		showHelp();
	}

	return { outputPath, packageJsonPath };
}

function ensureDirectoryExists(dirPath) {
	if (!existsSync(dirPath)) {
		mkdirSync(dirPath, { recursive: true });
		console.log(`Created directory: ${dirPath}`);
	}
	return path.resolve(dirPath);
}

function loadPackageJson(packageJsonPath) {
	try {
		const absolutePath = path.resolve(packageJsonPath);
		if (!existsSync(absolutePath)) {
			console.error(`[Error]: package.json not found at ${absolutePath}`);
			process.exit(1);
		}
		return require(absolutePath);
	} catch (error) {
		console.error("Error loading package.json:", error.message);
		process.exit(1);
	}
}

function packDependencies(outputDir, dependencies) {
	console.log(`Saving tarballs to: ${outputDir}`);

	for (const dep of Object.keys(dependencies)) {
		try {
			console.log(`Packing ${dep}...`);
			execSync(`npm pack ${dep}`, {
				stdio: "inherit",
				cwd: outputDir,
			});
		} catch (error) {
			console.error(`Failed to pack ${dep}:`, error.message);
		}
	}

	// Object.keys(dependencies).forEach((dep) => {
	// 	console.log("Fetching tarball for ${dep}...");
	// 	execSync(`npm pack ${dep}`, { stdio: "inherit" });
	// });

	// for (const [dep, version] of Object.entries(dependencies)) {
	// 	console.log(`Fetching ${dep}@${version}...`);
	// 	execSync(`npm pack ${dep}`, { stdio: "inherit" });
	// }
}

function main() {
	const { outputPath, packageJsonPath } = parseArgs();
	const packageJson = loadPackageJson(packageJsonPath);
	const absoluteOutputPath = ensureDirectoryExists(outputPath);

	const dependencies = {
		...packageJson.dependencies,
		...packageJson.devDependencies,
	};

	packDependencies(absoluteOutputPath, dependencies);
	console.log("All packages processed");
}

main();