@graphprotocol/graph-cli 0.37.3 → 0.37.4-alpha-20230117095424-b5750b1

package/src/commands/local.ts

@@ -1,539 +0,0 @@
-import { ChildProcess, spawn } from 'child_process';
-import http from 'http';
-import net from 'net';
-import path from 'path';
-import chalk from 'chalk';
-import compose from 'docker-compose';
-import { GluegunToolbox } from 'gluegun';
-import stripAnsi from 'strip-ansi';
-import tmp from 'tmp-promise';
-import { fixParameters } from '../command-helpers/gluegun';
-import { step, withSpinner } from '../command-helpers/spinner';
-
-// Clean up temporary files even when an uncaught exception occurs
-tmp.setGracefulCleanup();
-
-const HELP = `
-${chalk.bold('graph local')} [options] ${chalk.bold('<local-command>')}
-
-Options:
-
-  -h, --help                    Show usage information
-      --node-logs               Print the Graph Node logs (optional)
-      --ethereum-logs           Print the Ethereum logs (optional)
-      --compose-file <file>     Custom Docker Compose file for additional services (optional)
-      --node-image <image>      Custom Graph Node image to test against (default: graphprotocol/graph-node:latest)
-      --standalone-node <cmd>   Use a standalone Graph Node outside Docker Compose (optional)
-      --standalone-node-args    Custom arguments to be passed to the standalone Graph Node (optional)
-      --skip-wait-for-ipfs      Don't wait for IPFS to be up at localhost:15001 (optional)
-      --skip-wait-for-ethereum  Don't wait for Ethereum to be up at localhost:18545 (optional)
-      --skip-wait-for-postgres  Don't wait for Postgres to be up at localhost:15432 (optional)
-      --timeout                 Time to wait for service containers. (optional, defaults to 120000 milliseconds)
-`;
-
-export interface LocalOptions {
-  help?: boolean;
-  nodeLogs?: boolean;
-  ethereumLogs?: boolean;
-  composeFile?: string;
-  nodeImage?: string;
-  standaloneNode?: string;
-  standaloneNodeArgs?: string;
-  skipWaitForIpfs?: boolean;
-  skipWaitForEthereum?: boolean;
-  skipWaitForPostgres?: boolean;
-  timeout?: number;
-}
-
-export default {
-  description: 'Runs local tests against a Graph Node environment (using Ganache by default)',
-  run: async (toolbox: GluegunToolbox) => {
-    // Obtain tools
-    const { filesystem, print } = toolbox;
-
-    // Parse CLI parameters
-    let {
-      composeFile,
-      ethereumLogs,
-      h,
-      help,
-      nodeImage,
-      nodeLogs,
-      skipWaitForEthereum,
-      skipWaitForIpfs,
-      skipWaitForPostgres,
-      standaloneNode,
-      standaloneNodeArgs,
-      timeout,
-    } = toolbox.parameters.options;
-
-    // Support both short and long option variants
-    help ||= h;
-
-    // Extract test command
-    const params = fixParameters(toolbox.parameters, {
-      ethereumLogs,
-      h,
-      help,
-      nodeLogs,
-      skipWaitForEthereum,
-      skipWaitForIpfs,
-      skipWaitForPostgres,
-    });
-
-    // Show help text if requested
-    if (help) {
-      print.info(HELP);
-      return;
-    }
-
-    if (params.length == 0) {
-      print.error(`Test command not provided as the last argument`);
-      process.exitCode = 1;
-      return;
-    }
-
-    const testCommand = params[0];
-
-    // Obtain the Docker Compose file for services that the tests run against
-    composeFile ||= path.join(
-      __dirname,
-      '..',
-      '..',
-      'resources',
-      'test',
-      standaloneNode ? 'docker-compose-standalone-node.yml' : 'docker-compose.yml',
-    );
-
-    // parse timeout. Defaults to 120 seconds
-    timeout = Math.abs(parseInt(timeout)) || 120_000;
-
-    if (!filesystem.exists(composeFile)) {
-      print.error(`Docker Compose file \`${composeFile}\` not found`);
-      process.exitCode = 1;
-      return;
-    }
-
-    // Create temporary directory to operate in
-    const { path: tempdir } = await tmp.dir({ prefix: 'graph-test', unsafeCleanup: true });
-    try {
-      await configureTestEnvironment(toolbox, tempdir, composeFile, nodeImage);
-    } catch (e) {
-      process.exitCode = 1;
-      return;
-    }
-
-    // Bring up test environment
-    try {
-      await startTestEnvironment(tempdir);
-    } catch (e) {
-      print.error(e);
-      process.exitCode = 1;
-      return;
-    }
-
-    // Wait for test environment to come up
-    try {
-      await waitForTestEnvironment({
-        skipWaitForEthereum,
-        skipWaitForIpfs,
-        skipWaitForPostgres,
-        timeout,
-      });
-    } catch (e) {
-      await stopTestEnvironment(tempdir);
-      process.exitCode = 1;
-      return;
-    }
-
-    // Bring up Graph Node separately, if a standalone node is used
-    let nodeProcess;
-    const nodeOutputChunks: Buffer[] = [];
-    if (standaloneNode) {
-      try {
-        nodeProcess = await startGraphNode(standaloneNode, standaloneNodeArgs, nodeOutputChunks);
-      } catch (e) {
-        toolbox.print.error('');
-        toolbox.print.error('  Graph Node');
-        toolbox.print.error('  ----------');
-        toolbox.print.error(indent('  ', Buffer.concat(nodeOutputChunks).toString('utf-8')));
-        toolbox.print.error('');
-        await stopTestEnvironment(tempdir);
-        process.exitCode = 1;
-        return;
-      }
-    }
-
-    // Wait for Graph Node to come up
-    try {
-      await waitForGraphNode(timeout);
-    } catch (e) {
-      toolbox.print.error('');
-      toolbox.print.error('  Graph Node');
-      toolbox.print.error('  ----------');
-      toolbox.print.error(
-        indent('  ', await collectGraphNodeLogs(tempdir, standaloneNode, nodeOutputChunks)),
-      );
-      toolbox.print.error('');
-      await stopTestEnvironment(tempdir);
-      process.exitCode = 1;
-      return;
-    }
-
-    // Run tests
-    const result = await runTests(testCommand);
-
-    // Bring down Graph Node, if a standalone node is used
-    if (nodeProcess) {
-      try {
-        await stopGraphNode(nodeProcess);
-      } catch (e) {
-        // do nothing (the spinner already logs the problem)
-      }
-    }
-
-    if (result.exitCode == 0) {
-      toolbox.print.success('✔ Tests passed');
-    } else {
-      toolbox.print.error('✖ Tests failed');
-    }
-
-    // Capture logs
-    nodeLogs =
-      nodeLogs || result.exitCode !== 0
-        ? await collectGraphNodeLogs(tempdir, standaloneNode, nodeOutputChunks)
-        : undefined;
-    ethereumLogs = ethereumLogs ? await collectEthereumLogs(tempdir) : undefined;
-
-    // Bring down the test environment
-    try {
-      await stopTestEnvironment(tempdir);
-    } catch (e) {
-      // do nothing (the spinner already logs the problem)
-    }
-
-    if (nodeLogs) {
-      toolbox.print.info('');
-      toolbox.print.info('  Graph node');
-      toolbox.print.info('  ----------');
-      toolbox.print.info('');
-      toolbox.print.info(indent('  ', nodeLogs));
-    }
-
-    if (ethereumLogs) {
-      toolbox.print.info('');
-      toolbox.print.info('  Ethereum');
-      toolbox.print.info('  --------');
-      toolbox.print.info('');
-      toolbox.print.info(indent('  ', ethereumLogs));
-    }
-
-    // Always print the test output
-    toolbox.print.info('');
-    toolbox.print.info('  Output');
-    toolbox.print.info('  ------');
-    toolbox.print.info('');
-    toolbox.print.info(indent('  ', result.output));
-
-    // Propagate the exit code from the test run
-    process.exitCode = result.exitCode;
-  },
-};
-
-/**
- * Indents all lines of a string
- */
-const indent = (indentation: string, str: string) =>
-  str
-    .split('\n')
-    .map(s => `${indentation}${s}`)
-    // Remove whitespace from empty lines
-    .map(s => s.replace(/^\s+$/g, ''))
-    .join('\n');
-
-const configureTestEnvironment = async (
-  toolbox: GluegunToolbox,
-  tempdir: string,
-  composeFile: string,
-  nodeImage: string,
-) =>
-  await withSpinner(
-    `Configure test environment`,
-    `Failed to configure test environment`,
-    `Warnings configuring test environment`,
-    async () => {
-      // Temporary compose file
-      const tempComposeFile = path.join(tempdir, 'compose', 'docker-compose.yml');
-
-      // Copy the compose file to the temporary directory
-      toolbox.filesystem.copy(composeFile, tempComposeFile);
-
-      // Substitute the graph-node image with the custom one, if appropriate
-      if (nodeImage) {
-        await toolbox.patching.replace(
-          tempComposeFile,
-          'graphprotocol/graph-node:latest',
-          nodeImage,
-        );
-      }
-    },
-  );
-
-const waitFor = async (timeout: number, testFn: () => void) => {
-  const deadline = Date.now() + timeout;
-  let error: Error | undefined = undefined;
-  return new Promise((resolve, reject) => {
-    const check = async () => {
-      if (Date.now() > deadline) {
-        reject(error);
-      } else {
-        try {
-          const result = await testFn();
-          resolve(result);
-        } catch (e) {
-          error = e;
-          setTimeout(check, 500);
-        }
-      }
-    };
-
-    setTimeout(check, 0);
-  });
-};
-
-const startTestEnvironment = async (tempdir: string) =>
-  await withSpinner(
-    `Start test environment`,
-    `Failed to start test environment`,
-    `Warnings starting test environment`,
-    async _spinner => {
-      // Bring up the test environment
-      await compose.upAll({
-        cwd: path.join(tempdir, 'compose'),
-      });
-    },
-  );
-
-const waitForTestEnvironment = async ({
-  skipWaitForEthereum,
-  skipWaitForIpfs,
-  skipWaitForPostgres,
-  timeout,
-}: {
-  skipWaitForEthereum: boolean;
-  skipWaitForIpfs: boolean;
-  skipWaitForPostgres: boolean;
-  timeout: number;
-}) =>
-  await withSpinner(
-    `Wait for test environment`,
-    `Failed to wait for test environment`,
-    `Warnings waiting for test environment`,
-    async spinner => {
-      // Wait 10s for IPFS (if desired)
-      if (skipWaitForIpfs) {
-        step(spinner, 'Skip waiting for IPFS');
-      } else {
-        await waitFor(
-          timeout,
-          async () =>
-            new Promise((resolve, reject) => {
-              http
-                .get('http://localhost:15001/api/v0/version', () => {
-                  resolve();
-                })
-                .on('error', e => {
-                  reject(new Error(`Could not connect to IPFS: ${e}`));
-                });
-            }),
-        );
-        step(spinner, 'IPFS is up');
-      }
-
-      // Wait 10s for Ethereum (if desired)
-      if (skipWaitForEthereum) {
-        step(spinner, 'Skip waiting for Ethereum');
-      } else {
-        await waitFor(
-          timeout,
-          async () =>
-            new Promise((resolve, reject) => {
-              http
-                .get('http://localhost:18545', () => {
-                  resolve();
-                })
-                .on('error', e => {
-                  reject(new Error(`Could not connect to Ethereum: ${e}`));
-                });
-            }),
-        );
-        step(spinner, 'Ethereum is up');
-      }
-
-      // Wait 10s for Postgres (if desired)
-      if (skipWaitForPostgres) {
-        step(spinner, 'Skip waiting for Postgres');
-      } else {
-        await waitFor(
-          timeout,
-          async () =>
-            new Promise((resolve, reject) => {
-              try {
-                const socket = net.connect(15_432, 'localhost', () => resolve());
-                socket.on('error', e => reject(new Error(`Could not connect to Postgres: ${e}`)));
-                socket.end();
-              } catch (e) {
-                reject(new Error(`Could not connect to Postgres: ${e}`));
-              }
-            }),
-        );
-        step(spinner, 'Postgres is up');
-      }
-    },
-  );
-
-const stopTestEnvironment = async (tempdir: string) =>
-  await withSpinner(
-    `Stop test environment`,
-    `Failed to stop test environment`,
-    `Warnings stopping test environment`,
-    async () => {
-      // Our containers do not respond quickly to the SIGTERM which `down` tries before timing out
-      // and killing them, so speed things up by sending a SIGKILL right away.
-      try {
-        await compose.kill({ cwd: path.join(tempdir, 'compose') });
-      } catch (e) {
-        // Do nothing, we will just try to run 'down'
-        // to bring down the environment
-      }
-      await compose.down({ cwd: path.join(tempdir, 'compose') });
-    },
-  );
-
-const startGraphNode = async (
-  standaloneNode: string,
-  standaloneNodeArgs: string,
-  nodeOutputChunks: Buffer[],
-): Promise<ChildProcess> =>
-  await withSpinner(
-    `Start Graph node`,
-    `Failed to start Graph node`,
-    `Warnings starting Graph node`,
-    async spinner => {
-      const defaultArgs = [
-        '--ipfs',
-        'localhost:15001',
-        '--postgres-url',
-        'postgresql://graph:let-me-in@localhost:15432/graph',
-        '--ethereum-rpc',
-        'test:http://localhost:18545',
-        '--http-port',
-        '18000',
-        '--ws-port',
-        '18001',
-        '--admin-port',
-        '18020',
-        '--index-node-port',
-        '18030',
-        '--metrics-port',
-        '18040',
-      ];
-
-      const defaultEnv = {
-        GRAPH_LOG: 'debug',
-        GRAPH_MAX_API_VERSION: '0.0.5',
-      };
-
-      const args = standaloneNodeArgs ? standaloneNodeArgs.split(' ') : defaultArgs;
-      const env = { ...defaultEnv, ...process.env };
-
-      const nodeProcess = spawn(standaloneNode, args, {
-        cwd: process.cwd(),
-        env,
-      });
-
-      step(spinner, 'Graph node:', String(nodeProcess.spawnargs.join(' ')));
-
-      nodeProcess.stdout.on('data', data => nodeOutputChunks.push(Buffer.from(data)));
-      nodeProcess.stderr.on('data', data => nodeOutputChunks.push(Buffer.from(data)));
-      nodeProcess.on('error', e => {
-        nodeOutputChunks.push(Buffer.from(String(e), 'utf-8'));
-      });
-
-      // Return the node child process
-      return nodeProcess;
-    },
-  );
-
-const waitForGraphNode = async (timeout: number) =>
-  await withSpinner(
-    `Wait for Graph node`,
-    `Failed to wait for Graph node`,
-    `Warnings waiting for Graph node`,
-    async () => {
-      await waitFor(
-        timeout,
-        async () =>
-          new Promise<void>((resolve, reject) => {
-            http
-              .get('http://localhost:18000', { timeout }, () => resolve())
-              .on('error', e => reject(e));
-          }),
-      );
-    },
-  );
-
-const stopGraphNode = async (nodeProcess: ChildProcess) =>
-  await withSpinner(
-    `Stop Graph node`,
-    `Failed to stop Graph node`,
-    `Warnings stopping Graph node`,
-    async () => {
-      nodeProcess.kill(9);
-    },
-  );
-
-const collectGraphNodeLogs = async (
-  tempdir: string,
-  standaloneNode: string,
-  nodeOutputChunks: Buffer[],
-) => {
-  if (standaloneNode) {
-    // Pull the logs from the captured output
-    return stripAnsi(Buffer.concat(nodeOutputChunks).toString('utf-8'));
-  }
-  // Pull the logs from docker compose
-  const logs = await compose.logs('graph-node', {
-    follow: false,
-    cwd: path.join(tempdir, 'compose'),
-  });
-  return stripAnsi(logs.out.trim()).replace(/graph-node_1 {2}\| /g, '');
-};
-
-const collectEthereumLogs = async (tempdir: string) => {
-  const logs = await compose.logs('ethereum', {
-    follow: false,
-    cwd: path.join(tempdir, 'compose'),
-  });
-  return stripAnsi(logs.out.trim()).replace(/ethereum_1 {2}\| /g, '');
-};
-
-const runTests = async (testCommand: string) =>
-  await withSpinner(
-    `Run tests`,
-    `Failed to run tests`,
-    `Warnings running tests`,
-    async () =>
-      new Promise(resolve => {
-        const output: Buffer[] = [];
-        const testProcess = spawn(String(testCommand), { shell: true });
-        testProcess.stdout.on('data', data => output.push(Buffer.from(data)));
-        testProcess.stderr.on('data', data => output.push(Buffer.from(data)));
-        testProcess.on('close', code => {
-          resolve({
-            exitCode: code,
-            output: Buffer.concat(output).toString('utf-8'),
-          });
-        });
-      }),
-  );

package/src/commands/remove.ts

@@ -1,110 +0,0 @@
-import { URL } from 'url';
-import chalk from 'chalk';
-import { GluegunToolbox } from 'gluegun';
-import { identifyDeployKey as identifyAccessToken } from '../command-helpers/auth';
-import { createJsonRpcClient } from '../command-helpers/jsonrpc';
-import { validateNodeUrl } from '../command-helpers/node';
-
-const HELP = `
-${chalk.bold('graph remove')} ${chalk.dim('[options]')} ${chalk.bold('<subgraph-name>')}
-
-${chalk.dim('Options:')}
-
-      --access-token <token>    Graph access token
-  -h, --help                    Show usage information
-  -g, --node <url>              Graph node to create the subgraph in
-`;
-
-export interface RemoveOptions {
-  accessToken?: string;
-  help?: boolean;
-  node?: string;
-}
-
-export default {
-  description: 'Unregisters a subgraph name',
-  run: async (toolbox: GluegunToolbox) => {
-    // Obtain tools
-    const { print } = toolbox;
-
-    // Read CLI parameters
-    let { accessToken, g, h, help, node } = toolbox.parameters.options;
-    const subgraphName = toolbox.parameters.first;
-
-    // Support both long and short option variants
-    help ||= h;
-    node ||= g;
-
-    // Show help text if requested
-    if (help) {
-      print.info(HELP);
-      return;
-    }
-
-    // Validate the subgraph name
-    if (!subgraphName) {
-      print.error('No subgraph name provided');
-      print.info(HELP);
-      process.exitCode = 1;
-      return;
-    }
-
-    // Validate node
-    if (!node) {
-      print.error(`No Graph node provided`);
-      print.info(HELP);
-      process.exitCode = 1;
-      return;
-    }
-    try {
-      validateNodeUrl(node);
-    } catch (e) {
-      print.error(`Graph node "${node}" is invalid: ${e.message}`);
-      process.exitCode = 1;
-      return;
-    }
-
-    const requestUrl = new URL(node);
-    const client = createJsonRpcClient(requestUrl);
-
-    // Exit with an error code if the client couldn't be created
-    if (!client) {
-      process.exitCode = 1;
-      return;
-    }
-
-    // Use the access token, if one is set
-    accessToken = await identifyAccessToken(node, accessToken);
-    if (accessToken !== undefined && accessToken !== null) {
-      // @ts-expect-error options property seems to exist
-      client.options.headers = { Authorization: `Bearer ${accessToken}` };
-    }
-
-    const spinner = print.spin(`Creating subgraph in Graph node: ${requestUrl}`);
-    client.request(
-      'subgraph_remove',
-      { name: subgraphName },
-      (
-        // @ts-expect-error TODO: why are the arguments not typed?
-        requestError,
-        // @ts-expect-error TODO: why are the arguments not typed?
-        jsonRpcError,
-        // TODO: this argument is unused, but removing it from the commands/create.ts fails the basic-event-handlers tests.
-        //       I'll therefore leave it in here too until we figure out the weirdness
-        // @ts-expect-error TODO: why are the arguments not typed?
-        _res,
-      ) => {
-        if (jsonRpcError) {
-          spinner.fail(`Error removing the subgraph: ${jsonRpcError.message}`);
-          process.exitCode = 1;
-        } else if (requestError) {
-          spinner.fail(`HTTP error removing the subgraph: ${requestError.code}`);
-          process.exitCode = 1;
-        } else {
-          spinner.stop();
-          print.success(`Removed subgraph: ${subgraphName}`);
-        }
-      },
-    );
-  },
-};