ic-mops 1.0.1 → 1.1.0

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;
+}

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

@@ -0,0 +1,111 @@
+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 WarningChecker {
+    constructor({ verbose, canisters, errorChecker }) {
+        this.verbose = false;
+        this.canisters = {};
+        this.status = 'pending';
+        this.warnings = [];
+        this.aborted = false;
+        this.controllers = new Map();
+        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) {
+        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() {
+        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;
+    }
+}

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

@@ -0,0 +1,7 @@
+export declare function watch(options: {
+    error: boolean;
+    warning: boolean;
+    test: boolean;
+    generate: boolean;
+    deploy: boolean;
+}): Promise<void>;

package/dist/commands/watch/watch.js

@@ -0,0 +1,79 @@
+import chokidar from 'chokidar';
+import path from 'node:path';
+import debounce from 'debounce';
+import chalk from 'chalk';
+import { ErrorChecker } from './error-checker.js';
+import { WarningChecker } from './warning-checker.js';
+import { getMotokoCanisters, getMotokoCanistersWithDeclarations } from './parseDfxJson.js';
+import { getRootDir } from '../../mops.js';
+import { Tester } from './tester.js';
+import { Generator } from './generator.js';
+import { Deployer } from './deployer.js';
+let ignore = [
+    '**/node_modules/**',
+    '**/.mops/**',
+    '**/.vessel/**',
+    '**/.git/**',
+];
+export async function watch(options) {
+    let hasOptions = Object.values(options).includes(true);
+    if (!hasOptions) {
+        options = {
+            error: true,
+            warning: true,
+            test: true,
+            generate: true,
+            deploy: true,
+        };
+    }
+    options.error = true;
+    let rootDir = getRootDir();
+    let canisters = getMotokoCanisters();
+    let canistersWithDeclarations = getMotokoCanistersWithDeclarations();
+    let errorChecker = new ErrorChecker({ verbose: true, canisters: canisters });
+    let warningChecker = new WarningChecker({ errorChecker, verbose: true, canisters: canisters });
+    let tester = new Tester({ errorChecker, verbose: true });
+    let generator = new Generator({ errorChecker, verbose: true, canisters: canistersWithDeclarations });
+    let deployer = new Deployer({ errorChecker, generator, verbose: true, canisters: canisters });
+    let watcher = chokidar.watch([
+        path.join(rootDir, '**/*.mo'),
+        path.join(rootDir, 'mops.toml'),
+    ], {
+        ignored: ignore,
+        ignoreInitial: true,
+    });
+    let run = debounce(async () => {
+        errorChecker.reset();
+        warningChecker.reset();
+        tester.reset();
+        generator.reset();
+        deployer.reset();
+        options.error && await errorChecker.run(print);
+        options.warning && warningChecker.run(print);
+        options.test && tester.run(print);
+        options.generate && await generator.run(print);
+        options.deploy && deployer.run(print);
+    }, 200);
+    let print = () => {
+        console.clear();
+        process.stdout.write('\x1Bc');
+        options.error && console.log(errorChecker.getOutput());
+        options.warning && console.log(warningChecker.getOutput());
+        options.test && console.log(tester.getOutput());
+        options.generate && console.log(generator.getOutput());
+        options.deploy && console.log(deployer.getOutput());
+        let statuses = [];
+        options.error && statuses.push(errorChecker.status);
+        options.warning && statuses.push(warningChecker.status);
+        options.test && statuses.push(tester.status);
+        options.generate && statuses.push(generator.status);
+        options.deploy && statuses.push(deployer.status);
+        if (statuses.every(status => status !== 'pending' && status !== 'running')) {
+            console.log(chalk.dim('-'.repeat(50)));
+            console.log(chalk.dim('Waiting for file changes...'));
+            console.log(chalk.dim(`Press ${chalk.bold('Ctrl+C')} to exit.`));
+        }
+    };
+    watcher.on('all', run);
+    run();
+}

package/dist/declarations/main/main.did

@@ -91,13 +91,13 @@ type Result_6 =
    err: Err;
    ok: vec record {
              PackageName;
-             PackageVersion;
+             PackageVersion__1;
            };
  };
 type Result_5 = 
  variant {
    err: Err;
-   ok: PackageVersion;
+   ok: PackageVersion__1;
  };
 type Result_4 = 
  variant {
@@ -147,6 +147,7 @@ type Request =
  };
 type PublishingId = text;
 type PageCount = nat;
+type PackageVersion__1 = text;
 type PackageVersion = text;
 type PackageSummary__1 = 
  record {
@@ -155,6 +156,7 @@ type PackageSummary__1 =
    downloadsInLast30Days: nat;
    downloadsInLast7Days: nat;
    downloadsTotal: nat;
+   highestVersion: PackageVersion;
    owner: principal;
    ownerInfo: User;
    publication: PackagePublication;
@@ -168,6 +170,7 @@ type PackageSummaryWithChanges__1 =
    downloadsInLast30Days: nat;
    downloadsInLast7Days: nat;
    downloadsTotal: nat;
+   highestVersion: PackageVersion;
    owner: principal;
    ownerInfo: User;
    publication: PackagePublication;
@@ -181,6 +184,7 @@ type PackageSummaryWithChanges =
    downloadsInLast30Days: nat;
    downloadsInLast7Days: nat;
    downloadsTotal: nat;
+   highestVersion: PackageVersion;
    owner: principal;
    ownerInfo: User;
    publication: PackagePublication;
@@ -193,6 +197,7 @@ type PackageSummary =
    downloadsInLast30Days: nat;
    downloadsInLast7Days: nat;
    downloadsTotal: nat;
+   highestVersion: PackageVersion;
    owner: principal;
    ownerInfo: User;
    publication: PackagePublication;
@@ -237,6 +242,7 @@ type PackageDetails =
    downloadsInLast7Days: nat;
    downloadsTotal: nat;
    fileStats: PackageFileStatsPublic;
+   highestVersion: PackageVersion;
    owner: principal;
    ownerInfo: User;
    publication: PackagePublication;
@@ -303,13 +309,13 @@ type Main =
    getDefaultPackages: (text) ->
     (vec record {
            PackageName;
-           PackageVersion;
+           PackageVersion__1;
          }) query;
    getDownloadTrendByPackageId: (PackageId) ->
     (vec DownloadsSnapshot__1) query;
    getDownloadTrendByPackageName: (PackageName) ->
     (vec DownloadsSnapshot__1) query;
-   getFileHashes: (PackageName, PackageVersion) -> (Result_8);
+   getFileHashes: (PackageName, PackageVersion__1) -> (Result_8);
    getFileHashesByPackageIds: (vec PackageId) ->
     (vec record {
            PackageId;
@@ -318,19 +324,19 @@ type Main =
                  blob;
                };
          });
-   getFileHashesQuery: (PackageName, PackageVersion) -> (Result_8) query;
-   getFileIds: (PackageName, PackageVersion) -> (Result_7) query;
+   getFileHashesQuery: (PackageName, PackageVersion__1) -> (Result_8) query;
+   getFileIds: (PackageName, PackageVersion__1) -> (Result_7) query;
    getHighestSemverBatch:
     (vec record {
            PackageName;
-           PackageVersion;
+           PackageVersion__1;
            SemverPart;
          }) -> (Result_6) query;
    getHighestVersion: (PackageName) -> (Result_5) query;
    getMostDownloadedPackages: () -> (vec PackageSummary) query;
    getMostDownloadedPackagesIn7Days: () -> (vec PackageSummary) query;
    getNewPackages: () -> (vec PackageSummary) query;
-   getPackageDetails: (PackageName, PackageVersion) -> (Result_4) query;
+   getPackageDetails: (PackageName, PackageVersion__1) -> (Result_4) query;
    getPackagesByCategory: () -> (vec record {
                                        text;
                                        vec PackageSummary;
@@ -344,10 +350,10 @@ type Main =
    getTotalPackages: () -> (nat) query;
    getUser: (principal) -> (opt User__1) query;
    http_request: (Request) -> (Response) query;
-   notifyInstall: (PackageName, PackageVersion) -> () oneway;
+   notifyInstall: (PackageName, PackageVersion__1) -> () oneway;
    notifyInstalls: (vec record {
                           PackageName;
-                          PackageVersion;
+                          PackageVersion__1;
                         }) -> () oneway;
    restore: (nat) -> ();
    search: (Text, opt nat, opt nat) -> (vec PackageSummary, PageCount) query;