@microsoft/power-apps-native-host 0.2.22 → 0.3.0

package/scripts/upgrade.js

@@ -0,0 +1,188 @@
+#!/usr/bin/env node
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { parseArgs: parseNodeArgs } = require('node:util');
+const { runAuthoringCommand } = require('./upgrade-authoring');
+const {
+  HOST_PACKAGE,
+  buildUpgradePlan,
+  readJson,
+} = require('./upgrade/runtime');
+const {
+  UPGRADE_JOURNAL_PATH,
+  assertNoActiveUpgrade,
+  cleanupRejects,
+  detectPackageManager,
+  executePhase,
+  recoverInterruptedUpgrade,
+  reportNativeProjectState,
+  shouldValidate,
+  withUpgradeLock,
+  writeRejects,
+} = require('./upgrade/system');
+
+const PROFILE_PATH = path.join(__dirname, '..', 'compatibility', 'current.json');
+const MIGRATIONS_PATH = path.join(__dirname, '..', 'compatibility', 'migrations');
+
+function parseArgs(argv) {
+  const help = argv.includes('--help') || argv.includes('-h');
+  const { values, positionals } = parseNodeArgs({
+    args: help ? argv.filter(value => !['--help', '-h'].includes(value)) : argv,
+    allowPositionals: true,
+    strict: true,
+    options: {
+      'dry-run': { type: 'boolean' },
+      'no-install': { type: 'boolean' },
+      project: { type: 'string', default: process.cwd() },
+      'from-tag': { type: 'string' },
+      'from-version': { type: 'string' },
+      message: { type: 'string' },
+      id: { type: 'string' },
+    },
+  });
+  const fromVersion = values['from-version'] === undefined ? undefined : parsePositiveInteger(values['from-version']);
+  return {
+    command: positionals[0] || 'upgrade',
+    fromTag: values['from-tag'] || process.env.MIGRATION_BASE_TAG || null,
+    fromVersion,
+    dryRun: Boolean(values['dry-run']),
+    install: !values['no-install'],
+    project: path.resolve(values.project),
+    message: values.message,
+    id: values.id,
+    help,
+  };
+}
+
+function printHelp() {
+  console.log(`Usage: upgrade-template [command] [options]
+
+Commands: upgrade, change, check, build
+
+Options:
+  --dry-run          Show changes without writing or installing
+  --no-install       Write changes without installation or state advancement
+  --project PATH     Project path (defaults to current directory)
+  --from-tag TAG     Version tag for change/check
+  --from-version N   Source template version for legacy apps
+  --message TEXT     Changelog description
+  --id ID            Migration ID
+  -h, --help         Show this help`);
+}
+
+function parsePositiveInteger(value) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 1) throw new Error('--from-version must be a positive integer');
+  return parsed;
+}
+
+function findProjectRoot(startPath) {
+  let current = path.resolve(startPath);
+  if (fs.existsSync(current) && fs.statSync(current).isFile()) current = path.dirname(current);
+  while (true) {
+    const packagePath = path.join(current, 'package.json');
+    if (fs.existsSync(packagePath)) {
+      const packageJson = readJson(packagePath);
+      const dependencies = { ...packageJson.dependencies, ...packageJson.devDependencies };
+      if (dependencies.expo || dependencies[HOST_PACKAGE]) return current;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  throw new Error(`Could not find an Expo project from ${startPath}`);
+}
+
+function printPlan(projectRoot, profile, operations, conflicts, dryRun) {
+  console.log(`${dryRun ? '[dry-run] ' : ''}Target compatibility profile: ${profile.id} (Expo SDK ${profile.expoSdk})`);
+  if (!operations.length) {
+    console.log('Project files already match the target profile.');
+    return;
+  }
+  for (const operation of operations) {
+    console.log(`\n${path.relative(projectRoot, operation.filePath)}`);
+    for (const change of operation.changes) console.log(`  - ${change}`);
+    for (const warning of operation.warnings || []) console.log(`  ! ${warning}`);
+  }
+  if (conflicts.length) {
+    console.log(`\n${conflicts.length} patch conflict(s) require manual resolution.`);
+  }
+}
+
+async function main(argv = process.argv.slice(2)) {
+  const options = parseArgs(argv);
+  if (options.help) {
+    printHelp();
+    return;
+  }
+
+  if (!['upgrade', 'change', 'check', 'build'].includes(options.command)) {
+    throw new Error(`Unknown command: ${options.command}`);
+  }
+  if (options.command !== 'upgrade') {
+    await runAuthoringCommand(options.command, options.project, options);
+    return;
+  }
+
+  const projectRoot = findProjectRoot(options.project);
+  if (options.dryRun) await assertNoActiveUpgrade(projectRoot);
+  const runUpgrade = async () => {
+    const journalPath = path.join(projectRoot, UPGRADE_JOURNAL_PATH);
+    if (options.dryRun && fs.existsSync(journalPath)) {
+      throw new Error('An interrupted upgrade journal exists; rerun without --dry-run to recover it first');
+    }
+    recoverInterruptedUpgrade(projectRoot);
+    const profile = readJson(PROFILE_PATH);
+    const hostVersion = readJson(path.join(__dirname, '..', 'package.json')).version;
+    const fullPlan = buildUpgradePlan(projectRoot, profile, hostVersion, options.fromVersion, MIGRATIONS_PATH, options.install || options.dryRun);
+    const { operations, conflicts, migration, targetProfile, hasMore } = fullPlan;
+    printPlan(projectRoot, profile, operations, conflicts, options.dryRun);
+
+    if (conflicts.length) {
+      if (options.dryRun) throw new Error(`Dry run found patch conflicts; rerun without --dry-run to write .rej files for manual resolution.`);
+      writeRejects(operations);
+      throw new Error(`Patch conflicts were written as .rej files. Resolve them, delete the .rej files, and rerun the upgrade.`);
+    }
+    if (options.dryRun) return;
+
+    reportNativeProjectState(projectRoot);
+    const packageManager = detectPackageManager(projectRoot);
+
+    if (!options.install) {
+      executePhase(projectRoot, operations, packageManager, false);
+      cleanupRejects(projectRoot, migration);
+      console.log('\nApplied project files without installation or advancing template state. Rerun without --no-install to validate and record the upgrade.');
+      return;
+    }
+
+    if (migration) {
+      console.log(`\nApplying template ${migration.fromTemplateVersion} -> ${migration.toTemplateVersion} (${migration.id})...`);
+    }
+    const needsInstall = shouldValidate(migration, operations);
+    executePhase(projectRoot, operations, packageManager, needsInstall, undefined, targetProfile.expoDoctorVersion);
+    cleanupRejects(projectRoot, migration);
+    if (hasMore) {
+      console.log(`\nTemplate version ${migration.toTemplateVersion} completed successfully.`);
+      console.log(`Run npx --package ${HOST_PACKAGE}@latest upgrade-template for the next version.`);
+    } else {
+      console.log('\nUpgrade completed successfully.');
+    }
+  };
+  if (options.dryRun) return runUpgrade();
+  return withUpgradeLock(projectRoot, runUpgrade);
+}
+
+if (require.main === module) {
+  main().catch(error => {
+    console.error(`[upgrade-template] ${error.message}`);
+    process.exitCode = 1;
+  });
+}
+
+module.exports = {
+  main,
+  parseArgs,
+};