@graphprotocol/graph-cli 0.38.0-alpha-20230131175746-0102e0f → 0.38.0

package/CHANGELOG.md

@@ -1,9 +1,13 @@
 # @graphprotocol/graph-cli
 
-## 0.38.0-alpha-20230131175746-0102e0f
+## 0.38.0
 
 ### Minor Changes
 
+- [#1049](https://github.com/graphprotocol/graph-tooling/pull/1049)
+  [`18cf83f`](https://github.com/graphprotocol/graph-tooling/commit/18cf83fe1ec703fdc74fa03f898e2ca8b7e5f1fd)
+  Thanks [@incrypto32](https://github.com/incrypto32)! - Add startBlock prompt
+
 - [#1053](https://github.com/graphprotocol/graph-tooling/pull/1053)
   [`bc82507`](https://github.com/graphprotocol/graph-tooling/commit/bc8250763799ae2871c5d5b67c279c673329bcbc)
   Thanks [@saihaj](https://github.com/saihaj)! - Remove arbitrum-rinkeby to add arbitrum-goerli

package/dist/bin.js

@@ -1,34 +1,6 @@
 #!/usr/bin/env node
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const oclif = __importStar(require("@oclif/core"));
-const flush_1 = __importDefault(require("@oclif/core/flush"));
-// @ts-expect-error Handle is a pure JS file
-const handle_1 = __importDefault(require("@oclif/core/handle"));
-oclif.run().then(flush_1.default).catch(handle_1.default);
+// run the CLI with the current process arguments
+const cli_1 = require("./cli");
+(0, cli_1.run)(process.argv);

package/dist/cli.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = void 0;
+const path_1 = __importDefault(require("path"));
+const gluegun_1 = require("gluegun");
+const run = async (argv) => {
+    let builder = (0, gluegun_1.build)().brand('graph').src(__dirname);
+    const pluginDirs = [];
+    await Promise.all(['npm root -g', 'npm root', 'yarn global dir'].map(async (cmd) => {
+        try {
+            const dir = await gluegun_1.system.run(cmd, { trim: true });
+            pluginDirs.push(dir);
+        }
+        catch (_) {
+            // noop
+        }
+    }));
+    // Inject potential plugin directories
+    builder = pluginDirs.reduce((cli, dir) => cli.plugin(path_1.default.join(dir, '@graphprotocol', 'indexer-cli', 'dist')), builder);
+    const cli = builder.help().version().defaultCommand().create();
+    return await cli.run(argv);
+};
+exports.run = run;

package/dist/command-helpers/scaffold.js

@@ -24,7 +24,7 @@ const generateDataSource = async (protocol, contractName, network, contractAddre
     }))).asMutable();
 };
 exports.generateDataSource = generateDataSource;
-const generateScaffold = async ({ protocolInstance, abi, contract, network, subgraphName, indexEvents, contractName = 'Contract', node, }, spinner) => {
+const generateScaffold = async ({ protocolInstance, abi, contract, network, subgraphName, indexEvents, contractName = 'Contract', startBlock, node, }, spinner) => {
     (0, spinner_1.step)(spinner, 'Generate subgraph');
     const scaffold = new scaffold_1.default({
         protocol: protocolInstance,
@@ -33,6 +33,7 @@ const generateScaffold = async ({ protocolInstance, abi, contract, network, subg
         contract,
         network,
         contractName,
+        startBlock,
         subgraphName,
         node,
     });

package/dist/commands/add.js

@@ -1,29 +1,187 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const core_1 = require("@oclif/core");
-class Add extends core_1.Command {
-    async run() {
-        const { flags } = await this.parse(Add);
-        this.log('running my command', { flags });
+const chalk_1 = __importDefault(require("chalk"));
+const immutable_1 = __importDefault(require("immutable"));
+const abi_1 = require("../command-helpers/abi");
+const DataSourcesExtractor = __importStar(require("../command-helpers/data-sources"));
+const gluegun_1 = require("../command-helpers/gluegun");
+const network_1 = require("../command-helpers/network");
+const scaffold_1 = require("../command-helpers/scaffold");
+const spinner_1 = require("../command-helpers/spinner");
+const protocols_1 = __importDefault(require("../protocols"));
+const abi_2 = __importDefault(require("../protocols/ethereum/abi"));
+const subgraph_1 = __importDefault(require("../subgraph"));
+const HELP = `
+${chalk_1.default.bold('graph add')} <address> [<subgraph-manifest default: "./subgraph.yaml">]
+
+${chalk_1.default.dim('Options:')}
+
+      --abi <path>              Path to the contract ABI (default: download from Etherscan)
+      --contract-name           Name of the contract (default: Contract)
+      --merge-entities          Whether to merge entities with the same name (default: false)
+      --network-file <path>     Networks config file path (default: "./networks.json")
+  -h, --help                    Show usage information
+`;
+exports.default = {
+    description: 'Adds a new datasource to a subgraph',
+    run: async (toolbox) => {
+        // Obtain tools
+        const { print, system } = toolbox;
+        // Read CLI parameters
+        let { abi, contractName, h, help, mergeEntities, networkFile } = toolbox.parameters.options;
+        contractName || (contractName = 'Contract');
+        try {
+            (0, gluegun_1.fixParameters)(toolbox.parameters, {
+                h,
+                help,
+                mergeEntities,
+            });
+        }
+        catch (e) {
+            print.error(e.message);
+            process.exitCode = 1;
+            return;
+        }
+        const address = toolbox.parameters.first || toolbox.parameters.array?.[0];
+        const manifestPath = toolbox.parameters.second || toolbox.parameters.array?.[1] || './subgraph.yaml';
+        // Show help text if requested
+        if (help || h) {
+            print.info(HELP);
+            return;
+        }
+        // Validate the address
+        if (!address) {
+            print.error('No contract address provided');
+            process.exitCode = 1;
+            return;
+        }
+        const dataSourcesAndTemplates = await DataSourcesExtractor.fromFilePath(manifestPath);
+        const protocol = protocols_1.default.fromDataSources(dataSourcesAndTemplates);
+        const manifest = await subgraph_1.default.load(manifestPath, { protocol });
+        const network = manifest.result.getIn(['dataSources', 0, 'network']);
+        const result = manifest.result.asMutable();
+        const entities = getEntities(manifest);
+        const contractNames = getContractNames(manifest);
+        if (contractNames.includes(contractName)) {
+            print.error(`Datasource or template with name ${contractName} already exists, please choose a different name`);
+            process.exitCode = 1;
+            return;
+        }
+        let ethabi = null;
+        if (abi) {
+            ethabi = abi_2.default.load(contractName, abi);
+        }
+        else if (network === 'poa-core') {
+            ethabi = await (0, abi_1.loadAbiFromBlockScout)(abi_2.default, network, address);
+        }
+        else {
+            ethabi = await (0, abi_1.loadAbiFromEtherscan)(abi_2.default, network, address);
+        }
+        const { collisionEntities, onlyCollisions, abiData } = updateEventNamesOnCollision(toolbox, ethabi, entities, contractName, mergeEntities);
+        ethabi.data = abiData;
+        await (0, scaffold_1.writeABI)(ethabi, contractName);
+        await (0, scaffold_1.writeSchema)(ethabi, protocol, result.getIn(['schema', 'file']), collisionEntities);
+        await (0, scaffold_1.writeMapping)(ethabi, protocol, contractName, collisionEntities);
+        await (0, scaffold_1.writeTestsFiles)(ethabi, protocol, contractName);
+        const dataSources = result.get('dataSources');
+        const dataSource = await (0, scaffold_1.generateDataSource)(protocol, contractName, network, address, ethabi);
+        // Handle the collisions edge case by copying another data source yaml data
+        if (mergeEntities && onlyCollisions) {
+            const firstDataSource = dataSources.get(0);
+            const source = dataSource.get('source');
+            const mapping = firstDataSource.get('mapping').asMutable();
+            // Save the address of the new data source
+            source.abi = firstDataSource.get('source').get('abi');
+            dataSource.set('mapping', mapping);
+            dataSource.set('source', source);
+        }
+        result.set('dataSources', dataSources.push(dataSource));
+        await subgraph_1.default.write(result, manifestPath);
+        // Update networks.json
+        const networksFile = networkFile || './networks.json';
+        await (0, network_1.updateNetworksFile)(toolbox, network, contractName, address, networksFile);
+        // Detect Yarn and/or NPM
+        const yarn = system.which('yarn');
+        const npm = system.which('npm');
+        if (!yarn && !npm) {
+            print.error(`Neither Yarn nor NPM were found on your system. Please install one of them.`);
+            process.exitCode = 1;
+            return;
+        }
+        await (0, spinner_1.withSpinner)('Running codegen', 'Failed to run codegen', 'Warning during codegen', async () => {
+            await system.run(yarn ? 'yarn codegen' : 'npm run codegen');
+        });
+    },
+};
+const getEntities = (manifest) => {
+    const dataSources = manifest.result.get('dataSources', immutable_1.default.List());
+    const templates = manifest.result.get('templates', immutable_1.default.List());
+    return dataSources
+        .concat(templates)
+        .map((dataSource) => dataSource.getIn(['mapping', 'entities']))
+        .flatten();
+};
+const getContractNames = (manifest) => {
+    const dataSources = manifest.result.get('dataSources', immutable_1.default.List());
+    const templates = manifest.result.get('templates', immutable_1.default.List());
+    return dataSources.concat(templates).map((dataSource) => dataSource.get('name'));
+};
+const updateEventNamesOnCollision = (toolbox, ethabi, entities, contractName, mergeEntities) => {
+    let abiData = ethabi.data;
+    const { print } = toolbox;
+    const collisionEntities = [];
+    let onlyCollisions = true;
+    for (let i = 0; i < abiData.size; i++) {
+        const dataRow = abiData.get(i).asMutable();
+        if (dataRow.get('type') === 'event') {
+            if (entities.includes(dataRow.get('name'))) {
+                if (entities.includes(`${contractName}${dataRow.get('name')}`)) {
+                    print.error(`Contract name ('${contractName}')
+            + event name ('${dataRow.get('name')}') entity already exists.`);
+                    process.exitCode = 1;
+                    break;
+                }
+                if (mergeEntities) {
+                    collisionEntities.push(dataRow.get('name'));
+                    abiData = abiData.asImmutable().delete(i); // needs to be immutable when deleting, yes you read that right - https://github.com/immutable-js/immutable-js/issues/1901
+                    i--; // deletion also shifts values to the left
+                    continue;
+                }
+                else {
+                    dataRow.set('name', `${contractName}${dataRow.get('name')}`);
+                }
+            }
+            else {
+                onlyCollisions = false;
+            }
+        }
+        abiData = abiData.asMutable().set(i, dataRow);
     }
-}
-exports.default = Add;
-Add.description = 'Adds a new datasource to a subgraph.';
-Add.flags = {
-    abi: core_1.Flags.string({
-        summary: 'Path to the contract ABI.',
-        default: '*Download from Etherscan*',
-    }),
-    contractName: core_1.Flags.string({
-        summary: 'Name of the contract.',
-        default: 'Contract',
-    }),
-    mergeEntities: core_1.Flags.boolean({
-        summary: 'Whether to merge entities with the same name.',
-        default: false,
-    }),
-    networkFile: core_1.Flags.string({
-        summary: 'Networks config file path.',
-        default: 'networks.json',
-    }),
+    return { abiData, collisionEntities, onlyCollisions };
 };

package/dist/commands/auth.js

@@ -0,0 +1,122 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chalk_1 = __importDefault(require("chalk"));
+const auth_1 = require("../command-helpers/auth");
+const gluegun_1 = require("../command-helpers/gluegun");
+const node_1 = require("../command-helpers/node");
+const HELP = `
+${chalk_1.default.bold('graph auth')} [options] ${chalk_1.default.bold('<node>')} ${chalk_1.default.bold('<deploy-key>')}
+
+${chalk_1.default.dim('Options:')}
+
+      --product <subgraph-studio|hosted-service>
+                                Selects the product for which to authenticate
+      --studio                  Shortcut for --product subgraph-studio
+  -h, --help                    Show usage information
+`;
+const processForm = async (toolbox, { product, studio, node, deployKey }) => {
+    const questions = [
+        {
+            type: 'select',
+            name: 'product',
+            message: 'Product for which to initialize',
+            choices: ['subgraph-studio', 'hosted-service'],
+            skip: product === 'subgraph-studio' ||
+                product === 'hosted-service' ||
+                studio !== undefined ||
+                node !== undefined,
+        },
+        {
+            type: 'password',
+            name: 'deployKey',
+            message: 'Deploy key',
+            skip: deployKey !== undefined,
+        },
+    ];
+    try {
+        const answers = await toolbox.prompt.ask(questions);
+        return answers;
+    }
+    catch (e) {
+        return undefined;
+    }
+};
+exports.default = {
+    description: 'Sets the deploy key to use when deploying to a Graph node',
+    run: async (toolbox) => {
+        // Obtain tools
+        const { print } = toolbox;
+        // Read CLI parameters
+        const { product, studio, h, help } = toolbox.parameters.options;
+        // Show help text if requested
+        if (help || h) {
+            print.info(HELP);
+            return;
+        }
+        let firstParam, secondParam;
+        try {
+            [firstParam, secondParam] = (0, gluegun_1.fixParameters)(toolbox.parameters, {
+                h,
+                help,
+                studio,
+            });
+        }
+        catch (e) {
+            print.error(e.message);
+            process.exitCode = 1;
+            return;
+        }
+        // if user specifies --product or --studio then deployKey is the first parameter
+        let node;
+        let deployKey;
+        if (product || studio) {
+            ({ node } = (0, node_1.chooseNodeUrl)({ product, studio, node }));
+            deployKey = firstParam;
+        }
+        else {
+            node = firstParam;
+            deployKey = secondParam;
+        }
+        if (!node || !deployKey) {
+            const inputs = await processForm(toolbox, {
+                product,
+                studio,
+                node,
+                deployKey,
+            });
+            if (inputs === undefined) {
+                process.exit(1);
+            }
+            if (!node) {
+                ({ node } = (0, node_1.chooseNodeUrl)({
+                    product: inputs.product,
+                    studio,
+                    node,
+                }));
+            }
+            deployKey || (deployKey = inputs.deployKey);
+        }
+        if (!deployKey) {
+            print.error(`No deploy key provided`);
+            print.info(HELP);
+            process.exitCode = 1;
+            return;
+        }
+        if (deployKey.length > 200) {
+            print.error(`Deploy key must not exceed 200 characters`);
+            process.exitCode = 1;
+            return;
+        }
+        try {
+            await (0, auth_1.saveDeployKey)(node, deployKey);
+            print.success(`Deploy key set for ${node}`);
+        }
+        catch (e) {
+            print.error(e);
+            process.exitCode = 1;
+        }
+    },
+};

package/dist/commands/build.js

@@ -0,0 +1,136 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chalk_1 = __importDefault(require("chalk"));
+const compiler_1 = require("../command-helpers/compiler");
+const DataSourcesExtractor = __importStar(require("../command-helpers/data-sources"));
+const gluegun_1 = require("../command-helpers/gluegun");
+const network_1 = require("../command-helpers/network");
+const debug_1 = __importDefault(require("../debug"));
+const protocols_1 = __importDefault(require("../protocols"));
+const buildDebug = (0, debug_1.default)('graph-cli:build');
+const HELP = `
+${chalk_1.default.bold('graph build')} [options] ${chalk_1.default.bold('[<subgraph-manifest>]')}
+
+Options:
+
+  -h, --help                    Show usage information
+  -i, --ipfs <node>             Upload build results to an IPFS node
+  -o, --output-dir <path>       Output directory for build results (default: build/)
+  -t, --output-format <format>  Output format for mappings (wasm, wast) (default: wasm)
+      --skip-migrations         Skip subgraph migrations (default: false)
+  -w, --watch                   Regenerate types when subgraph files change (default: false)
+      --network <name>          Network configuration to use from the networks config file
+      --network-file <path>     Networks config file path (default: "./networks.json")
+`;
+exports.default = {
+    description: 'Builds a subgraph and (optionally) uploads it to IPFS',
+    run: async (toolbox) => {
+        // Obtain tools
+        const { filesystem, print } = toolbox;
+        // Parse CLI parameters
+        let { i, h, help, ipfs, o, outputDir, outputFormat, skipMigrations, t, w, watch, network, networkFile, } = toolbox.parameters.options;
+        // Support both short and long option variants
+        help || (help = h);
+        ipfs || (ipfs = i);
+        outputDir || (outputDir = o);
+        outputFormat || (outputFormat = t);
+        watch || (watch = w);
+        let manifest;
+        try {
+            [manifest] = (0, gluegun_1.fixParameters)(toolbox.parameters, {
+                h,
+                help,
+                w,
+                watch,
+            });
+        }
+        catch (e) {
+            print.error(e.message);
+            process.exitCode = 1;
+            return;
+        }
+        // Fall back to default values for options / parameters
+        outputFormat = outputFormat && ['wasm', 'wast'].includes(outputFormat) ? outputFormat : 'wasm';
+        outputDir = outputDir && outputDir !== '' ? outputDir : filesystem.path('build');
+        manifest =
+            manifest !== undefined && manifest !== '' ? manifest : filesystem.resolve('subgraph.yaml');
+        networkFile =
+            networkFile !== undefined && networkFile !== ''
+                ? networkFile
+                : filesystem.resolve('networks.json');
+        // Show help text if requested
+        if (help) {
+            print.info(HELP);
+            return;
+        }
+        let protocol;
+        try {
+            const dataSourcesAndTemplates = await DataSourcesExtractor.fromFilePath(manifest);
+            protocol = protocols_1.default.fromDataSources(dataSourcesAndTemplates);
+        }
+        catch (e) {
+            print.error(e.message);
+            process.exitCode = 1;
+            return;
+        }
+        buildDebug('Detected protocol "%s" (%o)', protocol.name, protocol);
+        if (network && filesystem.exists(networkFile) !== 'file') {
+            print.error(`Network file '${networkFile}' does not exists or is not a file!`);
+            process.exitCode = 1;
+            return;
+        }
+        if (network) {
+            const identifierName = protocol.getContract().identifierName();
+            await (0, network_1.updateSubgraphNetwork)(toolbox, manifest, network, networkFile, identifierName);
+        }
+        const compiler = (0, compiler_1.createCompiler)(manifest, {
+            ipfs,
+            outputDir,
+            outputFormat,
+            skipMigrations,
+            protocol,
+        });
+        // Exit with an error code if the compiler couldn't be created
+        if (!compiler) {
+            process.exitCode = 1;
+            return;
+        }
+        // Watch subgraph files for changes or additions, trigger
+        // compile (if watch argument specified)
+        if (watch) {
+            await compiler.watchAndCompile();
+        }
+        else {
+            const result = await compiler.compile();
+            if (result === false) {
+                process.exitCode = 1;
+            }
+        }
+    },
+};