ic-mops 1.11.1 → 2.0.0

package/commands/build.ts

@@ -0,0 +1,177 @@
+import chalk from "chalk";
+import { execa } from "execa";
+import { exists } from "fs-extra";
+import { mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { getMocPath } from "../helpers/get-moc-path.js";
+import { readConfig } from "../mops.js";
+import { CanisterConfig } from "../types.js";
+import { sourcesArgs } from "./sources.js";
+import { isCandidCompatible } from "../helpers/is-candid-compatible.js";
+import { cliError } from "../error.js";
+
+export interface BuildOptions {
+  outputDir: string;
+  verbose: boolean;
+  extraArgs: string[];
+}
+
+export const DEFAULT_BUILD_OUTPUT_DIR = ".mops/.build";
+
+export async function build(
+  canisterNames: string[] | undefined,
+  options: Partial<BuildOptions>,
+): Promise<void> {
+  if (canisterNames?.length == 0) {
+    cliError("No canisters specified to build");
+  }
+
+  let outputDir = options.outputDir ?? DEFAULT_BUILD_OUTPUT_DIR;
+  let mocPath = getMocPath();
+  let canisters: Record<string, CanisterConfig> = {};
+  let config = readConfig();
+  if (config.canisters) {
+    canisters =
+      Object.fromEntries(
+        Object.entries(config.canisters).map(([name, c]) =>
+          typeof c === "string" ? [name, { main: c }] : [name, c],
+        ),
+      ) ?? {};
+  }
+  if (!Object.keys(canisters).length) {
+    cliError(`No Motoko canisters found in mops.toml configuration`);
+  }
+
+  if (canisterNames) {
+    canisterNames = canisterNames.filter((name) => name in canisters);
+    if (canisterNames.length === 0) {
+      throw new Error("No valid canister names specified");
+    }
+    for (let name of canisterNames) {
+      if (!(name in canisters)) {
+        cliError(
+          `Motoko canister '${name}' not found in mops.toml configuration`,
+        );
+      }
+    }
+  }
+
+  if (!(await exists(outputDir))) {
+    await mkdir(outputDir, { recursive: true });
+  }
+
+  const filteredCanisters = canisterNames
+    ? Object.fromEntries(
+        Object.entries(canisters).filter(([name]) =>
+          canisterNames.includes(name),
+        ),
+      )
+    : canisters;
+
+  for (let [canisterName, canister] of Object.entries(filteredCanisters)) {
+    options.verbose && console.time(`build canister ${canisterName}`);
+    console.log(chalk.blue("build canister"), chalk.bold(canisterName));
+    let motokoPath = canister.main;
+    if (!motokoPath) {
+      cliError(`No main file is specified for canister ${canisterName}`);
+    }
+    let args = [
+      "-c",
+      "--idl",
+      "-o",
+      join(outputDir, `${canisterName}.wasm`),
+      motokoPath,
+      ...(options.extraArgs ?? []),
+      ...(await sourcesArgs()).flat(),
+    ];
+    if (config.build?.args) {
+      if (typeof config.build.args === "string") {
+        cliError(
+          `[build] config 'args' should be an array of strings in mops.toml config file`,
+        );
+      }
+      args.push(...config.build.args);
+    }
+    if (canister.args) {
+      if (typeof canister.args === "string") {
+        cliError(
+          `Canister config 'args' should be an array of strings for canister ${canisterName}`,
+        );
+      }
+      args.push(...canister.args);
+    }
+    try {
+      if (options.verbose) {
+        console.log(chalk.gray(mocPath, JSON.stringify(args)));
+      }
+      const result = await execa(mocPath, args, {
+        stdio: options.verbose ? "inherit" : "pipe",
+        reject: false,
+      });
+
+      if (result.exitCode !== 0) {
+        if (!options.verbose) {
+          if (result.stderr) {
+            console.error(chalk.red(result.stderr));
+          }
+          if (result.stdout?.trim()) {
+            console.error(chalk.yellow("Build output:"));
+            console.error(result.stdout);
+          }
+        }
+        cliError(
+          `Build failed for canister ${canisterName} (exit code: ${result.exitCode})`,
+        );
+      }
+
+      if (options.verbose && result.stdout && result.stdout.trim()) {
+        console.log(result.stdout);
+      }
+
+      if (canister.candid) {
+        const generatedDidPath = join(outputDir, `${canisterName}.did`);
+        const originalCandidPath = canister.candid;
+
+        try {
+          const compatible = await isCandidCompatible(
+            generatedDidPath,
+            originalCandidPath,
+          );
+
+          if (!compatible) {
+            cliError(
+              `Candid compatibility check failed for canister ${canisterName}`,
+            );
+          }
+
+          if (options.verbose) {
+            console.log(
+              chalk.green(
+                `Candid compatibility check passed for canister ${canisterName}`,
+              ),
+            );
+          }
+        } catch (candidError: any) {
+          cliError(
+            `Error during Candid compatibility check for canister ${canisterName}`,
+            candidError,
+          );
+        }
+      }
+    } catch (cliError: any) {
+      if (cliError.message?.includes("Build failed for canister")) {
+        throw cliError;
+      }
+      cliError(
+        `Error while compiling canister ${canisterName}${cliError?.message ? `\n${cliError.message}` : ""}`,
+      );
+    }
+    options.verbose && console.timeEnd(`build canister ${canisterName}`);
+  }
+
+  console.log(
+    chalk.green(
+      `\n✓ Built ${Object.keys(filteredCanisters).length} canister${Object.keys(filteredCanisters).length == 1 ? "" : "s"} successfully`,
+    ),
+  );
+}

package/commands/bump.ts

@@ -1,59 +1,70 @@
-import process from 'node:process';
-import prompts from 'prompts';
-import chalk from 'chalk';
-import {checkConfigFile, readConfig, writeConfig} from '../mops.js';
-
-export async function bump(part : string) {
-	if (!checkConfigFile()) {
-		return;
-	}
-
-	if (part && !['major', 'minor', 'patch'].includes(part)) {
-		console.log(chalk.red('Unknown version part. Available parts: major, minor, patch'));
-		process.exit(1);
-	}
-
-	let config = readConfig();
-
-	if (!config.package) {
-		console.log(chalk.red('No [package] section found in mops.toml.'));
-		process.exit(1);
-	}
-
-	console.log(`Current version: ${chalk.yellow.bold(config.package.version)}`);
-
-	if (!part) {
-		let res = await prompts({
-			type: 'select',
-			name: 'part',
-			message: 'Select new version:',
-			choices: [
-				{title: `${updateVersion(config.package.version, 'major')} ${chalk.dim('(major, breaking changes)')}`, value: 'major'},
-				{title: `${updateVersion(config.package.version, 'minor')} ${chalk.dim('(minor, new features)')}`, value: 'minor'},
-				{title: `${updateVersion(config.package.version, 'patch')} ${chalk.dim('(patch, bug fixes)')}`, value: 'patch'},
-			],
-			initial: 2,
-		});
-		if (!res.part) {
-			return;
-		}
-		part = res.part;
-	}
-
-	config.package.version = updateVersion(config.package.version, part);
-	writeConfig(config);
-	console.log(`Updated version: ${chalk.green.bold(config.package.version)}`);
+import process from "node:process";
+import prompts from "prompts";
+import chalk from "chalk";
+import { checkConfigFile, readConfig, writeConfig } from "../mops.js";
+
+export async function bump(part: string) {
+  if (!checkConfigFile()) {
+    return;
+  }
+
+  if (part && !["major", "minor", "patch"].includes(part)) {
+    console.log(
+      chalk.red("Unknown version part. Available parts: major, minor, patch"),
+    );
+    process.exit(1);
+  }
+
+  let config = readConfig();
+
+  if (!config.package) {
+    console.log(chalk.red("No [package] section found in mops.toml."));
+    process.exit(1);
+  }
+
+  console.log(`Current version: ${chalk.yellow.bold(config.package.version)}`);
+
+  if (!part) {
+    let res = await prompts({
+      type: "select",
+      name: "part",
+      message: "Select new version:",
+      choices: [
+        {
+          title: `${updateVersion(config.package.version, "major")} ${chalk.dim("(major, breaking changes)")}`,
+          value: "major",
+        },
+        {
+          title: `${updateVersion(config.package.version, "minor")} ${chalk.dim("(minor, new features)")}`,
+          value: "minor",
+        },
+        {
+          title: `${updateVersion(config.package.version, "patch")} ${chalk.dim("(patch, bug fixes)")}`,
+          value: "patch",
+        },
+      ],
+      initial: 2,
+    });
+    if (!res.part) {
+      return;
+    }
+    part = res.part;
+  }
+
+  config.package.version = updateVersion(config.package.version, part);
+  writeConfig(config);
+  console.log(`Updated version: ${chalk.green.bold(config.package.version)}`);
 }
 
-function updateVersion(version : string, part : string) {
-	let parts = version.split('.');
-	let idx = ['major', 'minor', 'patch'].indexOf(part);
-	if (!parts[idx]) {
-		throw new Error(`Invalid version part: ${part}`);
-	}
-	parts[idx] = String(parseInt(parts[idx] || '0') + 1);
-	for (let i = idx + 1; i < parts.length; i++) {
-		parts[i] = '0';
-	}
-	return parts.join('.');
-}
+function updateVersion(version: string, part: string) {
+  let parts = version.split(".");
+  let idx = ["major", "minor", "patch"].indexOf(part);
+  if (!parts[idx]) {
+    throw new Error(`Invalid version part: ${part}`);
+  }
+  parts[idx] = String(parseInt(parts[idx] || "0") + 1);
+  for (let i = idx + 1; i < parts.length; i++) {
+    parts[i] = "0";
+  }
+  return parts.join(".");
+}

package/commands/check-candid.ts

@@ -0,0 +1,24 @@
+import chalk from "chalk";
+import { isCandidCompatible } from "../helpers/is-candid-compatible.js";
+import { cliError } from "../error.js";
+
+export interface CheckCandidOptions {
+  verbose?: boolean;
+}
+
+export async function checkCandid(
+  newPath: string,
+  originalPath: string,
+): Promise<void> {
+  try {
+    const compatible = await isCandidCompatible(newPath, originalPath);
+    if (!compatible) {
+      cliError("✖ Candid compatibility check failed");
+    }
+    console.log(chalk.green("✓ Candid compatibility check passed"));
+  } catch (error: any) {
+    cliError(
+      `Error while checking Candid compatibility${error?.message ? `\n${error.message}` : ""}`,
+    );
+  }
+}

package/commands/docs-coverage.ts

@@ -1,110 +1,132 @@
-import {readFileSync} from 'node:fs';
-import chalk from 'chalk';
-import {globSync} from 'glob';
-import {JSDOM} from 'jsdom';
-import {docs} from './docs.js';
-
-export type DocsCoverageReporter = 'compact' | 'files' | 'missing' | 'verbose' | 'silent';
+import { readFileSync } from "node:fs";
+import chalk from "chalk";
+import { globSync } from "glob";
+import { JSDOM } from "jsdom";
+import { docs } from "./docs.js";
+
+export type DocsCoverageReporter =
+  | "compact"
+  | "files"
+  | "missing"
+  | "verbose"
+  | "silent";
 
 type DocsCoverageOptions = {
-	source : string,
-	reporter : DocsCoverageReporter,
-	threshold : number,
+  source: string;
+  reporter: DocsCoverageReporter;
+  threshold: number;
 };
 
-export async function docsCoverage(options : Partial<DocsCoverageOptions> = {}) {
-	let docsDir = '.mops/.docs';
-
-	let {source, reporter, threshold} = {
-		source: 'src',
-		reporter: 'files',
-		threshold: 0,
-		...options,
-	};
-
-	await docs({
-		source,
-		output: docsDir,
-		format: 'html',
-		silent: true,
-	});
-
-	let files = globSync(`${docsDir}/**/*.html`, {ignore: [`${docsDir}/**/index.html`]});
-	let coverages = [];
-
-	for (let file of files) {
-		let coverage = docFileCoverage(file);
-		coverages.push(coverage);
-
-		if (reporter === 'silent') {
-			continue;
-		}
-		if (reporter !== 'compact' && (reporter !== 'missing' || coverage.coverage < 100)) {
-			console.log(`• ${coverage.file} ${colorizeCoverage(coverage.coverage)}`);
-		}
-		if (reporter === 'missing' && coverage.coverage < 100) {
-			for (let item of coverage.items) {
-				if (!item.covered) {
-					console.log(`  ${item.covered ? chalk.green('✓') : chalk.red('✖')} ${item.id} ${chalk.gray(item.type)}`);
-				}
-			}
-		}
-		else if (reporter === 'verbose') {
-			for (let item of coverage.items) {
-				console.log(`  ${item.covered ? chalk.green('✓') : chalk.red('✖')} ${item.id} ${chalk.gray(item.type)}`);
-			}
-		}
-	}
-
-	if (reporter !== 'compact' && reporter !== 'silent') {
-		console.log('-'.repeat(50));
-	}
-
-	let totalCoverage = coverages.reduce((acc, coverage) => acc + coverage.coverage, 0) / (coverages.length || 1);
-	if (reporter !== 'silent') {
-		console.log(`Documentation coverage: ${colorizeCoverage(totalCoverage)}`);
-	}
-
-	if (threshold > 0 && totalCoverage < threshold) {
-		process.exit(1);
-	}
-
-	return totalCoverage;
+export async function docsCoverage(options: Partial<DocsCoverageOptions> = {}) {
+  let docsDir = ".mops/.docs";
+
+  let { source, reporter, threshold } = {
+    source: "src",
+    reporter: "files",
+    threshold: 0,
+    ...options,
+  };
+
+  await docs({
+    source,
+    output: docsDir,
+    format: "html",
+    silent: true,
+  });
+
+  let files = globSync(`${docsDir}/**/*.html`, {
+    ignore: [`${docsDir}/**/index.html`],
+  });
+  let coverages = [];
+
+  for (let file of files) {
+    let coverage = docFileCoverage(file);
+    coverages.push(coverage);
+
+    if (reporter === "silent") {
+      continue;
+    }
+    if (
+      reporter !== "compact" &&
+      (reporter !== "missing" || coverage.coverage < 100)
+    ) {
+      console.log(`• ${coverage.file} ${colorizeCoverage(coverage.coverage)}`);
+    }
+    if (reporter === "missing" && coverage.coverage < 100) {
+      for (let item of coverage.items) {
+        if (!item.covered) {
+          console.log(
+            `  ${item.covered ? chalk.green("✓") : chalk.red("✖")} ${item.id} ${chalk.gray(item.type)}`,
+          );
+        }
+      }
+    } else if (reporter === "verbose") {
+      for (let item of coverage.items) {
+        console.log(
+          `  ${item.covered ? chalk.green("✓") : chalk.red("✖")} ${item.id} ${chalk.gray(item.type)}`,
+        );
+      }
+    }
+  }
+
+  if (reporter !== "compact" && reporter !== "silent") {
+    console.log("-".repeat(50));
+  }
+
+  let totalCoverage =
+    coverages.reduce((acc, coverage) => acc + coverage.coverage, 0) /
+    (coverages.length || 1);
+  if (reporter !== "silent") {
+    console.log(`Documentation coverage: ${colorizeCoverage(totalCoverage)}`);
+  }
+
+  if (threshold > 0 && totalCoverage < threshold) {
+    process.exit(1);
+  }
+
+  return totalCoverage;
 }
 
-function docFileCoverage(file : string) {
-	let dom = new JSDOM(readFileSync(file, 'utf-8'));
-
-	let module = dom.window.document.querySelector('h1')?.textContent || '';
-	let moduleFile = `${module}.mo`;
-
-	let items = [...dom.window.document.querySelectorAll('h4')].map(h4 => {
-		let id = h4.getAttribute('id')?.replace('type.', '');
-		let type = h4.className.replace('-declaration', '').replace('function', 'func');
-		let definition = h4.textContent;
-		let comment = h4.parentElement?.querySelector('p + p')?.textContent;
-		return {file: moduleFile, id, type, definition, comment, covered: (comment || '').length >= 5};
-	});
-
-	let coverage = 0;
-	if (!items.length) {
-		coverage = 100;
-	}
-	else {
-		coverage = items.filter(item => item.covered).length / items.length * 100;
-	}
-
-	return {file: moduleFile, coverage, items};
+function docFileCoverage(file: string) {
+  let dom = new JSDOM(readFileSync(file, "utf-8"));
+
+  let module = dom.window.document.querySelector("h1")?.textContent || "";
+  let moduleFile = `${module}.mo`;
+
+  let items = [...dom.window.document.querySelectorAll("h4")].map((h4) => {
+    let id = h4.getAttribute("id")?.replace("type.", "");
+    let type = h4.className
+      .replace("-declaration", "")
+      .replace("function", "func");
+    let definition = h4.textContent;
+    let comment = h4.parentElement?.querySelector("p + p")?.textContent;
+    return {
+      file: moduleFile,
+      id,
+      type,
+      definition,
+      comment,
+      covered: (comment || "").length >= 5,
+    };
+  });
+
+  let coverage = 0;
+  if (!items.length) {
+    coverage = 100;
+  } else {
+    coverage =
+      (items.filter((item) => item.covered).length / items.length) * 100;
+  }
+
+  return { file: moduleFile, coverage, items };
 }
 
-function colorizeCoverage(coverage : number) {
-	if (coverage >= 90) {
-		return chalk.green(coverage.toFixed(2) + '%');
-	}
-	else if (coverage >= 50) {
-		return chalk.yellow(coverage.toFixed(2) + '%');
-	}
-	else {
-		return chalk.red(coverage.toFixed(2) + '%');
-	}
-}
+function colorizeCoverage(coverage: number) {
+  if (coverage >= 90) {
+    return chalk.green(coverage.toFixed(2) + "%");
+  } else if (coverage >= 50) {
+    return chalk.yellow(coverage.toFixed(2) + "%");
+  } else {
+    return chalk.red(coverage.toFixed(2) + "%");
+  }
+}