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

package/dist/command-helpers/jsonrpc.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.createJsonRpcClient = void 0;
+const jayson_1 = __importDefault(require("jayson"));
+const gluegun_1 = require("gluegun");
+const 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);
+    }
+    else if (url.protocol === 'http:') {
+        return jayson_1.default.Client.http(params);
+    }
+    else {
+        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;

package/dist/command-helpers/network.js

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

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

@@ -0,0 +1,86 @@
+"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 network_1 = require("../command-helpers/network");
+const toolbox = __importStar(require("gluegun/toolbox"));
+const yaml_1 = __importDefault(require("yaml"));
+const path_1 = __importDefault(require("path"));
+const SUBGRAPH_PATH_BASE = path_1.default.join(__dirname, '..', '..', '..', '..', 'examples', 'example-subgraph');
+describe('initNetworksConfig', () => {
+    beforeAll(async () => {
+        await (0, network_1.initNetworksConfig)(toolbox, SUBGRAPH_PATH_BASE, 'address');
+    });
+    afterAll(async () => {
+        await toolbox.filesystem.remove(`${SUBGRAPH_PATH_BASE}/networks.json`);
+    });
+    test('generates networks.json from subgraph.yaml', () => {
+        expect(toolbox.filesystem.exists(`${SUBGRAPH_PATH_BASE}/networks.json`)).toBe('file');
+    });
+    test('Populates the networks.json file with the data from subgraph.yaml', async () => {
+        let networksStr = await toolbox.filesystem.read(`${SUBGRAPH_PATH_BASE}/networks.json`);
+        let networks = JSON.parse(networksStr);
+        let expected = {
+            mainnet: {
+                ExampleSubgraph: { address: '0x22843e74c59580b3eaf6c233fa67d8b7c561a835' },
+            },
+        };
+        expect(networks).toStrictEqual(expected);
+    });
+});
+describe('updateSubgraphNetwork', () => {
+    beforeAll(async () => {
+        let content = {
+            optimism: {
+                ExampleSubgraph: { address: '0x12345...' },
+            },
+        };
+        await toolbox.filesystem.write(`${SUBGRAPH_PATH_BASE}/networks.json`, content);
+        await toolbox.filesystem.copy(`${SUBGRAPH_PATH_BASE}/subgraph.yaml`, `${SUBGRAPH_PATH_BASE}/subgraph_copy.yaml`);
+    });
+    afterAll(async () => {
+        await toolbox.filesystem.remove(`${SUBGRAPH_PATH_BASE}/networks.json`);
+        await toolbox.filesystem.remove(`${SUBGRAPH_PATH_BASE}/subgraph_copy.yaml`);
+    });
+    test('Updates subgraph.yaml', async () => {
+        let manifest = `${SUBGRAPH_PATH_BASE}/subgraph_copy.yaml`;
+        let networksFie = `${SUBGRAPH_PATH_BASE}/networks.json`;
+        let subgraph = await toolbox.filesystem.read(manifest);
+        let subgraphObj = yaml_1.default.parse(subgraph);
+        let network = subgraphObj.dataSources[0].network;
+        let address = subgraphObj.dataSources[0].source.address;
+        expect(network).toBe('mainnet');
+        expect(address).toBe('0x22843e74c59580b3eaf6c233fa67d8b7c561a835');
+        await (0, network_1.updateSubgraphNetwork)(toolbox, manifest, 'optimism', networksFie, 'address');
+        subgraph = await toolbox.filesystem.read(manifest);
+        subgraphObj = yaml_1.default.parse(subgraph);
+        network = subgraphObj.dataSources[0].network;
+        address = subgraphObj.dataSources[0].source.address;
+        expect(network).toBe('optimism');
+        expect(address).toBe('0x12345...');
+    });
+});

package/dist/command-helpers/node.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chooseNodeUrl = exports.normalizeNodeUrl = exports.validateNodeUrl = void 0;
+const URL = require('url').URL;
+const toolbox_1 = require("gluegun/toolbox");
+const SUBGRAPH_STUDIO_URL = 'https://api.studio.thegraph.com/deploy/';
+const HOSTED_SERVICE_URL = 'https://api.thegraph.com/deploy/';
+const validateNodeUrl = node => new URL(node);
+exports.validateNodeUrl = validateNodeUrl;
+const normalizeNodeUrl = node => new URL(node).toString();
+exports.normalizeNodeUrl = normalizeNodeUrl;
+function chooseNodeUrl({ product, studio, node, allowSimpleName }) {
+    if (node) {
+        try {
+            validateNodeUrl(node);
+        }
+        catch (e) {
+            toolbox_1.print.error(`Graph node "${node}" is invalid: ${e.message}`);
+            process.exit(1);
+        }
+    }
+    else {
+        if (studio) {
+            product = 'subgraph-studio';
+        }
+        switch (product) {
+            case 'subgraph-studio':
+                node = SUBGRAPH_STUDIO_URL;
+                break;
+            case 'hosted-service':
+                node = HOSTED_SERVICE_URL;
+                break;
+        }
+    }
+    if ((node && node.match(/studio/)) || product === 'subgraph-studio') {
+        allowSimpleName = true;
+    }
+    return { node, allowSimpleName };
+}
+exports.chooseNodeUrl = chooseNodeUrl;

package/dist/command-helpers/scaffold.js

@@ -0,0 +1,112 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeTestsFiles = exports.writeMapping = exports.writeSchema = exports.writeABI = exports.generateDataSource = exports.writeScaffold = exports.generateScaffold = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const prettier_1 = __importDefault(require("prettier"));
+const yaml_1 = __importDefault(require("yaml"));
+const spinner_1 = require("./spinner");
+const scaffold_1 = __importDefault(require("../scaffold"));
+const mapping_1 = require("../scaffold/mapping");
+const schema_1 = require("../scaffold/schema");
+const tests_1 = require("../scaffold/tests");
+const gluegun_1 = require("gluegun");
+const immutable_1 = require("immutable");
+const generateDataSource = async (protocol, contractName, network, contractAddress, abi) => {
+    const protocolManifest = protocol.getManifestScaffold();
+    return immutable_1.Map.of('kind', protocol.name, 'name', contractName, 'network', network, 'source', yaml_1.default.parse(prettier_1.default.format(protocolManifest.source({ contract: contractAddress, contractName }), { parser: 'yaml' })), 'mapping', yaml_1.default.parse(prettier_1.default.format(protocolManifest.mapping({ abi, contractName }), {
+        parser: 'yaml',
+    }))).asMutable();
+};
+exports.generateDataSource = generateDataSource;
+const generateScaffold = async ({ protocolInstance, abi, contract, network, subgraphName, indexEvents, contractName = 'Contract', node, }, spinner) => {
+    (0, spinner_1.step)(spinner, 'Generate subgraph');
+    const scaffold = new scaffold_1.default({
+        protocol: protocolInstance,
+        abi,
+        indexEvents,
+        contract,
+        network,
+        contractName,
+        subgraphName,
+        node,
+    });
+    return scaffold.generate();
+};
+exports.generateScaffold = generateScaffold;
+const writeScaffoldDirectory = async (scaffold, directory, spinner) => {
+    // Create directory itself
+    await fs_extra_1.default.mkdirs(directory);
+    let promises = Object.keys(scaffold).map(async (basename) => {
+        let content = scaffold[basename];
+        let filename = path_1.default.join(directory, basename);
+        // Write file or recurse into subdirectory
+        if (typeof content === 'string') {
+            await fs_extra_1.default.writeFile(filename, content, { encoding: 'utf-8' });
+        }
+        else if (content == null) {
+            return; // continue loop
+        }
+        else {
+            writeScaffoldDirectory(content, path_1.default.join(directory, basename), spinner);
+        }
+    });
+    await Promise.all(promises);
+};
+const writeScaffold = async (scaffold, directory, spinner) => {
+    (0, spinner_1.step)(spinner, `Write subgraph to directory`);
+    await writeScaffoldDirectory(scaffold, directory, spinner);
+};
+exports.writeScaffold = writeScaffold;
+const writeABI = async (abi, contractName) => {
+    let data = prettier_1.default.format(JSON.stringify(abi.data), {
+        parser: 'json',
+    });
+    await fs_extra_1.default.writeFile(`./abis/${contractName}.json`, data, { encoding: 'utf-8' });
+};
+exports.writeABI = writeABI;
+const writeSchema = async (abi, protocol, schemaPath, entities) => {
+    const events = protocol.hasEvents()
+        ? (0, schema_1.abiEvents)(abi)
+            .filter(event => entities.indexOf(event.get('name')) === -1)
+            .toJS()
+        : [];
+    let data = prettier_1.default.format(events.map(event => (0, schema_1.generateEventType)(event, protocol.name)).join('\n\n'), {
+        parser: 'graphql',
+    });
+    await fs_extra_1.default.appendFile(schemaPath, data, { encoding: 'utf-8' });
+};
+exports.writeSchema = writeSchema;
+const writeMapping = async (abi, protocol, contractName, entities) => {
+    const events = protocol.hasEvents()
+        ? (0, schema_1.abiEvents)(abi)
+            .filter(event => entities.indexOf(event.get('name')) === -1)
+            .toJS()
+        : [];
+    let mapping = prettier_1.default.format((0, mapping_1.generateEventIndexingHandlers)(events, contractName), {
+        parser: 'typescript',
+        semi: false,
+    });
+    await fs_extra_1.default.writeFile(`./src/${gluegun_1.strings.kebabCase(contractName)}.ts`, mapping, {
+        encoding: 'utf-8',
+    });
+};
+exports.writeMapping = writeMapping;
+const writeTestsFiles = async (abi, protocol, contractName) => {
+    const hasEvents = protocol.hasEvents();
+    const events = hasEvents ? (0, schema_1.abiEvents)(abi).toJS() : [];
+    if (events.length > 0) {
+        // If a contract is added to a subgraph that has no tests folder
+        await fs_extra_1.default.ensureDir('./tests/');
+        const testsFiles = (0, tests_1.generateTestsFiles)(contractName, events, true);
+        for (const [fileName, content] of Object.entries(testsFiles)) {
+            await fs_extra_1.default.writeFile(`./tests/${fileName}`, content, {
+                encoding: 'utf-8',
+            });
+        }
+    }
+};
+exports.writeTestsFiles = writeTestsFiles;

package/dist/command-helpers/spinner.js

@@ -0,0 +1,84 @@
+"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 });
+exports.withSpinner = exports.step = void 0;
+const toolbox = __importStar(require("gluegun"));
+const step = (spinner, subject, text) => {
+    if (text) {
+        spinner.stopAndPersist({
+            text: toolbox.print.colors.muted(`${subject} ${text}`),
+        });
+    }
+    else {
+        spinner.stopAndPersist({ text: toolbox.print.colors.muted(subject) });
+    }
+    spinner.start();
+    return spinner;
+};
+exports.step = step;
+// Executes the function `f` in a command-line spinner, using the
+// provided captions for in-progress, error and failed messages.
+//
+// If `f` throws an error, the spinner stops with the failure message
+//   and rethrows the error.
+// If `f` returns an object with a `warning` and a `result` key, the
+//   spinner stops with the warning message and returns the `result` value.
+// Otherwise the spinner prints the in-progress message with a check mark
+//   and simply returns the value returned by `f`.
+const withSpinner = async (text, errorText, warningText, f) => {
+    let spinner = toolbox.print.spin(text);
+    try {
+        let result = await f(spinner);
+        if (typeof result === 'object') {
+            let hasError = Object.keys(result).indexOf('error') >= 0;
+            let hasWarning = Object.keys(result).indexOf('warning') >= 0;
+            let hasResult = Object.keys(result).indexOf('result') >= 0;
+            if (hasError) {
+                spinner.fail(`${errorText}: ${result.error}`);
+                return hasResult ? result.result : result;
+            }
+            if (hasWarning && hasResult) {
+                if (result.warning !== null) {
+                    spinner.warn(`${warningText}: ${result.warning}`);
+                }
+                spinner.succeed(text);
+                return result.result;
+            }
+            else {
+                spinner.succeed(text);
+                return result;
+            }
+        }
+        else {
+            spinner.succeed(text);
+            return result;
+        }
+    }
+    catch (e) {
+        spinner.fail(`${errorText}: ${e.message}`);
+        throw e;
+    }
+};
+exports.withSpinner = withSpinner;

package/dist/command-helpers/studio.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateStudioNetwork = exports.allowedStudioNetworks = void 0;
+const allowedStudioNetworks = ['mainnet', 'rinkeby', 'goerli', 'gnosis'];
+exports.allowedStudioNetworks = allowedStudioNetworks;
+const validateStudioNetwork = ({ studio, product, network }) => {
+    let isStudio = studio || product === 'subgraph-studio';
+    let isAllowedNetwork = allowedStudioNetworks.includes(network);
+    if (isStudio && !isAllowedNetwork) {
+        throw new Error(`The Subgraph Studio only allows subgraphs for these networks: ${allowedStudioNetworks.join(', ')}`);
+    }
+};
+exports.validateStudioNetwork = validateStudioNetwork;

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const studio_1 = require("./studio");
+describe('Version Command Helpers', () => {
+    describe('validateStudioNetwork', () => {
+        describe("When it's studio", () => {
+            test("And it's Ethereum mainnet", () => {
+                expect(() => (0, studio_1.validateStudioNetwork)({
+                    studio: true,
+                    network: 'mainnet',
+                })).not.toThrow(new Error(`The Subgraph Studio only allows subgraphs for these networks: ${studio_1.allowedStudioNetworks.join(', ')}`));
+            });
+            test("And it's Gnosis chain", () => {
+                expect(() => (0, studio_1.validateStudioNetwork)({
+                    studio: true,
+                    network: 'gnosis',
+                })).not.toThrow(new Error(`The Subgraph Studio only allows subgraphs for these networks: ${studio_1.allowedStudioNetworks.join(', ')}`));
+            });
+            test("And it's NOT an allowed network", () => {
+                expect(() => (0, studio_1.validateStudioNetwork)({
+                    product: 'subgraph-studio',
+                    network: 'celo',
+                })).toThrow(new Error(`The Subgraph Studio only allows subgraphs for these networks: ${studio_1.allowedStudioNetworks.join(', ')}`));
+            });
+        });
+        describe("When it's NOT studio", () => {
+            test("And it's Rinkeby", () => {
+                expect(() => (0, studio_1.validateStudioNetwork)({
+                    studio: false,
+                    network: 'rinkeby',
+                })).not.toThrow(new Error(`The Subgraph Studio only allows subgraphs for these networks: ${studio_1.allowedStudioNetworks.join(', ')}`));
+            });
+            test("And it's NOT an allowed network", () => {
+                expect(() => (0, studio_1.validateStudioNetwork)({
+                    product: 'hosted-service',
+                    network: 'celo',
+                })).not.toThrow(new Error(`The Subgraph Studio only allows subgraphs for these networks: ${studio_1.allowedStudioNetworks.join(', ')}`));
+            });
+        });
+    });
+});

package/dist/command-helpers/subgraph.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSubgraphBasename = exports.validateSubgraphName = void 0;
+const validateSubgraphName = (name, { allowSimpleName }) => {
+    if (allowSimpleName) {
+        return name;
+    }
+    else {
+        if (name.split('/').length !== 2) {
+            throw new Error(`Subgraph name "${name}" needs to have the format "<PREFIX>/${name}".
+
+When using the Hosted Service at https://thegraph.com, <PREFIX> is the
+name of your GitHub user or organization.
+
+You can bypass this check with --allow-simple-name.`);
+        }
+    }
+};
+exports.validateSubgraphName = validateSubgraphName;
+const getSubgraphBasename = (name) => {
+    let segments = name.split('/', 2);
+    return segments[segments.length - 1];
+};
+exports.getSubgraphBasename = getSubgraphBasename;

package/dist/command-helpers/version.js

@@ -0,0 +1,74 @@
+"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.assertGraphTsVersion = exports.assertManifestApiVersion = void 0;
+const semver_1 = __importDefault(require("semver"));
+const graphTsUtil = __importStar(require("../migrations/util/versions"));
+const manifestUtil = __importStar(require("../migrations/util/load-manifest"));
+const assertManifestApiVersion = async (manifestPath, minimumApiVersion) => {
+    let manifest = await manifestUtil.loadManifest(manifestPath);
+    let lessThanMinimumVersion = manifestApiVersion => semver_1.default.lt(manifestApiVersion, minimumApiVersion);
+    let isLessThanMinimumVersion = false;
+    if (manifest) {
+        if (manifest.dataSources && Array.isArray(manifest.dataSources)) {
+            isLessThanMinimumVersion = manifest.dataSources.some(dataSource => dataSource &&
+                dataSource.mapping &&
+                dataSource.mapping.apiVersion &&
+                lessThanMinimumVersion(dataSource.mapping.apiVersion));
+        }
+        if (manifest.templates && Array.isArray(manifest.templates)) {
+            isLessThanMinimumVersion =
+                isLessThanMinimumVersion ||
+                    manifest.templates.some(template => template &&
+                        template.mapping &&
+                        template.mapping.apiVersion &&
+                        lessThanMinimumVersion(template.mapping.apiVersion));
+        }
+    }
+    if (isLessThanMinimumVersion) {
+        throw new Error(`The current version of graph-cli can't be used with mappings on apiVersion less than '${minimumApiVersion}'`);
+    }
+};
+exports.assertManifestApiVersion = assertManifestApiVersion;
+const assertGraphTsVersion = async (sourceDir, minimumGraphTsVersion) => {
+    let graphTsVersion;
+    try {
+        graphTsVersion = await graphTsUtil.getGraphTsVersion(sourceDir);
+    }
+    catch (_) {
+        // We only do the assertion if `graph-ts` is installed.
+    }
+    // Coerce needed because we may be dealing with an alpha version
+    // and in the `semver` library, this would return true when comparing
+    // the same version.
+    if (graphTsVersion && semver_1.default.lt(semver_1.default.coerce(graphTsVersion), minimumGraphTsVersion)) {
+        throw 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`);
+    }
+};
+exports.assertGraphTsVersion = assertGraphTsVersion;