ic-mops 1.0.1 → 1.1.0

package/commands/watch/deployer.ts

@@ -0,0 +1,155 @@
+import chalk from 'chalk';
+import os from 'node:os';
+import {promisify} from 'node:util';
+import {execFile, execSync} from 'node:child_process';
+
+import {ErrorChecker} from './error-checker.js';
+import {Generator} from './generator.js';
+import {parallel} from '../../parallel.js';
+import {getRootDir} from '../../mops.js';
+
+export class Deployer {
+	verbose = false;
+	canisters : Record<string, string> = {};
+	status : 'pending' | 'running' | 'syntax-error' | 'dfx-error' | 'error' | 'success' = 'pending';
+	errorChecker : ErrorChecker;
+	generator : Generator;
+	success = 0;
+	errors : string[] = [];
+	aborted = false;
+	controllers = new Map<string, AbortController>();
+	currentRun : Promise<any> | undefined;
+
+	constructor({verbose, canisters, errorChecker, generator} : {verbose : boolean, canisters : Record<string, string>, errorChecker : ErrorChecker, generator : Generator}) {
+		this.verbose = verbose;
+		this.canisters = canisters;
+		this.errorChecker = errorChecker;
+		this.generator = generator;
+	}
+
+	reset() {
+		this.status = 'pending';
+		this.success = 0;
+		this.errors = [];
+	}
+
+	async abortCurrent() {
+		this.aborted = true;
+		for (let controller of this.controllers.values()) {
+			controller.abort();
+		}
+		this.controllers.clear();
+		await this.currentRun;
+		this.reset();
+		this.aborted = false;
+	}
+
+	async run(onProgress : () => void) {
+		await this.abortCurrent();
+
+		if (this.errorChecker.status === 'error') {
+			this.status = 'syntax-error';
+			onProgress();
+			return;
+		}
+
+		if (Object.keys(this.canisters).length === 0) {
+			this.status = 'success';
+			onProgress();
+			return;
+		}
+
+		let rootDir = getRootDir();
+
+		try {
+			execSync('dfx ping', {cwd: rootDir});
+		}
+		catch (error) {
+			this.status = 'dfx-error';
+			onProgress();
+			return;
+		}
+
+		this.status = 'running';
+		onProgress();
+
+		// create canisters (sequentially to avoid DFX errors)
+		let resolve : (() => void) | undefined;
+		this.currentRun = new Promise<void>((res) => resolve = res);
+		for (let canister of Object.keys(this.canisters)) {
+			let controller = new AbortController();
+			let {signal} = controller;
+			this.controllers.set(canister, controller);
+
+			await promisify(execFile)('dfx', ['canister', 'create', canister], {cwd: rootDir, signal}).catch((error) => {
+				if (error.code === 'ABORT_ERR') {
+					return {stderr: ''};
+				}
+				throw error;
+			});
+
+			this.controllers.delete(canister);
+		}
+
+		resolve?.();
+
+		if (this.aborted) {
+			return;
+		}
+
+		this.currentRun = parallel(os.cpus().length, [...Object.keys(this.canisters)], async (canister) => {
+			let controller = new AbortController();
+			let {signal} = controller;
+			this.controllers.set(canister, controller);
+
+			// build
+			if (this.generator.status !== 'success' || !this.generator.canisters[canister]) {
+				await promisify(execFile)('dfx', ['build', canister], {cwd: rootDir, signal}).catch((error) => {
+					if (error.code === 'ABORT_ERR') {
+						return {stderr: ''};
+					}
+					throw error;
+				});
+			}
+
+			// install
+			await promisify(execFile)('dfx', ['canister', 'install', '--mode=auto', canister], {cwd: rootDir, signal}).catch((error) => {
+				if (error.code === 'ABORT_ERR') {
+					return {stderr: ''};
+				}
+				throw error;
+			});
+
+			this.success += 1;
+			this.controllers.delete(canister);
+			onProgress();
+		});
+
+		await this.currentRun;
+
+		if (!this.aborted) {
+			this.status = 'success';
+		}
+		onProgress();
+	}
+
+	getOutput() : string {
+		let get = (v : number) => v.toString();
+		let count = (this.status === 'running' ? get : chalk.bold[this.errors.length > 0 ? 'redBright' : 'green'])(this.errors.length || this.success);
+
+		if (this.status === 'pending') {
+			return `Deploy: ${chalk.gray('(pending)')}`;
+		}
+		if (this.status === 'running') {
+			return `Deploy: ${count}/${Object.keys(this.canisters).length} ${chalk.gray('(running)')}`;
+		}
+		if (this.status === 'syntax-error') {
+			return `Deploy: ${chalk.gray('(errors)')}`;
+		}
+		if (this.status === 'dfx-error') {
+			return `Deploy: ${chalk.gray('(dfx not running)')}`;
+		}
+
+		return `Deploy: ${count}`;
+	}
+}

package/commands/watch/error-checker.ts

@@ -0,0 +1,87 @@
+import {execFile} from 'node:child_process';
+import {promisify} from 'node:util';
+import os from 'node:os';
+import chalk from 'chalk';
+
+import {getMocPath} from '../../helpers/get-moc-path.js';
+import {getRootDir} from '../../mops.js';
+import {sources} from '../sources.js';
+import {parallel} from '../../parallel.js';
+import {globMoFiles} from './globMoFiles.js';
+
+export class ErrorChecker {
+	verbose = false;
+	canisters : Record<string, string> = {};
+	status : 'pending' | 'running' | 'error' | 'success' = 'pending';
+	errors : string[] = [];
+
+	constructor({verbose, canisters} : {verbose : boolean, canisters : Record<string, string>}) {
+		this.verbose = verbose;
+		this.canisters = canisters;
+	}
+
+	reset() {
+		this.status = 'pending';
+		this.errors = [];
+	}
+
+	async run(onProgress : () => void) {
+		this.reset();
+
+		this.status = 'running';
+		onProgress();
+
+		let rootDir = getRootDir();
+		let mocPath = getMocPath();
+		let deps = await sources({cwd: rootDir});
+
+		let paths = [...Object.values(this.canisters)];
+		if (!paths.length) {
+			paths = globMoFiles(rootDir);
+		}
+
+		await parallel(os.cpus().length, paths, async (file) => {
+			try {
+				await promisify(execFile)(mocPath, ['--check', ...deps.flatMap(x => x.split(' ')), file], {cwd: rootDir});
+			}
+			catch (error : any) {
+				error.message.split('\n').forEach((line : string) => {
+					if (line.match(/: \w+ error \[/)) {
+						// better formatting
+						let str = line
+							.replace(/: (\w+ error) \[/, (_, m1) => `: ${chalk.red(m1)} [`)
+							.replace(/unbound type (\w+)/, `unbound type ${chalk.bold('$1')}`)
+							.replace(/unbound variable (\w+)/, `unbound variable ${chalk.bold('$1')}`)
+							.trim();
+						this.errors.push(str);
+					}
+					else if (line.startsWith('  ') && this.errors.length) {
+						this.errors[this.errors.length - 1] += '\n  ' + line;
+					}
+					else {
+						// console.log('UNKNOWN ERROR', line);
+					}
+				});
+				onProgress();
+			}
+		});
+
+		this.status = this.errors.length ? 'error' : 'success';
+		onProgress();
+	}
+
+	getOutput() : string {
+		if (this.status === 'pending') {
+			return `Errors: ${chalk.gray('(pending)')}`;
+		}
+		if (this.status === 'running') {
+			return `Errors: ${chalk.gray('(running)')}`;
+		}
+		let output = '';
+		output += `Errors: ${chalk.bold[this.errors.length ? 'redBright' : 'green'](this.errors.length)}`;
+		if (this.verbose && this.errors.length) {
+			output += `\n  ${this.errors.join('\n  ')}`;
+		}
+		return output;
+	}
+}

package/commands/watch/generator.ts

@@ -0,0 +1,99 @@
+import os from 'node:os';
+import {promisify} from 'node:util';
+import {execFile} from 'node:child_process';
+import chalk from 'chalk';
+
+import {ErrorChecker} from './error-checker.js';
+import {parallel} from '../../parallel.js';
+import {getRootDir} from '../../mops.js';
+
+export class Generator {
+	verbose = false;
+	canisters : Record<string, string> = {};
+	status : 'pending' | 'running' | 'syntax-error' | 'error' | 'success' = 'pending';
+	errorChecker : ErrorChecker;
+	success = 0;
+	errors : string[] = [];
+	aborted = false;
+	controllers = new Map<string, AbortController>();
+	currentRun : Promise<any> | undefined;
+
+	constructor({verbose, canisters, errorChecker} : {verbose : boolean, canisters : Record<string, string>, errorChecker : ErrorChecker}) {
+		this.verbose = verbose;
+		this.canisters = canisters;
+		this.errorChecker = errorChecker;
+	}
+
+	reset() {
+		this.status = 'pending';
+		this.success = 0;
+		this.errors = [];
+	}
+
+	async abortCurrent() {
+		this.aborted = true;
+		for (let controller of this.controllers.values()) {
+			controller.abort();
+		}
+		this.controllers.clear();
+		await this.currentRun;
+		this.reset();
+		this.aborted = false;
+	}
+
+	async run(onProgress : () => void) {
+		await this.abortCurrent();
+
+		if (this.errorChecker.status === 'error') {
+			this.status = 'syntax-error';
+			onProgress();
+			return;
+		}
+
+		this.status = 'running';
+		onProgress();
+
+		let rootDir = getRootDir();
+
+		this.currentRun = parallel(os.cpus().length, [...Object.keys(this.canisters)], async (canister) => {
+			let controller = new AbortController();
+			let {signal} = controller;
+			this.controllers.set(canister, controller);
+
+			await promisify(execFile)('dfx', ['generate', canister], {cwd: rootDir, signal}).catch((error) => {
+				if (error.code === 'ABORT_ERR') {
+					return {stderr: ''};
+				}
+				throw error;
+			});
+
+			this.success += 1;
+			this.controllers.delete(canister);
+			onProgress();
+		});
+
+		await this.currentRun;
+
+		if (!this.aborted) {
+			this.status = 'success';
+		}
+		onProgress();
+	}
+
+	getOutput() : string {
+		let get = (v : number) => v.toString();
+		let count = (this.status === 'running' ? get : chalk.bold[this.errors.length > 0 ? 'redBright' : 'green'])(this.errors.length || this.success);
+
+		if (this.status === 'pending') {
+			return `Generate: ${chalk.gray('(pending)')}`;
+		}
+		if (this.status === 'running') {
+			return `Generate: ${count}/${Object.keys(this.canisters).length} ${chalk.gray('(running)')}`;
+		}
+		if (this.status === 'syntax-error') {
+			return `Generate: ${chalk.gray('(errors)')}`;
+		}
+
+		return `Generate: ${count}`;
+	}
+}

package/commands/watch/globMoFiles.ts

@@ -0,0 +1,16 @@
+import {globSync} from 'glob';
+
+let globConfig = {
+	nocase: true,
+	ignore: [
+		'**/node_modules/**',
+		'**/.mops/**',
+		'**/.vessel/**',
+		'**/.git/**',
+	],
+};
+
+export function globMoFiles(rootDir : string) {
+	// return globSync('{src,test?(s)}/**/*.mo', {cwd: rootDir, ...globConfig});
+	return globSync('src/**/*.mo', {cwd: rootDir, ...globConfig});
+}

package/commands/watch/parseDfxJson.ts

@@ -0,0 +1,64 @@
+import {existsSync, readFileSync} from 'node:fs';
+import path from 'node:path';
+import {getRootDir} from '../../mops.js';
+
+type DfxConfig = {
+	$schema : string;
+	version : number;
+	canisters : {
+		[key : string] : {
+			type : 'motoko' | 'assets';
+			main ?: string;
+			specified_id ?: string;
+			declarations ?: {
+				output : string;
+				node_compatibility : boolean;
+			};
+			build ?: string[];
+			frontend ?: {
+				entrypoint : string;
+			};
+			source ?: string[];
+			remote ?: {
+				id : {
+					ic : string;
+					staging : string;
+				};
+			};
+		};
+	};
+	defaults : {
+		build : {
+			packtool : string;
+		};
+	};
+	dfx : string;
+	networks : {
+		[key : string] : {
+			type : string;
+			providers : string[];
+		};
+	};
+};
+
+function readDfxJson() : DfxConfig | Record<string, never> {
+	let dfxJsonPath = path.resolve(getRootDir(), 'dfx.json');
+	if (!existsSync(dfxJsonPath)) {
+		return {};
+	}
+	return JSON.parse(readFileSync(dfxJsonPath, 'utf8')) as DfxConfig;
+}
+
+export function getMotokoCanisters() : Record<string, string> {
+	let dfxJson = readDfxJson();
+	return Object.fromEntries(Object.entries(dfxJson.canisters)
+		.filter(([_, canister]) => canister.type === 'motoko')
+		.map(([name, canister]) => [name, canister.main ?? '']));
+}
+
+export function getMotokoCanistersWithDeclarations() : Record<string, string> {
+	let dfxJson = readDfxJson();
+	return Object.fromEntries(Object.entries(dfxJson.canisters)
+		.filter(([_, canister]) => canister.type === 'motoko' && canister.declarations)
+		.map(([name, canister]) => [name, canister.main ?? '']));
+}

package/commands/watch/tester.ts

@@ -0,0 +1,81 @@
+import chalk from 'chalk';
+import {readConfig} from '../../mops.js';
+import {ErrorChecker} from './error-checker.js';
+import {testWithReporter} from '../test/test.js';
+import {SilentReporter} from '../test/reporters/silent-reporter.js';
+
+export class Tester {
+	verbose = false;
+	status : 'pending' | 'running' | 'syntax-error' | 'error' | 'success' = 'pending';
+	errorChecker : ErrorChecker;
+	reporter = new SilentReporter(false);
+	aborted = false;
+	controller = new AbortController();
+	currentRun : Promise<any> | undefined;
+
+	constructor({verbose, errorChecker} : {verbose : boolean, errorChecker : ErrorChecker}) {
+		this.verbose = verbose;
+		this.errorChecker = errorChecker;
+	}
+
+	reset() {
+		this.status = 'pending';
+	}
+
+	async abortCurrent() {
+		this.aborted = true;
+		this.controller.abort();
+		await this.currentRun;
+		this.reset();
+		this.aborted = false;
+	}
+
+	async run(onProgress : () => void) {
+		await this.abortCurrent();
+
+		if (this.errorChecker.status === 'error') {
+			this.status = 'syntax-error';
+			onProgress();
+			return;
+		}
+
+		this.status = 'running';
+		onProgress();
+
+		this.reporter = new SilentReporter(false, onProgress);
+		this.controller = new AbortController();
+
+		let config = readConfig();
+
+		this.currentRun = testWithReporter(this.reporter, '', 'interpreter', config.toolchain?.['pocket-ic'] ? 'pocket-ic' : 'dfx', true, this.controller.signal);
+		await this.currentRun;
+
+		if (!this.aborted) {
+			this.status = this.reporter.failed > 0 ? 'error' : 'success';
+		}
+
+		onProgress();
+	}
+
+	getOutput() : string {
+		let get = (v : number) => v.toString();
+		let count = (this.status === 'running' ? get : chalk.bold[this.reporter.failed > 0 ? 'redBright' : 'green'])(this.reporter.failedFiles || this.reporter.passedFiles);
+
+		if (this.status === 'pending') {
+			return `Tests: ${chalk.gray('(pending)')}`;
+		}
+		if (this.status === 'running') {
+			return `Tests: ${count}/${this.reporter.total} ${chalk.gray('(running)')}`;
+		}
+		if (this.status === 'syntax-error') {
+			return `Tests: ${chalk.gray('(errors)')}`;
+		}
+
+		let output = '';
+		output += `Tests: ${count}`;
+		if (this.reporter.errorOutput) {
+			output += '\n' + this.reporter.errorOutput;
+		}
+		return output;
+	}
+}

package/commands/watch/warning-checker.ts

@@ -0,0 +1,133 @@
+import {execFile} from 'node:child_process';
+import {promisify} from 'node:util';
+import os from 'node:os';
+import chalk from 'chalk';
+
+import {getMocPath} from '../../helpers/get-moc-path.js';
+import {getRootDir} from '../../mops.js';
+import {sources} from '../sources.js';
+import {ErrorChecker} from './error-checker.js';
+import {parallel} from '../../parallel.js';
+import {globMoFiles} from './globMoFiles.js';
+
+export class WarningChecker {
+	verbose = false;
+	canisters : Record<string, string> = {};
+	status : 'pending' | 'running' | 'syntax-error' | 'error' | 'success' = 'pending';
+	warnings : string[] = [];
+	errorChecker : ErrorChecker;
+	aborted = false;
+	controllers = new Map<string, AbortController>();
+	currentRun : Promise<any> | undefined;
+
+	constructor({verbose, canisters, errorChecker} : {verbose : boolean, canisters : Record<string, string>, errorChecker : ErrorChecker}) {
+		this.verbose = verbose;
+		this.canisters = canisters;
+		this.errorChecker = errorChecker;
+	}
+
+	reset() {
+		this.status = 'pending';
+		this.warnings = [];
+	}
+
+	async abortCurrent() {
+		this.aborted = true;
+		for (let controller of this.controllers.values()) {
+			controller.abort();
+		}
+		this.controllers.clear();
+		await this.currentRun;
+		this.reset();
+		this.aborted = false;
+	}
+
+	async run(onProgress : () => void) {
+		await this.abortCurrent();
+
+		if (this.errorChecker.status === 'error') {
+			this.status = 'syntax-error';
+			onProgress();
+			return;
+		}
+
+		this.status = 'running';
+		onProgress();
+
+		let rootDir = getRootDir();
+		let mocPath = getMocPath();
+		let deps = await sources({cwd: rootDir});
+
+		let paths = [...Object.values(this.canisters)];
+		if (!paths.length) {
+			paths = globMoFiles(rootDir);
+		}
+
+		this.currentRun = parallel(os.cpus().length, paths, async (file) => {
+			let controller = new AbortController();
+			let {signal} = controller;
+			this.controllers.set(file, controller);
+
+			let {stderr} = await promisify(execFile)(mocPath, ['--check', ...deps.flatMap(x => x.split(' ')), file], {cwd: rootDir, signal}).catch((error) => {
+				if (error.code === 'ABORT_ERR') {
+					return {stderr: ''};
+				}
+				throw error;
+			});
+
+			if (stderr) {
+				stderr.split('\n').forEach((line) => {
+					// ignore deps warnings
+					if (line.startsWith('.mops/')) {
+						return;
+					}
+					else if (line.includes(': warning [')) {
+						// better formatting
+						let str = line
+							.replace(': warning [', `: ${chalk.yellow('warning')} [`)
+							.replace(/unused field (\w+)/, `unused field ${chalk.bold('$1')}`)
+							.replace(/unused identifier (\w+)/, `unused identifier ${chalk.bold('$1')}`)
+							.trim();
+						this.warnings.push(str);
+					}
+					else if (line.startsWith('  ') && this.warnings.length) {
+						this.warnings[this.warnings.length - 1] += '\n  ' + line;
+					}
+					else {
+						// console.log('UNKNOWN WARNING', line);
+					}
+				});
+				onProgress();
+			}
+
+			this.controllers.delete(file);
+		});
+
+		await this.currentRun;
+
+		if (!this.aborted) {
+			this.status = this.warnings.length ? 'error' : 'success';
+		}
+
+		onProgress();
+	}
+
+	getOutput() : string {
+		if (this.status === 'pending') {
+			return `Warnings: ${chalk.gray('(pending)')}`;
+		}
+		if (this.status === 'running') {
+			return `Warnings: ${chalk.gray('(running)')}`;
+		}
+		if (this.status === 'syntax-error') {
+			return `Warnings: ${chalk.gray('(errors)')}`;
+		}
+
+		let output = '';
+		output += `Warnings: ${chalk.bold[this.warnings.length ? 'yellowBright' : 'green'](this.warnings.length)}`;
+		if (this.verbose && this.warnings.length) {
+			output += `\n  ${this.warnings.join('\n  ')}`;
+		}
+		return output;
+	}
+}