react-native-update-cli 2.8.5 → 2.9.0

package/src/provider.ts

@@ -12,27 +12,73 @@ import type {
   UploadOptions,
   Version,
 } from './types';
+import { runAsCommandResult } from './utils/command-result';
+import { runWorkflow } from './workflow-runner';
 
 export class CLIProviderImpl implements CLIProvider {
   private workflows: Map<string, CustomWorkflow> = new Map();
   private session?: Session;
+  private sessionInitPromise?: Promise<void>;
 
-  constructor() {
-    this.init();
+  private createContext(
+    options: Record<string, unknown>,
+    args: string[] = [],
+  ): CommandContext {
+    return { args, options };
   }
 
-  private async init() {
-    try {
-      await loadSession();
-      this.session = getSession();
-    } catch (error) {}
+  private async ensureInitialized(): Promise<void> {
+    if (this.session) {
+      return;
+    }
+
+    if (!this.sessionInitPromise) {
+      this.sessionInitPromise = (async () => {
+        await loadSession();
+        this.session = getSession();
+      })().finally(() => {
+        this.sessionInitPromise = undefined;
+      });
+    }
+
+    await this.sessionInitPromise;
+  }
+
+  private runMessageCommand(
+    task: () => Promise<void>,
+    fallbackError: string,
+    successMessage: string,
+    requireSession = true,
+  ): Promise<CommandResult> {
+    return runAsCommandResult(
+      async () => {
+        if (requireSession) {
+          await this.ensureInitialized();
+        }
+        await task();
+      },
+      fallbackError,
+      () => ({ message: successMessage }),
+    );
+  }
+
+  private runDataCommand<T>(
+    task: () => Promise<T>,
+    fallbackError: string,
+    requireSession = true,
+  ): Promise<CommandResult> {
+    return runAsCommandResult(async () => {
+      if (requireSession) {
+        await this.ensureInitialized();
+      }
+      return task();
+    }, fallbackError);
   }
 
   async bundle(options: BundleOptions): Promise<CommandResult> {
-    try {
-      const context: CommandContext = {
-        args: [],
-        options: {
+    return this.runMessageCommand(
+      async () => {
+        const context = this.createContext({
           dev: options.dev || false,
           platform: options.platform,
           bundleName: options.bundleName || 'index.bundlejs',
@@ -43,32 +89,21 @@ export class CLIProviderImpl implements CLIProvider {
           expo: options.expo || false,
           rncli: options.rncli || false,
           hermes: options.hermes || false,
-        },
-      };
-
-      const { bundleCommands } = await import('./bundle');
-      await bundleCommands.bundle(context);
-
-      return {
-        success: true,
-        data: { message: 'Bundle created successfully' },
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error:
-          error instanceof Error
-            ? error.message
-            : 'Unknown error during bundling',
-      };
-    }
+        });
+
+        const { bundleCommands } = await import('./bundle');
+        await bundleCommands.bundle(context);
+      },
+      'Unknown error during bundling',
+      'Bundle created successfully',
+      false,
+    );
   }
 
   async publish(options: PublishOptions): Promise<CommandResult> {
-    try {
-      const context: CommandContext = {
-        args: [],
-        options: {
+    return this.runMessageCommand(
+      async () => {
+        const context = this.createContext({
           name: options.name,
           description: options.description,
           metaInfo: options.metaInfo,
@@ -79,72 +114,50 @@ export class CLIProviderImpl implements CLIProvider {
           packageVersionRange: options.packageVersionRange,
           rollout: options.rollout,
           dryRun: options.dryRun || false,
-        },
-      };
-
-      const { versionCommands } = await import('./versions');
-      await versionCommands.publish(context);
-
-      return {
-        success: true,
-        data: { message: 'Version published successfully' },
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error:
-          error instanceof Error
-            ? error.message
-            : 'Unknown error during publishing',
-      };
-    }
+        });
+
+        const { versionCommands } = await import('./versions');
+        await versionCommands.publish(context);
+      },
+      'Unknown error during publishing',
+      'Version published successfully',
+    );
   }
 
   async upload(options: UploadOptions): Promise<CommandResult> {
-    try {
-      const platform = await this.getPlatform(options.platform);
-      const { appId } = await this.getSelectedApp(platform);
-
-      const filePath = options.filePath;
-      const fileType = filePath.split('.').pop()?.toLowerCase();
-
-      const context: CommandContext = {
-        args: [filePath],
-        options: { platform, appId, version: options.version },
-      };
-
-      const { packageCommands } = await import('./package');
-
-      switch (fileType) {
-        case 'ipa':
-          await packageCommands.uploadIpa(context);
-          break;
-        case 'apk':
-          await packageCommands.uploadApk(context);
-          break;
-        case 'aab':
-          await packageCommands.uploadAab(context);
-          break;
-        case 'app':
-          await packageCommands.uploadApp(context);
-          break;
-        default:
+    return this.runMessageCommand(
+      async () => {
+        const platform = await this.getPlatform(options.platform);
+        const { appId } = await this.getSelectedApp(platform);
+
+        const filePath = options.filePath;
+        const fileType = filePath.split('.').pop()?.toLowerCase();
+
+        const context = this.createContext(
+          { platform, appId, version: options.version },
+          [filePath],
+        );
+
+        const { packageCommands } = await import('./package');
+        const uploadHandlerMap = {
+          ipa: packageCommands.uploadIpa,
+          apk: packageCommands.uploadApk,
+          aab: packageCommands.uploadAab,
+          app: packageCommands.uploadApp,
+        } as const;
+        const uploadHandler =
+          fileType && fileType in uploadHandlerMap
+            ? uploadHandlerMap[fileType as keyof typeof uploadHandlerMap]
+            : undefined;
+
+        if (!uploadHandler) {
           throw new Error(`Unsupported file type: ${fileType}`);
-      }
-
-      return {
-        success: true,
-        data: { message: 'File uploaded successfully' },
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error:
-          error instanceof Error
-            ? error.message
-            : 'Unknown error during upload',
-      };
-    }
+        }
+        await uploadHandler(context);
+      },
+      'Unknown error during upload',
+      'File uploaded successfully',
+    );
   }
 
   async getSelectedApp(
@@ -155,71 +168,45 @@ export class CLIProviderImpl implements CLIProvider {
   }
 
   async listApps(platform?: Platform): Promise<CommandResult> {
-    try {
-      const resolvedPlatform = await this.getPlatform(platform);
-      const { appCommands } = await import('./app');
-      await appCommands.apps({ options: { platform: resolvedPlatform } });
-
-      return {
-        success: true,
-        data: { message: 'Apps listed successfully' },
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error:
-          error instanceof Error ? error.message : 'Unknown error listing apps',
-      };
-    }
+    return this.runMessageCommand(
+      async () => {
+        const resolvedPlatform = await this.getPlatform(platform);
+        const { appCommands } = await import('./app');
+        await appCommands.apps({ options: { platform: resolvedPlatform } });
+      },
+      'Unknown error listing apps',
+      'Apps listed successfully',
+    );
   }
 
   async createApp(name: string, platform: Platform): Promise<CommandResult> {
-    try {
-      const { appCommands } = await import('./app');
-      await appCommands.createApp({
-        options: {
-          name,
-          platform,
-          downloadUrl: '',
-        },
-      });
-
-      return {
-        success: true,
-        data: { message: 'App created successfully' },
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error:
-          error instanceof Error ? error.message : 'Unknown error creating app',
-      };
-    }
+    return this.runMessageCommand(
+      async () => {
+        const { appCommands } = await import('./app');
+        await appCommands.createApp({
+          options: {
+            name,
+            platform,
+            downloadUrl: '',
+          },
+        });
+      },
+      'Unknown error creating app',
+      'App created successfully',
+    );
   }
 
   async listVersions(appId: string): Promise<CommandResult> {
-    try {
-      const context: CommandContext = {
-        args: [],
-        options: { appId },
-      };
-
-      const { versionCommands } = await import('./versions');
-      await versionCommands.versions(context);
-
-      return {
-        success: true,
-        data: { message: 'Versions listed successfully' },
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error:
-          error instanceof Error
-            ? error.message
-            : 'Unknown error listing versions',
-      };
-    }
+    return this.runMessageCommand(
+      async () => {
+        const context = this.createContext({ appId });
+
+        const { versionCommands } = await import('./versions');
+        await versionCommands.versions(context);
+      },
+      'Unknown error listing versions',
+      'Versions listed successfully',
+    );
   }
 
   async updateVersion(
@@ -227,31 +214,16 @@ export class CLIProviderImpl implements CLIProvider {
     versionId: string,
     updates: Partial<Version>,
   ): Promise<CommandResult> {
-    try {
-      const context: CommandContext = {
-        args: [versionId],
-        options: {
-          appId,
-          ...updates,
-        },
-      };
-
-      const { versionCommands } = await import('./versions');
-      await versionCommands.update(context);
-
-      return {
-        success: true,
-        data: { message: 'Version updated successfully' },
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error:
-          error instanceof Error
-            ? error.message
-            : 'Unknown error updating version',
-      };
-    }
+    return this.runMessageCommand(
+      async () => {
+        const context = this.createContext({ appId, ...updates }, [versionId]);
+
+        const { versionCommands } = await import('./versions');
+        await versionCommands.update(context);
+      },
+      'Unknown error updating version',
+      'Version updated successfully',
+    );
   }
 
   async getPlatform(platform?: Platform): Promise<Platform> {
@@ -259,8 +231,7 @@ export class CLIProviderImpl implements CLIProvider {
   }
 
   async loadSession(): Promise<Session> {
-    await loadSession();
-    this.session = getSession();
+    await this.ensureInitialized();
     if (!this.session) {
       throw new Error('Failed to load session');
     }
@@ -275,70 +246,23 @@ export class CLIProviderImpl implements CLIProvider {
     workflowName: string,
     context: CommandContext,
   ): Promise<CommandResult> {
-    const workflow = this.workflows.get(workflowName);
-    if (!workflow) {
-      return {
-        success: false,
-        error: `Workflow '${workflowName}' not found`,
-      };
-    }
-
-    try {
-      let previousResult: any = null;
-      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 this.runDataCommand(async () => {
+      const workflow = this.workflows.get(workflowName);
+      if (!workflow) {
+        throw new Error(`Workflow '${workflowName}' not found`);
       }
-
-      return {
-        success: true,
-        data: {
-          message: `Workflow '${workflowName}' completed successfully`,
-          result: previousResult,
-        },
-      };
-    } catch (error) {
+      const result = await runWorkflow(workflowName, workflow, context);
       return {
-        success: false,
-        error:
-          error instanceof Error
-            ? error.message
-            : `Workflow '${workflowName}' failed`,
+        message: `Workflow '${workflowName}' completed successfully`,
+        result,
       };
-    }
-  }
-
-  getRegisteredWorkflows(): string[] {
-    return Array.from(this.workflows.keys());
+    }, `Workflow '${workflowName}' failed`);
   }
 
   async listPackages(appId?: string): Promise<CommandResult> {
-    try {
-      const context: CommandContext = {
-        args: [],
-        options: appId ? { appId } : {},
-      };
-
+    return this.runDataCommand(async () => {
       const { listPackage } = await import('./package');
-      const result = await listPackage(appId || '');
-
-      return {
-        success: true,
-        data: result,
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error:
-          error instanceof Error
-            ? error.message
-            : 'Unknown error listing packages',
-      };
-    }
+      return listPackage(appId || '');
+    }, 'Unknown error listing packages');
   }
 }

package/src/types.ts

@@ -16,8 +16,8 @@ export interface Package {
   status?: string;
   appId?: string;
   appKey?: string;
-  versionName?: any;
-  buildTime?: any;
+  versionName?: string | number | null;
+  buildTime?: string | number | null;
   deps?: Record<string, string> | string | null;
 }
 
@@ -29,9 +29,11 @@ export interface Version {
   deps?: Record<string, string> | string | null;
 }
 
-export interface CommandContext {
+export interface CommandContext<
+  TOptions extends Record<string, unknown> = Record<string, unknown>,
+> {
   args: string[];
-  options: Record<string, any>;
+  options: TOptions;
   platform?: Platform;
   appId?: string;
   session?: Session;
@@ -39,7 +41,7 @@ export interface CommandContext {
 
 export interface CommandResult {
   success: boolean;
-  data?: any;
+  data?: unknown;
   error?: string;
 }
 
@@ -51,7 +53,7 @@ export interface CommandDefinition {
     string,
     {
       hasValue?: boolean;
-      default?: any;
+      default?: unknown;
       description?: string;
     }
   >;
@@ -93,7 +95,10 @@ export interface UploadOptions {
 export interface WorkflowStep {
   name: string;
   description?: string;
-  execute: (context: CommandContext, previousResult?: any) => Promise<any>;
+  execute: (
+    context: CommandContext,
+    previousResult?: unknown,
+  ) => Promise<unknown>;
   condition?: (context: CommandContext) => boolean;
 }
 
@@ -106,7 +111,7 @@ export interface CustomWorkflow {
     string,
     {
       hasValue?: boolean;
-      default?: any;
+      default?: unknown;
       description?: string;
     }
   >;

package/src/utils/app-info-parser/aab.ts

@@ -10,13 +10,6 @@ import { ManifestParser } from './xml-parser/manifest';
 import { Zip } from './zip';
 
 export class AabParser extends Zip {
-  file: string | File;
-
-  constructor(file: string | File) {
-    super(file);
-    this.file = file;
-  }
-
   async extractApk(
     outputPath: string,
     {

package/src/utils/app-info-parser/apk.ts

@@ -8,10 +8,13 @@ const ResourceName = /^resources\.arsc$/;
 
 export class ApkParser extends Zip {
   parse(): Promise<any> {
+    const manifestKey = ManifestName.toString();
+    const resourceKey = ResourceName.toString();
+
     return new Promise((resolve, reject) => {
       this.getEntries([ManifestName, ResourceName])
-        .then((buffers: any) => {
-          const manifestBuffer = buffers[ManifestName];
+        .then((buffers: Record<string, Buffer | Blob | undefined>) => {
+          const manifestBuffer = buffers[manifestKey];
           if (!manifestBuffer) {
             throw new Error("AndroidManifest.xml can't be found.");
           }
@@ -20,19 +23,19 @@ export class ApkParser extends Zip {
 
           apkInfo = this._parseManifest(manifestBuffer as Buffer);
 
-          if (!buffers[ResourceName]) {
+          if (!buffers[resourceKey]) {
             resolve(apkInfo);
           } else {
             resourceMap = this._parseResourceMap(
-              buffers[ResourceName] as Buffer,
+              buffers[resourceKey] as Buffer,
             );
             apkInfo = mapInfoResource(apkInfo, resourceMap);
 
             const iconPath = findApkIconPath(apkInfo);
             if (iconPath) {
               this.getEntry(iconPath)
-                .then((iconBuffer: Buffer | null) => {
-                  apkInfo.icon = iconBuffer
+                .then((iconBuffer: Buffer | Blob | undefined) => {
+                  apkInfo.icon = Buffer.isBuffer(iconBuffer)
                     ? getBase64FromBuffer(iconBuffer)
                     : null;
                   resolve(apkInfo);

package/src/utils/app-info-parser/app.ts

@@ -1,3 +1,7 @@
 import { Zip } from './zip';
 
-export class AppParser extends Zip {}
+export class AppParser extends Zip {
+  async parse(): Promise<Record<string, never>> {
+    return {};
+  }
+}

package/src/utils/app-info-parser/index.ts

@@ -2,11 +2,14 @@ import { AabParser } from './aab';
 import { ApkParser } from './apk';
 import { AppParser } from './app';
 import { IpaParser } from './ipa';
-const supportFileTypes = ['ipa', 'apk', 'app', 'aab'];
+
+const supportFileTypes = ['ipa', 'apk', 'app', 'aab'] as const;
+type SupportedFileType = (typeof supportFileTypes)[number];
+type AppInfoInnerParser = AabParser | ApkParser | AppParser | IpaParser;
 
 class AppInfoParser {
   file: string | File;
-  parser: any;
+  parser: AppInfoInnerParser;
   /**
    * parser for parsing .ipa or .apk file
    * @param {String | File} file // file's path in Node, instance of File in Browser
@@ -19,14 +22,14 @@ class AppInfoParser {
     }
     const splits = (typeof file === 'string' ? file : file.name).split('.');
     const fileType = splits[splits.length - 1].toLowerCase();
-    if (!supportFileTypes.includes(fileType)) {
+    if (!supportFileTypes.includes(fileType as SupportedFileType)) {
       throw new Error(
         'Unsupported file type, only support .ipa, .apk, .app, or .aab file.',
       );
     }
     this.file = file;
 
-    switch (fileType) {
+    switch (fileType as SupportedFileType) {
       case 'ipa':
         this.parser = new IpaParser(this.file);
         break;
@@ -39,10 +42,12 @@ class AppInfoParser {
       case 'aab':
         this.parser = new AabParser(this.file);
         break;
+      default:
+        throw new Error('Unsupported parser file type.');
     }
   }
-  parse() {
-    return this.parser.parse();
+  parse<T = unknown>(): Promise<T> {
+    return this.parser.parse() as Promise<T>;
   }
 }
 

package/src/utils/app-info-parser/ipa.ts

@@ -61,7 +61,7 @@ export class IpaParser extends Zip {
   private _parsePlist(buffer: Buffer) {
     let result: any;
     const bufferType = buffer[0];
-    if (bufferType === 60 || bufferType === '<' || bufferType === 239) {
+    if (bufferType === 60 || bufferType === 239) {
       result = parsePlist(buffer.toString());
     } else if (bufferType === 98) {
       result = parseBplist(buffer)[0];

package/src/utils/app-info-parser/utils.ts

@@ -11,6 +11,9 @@ const isPrimitive = (value: unknown): boolean =>
   value === null ||
   ['boolean', 'number', 'string', 'undefined'].includes(objectType(value));
 
+const isBrowser = (): boolean =>
+  typeof window !== 'undefined' && typeof window.document !== 'undefined';
+
 /**
  * map file place with resourceMap
  * @param {Object} apkInfo // json info parsed from .apk file