@graphprotocol/graph-cli 0.37.2 → 0.37.3-alpha-20230110163550-d64bef6

package/dist/commands/codegen.js

@@ -0,0 +1,135 @@
+"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 path_1 = __importDefault(require("path"));
+const type_generator_1 = __importDefault(require("../type-generator"));
+const protocols_1 = __importDefault(require("../protocols"));
+const gluegun_1 = require("../command-helpers/gluegun");
+const DataSourcesExtractor = __importStar(require("../command-helpers/data-sources"));
+const debug_1 = __importDefault(require("../debug"));
+const version_1 = require("../command-helpers/version");
+const HELP = `
+${chalk_1.default.bold('graph codegen')} [options] ${chalk_1.default.bold('[<subgraph-manifest>]')}
+Options:
+  -h, --help                    Show usage information
+  -o, --output-dir <path>       Output directory for generated types (default: generated/)
+  --skip-migrations         Skip subgraph migrations (default: false)
+  -w, --watch                   Regenerate types when subgraph files change (default: false)
+  -u, --uncrashable            Generate Float Subgraph Uncrashable helper file
+  -uc, --uncrashable-config <path>  Directory for uncrashable config (default: ./uncrashable-config.yaml)
+  `;
+let codegenDebug = (0, debug_1.default)('graph-cli:codegen');
+exports.default = {
+    description: 'Generates AssemblyScript types for a subgraph',
+    run: async (toolbox) => {
+        // Obtain tools
+        let { filesystem, print, system } = toolbox;
+        // Read CLI parameters
+        let { h, help, o, outputDir, skipMigrations, w, watch, u, uncrashable, uc, uncrashableConfig, } = toolbox.parameters.options;
+        // Support both long and short option variants
+        help = help || h;
+        outputDir = outputDir || o;
+        watch = watch || w;
+        uncrashable = uncrashable || u;
+        let uncrashable_config = uncrashableConfig || uc;
+        let manifest;
+        try {
+            ;
+            [manifest] = (0, gluegun_1.fixParameters)(toolbox.parameters, {
+                h,
+                help,
+                skipMigrations,
+                w,
+                watch,
+                u,
+                uncrashable,
+            });
+        }
+        catch (e) {
+            print.error(e.message);
+            process.exitCode = 1;
+            return;
+        }
+        codegenDebug('Initialized codegen manifest: %o', manifest);
+        // Fall back to default values for options / parameters
+        outputDir =
+            outputDir !== undefined && outputDir !== ''
+                ? outputDir
+                : filesystem.path('generated');
+        manifest =
+            manifest !== undefined && manifest !== ''
+                ? manifest
+                : filesystem.resolve('subgraph.yaml');
+        uncrashable_config =
+            uncrashable_config !== undefined && uncrashable_config !== ''
+                ? uncrashable_config
+                : filesystem.resolve('uncrashable-config.yaml');
+        // Show help text if requested
+        if (help) {
+            print.info(HELP);
+            return;
+        }
+        let protocol;
+        try {
+            // Checks to make sure codegen doesn't run against
+            // older subgraphs (both apiVersion and graph-ts version).
+            //
+            // We don't want codegen to run without these conditions
+            // because that would mean the CLI would generate code to
+            // the wrong AssemblyScript version.
+            await (0, version_1.assertManifestApiVersion)(manifest, '0.0.5');
+            await (0, version_1.assertGraphTsVersion)(path_1.default.dirname(manifest), '0.25.0');
+            const dataSourcesAndTemplates = await DataSourcesExtractor.fromFilePath(manifest);
+            protocol = protocols_1.default.fromDataSources(dataSourcesAndTemplates);
+        }
+        catch (e) {
+            print.error(e.message);
+            process.exitCode = 1;
+            return;
+        }
+        let generator = new type_generator_1.default({
+            subgraphManifest: manifest,
+            outputDir: outputDir,
+            skipMigrations,
+            protocol,
+            uncrashable,
+            uncrashableConfig: uncrashable_config,
+        });
+        // Watch working directory for file updates or additions, trigger
+        // type generation (if watch argument specified)
+        if (watch) {
+            await generator.watchAndGenerateTypes();
+        }
+        else {
+            if (!(await generator.generateTypes())) {
+                process.exitCode = 1;
+            }
+        }
+    },
+};

package/dist/commands/create.js

@@ -0,0 +1,86 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const url_1 = require("url");
+const chalk_1 = __importDefault(require("chalk"));
+const node_1 = require("../command-helpers/node");
+const auth_1 = require("../command-helpers/auth");
+const jsonrpc_1 = require("../command-helpers/jsonrpc");
+const HELP = `
+${chalk_1.default.bold('graph create')} ${chalk_1.default.dim('[options]')} ${chalk_1.default.bold('<subgraph-name>')}
+
+${chalk_1.default.dim('Options:')}
+
+      --access-token <token>    Graph access token
+  -h, --help                    Show usage information
+  -g, --node <url>              Graph node to create the subgraph in
+`;
+exports.default = {
+    description: 'Registers a subgraph name',
+    run: async (toolbox) => {
+        // Obtain tools
+        let { filesystem, print, system } = toolbox;
+        // Read CLI parameters
+        let { accessToken, g, h, help, node } = toolbox.parameters.options;
+        let subgraphName = toolbox.parameters.first;
+        // Support both long and short option variants
+        node = node || g;
+        help = help || h;
+        // 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 {
+            (0, node_1.validateNodeUrl)(node);
+        }
+        catch (e) {
+            print.error(`Graph node "${node}" is invalid: ${e.message}`);
+            process.exitCode = 1;
+            return;
+        }
+        let requestUrl = new url_1.URL(node);
+        let client = (0, jsonrpc_1.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 (0, auth_1.identifyDeployKey)(node, accessToken);
+        if (accessToken !== undefined && accessToken !== null) {
+            client.options.headers = { Authorization: `Bearer ${accessToken}` };
+        }
+        let spinner = print.spin(`Creating subgraph in Graph node: ${requestUrl}`);
+        client.request('subgraph_create', { name: subgraphName }, function (requestError, jsonRpcError, res) {
+            if (jsonRpcError) {
+                spinner.fail(`Error creating the subgraph: ${jsonRpcError.message}`);
+                process.exitCode = 1;
+            }
+            else if (requestError) {
+                spinner.fail(`HTTP error creating the subgraph: ${requestError.code}`);
+                process.exitCode = 1;
+            }
+            else {
+                spinner.stop();
+                print.success(`Created subgraph: ${subgraphName}`);
+            }
+        });
+    },
+};

package/dist/commands/deploy.js

@@ -0,0 +1,334 @@
+"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 URL = require('url').URL;
+const chalk_1 = __importDefault(require("chalk"));
+const path_1 = __importDefault(require("path"));
+const auth_1 = require("../command-helpers/auth");
+const compiler_1 = require("../command-helpers/compiler");
+const gluegun_1 = require("../command-helpers/gluegun");
+const jsonrpc_1 = require("../command-helpers/jsonrpc");
+const node_1 = require("../command-helpers/node");
+const spinner_1 = require("../command-helpers/spinner");
+const subgraph_1 = require("../command-helpers/subgraph");
+const ipfs_1 = require("../command-helpers/ipfs");
+const version_1 = require("../command-helpers/version");
+const DataSourcesExtractor = __importStar(require("../command-helpers/data-sources"));
+const studio_1 = require("../command-helpers/studio");
+const protocols_1 = __importDefault(require("../protocols"));
+const network_1 = require("../command-helpers/network");
+const HELP = `
+${chalk_1.default.bold('graph deploy')} [options] ${chalk_1.default.bold('<subgraph-name>')} ${chalk_1.default.bold('[<subgraph-manifest>]')}
+
+Options:
+
+        --product <subgraph-studio|hosted-service>
+                                Selects the product to which to deploy
+        --studio                  Shortcut for --product subgraph-studio
+  -g,   --node <node>             Graph node to which to deploy
+        --deploy-key <key>        User deploy key
+  -l    --version-label <label>   Version label used for the deployment
+  -h,   --help                    Show usage information
+  -i,   --ipfs <node>             Upload build results to an IPFS node (default: ${ipfs_1.DEFAULT_IPFS_URL})
+  -hdr, --headers <map>           Add custom headers that will be used by the IPFS HTTP client (default: {})
+        --debug-fork              ID of a remote subgraph whose store will be GraphQL queried
+  -o,   --output-dir <path>       Output directory for build results (default: build/)
+        --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")
+`;
+const processForm = async (toolbox, { product, studio, node, versionLabel }) => {
+    const questions = [
+        {
+            type: 'select',
+            name: 'product',
+            message: 'Product for which to deploy',
+            choices: ['subgraph-studio', 'hosted-service'],
+            skip: product === 'subgraph-studio' ||
+                product === 'hosted-service' ||
+                studio !== undefined ||
+                node !== undefined,
+        },
+        {
+            type: 'input',
+            name: 'versionLabel',
+            message: 'Version Label (e.g. v0.0.1)',
+            skip: versionLabel !== undefined,
+        },
+    ];
+    try {
+        const answers = await toolbox.prompt.ask(questions);
+        return answers;
+    }
+    catch (e) {
+        return undefined;
+    }
+};
+exports.default = {
+    description: 'Deploys the subgraph to a Graph node',
+    run: async (toolbox) => {
+        // Obtain tools
+        let { filesystem, print, system } = toolbox;
+        // Parse CLI parameters
+        let { product, studio, deployKey, accessToken, versionLabel, l, g, h, i, help, ipfs, headers, hdr, node, o, outputDir, skipMigrations, w, watch, debugFork, network, networkFile, } = toolbox.parameters.options;
+        // Support both long and short option variants
+        help = help || h;
+        ipfs = ipfs || i || ipfs_1.DEFAULT_IPFS_URL;
+        headers = headers || hdr || '{}';
+        node = node || g;
+        outputDir = outputDir || o;
+        watch = watch || w;
+        versionLabel = versionLabel || l;
+        try {
+            headers = JSON.parse(headers);
+        }
+        catch (e) {
+            print.error('Please make sure headers is a valid JSON value');
+            process.exitCode = 1;
+            return;
+        }
+        let subgraphName, manifest;
+        try {
+            ;
+            [subgraphName, manifest] = (0, gluegun_1.fixParameters)(toolbox.parameters, {
+                h,
+                help,
+                w,
+                watch,
+                studio,
+            });
+        }
+        catch (e) {
+            print.error(e.message);
+            process.exitCode = 1;
+            return;
+        }
+        // Fall back to default values for options / parameters
+        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');
+        try {
+            const dataSourcesAndTemplates = await DataSourcesExtractor.fromFilePath(manifest);
+            for (const { network } of dataSourcesAndTemplates) {
+                (0, studio_1.validateStudioNetwork)({ studio, product, network });
+            }
+        }
+        catch (e) {
+            print.error(e.message);
+            process.exitCode = 1;
+            return;
+        }
+        // Show help text if requested
+        if (help) {
+            print.info(HELP);
+            return;
+        }
+        ;
+        ({ node } = (0, node_1.chooseNodeUrl)({ product, studio, node }));
+        if (!node) {
+            const inputs = await processForm(toolbox, {
+                product,
+                studio,
+                node,
+                versionLabel: 'skip', // determine label requirement later
+            });
+            if (inputs === undefined) {
+                process.exit(1);
+            }
+            product = inputs.product;
+            ({ node } = (0, node_1.chooseNodeUrl)({
+                product,
+                studio,
+                node,
+            }));
+        }
+        // Validate the subgraph name
+        if (!subgraphName) {
+            print.error(`No subgraph ${product == 'subgraph-studio' || studio ? 'slug' : '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;
+        }
+        // Validate IPFS
+        if (!ipfs) {
+            print.error(`No IPFS node provided`);
+            print.info(HELP);
+            process.exitCode = 1;
+            return;
+        }
+        let protocol;
+        try {
+            // Checks to make sure deploy doesn't run against
+            // older subgraphs (both apiVersion and graph-ts version).
+            //
+            // We don't want the deploy to run without these conditions
+            // because that would mean the CLI would try to compile code
+            // using the wrong AssemblyScript compiler.
+            await (0, version_1.assertManifestApiVersion)(manifest, '0.0.5');
+            await (0, version_1.assertGraphTsVersion)(path_1.default.dirname(manifest), '0.25.0');
+            const dataSourcesAndTemplates = await DataSourcesExtractor.fromFilePath(manifest);
+            protocol = protocols_1.default.fromDataSources(dataSourcesAndTemplates);
+        }
+        catch (e) {
+            print.error(e.message);
+            process.exitCode = 1;
+            return;
+        }
+        if (network) {
+            let identifierName = protocol.getContract().identifierName();
+            await (0, network_1.updateSubgraphNetwork)(toolbox, manifest, network, networkFile, identifierName);
+        }
+        const isStudio = node.match(/studio/);
+        const isHostedService = node.match(/thegraph.com/) && !isStudio;
+        let compiler = (0, compiler_1.createCompiler)(manifest, {
+            ipfs,
+            headers,
+            outputDir,
+            outputFormat: 'wasm',
+            skipMigrations,
+            blockIpfsMethods: isStudio,
+            protocol,
+        });
+        // Exit with an error code if the compiler couldn't be created
+        if (!compiler) {
+            process.exitCode = 1;
+            return;
+        }
+        // Ask for label if not on hosted service
+        if (!versionLabel && !isHostedService) {
+            const inputs = await processForm(toolbox, {
+                product,
+                studio,
+                node,
+                versionLabel,
+            });
+            if (inputs === undefined) {
+                process.exit(1);
+            }
+            versionLabel = inputs.versionLabel;
+        }
+        let requestUrl = new URL(node);
+        let client = (0, jsonrpc_1.createJsonRpcClient)(requestUrl);
+        // Exit with an error code if the client couldn't be created
+        if (!client) {
+            process.exitCode = 1;
+            return;
+        }
+        // Use the deploy key, if one is set
+        if (!deployKey && accessToken) {
+            deployKey = accessToken; // backwards compatibility
+        }
+        deployKey = await (0, auth_1.identifyDeployKey)(node, deployKey);
+        if (deployKey !== undefined && deployKey !== null) {
+            client.options.headers = { Authorization: 'Bearer ' + deployKey };
+        }
+        let deploySubgraph = async (ipfsHash) => {
+            let spinner = print.spin(`Deploying to Graph node ${requestUrl}`);
+            //       `Failed to deploy to Graph node ${requestUrl}`,
+            client.request('subgraph_deploy', {
+                name: subgraphName,
+                ipfs_hash: ipfsHash,
+                version_label: versionLabel,
+                debug_fork: debugFork,
+            }, async (requestError, jsonRpcError, res) => {
+                if (jsonRpcError) {
+                    spinner.fail(`Failed to deploy to Graph node ${requestUrl}: ${jsonRpcError.message}`);
+                    // Provide helpful advice when the subgraph has not been created yet
+                    if (jsonRpcError.message.match(/subgraph name not found/)) {
+                        if (isHostedService) {
+                            print.info(`
+You may need to create it at https://thegraph.com/explorer/dashboard.`);
+                        }
+                        else {
+                            print.info(`
+Make sure to create the subgraph first by running the following command:
+$ graph create --node ${node} ${subgraphName}`);
+                        }
+                    }
+                    process.exitCode = 1;
+                }
+                else if (requestError) {
+                    spinner.fail(`HTTP error deploying the subgraph ${requestError.code}`);
+                    process.exitCode = 1;
+                }
+                else {
+                    spinner.stop();
+                    const base = requestUrl.protocol + '//' + requestUrl.hostname;
+                    let playground = res.playground;
+                    let queries = res.queries;
+                    // Add a base URL if graph-node did not return the full URL
+                    if (playground.charAt(0) === ':') {
+                        playground = base + playground;
+                    }
+                    if (queries.charAt(0) === ':') {
+                        queries = base + queries;
+                    }
+                    if (isHostedService) {
+                        print.success(`Deployed to ${chalk_1.default.blue(`https://thegraph.com/explorer/subgraph/${subgraphName}`)}`);
+                    }
+                    else {
+                        print.success(`Deployed to ${chalk_1.default.blue(`${playground}`)}`);
+                    }
+                    print.info('\nSubgraph endpoints:');
+                    print.info(`Queries (HTTP):     ${queries}`);
+                    print.info(``);
+                }
+            });
+        };
+        if (watch) {
+            await compiler.watchAndCompile(async (ipfsHash) => {
+                if (ipfsHash !== undefined) {
+                    await deploySubgraph(ipfsHash);
+                }
+            });
+        }
+        else {
+            let result = await compiler.compile();
+            if (result === undefined || result === false) {
+                // Compilation failed, not deploying.
+                process.exitCode = 1;
+                return;
+            }
+            await deploySubgraph(result);
+        }
+    },
+};