ic-mops 0.41.1 → 0.42.1

package/commands/test/test.ts

@@ -1,3 +1,4 @@
+import process from 'node:process';
 import {spawn, ChildProcessWithoutNullStreams} from 'node:child_process';
 import path from 'node:path';
 import fs from 'node:fs';

package/commands/toolchain/index.ts

@@ -1,3 +1,4 @@
+import process from 'node:process';
 import path from 'node:path';
 import fs from 'node:fs';
 import os from 'node:os';

package/commands/toolchain/moc.ts

@@ -1,3 +1,4 @@
+import process from 'node:process';
 import path from 'node:path';
 import fs from 'fs-extra';
 

package/commands/toolchain/pocket-ic.ts

@@ -1,3 +1,4 @@
+import process from 'node:process';
 import path from 'node:path';
 import fs from 'node:fs';
 

package/commands/toolchain/toolchain-utils.ts

@@ -1,4 +1,6 @@
+import process from 'node:process';
 import path from 'node:path';
+import {Buffer} from 'node:buffer';
 import {unzipSync} from 'node:zlib';
 import {chmodSync} from 'node:fs';
 import fs from 'fs-extra';

package/commands/toolchain/wasmtime.ts

@@ -1,3 +1,4 @@
+import process from 'node:process';
 import path from 'node:path';
 import fs from 'fs-extra';
 

package/commands/transfer-ownership.ts

@@ -1,3 +1,4 @@
+import process from 'node:process';
 import chalk from 'chalk';
 import {checkConfigFile, getIdentity, readConfig} from '../mops.js';
 import {mainActor} from '../api/actors.js';

package/commands/user.ts

@@ -1,3 +1,4 @@
+import process from 'node:process';
 import chalk from 'chalk';
 import {getIdentity} from '../mops.js';
 import {mainActor} from '../api/actors.js';

package/declarations/bench/index.js

@@ -4,14 +4,6 @@ import { Actor, HttpAgent } from "@dfinity/agent";
 import { idlFactory } from "./bench.did.js";
 export { idlFactory } from "./bench.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_BENCH;
-
 export const createActor = (canisterId, options = {}) => {
   const agent = options.agent || new HttpAgent({ ...options.agentOptions });
 

package/declarations/storage/storage.did.d.ts

@@ -1,5 +1,6 @@
 import type { Principal } from '@dfinity/principal';
 import type { ActorMethod } from '@dfinity/agent';
+import type { IDL } from '@dfinity/candid';
 
 export type Chunk = Array<number>;
 export type Err = string;
@@ -35,3 +36,5 @@ export interface StorageStats {
   'memorySize' : bigint,
 }
 export interface _SERVICE extends Storage {}
+export declare const idlFactory: IDL.InterfaceFactory;
+export declare const init: (args: { IDL: typeof IDL }) => IDL.Type[];

package/dist/api/actors.js

@@ -1,6 +1,6 @@
 import { Actor, HttpAgent } from '@dfinity/agent';
-import { idlFactory } from '../declarations/main/index.js';
-import { idlFactory as storageIdlFactory } from '../declarations/storage/index.js';
+import { idlFactory } from '../declarations/main/main.did.js';
+import { idlFactory as storageIdlFactory } from '../declarations/storage/storage.did.js';
 import { getEndpoint } from './network.js';
 import { getNetwork } from './network.js';
 export let mainActor = async (identity) => {

package/dist/cache.d.ts

@@ -1,5 +1,9 @@
-export declare let isCached: (pkgId: string) => boolean;
-export declare let addCache: (pkgId: string, source: string) => Promise<void>;
-export declare let copyCache: (pkgId: string, dest: string) => Promise<void>;
+export declare let getDepCacheDir: (cacheName: string) => string;
+export declare let isDepCached: (cacheName: string) => boolean;
+export declare function getDepCacheName(name: string, version: string): string;
+export declare function getMopsDepCacheName(name: string, version: string): string;
+export declare function getGithubDepCacheName(name: string, repo: string): string;
+export declare let addCache: (cacheName: string, source: string) => Promise<void>;
+export declare let copyCache: (cacheName: string, dest: string) => Promise<void>;
 export declare let cacheSize: () => Promise<string>;
 export declare let cleanCache: () => Promise<void>;

package/dist/cache.js

@@ -2,13 +2,27 @@ import fs from 'node:fs';
 import path from 'node:path';
 import ncp from 'ncp';
 import getFolderSize from 'get-folder-size';
-import { globalCacheDir } from './mops.js';
-export let isCached = (pkgId) => {
-    let dir = path.join(globalCacheDir, 'packages', pkgId);
+import { getDependencyType, globalCacheDir, parseGithubURL } from './mops.js';
+export let getDepCacheDir = (cacheName) => {
+    return path.join(globalCacheDir, 'packages', cacheName);
+};
+export let isDepCached = (cacheName) => {
+    let dir = getDepCacheDir(cacheName);
     return fs.existsSync(dir);
 };
-export let addCache = (pkgId, source) => {
-    let dest = path.join(globalCacheDir, 'packages', pkgId);
+export function getDepCacheName(name, version) {
+    let depType = getDependencyType(version);
+    return depType === 'mops' ? getMopsDepCacheName(name, version) : getGithubDepCacheName(name, version);
+}
+export function getMopsDepCacheName(name, version) {
+    return `${name}@${version}`;
+}
+export function getGithubDepCacheName(name, repo) {
+    const { branch, commitHash } = parseGithubURL(repo);
+    return `_github/${name}#${branch}` + (commitHash ? `@${commitHash}` : '');
+}
+export let addCache = (cacheName, source) => {
+    let dest = path.join(globalCacheDir, 'packages', cacheName);
     fs.mkdirSync(dest, { recursive: true });
     return new Promise((resolve, reject) => {
         ncp.ncp(source, dest, { stopOnErr: true }, (err) => {
@@ -19,8 +33,8 @@ export let addCache = (pkgId, source) => {
         });
     });
 };
-export let copyCache = (pkgId, dest) => {
-    let source = path.join(globalCacheDir, 'packages', pkgId);
+export let copyCache = (cacheName, dest) => {
+    let source = path.join(globalCacheDir, 'packages', cacheName);
     fs.mkdirSync(dest, { recursive: true });
     return new Promise((resolve, reject) => {
         ncp.ncp(source, dest, { stopOnErr: true }, (err) => {

package/dist/check-requirements.js

@@ -1,7 +1,7 @@
 import path from 'node:path';
 import { SemVer } from 'semver';
 import chalk from 'chalk';
-import { getDependencyType, readConfig } from './mops.js';
+import { getDependencyType, getRootDir, readConfig } from './mops.js';
 import { resolvePackages } from './resolve-packages.js';
 import { getMocVersion } from './helpers/get-moc-version.js';
 export async function checkRequirements({ verbose = false } = {}) {
@@ -16,11 +16,12 @@ export async function checkRequirements({ verbose = false } = {}) {
     let installedMoc = new SemVer(mocVersion);
     let highestRequiredMoc = new SemVer('0.0.0');
     let highestRequiredMocPkgId = '';
+    let rootDir = getRootDir();
     let resolvedPackages = await resolvePackages();
     for (let [name, version] of Object.entries(resolvedPackages)) {
         if (getDependencyType(version) === 'mops') {
             let pkgId = `${name}@${version}`;
-            let depConfig = readConfig(path.join('.mops', pkgId, 'mops.toml'));
+            let depConfig = readConfig(path.join(rootDir, '.mops', pkgId, 'mops.toml'));
             let moc = depConfig.requirements?.moc;
             if (moc) {
                 let requiredMoc = new SemVer(moc);

package/dist/cli.js

@@ -1,3 +1,4 @@
+import process from 'node:process';
 import fs from 'node:fs';
 import { Command, Argument, Option } from 'commander';
 import chalk from 'chalk';
@@ -8,7 +9,7 @@ import { sources } from './commands/sources.js';
 import { checkApiCompatibility, setNetwork, apiVersion, checkConfigFile, getNetworkFile, version } from './mops.js';
 import { getNetwork } from './api/network.js';
 import { whoami } from './commands/whoami.js';
-import { installAll } from './commands/install-all.js';
+import { installAll } from './commands/install/install-all.js';
 import { search } from './commands/search.js';
 import { add } from './commands/add.js';
 import { cacheSize, cleanCache } from './cache.js';
@@ -90,8 +91,11 @@ program
         await add(pkg, options);
     }
     else {
-        await installAll(options);
+        let ok = await installAll(options);
         await toolchain.installAll(options);
+        if (!ok) {
+            process.exit(1);
+        }
     }
 });
 // publish
@@ -145,7 +149,7 @@ program
     if (!checkConfigFile()) {
         process.exit(1);
     }
-    await installAll({ silent: true, lock: 'ignore' });
+    await installAll({ silent: true, lock: 'ignore', threads: 6 });
     await toolchain.ensureToolchainInited({ strict: false });
     let sourcesArr = await sources(options);
     console.log(sourcesArr.join('\n'));

package/dist/commands/add.js

@@ -1,13 +1,15 @@
+import process from 'node:process';
 import path from 'node:path';
 import chalk from 'chalk';
 import { createLogUpdate } from 'log-update';
 import { checkConfigFile, getGithubCommit, parseGithubURL, readConfig, writeConfig } from '../mops.js';
 import { getHighestVersion } from '../api/getHighestVersion.js';
+import { installMopsDep } from './install/install-mops-dep.js';
 import { installFromGithub } from '../vessel.js';
-import { install } from './install.js';
-import { notifyInstalls } from '../notify-installs.js';
 import { checkIntegrity } from '../integrity.js';
 import { checkRequirements } from '../check-requirements.js';
+import { syncLocalCache } from './install/sync-local-cache.js';
+import { notifyInstalls } from '../notify-installs.js';
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 export async function add(name, { verbose = false, dev = false, lock } = {}, asName) {
     if (!checkConfigFile()) {
@@ -72,16 +74,14 @@ export async function add(name, { verbose = false, dev = false, lock } = {}, asN
             version: ver,
         };
     }
-    let installedPackages = {};
     if (pkgDetails.repo) {
         await installFromGithub(pkgDetails.name, pkgDetails.repo, { verbose: verbose });
     }
     else if (!pkgDetails.path) {
-        let res = await install(pkgDetails.name, pkgDetails.version, { verbose: verbose });
+        let res = await installMopsDep(pkgDetails.name, pkgDetails.version, { verbose: verbose });
         if (res === false) {
             return;
         }
-        installedPackages = { ...installedPackages, ...res };
     }
     const depsProp = dev ? 'dev-dependencies' : 'dependencies';
     let deps = config[depsProp];
@@ -96,8 +96,9 @@ export async function add(name, { verbose = false, dev = false, lock } = {}, asN
     if (lock !== 'ignore') {
         logUpdate('Checking integrity...');
     }
+    let installedPackages = await syncLocalCache();
     await Promise.all([
-        notifyInstalls(Object.keys(installedPackages)),
+        notifyInstalls(installedPackages),
         checkIntegrity(lock),
     ]);
     logUpdate.clear();

package/dist/commands/available-updates.js

@@ -1,3 +1,4 @@
+import process from 'node:process';
 import chalk from 'chalk';
 import { mainActor } from '../api/actors.js';
 // [pkg, oldVersion, newVersion]

package/dist/commands/bench-replica.js

@@ -1,3 +1,4 @@
+import process from 'node:process';
 import { execSync } from 'node:child_process';
 import path from 'node:path';
 import fs from 'node:fs';

package/dist/commands/bench.js

@@ -1,3 +1,4 @@
+import process from 'node:process';
 import path from 'node:path';
 import fs from 'node:fs';
 import os from 'node:os';

package/dist/commands/bump.js

@@ -1,3 +1,4 @@
+import process from 'node:process';
 import prompts from 'prompts';
 import chalk from 'chalk';
 import { checkConfigFile, readConfig, writeConfig } from '../mops.js';

package/dist/commands/docs.js

@@ -1,3 +1,4 @@
+import process from 'node:process';
 import { spawn } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';

package/dist/commands/import-identity.js

@@ -1,5 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { Buffer } from 'node:buffer';
 import chalk from 'chalk';
 import prompts from 'prompts';
 import { deleteSync } from 'del';

package/dist/commands/init.js

@@ -1,3 +1,4 @@
+import process from 'node:process';
 import { execSync } from 'node:child_process';
 import path from 'node:path';
 import { existsSync, readFileSync, writeFileSync } from 'node:fs';
@@ -5,7 +6,7 @@ import chalk from 'chalk';
 import prompts from 'prompts';
 import { checkApiCompatibility, writeConfig } from '../mops.js';
 import { mainActor } from '../api/actors.js';
-import { installAll } from './install-all.js';
+import { installAll } from './install/install-all.js';
 import { readVesselConfig } from '../vessel.js';
 import { template } from './template.js';
 export async function init({ yes = false } = {}) {

package/dist/commands/install/install-all.d.ts

@@ -0,0 +1,8 @@
+type InstallAllOptions = {
+    verbose?: boolean;
+    silent?: boolean;
+    lock?: 'check' | 'update' | 'ignore';
+    threads?: number;
+};
+export declare function installAll({ verbose, silent, threads, lock }?: InstallAllOptions): Promise<boolean>;
+export {};

package/dist/commands/install/install-all.js

@@ -0,0 +1,37 @@
+import process from 'node:process';
+import chalk from 'chalk';
+import { createLogUpdate } from 'log-update';
+import { checkConfigFile, readConfig } from '../../mops.js';
+import { checkIntegrity } from '../../integrity.js';
+import { installDeps } from './install-deps.js';
+import { checkRequirements } from '../../check-requirements.js';
+import { syncLocalCache } from './sync-local-cache.js';
+import { notifyInstalls } from '../../notify-installs.js';
+export async function installAll({ verbose = false, silent = false, threads, lock } = {}) {
+    if (!checkConfigFile()) {
+        return false;
+    }
+    let config = readConfig();
+    let deps = Object.values(config.dependencies || {});
+    let devDeps = Object.values(config['dev-dependencies'] || {});
+    let allDeps = [...deps, ...devDeps];
+    let ok = await installDeps(allDeps, { silent, verbose, threads });
+    if (!ok) {
+        return false;
+    }
+    let logUpdate = createLogUpdate(process.stdout, { showCursor: true });
+    if (!silent && lock !== 'ignore') {
+        logUpdate('Checking integrity...');
+    }
+    let installedPackages = await syncLocalCache();
+    await Promise.all([
+        notifyInstalls(installedPackages),
+        checkIntegrity(lock),
+    ]);
+    if (!silent) {
+        logUpdate.clear();
+        await checkRequirements();
+        console.log(chalk.green('Packages installed'));
+    }
+    return true;
+}

package/dist/commands/install/install-dep.d.ts

@@ -0,0 +1,8 @@
+import { Dependency } from '../../types.js';
+type InstallDepOptions = {
+    verbose?: boolean;
+    silent?: boolean;
+    threads?: number;
+};
+export declare function installDep(dep: Dependency, { verbose, silent, threads }?: InstallDepOptions, parentPkgPath?: string): Promise<boolean>;
+export {};

package/dist/commands/install/install-dep.js

@@ -0,0 +1,25 @@
+import path from 'node:path';
+import { installFromGithub } from '../../vessel.js';
+import { installMopsDep } from './install-mops-dep.js';
+import { installLocalDep } from './install-local-dep.js';
+import { getRootDir } from '../../mops.js';
+// install dependency
+// returns false if failed
+export async function installDep(dep, { verbose, silent, threads } = {}, parentPkgPath) {
+    if (dep.repo) {
+        await installFromGithub(dep.name, dep.repo, { silent, verbose });
+        return true;
+    }
+    else if (dep.path) {
+        let depPath = dep.path;
+        parentPkgPath = parentPkgPath || getRootDir();
+        if (parentPkgPath) {
+            depPath = path.resolve(parentPkgPath, dep.path);
+        }
+        return installLocalDep(dep.name, depPath, { silent, verbose });
+    }
+    else if (dep.version) {
+        return installMopsDep(dep.name, dep.version, { silent, verbose, threads });
+    }
+    return true;
+}

package/dist/commands/install/install-deps.d.ts

@@ -0,0 +1,8 @@
+import { Dependency } from '../../types.js';
+type InstallDepsOptions = {
+    verbose?: boolean;
+    silent?: boolean;
+    threads?: number;
+};
+export declare function installDeps(deps: Dependency[], { verbose, silent, threads }?: InstallDepsOptions, parentPkgPath?: string): Promise<boolean>;
+export {};

package/dist/commands/install/install-deps.js

@@ -0,0 +1,14 @@
+import { installDep } from './install-dep.js';
+// install all dependencies
+// returns actual installed dependencies
+// returns false if failed
+export async function installDeps(deps, { verbose, silent, threads } = {}, parentPkgPath) {
+    let ok = true;
+    for (const dep of deps) {
+        let res = await installDep(dep, { verbose, silent, threads }, parentPkgPath);
+        if (!res) {
+            ok = false;
+        }
+    }
+    return ok;
+}

package/dist/commands/install/install-local-dep.d.ts

@@ -0,0 +1,6 @@
+type InstallLocalDepOptions = {
+    verbose?: boolean;
+    silent?: boolean;
+};
+export declare function installLocalDep(pkg: string, pkgPath?: string, { verbose, silent }?: InstallLocalDepOptions): Promise<boolean>;
+export {};

package/dist/commands/install/install-local-dep.js

@@ -0,0 +1,23 @@
+import process from 'node:process';
+import path from 'node:path';
+import { createLogUpdate } from 'log-update';
+import { getRootDir, readConfig } from '../../mops.js';
+import { installDeps } from './install-deps.js';
+// skip install and just find non-local dependencies to install
+// pkgPath should be relative to the current root dir or absolute
+export async function installLocalDep(pkg, pkgPath = '', { verbose, silent } = {}) {
+    if (!silent) {
+        let logUpdate = createLogUpdate(process.stdout, { showCursor: true });
+        logUpdate(`Local dependency ${pkg} = "${pkgPath}"`);
+        if (verbose) {
+            silent || logUpdate.done();
+        }
+        else {
+            logUpdate.clear();
+        }
+    }
+    // install dependencies
+    let dir = path.resolve(getRootDir(), pkgPath);
+    let config = readConfig(path.join(dir, 'mops.toml'));
+    return installDeps(Object.values(config.dependencies || {}), { silent, verbose }, pkgPath);
+}

package/dist/commands/install/install-mops-dep.d.ts

@@ -0,0 +1,8 @@
+type InstallMopsDepOptions = {
+    verbose?: boolean;
+    silent?: boolean;
+    dep?: boolean;
+    threads?: number;
+};
+export declare function installMopsDep(pkg: string, version?: string, { verbose, silent, dep, threads }?: InstallMopsDepOptions): Promise<boolean>;
+export {};

package/dist/commands/install/install-mops-dep.js

@@ -0,0 +1,97 @@
+import process from 'node:process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { Buffer } from 'node:buffer';
+import { createLogUpdate } from 'log-update';
+import chalk from 'chalk';
+import { deleteSync } from 'del';
+import { checkConfigFile, progressBar, readConfig } from '../../mops.js';
+import { getHighestVersion } from '../../api/getHighestVersion.js';
+import { storageActor } from '../../api/actors.js';
+import { parallel } from '../../parallel.js';
+import { getDepCacheDir, getMopsDepCacheName, isDepCached } from '../../cache.js';
+import { downloadFile, getPackageFilesInfo } from '../../api/downloadPackageFiles.js';
+import { installDeps } from './install-deps.js';
+export async function installMopsDep(pkg, version = '', { verbose, silent, dep, threads } = {}) {
+    threads = threads || 12;
+    if (!checkConfigFile()) {
+        return false;
+    }
+    let logUpdate = createLogUpdate(process.stdout, { showCursor: true });
+    // 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 cacheName = getMopsDepCacheName(pkg, version);
+    let cacheDir = getDepCacheDir(cacheName);
+    // global cache hit
+    if (isDepCached(cacheName)) {
+        silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${pkg}@${version} (cache)`);
+    }
+    // download
+    else {
+        // GitHub Actions fails with "fetch failed" if there are multiple concurrent actions
+        if (process.env.GITHUB_ENV) {
+            threads = 4;
+        }
+        try {
+            let { storageId, fileIds } = await getPackageFilesInfo(pkg, version);
+            total = fileIds.length + 2;
+            let filesData = new Map;
+            let storage = await storageActor(storageId);
+            await parallel(threads, fileIds, async (fileId) => {
+                let { path, data } = await downloadFile(storage, fileId);
+                filesData.set(path, data);
+                progress();
+            });
+            let onSigInt = () => {
+                deleteSync([cacheDir], { force: true });
+                process.exit();
+            };
+            process.on('SIGINT', onSigInt);
+            // write files to global cache
+            try {
+                await Promise.all(Array.from(filesData.entries()).map(async ([filePath, data]) => {
+                    await fs.promises.mkdir(path.join(cacheDir, path.dirname(filePath)), { recursive: true });
+                    await fs.promises.writeFile(path.join(cacheDir, filePath), Buffer.from(data));
+                }));
+            }
+            catch (err) {
+                console.error(chalk.red('Error: ') + err);
+                deleteSync([cacheDir], { force: true });
+                return false;
+            }
+            process.off('SIGINT', onSigInt);
+        }
+        catch (err) {
+            console.error(chalk.red('Error: ') + err);
+            return false;
+        }
+        progress();
+    }
+    if (verbose) {
+        silent || logUpdate.done();
+    }
+    else {
+        logUpdate.clear();
+    }
+    // install dependencies
+    let config = readConfig(path.join(cacheDir, 'mops.toml'));
+    let res = await installDeps(Object.values(config.dependencies || {}), { silent, verbose });
+    if (!res) {
+        return false;
+    }
+    return true;
+}

package/dist/commands/install/sync-local-cache.d.ts

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

package/dist/commands/install/sync-local-cache.js

@@ -0,0 +1,26 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { copyCache, getDepCacheName } from '../../cache.js';
+import { getDependencyType, getRootDir } from '../../mops.js';
+import { resolvePackages } from '../../resolve-packages.js';
+export async function syncLocalCache({ verbose = false } = {}) {
+    let resolvedPackages = await resolvePackages();
+    let rootDir = getRootDir();
+    verbose && console.log('Syncing local cache...');
+    let installedDeps = {};
+    await Promise.all(Object.entries(resolvedPackages).map(([name, value]) => {
+        let depType = getDependencyType(value);
+        if (depType === 'mops' || depType === 'github') {
+            let cacheName = getDepCacheName(name, value);
+            let dest = path.join(rootDir, '.mops', cacheName);
+            if (!fs.existsSync(dest)) {
+                if (depType === 'mops') {
+                    installedDeps[name] = value;
+                }
+                return copyCache(cacheName, path.join(rootDir, '.mops', cacheName));
+            }
+        }
+        return Promise.resolve();
+    }));
+    return installedDeps;
+}

package/dist/commands/publish.js

@@ -1,3 +1,4 @@
+import process from 'node:process';
 import fs from 'node:fs';
 import path from 'node:path';
 import chalk from 'chalk';