ic-mops 2.9.0 → 2.11.0

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 ## Next
 
+## 2.11.0
+- Add `mops migrate new <Name>` and `mops migrate freeze` commands for managing enhanced migration chains
+- Add `[canisters.<name>.migrations]` config section with `chain`, `next`, `check-limit`, and `build-limit` fields
+- `mops check`, `mops build`, and `mops check-stable` now auto-inject `--enhanced-migration` when `[migrations]` is configured
+- `mops check` and `mops check-stable` emit a hint to create a migration when a stable compatibility check fails and `[migrations]` is configured
+- Migration chain trimming: only the last N migrations are passed to `moc` based on `check-limit`/`build-limit` settings
+
+## 2.10.0
+- `mops check` and `mops check-stable` now apply per-canister `[canisters.<name>].args` (previously only `mops build` applied them)
+- `mops check` now accepts canister names as arguments (e.g. `mops check backend`) to check a specific canister
+- `mops check-stable` now works without arguments, checking all canisters with `[check-stable]` configured
+- `mops check-stable` now accepts canister names as arguments (e.g. `mops check-stable backend`)
+
 ## 2.9.0
 - Add `mops info <pkg>` command to show detailed package metadata from the registry
 - Add `[lint.extra]` config for applying additional lint rules to specific files via glob patterns

package/cli.ts

@@ -43,6 +43,7 @@ import {
   importPem,
   setUserProp,
 } from "./commands/user.js";
+import { migrateNew, migrateFreeze } from "./commands/migrate.js";
 import { watch } from "./commands/watch/watch.js";
 import {
   apiVersion,
@@ -330,9 +331,9 @@ program
 
 // check
 program
-  .command("check [files...]")
+  .command("check [args...]")
   .description(
-    "Check Motoko files for syntax errors and type issues. If no files are specified, checks all canister entrypoints from mops.toml. Also runs stable compatibility checks for canisters with [check-stable] configured, and runs linting if lintoko is configured in [toolchain] and rule directories are present",
+    "Check Motoko canisters or files for syntax errors and type issues. Arguments can be canister names or file paths. If no arguments are given, checks all canisters from mops.toml. Also runs stable compatibility checks for canisters with [check-stable] configured, and runs linting if lintoko is configured in [toolchain]",
   )
   .option("--verbose", "Verbose console output")
   .addOption(
@@ -342,15 +343,15 @@ program
     ),
   )
   .allowUnknownOption(true)
-  .action(async (files, options) => {
+  .action(async (args, options) => {
     checkConfigFile(true);
-    const { extraArgs, args: fileList } = parseExtraArgs(files);
+    const { extraArgs, args: argList } = parseExtraArgs(args);
     await installAll({
       silent: true,
       lock: "ignore",
       installFromLockFile: true,
     });
-    await check(fileList, {
+    await check(argList, {
       ...options,
       extraArgs,
     });
@@ -372,21 +373,21 @@ program
 
 // check-stable
 program
-  .command("check-stable <old-file> [canister]")
+  .command("check-stable [args...]")
   .description(
-    "Check stable variable compatibility between an old version (.mo or .most file) and the current canister entrypoint",
+    "Check stable variable compatibility. With no arguments, checks all canisters with [check-stable] configured. Arguments can be canister names or an old file path followed by an optional canister name",
   )
   .option("--verbose", "Verbose console output")
   .allowUnknownOption(true)
-  .action(async (oldFile, canister, options) => {
+  .action(async (args, options) => {
     checkConfigFile(true);
-    const { extraArgs } = parseExtraArgs();
+    const { extraArgs, args: argList } = parseExtraArgs(args);
     await installAll({
       silent: true,
       lock: "ignore",
       installFromLockFile: true,
     });
-    await checkStable(oldFile, canister, {
+    await checkStable(argList, {
       ...options,
       extraArgs,
     });
@@ -707,6 +708,29 @@ toolchainCommand
 
 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");
 

package/commands/build.ts

@@ -6,7 +6,12 @@ import { join } from "node:path";
 import { lock, unlockSync } from "proper-lockfile";
 import { cliError } from "../error.js";
 import { isCandidCompatible } from "../helpers/is-candid-compatible.js";
-import { resolveCanisterConfigs } from "../helpers/resolve-canisters.js";
+import {
+  filterCanisters,
+  resolveCanisterConfigs,
+  validateCanisterArgs,
+} from "../helpers/resolve-canisters.js";
+import { prepareMigrationArgs } from "../helpers/migrations.js";
 import { CanisterConfig, Config } from "../types.js";
 import { CustomSection, getWasmBindings } from "../wasm.js";
 import { getGlobalMocArgs, readConfig, resolveConfigPath } from "../mops.js";
@@ -41,26 +46,11 @@ export async function build(
     cliError(`No Motoko canisters found in mops.toml configuration`);
   }
 
-  if (canisterNames) {
-    let invalidNames = canisterNames.filter((name) => !(name in canisters));
-    if (invalidNames.length) {
-      cliError(
-        `Motoko canister(s) not found in mops.toml configuration: ${invalidNames.join(", ")}`,
-      );
-    }
-  }
-
   if (!(await exists(outputDir))) {
     await mkdir(outputDir, { recursive: true });
   }
 
-  const filteredCanisters = canisterNames
-    ? Object.fromEntries(
-        Object.entries(canisters).filter(([name]) =>
-          canisterNames.includes(name),
-        ),
-      )
-    : canisters;
+  const filteredCanisters = filterCanisters(canisters, canisterNames);
 
   for (let [canisterName, canister] of Object.entries(filteredCanisters)) {
     console.log(chalk.blue("build canister"), chalk.bold(canisterName));
@@ -98,6 +88,12 @@ export async function build(
     };
     process.on("exit", exitCleanup);
 
+    const migration = await prepareMigrationArgs(
+      canister.migrations,
+      canisterName,
+      "build",
+      options.verbose,
+    );
     try {
       let args = [
         "-c",
@@ -108,6 +104,7 @@ export async function build(
         motokoPath,
         ...(await sourcesArgs()).flat(),
         ...getGlobalMocArgs(config),
+        ...migration.migrationArgs,
       ];
       args.push(
         ...collectExtraArgs(config, canister, canisterName, options.extraArgs),
@@ -210,6 +207,7 @@ export async function build(
         );
       }
     } finally {
+      await migration.cleanup();
       process.removeListener("exit", exitCleanup);
       try {
         await release?.();
@@ -249,11 +247,7 @@ function collectExtraArgs(
     args.push(...config.build.args);
   }
   if (canister.args) {
-    if (typeof canister.args === "string") {
-      cliError(
-        `Canister config 'args' should be an array of strings for canister ${canisterName}`,
-      );
-    }
+    validateCanisterArgs(canister, canisterName, config);
     args.push(...canister.args);
   }
   if (extraArgs) {

package/commands/check-stable.ts

@@ -4,8 +4,16 @@ 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 { resolveSingleCanister } from "../helpers/resolve-canisters.js";
+import { CanisterConfig } from "../types.js";
+import {
+  filterCanisters,
+  looksLikeFile,
+  resolveCanisterConfigs,
+  resolveSingleCanister,
+  validateCanisterArgs,
+} from "../helpers/resolve-canisters.js";
 import { sourcesArgs } from "./sources.js";
 import { toolchain } from "./toolchain/index.js";
 
@@ -16,29 +24,130 @@ export interface CheckStableOptions {
   extraArgs: string[];
 }
 
+export function resolveStablePath(
+  canister: CanisterConfig,
+  canisterName: string,
+  options?: { required?: boolean },
+): string | null {
+  const stableConfig = canister["check-stable"];
+  if (!stableConfig) {
+    if (options?.required) {
+      cliError(
+        `Canister '${canisterName}' has no [canisters.${canisterName}.check-stable] configuration in mops.toml`,
+      );
+    }
+    return null;
+  }
+  const stablePath = resolveConfigPath(stableConfig.path);
+  if (!existsSync(stablePath)) {
+    if (stableConfig.skipIfMissing) {
+      return null;
+    }
+    cliError(
+      `Deployed file not found: ${stablePath} (canister '${canisterName}')\n` +
+        "Set skipIfMissing = true in [canisters." +
+        canisterName +
+        ".check-stable] to skip this check when the file is missing.",
+    );
+  }
+  return stablePath;
+}
+
 export async function checkStable(
-  oldFile: string,
-  canisterName: string | undefined,
+  args: string[],
   options: Partial<CheckStableOptions> = {},
 ): Promise<void> {
   const config = readConfig();
-  const { name, canister } = resolveSingleCanister(config, canisterName);
+  const mocPath = await toolchain.bin("moc", { fallback: true });
+  const globalMocArgs = getGlobalMocArgs(config);
+
+  const firstArg = args[0];
+  if (firstArg && looksLikeFile(firstArg)) {
+    const oldFile = firstArg;
+    const canisterName = args[1];
+    const { name, canister } = resolveSingleCanister(config, canisterName);
+
+    if (!canister.main) {
+      cliError(`No main file specified for canister '${name}' in mops.toml`);
+    }
 
-  if (!canister.main) {
-    cliError(`No main file specified for canister '${name}' in mops.toml`);
+    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 mocPath = await toolchain.bin("moc", { fallback: true });
-  const globalMocArgs = getGlobalMocArgs(config);
+  const canisters = resolveCanisterConfigs(config);
+  const canisterNames = args.length > 0 ? args : undefined;
+  const filteredCanisters = filterCanisters(canisters, canisterNames);
+  const sources = (await sourcesArgs()).flat();
 
-  await runStableCheck({
-    oldFile,
-    canisterMain: resolveConfigPath(canister.main),
-    canisterName: name,
-    mocPath,
-    globalMocArgs,
-    options,
-  });
+  let checked = 0;
+  for (const [name, canister] of Object.entries(filteredCanisters)) {
+    if (!canister.main) {
+      cliError(`No main file specified for canister '${name}' in mops.toml`);
+    }
+
+    validateCanisterArgs(canister, name, config);
+    const stablePath = resolveStablePath(canister, name, {
+      required: !!canisterNames,
+    });
+    if (!stablePath) {
+      continue;
+    }
+
+    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) {
+    cliError(
+      "No canisters with [check-stable] configuration found in mops.toml.\n" +
+        "Either pass an old file: mops check-stable <old-file> [canister]\n" +
+        "Or configure check-stable for a canister:\n\n" +
+        "  [canisters.backend.check-stable]\n" +
+        '  path = "deployed.mo"',
+    );
+  }
 }
 
 export interface RunStableCheckParams {
@@ -47,7 +156,10 @@ export interface RunStableCheckParams {
   canisterName: string;
   mocPath: string;
   globalMocArgs: string[];
+  canisterArgs: string[];
+  sources?: string[];
   options?: Partial<CheckStableOptions>;
+  hasMigrations?: boolean;
 }
 
 export async function runStableCheck(
@@ -59,10 +171,11 @@ export async function runStableCheck(
     canisterName,
     mocPath,
     globalMocArgs,
+    canisterArgs,
     options = {},
   } = params;
 
-  const sources = (await sourcesArgs()).flat();
+  const sources = params.sources ?? (await sourcesArgs()).flat();
   const isOldMostFile = oldFile.endsWith(".most");
 
   if (!existsSync(oldFile)) {
@@ -80,6 +193,7 @@ export async function runStableCheck(
           join(CHECK_STABLE_DIR, "old.most"),
           sources,
           globalMocArgs,
+          canisterArgs,
           options,
         );
 
@@ -89,6 +203,7 @@ export async function runStableCheck(
       join(CHECK_STABLE_DIR, "new.most"),
       sources,
       globalMocArgs,
+      canisterArgs,
       options,
     );
 
@@ -113,6 +228,13 @@ export async function runStableCheck(
       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}'`,
       );
@@ -134,6 +256,7 @@ async function generateStableTypes(
   outputPath: string,
   sources: string[],
   globalMocArgs: string[],
+  canisterArgs: string[],
   options: Partial<CheckStableOptions>,
 ): Promise<string> {
   const base = basename(outputPath, ".most");
@@ -145,6 +268,7 @@ async function generateStableTypes(
     moFile,
     ...sources,
     ...globalMocArgs,
+    ...canisterArgs,
     ...(options.extraArgs ?? []),
   ];