ic-mops 0.39.2 → 0.40.0

package/dist/declarations/bench/bench.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 interface BenchResult {
   'instructions' : bigint,
@@ -24,3 +25,5 @@ export interface anon_class_10_1 {
   'runCellUpdateAwait' : ActorMethod<[bigint, bigint], BenchResult>,
 }
 export interface _SERVICE extends anon_class_10_1 {}
+export declare const idlFactory: IDL.InterfaceFactory;
+export declare const init: ({ IDL }: { IDL: IDL }) => IDL.Type[];

package/dist/declarations/main/main.did

@@ -216,6 +216,7 @@ type PackageFileStatsPublic =
  };
 type PackageDetails = 
  record {
+   benchmarks: Benchmarks__1;
    changes: PackageChanges;
    config: PackageConfigV2__1;
    dependents: vec PackageSummary__1;
@@ -273,9 +274,11 @@ type PackageConfigV2 =
  };
 type PackageChanges = 
  record {
+   curBenchmarks: Benchmarks__1;
    deps: vec DepChange;
    devDeps: vec DepChange;
    notes: text;
+   prevBenchmarks: Benchmarks__1;
    tests: TestsChanges;
  };
 type Main = 
@@ -303,6 +306,7 @@ type Main =
                  blob;
                };
          });
+   getFileHashesQuery: (PackageName, PackageVersion) -> (Result_8) query;
    getFileIds: (PackageName, PackageVersion) -> (Result_7) query;
    getHighestSemverBatch:
     (vec record {
@@ -333,13 +337,14 @@ type Main =
                           PackageName;
                           PackageVersion;
                         }) -> () oneway;
-   restore: (nat, nat) -> ();
+   restore: (nat) -> ();
    search: (Text, opt nat, opt nat) -> (vec PackageSummary, PageCount) query;
    setUserProp: (text, text) -> (Result_1);
    startFileUpload: (PublishingId, Text, nat, blob) -> (Result_3);
    startPublish: (PackageConfigV2) -> (Result_2);
    transferOwnership: (PackageName, principal) -> (Result_1);
    transformRequest: (HttpTransformArg) -> (HttpResponse) query;
+   uploadBenchmarks: (PublishingId, Benchmarks) -> (Result);
    uploadFileChunk: (PublishingId, FileId, nat, blob) -> (Result);
    uploadNotes: (PublishingId, text) -> (Result);
    uploadTestStats: (PublishingId, TestStats) -> (Result);
@@ -397,4 +402,25 @@ type DepChange =
    newVersion: text;
    oldVersion: text;
  };
+type Benchmarks__1 = vec Benchmark;
+type Benchmarks = vec Benchmark;
+type BenchmarkMetric = text;
+type Benchmark = 
+ record {
+   cols: vec text;
+   compiler: text;
+   compilerVersion: text;
+   description: text;
+   file: text;
+   forceGC: bool;
+   gc: text;
+   metrics: vec record {
+                  BenchmarkMetric;
+                  vec vec int;
+                };
+   name: text;
+   replica: text;
+   replicaVersion: text;
+   rows: vec text;
+ };
 service : () -> Main

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

@@ -1,6 +1,24 @@
 import type { Principal } from '@dfinity/principal';
 import type { ActorMethod } from '@dfinity/agent';
+import type { IDL } from '@dfinity/candid';
 
+export interface Benchmark {
+  'gc' : string,
+  'metrics' : Array<[BenchmarkMetric, Array<Array<bigint>>]>,
+  'cols' : Array<string>,
+  'file' : string,
+  'name' : string,
+  'rows' : Array<string>,
+  'description' : string,
+  'compilerVersion' : string,
+  'compiler' : string,
+  'replica' : string,
+  'replicaVersion' : string,
+  'forceGC' : boolean,
+}
+export type BenchmarkMetric = string;
+export type Benchmarks = Array<Benchmark>;
+export type Benchmarks__1 = Array<Benchmark>;
 export interface DepChange {
   'oldVersion' : string,
   'name' : string,
@@ -60,6 +78,7 @@ export interface Main {
     [Array<PackageId>],
     Array<[PackageId, Array<[FileId, Uint8Array | number[]]>]>
   >,
+  'getFileHashesQuery' : ActorMethod<[PackageName, PackageVersion], Result_8>,
   'getFileIds' : ActorMethod<[PackageName, PackageVersion], Result_7>,
   'getHighestSemverBatch' : ActorMethod<
     [Array<[PackageName, PackageVersion, SemverPart]>],
@@ -88,7 +107,7 @@ export interface Main {
     [Array<[PackageName, PackageVersion]>],
     undefined
   >,
-  'restore' : ActorMethod<[bigint, bigint], undefined>,
+  'restore' : ActorMethod<[bigint], undefined>,
   'search' : ActorMethod<
     [Text, [] | [bigint], [] | [bigint]],
     [Array<PackageSummary>, PageCount]
@@ -101,6 +120,7 @@ export interface Main {
   'startPublish' : ActorMethod<[PackageConfigV2], Result_2>,
   'transferOwnership' : ActorMethod<[PackageName, Principal], Result_1>,
   'transformRequest' : ActorMethod<[HttpTransformArg], HttpResponse>,
+  'uploadBenchmarks' : ActorMethod<[PublishingId, Benchmarks], Result>,
   'uploadFileChunk' : ActorMethod<
     [PublishingId, FileId, bigint, Uint8Array | number[]],
     Result
@@ -111,6 +131,8 @@ export interface Main {
 export interface PackageChanges {
   'tests' : TestsChanges,
   'deps' : Array<DepChange>,
+  'curBenchmarks' : Benchmarks__1,
+  'prevBenchmarks' : Benchmarks__1,
   'notes' : string,
   'devDeps' : Array<DepChange>,
 }
@@ -151,6 +173,7 @@ export interface PackageConfigV2__1 {
   'readme' : string,
 }
 export interface PackageDetails {
+  'benchmarks' : Benchmarks__1,
   'ownerInfo' : User,
   'owner' : Principal,
   'deps' : Array<PackageSummary__1>,
@@ -325,3 +348,5 @@ export interface User__1 {
   'github' : string,
 }
 export interface _SERVICE extends Main {}
+export declare const idlFactory: IDL.InterfaceFactory;
+export declare const init: ({ IDL }: { IDL: IDL }) => IDL.Type[];

package/dist/declarations/main/main.did.js

@@ -95,6 +95,22 @@ export const idlFactory = ({ IDL }) => {
     'config' : PackageConfigV2__1,
     'publication' : PackagePublication,
   });
+  const BenchmarkMetric = IDL.Text;
+  const Benchmark = IDL.Record({
+    'gc' : IDL.Text,
+    'metrics' : IDL.Vec(IDL.Tuple(BenchmarkMetric, IDL.Vec(IDL.Vec(IDL.Int)))),
+    'cols' : IDL.Vec(IDL.Text),
+    'file' : IDL.Text,
+    'name' : IDL.Text,
+    'rows' : IDL.Vec(IDL.Text),
+    'description' : IDL.Text,
+    'compilerVersion' : IDL.Text,
+    'compiler' : IDL.Text,
+    'replica' : IDL.Text,
+    'replicaVersion' : IDL.Text,
+    'forceGC' : IDL.Bool,
+  });
+  const Benchmarks__1 = IDL.Vec(Benchmark);
   const PackageSummary__1 = IDL.Record({
     'ownerInfo' : User,
     'owner' : IDL.Principal,
@@ -130,6 +146,8 @@ export const idlFactory = ({ IDL }) => {
   const PackageChanges = IDL.Record({
     'tests' : TestsChanges,
     'deps' : IDL.Vec(DepChange),
+    'curBenchmarks' : Benchmarks__1,
+    'prevBenchmarks' : Benchmarks__1,
     'notes' : IDL.Text,
     'devDeps' : IDL.Vec(DepChange),
   });
@@ -145,6 +163,7 @@ export const idlFactory = ({ IDL }) => {
     'publication' : PackagePublication,
   });
   const PackageDetails = IDL.Record({
+    'benchmarks' : Benchmarks__1,
     'ownerInfo' : User,
     'owner' : IDL.Principal,
     'deps' : IDL.Vec(PackageSummary__1),
@@ -255,6 +274,7 @@ export const idlFactory = ({ IDL }) => {
     'context' : IDL.Vec(IDL.Nat8),
     'response' : HttpResponse,
   });
+  const Benchmarks = IDL.Vec(Benchmark);
   const TestStats = IDL.Record({
     'passedNames' : IDL.Vec(IDL.Text),
     'passed' : IDL.Nat,
@@ -290,6 +310,11 @@ export const idlFactory = ({ IDL }) => {
         ],
         [],
       ),
+    'getFileHashesQuery' : IDL.Func(
+        [PackageName, PackageVersion],
+        [Result_8],
+        ['query'],
+      ),
     'getFileIds' : IDL.Func(
         [PackageName, PackageVersion],
         [Result_7],
@@ -342,7 +367,7 @@ export const idlFactory = ({ IDL }) => {
         [],
         ['oneway'],
       ),
-    'restore' : IDL.Func([IDL.Nat, IDL.Nat], [], []),
+    'restore' : IDL.Func([IDL.Nat], [], []),
     'search' : IDL.Func(
         [Text, IDL.Opt(IDL.Nat), IDL.Opt(IDL.Nat)],
         [IDL.Vec(PackageSummary), PageCount],
@@ -365,6 +390,7 @@ export const idlFactory = ({ IDL }) => {
         [HttpResponse],
         ['query'],
       ),
+    'uploadBenchmarks' : IDL.Func([PublishingId, Benchmarks], [Result], []),
     'uploadFileChunk' : IDL.Func(
         [PublishingId, FileId, IDL.Nat, IDL.Vec(IDL.Nat8)],
         [Result],

package/dist/helpers/find-changelog-entry.d.ts

@@ -0,0 +1 @@
+export declare function findChangelogEntry(changelog: string, version: string): string;

package/dist/helpers/find-changelog-entry.js

@@ -0,0 +1,24 @@
+import { fromMarkdown } from 'mdast-util-from-markdown';
+import { toMarkdown } from 'mdast-util-to-markdown';
+export function findChangelogEntry(changelog, version) {
+    let tree = fromMarkdown(changelog);
+    let found = false;
+    let nodes = [];
+    for (let node of tree.children) {
+        if (found) {
+            if (node.type === 'heading') {
+                break;
+            }
+            else {
+                nodes.push(node);
+            }
+        }
+        else if (node.type === 'heading' && toMarkdown(node).match(new RegExp(`\\b${version}\\b`))) {
+            found = true;
+        }
+    }
+    return toMarkdown({
+        type: 'root',
+        children: nodes,
+    });
+}

package/dist/mops.js

@@ -82,7 +82,7 @@ export let getIdentity = async () => {
         let res = await prompts({
             type: 'invisible',
             name: 'value',
-            message: 'Enter password:'
+            message: 'Enter password:',
         });
         return await decodeFile(identityPemEncrypted, res.value);
     }

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ic-mops",
-  "version": "0.39.2",
+  "version": "0.40.0",
   "type": "module",
   "bin": {
     "mops": "dist/bin/mops.js",

package/dist/release-cli.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/release-cli.js

@@ -0,0 +1,35 @@
+/* eslint-disable no-undef */
+import fs from 'node:fs';
+import path from 'node:path';
+import { URL } from 'node:url';
+import { execSync } from 'node:child_process';
+import semver from 'semver';
+import { sha256 } from '@noble/hashes/sha256';
+import { bytesToHex } from '@noble/hashes/utils';
+import { findChangelogEntry } from './helpers/find-changelog-entry.js';
+let __dirname = new URL('.', import.meta.url).pathname;
+execSync('npm run prepare', { stdio: 'inherit', cwd: __dirname });
+execSync('npm run bundle', { stdio: 'inherit', cwd: __dirname });
+let version = JSON.parse(fs.readFileSync(path.resolve(__dirname, 'package.json'), 'utf8')).version;
+let major = semver.parse(version)?.major;
+let tag = semver.parse(version)?.prerelease[0] || 'latest';
+let releaseNotes = findChangelogEntry(fs.readFileSync(path.resolve(__dirname, 'CHANGELOG.md'), 'utf8'), version);
+let hash = bytesToHex(sha256(fs.readFileSync(path.resolve(__dirname, 'bundle/cli.tgz'))));
+fs.cpSync(path.resolve(__dirname, 'bundle/cli.tgz'), path.resolve(__dirname, `../cli-releases/versions/${version}/cli.tgz`), { force: false, errorOnExist: true });
+fs.writeFileSync(path.resolve(__dirname, `../cli-releases/versions/${version}/RELEASE_NOTES.md`), releaseNotes);
+fs.writeFileSync(path.resolve(__dirname, `../cli-releases/versions/${version}/cli.tgz.sha256`), hash);
+fs.cpSync(path.resolve(__dirname, `../cli-releases/versions/${version}`), path.resolve(__dirname, `../cli-releases/versions/${tag}`), { force: true, errorOnExist: false, recursive: true });
+fs.cpSync(path.resolve(__dirname, `../cli-releases/versions/${version}`), path.resolve(__dirname, `../cli-releases/versions/${major}`), { force: true, errorOnExist: false, recursive: true });
+fs.writeFileSync(path.resolve(__dirname, `../cli-releases/tags/${tag}`), version);
+console.log(`Release '${version}' created with tag '${tag}'`);
+if (!fs.existsSync(path.resolve(__dirname, '../cli-releases/releases.json'))) {
+    fs.writeFileSync(path.resolve(__dirname, '../cli-releases/releases.json'), JSON.stringify({ tags: {}, versions: {} }, null, 2));
+}
+let releases = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../cli-releases/releases.json'), 'utf8'));
+releases.tags[tag] = version;
+releases.versions[version] = {
+    relseaseNotes: releaseNotes,
+    hash,
+    url: `https://cli.mops.one/versions/${version}/cli.tgz`,
+};
+fs.writeFileSync(path.resolve(__dirname, '../cli-releases/releases.json'), JSON.stringify(releases, null, 2));

package/dist/remove-scripts.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/remove-scripts.js

@@ -0,0 +1,5 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+let text = readFileSync('dist/package.json', 'utf8');
+let json = JSON.parse(text);
+delete json.scripts;
+writeFileSync('dist/package.json', JSON.stringify(json, null, 2));

package/dist/vessel.js

@@ -37,7 +37,7 @@ export const readVesselConfig = async (dir, { cache = true, silent = false } = {
     }
     const [vessel, packageSetArray] = await Promise.all([
         dhallFileToJson((dir || process.cwd()) + '/vessel.dhall', silent),
-        dhallFileToJson((dir || process.cwd()) + '/package-set.dhall', silent)
+        dhallFileToJson((dir || process.cwd()) + '/package-set.dhall', silent),
     ]);
     if (!vessel || !packageSetArray) {
         return null;

package/helpers/get-dfx-version.ts

@@ -1,6 +1,6 @@
 import {execSync} from 'node:child_process';
 
-export function getDfxVersion(): string {
+export function getDfxVersion() : string {
 	try {
 		let res = execSync('dfx --version').toString();
 		return res.trim().split('dfx ')[1] || '';

package/helpers/get-moc-path.ts

@@ -1,6 +1,6 @@
 import {execSync} from 'node:child_process';
 
-export function getMocPath(): string {
+export function getMocPath() : string {
 	let mocPath = process.env.DFX_MOC_PATH;
 	if (!mocPath) {
 		mocPath = execSync('dfx cache show').toString().trim() + '/moc';

package/helpers/get-moc-version.ts

@@ -1,7 +1,7 @@
 import {execSync} from 'node:child_process';
 import {getMocPath} from './get-moc-path.js';
 
-export function getMocVersion(): string {
+export function getMocVersion() : string {
 	let mocPath = getMocPath();
 	let match = execSync(mocPath).toString().trim().match(/Motoko compiler ([^\s]+) .*/);
 	return match?.[1] || '';

package/integrity.ts

@@ -7,24 +7,24 @@ import {mainActor} from './api/actors.js';
 import {resolvePackages} from './resolve-packages.js';
 
 type LockFileGeneric = {
-	version: number;
+	version : number;
 };
 
 type LockFileV1 = {
-	version: 1;
-	mopsTomlHash: string;
-	hashes: Record<string, Record<string, string>>;
+	version : 1;
+	mopsTomlHash : string;
+	hashes : Record<string, Record<string, string>>;
 };
 
 type LockFileV2 = {
-	version: 2;
-	mopsTomlDepsHash: string;
-	hashes: Record<string, Record<string, string>>;
+	version : 2;
+	mopsTomlDepsHash : string;
+	hashes : Record<string, Record<string, string>>;
 };
 
 type LockFile = LockFileV1 | LockFileV2;
 
-export async function checkIntegrity(lock?: 'check' | 'update' | 'ignore') {
+export async function checkIntegrity(lock ?: 'check' | 'update' | 'ignore') {
 	let force = !!lock;
 
 	if (!lock && !process.env['CI'] && fs.existsSync(path.join(getRootDir(), 'mops.lock'))) {
@@ -44,14 +44,14 @@ export async function checkIntegrity(lock?: 'check' | 'update' | 'ignore') {
 	}
 }
 
-async function getFileHashesFromRegistry(): Promise<[string, [string, Uint8Array | number[]][]][]> {
+async function getFileHashesFromRegistry() : Promise<[string, [string, Uint8Array | number[]][]][]> {
 	let packageIds = await getResolvedMopsPackageIds();
 	let actor = await mainActor();
 	let fileHashesByPackageIds = await actor.getFileHashesByPackageIds(packageIds);
 	return fileHashesByPackageIds;
 }
 
-async function getResolvedMopsPackageIds(): Promise<string[]> {
+async function getResolvedMopsPackageIds() : Promise<string[]> {
 	let resolvedPackages = await resolvePackages();
 	let packageIds = Object.entries(resolvedPackages)
 		.filter(([_, version]) => getDependencyType(version) === 'mops')
@@ -60,7 +60,7 @@ async function getResolvedMopsPackageIds(): Promise<string[]> {
 }
 
 // get hash of local file from '.mops' dir by fileId
-export function getLocalFileHash(fileId: string): string {
+export function getLocalFileHash(fileId : string) : string {
 	let rootDir = getRootDir();
 	let file = path.join(rootDir, '.mops', fileId);
 	if (!fs.existsSync(file)) {
@@ -71,11 +71,11 @@ export function getLocalFileHash(fileId: string): string {
 	return bytesToHex(sha256(fileData));
 }
 
-function getMopsTomlHash(): string {
+function getMopsTomlHash() : string {
 	return bytesToHex(sha256(fs.readFileSync(getRootDir() + '/mops.toml')));
 }
 
-function getMopsTomlDepsHash(): string {
+function getMopsTomlDepsHash() : string {
 	let config = readConfig();
 	let deps = config.dependencies || {};
 	let devDeps = config['dev-dependencies'] || {};
@@ -113,7 +113,7 @@ export async function updateLockFile() {
 
 	// if lock file exists and mops.toml hasn't changed, don't update it
 	if (fs.existsSync(lockFile)) {
-		let lockFileJson: LockFileV2 = JSON.parse(fs.readFileSync(lockFile).toString());
+		let lockFileJson : LockFileV2 = JSON.parse(fs.readFileSync(lockFile).toString());
 		let mopsTomlDepsHash = getMopsTomlDepsHash();
 		if (mopsTomlDepsHash === lockFileJson.mopsTomlDepsHash) {
 			return;
@@ -122,7 +122,7 @@ export async function updateLockFile() {
 
 	let fileHashes = await getFileHashesFromRegistry();
 
-	let lockFileJson: LockFileV2 = {
+	let lockFileJson : LockFileV2 = {
 		version: 2,
 		mopsTomlDepsHash: getMopsTomlDepsHash(),
 		hashes: fileHashes.reduce((acc, [packageId, fileHashes]) => {
@@ -151,7 +151,7 @@ export async function checkLockFile(force = false) {
 		return;
 	}
 
-	let lockFileJsonGeneric: LockFileGeneric = JSON.parse(fs.readFileSync(lockFile).toString());
+	let lockFileJsonGeneric : LockFileGeneric = JSON.parse(fs.readFileSync(lockFile).toString());
 	let packageIds = await getResolvedMopsPackageIds();
 
 	// check lock file version