ic-mops 2.10.0 → 2.11.0

package/dist/cli.js

@@ -33,6 +33,7 @@ import { test } from "./commands/test/test.js";
 import { toolchain } from "./commands/toolchain/index.js";
 import { update } from "./commands/update.js";
 import { getPrincipal, getUserProp, importPem, setUserProp, } from "./commands/user.js";
+import { migrateNew, migrateFreeze } from "./commands/migrate.js";
 import { watch } from "./commands/watch/watch.js";
 import { apiVersion, checkApiCompatibility, checkConfigFile, getGlobalMocArgs, getNetworkFile, readConfig, setNetwork, version, } from "./mops.js";
 import { resolvePackages } from "./resolve-packages.js";
@@ -550,6 +551,23 @@ toolchainCommand
     console.log(bin);
 });
 program.addCommand(toolchainCommand);
+// migrate
+const migrateCommand = new Command("migrate").description("Manage enhanced migration chains");
+migrateCommand
+    .command("new <name> [canister]")
+    .description("Create a new migration file in the next-migration directory")
+    .action(async (name, canister) => {
+    checkConfigFile(true);
+    await migrateNew(name, canister);
+});
+migrateCommand
+    .command("freeze [canister]")
+    .description("Move the next migration into the frozen chain")
+    .action(async (canister) => {
+    checkConfigFile(true);
+    await migrateFreeze(canister);
+});
+program.addCommand(migrateCommand);
 // self
 const selfCommand = new Command("self").description("Mops CLI management");
 selfCommand

package/dist/commands/build.js

@@ -7,6 +7,7 @@ import { lock, unlockSync } from "proper-lockfile";
 import { cliError } from "../error.js";
 import { isCandidCompatible } from "../helpers/is-candid-compatible.js";
 import { filterCanisters, resolveCanisterConfigs, validateCanisterArgs, } from "../helpers/resolve-canisters.js";
+import { prepareMigrationArgs } from "../helpers/migrations.js";
 import { getWasmBindings } from "../wasm.js";
 import { getGlobalMocArgs, readConfig, resolveConfigPath } from "../mops.js";
 import { sourcesArgs } from "./sources.js";
@@ -62,6 +63,7 @@ export async function build(canisterNames, options) {
             catch { }
         };
         process.on("exit", exitCleanup);
+        const migration = await prepareMigrationArgs(canister.migrations, canisterName, "build", options.verbose);
         try {
             let args = [
                 "-c",
@@ -72,6 +74,7 @@ export async function build(canisterNames, options) {
                 motokoPath,
                 ...(await sourcesArgs()).flat(),
                 ...getGlobalMocArgs(config),
+                ...migration.migrationArgs,
             ];
             args.push(...collectExtraArgs(config, canister, canisterName, options.extraArgs));
             const isPublicCandid = true; // always true for now to reduce corner cases
@@ -148,6 +151,7 @@ export async function build(canisterNames, options) {
             }
         }
         finally {
+            await migration.cleanup();
             process.removeListener("exit", exitCleanup);
             try {
                 await release?.();
@@ -173,7 +177,7 @@ function collectExtraArgs(config, canister, canisterName, extraArgs) {
         args.push(...config.build.args);
     }
     if (canister.args) {
-        validateCanisterArgs(canister, canisterName);
+        validateCanisterArgs(canister, canisterName, config);
         args.push(...canister.args);
     }
     if (extraArgs) {

package/dist/commands/check-stable.d.ts

@@ -16,5 +16,6 @@ export interface RunStableCheckParams {
     canisterArgs: string[];
     sources?: string[];
     options?: Partial<CheckStableOptions>;
+    hasMigrations?: boolean;
 }
 export declare function runStableCheck(params: RunStableCheckParams): Promise<void>;

package/dist/commands/check-stable.js

@@ -4,6 +4,7 @@ import { rm } from "node:fs/promises";
 import chalk from "chalk";
 import { execa } from "execa";
 import { cliError } from "../error.js";
+import { prepareMigrationArgs } from "../helpers/migrations.js";
 import { getGlobalMocArgs, readConfig, resolveConfigPath } from "../mops.js";
 import { filterCanisters, looksLikeFile, resolveCanisterConfigs, resolveSingleCanister, validateCanisterArgs, } from "../helpers/resolve-canisters.js";
 import { sourcesArgs } from "./sources.js";
@@ -41,16 +42,23 @@ export async function checkStable(args, options = {}) {
         if (!canister.main) {
             cliError(`No main file specified for canister '${name}' in mops.toml`);
         }
-        validateCanisterArgs(canister, name);
-        await runStableCheck({
-            oldFile,
-            canisterMain: resolveConfigPath(canister.main),
-            canisterName: name,
-            mocPath,
-            globalMocArgs,
-            canisterArgs: canister.args ?? [],
-            options,
-        });
+        validateCanisterArgs(canister, name, config);
+        const migration = await prepareMigrationArgs(canister.migrations, name, "check", options.verbose);
+        try {
+            await runStableCheck({
+                oldFile,
+                canisterMain: resolveConfigPath(canister.main),
+                canisterName: name,
+                mocPath,
+                globalMocArgs,
+                canisterArgs: [...migration.migrationArgs, ...(canister.args ?? [])],
+                options,
+                hasMigrations: !!canister.migrations,
+            });
+        }
+        finally {
+            await migration.cleanup();
+        }
         return;
     }
     const canisters = resolveCanisterConfigs(config);
@@ -62,23 +70,30 @@ export async function checkStable(args, options = {}) {
         if (!canister.main) {
             cliError(`No main file specified for canister '${name}' in mops.toml`);
         }
-        validateCanisterArgs(canister, name);
+        validateCanisterArgs(canister, name, config);
         const stablePath = resolveStablePath(canister, name, {
             required: !!canisterNames,
         });
         if (!stablePath) {
             continue;
         }
-        await runStableCheck({
-            oldFile: stablePath,
-            canisterMain: resolveConfigPath(canister.main),
-            canisterName: name,
-            mocPath,
-            globalMocArgs,
-            canisterArgs: canister.args ?? [],
-            sources,
-            options,
-        });
+        const migration = await prepareMigrationArgs(canister.migrations, name, "check", options.verbose);
+        try {
+            await runStableCheck({
+                oldFile: stablePath,
+                canisterMain: resolveConfigPath(canister.main),
+                canisterName: name,
+                mocPath,
+                globalMocArgs,
+                canisterArgs: [...migration.migrationArgs, ...(canister.args ?? [])],
+                sources,
+                options,
+                hasMigrations: !!canister.migrations,
+            });
+        }
+        finally {
+            await migration.cleanup();
+        }
         checked++;
     }
     if (checked === 0 && !canisterNames) {
@@ -118,6 +133,9 @@ export async function runStableCheck(params) {
             if (result.stderr) {
                 console.error(result.stderr);
             }
+            if (params.hasMigrations) {
+                console.error(chalk.yellow("Hint: You may need a migration. Run `mops migrate new <Name>` to create one."));
+            }
             cliError(`✗ Stable compatibility check failed for canister '${canisterName}'`);
         }
         console.log(chalk.green(`✓ Stable compatibility check passed for canister '${canisterName}'`));

package/dist/commands/check.js

@@ -6,6 +6,7 @@ import { getGlobalMocArgs, getRootDir, readConfig, resolveConfigPath, } from "..
 import { autofixMotoko } from "../helpers/autofix-motoko.js";
 import { getMocSemVer } from "../helpers/get-moc-version.js";
 import { filterCanisters, looksLikeFile, resolveCanisterConfigs, validateCanisterArgs, } from "../helpers/resolve-canisters.js";
+import { prepareMigrationArgs } from "../helpers/migrations.js";
 import { resolveStablePath, runStableCheck } from "./check-stable.js";
 import { sourcesArgs } from "./sources.js";
 import { toolchain } from "./toolchain/index.js";
@@ -87,53 +88,61 @@ async function checkCanisters(config, canisters, options) {
         if (!canister.main) {
             cliError(`No main file specified for canister '${canisterName}' in mops.toml`);
         }
-        validateCanisterArgs(canister, canisterName);
+        validateCanisterArgs(canister, canisterName, config);
         const motokoPath = resolveConfigPath(canister.main);
-        const mocArgs = [
-            "--check",
-            ...(allLibs ? ["--all-libs"] : []),
-            ...sources,
-            ...globalMocArgs,
-            ...(canister.args ?? []),
-            ...(options.extraArgs ?? []),
-        ];
-        if (options.fix) {
-            if (options.verbose) {
-                console.log(chalk.blue("check"), chalk.gray(`Attempting to fix ${canisterName}`));
-            }
-            const fixResult = await autofixMotoko(mocPath, [motokoPath], mocArgs);
-            logAutofixResult(fixResult, options.verbose);
-        }
+        const migration = await prepareMigrationArgs(canister.migrations, canisterName, "check", options.verbose);
         try {
-            const args = [motokoPath, ...mocArgs];
-            if (options.verbose) {
-                console.log(chalk.blue("check"), chalk.gray(`Checking canister ${canisterName}:`));
-                console.log(chalk.gray(mocPath, JSON.stringify(args)));
+            const mocArgs = [
+                "--check",
+                ...(allLibs ? ["--all-libs"] : []),
+                ...sources,
+                ...globalMocArgs,
+                ...migration.migrationArgs,
+                ...(canister.args ?? []),
+                ...(options.extraArgs ?? []),
+            ];
+            if (options.fix) {
+                if (options.verbose) {
+                    console.log(chalk.blue("check"), chalk.gray(`Attempting to fix ${canisterName}`));
+                }
+                const fixResult = await autofixMotoko(mocPath, [motokoPath], mocArgs);
+                logAutofixResult(fixResult, options.verbose);
             }
-            const result = await execa(mocPath, args, {
-                stdio: "inherit",
-                reject: false,
-            });
-            if (result.exitCode !== 0) {
-                cliError(`✗ Check failed for canister ${canisterName} (exit code: ${result.exitCode})`);
+            try {
+                const args = [motokoPath, ...mocArgs];
+                if (options.verbose) {
+                    console.log(chalk.blue("check"), chalk.gray(`Checking canister ${canisterName}:`));
+                    console.log(chalk.gray(mocPath, JSON.stringify(args)));
+                }
+                const result = await execa(mocPath, args, {
+                    stdio: "inherit",
+                    reject: false,
+                });
+                if (result.exitCode !== 0) {
+                    cliError(`✗ Check failed for canister ${canisterName} (exit code: ${result.exitCode})`);
+                }
+                console.log(chalk.green(`✓ ${canisterName}`));
+            }
+            catch (err) {
+                cliError(`Error while checking canister ${canisterName}${err?.message ? `\n${err.message}` : ""}`);
+            }
+            const stablePath = resolveStablePath(canister, canisterName);
+            if (stablePath) {
+                await runStableCheck({
+                    oldFile: stablePath,
+                    canisterMain: motokoPath,
+                    canisterName,
+                    mocPath,
+                    globalMocArgs,
+                    canisterArgs: [...migration.migrationArgs, ...(canister.args ?? [])],
+                    sources,
+                    options: { verbose: options.verbose, extraArgs: options.extraArgs },
+                    hasMigrations: !!canister.migrations,
+                });
             }
-            console.log(chalk.green(`✓ ${canisterName}`));
-        }
-        catch (err) {
-            cliError(`Error while checking canister ${canisterName}${err?.message ? `\n${err.message}` : ""}`);
         }
-        const stablePath = resolveStablePath(canister, canisterName);
-        if (stablePath) {
-            await runStableCheck({
-                oldFile: stablePath,
-                canisterMain: motokoPath,
-                canisterName,
-                mocPath,
-                globalMocArgs,
-                canisterArgs: canister.args ?? [],
-                sources,
-                options: { verbose: options.verbose, extraArgs: options.extraArgs },
-            });
+        finally {
+            await migration.cleanup();
         }
     }
 }

package/dist/commands/migrate.d.ts

@@ -0,0 +1,2 @@
+export declare function migrateNew(name: string, canisterName?: string): Promise<void>;
+export declare function migrateFreeze(canisterName?: string): Promise<void>;

package/dist/commands/migrate.js

@@ -0,0 +1,104 @@
+import { existsSync, mkdirSync, renameSync } from "node:fs";
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import chalk from "chalk";
+import { cliError } from "../error.js";
+import { getNextMigrationFile, validateMigrationsConfig, validateNextMigrationOrder, } from "../helpers/migrations.js";
+import { resolveCanisterConfigs } from "../helpers/resolve-canisters.js";
+import { readConfig, resolveConfigPath } from "../mops.js";
+function resolveMigrationCanister(canisterName) {
+    const config = readConfig();
+    const canisters = resolveCanisterConfigs(config);
+    const withMigrations = Object.entries(canisters).filter(([, c]) => c.migrations);
+    if (withMigrations.length === 0) {
+        cliError("No canisters with [migrations] config found in mops.toml.\n" +
+            "Add a [canisters.<name>.migrations] section first:\n\n" +
+            "  [canisters.backend.migrations]\n" +
+            '  chain = "migrations"\n' +
+            '  next = "next-migration"   # required for migrate new/freeze');
+    }
+    if (canisterName) {
+        const canister = canisters[canisterName];
+        if (!canister) {
+            cliError(`Canister '${canisterName}' not found in mops.toml. Available: ${Object.keys(canisters).join(", ")}`);
+        }
+        if (!canister.migrations) {
+            cliError(`Canister '${canisterName}' has no [canisters.${canisterName}.migrations] config in mops.toml`);
+        }
+        return { name: canisterName, canister };
+    }
+    if (withMigrations.length > 1) {
+        cliError(`Multiple canisters with [migrations] config. Please specify one: ${withMigrations.map(([n]) => n).join(", ")}`);
+    }
+    return { name: withMigrations[0][0], canister: withMigrations[0][1] };
+}
+const VALID_NAME_RE = /^[A-Za-z][A-Za-z0-9_]*$/;
+function generateTimestamp() {
+    const now = new Date();
+    const pad = (n) => String(n).padStart(2, "0");
+    return (`${now.getUTCFullYear()}${pad(now.getUTCMonth() + 1)}${pad(now.getUTCDate())}` +
+        `_${pad(now.getUTCHours())}${pad(now.getUTCMinutes())}${pad(now.getUTCSeconds())}`);
+}
+const MIGRATION_TEMPLATE = `module {
+  public func migration(old : {}) : {} {
+    {}
+  }
+}
+`;
+export async function migrateNew(name, canisterName) {
+    if (!VALID_NAME_RE.test(name)) {
+        cliError(`Invalid migration name: "${name}"\n` +
+            "Name must start with a letter and contain only letters, digits, and underscores.");
+    }
+    const { name: resolvedName, canister } = resolveMigrationCanister(canisterName);
+    const migrations = canister.migrations;
+    validateMigrationsConfig(migrations, resolvedName);
+    if (!migrations.next) {
+        cliError(`[canisters.${resolvedName}.migrations] is missing the "next" field.\n` +
+            'Add next = "next-migration" to use `mops migrate new/freeze`.');
+    }
+    const chainDir = resolveConfigPath(migrations.chain);
+    const nextDir = resolveConfigPath(migrations.next);
+    const existingNext = existsSync(nextDir)
+        ? getNextMigrationFile(nextDir)
+        : null;
+    if (existingNext) {
+        cliError(`A next migration already exists: ${existingNext}\n` +
+            "Freeze it first with `mops migrate freeze`.");
+    }
+    const timestamp = generateTimestamp();
+    const fileName = `${timestamp}_${name}.mo`;
+    validateNextMigrationOrder(chainDir, fileName);
+    if (!existsSync(chainDir)) {
+        mkdirSync(chainDir, { recursive: true });
+    }
+    if (!existsSync(nextDir)) {
+        mkdirSync(nextDir, { recursive: true });
+    }
+    const filePath = join(nextDir, fileName);
+    await writeFile(filePath, MIGRATION_TEMPLATE);
+    console.log(chalk.green(`✓ Created migration: ${filePath}`));
+}
+export async function migrateFreeze(canisterName) {
+    const { name: resolvedName, canister } = resolveMigrationCanister(canisterName);
+    const migrations = canister.migrations;
+    validateMigrationsConfig(migrations, resolvedName);
+    if (!migrations.next) {
+        cliError(`[canisters.${resolvedName}.migrations] is missing the "next" field.\n` +
+            'Add next = "next-migration" to use `mops migrate new/freeze`.');
+    }
+    const chainDir = resolveConfigPath(migrations.chain);
+    const nextDir = resolveConfigPath(migrations.next);
+    const nextFile = existsSync(nextDir) ? getNextMigrationFile(nextDir) : null;
+    if (!nextFile) {
+        cliError("No next migration to freeze. Create one with `mops migrate new <Name>`.");
+    }
+    validateNextMigrationOrder(chainDir, nextFile);
+    if (!existsSync(chainDir)) {
+        mkdirSync(chainDir, { recursive: true });
+    }
+    const src = join(nextDir, nextFile);
+    const dest = join(chainDir, nextFile);
+    renameSync(src, dest);
+    console.log(chalk.green(`✓ Frozen migration: ${nextFile} → ${chainDir}/`));
+}

package/dist/declarations/main/main.did

@@ -42,6 +42,11 @@ type StreamingCallbackResponse =
  };
 type StreamingCallback = func (StreamingToken) ->
                           (opt StreamingCallbackResponse) query;
+type StructureStats = 
+ record {
+   bytes: nat;
+   count: nat;
+ };
 type StorageStats = 
  record {
    cyclesBalance: nat;
@@ -272,6 +277,38 @@ type PackageChanges =
    prevDocsCoverage: float64;
    tests: TestsChanges;
  };
+type MemoryStats = 
+ record {
+   dailySnapshots: StructureStats;
+   dailySnapshotsByPackageId: StructureStats;
+   dailySnapshotsByPackageName: StructureStats;
+   dailyTempRecords: StructureStats;
+   downloadsByPackageId: StructureStats;
+   downloadsByPackageName: StructureStats;
+   fileIdsByPackage: StructureStats;
+   hashByFileId: StructureStats;
+   highestConfigs: StructureStats;
+   maintainersByPackage: StructureStats;
+   ownersByPackage: StructureStats;
+   packageBenchmarks: StructureStats;
+   packageConfigs: StructureStats;
+   packageDocsCoverage: StructureStats;
+   packageFileStats: StructureStats;
+   packageNotes: StructureStats;
+   packagePublications: StructureStats;
+   packageTestStats: StructureStats;
+   packageVersions: StructureStats;
+   rtsHeapSize: nat;
+   rtsMemorySize: nat;
+   names: StructureStats;
+   storageByFileId: StructureStats;
+   storages: StructureStats;
+   users: StructureStats;
+   weeklySnapshots: StructureStats;
+   weeklySnapshotsByPackageId: StructureStats;
+   weeklySnapshotsByPackageName: StructureStats;
+   weeklyTempRecords: StructureStats;
+ };
 type Main = 
  service {
    addMaintainer: (packageName: PackageName, newMaintainer: principal) ->
@@ -311,6 +348,7 @@ type Main =
           SemverPart;
         }) -> (Result_6) query;
    getHighestVersion: (name: PackageName) -> (Result_5) query;
+   getMemoryStats: () -> (MemoryStats) query;
    getMostDownloadedPackages: () -> (vec PackageSummary) query;
    getMostDownloadedPackagesIn7Days: () -> (vec PackageSummary) query;
    getNewPackages: () -> (vec PackageSummary) query;

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

@@ -45,6 +45,41 @@ export interface HttpRequestResult {
   'body' : Uint8Array | number[],
   'headers' : Array<HttpHeader>,
 }
+export interface StructureStats {
+  'count' : bigint,
+  'bytes' : bigint,
+}
+export interface MemoryStats {
+  'rtsHeapSize' : bigint,
+  'rtsMemorySize' : bigint,
+  'packageVersions' : StructureStats,
+  'packageConfigs' : StructureStats,
+  'highestConfigs' : StructureStats,
+  'packagePublications' : StructureStats,
+  'ownersByPackage' : StructureStats,
+  'maintainersByPackage' : StructureStats,
+  'fileIdsByPackage' : StructureStats,
+  'hashByFileId' : StructureStats,
+  'packageFileStats' : StructureStats,
+  'packageTestStats' : StructureStats,
+  'packageBenchmarks' : StructureStats,
+  'packageNotes' : StructureStats,
+  'packageDocsCoverage' : StructureStats,
+  'downloadsByPackageName' : StructureStats,
+  'downloadsByPackageId' : StructureStats,
+  'dailySnapshots' : StructureStats,
+  'weeklySnapshots' : StructureStats,
+  'dailySnapshotsByPackageName' : StructureStats,
+  'dailySnapshotsByPackageId' : StructureStats,
+  'weeklySnapshotsByPackageName' : StructureStats,
+  'weeklySnapshotsByPackageId' : StructureStats,
+  'dailyTempRecords' : StructureStats,
+  'weeklyTempRecords' : StructureStats,
+  'storages' : StructureStats,
+  'storageByFileId' : StructureStats,
+  'users' : StructureStats,
+  'names' : StructureStats,
+}
 export interface Main {
   'addMaintainer' : ActorMethod<[PackageName, Principal], Result_3>,
   'addOwner' : ActorMethod<[PackageName, Principal], Result_3>,
@@ -77,6 +112,7 @@ export interface Main {
     Result_6
   >,
   'getHighestVersion' : ActorMethod<[PackageName], Result_5>,
+  'getMemoryStats' : ActorMethod<[], MemoryStats, 'query'>,
   'getMostDownloadedPackages' : ActorMethod<[], Array<PackageSummary>>,
   'getMostDownloadedPackagesIn7Days' : ActorMethod<[], Array<PackageSummary>>,
   'getNewPackages' : ActorMethod<[], Array<PackageSummary>>,

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

@@ -196,6 +196,41 @@ export const idlFactory = ({ IDL }) => {
     'cyclesBalance' : IDL.Nat,
     'memorySize' : IDL.Nat,
   });
+  const StructureStats = IDL.Record({
+    'count' : IDL.Nat,
+    'bytes' : IDL.Nat,
+  });
+  const MemoryStats = IDL.Record({
+    'rtsHeapSize' : IDL.Nat,
+    'rtsMemorySize' : IDL.Nat,
+    'packageVersions' : StructureStats,
+    'packageConfigs' : StructureStats,
+    'highestConfigs' : StructureStats,
+    'packagePublications' : StructureStats,
+    'ownersByPackage' : StructureStats,
+    'maintainersByPackage' : StructureStats,
+    'fileIdsByPackage' : StructureStats,
+    'hashByFileId' : StructureStats,
+    'packageFileStats' : StructureStats,
+    'packageTestStats' : StructureStats,
+    'packageBenchmarks' : StructureStats,
+    'packageNotes' : StructureStats,
+    'packageDocsCoverage' : StructureStats,
+    'downloadsByPackageName' : StructureStats,
+    'downloadsByPackageId' : StructureStats,
+    'dailySnapshots' : StructureStats,
+    'weeklySnapshots' : StructureStats,
+    'dailySnapshotsByPackageName' : StructureStats,
+    'dailySnapshotsByPackageId' : StructureStats,
+    'weeklySnapshotsByPackageName' : StructureStats,
+    'weeklySnapshotsByPackageId' : StructureStats,
+    'dailyTempRecords' : StructureStats,
+    'weeklyTempRecords' : StructureStats,
+    'storages' : StructureStats,
+    'storageByFileId' : StructureStats,
+    'users' : StructureStats,
+    'names' : StructureStats,
+  });
   const Header = IDL.Tuple(IDL.Text, IDL.Text);
   const Request = IDL.Record({
     'url' : IDL.Text,
@@ -308,6 +343,7 @@ export const idlFactory = ({ IDL }) => {
         ['query'],
       ),
     'getHighestVersion' : IDL.Func([PackageName], [Result_5], ['query']),
+    'getMemoryStats' : IDL.Func([], [MemoryStats], ['query']),
     'getMostDownloadedPackages' : IDL.Func(
         [],
         [IDL.Vec(PackageSummary)],

package/dist/helpers/migrations.d.ts

@@ -0,0 +1,10 @@
+import { MigrationsConfig } from "../types.js";
+export interface MigrationArgsResult {
+    migrationArgs: string[];
+    cleanup: () => Promise<void>;
+}
+export declare function getMigrationFiles(dir: string): string[];
+export declare function getNextMigrationFile(nextDir: string): string | null;
+export declare function validateNextMigrationOrder(chainDirOrFiles: string | string[], nextFile: string): void;
+export declare function validateMigrationsConfig(migrations: MigrationsConfig, canisterName: string): void;
+export declare function prepareMigrationArgs(migrations: MigrationsConfig | undefined, canisterName: string, mode: "check" | "build", verbose?: boolean): Promise<MigrationArgsResult>;