ic-mops 1.12.0 → 2.0.0

package/commands/install/install-all.ts

@@ -1,75 +1,88 @@
-import process from 'node:process';
-import chalk from 'chalk';
-import {createLogUpdate} from 'log-update';
-import {checkConfigFile, parseDepValue, readConfig} from '../../mops.js';
-import {checkIntegrity, checkLockFileLight, readLockFile} from '../../integrity.js';
-import {installDeps} from './install-deps.js';
-import {checkRequirements} from '../../check-requirements.js';
-import {syncLocalCache} from './sync-local-cache.js';
-import {notifyInstalls} from '../../notify-installs.js';
+import process from "node:process";
+import chalk from "chalk";
+import { createLogUpdate } from "log-update";
+import { checkConfigFile, parseDepValue, readConfig } from "../../mops.js";
+import {
+  checkIntegrity,
+  checkLockFileLight,
+  readLockFile,
+} from "../../integrity.js";
+import { installDeps } from "./install-deps.js";
+import { checkRequirements } from "../../check-requirements.js";
+import { syncLocalCache } from "./sync-local-cache.js";
+import { notifyInstalls } from "../../notify-installs.js";
 
 type InstallAllOptions = {
-	verbose ?: boolean;
-	silent ?: boolean;
-	lock ?: 'check' | 'update' | 'ignore';
-	threads ?: number;
-	installFromLockFile ?: boolean;
-}
-
-export async function installAll({verbose = false, silent = false, threads, lock, installFromLockFile} : InstallAllOptions = {}) : Promise<boolean> {
-	if (!checkConfigFile()) {
-		return false;
-	}
+  verbose?: boolean;
+  silent?: boolean;
+  lock?: "check" | "update" | "ignore";
+  threads?: number;
+  installFromLockFile?: boolean;
+};
 
-	let config = readConfig();
-	let deps = Object.values(config.dependencies || {});
-	let devDeps = Object.values(config['dev-dependencies'] || {});
-	let allDeps = [...deps, ...devDeps];
-	let installedFromLockFile = false;
+export async function installAll({
+  verbose = false,
+  silent = false,
+  threads,
+  lock,
+  installFromLockFile,
+}: InstallAllOptions = {}): Promise<boolean> {
+  if (!checkConfigFile()) {
+    return false;
+  }
 
-	// install from lock file to avoid installing intermediate dependencies
-	if ((lock !== 'ignore' || installFromLockFile) && checkLockFileLight()) {
-		let lockFileJson = readLockFile();
+  let config = readConfig();
+  let deps = Object.values(config.dependencies || {});
+  let devDeps = Object.values(config["dev-dependencies"] || {});
+  let allDeps = [...deps, ...devDeps];
+  let installedFromLockFile = false;
 
-		if (lockFileJson && lockFileJson.version === 3) {
-			verbose && console.log('Installing from lock file...');
-			installedFromLockFile = true;
-			let lockedDeps = Object.entries(lockFileJson.deps).map(([name, version]) => {
-				return parseDepValue(name, version);
-			});
-			let ok = await installDeps(lockedDeps, {silent, verbose, threads, ignoreTransitive: true});
-			if (!ok) {
-				return false;
-			}
-		}
-	}
+  // install from lock file to avoid installing intermediate dependencies
+  if ((lock !== "ignore" || installFromLockFile) && checkLockFileLight()) {
+    let lockFileJson = readLockFile();
 
-	if (!installedFromLockFile) {
-		let ok = await installDeps(allDeps, {silent, verbose, threads});
-		if (!ok) {
-			return false;
-		}
-	}
+    if (lockFileJson && lockFileJson.version === 3) {
+      verbose && console.log("Installing from lock file...");
+      installedFromLockFile = true;
+      let lockedDeps = Object.entries(lockFileJson.deps).map(
+        ([name, version]) => {
+          return parseDepValue(name, version);
+        },
+      );
+      let ok = await installDeps(lockedDeps, {
+        silent,
+        verbose,
+        threads,
+        ignoreTransitive: true,
+      });
+      if (!ok) {
+        return false;
+      }
+    }
+  }
 
+  if (!installedFromLockFile) {
+    let ok = await installDeps(allDeps, { silent, verbose, threads });
+    if (!ok) {
+      return false;
+    }
+  }
 
-	let logUpdate = createLogUpdate(process.stdout, {showCursor: true});
+  let logUpdate = createLogUpdate(process.stdout, { showCursor: true });
 
-	if (!silent && lock !== 'ignore') {
-		logUpdate('Checking integrity...');
-	}
+  if (!silent && lock !== "ignore") {
+    logUpdate("Checking integrity...");
+  }
 
-	let installedPackages = await syncLocalCache({verbose});
+  let installedPackages = await syncLocalCache({ verbose });
 
-	await Promise.all([
-		notifyInstalls(installedPackages),
-		checkIntegrity(lock),
-	]);
+  await Promise.all([notifyInstalls(installedPackages), checkIntegrity(lock)]);
 
-	if (!silent) {
-		logUpdate.clear();
-		await checkRequirements();
-		console.log(chalk.green('Packages installed'));
-	}
+  if (!silent) {
+    logUpdate.clear();
+    await checkRequirements();
+    console.log(chalk.green("Packages installed"));
+  }
 
-	return true;
-}
+  return true;
+}

package/commands/install/install-dep.ts

@@ -1,35 +1,50 @@
-import path from 'node:path';
-import {installFromGithub} from '../../vessel.js';
-import {installMopsDep} from './install-mops-dep.js';
-import {Dependency} from '../../types.js';
-import {installLocalDep} from './install-local-dep.js';
-import {getRootDir} from '../../mops.js';
+import path from "node:path";
+import { installFromGithub } from "../../vessel.js";
+import { installMopsDep } from "./install-mops-dep.js";
+import { Dependency } from "../../types.js";
+import { installLocalDep } from "./install-local-dep.js";
+import { getRootDir } from "../../mops.js";
 
 type InstallDepOptions = {
-	verbose ?: boolean;
-	silent ?: boolean;
-	threads ?: number;
-	ignoreTransitive ?: boolean;
+  verbose?: boolean;
+  silent?: boolean;
+  threads?: number;
+  ignoreTransitive?: boolean;
 };
 
 // install dependency
 // returns false if failed
-export async function installDep(dep : Dependency, {verbose, silent, threads, ignoreTransitive} : InstallDepOptions = {}, parentPkgPath ?: string) : Promise<boolean> {
-	if (dep.repo) {
-		await installFromGithub(dep.name, dep.repo, {silent, verbose, ignoreTransitive});
-		return true;
-	}
-	else if (dep.path) {
-		let depPath = dep.path;
-		parentPkgPath = parentPkgPath || getRootDir();
-		if (parentPkgPath) {
-			depPath = path.resolve(parentPkgPath, dep.path);
-		}
-		return installLocalDep(dep.name, depPath, {silent, verbose, ignoreTransitive});
-	}
-	else if (dep.version) {
-		return installMopsDep(dep.name, dep.version, {silent, verbose, threads, ignoreTransitive});
-	}
+export async function installDep(
+  dep: Dependency,
+  { verbose, silent, threads, ignoreTransitive }: InstallDepOptions = {},
+  parentPkgPath?: string,
+): Promise<boolean> {
+  if (dep.repo) {
+    await installFromGithub(dep.name, dep.repo, {
+      silent,
+      verbose,
+      ignoreTransitive,
+    });
+    return true;
+  } else if (dep.path) {
+    let depPath = dep.path;
+    parentPkgPath = parentPkgPath || getRootDir();
+    if (parentPkgPath) {
+      depPath = path.resolve(parentPkgPath, dep.path);
+    }
+    return installLocalDep(dep.name, depPath, {
+      silent,
+      verbose,
+      ignoreTransitive,
+    });
+  } else if (dep.version) {
+    return installMopsDep(dep.name, dep.version, {
+      silent,
+      verbose,
+      threads,
+      ignoreTransitive,
+    });
+  }
 
-	return true;
-}
+  return true;
+}

package/commands/install/install-deps.ts

@@ -1,25 +1,33 @@
-import {Dependency} from '../../types.js';
-import {installDep} from './install-dep.js';
+import { Dependency } from "../../types.js";
+import { installDep } from "./install-dep.js";
 
 type InstallDepsOptions = {
-	verbose ?: boolean;
-	silent ?: boolean;
-	threads ?: number;
-	ignoreTransitive ?: boolean;
+  verbose?: boolean;
+  silent?: boolean;
+  threads?: number;
+  ignoreTransitive?: boolean;
 };
 
 // install all dependencies
 // returns actual installed dependencies
 // returns false if failed
-export async function installDeps(deps : Dependency[], {verbose, silent, threads, ignoreTransitive} : InstallDepsOptions = {}, parentPkgPath ?: string) : Promise<boolean> {
-	let ok = true;
+export async function installDeps(
+  deps: Dependency[],
+  { verbose, silent, threads, ignoreTransitive }: InstallDepsOptions = {},
+  parentPkgPath?: string,
+): Promise<boolean> {
+  let ok = true;
 
-	for (const dep of deps) {
-		let res = await installDep(dep, {verbose, silent, threads, ignoreTransitive}, parentPkgPath);
-		if (!res) {
-			ok = false;
-		}
-	}
+  for (const dep of deps) {
+    let res = await installDep(
+      dep,
+      { verbose, silent, threads, ignoreTransitive },
+      parentPkgPath,
+    );
+    if (!res) {
+      ok = false;
+    }
+  }
 
-	return ok;
+  return ok;
 }

package/commands/install/install-local-dep.ts

@@ -1,44 +1,52 @@
-import process from 'node:process';
-import path from 'node:path';
-import {existsSync} from 'node:fs';
-import {createLogUpdate} from 'log-update';
-import {getRootDir, readConfig} from '../../mops.js';
-import {installDeps} from './install-deps.js';
+import process from "node:process";
+import path from "node:path";
+import { existsSync } from "node:fs";
+import { createLogUpdate } from "log-update";
+import { getRootDir, readConfig } from "../../mops.js";
+import { installDeps } from "./install-deps.js";
 
 type InstallLocalDepOptions = {
-	verbose ?: boolean;
-	silent ?: boolean;
-	ignoreTransitive ?: boolean;
+  verbose?: boolean;
+  silent?: boolean;
+  ignoreTransitive?: boolean;
 };
 
 // skip install and just find non-local dependencies to install
 // pkgPath should be relative to the current root dir or absolute
-export async function installLocalDep(pkg : string, pkgPath = '', {verbose, silent, ignoreTransitive} : InstallLocalDepOptions = {}) : Promise<boolean> {
-	if (!silent) {
-		let logUpdate = createLogUpdate(process.stdout, {showCursor: true});
-		logUpdate(`Local dependency ${pkg} = "${pkgPath}"`);
+export async function installLocalDep(
+  pkg: string,
+  pkgPath = "",
+  { verbose, silent, ignoreTransitive }: InstallLocalDepOptions = {},
+): Promise<boolean> {
+  if (!silent) {
+    let logUpdate = createLogUpdate(process.stdout, { showCursor: true });
+    logUpdate(`Local dependency ${pkg} = "${pkgPath}"`);
 
-		if (verbose) {
-			silent || logUpdate.done();
-		}
-		else {
-			logUpdate.clear();
-		}
-	}
+    if (verbose) {
+      silent || logUpdate.done();
+    } else {
+      logUpdate.clear();
+    }
+  }
 
-	// install dependencies
-	if (!ignoreTransitive) {
-		let dir = path.resolve(getRootDir(), pkgPath).replaceAll('{MOPS_ENV}', process.env.MOPS_ENV || 'local');
-		let mopsToml = path.join(dir, 'mops.toml');
+  // install dependencies
+  if (!ignoreTransitive) {
+    let dir = path
+      .resolve(getRootDir(), pkgPath)
+      .replaceAll("{MOPS_ENV}", process.env.MOPS_ENV || "local");
+    let mopsToml = path.join(dir, "mops.toml");
 
-		if (!existsSync(mopsToml)) {
-			return true;
-		}
+    if (!existsSync(mopsToml)) {
+      return true;
+    }
 
-		let config = readConfig(mopsToml);
-		return installDeps(Object.values(config.dependencies || {}), {silent, verbose}, pkgPath);
-	}
-	else {
-		return true;
-	}
-}
+    let config = readConfig(mopsToml);
+    return installDeps(
+      Object.values(config.dependencies || {}),
+      { silent, verbose },
+      pkgPath,
+    );
+  } else {
+    return true;
+  }
+}

package/commands/install/install-mops-dep.ts

@@ -1,127 +1,158 @@
-import process from 'node:process';
-import fs from 'node:fs';
-import path from 'node:path';
-import {Buffer} from 'node:buffer';
-import {createLogUpdate} from 'log-update';
-import chalk from 'chalk';
-import {deleteSync} from 'del';
-import {checkConfigFile, progressBar, readConfig} from '../../mops.js';
-import {getHighestVersion} from '../../api/getHighestVersion.js';
-import {storageActor} from '../../api/actors.js';
-import {parallel} from '../../parallel.js';
-import {getDepCacheDir, getMopsDepCacheName, isDepCached} from '../../cache.js';
-import {downloadFile, getPackageFilesInfo} from '../../api/downloadPackageFiles.js';
-import {installDeps} from './install-deps.js';
-import {getDepName} from '../../helpers/get-dep-name.js';
+import process from "node:process";
+import fs from "node:fs";
+import path from "node:path";
+import { Buffer } from "node:buffer";
+import { createLogUpdate } from "log-update";
+import chalk from "chalk";
+import { deleteSync } from "del";
+import { checkConfigFile, progressBar, readConfig } from "../../mops.js";
+import { getHighestVersion } from "../../api/getHighestVersion.js";
+import { storageActor } from "../../api/actors.js";
+import { parallel } from "../../parallel.js";
+import {
+  getDepCacheDir,
+  getMopsDepCacheName,
+  isDepCached,
+} from "../../cache.js";
+import {
+  downloadFile,
+  getPackageFilesInfo,
+} from "../../api/downloadPackageFiles.js";
+import { installDeps } from "./install-deps.js";
+import { getDepName } from "../../helpers/get-dep-name.js";
 
 type InstallMopsDepOptions = {
-	verbose ?: boolean;
-	silent ?: boolean;
-	dep ?: boolean;
-	threads ?: number;
-	ignoreTransitive ?: boolean;
+  verbose?: boolean;
+  silent?: boolean;
+  dep?: boolean;
+  threads?: number;
+  ignoreTransitive?: boolean;
 };
 
-export async function installMopsDep(pkg : string, version = '', {verbose, silent, dep, threads, ignoreTransitive} : InstallMopsDepOptions = {}) : Promise<boolean> {
-	threads = threads || 12;
-	let depName = getDepName(pkg);
-
-	if (!checkConfigFile()) {
-		return false;
-	}
-	let logUpdate = createLogUpdate(process.stdout, {showCursor: true});
-
-	// progress
-	let total = Infinity;
-	let step = 0;
-	let progress = () => {
-		step++;
-		silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${depName}@${version} ${progressBar(step, total)}`);
-	};
-	progress();
-
-	if (!version) {
-		let versionRes = await getHighestVersion(depName);
-		if ('err' in versionRes) {
-			console.log(chalk.red('Error: ') + versionRes.err);
-			return false;
-		}
-		version = versionRes.ok;
-	}
-
-	let cacheName = getMopsDepCacheName(depName, version);
-	let cacheDir = getDepCacheDir(cacheName);
-
-	// global cache hit
-	if (isDepCached(cacheName)) {
-		silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${depName}@${version} (cache)`);
-	}
-	// download
-	else {
-		// GitHub Actions fails with "fetch failed" if there are multiple concurrent actions
-		if (process.env.GITHUB_ENV) {
-			threads = 4;
-		}
-
-		try {
-			let {storageId, fileIds} = await getPackageFilesInfo(depName, version);
-
-			total = fileIds.length + 2;
-
-			let filesData = new Map;
-			let storage = await storageActor(storageId);
-
-			await parallel(threads, fileIds, async (fileId : string) => {
-				let {path, data} = await downloadFile(storage, fileId);
-				filesData.set(path, data);
-				progress();
-			});
-
-			let onSigInt = () => {
-				deleteSync([cacheDir], {force: true});
-				process.exit();
-			};
-			process.on('SIGINT', onSigInt);
-
-			// write files to global cache
-			try {
-				await Promise.all(Array.from(filesData.entries()).map(async ([filePath, data]) => {
-					await fs.promises.mkdir(path.join(cacheDir, path.dirname(filePath)), {recursive: true});
-					await fs.promises.writeFile(path.join(cacheDir, filePath), Buffer.from(data));
-				}));
-			}
-			catch (err) {
-				console.error(chalk.red('Error: ') + err);
-				deleteSync([cacheDir], {force: true});
-				return false;
-			}
-
-			process.off('SIGINT', onSigInt);
-		}
-		catch (err) {
-			console.error(chalk.red('Error: ') + err);
-			return false;
-		}
-
-		progress();
-	}
-
-	if (verbose) {
-		silent || logUpdate.done();
-	}
-	else {
-		logUpdate.clear();
-	}
-
-	// install dependencies
-	if (!ignoreTransitive) {
-		let config = readConfig(path.join(cacheDir, 'mops.toml'));
-		let res = await installDeps(Object.values(config.dependencies || {}), {silent, verbose});
-
-		if (!res) {
-			return false;
-		}
-	}
-
-	return true;
-}
+export async function installMopsDep(
+  pkg: string,
+  version = "",
+  {
+    verbose,
+    silent,
+    dep,
+    threads,
+    ignoreTransitive,
+  }: InstallMopsDepOptions = {},
+): Promise<boolean> {
+  threads = threads || 12;
+  let depName = getDepName(pkg);
+
+  if (!checkConfigFile()) {
+    return false;
+  }
+  let logUpdate = createLogUpdate(process.stdout, { showCursor: true });
+
+  // progress
+  let total = Infinity;
+  let step = 0;
+  let progress = () => {
+    step++;
+    silent ||
+      logUpdate(
+        `${dep ? "Dependency" : "Installing"} ${depName}@${version} ${progressBar(step, total)}`,
+      );
+  };
+  progress();
+
+  if (!version) {
+    let versionRes = await getHighestVersion(depName);
+    if ("err" in versionRes) {
+      console.log(chalk.red("Error: ") + versionRes.err);
+      return false;
+    }
+    version = versionRes.ok;
+  }
+
+  let cacheName = getMopsDepCacheName(depName, version);
+  let cacheDir = getDepCacheDir(cacheName);
+
+  // global cache hit
+  if (isDepCached(cacheName)) {
+    silent ||
+      logUpdate(
+        `${dep ? "Dependency" : "Installing"} ${depName}@${version} (cache)`,
+      );
+  }
+  // download
+  else {
+    // GitHub Actions fails with "fetch failed" if there are multiple concurrent actions
+    if (process.env.GITHUB_ENV) {
+      threads = 4;
+    }
+
+    try {
+      let { storageId, fileIds } = await getPackageFilesInfo(depName, version);
+
+      total = fileIds.length + 2;
+
+      let filesData = new Map();
+      let storage = await storageActor(storageId);
+
+      await parallel(threads, fileIds, async (fileId: string) => {
+        let { path, data } = await downloadFile(storage, fileId);
+        filesData.set(path, data);
+        progress();
+      });
+
+      let onSigInt = () => {
+        deleteSync([cacheDir], { force: true });
+        process.exit();
+      };
+      process.on("SIGINT", onSigInt);
+
+      // write files to global cache
+      try {
+        await Promise.all(
+          Array.from(filesData.entries()).map(async ([filePath, data]) => {
+            await fs.promises.mkdir(
+              path.join(cacheDir, path.dirname(filePath)),
+              { recursive: true },
+            );
+            await fs.promises.writeFile(
+              path.join(cacheDir, filePath),
+              Buffer.from(data),
+            );
+          }),
+        );
+      } catch (err) {
+        console.error(chalk.red("Error: ") + err);
+        deleteSync([cacheDir], { force: true });
+        return false;
+      }
+
+      process.off("SIGINT", onSigInt);
+    } catch (err) {
+      console.error(chalk.red("Error: ") + err);
+      return false;
+    }
+
+    progress();
+  }
+
+  if (verbose) {
+    silent || logUpdate.done();
+  } else {
+    logUpdate.clear();
+  }
+
+  // install dependencies
+  if (!ignoreTransitive) {
+    let config = readConfig(path.join(cacheDir, "mops.toml"));
+    let res = await installDeps(Object.values(config.dependencies || {}), {
+      silent,
+      verbose,
+    });
+
+    if (!res) {
+      return false;
+    }
+  }
+
+  return true;
+}