react-native-update-cli 2.8.4 → 2.9.0

package/src/versions.ts

@@ -1,9 +1,10 @@
-import { get, getAllPackages, post, put, uploadFile, doDelete } from './api';
+import { doDelete, get, getAllPackages, post, put, uploadFile } from './api';
 import { question, saveToLocal } from './utils';
 import { t } from './utils/i18n';
 
 import chalk from 'chalk';
 import { satisfies } from 'compare-versions';
+import Table from 'tty-table';
 import { getPlatform, getSelectedApp } from './app';
 import { choosePackage } from './package';
 import type { Package, Platform, Version } from './types';
@@ -24,6 +25,258 @@ interface VersionCommandOptions {
   packageVersionRange?: string;
   rollout?: string;
   dryRun?: boolean;
+  versionDeps?: Record<string, string>;
+}
+
+type Deps = Record<string, string>;
+type DepChangeType = 'added' | 'removed' | 'changed';
+
+interface DepChange {
+  dependency: string;
+  oldVersion: string;
+  newVersion: string;
+  type: DepChangeType;
+}
+
+interface DepsChangeSummary {
+  added: number;
+  removed: number;
+  changed: number;
+}
+
+function normalizeDeps(input: unknown): Deps | undefined {
+  if (!input) {
+    return undefined;
+  }
+
+  let raw: unknown = input;
+  if (typeof input === 'string') {
+    try {
+      raw = JSON.parse(input);
+    } catch (_e) {
+      return undefined;
+    }
+  }
+
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+    return undefined;
+  }
+
+  const deps: Deps = {};
+  for (const [name, version] of Object.entries(
+    raw as Record<string, unknown>,
+  )) {
+    if (typeof version === 'string' && version) {
+      deps[name] = version;
+    }
+  }
+
+  return Object.keys(deps).length > 0 ? deps : undefined;
+}
+
+function getDepsChanges(oldDeps?: Deps, newDeps?: Deps): DepChange[] {
+  if (!oldDeps || !newDeps) {
+    return [];
+  }
+
+  const rows: DepChange[] = [];
+  const keys = Object.keys({ ...oldDeps, ...newDeps }).sort((a, b) =>
+    a.localeCompare(b),
+  );
+
+  for (const key of keys) {
+    const oldVersion = oldDeps[key];
+    const newVersion = newDeps[key];
+
+    if (oldVersion === undefined && newVersion !== undefined) {
+      rows.push({
+        dependency: key,
+        oldVersion: '-',
+        newVersion,
+        type: 'added',
+      });
+      continue;
+    }
+
+    if (oldVersion !== undefined && newVersion === undefined) {
+      rows.push({
+        dependency: key,
+        oldVersion,
+        newVersion: '-',
+        type: 'removed',
+      });
+      continue;
+    }
+
+    if (
+      oldVersion !== undefined &&
+      newVersion !== undefined &&
+      oldVersion !== newVersion
+    ) {
+      rows.push({
+        dependency: key,
+        oldVersion,
+        newVersion,
+        type: 'changed',
+      });
+    }
+  }
+
+  return rows;
+}
+
+function getDepsChangeSummary(changes: DepChange[]): DepsChangeSummary {
+  return changes.reduce(
+    (acc, item) => {
+      if (item.type === 'added') {
+        acc.added += 1;
+      } else if (item.type === 'removed') {
+        acc.removed += 1;
+      } else {
+        acc.changed += 1;
+      }
+      return acc;
+    },
+    { added: 0, removed: 0, changed: 0 },
+  );
+}
+
+function renderVersionChange(change: DepChange) {
+  const arrow = chalk.gray(` ${t('depsChangeArrow')} `);
+
+  if (change.type === 'added') {
+    return `${chalk.red(t('depsChangeAddedLabel'))} | ${chalk.gray(
+      change.oldVersion,
+    )}${arrow}${chalk.red(change.newVersion)}`;
+  }
+
+  if (change.type === 'removed') {
+    return `${chalk.green(t('depsChangeRemovedLabel'))} | ${chalk.green(
+      change.oldVersion,
+    )}${arrow}${chalk.gray(change.newVersion)}`;
+  }
+
+  return `${chalk.yellow(t('depsChangeChangedLabel'))} | ${chalk.yellow(
+    change.oldVersion,
+  )}${arrow}${chalk.yellow(change.newVersion)}`;
+}
+
+function printDepsChangesForPackage({
+  pkg,
+  versionDeps,
+}: {
+  pkg: Package;
+  versionDeps: Deps;
+}) {
+  const pkgDeps = normalizeDeps(pkg.deps);
+  if (!pkgDeps) {
+    return false;
+  }
+
+  const changes = getDepsChanges(pkgDeps, versionDeps);
+  if (changes.length === 0) {
+    return false;
+  }
+
+  const summary = getDepsChangeSummary(changes);
+  const summaryText = t('depsChangeSummary', {
+    added: chalk.red(String(summary.added)),
+    removed: chalk.green(String(summary.removed)),
+    changed: chalk.yellow(String(summary.changed)),
+  });
+  const header = [
+    { value: t('depsChangeDependencyHeader') },
+    { value: t('depsChangeVersionHeader') },
+  ];
+  const rows = changes.map((change) => [
+    change.dependency,
+    renderVersionChange(change),
+  ]);
+
+  console.log('');
+  console.log(
+    chalk.yellow(
+      t('depsChangeTargetPackage', {
+        packageName: pkg.name,
+        packageId: pkg.id,
+      }),
+    ),
+  );
+  console.log(summaryText);
+  console.log(Table(header, rows).render());
+  console.log(chalk.yellow(t('depsChangeRiskWarning')));
+  return true;
+}
+
+async function findVersionDeps(appId: string, versionId: string) {
+  const targetId = String(versionId);
+  const limit = 100;
+  let offset = 0;
+
+  while (true) {
+    const { data, count } = await get(
+      `/app/${appId}/version/list?offset=${offset}&limit=${limit}`,
+    );
+    const versions: Version[] = Array.isArray(data) ? data : [];
+    const version = versions.find((item) => String(item.id) === targetId);
+
+    if (version) {
+      return normalizeDeps(version.deps);
+    }
+
+    offset += versions.length;
+    if (versions.length === 0 || offset >= Number(count || 0)) {
+      break;
+    }
+  }
+
+  return undefined;
+}
+
+async function printDepsChangesForPublish({
+  appId,
+  versionId,
+  pkgs,
+  providedVersionDeps,
+}: {
+  appId: string;
+  versionId?: string;
+  pkgs: Package[];
+  providedVersionDeps?: Deps;
+}) {
+  if (!versionId || pkgs.length === 0) {
+    return;
+  }
+
+  let versionDeps = normalizeDeps(providedVersionDeps);
+  if (!versionDeps) {
+    try {
+      versionDeps = await findVersionDeps(appId, versionId);
+    } catch (error: any) {
+      console.warn(
+        chalk.yellow(
+          t('depsChangeFetchFailed', {
+            error: error?.message || String(error),
+          }),
+        ),
+      );
+      return;
+    }
+  }
+
+  if (!versionDeps) {
+    return;
+  }
+
+  let hasChanges = false;
+  for (const pkg of pkgs) {
+    const printed = printDepsChangesForPackage({ pkg, versionDeps });
+    hasChanges = hasChanges || printed;
+  }
+
+  if (hasChanges) {
+    console.log(chalk.yellow(t('depsChangeNonBlockingHint')));
+  }
 }
 
 async function showVersion(appId: string, offset: number) {
@@ -211,12 +464,15 @@ export const versionCommands = {
           maxPackageVersion,
           rollout,
           dryRun,
+          versionDeps: depVersions,
         },
       });
     } else {
       const q = await question(t('updateNativePackageQuestion'));
       if (q.toLowerCase() === 'y') {
-        await this.update({ options: { versionId: id, platform } });
+        await this.update({
+          options: { versionId: id, platform, versionDeps: depVersions },
+        });
       }
     }
     return versionName;
@@ -318,6 +574,13 @@ export const versionCommands = {
       }
     }
 
+    await printDepsChangesForPublish({
+      appId,
+      versionId,
+      pkgs: pkgsToBind,
+      providedVersionDeps: options.versionDeps,
+    });
+
     await bindVersionToPackages({
       appId,
       versionId,

package/src/workflow-runner.ts

@@ -0,0 +1,24 @@
+import type { CommandContext, CustomWorkflow } from './types';
+
+export async function runWorkflow(
+  workflowName: string,
+  workflow: CustomWorkflow,
+  context: CommandContext,
+): Promise<unknown> {
+  if (workflow.validate && !workflow.validate(context)) {
+    throw new Error(`Workflow '${workflowName}' validation failed`);
+  }
+
+  let previousResult: unknown;
+  for (const step of workflow.steps) {
+    if (step.condition && !step.condition(context)) {
+      console.log(`Skipping step '${step.name}' due to condition`);
+      continue;
+    }
+
+    console.log(`Executing step '${step.name}'`);
+    previousResult = await step.execute(context, previousResult);
+  }
+
+  return previousResult;
+}

package/index.js

@@ -1 +0,0 @@
-module.exports = require('./lib');