ic-mops 1.1.0-pre.0 → 1.1.1

package/dist/commands/test/test.js

@@ -59,13 +59,22 @@ export async function test(filter = '', options = {}) {
                     process.exit(0);
                 });
             }
+            else {
+                process.exit(0);
+            }
         });
         // todo: run only changed for *.test.mo?
         // todo: run all for *.mo?
+        let curRun = Promise.resolve(true);
+        let controller = new AbortController();
         let run = debounce(async () => {
+            controller.abort();
+            await curRun;
             console.clear();
             process.stdout.write('\x1Bc');
-            await runAll(options.reporter, filter, options.mode, replicaType, true);
+            controller = new AbortController();
+            curRun = runAll(options.reporter, filter, options.mode, replicaType, true, controller.signal);
+            await curRun;
             console.log('-'.repeat(50));
             console.log('Waiting for file changes...');
             console.log(chalk.gray((`Press ${chalk.gray('Ctrl+C')} to exit.`)));
@@ -91,11 +100,11 @@ export async function test(filter = '', options = {}) {
 }
 let mocPath = '';
 let wasmtimePath = '';
-async function runAll(reporterName, filter = '', mode = 'interpreter', replicaType, watch = false) {
-    let done = await testWithReporter(reporterName, filter, mode, replicaType, watch);
+async function runAll(reporterName, filter = '', mode = 'interpreter', replicaType, watch = false, signal) {
+    let done = await testWithReporter(reporterName, filter, mode, replicaType, watch, signal);
     return done;
 }
-export async function testWithReporter(reporterName, filter = '', defaultMode = 'interpreter', replicaType, watch = false) {
+export async function testWithReporter(reporterName, filter = '', defaultMode = 'interpreter', replicaType, watch = false, signal) {
     let rootDir = getRootDir();
     let files = [];
     let libFiles = globSync('**/test?(s)/lib.mo', globConfig);
@@ -149,6 +158,9 @@ export async function testWithReporter(reporterName, filter = '', defaultMode =
     replica.dir = testTempDir;
     fs.mkdirSync(testTempDir, { recursive: true });
     await parallel(os.cpus().length, files, async (file) => {
+        if (signal?.aborted) {
+            return;
+        }
         let mmf = new MMF1('store', absToRel(file));
         // mode overrides
         let lines = fs.readFileSync(file, 'utf8').split('\n');
@@ -175,14 +187,26 @@ export async function testWithReporter(reporterName, filter = '', defaultMode =
             let mocArgs = ['--hide-warnings', '--error-detail=2', ...sourcesArr.join(' ').split(' '), file].filter(x => x);
             // interpret
             if (mode === 'interpreter') {
-                let proc = spawn(mocPath, ['-r', '-ref-system-api', ...mocArgs]);
+                let proc = spawn(mocPath, ['-r', '-ref-system-api', ...mocArgs], { signal });
+                proc.addListener('error', (error) => {
+                    if (error?.code === 'ABORT_ERR') {
+                        return;
+                    }
+                    throw error;
+                });
                 pipeMMF(proc, mmf).then(resolve);
             }
             // build and run wasm
             else if (mode === 'wasi') {
                 let wasmFile = `${path.join(testTempDir, path.parse(file).name)}.wasm`;
                 // build
-                let buildProc = spawn(mocPath, [`-o=${wasmFile}`, '-wasi-system-api', ...mocArgs]);
+                let buildProc = spawn(mocPath, [`-o=${wasmFile}`, '-wasi-system-api', ...mocArgs], { signal });
+                buildProc.addListener('error', (error) => {
+                    if (error?.code === 'ABORT_ERR') {
+                        return;
+                    }
+                    throw error;
+                });
                 pipeMMF(buildProc, mmf).then(async () => {
                     if (mmf.failed > 0) {
                         return;
@@ -204,7 +228,13 @@ export async function testWithReporter(reporterName, filter = '', defaultMode =
                         console.error(chalk.red('Minimum wasmtime version is 14.0.0. Please update wasmtime to the latest version'));
                         process.exit(1);
                     }
-                    let proc = spawn(wasmtimePath, wasmtimeArgs);
+                    let proc = spawn(wasmtimePath, wasmtimeArgs, { signal });
+                    proc.addListener('error', (error) => {
+                        if (error?.code === 'ABORT_ERR') {
+                            return;
+                        }
+                        throw error;
+                    });
                     await pipeMMF(proc, mmf);
                 }).finally(() => {
                     fs.rmSync(wasmFile, { force: true });
@@ -215,18 +245,30 @@ export async function testWithReporter(reporterName, filter = '', defaultMode =
                 // mmf.strategy = 'print'; // because we run replica tests one-by-one
                 let wasmFile = `${path.join(testTempDir, path.parse(file).name)}.wasm`;
                 // build
-                let buildProc = spawn(mocPath, [`-o=${wasmFile}`, ...mocArgs]);
+                let buildProc = spawn(mocPath, [`-o=${wasmFile}`, ...mocArgs], { signal });
+                buildProc.addListener('error', (error) => {
+                    if (error?.code === 'ABORT_ERR') {
+                        return;
+                    }
+                    throw error;
+                });
                 pipeMMF(buildProc, mmf).then(async () => {
                     if (mmf.failed > 0) {
                         return;
                     }
                     await startReplicaOnce(replica, replicaType);
+                    if (signal?.aborted) {
+                        return;
+                    }
                     let canisterName = path.parse(file).name;
                     let idlFactory = ({ IDL }) => {
                         return IDL.Service({ 'runTests': IDL.Func([], [], []) });
                     };
-                    let { stream } = await replica.deploy(canisterName, wasmFile, idlFactory);
-                    pipeStdoutToMMF(stream, mmf);
+                    let canister = await replica.deploy(canisterName, wasmFile, idlFactory, undefined, signal);
+                    if (signal?.aborted || !canister) {
+                        return;
+                    }
+                    pipeStdoutToMMF(canister.stream, mmf);
                     let actor = await replica.getActor(canisterName);
                     try {
                         if (globalThis.mopsReplicaTestRunning) {
@@ -239,6 +281,9 @@ export async function testWithReporter(reporterName, filter = '', defaultMode =
                                 }, Math.random() * 1000 | 0);
                             });
                         }
+                        if (signal?.aborted) {
+                            return;
+                        }
                         globalThis.mopsReplicaTestRunning = true;
                         await actor.runTests();
                         globalThis.mopsReplicaTestRunning = false;
@@ -250,10 +295,14 @@ export async function testWithReporter(reporterName, filter = '', defaultMode =
                         stderrStream.write(e.message);
                     }
                 }).finally(async () => {
+                    globalThis.mopsReplicaTestRunning = false;
                     fs.rmSync(wasmFile, { force: true });
                 }).then(resolve);
             }
         });
+        if (signal?.aborted) {
+            return;
+        }
         reporter.addRun(file, mmf, promise, mode);
         await promise;
     });
@@ -261,6 +310,9 @@ export async function testWithReporter(reporterName, filter = '', defaultMode =
         await replica.stop();
         fs.rmSync(testTempDir, { recursive: true, force: true });
     }
+    if (signal?.aborted) {
+        return false;
+    }
     return reporter.done();
 }
 function pipeStdoutToMMF(stdout, mmf) {

package/dist/commands/watch/deployer.d.ts

@@ -0,0 +1,24 @@
+import { ErrorChecker } from './error-checker.js';
+import { Generator } from './generator.js';
+export declare class Deployer {
+    verbose: boolean;
+    canisters: Record<string, string>;
+    status: 'pending' | 'running' | 'syntax-error' | 'dfx-error' | 'error' | 'success';
+    errorChecker: ErrorChecker;
+    generator: Generator;
+    success: number;
+    errors: string[];
+    aborted: boolean;
+    controllers: Map<string, AbortController>;
+    currentRun: Promise<any> | undefined;
+    constructor({ verbose, canisters, errorChecker, generator }: {
+        verbose: boolean;
+        canisters: Record<string, string>;
+        errorChecker: ErrorChecker;
+        generator: Generator;
+    });
+    reset(): void;
+    abortCurrent(): Promise<void>;
+    run(onProgress: () => void): Promise<void>;
+    getOutput(): string;
+}

package/dist/commands/watch/deployer.js

@@ -0,0 +1,125 @@
+import chalk from 'chalk';
+import os from 'node:os';
+import { promisify } from 'node:util';
+import { execFile, execSync } from 'node:child_process';
+import { parallel } from '../../parallel.js';
+import { getRootDir } from '../../mops.js';
+export class Deployer {
+    constructor({ verbose, canisters, errorChecker, generator }) {
+        this.verbose = false;
+        this.canisters = {};
+        this.status = 'pending';
+        this.success = 0;
+        this.errors = [];
+        this.aborted = false;
+        this.controllers = new Map();
+        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) {
+        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;
+        this.currentRun = new Promise((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', '--yes', 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() {
+        let get = (v) => 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/dist/commands/watch/error-checker.d.ts

@@ -0,0 +1,13 @@
+export declare class ErrorChecker {
+    verbose: boolean;
+    canisters: Record<string, string>;
+    status: 'pending' | 'running' | 'error' | 'success';
+    errors: string[];
+    constructor({ verbose, canisters }: {
+        verbose: boolean;
+        canisters: Record<string, string>;
+    });
+    reset(): void;
+    run(onProgress: () => void): Promise<void>;
+    getOutput(): string;
+}

package/dist/commands/watch/error-checker.js

@@ -0,0 +1,76 @@
+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 {
+    constructor({ verbose, canisters }) {
+        this.verbose = false;
+        this.canisters = {};
+        this.status = 'pending';
+        this.errors = [];
+        this.verbose = verbose;
+        this.canisters = canisters;
+    }
+    reset() {
+        this.status = 'pending';
+        this.errors = [];
+    }
+    async run(onProgress) {
+        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) {
+                error.message.split('\n').forEach((line) => {
+                    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() {
+        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/dist/commands/watch/generator.d.ts

@@ -0,0 +1,21 @@
+import { ErrorChecker } from './error-checker.js';
+export declare class Generator {
+    verbose: boolean;
+    canisters: Record<string, string>;
+    status: 'pending' | 'running' | 'syntax-error' | 'error' | 'success';
+    errorChecker: ErrorChecker;
+    success: number;
+    errors: string[];
+    aborted: boolean;
+    controllers: Map<string, AbortController>;
+    currentRun: Promise<any> | undefined;
+    constructor({ verbose, canisters, errorChecker }: {
+        verbose: boolean;
+        canisters: Record<string, string>;
+        errorChecker: ErrorChecker;
+    });
+    reset(): void;
+    abortCurrent(): Promise<void>;
+    run(onProgress: () => void): Promise<void>;
+    getOutput(): string;
+}

package/dist/commands/watch/generator.js

@@ -0,0 +1,79 @@
+import os from 'node:os';
+import { promisify } from 'node:util';
+import { execFile } from 'node:child_process';
+import chalk from 'chalk';
+import { parallel } from '../../parallel.js';
+import { getRootDir } from '../../mops.js';
+export class Generator {
+    constructor({ verbose, canisters, errorChecker }) {
+        this.verbose = false;
+        this.canisters = {};
+        this.status = 'pending';
+        this.success = 0;
+        this.errors = [];
+        this.aborted = false;
+        this.controllers = new Map();
+        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) {
+        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() {
+        let get = (v) => 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/dist/commands/watch/globMoFiles.d.ts

@@ -0,0 +1 @@
+export declare function globMoFiles(rootDir: string): string[];

package/dist/commands/watch/globMoFiles.js

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

package/dist/commands/watch/parseDfxJson.d.ts

@@ -0,0 +1,2 @@
+export declare function getMotokoCanisters(): Record<string, string>;
+export declare function getMotokoCanistersWithDeclarations(): Record<string, string>;

package/dist/commands/watch/parseDfxJson.js

@@ -0,0 +1,22 @@
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { getRootDir } from '../../mops.js';
+function readDfxJson() {
+    let dfxJsonPath = path.resolve(getRootDir(), 'dfx.json');
+    if (!existsSync(dfxJsonPath)) {
+        return {};
+    }
+    return JSON.parse(readFileSync(dfxJsonPath, 'utf8'));
+}
+export function getMotokoCanisters() {
+    let dfxJson = readDfxJson();
+    return Object.fromEntries(Object.entries(dfxJson.canisters)
+        .filter(([_, canister]) => canister.type === 'motoko')
+        .map(([name, canister]) => [name, canister.main ?? '']));
+}
+export function getMotokoCanistersWithDeclarations() {
+    let dfxJson = readDfxJson();
+    return Object.fromEntries(Object.entries(dfxJson.canisters)
+        .filter(([_, canister]) => canister.type === 'motoko' && canister.declarations)
+        .map(([name, canister]) => [name, canister.main ?? '']));
+}

package/dist/commands/watch/tester.d.ts

@@ -0,0 +1,19 @@
+import { ErrorChecker } from './error-checker.js';
+import { SilentReporter } from '../test/reporters/silent-reporter.js';
+export declare class Tester {
+    verbose: boolean;
+    status: 'pending' | 'running' | 'syntax-error' | 'error' | 'success';
+    errorChecker: ErrorChecker;
+    reporter: SilentReporter;
+    aborted: boolean;
+    controller: AbortController;
+    currentRun: Promise<any> | undefined;
+    constructor({ verbose, errorChecker }: {
+        verbose: boolean;
+        errorChecker: ErrorChecker;
+    });
+    reset(): void;
+    abortCurrent(): Promise<void>;
+    run(onProgress: () => void): Promise<void>;
+    getOutput(): string;
+}

package/dist/commands/watch/tester.js

@@ -0,0 +1,63 @@
+import chalk from 'chalk';
+import { readConfig } from '../../mops.js';
+import { testWithReporter } from '../test/test.js';
+import { SilentReporter } from '../test/reporters/silent-reporter.js';
+export class Tester {
+    constructor({ verbose, errorChecker }) {
+        this.verbose = false;
+        this.status = 'pending';
+        this.reporter = new SilentReporter(false);
+        this.aborted = false;
+        this.controller = new AbortController();
+        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) {
+        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() {
+        let get = (v) => 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/dist/commands/watch/warning-checker.d.ts

@@ -0,0 +1,20 @@
+import { ErrorChecker } from './error-checker.js';
+export declare class WarningChecker {
+    verbose: boolean;
+    canisters: Record<string, string>;
+    status: 'pending' | 'running' | 'syntax-error' | 'error' | 'success';
+    warnings: string[];
+    errorChecker: ErrorChecker;
+    aborted: boolean;
+    controllers: Map<string, AbortController>;
+    currentRun: Promise<any> | undefined;
+    constructor({ verbose, canisters, errorChecker }: {
+        verbose: boolean;
+        canisters: Record<string, string>;
+        errorChecker: ErrorChecker;
+    });
+    reset(): void;
+    abortCurrent(): Promise<void>;
+    run(onProgress: () => void): Promise<void>;
+    getOutput(): string;
+}