@graphprotocol/graph-cli 0.37.4 → 0.37.5

package/dist/command-helpers/version.test.js

@@ -0,0 +1,186 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const loadManifestUtil = __importStar(require("../migrations/util/load-manifest"));
+const graphTsUtil = __importStar(require("../migrations/util/versions"));
+const version_1 = require("./version");
+describe('Version Command Helpers', () => {
+    describe('assertManifestApiVersion', () => {
+        const fakeManifestPath = 'fake/manifest/path';
+        const minimumApiVersion = '0.0.5';
+        describe('With just dataSources', () => {
+            test('When all of them are less than minimum apiVersion', async () => {
+                // @ts-expect-error TODO: dont pollute the globals
+                loadManifestUtil.loadManifest = jest.fn().mockImplementation(() => Promise.resolve({
+                    dataSources: [
+                        { mapping: { apiVersion: '0.0.1' } },
+                        { mapping: { apiVersion: '0.0.2' } },
+                        { mapping: { apiVersion: '0.0.3' } },
+                    ],
+                }));
+                await expect((0, version_1.assertManifestApiVersion)(fakeManifestPath, minimumApiVersion)).rejects.toThrow(new Error(`The current version of graph-cli can't be used with mappings on apiVersion less than '${minimumApiVersion}'`));
+            });
+            test('When one of them is less than minimum apiVersion', async () => {
+                // @ts-expect-error TODO: dont pollute the globals
+                loadManifestUtil.loadManifest = jest.fn().mockImplementation(() => Promise.resolve({
+                    dataSources: [
+                        { mapping: { apiVersion: '0.0.5' } },
+                        { mapping: { apiVersion: '0.0.2' } },
+                        { mapping: { apiVersion: '0.0.5' } },
+                    ],
+                }));
+                await expect((0, version_1.assertManifestApiVersion)(fakeManifestPath, minimumApiVersion)).rejects.toThrow(new Error(`The current version of graph-cli can't be used with mappings on apiVersion less than '${minimumApiVersion}'`));
+            });
+            test('When none of them are less than minimum apiVersion', async () => {
+                // @ts-expect-error TODO: dont pollute the globals
+                loadManifestUtil.loadManifest = jest.fn().mockImplementation(() => Promise.resolve({
+                    dataSources: [
+                        { mapping: { apiVersion: '0.0.5' } },
+                        { mapping: { apiVersion: '0.0.6' } },
+                        { mapping: { apiVersion: '0.0.5' } },
+                    ],
+                }));
+                await expect((0, version_1.assertManifestApiVersion)(fakeManifestPath, minimumApiVersion)).resolves.toBe(undefined);
+            });
+        });
+        describe('With dataSources and templates', () => {
+            describe('And the dataSources have a lower apiVersion', () => {
+                test('When all of the templates are less than minimum apiVersion', async () => {
+                    // @ts-expect-error TODO: dont pollute the globals
+                    loadManifestUtil.loadManifest = jest.fn().mockImplementation(() => Promise.resolve({
+                        dataSources: [
+                            { mapping: { apiVersion: '0.0.5' } },
+                            { mapping: { apiVersion: '0.0.5' } },
+                            { mapping: { apiVersion: '0.0.3' } },
+                        ],
+                        templates: [
+                            { mapping: { apiVersion: '0.0.1' } },
+                            { mapping: { apiVersion: '0.0.2' } },
+                            { mapping: { apiVersion: '0.0.3' } },
+                        ],
+                    }));
+                    await expect((0, version_1.assertManifestApiVersion)(fakeManifestPath, minimumApiVersion)).rejects.toThrow(new Error(`The current version of graph-cli can't be used with mappings on apiVersion less than '${minimumApiVersion}'`));
+                });
+                test('When one of the templates is less than minimum apiVersion', async () => {
+                    // @ts-expect-error TODO: dont pollute the globals
+                    loadManifestUtil.loadManifest = jest.fn().mockImplementation(() => Promise.resolve({
+                        dataSources: [
+                            { mapping: { apiVersion: '0.0.5' } },
+                            { mapping: { apiVersion: '0.0.5' } },
+                            { mapping: { apiVersion: '0.0.3' } },
+                        ],
+                        templates: [
+                            { mapping: { apiVersion: '0.0.5' } },
+                            { mapping: { apiVersion: '0.0.2' } },
+                            { mapping: { apiVersion: '0.0.5' } },
+                        ],
+                    }));
+                    await expect((0, version_1.assertManifestApiVersion)(fakeManifestPath, minimumApiVersion)).rejects.toThrow(new Error(`The current version of graph-cli can't be used with mappings on apiVersion less than '${minimumApiVersion}'`));
+                });
+                test('When none of the templates are less than minimum apiVersion', async () => {
+                    // @ts-expect-error TODO: dont pollute the globals
+                    loadManifestUtil.loadManifest = jest.fn().mockImplementation(() => Promise.resolve({
+                        dataSources: [
+                            { mapping: { apiVersion: '0.0.5' } },
+                            { mapping: { apiVersion: '0.0.5' } },
+                            { mapping: { apiVersion: '0.0.3' } },
+                        ],
+                        templates: [
+                            { mapping: { apiVersion: '0.0.5' } },
+                            { mapping: { apiVersion: '0.0.6' } },
+                            { mapping: { apiVersion: '0.0.5' } },
+                        ],
+                    }));
+                    await expect((0, version_1.assertManifestApiVersion)(fakeManifestPath, minimumApiVersion)).rejects.toThrow(new Error(`The current version of graph-cli can't be used with mappings on apiVersion less than '${minimumApiVersion}'`));
+                });
+            });
+            describe('And the dataSources do NOT have a lower apiVersion', () => {
+                test('When all of the templates are less than minimum apiVersion', async () => {
+                    // @ts-expect-error TODO: dont pollute the globals
+                    loadManifestUtil.loadManifest = jest.fn().mockImplementation(() => Promise.resolve({
+                        dataSources: [
+                            { mapping: { apiVersion: '0.0.5' } },
+                            { mapping: { apiVersion: '0.0.5' } },
+                            { mapping: { apiVersion: '0.0.6' } },
+                        ],
+                        templates: [
+                            { mapping: { apiVersion: '0.0.1' } },
+                            { mapping: { apiVersion: '0.0.2' } },
+                            { mapping: { apiVersion: '0.0.3' } },
+                        ],
+                    }));
+                    await expect((0, version_1.assertManifestApiVersion)(fakeManifestPath, minimumApiVersion)).rejects.toThrow(new Error(`The current version of graph-cli can't be used with mappings on apiVersion less than '${minimumApiVersion}'`));
+                });
+                test('When one of the templates is less than minimum apiVersion', async () => {
+                    // @ts-expect-error TODO: dont pollute the globals
+                    loadManifestUtil.loadManifest = jest.fn().mockImplementation(() => Promise.resolve({
+                        dataSources: [
+                            { mapping: { apiVersion: '0.0.5' } },
+                            { mapping: { apiVersion: '0.0.5' } },
+                            { mapping: { apiVersion: '0.0.6' } },
+                        ],
+                        templates: [
+                            { mapping: { apiVersion: '0.0.5' } },
+                            { mapping: { apiVersion: '0.0.2' } },
+                            { mapping: { apiVersion: '0.0.5' } },
+                        ],
+                    }));
+                    await expect((0, version_1.assertManifestApiVersion)(fakeManifestPath, minimumApiVersion)).rejects.toThrow(new Error(`The current version of graph-cli can't be used with mappings on apiVersion less than '${minimumApiVersion}'`));
+                });
+                test('When none of the templates are less than minimum apiVersion', async () => {
+                    // @ts-expect-error TODO: dont pollute the globals
+                    loadManifestUtil.loadManifest = jest.fn().mockImplementation(() => Promise.resolve({
+                        dataSources: [
+                            { mapping: { apiVersion: '0.0.5' } },
+                            { mapping: { apiVersion: '0.0.5' } },
+                            { mapping: { apiVersion: '0.0.6' } },
+                        ],
+                        templates: [
+                            { mapping: { apiVersion: '0.0.5' } },
+                            { mapping: { apiVersion: '0.0.6' } },
+                            { mapping: { apiVersion: '0.0.5' } },
+                        ],
+                    }));
+                    await expect((0, version_1.assertManifestApiVersion)(fakeManifestPath, minimumApiVersion)).resolves.toBe(undefined);
+                });
+            });
+        });
+    });
+    describe('assertGraphTsVersion', () => {
+        const fakeNodeModulesDir = 'fake/path/to/node/modules';
+        const minimumGraphTsVersion = '0.22.0';
+        test("When the installed graph-ts version is less than what's supported", async () => {
+            // @ts-expect-error TODO: dont pollute the globals
+            graphTsUtil.getGraphTsVersion = jest.fn().mockImplementation(() => Promise.resolve('0.19.0'));
+            await expect((0, version_1.assertGraphTsVersion)(fakeNodeModulesDir, minimumGraphTsVersion)).rejects.toThrow(new Error(`To use this version of the graph-cli you must upgrade the graph-ts dependency to a version greater than or equal to ${minimumGraphTsVersion}
+Also, you'll probably need to take a look at our AssemblyScript migration guide because of language breaking changes: https://thegraph.com/docs/developer/assemblyscript-migration-guide`));
+        });
+        test('When the installed graph-ts version is a supported one', async () => {
+            // @ts-expect-error TODO: dont pollute the globals
+            graphTsUtil.getGraphTsVersion = jest.fn().mockImplementation(() => Promise.resolve('0.22.0'));
+            await expect((0, version_1.assertGraphTsVersion)(fakeNodeModulesDir, minimumGraphTsVersion)).resolves.toBe(undefined);
+        });
+    });
+});

package/dist/commands/add.js

@@ -0,0 +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 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 ||= '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);
+    }
+    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 ||= 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 ||= h;
+        ipfs ||= i;
+        outputDir ||= o;
+        outputFormat ||= t;
+        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;
+            }
+        }
+    },
+};