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

package/dist/codegen/typescript.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.staticMethod = exports.StaticMethod = exports.param = exports.Param = exports.nullableType = exports.NullableType = exports.namedType = exports.NamedType = exports.moduleImports = exports.ModuleImports = exports.method = exports.Method = exports.klassMember = exports.klass = exports.GENERATED_FILE_NOTE = exports.ClassMember = exports.Class = exports.arrayType = exports.ArrayType = void 0;
+class Param {
+    name;
+    type;
+    constructor(name, type) {
+        this.name = name;
+        this.type = type;
+        this.name = name;
+        this.type = type;
+    }
+    toString() {
+        return `${this.name}: ${this.type.toString()}`;
+    }
+}
+exports.Param = Param;
+class Method {
+    name;
+    params;
+    returnType;
+    body;
+    constructor(name, params, returnType, body) {
+        this.name = name;
+        this.params = params;
+        this.returnType = returnType;
+        this.body = body;
+        this.name = name;
+        this.params = params || [];
+        this.returnType = returnType;
+        this.body = body || '';
+    }
+    toString() {
+        return `
+  ${this.name}(${this.params.map(param => param.toString()).join(', ')})${this.returnType ? `: ${this.returnType.toString()}` : ''} {${this.body}
+  }
+`;
+    }
+}
+exports.Method = Method;
+class StaticMethod {
+    name;
+    params;
+    returnType;
+    body;
+    constructor(name, params, returnType, body) {
+        this.name = name;
+        this.params = params;
+        this.returnType = returnType;
+        this.body = body;
+        this.name = name;
+        this.params = params || [];
+        this.returnType = returnType || 'void';
+        this.body = body || '';
+    }
+    toString() {
+        return `
+  static ${this.name}(${this.params.map(param => param.toString()).join(', ')})${this.returnType ? `: ${this.returnType.toString()}` : ''} {${this.body}
+  }
+`;
+    }
+}
+exports.StaticMethod = StaticMethod;
+class Class {
+    name;
+    extends;
+    methods;
+    members;
+    export;
+    constructor(name, options) {
+        this.name = name;
+        this.name = name;
+        this.extends = options.extends;
+        this.methods = [];
+        this.members = [];
+        this.export = options.export || false;
+    }
+    addMember(member) {
+        this.members.push(member);
+    }
+    addMethod(method) {
+        this.methods.push(method);
+    }
+    toString() {
+        return `
+${this.export ? 'export' : ''} class ${this.name}${this.extends ? ` extends ${this.extends}` : ''} {
+${this.members.map(member => member.toString()).join('\n')}
+${this.methods.map(method => method.toString()).join('')}
+}
+`;
+    }
+}
+exports.Class = Class;
+class ClassMember {
+    name;
+    type;
+    constructor(name, type) {
+        this.name = name;
+        this.type = type;
+        this.name = name;
+        this.type = type;
+    }
+    toString() {
+        return `  ${this.name}: ${this.type.toString()}`;
+    }
+}
+exports.ClassMember = ClassMember;
+class NamedType {
+    name;
+    constructor(name) {
+        this.name = name;
+        this.name = name;
+    }
+    toString() {
+        return this.name;
+    }
+    capitalize() {
+        this.name = this.name.charAt(0).toUpperCase() + this.name.slice(1);
+        return this;
+    }
+    isPrimitive() {
+        const primitives = [
+            'boolean',
+            'u8',
+            'i8',
+            'u16',
+            'i16',
+            'u32',
+            'i32',
+            'u64',
+            'i64',
+            'f32',
+            'f64',
+            'usize',
+            'isize',
+        ];
+        return primitives.includes(this.name);
+    }
+}
+exports.NamedType = NamedType;
+class ArrayType {
+    inner;
+    name;
+    constructor(inner) {
+        this.inner = inner;
+        this.inner = inner;
+        this.name = `Array<${inner.toString()}>`;
+    }
+    toString() {
+        return this.name;
+    }
+}
+exports.ArrayType = ArrayType;
+class NullableType {
+    inner;
+    constructor(inner) {
+        this.inner = inner;
+        this.inner = inner;
+    }
+    toString() {
+        return `${this.inner.toString()} | null`;
+    }
+}
+exports.NullableType = NullableType;
+class ModuleImports {
+    nameOrNames;
+    module;
+    constructor(nameOrNames, module) {
+        this.nameOrNames = nameOrNames;
+        this.module = module;
+        this.nameOrNames = nameOrNames;
+        this.module = module;
+    }
+    toString() {
+        return `import { ${typeof this.nameOrNames === 'string' ? this.nameOrNames : this.nameOrNames.join(',')} } from "${this.module}"`;
+    }
+}
+exports.ModuleImports = ModuleImports;
+const namedType = (name) => new NamedType(name);
+exports.namedType = namedType;
+const arrayType = (name) => new ArrayType(name);
+exports.arrayType = arrayType;
+const param = (name, type) => new Param(name, type);
+exports.param = param;
+const method = (name, params, returnType, body) => new Method(name, params, returnType, body);
+exports.method = method;
+const staticMethod = (name, params, returnType, body) => new StaticMethod(name, params, returnType, body);
+exports.staticMethod = staticMethod;
+const klass = (name, options) => new Class(name, options);
+exports.klass = klass;
+const klassMember = (name, type) => new ClassMember(name, type);
+exports.klassMember = klassMember;
+const nullableType = (type) => new NullableType(type);
+exports.nullableType = nullableType;
+const moduleImports = (nameOrNames, module) => new ModuleImports(nameOrNames, module);
+exports.moduleImports = moduleImports;
+const GENERATED_FILE_NOTE = `
+// THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+`;
+exports.GENERATED_FILE_NOTE = GENERATED_FILE_NOTE;

package/dist/codegen/util.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unrollTuple = exports.isTupleMatrixType = exports.isTupleArrayType = exports.containsTupleType = exports.isTupleType = exports.disambiguateNames = void 0;
+function disambiguateNames({ values, getName, setName, }) {
+    const collisionCounter = new Map();
+    return values.map((value, index) => {
+        const name = getName(value, index);
+        const counter = collisionCounter.get(name);
+        if (counter === undefined) {
+            collisionCounter.set(name, 1);
+            return setName(value, name);
+        }
+        collisionCounter.set(name, counter + 1);
+        return setName(value, `${name}${counter}`);
+    });
+}
+exports.disambiguateNames = disambiguateNames;
+function isTupleType(t) {
+    return t === 'tuple';
+}
+exports.isTupleType = isTupleType;
+function containsTupleType(t) {
+    return isTupleType(t) || isTupleArrayType(t) || isTupleMatrixType(t);
+}
+exports.containsTupleType = containsTupleType;
+function isTupleArrayType(t) {
+    return t.match(/^tuple\[([0-9]+)?\]$/);
+}
+exports.isTupleArrayType = isTupleArrayType;
+function isTupleMatrixType(t) {
+    return t.match(/^tuple\[([0-9]+)?\]\[([0-9]+)?\]$/);
+}
+exports.isTupleMatrixType = isTupleMatrixType;
+const unrollTuple = ({ path, value, }) => value.components.reduce((acc, component, index) => {
+    const name = component.name || `value${index}`;
+    return acc.concat(component.type === 'tuple'
+        ? (0, exports.unrollTuple)({ path: [...path, name], index, value: component })
+        : [{ path: [...path, name], type: component.type }]);
+}, []);
+exports.unrollTuple = unrollTuple;

package/dist/codegen/util.test.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("./util");
+describe('Codegen utilities', () => {
+    test('Name disambiguation', () => {
+        expect((0, util_1.disambiguateNames)({
+            values: ['a', 'b', 'c'],
+            getName: x => x,
+            setName: (_x, name) => name,
+        })).toEqual(['a', 'b', 'c']);
+        expect((0, util_1.disambiguateNames)({
+            values: ['a', 'a', 'a'],
+            getName: x => x,
+            setName: (_x, name) => name,
+        })).toEqual(['a', 'a1', 'a2']);
+        expect((0, util_1.disambiguateNames)({
+            values: [
+                { name: 'ExampleEvent', inputs: [] },
+                { name: 'ExampleEvent', inputs: [{ type: 'uint256' }] },
+                { name: 'ExampleEvent', inputs: [{ type: 'uint96' }] },
+            ],
+            getName: event => event.name,
+            setName: (event, name) => {
+                event.name = name;
+                return event;
+            },
+        })).toEqual([
+            { name: 'ExampleEvent', inputs: [] },
+            { name: 'ExampleEvent1', inputs: [{ type: 'uint256' }] },
+            { name: 'ExampleEvent2', inputs: [{ type: 'uint96' }] },
+        ]);
+    });
+    test('Tuple unrolling', () => {
+        expect((0, util_1.unrollTuple)({
+            value: { type: 'tuple', name: 'value', components: [] },
+            path: ['value'],
+            index: 0,
+        })).toEqual([]);
+        expect((0, util_1.unrollTuple)({
+            value: {
+                type: 'tuple',
+                name: 'value',
+                components: [{ name: 'a', type: 'string' }],
+            },
+            path: ['value'],
+            index: 0,
+        })).toEqual([{ path: ['value', 'a'], type: 'string' }]);
+        expect((0, util_1.unrollTuple)({
+            value: {
+                type: 'tuple',
+                name: 'value',
+                components: [
+                    { name: 'a', type: 'string' },
+                    { name: 'b', type: 'uint256' },
+                ],
+            },
+            path: ['value'],
+            index: 0,
+        })).toEqual([
+            { path: ['value', 'a'], type: 'string' },
+            { path: ['value', 'b'], type: 'uint256' },
+        ]);
+        expect((0, util_1.unrollTuple)({
+            value: {
+                type: 'tuple',
+                name: 'value',
+                components: [
+                    { name: 'a', type: 'string' },
+                    { name: 'b', type: 'uint256' },
+                    {
+                        name: 'c',
+                        type: 'tuple',
+                        components: [
+                            { type: 'bytes32' },
+                            {
+                                name: 'd',
+                                type: 'tuple',
+                                components: [{ name: 'd1', type: 'uint72' }],
+                            },
+                        ],
+                    },
+                ],
+            },
+            path: ['value'],
+            index: 1,
+        })).toEqual([
+            { path: ['value', 'a'], type: 'string' },
+            { path: ['value', 'b'], type: 'uint256' },
+            { path: ['value', 'c', 'value0'], type: 'bytes32' },
+            { path: ['value', 'c', 'd', 'd1'], type: 'uint72' },
+        ]);
+    });
+});

package/dist/command-helpers/abi.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadAbiFromBlockScout = exports.loadAbiFromEtherscan = void 0;
+const immutable_1 = __importDefault(require("immutable"));
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const spinner_1 = require("./spinner");
+const loadAbiFromEtherscan = async (ABICtor, network, address) => await (0, spinner_1.withSpinner)(`Fetching ABI from Etherscan`, `Failed to fetch ABI from Etherscan`, `Warnings while fetching ABI from Etherscan`, async () => {
+    const scanApiUrl = getEtherscanLikeAPIUrl(network);
+    const result = await (0, node_fetch_1.default)(`${scanApiUrl}?module=contract&action=getabi&address=${address}`);
+    const json = await result.json();
+    // Etherscan returns a JSON object that has a `status`, a `message` and
+    // a `result` field. The `status` is '0' in case of errors and '1' in
+    // case of success
+    if (json.status === '1') {
+        return new ABICtor('Contract', undefined, immutable_1.default.fromJS(JSON.parse(json.result)));
+    }
+    throw new Error('ABI not found, try loading it from a local file');
+});
+exports.loadAbiFromEtherscan = loadAbiFromEtherscan;
+const loadAbiFromBlockScout = async (ABICtor, network, address) => await (0, spinner_1.withSpinner)(`Fetching ABI from BlockScout`, `Failed to fetch ABI from BlockScout`, `Warnings while fetching ABI from BlockScout`, async () => {
+    const result = await (0, node_fetch_1.default)(`https://blockscout.com/${network.replace('-', '/')}/api?module=contract&action=getabi&address=${address}`);
+    const json = await result.json();
+    // BlockScout returns a JSON object that has a `status`, a `message` and
+    // a `result` field. The `status` is '0' in case of errors and '1' in
+    // case of success
+    if (json.status === '1') {
+        return new ABICtor('Contract', undefined, immutable_1.default.fromJS(JSON.parse(json.result)));
+    }
+    throw new Error('ABI not found, try loading it from a local file');
+});
+exports.loadAbiFromBlockScout = loadAbiFromBlockScout;
+const getEtherscanLikeAPIUrl = (network) => {
+    switch (network) {
+        case 'mainnet':
+            return `https://api.etherscan.io/api`;
+        case 'arbitrum-one':
+            return `https://api.arbiscan.io/api`;
+        case 'bsc':
+            return `https://api.bscscan.com/api`;
+        case 'chapel':
+            return `https://api-testnet.bscscan.com/api`;
+        case 'matic':
+            return `https://api.polygonscan.com/api`;
+        case 'mumbai':
+            return `https://api-testnet.polygonscan.com/api`;
+        case 'aurora':
+            return `https://api.aurorascan.dev/api`;
+        case 'aurora-testnet':
+            return `https://api-testnet.aurorascan.dev/api`;
+        case 'optimism-kovan':
+            return `https://api-kovan-optimistic.etherscan.io/api`;
+        case 'optimism':
+            return `https://api-optimistic.etherscan.io/api`;
+        case 'moonbeam':
+            return `https://api-moonbeam.moonscan.io/api`;
+        case 'moonriver':
+            return `https://api-moonriver.moonscan.io/api`;
+        case 'mbase':
+            return `https://api-moonbase.moonscan.io/api`;
+        case 'avalanche':
+            return `https://api.snowtrace.io/api`;
+        case 'fuji':
+            return `https://api-testnet.snowtrace.io/api`;
+        case 'gnosis':
+            return `https://api.gnosisscan.io/api`;
+        case 'fantom':
+            return `https://api.ftmscan.com/api`;
+        case 'fantom-testnet':
+            return `https://api-testnet.ftmscan.com/api`;
+        default:
+            return `https://api-${network}.etherscan.io/api`;
+    }
+};

package/dist/command-helpers/auth.js

@@ -0,0 +1,76 @@
+"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 });
+exports.saveDeployKey = exports.identifyDeployKey = void 0;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const toolbox = __importStar(require("gluegun"));
+const node_1 = require("./node");
+const homedir = os_1.default.homedir();
+const CONFIG_PATH = path_1.default.join(homedir, '/.graph-cli.json');
+const getConfig = () => {
+    let config;
+    try {
+        config = JSON.parse(fs_1.default.readFileSync(CONFIG_PATH).toString());
+    }
+    catch {
+        config = {};
+    }
+    return config;
+};
+const identifyDeployKey = async (node, deployKey) => {
+    // Determine the deploy key to use, if any:
+    // - First try using --deploy-key, if provided
+    // - Then see if we have a deploy key set for the Graph node
+    if (deployKey !== undefined) {
+        return deployKey;
+    }
+    try {
+        node = (0, node_1.normalizeNodeUrl)(node);
+        const config = getConfig();
+        return config[node];
+    }
+    catch (e) {
+        toolbox.print.warning(`Could not get deploy key: ${e.message}`);
+        toolbox.print.info(`Continuing without a deploy key\n`);
+    }
+};
+exports.identifyDeployKey = identifyDeployKey;
+const saveDeployKey = async (node, deployKey) => {
+    try {
+        node = (0, node_1.normalizeNodeUrl)(node);
+        const config = getConfig();
+        config[node] = deployKey;
+        fs_1.default.writeFileSync(CONFIG_PATH, JSON.stringify(config));
+    }
+    catch (e) {
+        throw new Error(`Error storing deploy key: ${e.message}`);
+    }
+};
+exports.saveDeployKey = saveDeployKey;

package/dist/command-helpers/compiler.js

@@ -0,0 +1,66 @@
+"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 });
+exports.createCompiler = void 0;
+const url_1 = require("url");
+const toolbox = __importStar(require("gluegun"));
+const ipfs_http_client_1 = __importDefault(require("ipfs-http-client"));
+const compiler_1 = __importDefault(require("../compiler"));
+// Helper function to construct a subgraph compiler
+function createCompiler(manifest, { ipfs, headers, outputDir, outputFormat, skipMigrations, blockIpfsMethods, protocol, }) {
+    // Parse the IPFS URL
+    let url;
+    try {
+        url = ipfs ? new url_1.URL(ipfs) : undefined;
+    }
+    catch (e) {
+        toolbox.print.error(`Invalid IPFS URL: ${ipfs}
+The IPFS URL must be of the following format: http(s)://host[:port]/[path]`);
+        return null;
+    }
+    // Connect to the IPFS node (if a node address was provided)
+    ipfs = ipfs
+        ? (0, ipfs_http_client_1.default)({
+            protocol: url?.protocol.replace(/[:]+$/, ''),
+            host: url?.hostname,
+            port: url?.port,
+            'api-path': url?.pathname.replace(/\/$/, '') + '/api/v0/',
+            headers,
+        })
+        : undefined;
+    return new compiler_1.default({
+        ipfs,
+        subgraphManifest: manifest,
+        outputDir,
+        outputFormat,
+        skipMigrations,
+        blockIpfsMethods,
+        protocol,
+    });
+}
+exports.createCompiler = createCompiler;

package/dist/command-helpers/data-sources.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromManifest = exports.fromFilePath = void 0;
+const immutable_1 = __importDefault(require("immutable"));
+const load_manifest_1 = require("../migrations/util/load-manifest");
+// Loads manifest from file path and returns all:
+// - data sources
+// - templates
+// In a single list.
+const fromFilePath = async (manifestPath) => {
+    const { dataSources = [], templates = [] } = await (0, load_manifest_1.loadManifest)(manifestPath);
+    return dataSources.concat(templates);
+};
+exports.fromFilePath = fromFilePath;
+const extractDataSourceByType = (manifest, dataSourceType, protocol) => manifest
+    .get(dataSourceType, immutable_1.default.List())
+    .reduce((dataSources, dataSource, dataSourceIndex) => protocol.isValidKindName(dataSource.get('kind'))
+    ? dataSources.push(immutable_1.default.Map({ path: [dataSourceType, dataSourceIndex], dataSource }))
+    : dataSources, immutable_1.default.List());
+// Extracts data sources and templates from a immutable manifest data structure
+const fromManifest = (manifest, protocol) => {
+    const dataSources = extractDataSourceByType(manifest, 'dataSources', protocol);
+    const templates = extractDataSourceByType(manifest, 'templates', protocol);
+    return dataSources.concat(templates);
+};
+exports.fromManifest = fromManifest;

package/dist/command-helpers/fs.js

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.displayPath = void 0;
+const path_1 = __importDefault(require("path"));
+const displayPath = (p) => path_1.default.relative(process.cwd(), p);
+exports.displayPath = displayPath;

package/dist/command-helpers/gluegun.js

@@ -0,0 +1,48 @@
+"use strict";
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fixParameters = void 0;
+const fixParameters = (parameters, booleanOptions) => {
+    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;
+    }
+};
+exports.fixParameters = fixParameters;

package/dist/command-helpers/ipfs.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_IPFS_URL = void 0;
+const DEFAULT_IPFS_URL = 'https://api.thegraph.com/ipfs/';
+exports.DEFAULT_IPFS_URL = DEFAULT_IPFS_URL;

package/dist/command-helpers/jsonrpc.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createJsonRpcClient = void 0;
+const gluegun_1 = require("gluegun");
+const jayson_1 = __importDefault(require("jayson"));
+function createJsonRpcClient(url) {
+    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_1.default.Client.https(params);
+    }
+    if (url.protocol === 'http:') {
+        return jayson_1.default.Client.http(params);
+    }
+    gluegun_1.print.error(`Unsupported protocol: ${url.protocol.substring(0, url.protocol.length - 1)}`);
+    gluegun_1.print.error('The Graph Node URL must be of the following format: http(s)://host[:port]/[path]');
+    return null;
+}
+exports.createJsonRpcClient = createJsonRpcClient;