mono-runner/lib/utils/alias.ts

A script runner for mono repos that just works. Use Mono to run separate compilers and dev servers for your packages at once, build only dependent packages or format everything at once.

import { writeFileSync } from "fs";
import { getLocalPackages, getPackageJson, getWorkspacePackages, rootPath } from "./packages";
import { join, relative,  } from "path";
import { getPackageConfig } from "./config";
import ts from "typescript";
import { lstat } from "fs/promises";

const addToTsConfig = (name: string, folderPath: string, paths: Record<string, string>) => {
	const tscPath = join(rootPath, folderPath, "tsconfig.json");
	const tsConfig = ts.readConfigFile(tscPath, ts.sys.readFile);
	if(!tsConfig){
		console.warn(`could parse tsconfig.json file for ${name}`);
		return;
	}
	const config = tsConfig.config;
		
		if(!config.compilerOptions){
			config.compilerOptions = {};
		}
		if(!config.compilerOptions.baseUrl){
			config.compilerOptions.baseUrl = "./";
		}			
		if(!config.compilerOptions.paths){
			config.compilerOptions.paths = paths;
		}else{			
			config.compilerOptions.paths = {...config.compilerOptions.paths, ...paths};
		}

		writeFileSync(tscPath, JSON.stringify(config, null, 2));

};






export const genAlias = async (dryrun: boolean) => {
	const paths: Record<string, string> = {};

	const packages = await getLocalPackages();
	const allPackageNames = packages.map((p) => p.name);
	const dependencies = packages.flatMap((p) => p.dependencies.filter((d) => allPackageNames.includes(d)));	

	const pathPromises = packages.map(async(p) => {
		const {name, path} = p;
		if(!dependencies.includes(name)){
			// only include packages that others are dependent on
			console.info(`No packages depend on ${name}, skipping...`);
			return;
		}
		const config = await getPackageConfig(p);
		
		if(!config || !config.srcPath){
			paths[name] = path;
		}else{
			const {srcPath} = config;
			const combined = join(path, srcPath);
			paths[name] = combined;
		}
	});

	await Promise.all(pathPromises);


	const promises = packages.map(async (p) => {
		const {name, path, localDependencies} = p;
		const tsconfig = await lstat(join(rootPath, path, "tsconfig.json")).catch(() => null);
		if(!tsconfig || !tsconfig.isFile()){
			console.info(`No tsconfig.json file found in ${name}, skipping...`);
			return;
		}
		const deps = localDependencies.map(d => {
			const {name} = d;
			const absPath = paths[name];
			const relPath = relative(path, absPath);
			return [name, relPath];
		}).filter((d) => d !== undefined).reduce((acc, [name, out]) => {
			return {...acc, [name]: [out], [`${name}/*`]: [`${out}/*`]};
		}, {});

		if(Object.keys(deps).length === 0){
			if(dryrun){
				console.log(`No local dependencies found for ${name}, skipping...`);
			}
			return;
		}

		if(dryrun){
			console.log(`--- adding to ${name} tsconfig.json --- `);
			console.log(JSON.stringify(deps, null, 2));
			console.log(`------------`);
		}else{
			await addToTsConfig(name, path, deps);
		}
		
	});
	await Promise.all(promises);

	/*
	const base = {
		compilerOptions: {
			baseUrl: "./",
			paths: paths,
		},
	};

	if(alias){
		const out = base;
		writeFileSync(join(rootPath, "tsconfig.alias.json"), JSON.stringify(out, null, 2));
	}else{
		const tscPath = join(rootPath, "tsconfig.json");
		const tsConfig = ts.readConfigFile(tscPath, ts.sys.readFile);

		if(!tsConfig){
			console.log("could not find tsconfig.json file, creating one...");
			writeFileSync(tscPath, JSON.stringify(base, null, 2));
			return
		}
		const config = tsConfig.config;

		if(!config.compilerOptions){
			config.compilerOptions = {};
		}
		if(!config.compilerOptions.baseUrl){
			config.compilerOptions.baseUrl = "./";
		}			
		if(!config.compilerOptions.paths){
			config.compilerOptions.paths = paths;
		}else{
			config.compilerOptions.paths = {...config.compilerOptions.paths, ...paths};
		}

		writeFileSync(join(rootPath, "tsconfig.json"), JSON.stringify(config, null, 2));

	}*/
	
};