ic-mops 1.11.1 → 2.0.0

package/.eslintrc.json

@@ -1,8 +1,8 @@
 {
-    "env": {
-        "node": true
-    },
-    "parserOptions": {
-        "sourceType": "module"
-    }
-}
+  "env": {
+    "node": true
+  },
+  "parserOptions": {
+    "sourceType": "module"
+  }
+}

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Mops CLI Changelog
 
+## Next
+- `mops publish` add support for subheadings in changelog (by @f0i)
+- `mops toolchain` now downloads `moc.js` in addition to `moc` binary
+- New `mops build` subcommand (alternative to `dfx build`)
+- `core` package used in place of `base` for benchmarks
+
+## 1.12.0
+- Add pinned dependencies support to `mops update` and `mops outdated` commands
+- Add support for pocket-ic v9
+- Migrate from `@dfinity/*` packages to `@icp-sdk/core` package
+- `mops test` now runs replica tests sequentially
+
+## 1.11.1
+- Fix `Cannot find module 'simple-cbor'` error
+
 ## 1.11.0
 - Fix `mops bench` to work with moc >= 0.15.0
 - `mops test` now detects persistent actor to run in replica mode

package/api/actors.ts

@@ -1,53 +1,57 @@
-import {Actor, HttpAgent, Identity} from '@dfinity/agent';
-import {Principal} from '@dfinity/principal';
+import { Actor, HttpAgent, Identity } from "@icp-sdk/core/agent";
+import { Principal } from "@icp-sdk/core/principal";
 
-import {_SERVICE, idlFactory} from '../declarations/main/main.did.js';
-import {idlFactory as storageIdlFactory} from '../declarations/storage/storage.did.js';
-import {_SERVICE as _STORAGE_SERVICE} from '../declarations/storage/storage.did.js';
+import { _SERVICE, idlFactory } from "../declarations/main/main.did.js";
+import { idlFactory as storageIdlFactory } from "../declarations/storage/storage.did.js";
+import { _SERVICE as _STORAGE_SERVICE } from "../declarations/storage/storage.did.js";
 
-import {getEndpoint} from './network.js';
-import {getNetwork} from './network.js';
+import { getEndpoint } from "./network.js";
+import { getNetwork } from "./network.js";
 
 let agentPromiseByPrincipal = new Map<string, Promise<HttpAgent>>();
 
-let getAgent = async (identity ?: Identity) : Promise<HttpAgent> => {
-	let principal = identity ? identity?.getPrincipal().toText() : '';
-	let agentPromise = agentPromiseByPrincipal.get(principal);
+let getAgent = async (identity?: Identity): Promise<HttpAgent> => {
+  let principal = identity ? identity?.getPrincipal().toText() : "";
+  let agentPromise = agentPromiseByPrincipal.get(principal);
 
-	if (!agentPromise) {
-		let network = getNetwork();
-		let host = getEndpoint(network).host;
+  if (!agentPromise) {
+    let network = getNetwork();
+    let host = getEndpoint(network).host;
 
-		agentPromise = HttpAgent.create({
-			host,
-			identity,
-			shouldFetchRootKey: network === 'local',
-			verifyQuerySignatures: process.env.MOPS_VERIFY_QUERY_SIGNATURES !== 'false',
-			shouldSyncTime: true,
-		});
+    agentPromise = HttpAgent.create({
+      host,
+      identity,
+      shouldFetchRootKey: network === "local",
+      verifyQuerySignatures:
+        process.env.MOPS_VERIFY_QUERY_SIGNATURES !== "false",
+      shouldSyncTime: true,
+    });
 
-		agentPromiseByPrincipal.set(principal, agentPromise);
-	}
+    agentPromiseByPrincipal.set(principal, agentPromise);
+  }
 
-	return agentPromise;
+  return agentPromise;
 };
 
-export let mainActor = async (identity ?: Identity) : Promise<_SERVICE> => {
-	let agent = await getAgent(identity);
-	let network = getNetwork();
-	let canisterId = getEndpoint(network).canisterId;
+export let mainActor = async (identity?: Identity): Promise<_SERVICE> => {
+  let agent = await getAgent(identity);
+  let network = getNetwork();
+  let canisterId = getEndpoint(network).canisterId;
 
-	return Actor.createActor(idlFactory, {
-		agent,
-		canisterId,
-	});
+  return Actor.createActor(idlFactory, {
+    agent,
+    canisterId,
+  });
 };
 
-export let storageActor = async (storageId : Principal, identity ?: Identity) : Promise<_STORAGE_SERVICE> => {
-	let agent = await getAgent(identity);
+export let storageActor = async (
+  storageId: Principal,
+  identity?: Identity,
+): Promise<_STORAGE_SERVICE> => {
+  let agent = await getAgent(identity);
 
-	return Actor.createActor(storageIdlFactory, {
-		agent,
-		canisterId: storageId,
-	});
+  return Actor.createActor(storageIdlFactory, {
+    agent,
+    canisterId: storageId,
+  });
 };

package/api/downloadPackageFiles.ts

@@ -1,81 +1,95 @@
-import {Principal} from '@dfinity/principal';
-import {mainActor, storageActor} from './actors.js';
-import {resolveVersion} from './resolveVersion.js';
-import {parallel} from '../parallel.js';
-import {Storage} from '../declarations/storage/storage.did.js';
+import { Principal } from "@icp-sdk/core/principal";
+import { mainActor, storageActor } from "./actors.js";
+import { resolveVersion } from "./resolveVersion.js";
+import { parallel } from "../parallel.js";
+import { Storage } from "../declarations/storage/storage.did.js";
 
-export async function downloadPackageFiles(pkg : string, version = '', threads = 8, onLoad = (_fileIds : string[], _fileId : string) => {}) : Promise<Map<string, Array<number>>> {
-	version = await resolveVersion(pkg, version);
+export async function downloadPackageFiles(
+  pkg: string,
+  version = "",
+  threads = 8,
+  onLoad = (_fileIds: string[], _fileId: string) => {},
+): Promise<Map<string, Array<number>>> {
+  version = await resolveVersion(pkg, version);
 
-	let {storageId, fileIds} = await getPackageFilesInfo(pkg, version);
-	let storage = await storageActor(storageId);
+  let { storageId, fileIds } = await getPackageFilesInfo(pkg, version);
+  let storage = await storageActor(storageId);
 
-	let filesData = new Map<string, Array<number>>();
-	await parallel(threads, fileIds, async (fileId : string) => {
-		let {path, data} = await downloadFile(storage, fileId);
-		filesData.set(path, data);
-		onLoad(fileIds, fileId);
-	});
+  let filesData = new Map<string, Array<number>>();
+  await parallel(threads, fileIds, async (fileId: string) => {
+    let { path, data } = await downloadFile(storage, fileId);
+    filesData.set(path, data);
+    onLoad(fileIds, fileId);
+  });
 
-	return filesData;
+  return filesData;
 }
 
 // get package files meta
-export async function getPackageFilesInfo(pkg : string, version : string) : Promise<{ storageId : Principal, fileIds : string[] }> {
-	let actor = await mainActor();
+export async function getPackageFilesInfo(
+  pkg: string,
+  version: string,
+): Promise<{ storageId: Principal; fileIds: string[] }> {
+  let actor = await mainActor();
 
-	let [packageDetailsRes, fileIds] = await Promise.all([
-		actor.getPackageDetails(pkg, version),
-		getFileIds(pkg, version),
-	]);
+  let [packageDetailsRes, fileIds] = await Promise.all([
+    actor.getPackageDetails(pkg, version),
+    getFileIds(pkg, version),
+  ]);
 
-	if ('err' in packageDetailsRes) {
-		throw packageDetailsRes.err;
-	}
-	let packageDetails = packageDetailsRes.ok;
+  if ("err" in packageDetailsRes) {
+    throw packageDetailsRes.err;
+  }
+  let packageDetails = packageDetailsRes.ok;
 
-	return {
-		storageId: packageDetails.publication.storage,
-		fileIds,
-	};
+  return {
+    storageId: packageDetails.publication.storage,
+    fileIds,
+  };
 }
 
 // get package files ids
-export async function getFileIds(pkg : string, version : string) : Promise<string[]> {
-	let actor = await mainActor();
-	let fileIdsRes = await actor.getFileIds(pkg, version);
+export async function getFileIds(
+  pkg: string,
+  version: string,
+): Promise<string[]> {
+  let actor = await mainActor();
+  let fileIdsRes = await actor.getFileIds(pkg, version);
 
-	if ('err' in fileIdsRes) {
-		throw fileIdsRes.err;
-	}
-	let filesIds = fileIdsRes.ok;
+  if ("err" in fileIdsRes) {
+    throw fileIdsRes.err;
+  }
+  let filesIds = fileIdsRes.ok;
 
-	return filesIds;
+  return filesIds;
 }
 
 // download single file
-export async function downloadFile(storage : Storage | string, fileId : string) : Promise<{path : string, data : Array<number>;}> {
-	if (typeof storage === 'string') {
-		storage = await storageActor(Principal.fromText(storage));
-	}
-	let fileMetaRes = await storage.getFileMeta(fileId);
-	if ('err' in fileMetaRes) {
-		throw fileMetaRes.err;
-	}
-	let fileMeta = fileMetaRes.ok;
+export async function downloadFile(
+  storage: Storage | string,
+  fileId: string,
+): Promise<{ path: string; data: Array<number> }> {
+  if (typeof storage === "string") {
+    storage = await storageActor(Principal.fromText(storage));
+  }
+  let fileMetaRes = await storage.getFileMeta(fileId);
+  if ("err" in fileMetaRes) {
+    throw fileMetaRes.err;
+  }
+  let fileMeta = fileMetaRes.ok;
 
-	let data : Array<number> = [];
-	for (let i = 0n; i < fileMeta.chunkCount; i++) {
-		let chunkRes = await storage.downloadChunk(fileId, i);
-		if ('err' in chunkRes) {
-			throw chunkRes.err;
-		}
-		let chunk = chunkRes.ok;
-		data = [...data, ...chunk];
-	}
+  let data: Array<number> = [];
+  for (let i = 0n; i < fileMeta.chunkCount; i++) {
+    let chunkRes = await storage.downloadChunk(fileId, i);
+    if ("err" in chunkRes) {
+      throw chunkRes.err;
+    }
+    let chunk = chunkRes.ok;
+    data = [...data, ...chunk];
+  }
 
-	return {
-		path: fileMeta.path,
-		data: data,
-	};
-}
+  return {
+    path: fileMeta.path,
+    data: data,
+  };
+}

package/api/getHighestVersion.ts

@@ -1,6 +1,6 @@
-import {mainActor} from './actors.js';
+import { mainActor } from "./actors.js";
 
-export async function getHighestVersion(pkgName : string) {
-	let actor = await mainActor();
-	return actor.getHighestVersion(pkgName);
-}
+export async function getHighestVersion(pkgName: string) {
+  let actor = await mainActor();
+  return actor.getHighestVersion(pkgName);
+}

package/api/index.ts

@@ -1,4 +1,4 @@
-export {mainActor, storageActor} from './actors.js';
-export {downloadPackageFiles} from './downloadPackageFiles.js';
-export {getEndpoint, getNetwork} from './network.js';
-export {resolveVersion} from './resolveVersion.js';
+export { mainActor, storageActor } from "./actors.js";
+export { downloadPackageFiles } from "./downloadPackageFiles.js";
+export { getEndpoint, getNetwork } from "./network.js";
+export { resolveVersion } from "./resolveVersion.js";

package/api/network.ts

@@ -1,24 +1,22 @@
 export function getNetwork() {
-	return globalThis.MOPS_NETWORK || 'ic';
+  return globalThis.MOPS_NETWORK || "ic";
 }
 
-export function getEndpoint(network : string) {
-	if (network === 'staging') {
-		return {
-			host: 'https://icp-api.io',
-			canisterId: '2d2zu-vaaaa-aaaak-qb6pq-cai',
-		};
-	}
-	else if (network === 'ic') {
-		return {
-			host: 'https://icp-api.io',
-			canisterId: 'oknww-riaaa-aaaam-qaf6a-cai',
-		};
-	}
-	else {
-		return {
-			host: 'http://127.0.0.1:4943',
-			canisterId: '2d2zu-vaaaa-aaaak-qb6pq-cai',
-		};
-	}
-}
+export function getEndpoint(network: string) {
+  if (network === "staging") {
+    return {
+      host: "https://icp-api.io",
+      canisterId: "2d2zu-vaaaa-aaaak-qb6pq-cai",
+    };
+  } else if (network === "ic") {
+    return {
+      host: "https://icp-api.io",
+      canisterId: "oknww-riaaa-aaaam-qaf6a-cai",
+    };
+  } else {
+    return {
+      host: "http://127.0.0.1:4943",
+      canisterId: "2d2zu-vaaaa-aaaak-qb6pq-cai",
+    };
+  }
+}

package/api/resolveVersion.ts

@@ -1,12 +1,15 @@
-import {getHighestVersion} from './getHighestVersion.js';
+import { getHighestVersion } from "./getHighestVersion.js";
 
-export async function resolveVersion(pkg : string, version = '') : Promise<string> {
-	if (!version) {
-		let versionRes = await getHighestVersion(pkg);
-		if ('err' in versionRes) {
-			throw versionRes.err;
-		}
-		version = versionRes.ok;
-	}
-	return version;
-}
+export async function resolveVersion(
+  pkg: string,
+  version = "",
+): Promise<string> {
+  if (!version) {
+    let versionRes = await getHighestVersion(pkg);
+    if ("err" in versionRes) {
+      throw versionRes.err;
+    }
+    version = versionRes.ok;
+  }
+  return version;
+}

package/bin/mops.js

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
 
-import '../cli.js';
+import "../cli.js";