ic-mops 0.19.0 → 0.20.0

package/dist/commands/sources.js

@@ -0,0 +1,124 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import chalk from 'chalk';
+import { checkConfigFile, formatDir, formatGithubDir, parseGithubURL, readConfig } from '../mops.js';
+import { readVesselConfig } from '../vessel.js';
+// TODO: resolve conflicts
+export async function sources({ verbose = false } = {}) {
+    if (!checkConfigFile()) {
+        return [];
+    }
+    let packages = {};
+    let versions = {};
+    let compareVersions = (a = '0.0.0', b = '0.0.0') => {
+        let ap = a.split('.').map((x) => parseInt(x));
+        let bp = b.split('.').map((x) => parseInt(x));
+        if (ap[0] - bp[0]) {
+            return Math.sign(ap[0] - bp[0]);
+        }
+        if (ap[0] === bp[0] && ap[1] - bp[1]) {
+            return Math.sign(ap[1] - bp[1]);
+        }
+        if (ap[0] === bp[0] && ap[1] === bp[1] && ap[2] - bp[2]) {
+            return Math.sign(ap[2] - bp[2]);
+        }
+        return 0;
+    };
+    const gitVerRegex = new RegExp(/v(\d{1,2}\.\d{1,2}\.\d{1,2})(-.*)?$/);
+    const compareGitVersions = (repoA, repoB) => {
+        const { branch: a } = parseGithubURL(repoA);
+        const { branch: b } = parseGithubURL(repoB);
+        if (gitVerRegex.test(a) && gitVerRegex.test(b)) {
+            return compareVersions(a.substring(1), b.substring(1));
+        }
+        else if (!gitVerRegex.test(a)) {
+            return -1;
+        }
+        else {
+            return 1;
+        }
+    };
+    let collectDeps = async (config, isRoot = false) => {
+        let allDeps = [...Object.values(config.dependencies || {})];
+        if (isRoot) {
+            allDeps = [...allDeps, ...Object.values(config['dev-dependencies'] || {})];
+        }
+        for (const pkgDetails of allDeps) {
+            const { name, repo, version } = pkgDetails;
+            // take root dep version or bigger one
+            if (isRoot
+                || !packages[name]
+                || !packages[name]?.isRoot
+                    && (repo && packages[name]?.repo && compareGitVersions(packages[name]?.repo || '', repo) === -1
+                        || compareVersions(packages[name]?.version, version) === -1)) {
+                packages[name] = {
+                    ...pkgDetails,
+                    isRoot,
+                };
+            }
+            let nestedConfig;
+            if (repo) {
+                const dir = formatGithubDir(name, repo);
+                nestedConfig = await readVesselConfig(dir) || {};
+            }
+            else if (!pkgDetails.path && version) {
+                const file = formatDir(name, version) + '/mops.toml';
+                nestedConfig = readConfig(file);
+            }
+            if (nestedConfig && !pkgDetails.path) {
+                await collectDeps(nestedConfig);
+            }
+            if (!versions[name]) {
+                versions[name] = [];
+            }
+            if (repo) {
+                const { branch } = parseGithubURL(repo);
+                versions[name]?.push(branch);
+            }
+            else if (version) {
+                versions[name]?.push(version);
+            }
+        }
+    };
+    let config = readConfig();
+    await collectDeps(config, true);
+    // show conflicts
+    if (verbose) {
+        for (let [dep, vers] of Object.entries(versions)) {
+            if (vers.length > 1) {
+                console.log(chalk.yellow('WARN:'), `Conflicting package versions "${dep}" - ${vers.join(', ')}`);
+            }
+        }
+    }
+    // sources
+    return Object.entries(packages).map(([name, pkg]) => {
+        let pkgDir;
+        if (pkg.path) {
+            pkgDir = path.relative(process.cwd(), path.resolve(pkg.path));
+            pkgDir = pkgDir.replaceAll('{MOPS_ENV}', process.env.MOPS_ENV || 'local');
+        }
+        else if (pkg.repo) {
+            pkgDir = path.relative(process.cwd(), formatGithubDir(name, pkg.repo));
+        }
+        else if (pkg.version) {
+            pkgDir = path.relative(process.cwd(), formatDir(name, pkg.version));
+        }
+        else {
+            return;
+        }
+        // append baseDir
+        let pkgBaseDir;
+        if (fs.existsSync(path.join(pkgDir, 'mops.toml'))) {
+            let config = readConfig(path.join(pkgDir, 'mops.toml'));
+            pkgBaseDir = path.join(pkgDir, config.package?.baseDir || 'src');
+        }
+        else {
+            pkgBaseDir = path.join(pkgDir, 'src');
+        }
+        // use pkgDir if baseDir doesn't exist for local packages
+        if (pkg.path && !fs.existsSync(pkgBaseDir)) {
+            pkgBaseDir = pkgDir;
+        }
+        return `--package ${name} ${pkgBaseDir}`;
+    });
+}

package/dist/commands/template.d.ts

@@ -0,0 +1 @@
+export declare function template(): Promise<void>;

package/dist/commands/template.js

@@ -0,0 +1,28 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import chalk from 'chalk';
+import prompts from 'prompts';
+import { getRootDir } from '../mops.js';
+export async function template() {
+    let res = await prompts({
+        type: 'select',
+        name: 'value',
+        message: 'Select template:',
+        choices: [
+            { title: 'GitHub Workflow to run \'mops test\'', value: 'github-workflow:mops-test' },
+            { title: '× Cancel', value: '' },
+        ],
+        initial: 0,
+    });
+    if (res.value === 'github-workflow:mops-test') {
+        let dest = path.resolve(getRootDir(), '.github/workflows/mops-test.yml');
+        if (fs.existsSync(dest)) {
+            console.log(chalk.yellow('Workflow already exists:'), dest);
+            return;
+        }
+        let mopsTestYml = new URL('../templates/mops-test.yml', import.meta.url);
+        fs.mkdirSync(path.resolve(getRootDir(), '.github/workflows'), { recursive: true });
+        fs.copyFileSync(mopsTestYml, dest);
+        console.log(chalk.green('Workflow created:'), dest);
+    }
+}

package/dist/commands/test.d.ts

@@ -0,0 +1,4 @@
+export declare function test(filter?: string, { watch }?: {
+    watch?: boolean | undefined;
+}): Promise<void>;
+export declare function runAll(filter?: string): Promise<boolean | undefined>;

package/dist/commands/test.js

@@ -0,0 +1,201 @@
+import { spawn, execSync } from 'node:child_process';
+import path from 'node:path';
+import fs from 'node:fs';
+import os from 'node:os';
+import chalk from 'chalk';
+import { globSync } from 'glob';
+import chokidar from 'chokidar';
+import debounce from 'debounce';
+import { MMF1 } from './mmf1.js';
+import { sources } from './sources.js';
+import { getRootDir } from '../mops.js';
+import { parallel } from '../parallel.js';
+let ignore = [
+    '**/node_modules/**',
+    '**/.mops/**',
+    '**/.vessel/**',
+    '**/.git/**',
+];
+let globConfig = {
+    nocase: true,
+    ignore: ignore,
+};
+export async function test(filter = '', { watch = false } = {}) {
+    let rootDir = getRootDir();
+    if (watch) {
+        // todo: run only changed for *.test.mo?
+        // todo: run all for *.mo?
+        let run = debounce(async () => {
+            console.clear();
+            process.stdout.write('\x1Bc');
+            await runAll(filter);
+            console.log('-'.repeat(50));
+            console.log('Waiting for file changes...');
+            console.log(chalk.gray((`Press ${chalk.gray('Ctrl+C')} to exit.`)));
+        }, 200);
+        let watcher = chokidar.watch([
+            path.join(rootDir, '**/*.mo'),
+            path.join(rootDir, 'mops.toml'),
+        ], {
+            ignored: ignore,
+            ignoreInitial: true,
+        });
+        watcher.on('all', () => {
+            run();
+        });
+        run();
+    }
+    else {
+        let passed = await runAll(filter);
+        if (!passed) {
+            process.exit(1);
+        }
+    }
+}
+let mocPath = process.env.DFX_MOC_PATH;
+export async function runAll(filter = '') {
+    let start = Date.now();
+    let rootDir = getRootDir();
+    let files = [];
+    let libFiles = globSync('**/test?(s)/lib.mo', globConfig);
+    if (libFiles[0]) {
+        files = [libFiles[0]];
+    }
+    else {
+        let globStr = '**/test?(s)/**/*.test.mo';
+        if (filter) {
+            globStr = `**/test?(s)/**/*${filter}*.mo`;
+        }
+        files = globSync(path.join(rootDir, globStr), globConfig);
+    }
+    if (!files.length) {
+        if (filter) {
+            console.log(`No test files found for filter '${filter}'`);
+            return;
+        }
+        console.log('No test files found');
+        console.log('Put your tests in \'test\' directory in *.test.mo files');
+        return;
+    }
+    console.log('Test files:');
+    for (let file of files) {
+        console.log(chalk.gray(`• ${absToRel(file)}`));
+    }
+    console.log('='.repeat(50));
+    let failed = 0;
+    let passed = 0;
+    let skipped = 0;
+    let sourcesArr = await sources();
+    if (!mocPath) {
+        mocPath = execSync('dfx cache show').toString().trim() + '/moc';
+    }
+    let wasmDir = `${getRootDir()}/.mops/.test/`;
+    fs.mkdirSync(wasmDir, { recursive: true });
+    let i = 0;
+    await parallel(os.cpus().length, files, async (file) => {
+        if (!mocPath) {
+            mocPath = 'moc';
+        }
+        let mmf = new MMF1('store');
+        let wasiMode = fs.readFileSync(file, 'utf8').startsWith('// @testmode wasi');
+        let mocArgs = ['--hide-warnings', '--error-detail=2', ...sourcesArr.join(' ').split(' '), file].filter(x => x);
+        // build and run wasm
+        if (wasiMode) {
+            let wasmFile = `${path.join(wasmDir, path.parse(file).name)}.wasm`;
+            // build
+            let buildProc = spawn(mocPath, [`-o=${wasmFile}`, '-wasi-system-api', ...mocArgs]);
+            await pipeMMF(buildProc, mmf).then(async () => {
+                if (mmf.failed > 0) {
+                    return;
+                }
+                // run
+                let proc = spawn('wasmtime', [wasmFile]);
+                await pipeMMF(proc, mmf);
+            }).finally(() => {
+                fs.rmSync(wasmFile, { force: true });
+            });
+        }
+        // interpret
+        else {
+            let proc = spawn(mocPath, ['-r', '-ref-system-api', ...mocArgs]);
+            await pipeMMF(proc, mmf);
+        }
+        passed += mmf.passed;
+        failed += mmf.failed;
+        skipped += mmf.skipped;
+        i++ && console.log('-'.repeat(50));
+        console.log(`Running ${chalk.gray(path.relative(rootDir, file))} ${wasiMode ? chalk.gray('(wasi)') : ''}`);
+        mmf.flush();
+    });
+    fs.rmSync(wasmDir, { recursive: true, force: true });
+    console.log('='.repeat(50));
+    if (failed) {
+        console.log(chalk.redBright('Tests failed'));
+    }
+    else {
+        console.log(chalk.greenBright('Tests passed'));
+    }
+    console.log(`Done in ${chalk.gray(((Date.now() - start) / 1000).toFixed(2) + 's')}`
+        + `, passed ${chalk.greenBright(passed)}`
+        + (skipped ? `, skipped ${chalk[skipped ? 'yellowBright' : 'gray'](skipped)}` : '')
+        + (failed ? `, failed ${chalk[failed ? 'redBright' : 'gray'](failed)}` : ''));
+    return failed === 0;
+}
+function absToRel(p) {
+    let rootDir = getRootDir();
+    return path.relative(rootDir, path.resolve(p));
+}
+function pipeMMF(proc, mmf) {
+    return new Promise((resolve) => {
+        // stdout
+        proc.stdout.on('data', (data) => {
+            for (let line of data.toString().split('\n')) {
+                line = line.trim();
+                if (line) {
+                    mmf.parseLine(line);
+                }
+            }
+        });
+        // stderr
+        proc.stderr.on('data', (data) => {
+            let text = data.toString().trim();
+            let failedLine = '';
+            text = text.replace(/([\w+._/-]+):(\d+).(\d+)(-\d+.\d+)/g, (_m0, m1, m2, m3) => {
+                // change absolute file path to relative
+                // change :line:col-line:col to :line:col to work in vscode
+                let res = `${absToRel(m1)}:${m2}:${m3}`;
+                if (!fs.existsSync(m1)) {
+                    return res;
+                }
+                // show failed line
+                let content = fs.readFileSync(m1);
+                let lines = content.toString().split('\n') || [];
+                failedLine += chalk.dim `\n   ...`;
+                let lineBefore = lines[+m2 - 2];
+                if (lineBefore) {
+                    failedLine += chalk.dim `\n   ${+m2 - 1}\t| ${lineBefore.replaceAll('\t', '  ')}`;
+                }
+                failedLine += `\n${chalk.redBright `->`} ${m2}\t| ${lines[+m2 - 1]?.replaceAll('\t', '  ')}`;
+                if (lines.length > +m2) {
+                    failedLine += chalk.dim `\n   ${+m2 + 1}\t| ${lines[+m2]?.replaceAll('\t', '  ')}`;
+                }
+                failedLine += chalk.dim `\n   ...`;
+                return res;
+            });
+            if (failedLine) {
+                text += failedLine;
+            }
+            mmf.fail(text);
+        });
+        // exit
+        proc.on('close', (code) => {
+            if (code === 0) {
+                mmf.pass();
+            }
+            else if (code !== 1) {
+                mmf.fail(`unknown exit code: ${code}`);
+            }
+            resolve(mmf);
+        });
+    });
+}

package/dist/commands/user.d.ts

@@ -0,0 +1,2 @@
+export declare function getUserProp(prop: string): Promise<void>;
+export declare function setUserProp(prop: string, value: string): Promise<void>;

package/dist/commands/user.js

@@ -0,0 +1,23 @@
+import chalk from 'chalk';
+import { getIdentity, mainActor } from '../mops.js';
+export async function getUserProp(prop) {
+    let actor = await mainActor();
+    let identity = await getIdentity();
+    if (!identity) {
+        console.log(chalk.red('Error: ') + 'No identity found');
+        process.exit(1);
+    }
+    let res = await actor.getUser(identity.getPrincipal());
+    // @ts-ignore
+    console.log(res[0]?.[prop] || '');
+}
+export async function setUserProp(prop, value) {
+    let actor = await mainActor(true);
+    let res = await actor.setUserProp(prop, value);
+    if ('ok' in res) {
+        console.log(chalk.green('Success!'));
+    }
+    else {
+        console.log(chalk.red('Error: ') + res.err);
+    }
+}

package/dist/commands/whoami.d.ts

@@ -0,0 +1 @@
+export declare function whoami(): Promise<void>;

package/dist/commands/whoami.js

@@ -0,0 +1,11 @@
+import chalk from 'chalk';
+import { getIdentity } from '../mops.js';
+export async function whoami() {
+    let identity = await getIdentity();
+    if (identity) {
+        console.log(identity.getPrincipal().toText());
+    }
+    else {
+        console.log(chalk.red('Error: ') + 'identity not found. Run ' + chalk.greenBright('mops import-identity') + ' command.');
+    }
+}

package/dist/declarations/main/index.d.ts

@@ -0,0 +1,50 @@
+import type {
+  ActorSubclass,
+  HttpAgentOptions,
+  ActorConfig,
+  Agent,
+} from "@dfinity/agent";
+import type { Principal } from "@dfinity/principal";
+import type { IDL } from "@dfinity/candid";
+
+import { _SERVICE } from './main.did';
+
+export declare const idlFactory: IDL.InterfaceFactory;
+export declare const canisterId: string;
+
+export declare interface CreateActorOptions {
+  /**
+   * @see {@link Agent}
+   */
+  agent?: Agent;
+  /**
+   * @see {@link HttpAgentOptions}
+   */
+  agentOptions?: HttpAgentOptions;
+  /**
+   * @see {@link ActorConfig}
+   */
+  actorOptions?: ActorConfig;
+}
+
+/**
+ * Intializes an {@link ActorSubclass}, configured with the provided SERVICE interface of a canister.
+ * @constructs {@link ActorSubClass}
+ * @param {string | Principal} canisterId - ID of the canister the {@link Actor} will talk to
+ * @param {CreateActorOptions} options - see {@link CreateActorOptions}
+ * @param {CreateActorOptions["agent"]} options.agent - a pre-configured agent you'd like to use. Supercedes agentOptions
+ * @param {CreateActorOptions["agentOptions"]} options.agentOptions - options to set up a new agent
+ * @see {@link HttpAgentOptions}
+ * @param {CreateActorOptions["actorOptions"]} options.actorOptions - options for the Actor
+ * @see {@link ActorConfig}
+ */
+export declare const createActor: (
+  canisterId: string | Principal,
+  options?: CreateActorOptions
+) => ActorSubclass<_SERVICE>;
+
+/**
+ * Intialized Actor using default settings, ready to talk to a canister using its candid interface
+ * @constructs {@link ActorSubClass}
+ */
+export declare const main: ActorSubclass<_SERVICE>;

package/dist/declarations/main/index.js

@@ -0,0 +1,41 @@
+import { Actor, HttpAgent } from "@dfinity/agent";
+
+// Imports and re-exports candid interface
+import { idlFactory } from "./main.did.js";
+export { idlFactory } from "./main.did.js";
+
+/* CANISTER_ID is replaced by webpack based on node environment
+ * Note: canister environment variable will be standardized as
+ * process.env.CANISTER_ID_<CANISTER_NAME_UPPERCASE>
+ * beginning in dfx 0.15.0
+ */
+export const canisterId =
+  process.env.CANISTER_ID_MAIN ||
+  process.env.MAIN_CANISTER_ID;
+
+export const createActor = (canisterId, options = {}) => {
+  const agent = options.agent || new HttpAgent({ ...options.agentOptions });
+
+  if (options.agent && options.agentOptions) {
+    console.warn(
+      "Detected both agent and agentOptions passed to createActor. Ignoring agentOptions and proceeding with the provided agent."
+    );
+  }
+
+  // Fetch root key for certificate validation during development
+  if (process.env.DFX_NETWORK !== "ic") {
+    agent.fetchRootKey().catch((err) => {
+      console.warn(
+        "Unable to fetch root key. Check to ensure that your local replica is running"
+      );
+      console.error(err);
+    });
+  }
+
+  // Creates an actor with using the candid interface and the HttpAgent
+  return Actor.createActor(idlFactory, {
+    agent,
+    canisterId,
+    ...options.actorOptions,
+  });
+};