refactor prompts

YaroShkvorets · YaroShkvorets · commit ea8c86734e76 · 2024-12-06T12:00:48.000-05:00
diff --git a/packages/cli/src/command-helpers/contracts.ts b/packages/cli/src/command-helpers/contracts.ts
@@ -3,7 +3,6 @@ import { NetworksRegistry } from '@pinax/graph-networks-registry';
 import debugFactory from '../debug.js';
 import fetch from '../fetch.js';
 import ABI from '../protocols/ethereum/abi.js';
-import { withSpinner } from './spinner.js';
 
 const logger = debugFactory('graph-cli:contract-service');
 
@@ -72,108 +71,84 @@ export class ContractService {
 
   async getABI(ABICtor: typeof ABI, networkId: string, address: string) {
     const urls = this.getEtherscanUrls(networkId);
-
     let errors: string[] = [];
-    return await withSpinner(
-      `Fetching ABI from contract API`,
-      `Failed to fetch ABI from contract API`,
-      `Warnings while fetching ABI from contract API`,
-      async () => {
-        if (!urls.length) {
-          throw new Error(`No contract API available for ${networkId} in the registry`);
-        }
-        for (const url of urls) {
-          try {
-            const json = await this.fetchFromEtherscan(
-              `${url}?module=contract&action=getabi&address=${address}`,
-            );
-
-            if (json) {
-              return new ABICtor('Contract', undefined, immutable.fromJS(JSON.parse(json.result)));
-            }
-            throw new Error(`no result: ${JSON.stringify(json)}`);
-          } catch (error) {
-            logger(`Failed to fetch from ${url}: ${error}`);
-            errors.push(`${error}`);
-          }
+    if (!urls.length) {
+      throw new Error(`No contract API available for ${networkId} in the registry`);
+    }
+    for (const url of urls) {
+      try {
+        const json = await this.fetchFromEtherscan(
+          `${url}?module=contract&action=getabi&address=${address}`,
+        );
+
+        if (json) {
+          return new ABICtor('Contract', undefined, immutable.fromJS(JSON.parse(json.result)));
         }
+        throw new Error(`no result: ${JSON.stringify(json)}`);
+      } catch (error) {
+        logger(`Failed to fetch from ${url}: ${error}`);
+        errors.push(`${error}`);
+      }
+    }
 
-        throw new Error(errors?.[0]);
-      },
-    );
+    throw new Error(errors?.[0]);
   }
 
   async getStartBlock(networkId: string, address: string): Promise<string> {
     const urls = this.getEtherscanUrls(networkId);
+    if (!urls.length) {
+      throw new Error(`No contract API available for ${networkId} in the registry`);
+    }
+    for (const url of urls) {
+      try {
+        const json = await this.fetchFromEtherscan(
+          `${url}?module=contract&action=getcontractcreation&contractaddresses=${address}`,
+        );
 
-    return await withSpinner(
-      `Fetching start block`,
-      `Failed to fetch start block`,
-      `Warnings while fetching deploy contract transaction from contract API`,
-      async () => {
-        if (!urls.length) {
-          throw new Error(`No contract API available for ${networkId} in the registry`);
-        }
-        for (const url of urls) {
-          try {
-            const json = await this.fetchFromEtherscan(
-              `${url}?module=contract&action=getcontractcreation&contractaddresses=${address}`,
-            );
-
-            if (json?.result?.length) {
-              if (json.result[0]?.blockNumber) {
-                return json.result[0].blockNumber;
-              }
-              const txHash = json.result[0].txHash;
-              const tx = await this.fetchTransactionByHash(networkId, txHash);
-              if (!tx?.blockNumber) {
-                throw new Error(`no blockNumber: ${JSON.stringify(tx)}`);
-              }
-              return Number(tx.blockNumber).toString();
-            }
-            throw new Error(`no result: ${JSON.stringify(json)}`);
-          } catch (error) {
-            logger(`Failed to fetch start block from ${url}: ${error}`);
+        if (json?.result?.length) {
+          if (json.result[0]?.blockNumber) {
+            return json.result[0].blockNumber;
+          }
+          const txHash = json.result[0].txHash;
+          const tx = await this.fetchTransactionByHash(networkId, txHash);
+          if (!tx?.blockNumber) {
+            throw new Error(`no blockNumber: ${JSON.stringify(tx)}`);
           }
+          return Number(tx.blockNumber).toString();
         }
+        throw new Error(`no result: ${JSON.stringify(json)}`);
+      } catch (error) {
+        logger(`Failed to fetch start block from ${url}: ${error}`);
+      }
+    }
 
-        throw new Error(`Failed to fetch deploy contract transaction for ${address}`);
-      },
-    );
+    throw new Error(`Failed to fetch deploy contract transaction for ${address}`);
   }
 
   async getContractName(networkId: string, address: string): Promise<string> {
     const urls = this.getEtherscanUrls(networkId);
-
-    return await withSpinner(
-      `Fetching contract name`,
-      `Failed to fetch contract name`,
-      `Warnings while fetching contract name from contract API`,
-      async () => {
-        if (!urls.length) {
-          throw new Error(`No contract API available for ${networkId} in the registry`);
-        }
-        for (const url of urls) {
-          try {
-            const json = await this.fetchFromEtherscan(
-              `${url}?module=contract&action=getsourcecode&address=${address}`,
-            );
-
-            if (json) {
-              const { ContractName } = json.result[0];
-              if (ContractName !== '') {
-                return ContractName;
-              }
-            }
-            throw new Error(`no result: ${JSON.stringify(json)}`);
-          } catch (error) {
-            logger(`Failed to fetch from ${url}: ${error}`);
+    if (!urls.length) {
+      throw new Error(`No contract API available for ${networkId} in the registry`);
+    }
+    for (const url of urls) {
+      try {
+        const json = await this.fetchFromEtherscan(
+          `${url}?module=contract&action=getsourcecode&address=${address}`,
+        );
+
+        if (json) {
+          const { ContractName } = json.result[0];
+          if (ContractName !== '') {
+            return ContractName;
           }
         }
+        throw new Error(`no result: ${JSON.stringify(json)}`);
+      } catch (error) {
+        logger(`Failed to fetch from ${url}: ${error}`);
+      }
+    }
 
-        throw new Error(`Failed to fetch contract name for ${address}`);
-      },
-    );
+    throw new Error(`Failed to fetch contract name for ${address}`);
   }
 
   private async fetchTransactionByHash(networkId: string, txHash: string) {
diff --git a/packages/cli/src/command-helpers/prompt-manager.ts b/packages/cli/src/command-helpers/prompt-manager.ts
@@ -5,9 +5,34 @@ export class PromptManager {
   private steps: PromptOptions[] = [];
   private currentStep = 0;
   private results: any[] = [];
+  private stepLines: number[] = [];
 
+  // adds a step prompt
   addStep(options: PromptOptions) {
     this.steps.push(options);
+    this.stepLines.push(1);
+  }
+
+  // "options" doesn't take closure, so to populate it dynamically we need to call this
+  setOptions(stepName: string, options: Partial<PromptOptions>) {
+    const step = this.steps.find(s => s.name === stepName);
+    if (step) {
+      Object.assign(step, options);
+    }
+  }
+
+  // can be called externally if more than one line is added on the step
+  addLine() {
+    this.stepLines[this.currentStep]++;
+  }
+
+  // clears the lines added during the step
+  private clearStepLines() {
+    const linesToClear = 1 + this.stepLines[this.currentStep];
+    for (let i = 0; i < linesToClear; i++) {
+      process.stdout.write('\x1b[1A\x1b[2K'); // Move up and clear line
+    }
+    this.stepLines[this.currentStep] = 1;
   }
 
   // runs all steps and returns the results
@@ -36,8 +61,7 @@ export class PromptManager {
           process.stdout.write('\n');
           process.exit(0);
         }
-        // delete 2 lines
-        process.stdout.write('\x1b[1A\x1b[2K\x1b[1A\x1b[2K');
+
         this.currentStep--;
         while (this.currentStep > 0) {
           delete this.results[this.currentStep];
@@ -46,6 +70,7 @@ export class PromptManager {
           if (!shouldSkip) break;
           this.currentStep--;
         }
+        this.clearStepLines();
       }
     }
 
diff --git a/packages/cli/src/command-helpers/retry.ts b/packages/cli/src/command-helpers/retry.ts
@@ -0,0 +1,25 @@
+import { prompt } from 'gluegun';
+
+export async function retryWithPrompt<T>(func: () => Promise<T>): Promise<T | undefined> {
+  for (;;) {
+    try {
+      return await func();
+    } catch (_) {
+      try {
+        const { retry } = await prompt.ask({
+          type: 'confirm',
+          name: 'retry',
+          message: 'Do you want to retry?',
+          initial: true,
+        });
+
+        if (!retry) {
+          break;
+        }
+      } catch (_) {
+        break;
+      }
+    }
+  }
+  return undefined;
+}
diff --git a/packages/cli/src/commands/add.ts b/packages/cli/src/commands/add.ts
@@ -5,6 +5,7 @@ import { NetworksRegistry } from '@pinax/graph-networks-registry';
 import { ContractService } from '../command-helpers/contracts.js';
 import * as DataSourcesExtractor from '../command-helpers/data-sources.js';
 import { updateNetworksFile } from '../command-helpers/network.js';
+import { retryWithPrompt } from '../command-helpers/retry.js';
 import {
   generateDataSource,
   writeABI,
@@ -100,7 +101,14 @@ export default class AddCommand extends Command {
       try {
         if (isLocalHost) throw Error; // Triggers user prompting without waiting for Etherscan lookup to fail
 
-        ethabi = await contractService?.getABI(EthereumABI, network, address);
+        ethabi = await retryWithPrompt(() =>
+          withSpinner(
+            'Fetching ABI from contract API...',
+            'Failed to fetch ABI',
+            'Warning fetching ABI',
+            () => contractService?.getABI(EthereumABI, network, address),
+          ),
+        );
       } catch (error) {
         // we cannot ask user to do prompt in test environment
         if (process.env.NODE_ENV !== 'test') {
diff --git a/packages/cli/src/commands/init.ts b/packages/cli/src/commands/init.ts
@@ -11,6 +11,7 @@ import { DEFAULT_IPFS_URL } from '../command-helpers/ipfs.js';
 import { initNetworksConfig } from '../command-helpers/network.js';
 import { chooseNodeUrl } from '../command-helpers/node.js';
 import { PromptManager } from '../command-helpers/prompt-manager.js';
+import { retryWithPrompt } from '../command-helpers/retry.js';
 import { generateScaffold, writeScaffold } from '../command-helpers/scaffold.js';
 import { sortWithPriority } from '../command-helpers/sort.js';
 import { withSpinner } from '../command-helpers/spinner.js';
@@ -361,26 +362,6 @@ async function processFromExampleInitForm(
   }
 }
 
-async function retryWithPrompt<T>(func: () => Promise<T>): Promise<T | undefined> {
-  for (;;) {
-    try {
-      return await func();
-    } catch (_) {
-      const { retry } = await prompt.ask({
-        type: 'confirm',
-        name: 'retry',
-        message: 'Do you want to retry?',
-        initial: true,
-      });
-
-      if (!retry) {
-        break;
-      }
-    }
-  }
-  return undefined;
-}
-
 async function processInitForm(
   this: InitCommand,
   {
@@ -493,6 +474,18 @@ async function processInitForm(
       result: value => {
         initDebugger.extend('processInitForm')('networkId: %O', value);
         network = networks.find(n => n.id === value)!;
+        promptManager.setOptions('protocol', {
+          choices: [
+            {
+              message: 'Smart contract',
+              name: network.graphNode?.protocol ?? '',
+              value: 'contract',
+            },
+            { message: 'Substreams', name: 'substreams', value: 'substreams' },
+            { message: 'Subgraph', name: 'subgraph', value: 'subgraph' },
+          ].filter(({ name }) => name),
+        });
+
         return value;
       },
     });
@@ -502,16 +495,15 @@ async function processInitForm(
       name: 'protocol',
       message: 'Source',
       choices: [
-        { message: 'Smart contract', name: network.graphNode?.protocol ?? '', value: 'contract' },
         { message: 'Substreams', name: 'substreams', value: 'substreams' },
         { message: 'Subgraph', name: 'subgraph', value: 'subgraph' },
       ].filter(({ name }) => name),
       validate: name => {
         if (name === 'arweave') {
-          return 'Arweave only supported via substreams';
+          return 'Arweave are only supported via substreams';
         }
         if (name === 'cosmos') {
-          return 'Cosmos chains only supported via substreams';
+          return 'Cosmos chains are only supported via substreams';
         }
         return true;
       },
@@ -587,22 +579,37 @@ async function processInitForm(
         // If ABI is not provided, try to fetch it from Etherscan API
         if (protocolInstance.hasABIs() && !initAbi) {
           abiFromApi = await retryWithPrompt(() =>
-            contractService.getABI(protocolInstance.getABI(), network.id, address),
+            withSpinner(
+              'Fetching ABI from contract API...',
+              'Failed to fetch ABI',
+              'Warning fetching ABI',
+              () => contractService.getABI(protocolInstance.getABI(), network.id, address),
+            ),
           );
           initDebugger.extend('processInitForm')("abiFromEtherscan len: '%s'", abiFromApi?.name);
         }
         // If startBlock is not provided, try to fetch it from Etherscan API
         if (!initStartBlock) {
           startBlock = await retryWithPrompt(() =>
-            contractService.getStartBlock(network.id, address),
+            withSpinner(
+              'Fetching start block from contract API...',
+              'Failed to fetch start block',
+              'Warning fetching start block',
+              () => contractService.getStartBlock(network.id, address),
+            ),
           );
           initDebugger.extend('processInitForm')("startBlockFromEtherscan: '%s'", startBlock);
         }
 
         // If contract name is not provided, try to fetch it from Etherscan API
         if (!initContractName) {
           contractName = await retryWithPrompt(() =>
-            contractService.getContractName(network.id, address),
+            withSpinner(
+              'Fetching contract name from contract API...',
+              'Failed to fetch contract name',
+              'Warning fetching contract name',
+              () => contractService.getContractName(network.id, address),
+            ),
           );
           initDebugger.extend('processInitForm')("contractNameFromEtherscan: '%s'", contractName);
         }
