ic-mops 2.9.0 → 2.11.0

package/commands/check.ts

@@ -1,5 +1,4 @@
 import path from "node:path";
-import { existsSync } from "node:fs";
 import chalk from "chalk";
 import { execa } from "execa";
 import { cliError } from "../error.js";
@@ -9,13 +8,17 @@ import {
   readConfig,
   resolveConfigPath,
 } from "../mops.js";
-import { autofixMotoko } from "../helpers/autofix-motoko.js";
+import { AutofixResult, autofixMotoko } from "../helpers/autofix-motoko.js";
 import { getMocSemVer } from "../helpers/get-moc-version.js";
 import {
+  filterCanisters,
+  looksLikeFile,
   resolveCanisterConfigs,
-  resolveCanisterEntrypoints,
+  validateCanisterArgs,
 } from "../helpers/resolve-canisters.js";
-import { runStableCheck } from "./check-stable.js";
+import { prepareMigrationArgs } from "../helpers/migrations.js";
+import { CanisterConfig, Config } from "../types.js";
+import { resolveStablePath, runStableCheck } from "./check-stable.js";
 import { sourcesArgs } from "./sources.js";
 import { toolchain } from "./toolchain/index.js";
 import { collectLintRules, lint } from "./lint.js";
@@ -33,52 +36,209 @@ export interface CheckOptions {
   extraArgs: string[];
 }
 
+function checkAllLibsSupport(verbose?: boolean): boolean {
+  const allLibs = supportsAllLibsFlag();
+  if (!allLibs) {
+    console.log(
+      chalk.yellow(
+        `moc < ${MOC_ALL_LIBS_MIN_VERSION}: some diagnostic hints may be missing`,
+      ),
+    );
+  } else if (verbose) {
+    console.log(
+      chalk.blue("check"),
+      chalk.gray("Using --all-libs for richer diagnostics"),
+    );
+  }
+  return allLibs;
+}
+
+function logAutofixResult(
+  fixResult: AutofixResult | null,
+  verbose?: boolean,
+): void {
+  if (fixResult) {
+    for (const [file, codes] of fixResult.fixedFiles) {
+      const unique = [...new Set(codes)].sort();
+      const n = codes.length;
+      const rel = path.relative(process.cwd(), file);
+      console.log(
+        chalk.green(
+          `Fixed ${rel} (${n} ${n === 1 ? "fix" : "fixes"}: ${unique.join(", ")})`,
+        ),
+      );
+    }
+    const fileCount = fixResult.fixedFiles.size;
+    console.log(
+      chalk.green(
+        `\n✓ ${fixResult.totalFixCount} ${fixResult.totalFixCount === 1 ? "fix" : "fixes"} applied to ${fileCount} ${fileCount === 1 ? "file" : "files"}`,
+      ),
+    );
+  } else if (verbose) {
+    console.log(chalk.yellow("No fixes were needed"));
+  }
+}
+
 export async function check(
-  files: string | string[],
+  args: string[],
   options: Partial<CheckOptions> = {},
 ): Promise<void> {
-  const explicitFiles = Array.isArray(files) ? files : files ? [files] : [];
-  let fileList = [...explicitFiles];
-
   const config = readConfig();
+  const canisters = resolveCanisterConfigs(config);
+  const hasCanisters = Object.keys(canisters).length > 0;
+  const fileArgs = args.filter(looksLikeFile);
+  const nonFileArgs = args.filter((a) => !looksLikeFile(a));
+  const isFileMode = fileArgs.length > 0;
 
-  if (fileList.length === 0) {
-    fileList = resolveCanisterEntrypoints(config).map(resolveConfigPath);
-  }
-
-  if (fileList.length === 0) {
+  if (isFileMode && nonFileArgs.length > 0) {
     cliError(
-      "No Motoko files specified and no canisters defined in mops.toml.\n" +
-        "Either pass files: mops check <files...>\n" +
-        "Or define canisters in mops.toml:\n\n" +
-        "  [canisters.backend]\n" +
-        '  main = "src/main.mo"',
+      `Cannot mix file paths and canister names: ${args.join(", ")}\n` +
+        "Pass either file paths (e.g. mops check src/main.mo) or canister names (e.g. mops check backend)",
     );
   }
+
+  if (isFileMode) {
+    await checkFiles(config, fileArgs, options);
+  } else {
+    if (!hasCanisters) {
+      cliError(
+        "No canisters defined in mops.toml.\n" +
+          "Either pass files: mops check <files...>\n" +
+          "Or define canisters in mops.toml:\n\n" +
+          "  [canisters.backend]\n" +
+          '  main = "src/main.mo"',
+      );
+    }
+
+    const canisterNames = args.length > 0 ? args : undefined;
+    const filtered = filterCanisters(canisters, canisterNames);
+    await checkCanisters(config, filtered, options);
+  }
+
+  if (config.toolchain?.lintoko) {
+    const rootDir = getRootDir();
+    const lintRules = await collectLintRules(config, rootDir);
+    const lintFiles = isFileMode ? fileArgs : undefined;
+    await lint(undefined, {
+      verbose: options.verbose,
+      fix: options.fix,
+      rules: lintRules,
+      files: lintFiles,
+    });
+  }
+}
+
+async function checkCanisters(
+  config: Config,
+  canisters: Record<string, CanisterConfig>,
+  options: Partial<CheckOptions>,
+): Promise<void> {
   const mocPath = await toolchain.bin("moc", { fallback: true });
-  const sources = await sourcesArgs();
+  const sources = (await sourcesArgs()).flat();
   const globalMocArgs = getGlobalMocArgs(config);
+  const allLibs = checkAllLibsSupport(options.verbose);
 
-  // --all-libs enables richer diagnostics with edit suggestions from moc (requires moc >= 1.3.0)
-  const allLibs = supportsAllLibsFlag();
+  for (const [canisterName, canister] of Object.entries(canisters)) {
+    if (!canister.main) {
+      cliError(
+        `No main file specified for canister '${canisterName}' in mops.toml`,
+      );
+    }
 
-  if (!allLibs) {
-    console.log(
-      chalk.yellow(
-        `moc < ${MOC_ALL_LIBS_MIN_VERSION}: some diagnostic hints may be missing`,
-      ),
-    );
-  } else if (options.verbose) {
-    console.log(
-      chalk.blue("check"),
-      chalk.gray("Using --all-libs for richer diagnostics"),
+    validateCanisterArgs(canister, canisterName, config);
+    const motokoPath = resolveConfigPath(canister.main);
+
+    const migration = await prepareMigrationArgs(
+      canister.migrations,
+      canisterName,
+      "check",
+      options.verbose,
     );
+    try {
+      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);
+      }
+
+      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: any) {
+        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,
+        });
+      }
+    } finally {
+      await migration.cleanup();
+    }
   }
+}
+
+async function checkFiles(
+  config: Config,
+  files: string[],
+  options: Partial<CheckOptions>,
+): Promise<void> {
+  const mocPath = await toolchain.bin("moc", { fallback: true });
+  const sources = (await sourcesArgs()).flat();
+  const globalMocArgs = getGlobalMocArgs(config);
+  const allLibs = checkAllLibsSupport(options.verbose);
 
   const mocArgs = [
     "--check",
     ...(allLibs ? ["--all-libs"] : []),
-    ...sources.flat(),
+    ...sources,
     ...globalMocArgs,
     ...(options.extraArgs ?? []),
   ];
@@ -88,32 +248,11 @@ export async function check(
       console.log(chalk.blue("check"), chalk.gray("Attempting to fix files"));
     }
 
-    const fixResult = await autofixMotoko(mocPath, fileList, mocArgs);
-    if (fixResult) {
-      for (const [file, codes] of fixResult.fixedFiles) {
-        const unique = [...new Set(codes)].sort();
-        const n = codes.length;
-        const rel = path.relative(process.cwd(), file);
-        console.log(
-          chalk.green(
-            `Fixed ${rel} (${n} ${n === 1 ? "fix" : "fixes"}: ${unique.join(", ")})`,
-          ),
-        );
-      }
-      const fileCount = fixResult.fixedFiles.size;
-      console.log(
-        chalk.green(
-          `\n✓ ${fixResult.totalFixCount} ${fixResult.totalFixCount === 1 ? "fix" : "fixes"} applied to ${fileCount} ${fileCount === 1 ? "file" : "files"}`,
-        ),
-      );
-    } else {
-      if (options.verbose) {
-        console.log(chalk.yellow("No fixes were needed"));
-      }
-    }
+    const fixResult = await autofixMotoko(mocPath, files, mocArgs);
+    logAutofixResult(fixResult, options.verbose);
   }
 
-  for (const file of fileList) {
+  for (const file of files) {
     try {
       const args = [file, ...mocArgs];
       if (options.verbose) {
@@ -139,49 +278,4 @@ export async function check(
       );
     }
   }
-
-  const canisters = resolveCanisterConfigs(config);
-  for (const [name, canister] of Object.entries(canisters)) {
-    const stableConfig = canister["check-stable"];
-    if (!stableConfig) {
-      continue;
-    }
-
-    if (!canister.main) {
-      cliError(`No main file specified for canister '${name}' in mops.toml`);
-    }
-
-    const stablePath = resolveConfigPath(stableConfig.path);
-    if (!existsSync(stablePath)) {
-      if (stableConfig.skipIfMissing) {
-        continue;
-      }
-      cliError(
-        `Deployed file not found: ${stablePath} (canister '${name}')\n` +
-          "Set skipIfMissing = true in [canisters." +
-          name +
-          ".check-stable] to skip this check when the file is missing.",
-      );
-    }
-
-    await runStableCheck({
-      oldFile: stablePath,
-      canisterMain: resolveConfigPath(canister.main),
-      canisterName: name,
-      mocPath,
-      globalMocArgs,
-      options: { verbose: options.verbose, extraArgs: options.extraArgs },
-    });
-  }
-
-  if (config.toolchain?.lintoko) {
-    const rootDir = getRootDir();
-    const lintRules = await collectLintRules(config, rootDir);
-    await lint(undefined, {
-      verbose: options.verbose,
-      fix: options.fix,
-      rules: lintRules,
-      files: explicitFiles.length > 0 ? explicitFiles : undefined,
-    });
-  }
 }

package/commands/migrate.ts

@@ -0,0 +1,165 @@
+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";
+import { CanisterConfig } from "../types.js";
+
+function resolveMigrationCanister(canisterName?: string): {
+  name: string;
+  canister: CanisterConfig;
+} {
+  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(): string {
+  const now = new Date();
+  const pad = (n: number) => 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: string,
+  canisterName?: string,
+): Promise<void> {
+  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?: string): Promise<void> {
+  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/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/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/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)],