@graphprotocol/graph-cli 0.37.3 → 0.37.4

package/src/command-helpers/data-sources.ts

@@ -1,36 +0,0 @@
-import immutable from 'immutable';
-import { loadManifest } from '../migrations/util/load-manifest';
-import Protocol from '../protocols';
-
-// Loads manifest from file path and returns all:
-// - data sources
-// - templates
-// In a single list.
-export const fromFilePath = async (manifestPath: string) => {
-  const { dataSources = [], templates = [] } = await loadManifest(manifestPath);
-
-  return dataSources.concat(templates);
-};
-
-const extractDataSourceByType = (
-  manifest: immutable.Map<any, any>,
-  dataSourceType: string,
-  protocol: Protocol,
-) =>
-  manifest
-    .get(dataSourceType, immutable.List())
-    .reduce(
-      (dataSources: any[], dataSource: any, dataSourceIndex: number) =>
-        protocol.isValidKindName(dataSource.get('kind'))
-          ? dataSources.push(immutable.Map({ path: [dataSourceType, dataSourceIndex], dataSource }))
-          : dataSources,
-      immutable.List(),
-    );
-
-// Extracts data sources and templates from a immutable manifest data structure
-export const fromManifest = (manifest: immutable.Map<any, any>, protocol: Protocol) => {
-  const dataSources = extractDataSourceByType(manifest, 'dataSources', protocol);
-  const templates = extractDataSourceByType(manifest, 'templates', protocol);
-
-  return dataSources.concat(templates);
-};

package/src/command-helpers/fs.ts

@@ -1,5 +0,0 @@
-import path from 'path';
-
-const displayPath = (p: string) => path.relative(process.cwd(), p);
-
-export { displayPath };

package/src/command-helpers/gluegun.ts

@@ -1,52 +0,0 @@
-// Workaround for https://github.com/infinitered/gluegun/pull/464.
-//
-// There is currently no way in Gluegun to define command-line options
-// that take no arguments (like `--watch`). As a consequence, boolean
-// options like `--watch` will consume the immediately following argument,
-// leading to confusing behavior.
-//
-// E.g. `graph deploy --watch subgraph/name
-//
-// Will result in
-// ```
-// toolbox.parameters.options === { watch: 'subgraph/name' }
-// toolbox.parameters.first === undefined
-// toolbox.parameters.array === []
-// ```
-// where what we really want is
-// ```
-// toolbox.parameters.options === { watch: true }
-// toolbox.parameters.first = 'subgraph/name'
-// toolbox.parameters.array = ['subgraph/name']
-// ```
-//
-// The `fixParameters` function checks if any of the provided boolean
-// options has a string value; if so, it pushes it to the front of the
-// parameters array and returns the result of that.
-
-import { GluegunParameters } from 'gluegun';
-
-export const fixParameters = (
-  parameters: GluegunParameters,
-  booleanOptions: Record<string, string>,
-) => {
-  const unexpectedStringOptions = Object.keys(booleanOptions)
-    .filter(key => typeof booleanOptions[key] === 'string')
-    .map(key => ({ key, value: booleanOptions[key] }));
-
-  const optionNames = unexpectedStringOptions
-    .map(({ key }) => `--` + key.replace(/([A-Z])/, '-$1').toLowerCase())
-    .join(', ');
-
-  if (unexpectedStringOptions.length > 1) {
-    throw new Error(
-      `Unexpected value provided for one or more of ${optionNames}. See --help for more information.`,
-    );
-  } else if (unexpectedStringOptions.length == 1) {
-    const params = parameters.array;
-    params!.unshift(unexpectedStringOptions[0].value);
-    return params!;
-  } else {
-    return parameters.array!;
-  }
-};

package/src/command-helpers/ipfs-http-client.d.ts

@@ -1 +0,0 @@
-declare module 'ipfs-http-client';

package/src/command-helpers/ipfs.ts

@@ -1,3 +0,0 @@
-const DEFAULT_IPFS_URL = 'https://api.thegraph.com/ipfs/' as const;
-
-export { DEFAULT_IPFS_URL };

package/src/command-helpers/jsonrpc.ts

@@ -1,22 +0,0 @@
-import { print } from 'gluegun';
-import jayson from 'jayson';
-
-export function createJsonRpcClient(url: URL): jayson.Client | null {
-  const params = {
-    host: url.hostname,
-    port: url.port,
-    path: url.pathname,
-    // username may be empty
-    auth: url.password ? `${url.username}:${url.password}` : undefined,
-  };
-
-  if (url.protocol === 'https:') {
-    return jayson.Client.https(params);
-  }
-  if (url.protocol === 'http:') {
-    return jayson.Client.http(params);
-  }
-  print.error(`Unsupported protocol: ${url.protocol.substring(0, url.protocol.length - 1)}`);
-  print.error('The Graph Node URL must be of the following format: http(s)://host[:port]/[path]');
-  return null;
-}

package/src/command-helpers/network.test.ts

@@ -1,85 +0,0 @@
-import path from 'path';
-import * as toolbox from 'gluegun';
-import yaml from 'yaml';
-import { initNetworksConfig, updateSubgraphNetwork } from './network';
-
-const SUBGRAPH_PATH_BASE = path.join(
-  __dirname,
-  '..',
-  '..',
-  '..',
-  '..',
-  'examples',
-  'example-subgraph',
-);
-
-describe('initNetworksConfig', () => {
-  beforeAll(async () => {
-    await initNetworksConfig(toolbox, SUBGRAPH_PATH_BASE, 'address');
-  });
-  afterAll(async () => {
-    toolbox.filesystem.remove(`${SUBGRAPH_PATH_BASE}/networks.json`);
-  });
-
-  test('generates networks.json from subgraph.yaml', () => {
-    expect(toolbox.filesystem.exists(`${SUBGRAPH_PATH_BASE}/networks.json`)).toBe('file');
-  });
-
-  test('Populates the networks.json file with the data from subgraph.yaml', async () => {
-    const networksStr = toolbox.filesystem.read(`${SUBGRAPH_PATH_BASE}/networks.json`);
-    const networks = JSON.parse(networksStr!);
-
-    const expected = {
-      mainnet: {
-        ExampleSubgraph: { address: '0x22843e74c59580b3eaf6c233fa67d8b7c561a835' },
-      },
-    };
-
-    expect(networks).toStrictEqual(expected);
-  });
-});
-
-describe('updateSubgraphNetwork', () => {
-  beforeAll(async () => {
-    const content = {
-      optimism: {
-        ExampleSubgraph: { address: '0x12345...' },
-      },
-    };
-
-    toolbox.filesystem.write(`${SUBGRAPH_PATH_BASE}/networks.json`, content);
-    toolbox.filesystem.copy(
-      `${SUBGRAPH_PATH_BASE}/subgraph.yaml`,
-      `${SUBGRAPH_PATH_BASE}/subgraph_copy.yaml`,
-    );
-  });
-
-  afterAll(async () => {
-    toolbox.filesystem.remove(`${SUBGRAPH_PATH_BASE}/networks.json`);
-    toolbox.filesystem.remove(`${SUBGRAPH_PATH_BASE}/subgraph_copy.yaml`);
-  });
-
-  test('Updates subgraph.yaml', async () => {
-    const manifest = `${SUBGRAPH_PATH_BASE}/subgraph_copy.yaml`;
-    const networksFie = `${SUBGRAPH_PATH_BASE}/networks.json`;
-    let subgraph = toolbox.filesystem.read(manifest);
-    let subgraphObj = yaml.parse(subgraph!);
-
-    let network = subgraphObj.dataSources[0].network;
-    let address = subgraphObj.dataSources[0].source.address;
-
-    expect(network).toBe('mainnet');
-    expect(address).toBe('0x22843e74c59580b3eaf6c233fa67d8b7c561a835');
-
-    await updateSubgraphNetwork(toolbox, manifest, 'optimism', networksFie, 'address');
-
-    subgraph = toolbox.filesystem.read(manifest);
-    subgraphObj = yaml.parse(subgraph!);
-
-    network = subgraphObj.dataSources[0].network;
-    address = subgraphObj.dataSources[0].source.address;
-
-    expect(network).toBe('optimism');
-    expect(address).toBe('0x12345...');
-  });
-});

package/src/command-helpers/network.ts

@@ -1,133 +0,0 @@
-import path from 'path';
-import { GluegunFilesystem, GluegunPatching } from 'gluegun';
-import yaml from 'yaml';
-import { step, withSpinner } from './spinner';
-
-export const updateSubgraphNetwork = async (
-  toolbox: { filesystem: GluegunFilesystem; patching: GluegunPatching },
-  manifest: any,
-  network: string,
-  networksFile: string,
-  identifierName: string,
-) =>
-  await withSpinner(
-    `Update sources network`,
-    `Failed to update sources network`,
-    `Warnings while updating sources network`,
-    async spinner => {
-      step(spinner, `Reading networks config`);
-      const allNetworks = await toolbox.filesystem.read(networksFile, 'json');
-      const networkConfig = allNetworks[network];
-
-      // Exit if the network passed with --network does not exits in networks.json
-      if (!networkConfig) {
-        throw new Error(`Network '${network}' was not found in '${networksFile}'`);
-      }
-
-      await toolbox.patching.update(manifest, content => {
-        const subgraph = yaml.parse(content);
-        const networkSources = Object.keys(networkConfig);
-        const subgraphSources = subgraph.dataSources.map((value: any) => value.name);
-
-        // Update the dataSources network config
-        subgraph.dataSources = subgraph.dataSources.map((source: any) => {
-          if (!networkSources.includes(source.name)) {
-            throw new Error(
-              `'${source.name}' was not found in the '${network}' configuration, please update!`,
-            );
-          }
-
-          if (hasChanges(identifierName, network, networkConfig[source.name], source)) {
-            step(spinner, `Update '${source.name}' network configuration`);
-            source.network = network;
-            source.source = source.source.abi ? { abi: source.source.abi } : {};
-            Object.assign(source.source, networkConfig[source.name]);
-          } else {
-            step(spinner, `Skip '${source.name}': No changes to network configuration`);
-          }
-
-          return source;
-        });
-
-        // All data sources shoud be on the same network,
-        // so we have to update the network of all templates too.
-        subgraph.templates &&= subgraph.templates.map((template: any) => ({
-          ...template,
-          network,
-        }));
-
-        const unsusedSources = networkSources.filter(x => !subgraphSources.includes(x));
-
-        unsusedSources.forEach(source => {
-          step(spinner, `dataSource '${source}' from '${networksFile}' not found in ${manifest}`);
-        });
-
-        const yaml_doc = new yaml.Document();
-        yaml_doc.contents = subgraph;
-        return yaml_doc.toString();
-      });
-    },
-  );
-
-export const initNetworksConfig = async (
-  toolbox: { filesystem: GluegunFilesystem },
-  directory: string,
-  identifierName: string,
-) =>
-  await withSpinner(
-    `Initialize networks config`,
-    `Failed to initialize networks config`,
-    `Warnings while initializing networks config`,
-    async () => {
-      const subgraphStr = toolbox.filesystem.read(path.join(directory, 'subgraph.yaml'));
-      const subgraph = yaml.parse(subgraphStr!);
-
-      const networks = subgraph.dataSources.reduce(
-        (acc: any, source: any) =>
-          Object.assign(acc, {
-            [source.network]: {
-              [source.name]: {
-                [identifierName]: source.source.address,
-                startBlock: source.source.startBlock,
-              },
-            },
-          }),
-        {},
-      );
-
-      toolbox.filesystem.write(`${directory}/networks.json`, networks);
-
-      return true;
-    },
-  );
-
-// Checks if any network attribute has been changed
-function hasChanges(identifierName: string, network: string, networkConfig: any, dataSource: any) {
-  const networkChanged = dataSource.network !== network;
-
-  // Return directly if the network is different
-  if (networkChanged) return networkChanged;
-
-  const addressChanged = networkConfig[identifierName] !== dataSource.source[identifierName];
-
-  const startBlockChanged = networkConfig.startBlock !== dataSource.source.startBlock;
-
-  return networkChanged || addressChanged || startBlockChanged;
-}
-
-export const updateNetworksFile = async (
-  toolbox: { patching: GluegunPatching },
-  network: string,
-  dataSource: any,
-  address: string,
-  networksFile: string,
-) => {
-  await toolbox.patching.update(networksFile, config => {
-    if (Object.keys(config).includes(network)) {
-      Object.assign(config[network], { [dataSource]: { address } });
-    } else {
-      Object.assign(config, { [network]: { [dataSource]: { address } } });
-    }
-    return config;
-  });
-};

package/src/command-helpers/node.ts

@@ -1,46 +0,0 @@
-import { URL } from 'url';
-import { print } from 'gluegun';
-
-const SUBGRAPH_STUDIO_URL = 'https://api.studio.thegraph.com/deploy/';
-const HOSTED_SERVICE_URL = 'https://api.thegraph.com/deploy/';
-
-export const validateNodeUrl = (node: string) => new URL(node);
-
-export const normalizeNodeUrl = (node: string) => new URL(node).toString();
-
-export function chooseNodeUrl({
-  product,
-  studio,
-  node,
-  allowSimpleName,
-}: {
-  product: string;
-  studio: string;
-  node?: string;
-  allowSimpleName?: boolean;
-}) {
-  if (node) {
-    try {
-      validateNodeUrl(node);
-    } catch (e) {
-      print.error(`Graph node "${node}" is invalid: ${e.message}`);
-      process.exit(1);
-    }
-  } else {
-    if (studio) {
-      product = 'subgraph-studio';
-    }
-    switch (product) {
-      case 'subgraph-studio':
-        node = SUBGRAPH_STUDIO_URL;
-        break;
-      case 'hosted-service':
-        node = HOSTED_SERVICE_URL;
-        break;
-    }
-  }
-  if (node?.match(/studio/) || product === 'subgraph-studio') {
-    allowSimpleName = true;
-  }
-  return { node, allowSimpleName };
-}

package/src/command-helpers/scaffold.ts

@@ -1,174 +0,0 @@
-import path from 'path';
-import fs from 'fs-extra';
-import { strings } from 'gluegun';
-import { Map } from 'immutable';
-import prettier from 'prettier';
-import yaml from 'yaml';
-import Protocol from '../protocols';
-import ABI from '../protocols/ethereum/abi';
-import Scaffold from '../scaffold';
-import { generateEventIndexingHandlers } from '../scaffold/mapping';
-import { abiEvents, generateEventType } from '../scaffold/schema';
-import { generateTestsFiles } from '../scaffold/tests';
-import { Spinner, step } from './spinner';
-
-export const generateDataSource = async (
-  protocol: Protocol,
-  contractName: string,
-  network: string,
-  contractAddress: string,
-  abi: ABI,
-) => {
-  const protocolManifest = protocol.getManifestScaffold();
-
-  return Map.of(
-    'kind',
-    protocol.name,
-    'name',
-    contractName,
-    'network',
-    network,
-    'source',
-    yaml.parse(
-      prettier.format(protocolManifest.source({ contract: contractAddress, contractName }), {
-        parser: 'yaml',
-      }),
-    ),
-    'mapping',
-    yaml.parse(
-      prettier.format(protocolManifest.mapping({ abi, contractName }), {
-        parser: 'yaml',
-      }),
-    ),
-  ).asMutable();
-};
-
-export const generateScaffold = async (
-  {
-    protocolInstance,
-    abi,
-    contract,
-    network,
-    subgraphName,
-    indexEvents,
-    contractName = 'Contract',
-    node,
-  }: {
-    protocolInstance: Protocol;
-    abi: ABI;
-    contract: string;
-    network: string;
-    subgraphName: string;
-    indexEvents: boolean;
-    contractName?: string;
-    node: string;
-  },
-  spinner: Spinner,
-) => {
-  step(spinner, 'Generate subgraph');
-
-  const scaffold = new Scaffold({
-    protocol: protocolInstance,
-    abi,
-    indexEvents,
-    contract,
-    network,
-    contractName,
-    subgraphName,
-    node,
-  });
-
-  return scaffold.generate();
-};
-
-const writeScaffoldDirectory = async (scaffold: any, directory: string, spinner: Spinner) => {
-  // Create directory itself
-  await fs.mkdirs(directory);
-
-  const promises = Object.keys(scaffold).map(async basename => {
-    const content = scaffold[basename];
-    const filename = path.join(directory, basename);
-
-    // Write file or recurse into subdirectory
-    if (typeof content === 'string') {
-      await fs.writeFile(filename, content, 'utf-8');
-    } else if (content == null) {
-      return; // continue loop
-    } else {
-      writeScaffoldDirectory(content, path.join(directory, basename), spinner);
-    }
-  });
-
-  await Promise.all(promises);
-};
-
-export const writeScaffold = async (scaffold: any, directory: string, spinner: Spinner) => {
-  step(spinner, `Write subgraph to directory`);
-  await writeScaffoldDirectory(scaffold, directory, spinner);
-};
-
-export const writeABI = async (abi: ABI, contractName: string) => {
-  const data = prettier.format(JSON.stringify(abi.data), {
-    parser: 'json',
-  });
-
-  await fs.writeFile(`./abis/${contractName}.json`, data, 'utf-8');
-};
-
-export const writeSchema = async (
-  abi: ABI,
-  protocol: Protocol,
-  schemaPath: string,
-  entities: any,
-) => {
-  const events = protocol.hasEvents()
-    ? abiEvents(abi)
-        .filter(event => !entities.includes(event.get('name')))
-        .toJS()
-    : [];
-
-  const data = prettier.format(
-    events.map(event => generateEventType(event, protocol.name)).join('\n\n'),
-    {
-      parser: 'graphql',
-    },
-  );
-
-  await fs.appendFile(schemaPath, data, { encoding: 'utf-8' });
-};
-
-export const writeMapping = async (
-  abi: ABI,
-  protocol: Protocol,
-  contractName: string,
-  entities: any,
-) => {
-  const events = protocol.hasEvents()
-    ? abiEvents(abi)
-        .filter(event => !entities.includes(event.get('name')))
-        .toJS()
-    : [];
-
-  const mapping = prettier.format(generateEventIndexingHandlers(events, contractName), {
-    parser: 'typescript',
-    semi: false,
-  });
-
-  await fs.writeFile(`./src/${strings.kebabCase(contractName)}.ts`, mapping, 'utf-8');
-};
-
-export const writeTestsFiles = async (abi: ABI, protocol: Protocol, contractName: string) => {
-  const hasEvents = protocol.hasEvents();
-  const events = hasEvents ? abiEvents(abi).toJS() : [];
-
-  if (events.length > 0) {
-    // If a contract is added to a subgraph that has no tests folder
-    await fs.ensureDir('./tests/');
-
-    const testsFiles = generateTestsFiles(contractName, events, true);
-
-    for (const [fileName, content] of Object.entries(testsFiles)) {
-      await fs.writeFile(`./tests/${fileName}`, content, 'utf-8');
-    }
-  }
-};

package/src/command-helpers/spinner.ts

@@ -1,60 +0,0 @@
-import * as toolbox from 'gluegun';
-
-export type Spinner = ReturnType<toolbox.GluegunPrint['spin']>;
-
-export const step = (spinner: Spinner, subject: string, text?: string) => {
-  if (text) {
-    spinner.stopAndPersist({
-      text: toolbox.print.colors.muted(`${subject} ${text}`),
-    });
-  } else {
-    spinner.stopAndPersist({ text: toolbox.print.colors.muted(subject) });
-  }
-  spinner.start();
-  return spinner;
-};
-
-// Executes the function `f` in a command-line spinner, using the
-// provided captions for in-progress, error and failed messages.
-//
-// If `f` throws an error, the spinner stops with the failure message
-//   and rethrows the error.
-// If `f` returns an object with a `warning` and a `result` key, the
-//   spinner stops with the warning message and returns the `result` value.
-// Otherwise the spinner prints the in-progress message with a check mark
-//   and simply returns the value returned by `f`.
-export const withSpinner = async (
-  text: string,
-  errorText: string,
-  warningText: string,
-  f: (spinner: Spinner) => Promise<any> | any, // TODO: type result
-) => {
-  const spinner = toolbox.print.spin(text);
-  try {
-    const result = await f(spinner);
-    if (typeof result === 'object') {
-      const hasError = Object.keys(result).includes('error');
-      const hasWarning = Object.keys(result).includes('warning');
-      const hasResult = Object.keys(result).includes('result');
-
-      if (hasError) {
-        spinner.fail(`${errorText}: ${result.error}`);
-        return hasResult ? result.result : result;
-      }
-      if (hasWarning && hasResult) {
-        if (result.warning !== null) {
-          spinner.warn(`${warningText}: ${result.warning}`);
-        }
-        spinner.succeed(text);
-        return result.result;
-      }
-      spinner.succeed(text);
-      return result;
-    }
-    spinner.succeed(text);
-    return result;
-  } catch (e) {
-    spinner.fail(`${errorText}: ${e.message}`);
-    throw e;
-  }
-};