ic-mops 0.19.0 → 0.20.0

package/dist/commands/install.js

@@ -0,0 +1,110 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import logUpdate from 'log-update';
+import chalk from 'chalk';
+import { checkConfigFile, formatDir, getHighestVersion, mainActor, progressBar, readConfig, storageActor } from '../mops.js';
+import { parallel } from '../parallel.js';
+import { installFromGithub } from '../vessel.js';
+import { addCache, copyCache, isCached } from '../cache.js';
+export async function install(pkg, version = '', { verbose = false, silent = false, dep = false } = {}) {
+    if (!checkConfigFile()) {
+        return false;
+    }
+    // progress
+    let total = Infinity;
+    let step = 0;
+    let progress = () => {
+        step++;
+        silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${pkg}@${version} ${progressBar(step, total)}`);
+    };
+    progress();
+    if (!version) {
+        let versionRes = await getHighestVersion(pkg);
+        if ('err' in versionRes) {
+            console.log(chalk.red('Error: ') + versionRes.err);
+            return false;
+        }
+        version = versionRes.ok;
+    }
+    let dir = formatDir(pkg, version);
+    let actor = await mainActor();
+    // already installed
+    if (fs.existsSync(dir)) {
+        silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${pkg}@${version} (already installed)`);
+    }
+    // copy from cache
+    else if (isCached(`${pkg}@${version}`)) {
+        actor.notifyInstall(pkg, version);
+        await copyCache(`${pkg}@${version}`, dir);
+        silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${pkg}@${version} (cache)`);
+    }
+    // download
+    else {
+        let [packageDetailsRes, filesIdsRes] = await Promise.all([
+            actor.getPackageDetails(pkg, version),
+            actor.getFileIds(pkg, version),
+        ]);
+        if ('err' in packageDetailsRes) {
+            console.log(chalk.red('Error: ') + packageDetailsRes.err);
+            return false;
+        }
+        let packageDetails = packageDetailsRes.ok;
+        if ('err' in filesIdsRes) {
+            console.log(chalk.red('Error: ') + filesIdsRes.err);
+            return false;
+        }
+        let filesIds = filesIdsRes.ok;
+        total = filesIds.length + 2;
+        let storage = await storageActor(packageDetails.publication.storage);
+        actor.notifyInstall(pkg, version);
+        // download files
+        let filesData = new Map;
+        await parallel(16, filesIds, async (fileId) => {
+            let fileMetaRes = await storage.getFileMeta(fileId);
+            if ('err' in fileMetaRes) {
+                console.log(chalk.red('ERR: ') + fileMetaRes.err);
+                return;
+            }
+            let fileMeta = fileMetaRes.ok;
+            let buffer = Buffer.from([]);
+            for (let i = 0n; i < fileMeta.chunkCount; i++) {
+                let chunkRes = await storage.downloadChunk(fileId, i);
+                if ('err' in chunkRes) {
+                    console.log(chalk.red('ERR: ') + chunkRes.err);
+                    return;
+                }
+                let chunk = chunkRes.ok;
+                buffer = Buffer.concat([buffer, Buffer.from(chunk)]);
+            }
+            filesData.set(fileMeta.path, buffer);
+            progress();
+        });
+        // write files to disk
+        for (let [filePath, buffer] of filesData.entries()) {
+            fs.mkdirSync(path.join(dir, path.dirname(filePath)), { recursive: true });
+            fs.writeFileSync(path.join(dir, filePath), buffer);
+        }
+        // add to cache
+        await addCache(`${pkg}@${version}`, dir);
+        progress();
+    }
+    if (verbose) {
+        silent || logUpdate.done();
+    }
+    // install dependencies
+    let ok = true;
+    let config = readConfig(path.join(dir, 'mops.toml'));
+    let deps = Object.values(config.dependencies || {});
+    for (const { name, repo, version } of deps) {
+        if (repo) {
+            await installFromGithub(name, repo, { silent, verbose });
+        }
+        else {
+            let res = await install(name, version, { silent, verbose });
+            if (!res) {
+                ok = false;
+            }
+        }
+    }
+    return ok;
+}

package/dist/commands/mmf1.d.ts

@@ -0,0 +1,21 @@
+type Strategy = 'store' | 'print';
+export declare class MMF1 {
+    stack: string[];
+    currSuite: string;
+    failed: number;
+    passed: number;
+    skipped: number;
+    srategy: Strategy;
+    output: string[];
+    constructor(srategy: Strategy);
+    _log(...args: string[]): void;
+    flush(): void;
+    parseLine(line: string): void;
+    _testStart(name: string): void;
+    _testEnd(name: string): void;
+    _testSkip(name: string): void;
+    _status(name: string, status: string): void;
+    fail(stderr: string): void;
+    pass(): void;
+}
+export {};

package/dist/commands/mmf1.js

@@ -0,0 +1,93 @@
+// mops message format v1
+// mops:1:start
+// mops:1:end
+// mops:1:skip
+import chalk from 'chalk';
+export class MMF1 {
+    constructor(srategy) {
+        this.stack = [];
+        this.currSuite = '';
+        this.failed = 0;
+        this.passed = 0;
+        this.skipped = 0;
+        this.output = [];
+        this.srategy = srategy;
+    }
+    _log(...args) {
+        if (this.srategy === 'store') {
+            this.output.push(args.join(' '));
+        }
+        else if (this.srategy === 'print') {
+            console.log(...args);
+        }
+    }
+    flush() {
+        for (let out of this.output) {
+            console.log(out);
+        }
+        this.output = [];
+    }
+    parseLine(line) {
+        if (line.startsWith('mops:1:start ')) {
+            this._testStart(line.split('mops:1:start ')[1] || '');
+        }
+        else if (line.startsWith('mops:1:end ')) {
+            this._testEnd(line.split('mops:1:end ')[1] || '');
+        }
+        else if (line.startsWith('mops:1:skip ')) {
+            this._testSkip(line.split('mops:1:skip ')[1] || '');
+        }
+        else {
+            this._log(' '.repeat(this.stack.length * 2), chalk.gray('stdout'), line);
+        }
+    }
+    _testStart(name) {
+        let suite = this.stack[this.stack.length - 1];
+        if (suite) {
+            if (this.currSuite !== suite) {
+                this.currSuite = suite;
+                this._log(' '.repeat((this.stack.length - 1) * 2), (chalk.gray('•')) + '', suite);
+            }
+        }
+        this.stack.push(name);
+    }
+    _testEnd(name) {
+        if (name !== this.stack.pop()) {
+            throw 'mmf1._testEnd: start and end test mismatch';
+        }
+        this._status(name, 'pass');
+    }
+    _testSkip(name) {
+        this._status(name, 'skip');
+    }
+    _status(name, status) {
+        if (status === 'pass') {
+            // do not print suite at the end
+            if (name === this.currSuite) {
+                return;
+            }
+            this.passed++;
+            this._log(' '.repeat(this.stack.length * 2), chalk.green('✓'), name);
+        }
+        else if (status === 'fail') {
+            this.failed++;
+            this._log(' '.repeat(this.stack.length * 2), chalk.red('✖'), name);
+        }
+        else if (status === 'skip') {
+            this.skipped++;
+            this._log(' '.repeat(this.stack.length * 2), chalk.yellow('−'), name);
+        }
+    }
+    fail(stderr) {
+        let name = this.stack.pop() || '';
+        this._status(name, 'fail');
+        this._log(' '.repeat(this.stack.length * 2), chalk.red('FAIL'), stderr);
+    }
+    pass() {
+        let name = this.stack.pop();
+        if (name) {
+            this._status(name, 'pass');
+        }
+        this._log(' '.repeat(this.stack.length * 2), chalk.green('PASS'));
+    }
+}

package/dist/commands/publish.d.ts

@@ -0,0 +1,3 @@
+export declare function publish({ noDocs }?: {
+    noDocs?: boolean | undefined;
+}): Promise<void>;

package/dist/commands/publish.js

@@ -0,0 +1,254 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import chalk from 'chalk';
+import logUpdate from 'log-update';
+import { globbySync } from 'globby';
+import { minimatch } from 'minimatch';
+import prompts from 'prompts';
+import { checkConfigFile, getRootDir, mainActor, progressBar, readConfig } from '../mops.js';
+import { parallel } from '../parallel.js';
+import { docs } from './docs.js';
+export async function publish({ noDocs = false } = {}) {
+    if (!checkConfigFile()) {
+        return;
+    }
+    let rootDir = getRootDir();
+    let config = readConfig();
+    // validate
+    for (let key of Object.keys(config)) {
+        if (!['package', 'dependencies', 'dev-dependencies', 'scripts'].includes(key)) {
+            console.log(chalk.red('Error: ') + `Unknown config section [${key}]`);
+            return;
+        }
+    }
+    // required fields
+    if (!config.package) {
+        console.log(chalk.red('Error: ') + 'Please specify [package] section in your mops.toml');
+        return;
+    }
+    for (let key of ['name', 'version']) {
+        // @ts-ignore
+        if (!config.package[key]) {
+            console.log(chalk.red('Error: ') + `Please specify "${key}" in [config] section in your mops.toml`);
+            return;
+        }
+    }
+    // desired fields
+    for (let key of ['description', 'repository']) {
+        // @ts-ignore
+        if (!config.package[key]) {
+            let res = await prompts({
+                type: 'confirm',
+                name: 'ok',
+                message: `Missing recommended config key "${key}", publish anyway?`,
+            });
+            if (!res.ok) {
+                return;
+            }
+        }
+    }
+    let packageKeys = [
+        'name',
+        'version',
+        'keywords',
+        'description',
+        'repository',
+        'documentation',
+        'homepage',
+        'baseDir',
+        'readme',
+        'license',
+        'files',
+        'dfx',
+        'moc',
+        'donation',
+    ];
+    for (let key of Object.keys(config.package)) {
+        if (!packageKeys.includes(key)) {
+            console.log(chalk.red('Error: ') + `Unknown config key 'package.${key}'`);
+            return;
+        }
+    }
+    // check lengths
+    let keysMax = {
+        name: 50,
+        version: 20,
+        keywords: 5,
+        description: 200,
+        repository: 300,
+        documentation: 300,
+        homepage: 300,
+        readme: 100,
+        license: 30,
+        files: 20,
+        dfx: 10,
+        moc: 10,
+        donation: 64,
+        root: 50,
+    };
+    for (let [key, max] of Object.entries(keysMax)) {
+        // @ts-ignore
+        if (config.package[key] && config.package[key].length > max) {
+            console.log(chalk.red('Error: ') + `package.${key} value max length is ${max}`);
+            return;
+        }
+    }
+    if (config.dependencies) {
+        if (Object.keys(config.dependencies).length > 100) {
+            console.log(chalk.red('Error: ') + 'max dependencies is 100');
+            return;
+        }
+        for (let dep of Object.values(config.dependencies)) {
+            if (dep.path) {
+                console.log(chalk.red('Error: ') + 'you can\'t publish packages with local dependencies');
+                return;
+            }
+            delete dep.path;
+        }
+    }
+    if (config['dev-dependencies']) {
+        if (Object.keys(config['dev-dependencies']).length > 100) {
+            console.log(chalk.red('Error: ') + 'max dev-dependencies is 100');
+            return;
+        }
+        for (let dep of Object.values(config['dev-dependencies'])) {
+            if (dep.path) {
+                console.log(chalk.red('Error: ') + 'you can\'t publish packages with local dev-dependencies');
+                return;
+            }
+            delete dep.path;
+        }
+    }
+    if (config.package.keywords) {
+        for (let keyword of config.package.keywords) {
+            if (keyword.length > 20) {
+                console.log(chalk.red('Error: ') + 'max keyword length is 20');
+                return;
+            }
+        }
+    }
+    if (config.package.files) {
+        for (let file of config.package.files) {
+            if (file.startsWith('/') || file.startsWith('../')) {
+                console.log(chalk.red('Error: ') + 'file path cannot start with \'/\' or \'../\'');
+                return;
+            }
+        }
+    }
+    let toBackendDep = (dep) => {
+        return {
+            ...dep,
+            version: dep.version || '',
+            repo: dep.repo || ''
+        };
+    };
+    // map fields
+    let backendPkgConfig = {
+        name: config.package.name,
+        version: config.package.version,
+        keywords: config.package.keywords || [],
+        description: config.package.description || '',
+        repository: config.package.repository || '',
+        homepage: config.package.homepage || '',
+        documentation: config.package.documentation || '',
+        baseDir: 'src',
+        readme: 'README.md',
+        license: config.package.license || '',
+        dfx: config.package.dfx || '',
+        moc: config.package.moc || '',
+        donation: config.package.donation || '',
+        dependencies: Object.values(config.dependencies || {}).map(toBackendDep),
+        devDependencies: Object.values(config['dev-dependencies'] || {}).map(toBackendDep),
+        scripts: [],
+    };
+    let defaultFiles = [
+        'mops.toml',
+        'README.md',
+        'LICENSE',
+        'NOTICE',
+        '!.mops/**',
+        '!test/**',
+        '!tests/**',
+        '!**/*.test.mo',
+        '!**/*.Test.mo',
+    ];
+    let files = config.package.files || ['**/*.mo'];
+    files = [...files, ...defaultFiles];
+    files = globbySync([...files, ...defaultFiles]);
+    // generate docs
+    let docsFile = path.join(rootDir, '.mops/.docs/docs.tgz');
+    if (!noDocs) {
+        await docs({ silent: true });
+        if (fs.existsSync(docsFile)) {
+            files.unshift(docsFile);
+        }
+    }
+    // check required files
+    if (!files.includes('mops.toml')) {
+        console.log(chalk.red('Error: ') + ' please add mops.toml file');
+        return;
+    }
+    if (!files.includes('README.md')) {
+        console.log(chalk.red('Error: ') + ' please add README.md file');
+        return;
+    }
+    // check allowed exts
+    for (let file of files) {
+        if (!minimatch(file, '**/*.{mo,did,md,toml}') && !file.toLowerCase().endsWith('license') && file !== docsFile) {
+            console.log(chalk.red('Error: ') + `file ${file} has unsupported extension. Allowed: .mo, .did, .md, .toml`);
+            return;
+        }
+    }
+    // progress
+    let total = files.length + 2;
+    let step = 0;
+    function progress() {
+        step++;
+        logUpdate(`Publishing ${config.package?.name}@${config.package?.version} ${progressBar(step, total)}`);
+    }
+    // upload config
+    let actor = await mainActor(true);
+    progress();
+    let publishing = await actor.startPublish(backendPkgConfig);
+    if ('err' in publishing) {
+        console.log(chalk.red('Error: ') + publishing.err);
+        return;
+    }
+    let puiblishingId = publishing.ok;
+    // upload files
+    await parallel(8, files, async (file) => {
+        progress();
+        let chunkSize = 1024 * 1024 + 512 * 1024; // 1.5mb
+        let content = fs.readFileSync(file);
+        let chunkCount = Math.ceil(content.length / chunkSize);
+        let firstChunk = Array.from(content.slice(0, chunkSize));
+        // remove path from docs file
+        if (file === docsFile) {
+            file = path.basename(file);
+        }
+        let res = await actor.startFileUpload(puiblishingId, file, BigInt(chunkCount), firstChunk);
+        if ('err' in res) {
+            console.log(chalk.red('Error: ') + res.err);
+            return;
+        }
+        let fileId = res.ok;
+        for (let i = 1; i < chunkCount; i++) {
+            let start = i * chunkSize;
+            let chunk = Array.from(content.slice(start, start + chunkSize));
+            let res = await actor.uploadFileChunk(puiblishingId, fileId, BigInt(i), chunk);
+            if ('err' in res) {
+                console.log(chalk.red('Error: ') + res.err);
+                return;
+            }
+        }
+    });
+    fs.rmSync(path.join(rootDir, '.mops/.docs'), { force: true, recursive: true });
+    // finish
+    progress();
+    let res = await actor.finishPublish(puiblishingId);
+    if ('err' in res) {
+        console.log(chalk.red('Error: ') + res.err);
+        return;
+    }
+    console.log(chalk.green('Published ') + `${config.package.name}@${config.package.version}`);
+}

package/dist/commands/remove.d.ts

@@ -0,0 +1,5 @@
+export declare function remove(name: string, { dev, verbose, dryRun }?: {
+    dev?: boolean | undefined;
+    verbose?: boolean | undefined;
+    dryRun?: boolean | undefined;
+}): Promise<void>;

package/dist/commands/remove.js

@@ -0,0 +1,83 @@
+import fs from 'node:fs';
+import { deleteSync } from 'del';
+import chalk from 'chalk';
+import { formatDir, formatGithubDir, checkConfigFile, readConfig, writeConfig } from '../mops.js';
+export async function remove(name, { dev = false, verbose = false, dryRun = false } = {}) {
+    if (!checkConfigFile()) {
+        return;
+    }
+    function getTransitiveDependencies(config, exceptPkgId) {
+        let deps = Object.values(config.dependencies || {});
+        let devDeps = Object.values(config['dev-dependencies'] || {});
+        return [...deps, ...devDeps]
+            .filter((dep) => {
+            let depId = dep.name + '@' + dep.version;
+            return depId !== exceptPkgId;
+        }).map((dep) => {
+            return [dep, ...getTransitiveDependenciesOf(dep.name, dep.version, dep.repo)];
+        }).flat();
+    }
+    function getTransitiveDependenciesOf(name, version, repo) {
+        let pkgDir = '';
+        if (repo) {
+            pkgDir = formatGithubDir(name, repo);
+        }
+        else if (version) {
+            pkgDir = formatDir(name, version);
+        }
+        let configFile = pkgDir + '/mops.toml';
+        if (!fs.existsSync(configFile)) {
+            verbose && console.log('no config', configFile);
+            return [];
+        }
+        let config = readConfig(configFile);
+        let deps = Object.values(config.dependencies || {}).map((dep) => {
+            return [dep, ...getTransitiveDependenciesOf(dep.name, dep.version)];
+        }).flat();
+        return deps;
+    }
+    let config = readConfig();
+    let deps = dev ? config['dev-dependencies'] : config.dependencies;
+    deps = deps || {};
+    let pkgDetails = deps[name];
+    if (!pkgDetails) {
+        return console.log(chalk.red('Error: ') + `No ${dev ? 'dev ' : ''}dependency to remove "${name}"`);
+    }
+    let version = pkgDetails.version;
+    let packageId = `${name}@${version}`;
+    // transitive deps ignoring deps of this package
+    let transitiveDeps = getTransitiveDependencies(config, packageId);
+    let transitiveDepIds = new Set(transitiveDeps.map((dep) => {
+        return dep.name + '@' + dep.version;
+    }));
+    // transitive deps of this package (including itself)
+    let transitiveDepsOfPackage = [pkgDetails, ...getTransitiveDependenciesOf(name, version)];
+    // remove local cache
+    for (let dep of transitiveDepsOfPackage) {
+        let depId = dep.name + '@' + dep.version;
+        if (transitiveDepIds.has(depId)) {
+            verbose && console.log(`Ignored transitive dependency ${depId} (other deps depend on it)`);
+            continue;
+        }
+        let pkgDir;
+        if (dep.repo) {
+            pkgDir = formatGithubDir(dep.name, dep.repo);
+        }
+        else if (dep.version) {
+            pkgDir = formatDir(dep.name, dep.version);
+        }
+        if (pkgDir && fs.existsSync(pkgDir)) {
+            dryRun || deleteSync([`${pkgDir}`]);
+            verbose && console.log(`Removed local cache ${pkgDir}`);
+        }
+    }
+    // remove from config
+    if (!dev && config.dependencies) {
+        delete config.dependencies[name];
+    }
+    if (dev && config['dev-dependencies']) {
+        delete config['dev-dependencies'][name];
+    }
+    dryRun || writeConfig(config);
+    console.log(chalk.green('Package removed ') + `${name} = "${version}"`);
+}

package/dist/commands/search.d.ts

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

package/dist/commands/search.js

@@ -0,0 +1,36 @@
+import asTable from 'as-table';
+import chalk from 'chalk';
+import { mainActor } from '../mops.js';
+export async function search(text) {
+    let actor = await mainActor();
+    let res = await actor.search(text, [], []);
+    let packages = res[0];
+    if (!packages.length) {
+        console.log('Packages not found');
+        return;
+    }
+    let ellipsis = (text, max) => {
+        if (text.length <= max) {
+            return text;
+        }
+        else {
+            return text.slice(0, max) + '…';
+        }
+    };
+    let maxNameLength = Math.max(...packages.map(a => a.config.name.length));
+    let table = packages.map((item) => {
+        return {
+            NAME: chalk.bold(item.config.name),
+            DESCRIPTION: ellipsis(item.config.description, process.stdout.columns - 40 - maxNameLength),
+            VERSION: item.config.version,
+            UPDATED: new Date(Number(item.publication.time / 1000000n)).toISOString().split('T')[0],
+        };
+    });
+    console.log('');
+    console.log(asTable.configure({
+        delimiter: chalk.gray(' | '),
+        dash: chalk.gray('─'),
+        title: t => chalk.gray.bold(t),
+    })(table));
+    console.log('');
+}

package/dist/commands/self-update.d.ts

@@ -0,0 +1,3 @@
+export declare function selfUpdate({ detached }?: {
+    detached?: boolean | undefined;
+}): void;

package/dist/commands/self-update.js

@@ -0,0 +1,5 @@
+import child_process from 'node:child_process';
+export function selfUpdate({ detached = false } = {}) {
+    console.log('Updating mops CLI...');
+    child_process.spawn('npm i ic-mops -g', { stdio: 'inherit', detached });
+}

package/dist/commands/sources.d.ts

@@ -0,0 +1,3 @@
+export declare function sources({ verbose }?: {
+    verbose?: boolean | undefined;
+}): Promise<(string | undefined)[]>;