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

package/scripts/upgrade/runtime.js

@@ -0,0 +1,463 @@
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const { applyPatch, formatPatch, parsePatch, reversePatch } = require('diff');
+
+const HOST_PACKAGE = '@microsoft/power-apps-native-host';
+const TEMPLATE_VERSION_PATH = 'app.json';
+const TSCONFIG_PATH = 'tsconfig.json';
+const TEMPLATE_MANAGED_PATHS = [
+  TEMPLATE_VERSION_PATH,
+  'app.config.js',
+  'package-lock.json',
+  'package.json',
+  TSCONFIG_PATH,
+];
+const UNIFIED_PATCH_MANAGED_PATHS = ['app.config.js'];
+
+function isTemplateManagedPath(relativePath) {
+  return TEMPLATE_MANAGED_PATHS.includes(relativePath);
+}
+
+function isUnifiedPatchManagedPath(relativePath) {
+  return UNIFIED_PATCH_MANAGED_PATHS.includes(relativePath);
+}
+
+function isCustomerOwnedPath(relativePath) {
+  return !isTemplateManagedPath(relativePath);
+}
+
+function readJson(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+
+function hashContent(content) {
+  return content === null ? null : crypto.createHash('sha256').update(content).digest('hex');
+}
+
+function assertSafeFilePath(projectRoot, filePath) {
+  const root = path.resolve(projectRoot);
+  if (filePath !== root && !filePath.startsWith(`${root}${path.sep}`)) {
+    throw new Error(`Patch path escapes project root: ${filePath}`);
+  }
+  let current = root;
+  for (const segment of path.relative(root, filePath).split(path.sep)) {
+    current = path.join(current, segment);
+    if (fs.existsSync(current) && fs.lstatSync(current).isSymbolicLink()) {
+      throw new Error(`Migration cannot modify symbolic link path: ${path.relative(root, current)}`);
+    }
+  }
+}
+
+function parseFileMode(mode) {
+  if (mode === null || mode === undefined) return null;
+  const serialized = String(mode);
+  if (!/^(?:(?:100|000)?(?:644|755))$/.test(serialized)) throw new Error(`Invalid migration file mode: ${mode}`);
+  return Number.parseInt(serialized.slice(-3), 8);
+}
+
+function isHashOrNull(value) {
+  return value === null || typeof value === 'string' && /^[a-f0-9]{64}$/.test(value);
+}
+
+function jsonFormatting(source) {
+  const indentMatch = source.match(/\n([\t ]+)\S/);
+  return {
+    indent: indentMatch ? indentMatch[1] : '  ',
+    newline: source.includes('\r\n') ? '\r\n' : '\n',
+  };
+}
+
+function stringifyJson(value, source) {
+  const { indent, newline } = jsonFormatting(source);
+  return `${JSON.stringify(value, null, indent).replace(/\n/g, newline)}${newline}`;
+}
+
+function setManagedValues(target, values, section, changes) {
+  target[section] ||= {};
+  for (const [name, version] of Object.entries(values)) {
+    const otherSections = section === 'dependencies'
+      ? ['devDependencies', 'optionalDependencies']
+      : section === 'devDependencies' ? ['dependencies', 'optionalDependencies'] : [];
+    for (const otherSection of otherSections) {
+      if (target[otherSection]?.[name] !== undefined) {
+        changes.push(`move ${name} from ${otherSection} to ${section}`);
+        delete target[otherSection][name];
+      }
+    }
+    if (target[section][name] !== version) {
+      changes.push(`${section}.${name}: ${target[section][name] || '(missing)'} -> ${version}`);
+      target[section][name] = version;
+    }
+  }
+}
+
+function sameValue(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+
+function formatValue(value) {
+  return typeof value === 'object' && value !== null ? JSON.stringify(value) : String(value);
+}
+
+function applyPackageTransitions(packageJson, transitions, changes, warnings) {
+  const blockedMoves = new Set();
+  for (const section of ['dependencies', 'devDependencies', 'overrides']) {
+    for (const [name, transition] of Object.entries(transitions?.[section] || {})) {
+      const current = packageJson[section]?.[name];
+      if (transition.to === null && current !== undefined && !sameValue(current, transition.from)) blockedMoves.add(name);
+    }
+  }
+  for (const section of ['dependencies', 'devDependencies', 'overrides']) {
+    packageJson[section] ||= {};
+    for (const [name, transition] of Object.entries(transitions?.[section] || {})) {
+      const current = packageJson[section][name];
+      if (transition.to === null) {
+        if (sameValue(current, transition.from)) {
+          changes.push(`remove ${section}.${name}`);
+          delete packageJson[section][name];
+        } else if (current !== undefined) warnings.push(`retain customized ${section}.${name}`);
+      } else if (transition.from === null && blockedMoves.has(name)) {
+        warnings.push(`retain customized placement for ${name}`);
+      } else if (current === undefined || sameValue(current, transition.from)) {
+        changes.push(`${section}.${name}: ${formatValue(current ?? '(missing)')} -> ${formatValue(transition.to)}`);
+        packageJson[section][name] = transition.to;
+      } else if (!sameValue(current, transition.to)) warnings.push(`retain customized ${section}.${name}`);
+    }
+  }
+}
+
+function ensureManagedValues(packageJson, values, section, changes, warnings) {
+  packageJson[section] ||= {};
+  for (const [name, targetValue] of Object.entries(values || {})) {
+    const otherSections = section === 'dependencies'
+      ? ['devDependencies', 'optionalDependencies']
+      : section === 'devDependencies' ? ['dependencies', 'optionalDependencies'] : [];
+    const otherSection = otherSections.find(candidate => packageJson[candidate]?.[name] !== undefined);
+    if (packageJson[section][name] === undefined && !otherSection) {
+      changes.push(`add missing ${section}.${name}: ${formatValue(targetValue)}`);
+      packageJson[section][name] = targetValue;
+    } else if (otherSection) warnings.push(`retain customized placement ${otherSection}.${name}`);
+    else if (!sameValue(packageJson[section][name], targetValue)) warnings.push(`retain customized ${section}.${name}`);
+  }
+}
+
+function patchPackageJson(source, profile, hostVersion, transitions = null) {
+  const packageJson = JSON.parse(source);
+  const changes = [];
+  const warnings = [];
+  packageJson.dependencies ||= {};
+  setManagedValues(packageJson, { expo: profile.expoVersion }, 'dependencies', changes);
+  setManagedValues(packageJson, { [HOST_PACKAGE]: hostVersion }, 'dependencies', changes);
+  if (transitions) applyPackageTransitions(packageJson, transitions, changes, warnings);
+  ensureManagedValues(packageJson, profile.managedDependencies, 'dependencies', changes, warnings);
+  ensureManagedValues(packageJson, profile.managedDevDependencies, 'devDependencies', changes, warnings);
+  ensureManagedValues(packageJson, profile.managedOverrides, 'overrides', changes, warnings);
+  return {
+    changed: changes.length > 0,
+    changes,
+    warnings,
+    content: changes.length ? stringifyJson(packageJson, source) : source,
+  };
+}
+
+function applyJsonTransitions(target, transitions, sectionPath, changes, warnings) {
+  let section = target;
+  for (const segment of sectionPath) {
+    section[segment] ||= {};
+    section = section[segment];
+  }
+  const prefix = sectionPath.join('.');
+  for (const [name, transition] of Object.entries(transitions || {})) {
+    const current = section[name];
+    if (transition.to === null) {
+      if (sameValue(current, transition.from)) {
+        changes.push(`remove ${prefix}.${name}`);
+        delete section[name];
+      } else if (current !== undefined) warnings.push(`retain customized ${prefix}.${name}`);
+    } else if (current === undefined || sameValue(current, transition.from)) {
+      changes.push(`${prefix}.${name}: ${formatValue(current ?? '(missing)')} -> ${formatValue(transition.to)}`);
+      section[name] = transition.to;
+    } else if (!sameValue(current, transition.to)) warnings.push(`retain customized ${prefix}.${name}`);
+  }
+}
+
+function patchTsconfigJson(source, transitions = null) {
+  const tsconfig = JSON.parse(source);
+  const changes = [];
+  const warnings = [];
+  applyJsonTransitions(tsconfig, transitions?.paths, ['compilerOptions', 'paths'], changes, warnings);
+  return {
+    changed: changes.length > 0,
+    changes,
+    warnings,
+    content: changes.length ? stringifyJson(tsconfig, source) : source,
+  };
+}
+
+function buildMigrationOperations(projectRoot, migration) {
+  if (!migration) return { operations: [], conflicts: [] };
+  const operations = [];
+  const rejectOperations = [];
+  const conflicts = [];
+  const patchedPaths = new Set();
+  for (const patch of parseMigrationPatch(migration.patch)) {
+    const oldPath = patch.oldFileName;
+    const newPath = patch.newFileName;
+    const relativePath = newPath === '/dev/null' ? oldPath : newPath;
+    if (!relativePath || path.isAbsolute(relativePath) || relativePath.split(/[\\/]/).includes('..')) {
+      throw new Error(`Migration ${migration.id} contains an unsafe patch path: ${relativePath}`);
+    }
+    if (!isUnifiedPatchManagedPath(relativePath)) throw new Error(`Migration ${migration.id} cannot modify path ${relativePath} with a unified patch`);
+    if (patchedPaths.has(relativePath)) throw new Error(`Migration ${migration.id} patches ${relativePath} more than once`);
+    patchedPaths.add(relativePath);
+    const filePath = path.resolve(projectRoot, relativePath);
+    assertSafeFilePath(projectRoot, filePath);
+    const currentValue = fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf8') : null;
+    const currentMode = fs.existsSync(filePath) ? fs.statSync(filePath).mode & 0o777 : null;
+    const currentContent = currentValue || '';
+    const isCreate = oldPath === '/dev/null';
+    const isDelete = newPath === '/dev/null';
+    const metadata = migration.patchFiles?.[relativePath];
+    if (!metadata) throw new Error(`Migration ${migration.id} is missing metadata for ${relativePath}`);
+    const targetMode = parseFileMode(metadata.toMode);
+    if (hashContent(currentValue) === metadata.toHash) {
+      addModeOperation(operations, filePath, currentValue, currentMode, targetMode, metadata.toMode, migration.id);
+      continue;
+    }
+    if (isCreate && currentValue !== null) {
+      addConflict(rejectOperations, conflicts, filePath, relativePath, migration.id, patch, true);
+      continue;
+    }
+    if (isDelete && currentValue === null) continue;
+    const patchedContent = applyPatch(currentContent, patch);
+    if (patchedContent === false) {
+      const reversedContent = applyPatch(currentContent, reversePatch(patch));
+      if (reversedContent !== false && applyPatch(reversedContent, patch) === currentContent) {
+        addModeOperation(operations, filePath, currentValue, currentMode, targetMode, metadata.toMode, migration.id);
+        continue;
+      }
+      addConflict(rejectOperations, conflicts, filePath, relativePath, migration.id, patch, false);
+      continue;
+    }
+    if (isDelete && patchedContent !== '') {
+      addConflict(rejectOperations, conflicts, filePath, relativePath, migration.id, patch, false);
+      continue;
+    }
+    if (hashContent(currentValue) === metadata.fromHash && hashContent(isDelete ? null : patchedContent) !== metadata.toHash) {
+      throw new Error(`Migration ${migration.id} produced an unexpected result for ${relativePath}`);
+    }
+    operations.push({
+      filePath,
+      changed: true,
+      changes: [`apply unified patch from migration ${migration.id}`],
+      content: isDelete ? null : patchedContent,
+      delete: isDelete,
+      mode: metadata.toMode,
+    });
+  }
+  return conflicts.length ? { operations: rejectOperations, conflicts } : { operations, conflicts: [] };
+}
+
+function addModeOperation(operations, filePath, content, currentMode, targetMode, serializedMode, migrationId) {
+  if (targetMode !== null && currentMode !== targetMode) {
+    operations.push({ filePath, changed: true, changes: [`apply file mode from migration ${migrationId}`], content, mode: serializedMode });
+  }
+}
+
+function addConflict(operations, conflicts, filePath, relativePath, migrationId, patch, existingFile) {
+  conflicts.push(relativePath);
+  operations.push({
+    filePath: `${filePath}.power-apps-${migrationId}.rej`,
+    changed: true,
+    changes: [`write rejected migration hunk${existingFile ? ' for existing file' : ' for'} ${relativePath}`],
+    content: formatPatch(patch),
+    reject: true,
+  });
+}
+
+function readProjectState(projectRoot, targetVersion, fromVersion) {
+  const statePath = path.join(projectRoot, TEMPLATE_VERSION_PATH);
+  if (fs.existsSync(statePath)) {
+    const state = readJson(statePath).expo?.extra?.powerappsNative;
+    if (state) {
+      if (state.schemaVersion !== 1) throw new Error(`${TEMPLATE_VERSION_PATH} uses unsupported schemaVersion ${state.schemaVersion}`);
+      if (!Number.isInteger(state.templateVersion)) throw new Error(`${TEMPLATE_VERSION_PATH} has an invalid templateVersion`);
+      return state;
+    }
+  }
+  if (fromVersion) return { schemaVersion: 1, templateVersion: fromVersion };
+  if (targetVersion === 1) return { schemaVersion: 1, templateVersion: 1 };
+  throw new Error(`Template state is missing. Rerun with --from-version <version> after identifying the app's source template version.`);
+}
+
+function selectNextMigration(migrations, fromVersion, targetVersion) {
+  if (fromVersion > targetVersion) throw new Error(`Template downgrade ${fromVersion} -> ${targetVersion} is not supported`);
+  if (fromVersion === targetVersion) return null;
+  const candidates = migrations.filter(migration => migration.fromTemplateVersion === fromVersion);
+  if (candidates.length !== 1) throw new Error(`Expected exactly one migration from template version ${fromVersion}; found ${candidates.length}`);
+  const migration = candidates[0];
+  if (migration.toTemplateVersion !== fromVersion + 1 || migration.toTemplateVersion > targetVersion) {
+    throw new Error(`Migration ${migration.id} has an invalid target template version`);
+  }
+  return migration;
+}
+
+function loadMigrations(profile, migrationsDirectory) {
+  if (profile.schemaVersion !== 1) throw new Error(`Compatibility profile uses unsupported schemaVersion ${profile.schemaVersion}`);
+  if (!Number.isInteger(profile.targetTemplateVersion) || profile.targetTemplateVersion < 1) throw new Error('Compatibility profile has an invalid targetTemplateVersion');
+  const ids = profile.migrations || [];
+  if (new Set(ids).size !== ids.length) throw new Error('Compatibility profile contains duplicate migration IDs');
+  const migrations = ids.map(migrationId => loadMigration(migrationId, migrationsDirectory));
+  validateGraph(migrations, profile.targetTemplateVersion);
+  return migrations;
+}
+
+function loadMigration(migrationId, migrationsDirectory) {
+  if (!/^[a-z0-9][a-z0-9._-]*$/i.test(migrationId)) throw new Error(`Compatibility profile contains unsafe migration ID: ${migrationId}`);
+  const migrationPath = path.join(migrationsDirectory, `${migrationId}.json`);
+  if (!fs.existsSync(migrationPath)) throw new Error(`Migration ${migrationId} is missing from the host package`);
+  const migration = readJson(migrationPath);
+  if (migration.schemaVersion !== 1) throw new Error(`Migration ${migrationId} uses unsupported schemaVersion ${migration.schemaVersion}`);
+  if (migration.patchFile !== `${migrationId}.patch`) throw new Error(`Migration ${migrationId} has an unsafe patch filename`);
+  const patchPath = path.join(migrationsDirectory, migration.patchFile);
+  if (!fs.existsSync(patchPath)) throw new Error(`Patch file ${migration.patchFile} is missing from the host package`);
+  const patch = fs.readFileSync(patchPath, 'utf8');
+  if (migration.id !== migrationId) throw new Error(`Migration file ${migrationId} has mismatched id ${migration.id}`);
+  if (!Number.isInteger(migration.fromTemplateVersion) || !Number.isInteger(migration.toTemplateVersion)) {
+    throw new Error(`Migration ${migration.id} is missing template version boundaries`);
+  }
+  if (!migration.targetProfile?.hostVersion || !migration.targetProfile?.expoVersion || !migration.targetProfile?.expoDoctorVersion) {
+    throw new Error(`Migration ${migration.id} has an incomplete target profile`);
+  }
+  validatePatchMetadata(migration, patch);
+  return { ...migration, patch };
+}
+
+function validatePatchMetadata(migration, patch) {
+  try {
+    const parsedPatches = parseMigrationPatch(patch);
+    const patchPaths = parsedPatches.map(item => item.newFileName === '/dev/null' ? item.oldFileName : item.newFileName);
+    if (new Set(patchPaths).size !== patchPaths.length) throw new Error('duplicate patch paths');
+    if (patchPaths.some(filePath => !migration.patchFiles?.[filePath])) throw new Error('patch metadata is incomplete');
+    if (Object.keys(migration.patchFiles || {}).some(filePath => !patchPaths.includes(filePath))) throw new Error('patch metadata contains extra files');
+    for (const parsedPatch of parsedPatches) {
+      const oldPath = parsedPatch.oldFileName;
+      const newPath = parsedPatch.newFileName;
+      const isCreate = oldPath === '/dev/null';
+      const isDelete = newPath === '/dev/null';
+      if (isCreate && isDelete || !isCreate && !isDelete && oldPath !== newPath) throw new Error(`unsupported rename patch ${oldPath} -> ${newPath}`);
+      const filePath = isDelete ? oldPath : newPath;
+      if (!filePath || path.isAbsolute(filePath) || filePath.split(/[\\/]/).includes('..')) throw new Error(`unsafe patch path ${filePath}`);
+      if (!isUnifiedPatchManagedPath(filePath)) throw new Error(`unified patch path ${filePath} is not managed by raw patches`);
+      const metadata = migration.patchFiles[filePath];
+      if (!isHashOrNull(metadata.fromHash) || !isHashOrNull(metadata.toHash)) throw new Error(`invalid hashes for ${filePath}`);
+      parseFileMode(metadata.fromMode);
+      parseFileMode(metadata.toMode);
+      if (isCreate && (metadata.fromHash !== null || metadata.fromMode !== null || metadata.toHash === null || metadata.toMode === null)) {
+        throw new Error(`invalid creation metadata for ${filePath}`);
+      }
+      if (isDelete && (metadata.toHash !== null || metadata.toMode !== null || metadata.fromHash === null || metadata.fromMode === null)) {
+        throw new Error(`invalid deletion metadata for ${filePath}`);
+      }
+      if (!isCreate && !isDelete && (metadata.fromHash === null || metadata.toHash === null || metadata.fromMode === null || metadata.toMode === null)) {
+        throw new Error(`invalid update metadata for ${filePath}`);
+      }
+    }
+  } catch (error) {
+    throw new Error(`Migration ${migration.id} has an invalid patch: ${error.message}`);
+  }
+}
+
+function parseMigrationPatch(patch) {
+  return patch.trim() ? parsePatch(patch) : [];
+}
+
+function validateGraph(migrations, targetVersion) {
+  const fromVersions = new Set();
+  for (const migration of migrations) {
+    if (!Number.isInteger(migration.fromTemplateVersion) || migration.fromTemplateVersion < 1) throw new Error(`Migration ${migration.id} has an invalid source version`);
+    if (migration.toTemplateVersion !== migration.fromTemplateVersion + 1) throw new Error(`Migration ${migration.id} is not adjacent`);
+    if (fromVersions.has(migration.fromTemplateVersion)) throw new Error(`Multiple migrations start at template version ${migration.fromTemplateVersion}`);
+    fromVersions.add(migration.fromTemplateVersion);
+  }
+  if (migrations.length) {
+    const firstVersion = Math.min(...fromVersions);
+    for (let version = firstVersion; version < targetVersion; version += 1) {
+      if (!fromVersions.has(version)) throw new Error(`Migration graph is missing template version ${version} -> ${version + 1}`);
+    }
+    if (Math.max(...migrations.map(migration => migration.toTemplateVersion)) !== targetVersion) {
+      throw new Error(`Migration graph does not reach target template version ${targetVersion}`);
+    }
+  }
+}
+
+function buildUpgradePlan(projectRoot, profile, hostVersion, fromVersion, migrationsDirectory, includeState = true) {
+  const migrations = loadMigrations(profile, migrationsDirectory);
+  const state = readProjectState(projectRoot, profile.targetTemplateVersion, fromVersion);
+  const migration = selectNextMigration(migrations, state.templateVersion, profile.targetTemplateVersion);
+  const targetProfile = migration ? migration.targetProfile : profile;
+  const targetHostVersion = migration ? migration.targetProfile.hostVersion : hostVersion;
+  const migrationPlan = buildMigrationOperations(projectRoot, migration);
+  if (migrationPlan.conflicts.length) return migrationPlan;
+  const operations = migrationPlan.operations;
+  const packagePath = path.join(projectRoot, 'package.json');
+  const packagePatch = patchPackageJson(fs.readFileSync(packagePath, 'utf8'), targetProfile, targetHostVersion, migration?.packageTransitions || null);
+  if (packagePatch.changed) operations.push({ filePath: packagePath, ...packagePatch });
+  if (migration?.tsconfigTransitions) {
+    const tsconfigPath = path.join(projectRoot, TSCONFIG_PATH);
+    const source = fs.existsSync(tsconfigPath) ? fs.readFileSync(tsconfigPath, 'utf8') : '{}\n';
+    const tsconfigPatch = patchTsconfigJson(source, migration.tsconfigTransitions);
+    if (tsconfigPatch.changed) operations.push({ filePath: tsconfigPath, ...tsconfigPatch });
+  }
+  if (includeState) addStateOperation(operations, projectRoot, migration?.toTemplateVersion || profile.targetTemplateVersion);
+  return {
+    operations,
+    conflicts: [],
+    migration,
+    state,
+    targetProfile,
+    targetHostVersion,
+    hasMore: Boolean(migration && migration.toTemplateVersion < profile.targetTemplateVersion),
+  };
+}
+
+function addStateOperation(operations, projectRoot, targetVersion) {
+  const statePath = path.join(projectRoot, TEMPLATE_VERSION_PATH);
+  const nextState = { schemaVersion: 1, templateVersion: targetVersion };
+  const appConfig = fs.existsSync(statePath) ? readJson(statePath) : {};
+  const currentState = appConfig.expo?.extra?.powerappsNative || null;
+  if (JSON.stringify(currentState) !== JSON.stringify(nextState)) {
+    appConfig.expo ||= {};
+    appConfig.expo.extra ||= {};
+    appConfig.expo.extra.powerappsNative = nextState;
+    operations.push({
+      filePath: statePath,
+      changed: true,
+      changes: [`record template version ${targetVersion}`],
+      content: `${JSON.stringify(appConfig, null, 2)}\n`,
+      state: true,
+    });
+  }
+}
+
+module.exports = {
+  HOST_PACKAGE,
+  TEMPLATE_VERSION_PATH,
+  assertSafeFilePath,
+  buildMigrationOperations,
+  buildUpgradePlan,
+  hashContent,
+  isHashOrNull,
+  isCustomerOwnedPath,
+  isTemplateManagedPath,
+  isUnifiedPatchManagedPath,
+  parseFileMode,
+  patchTsconfigJson,
+  patchPackageJson,
+  readJson,
+  readProjectState,
+  selectNextMigration,
+};