@graphprotocol/graph-cli 0.53.0 → 0.54.0-alpha-20230724180700-d5ce4e2

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @graphprotocol/graph-cli
 
+## 0.54.0-alpha-20230724180700-d5ce4e2
+
+### Minor Changes
+
+- [#1407](https://github.com/graphprotocol/graph-tooling/pull/1407)
+  [`d388127`](https://github.com/graphprotocol/graph-tooling/commit/d388127aa46a47feaab5024d0a2f2da49c9cabac)
+  Thanks [@saihaj](https://github.com/saihaj)! - add skipInstall flag for init
+
+### Patch Changes
+
+- [#1394](https://github.com/graphprotocol/graph-tooling/pull/1394)
+  [`a2a6ae6`](https://github.com/graphprotocol/graph-tooling/commit/a2a6ae697ae93631e020c8583d7c04a338d3c298)
+  Thanks [@saihaj](https://github.com/saihaj)! - dependencies updates:
+  - Added dependency [`zod@^3.21.4` ↗︎](https://www.npmjs.com/package/zod/v/3.21.4) (to
+    `dependencies`)
+
 ## 0.53.0
 
 ### Minor Changes

package/dist/commands/add.js

@@ -29,7 +29,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("@oclif/core");
 const errors_1 = require("@oclif/core/lib/errors");
 const gluegun_1 = require("gluegun");
-const immutable_1 = __importDefault(require("immutable"));
 const abi_1 = require("../command-helpers/abi");
 const DataSourcesExtractor = __importStar(require("../command-helpers/data-sources"));
 const network_1 = require("../command-helpers/network");
@@ -44,8 +43,8 @@ class AddCommand extends core_1.Command {
         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 network = manifest.result.dataSources?.[0].network;
+        const result = manifest.result;
         let startBlock = startBlockFlag;
         const entities = getEntities(manifest);
         const contractNames = getContractNames(manifest);
@@ -87,23 +86,22 @@ class AddCommand extends core_1.Command {
         await (0, scaffold_1.writeABI)(ethabi, contractName);
         const { collisionEntities, onlyCollisions, abiData } = updateEventNamesOnCollision(ethabi, entities, contractName, mergeEntities);
         ethabi.data = abiData;
-        await (0, scaffold_1.writeSchema)(ethabi, protocol, result.getIn(['schema', 'file']), collisionEntities, contractName);
+        await (0, scaffold_1.writeSchema)(ethabi, protocol, result.schema.file, collisionEntities, contractName);
         await (0, scaffold_1.writeMapping)(ethabi, protocol, contractName, collisionEntities);
         await (0, scaffold_1.writeTestsFiles)(ethabi, protocol, contractName);
-        const dataSources = result.get('dataSources');
+        const dataSources = result.dataSources;
         const dataSource = await (0, scaffold_1.generateDataSource)(protocol, contractName, network, address, ethabi, startBlock);
         // Handle the collisions edge case by copying another data source yaml data
         if (mergeEntities && onlyCollisions) {
-            const firstDataSource = dataSources.get(0);
+            const firstDataSource = dataSources?.[0];
             const source = dataSource.get('source');
-            const mapping = firstDataSource.get('mapping').asMutable();
+            const mapping = firstDataSource.mapping;
             // Save the address of the new data source
-            source.abi = firstDataSource.get('source').get('abi');
+            source.abi = firstDataSource.source.abi;
             dataSource.set('mapping', mapping);
             dataSource.set('source', source);
         }
-        result.set('dataSources', dataSources.push(dataSource));
-        await subgraph_1.default.write(result, manifestPath);
+        await subgraph_1.default.write({ ...result, dataSources: [...dataSources, dataSource] }, manifestPath);
         // Update networks.json
         if (gluegun_1.filesystem.exists(networksFile)) {
             await (0, network_1.updateNetworksFile)(network, contractName, address, networksFile);
@@ -155,17 +153,17 @@ AddCommand.flags = {
 };
 exports.default = AddCommand;
 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 dataSources = manifest.result?.dataSources || [];
+    const templates = manifest.result?.templates || [];
+    return [
+        ...dataSources.map(source => source.mapping.entities),
+        ...templates.map(template => template.mapping.entities),
+    ].flat();
 };
 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 dataSources = manifest.result?.dataSources || [];
+    const templates = manifest.result?.templates || [];
+    return [...dataSources.map(source => source.name), templates.map(template => template.name)];
 };
 const updateEventNamesOnCollision = (ethabi, entities, contractName, mergeEntities) => {
     let abiData = ethabi.data;

package/dist/commands/init.d.ts

@@ -16,6 +16,7 @@ export default class InitCommand extends Command {
         'from-example': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
         'contract-name': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
         'index-events': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'skip-install': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         'start-block': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
         abi: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
         spkg: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;

package/dist/commands/init.js

@@ -24,7 +24,7 @@ const availableNetworks = protocols_1.default.availableNetworks();
 const DEFAULT_EXAMPLE_SUBGRAPH = 'ethereum-gravatar';
 class InitCommand extends core_1.Command {
     async run() {
-        const { args: { subgraphName, directory }, flags: { protocol, product, studio, node: nodeFlag, 'allow-simple-name': allowSimpleNameFlag, 'from-contract': fromContract, 'contract-name': contractName, 'from-example': fromExample, 'index-events': indexEvents, network, abi: abiPath, 'start-block': startBlock, spkg: spkgPath, }, } = await this.parse(InitCommand);
+        const { args: { subgraphName, directory }, flags: { protocol, product, studio, node: nodeFlag, 'allow-simple-name': allowSimpleNameFlag, 'from-contract': fromContract, 'contract-name': contractName, 'from-example': fromExample, 'index-events': indexEvents, 'skip-install': skipInstall, network, abi: abiPath, 'start-block': startBlock, spkg: spkgPath, }, } = await this.parse(InitCommand);
         let { node, allowSimpleName } = (0, node_1.chooseNodeUrl)({
             product,
             // if we are loading example, we want to ensure we are using studio
@@ -66,6 +66,7 @@ class InitCommand extends core_1.Command {
                 allowSimpleName,
                 directory,
                 subgraphName,
+                skipInstall,
             }, { commands });
             // Exit with success
             return this.exit(0);
@@ -119,6 +120,7 @@ class InitCommand extends core_1.Command {
                 product,
                 startBlock,
                 spkgPath,
+                skipInstall,
             }, { commands, addContract: false });
             // Exit with success
             return this.exit(0);
@@ -138,6 +140,7 @@ class InitCommand extends core_1.Command {
                 fromExample,
                 subgraphName: answers.subgraphName,
                 directory: answers.directory,
+                skipInstall,
             }, { commands });
         }
         else {
@@ -185,6 +188,7 @@ class InitCommand extends core_1.Command {
                 product: answers.product,
                 startBlock: answers.startBlock,
                 spkgPath: answers.spkgPath,
+                skipInstall,
             }, { commands, addContract: true });
         }
         // Exit with success
@@ -239,6 +243,10 @@ InitCommand.flags = {
         description: 'Index contract events as entities.',
         dependsOn: ['from-contract'],
     }),
+    'skip-install': core_1.Flags.boolean({
+        summary: 'Skip installing dependencies.',
+        default: false,
+    }),
     'start-block': core_1.Flags.string({
         helpGroup: 'Scaffold from contract',
         description: 'Block number to start indexing from.',
@@ -652,7 +660,7 @@ Subgraph ${subgraphName} created in ${relativeDir}
 
 Make sure to visit the documentation on https://thegraph.com/docs/ for further information.`);
 }
-async function initSubgraphFromExample({ fromExample, allowSimpleName, subgraphName, directory, }, { commands, }) {
+async function initSubgraphFromExample({ fromExample, allowSimpleName, subgraphName, directory, skipInstall, }, { commands, }) {
     // Fail if the subgraph name is invalid
     if (!revalidateSubgraphName.bind(this)(subgraphName, { allowSimpleName })) {
         process.exitCode = 1;
@@ -733,10 +741,12 @@ async function initSubgraphFromExample({ fromExample, allowSimpleName, subgraphN
         return;
     }
     // Install dependencies
-    const installed = await installDependencies(directory, commands);
-    if (installed !== true) {
-        this.exit(1);
-        return;
+    if (!skipInstall) {
+        const installed = await installDependencies(directory, commands);
+        if (installed !== true) {
+            this.exit(1);
+            return;
+        }
     }
     // Run code-generation
     const codegen = await runCodegen(directory, commands.codegen);
@@ -746,7 +756,7 @@ async function initSubgraphFromExample({ fromExample, allowSimpleName, subgraphN
     }
     printNextSteps.bind(this)({ subgraphName, directory }, { commands });
 }
-async function initSubgraphFromContract({ protocolInstance, allowSimpleName, subgraphName, directory, abi, network, contract, indexEvents, contractName, node, studio, product, startBlock, spkgPath, }, { commands, addContract, }) {
+async function initSubgraphFromContract({ protocolInstance, allowSimpleName, subgraphName, directory, abi, network, contract, indexEvents, contractName, node, studio, product, startBlock, spkgPath, skipInstall, }, { commands, addContract, }) {
     const isSubstreams = protocolInstance.name === 'substreams';
     // Fail if the subgraph name is invalid
     if (!revalidateSubgraphName.bind(this)(subgraphName, { allowSimpleName })) {
@@ -808,11 +818,13 @@ async function initSubgraphFromContract({ protocolInstance, allowSimpleName, sub
         this.exit(1);
         return;
     }
-    // Install dependencies
-    const installed = await installDependencies(directory, commands);
-    if (installed !== true) {
-        this.exit(1);
-        return;
+    if (!skipInstall) {
+        // Install dependencies
+        const installed = await installDependencies(directory, commands);
+        if (installed !== true) {
+            this.exit(1);
+            return;
+        }
     }
     // Substreams we have nothing to install or generate
     if (!isSubstreams) {

package/dist/manifest.d.ts

@@ -0,0 +1,511 @@
+import { z } from 'zod';
+export declare const Manifest: z.ZodObject<{
+    specVersion: z.ZodString;
+    schema: z.ZodObject<{
+        file: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        file: string;
+    }, {
+        file: string;
+    }>;
+    description: z.ZodOptional<z.ZodString>;
+    repository: z.ZodOptional<z.ZodString>;
+    graft: z.ZodOptional<z.ZodObject<{
+        base: z.ZodString;
+        block: z.ZodBigInt;
+    }, "strip", z.ZodTypeAny, {
+        base: string;
+        block: bigint;
+    }, {
+        base: string;
+        block: bigint;
+    }>>;
+    dataSources: z.ZodArray<z.ZodObject<{
+        kind: z.ZodString;
+        name: z.ZodString;
+        network: z.ZodString;
+        source: z.ZodObject<{
+            address: z.ZodString;
+            abi: z.ZodString;
+            startBlock: z.ZodOptional<z.ZodUnion<[z.ZodBigInt, z.ZodNumber]>>;
+        }, "strip", z.ZodTypeAny, {
+            address: string;
+            abi: string;
+            startBlock?: number | bigint | undefined;
+        }, {
+            address: string;
+            abi: string;
+            startBlock?: number | bigint | undefined;
+        }>;
+        mapping: z.ZodObject<{
+            kind: z.ZodLiteral<"ethereum/events">;
+            apiVersion: z.ZodString;
+            language: z.ZodLiteral<"wasm/assemblyscript">;
+            entities: z.ZodArray<z.ZodString, "many">;
+            eventHandlers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                event: z.ZodString;
+                handler: z.ZodString;
+                topic0: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                event: string;
+                handler: string;
+                topic0?: string | undefined;
+            }, {
+                event: string;
+                handler: string;
+                topic0?: string | undefined;
+            }>, "many">>;
+            callHandlers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                function: z.ZodString;
+                handler: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                function: string;
+                handler: string;
+            }, {
+                function: string;
+                handler: string;
+            }>, "many">>;
+            blockHandlers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                handler: z.ZodString;
+                filter: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodLiteral<"call">;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "call";
+                }, {
+                    kind: "call";
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                handler: string;
+                filter?: {
+                    kind: "call";
+                } | undefined;
+            }, {
+                handler: string;
+                filter?: {
+                    kind: "call";
+                } | undefined;
+            }>, "many">>;
+            file: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            file: string;
+            kind: "ethereum/events";
+            apiVersion: string;
+            language: "wasm/assemblyscript";
+            entities: string[];
+            eventHandlers?: {
+                event: string;
+                handler: string;
+                topic0?: string | undefined;
+            }[] | undefined;
+            callHandlers?: {
+                function: string;
+                handler: string;
+            }[] | undefined;
+            blockHandlers?: {
+                handler: string;
+                filter?: {
+                    kind: "call";
+                } | undefined;
+            }[] | undefined;
+        }, {
+            file: string;
+            kind: "ethereum/events";
+            apiVersion: string;
+            language: "wasm/assemblyscript";
+            entities: string[];
+            eventHandlers?: {
+                event: string;
+                handler: string;
+                topic0?: string | undefined;
+            }[] | undefined;
+            callHandlers?: {
+                function: string;
+                handler: string;
+            }[] | undefined;
+            blockHandlers?: {
+                handler: string;
+                filter?: {
+                    kind: "call";
+                } | undefined;
+            }[] | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        kind: string;
+        name: string;
+        network: string;
+        source: {
+            address: string;
+            abi: string;
+            startBlock?: number | bigint | undefined;
+        };
+        mapping: {
+            file: string;
+            kind: "ethereum/events";
+            apiVersion: string;
+            language: "wasm/assemblyscript";
+            entities: string[];
+            eventHandlers?: {
+                event: string;
+                handler: string;
+                topic0?: string | undefined;
+            }[] | undefined;
+            callHandlers?: {
+                function: string;
+                handler: string;
+            }[] | undefined;
+            blockHandlers?: {
+                handler: string;
+                filter?: {
+                    kind: "call";
+                } | undefined;
+            }[] | undefined;
+        };
+    }, {
+        kind: string;
+        name: string;
+        network: string;
+        source: {
+            address: string;
+            abi: string;
+            startBlock?: number | bigint | undefined;
+        };
+        mapping: {
+            file: string;
+            kind: "ethereum/events";
+            apiVersion: string;
+            language: "wasm/assemblyscript";
+            entities: string[];
+            eventHandlers?: {
+                event: string;
+                handler: string;
+                topic0?: string | undefined;
+            }[] | undefined;
+            callHandlers?: {
+                function: string;
+                handler: string;
+            }[] | undefined;
+            blockHandlers?: {
+                handler: string;
+                filter?: {
+                    kind: "call";
+                } | undefined;
+            }[] | undefined;
+        };
+    }>, "many">;
+    templates: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        kind: z.ZodString;
+        name: z.ZodString;
+        network: z.ZodString;
+        source: z.ZodObject<{
+            abi: z.ZodString;
+            startBlock: z.ZodOptional<z.ZodUnion<[z.ZodBigInt, z.ZodNumber]>>;
+        }, "strip", z.ZodTypeAny, {
+            abi: string;
+            startBlock?: number | bigint | undefined;
+        }, {
+            abi: string;
+            startBlock?: number | bigint | undefined;
+        }>;
+        mapping: z.ZodObject<{
+            kind: z.ZodLiteral<"ethereum/events">;
+            apiVersion: z.ZodString;
+            language: z.ZodLiteral<"wasm/assemblyscript">;
+            entities: z.ZodArray<z.ZodString, "many">;
+            eventHandlers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                event: z.ZodString;
+                handler: z.ZodString;
+                topic0: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                event: string;
+                handler: string;
+                topic0?: string | undefined;
+            }, {
+                event: string;
+                handler: string;
+                topic0?: string | undefined;
+            }>, "many">>;
+            callHandlers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                function: z.ZodString;
+                handler: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                function: string;
+                handler: string;
+            }, {
+                function: string;
+                handler: string;
+            }>, "many">>;
+            blockHandlers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                handler: z.ZodString;
+                filter: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodLiteral<"call">;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "call";
+                }, {
+                    kind: "call";
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                handler: string;
+                filter?: {
+                    kind: "call";
+                } | undefined;
+            }, {
+                handler: string;
+                filter?: {
+                    kind: "call";
+                } | undefined;
+            }>, "many">>;
+            file: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            file: string;
+            kind: "ethereum/events";
+            apiVersion: string;
+            language: "wasm/assemblyscript";
+            entities: string[];
+            eventHandlers?: {
+                event: string;
+                handler: string;
+                topic0?: string | undefined;
+            }[] | undefined;
+            callHandlers?: {
+                function: string;
+                handler: string;
+            }[] | undefined;
+            blockHandlers?: {
+                handler: string;
+                filter?: {
+                    kind: "call";
+                } | undefined;
+            }[] | undefined;
+        }, {
+            file: string;
+            kind: "ethereum/events";
+            apiVersion: string;
+            language: "wasm/assemblyscript";
+            entities: string[];
+            eventHandlers?: {
+                event: string;
+                handler: string;
+                topic0?: string | undefined;
+            }[] | undefined;
+            callHandlers?: {
+                function: string;
+                handler: string;
+            }[] | undefined;
+            blockHandlers?: {
+                handler: string;
+                filter?: {
+                    kind: "call";
+                } | undefined;
+            }[] | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        kind: string;
+        name: string;
+        network: string;
+        source: {
+            abi: string;
+            startBlock?: number | bigint | undefined;
+        };
+        mapping: {
+            file: string;
+            kind: "ethereum/events";
+            apiVersion: string;
+            language: "wasm/assemblyscript";
+            entities: string[];
+            eventHandlers?: {
+                event: string;
+                handler: string;
+                topic0?: string | undefined;
+            }[] | undefined;
+            callHandlers?: {
+                function: string;
+                handler: string;
+            }[] | undefined;
+            blockHandlers?: {
+                handler: string;
+                filter?: {
+                    kind: "call";
+                } | undefined;
+            }[] | undefined;
+        };
+    }, {
+        kind: string;
+        name: string;
+        network: string;
+        source: {
+            abi: string;
+            startBlock?: number | bigint | undefined;
+        };
+        mapping: {
+            file: string;
+            kind: "ethereum/events";
+            apiVersion: string;
+            language: "wasm/assemblyscript";
+            entities: string[];
+            eventHandlers?: {
+                event: string;
+                handler: string;
+                topic0?: string | undefined;
+            }[] | undefined;
+            callHandlers?: {
+                function: string;
+                handler: string;
+            }[] | undefined;
+            blockHandlers?: {
+                handler: string;
+                filter?: {
+                    kind: "call";
+                } | undefined;
+            }[] | undefined;
+        };
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    specVersion: string;
+    schema: {
+        file: string;
+    };
+    dataSources: {
+        kind: string;
+        name: string;
+        network: string;
+        source: {
+            address: string;
+            abi: string;
+            startBlock?: number | bigint | undefined;
+        };
+        mapping: {
+            file: string;
+            kind: "ethereum/events";
+            apiVersion: string;
+            language: "wasm/assemblyscript";
+            entities: string[];
+            eventHandlers?: {
+                event: string;
+                handler: string;
+                topic0?: string | undefined;
+            }[] | undefined;
+            callHandlers?: {
+                function: string;
+                handler: string;
+            }[] | undefined;
+            blockHandlers?: {
+                handler: string;
+                filter?: {
+                    kind: "call";
+                } | undefined;
+            }[] | undefined;
+        };
+    }[];
+    description?: string | undefined;
+    repository?: string | undefined;
+    graft?: {
+        base: string;
+        block: bigint;
+    } | undefined;
+    templates?: {
+        kind: string;
+        name: string;
+        network: string;
+        source: {
+            abi: string;
+            startBlock?: number | bigint | undefined;
+        };
+        mapping: {
+            file: string;
+            kind: "ethereum/events";
+            apiVersion: string;
+            language: "wasm/assemblyscript";
+            entities: string[];
+            eventHandlers?: {
+                event: string;
+                handler: string;
+                topic0?: string | undefined;
+            }[] | undefined;
+            callHandlers?: {
+                function: string;
+                handler: string;
+            }[] | undefined;
+            blockHandlers?: {
+                handler: string;
+                filter?: {
+                    kind: "call";
+                } | undefined;
+            }[] | undefined;
+        };
+    }[] | undefined;
+}, {
+    specVersion: string;
+    schema: {
+        file: string;
+    };
+    dataSources: {
+        kind: string;
+        name: string;
+        network: string;
+        source: {
+            address: string;
+            abi: string;
+            startBlock?: number | bigint | undefined;
+        };
+        mapping: {
+            file: string;
+            kind: "ethereum/events";
+            apiVersion: string;
+            language: "wasm/assemblyscript";
+            entities: string[];
+            eventHandlers?: {
+                event: string;
+                handler: string;
+                topic0?: string | undefined;
+            }[] | undefined;
+            callHandlers?: {
+                function: string;
+                handler: string;
+            }[] | undefined;
+            blockHandlers?: {
+                handler: string;
+                filter?: {
+                    kind: "call";
+                } | undefined;
+            }[] | undefined;
+        };
+    }[];
+    description?: string | undefined;
+    repository?: string | undefined;
+    graft?: {
+        base: string;
+        block: bigint;
+    } | undefined;
+    templates?: {
+        kind: string;
+        name: string;
+        network: string;
+        source: {
+            abi: string;
+            startBlock?: number | bigint | undefined;
+        };
+        mapping: {
+            file: string;
+            kind: "ethereum/events";
+            apiVersion: string;
+            language: "wasm/assemblyscript";
+            entities: string[];
+            eventHandlers?: {
+                event: string;
+                handler: string;
+                topic0?: string | undefined;
+            }[] | undefined;
+            callHandlers?: {
+                function: string;
+                handler: string;
+            }[] | undefined;
+            blockHandlers?: {
+                handler: string;
+                filter?: {
+                    kind: "call";
+                } | undefined;
+            }[] | undefined;
+        };
+    }[] | undefined;
+}>;
+export type ManifestZodSchema = z.infer<typeof Manifest>;

package/dist/manifest.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Manifest = void 0;
+const zod_1 = require("zod");
+// https://github.com/graphprotocol/graph-node/blob/master/docs/subgraph-manifest.md#14-schema
+const Schema = zod_1.z.object({
+    file: zod_1.z.string().describe('The path of the GraphQL IDL file, either local or on IPFS.'),
+});
+// https://github.com/graphprotocol/graph-node/blob/master/docs/subgraph-manifest.md#151-ethereumcontractsource
+const EthereumContractSource = zod_1.z.object({
+    address: zod_1.z.string(),
+    abi: zod_1.z.string(),
+    startBlock: zod_1.z.union([zod_1.z.bigint(), zod_1.z.number()]).optional(),
+});
+// https://github.com/graphprotocol/graph-node/blob/master/docs/subgraph-manifest.md#151-ethereumcontractsource
+const EthereumTemplateContractSource = zod_1.z.object({
+    abi: zod_1.z.string(),
+    startBlock: zod_1.z.union([zod_1.z.bigint(), zod_1.z.number()]).optional(),
+});
+// https://github.com/graphprotocol/graph-node/blob/master/docs/subgraph-manifest.md#1522-eventhandler
+const EventHandler = zod_1.z.object({
+    event: zod_1.z
+        .string()
+        .describe('An identifier for an event that will be handled in the mapping script. For Ethereum contracts, this must be the full event signature to distinguish from events that may share the same name. No alias types can be used.'),
+    handler: zod_1.z
+        .string()
+        .describe('The name of an exported function in the mapping script that should handle the specified event.'),
+    topic0: zod_1.z
+        .string()
+        .optional()
+        .describe('A 0x prefixed hex string. If provided, events whose topic0 is equal to this value will be processed by the given handler. When topic0 is provided, only the topic0 value will be matched, and not the hash of the event signature. This is useful for processing anonymous events in Solidity, which can have their topic0 set to anything. By default, topic0 is equal to the hash of the event signature.'),
+});
+// https://github.com/graphprotocol/graph-node/blob/master/docs/subgraph-manifest.md#1523-callhandler
+const CallHandler = zod_1.z.object({
+    function: zod_1.z
+        .string()
+        .describe('An identifier for a function that will be handled in the mapping script. For Ethereum contracts, this is the normalized function signature to filter calls by.'),
+    handler: zod_1.z
+        .string()
+        .describe('The name of an exported function in the mapping script that should handle the specified event.'),
+});
+// https://github.com/graphprotocol/graph-node/blob/master/docs/subgraph-manifest.md#15241-blockhandlerfilter
+const BlockHandlerFilter = zod_1.z.object({
+    kind: zod_1.z.literal('call').describe('The selected block handler filter.'),
+});
+// https://github.com/graphprotocol/graph-node/blob/master/docs/subgraph-manifest.md#1524-blockhandler
+const BlockHandler = zod_1.z.object({
+    handler: zod_1.z
+        .string()
+        .describe('The name of an exported function in the mapping script that should handle the specified event.'),
+    filter: BlockHandlerFilter.optional().describe('Definition of the filter to apply. If none is supplied, the handler will be called on every block.'),
+});
+// https://github.com/graphprotocol/graph-node/blob/master/docs/subgraph-manifest.md#1521-ethereum-mapping
+const EthereumMapping = zod_1.z.object({
+    kind: zod_1.z
+        .literal('ethereum/events')
+        .describe('Must be "ethereum/events" for Ethereum Events Mapping.'),
+    apiVersion: zod_1.z
+        .string()
+        .describe('Semver string of the version of the Mappings API that will be used by the mapping script.'),
+    language: zod_1.z
+        .literal('wasm/assemblyscript')
+        .describe('The language of the runtime for the Mapping API.'),
+    entities: zod_1.z
+        .array(zod_1.z.string())
+        .describe('A list of entities that will be ingested as part of this mapping. Must correspond to names of entities in the GraphQL IDL.'),
+    eventHandlers: zod_1.z
+        .array(EventHandler)
+        .optional()
+        .describe('Handlers for specific events, which will be defined in the mapping script.'),
+    callHandlers: zod_1.z
+        .array(CallHandler)
+        .optional()
+        .describe('A list of functions that will trigger a handler and the name of the corresponding handlers in the mapping.'),
+    blockHandlers: zod_1.z
+        .array(BlockHandler)
+        .optional()
+        .describe('Defines block filters and handlers to process matching blocks.'),
+    file: zod_1.z.string().describe('The path of the mapping script.'),
+});
+// https://github.com/graphprotocol/graph-node/blob/master/docs/subgraph-manifest.md#152-mapping
+const Mapping = EthereumMapping;
+// https://github.com/graphprotocol/graph-node/blob/master/docs/subgraph-manifest.md#15-data-source
+const DataSource = zod_1.z.object({
+    kind: zod_1.z.string().describe('The type of data source. Possible values: ethereum/contract.'),
+    name: zod_1.z
+        .string()
+        .describe('The name of the source data. Will be used to generate APIs in the mapping and also for self-documentation purposes.'),
+    network: zod_1.z
+        .string()
+        .describe('For blockchains, this describes which network the subgraph targets'),
+    source: EthereumContractSource.describe('The source data on a blockchain such as Ethereum.'),
+    mapping: Mapping.describe('The mapping that defines how to ingest the data.'),
+});
+// https://github.com/graphprotocol/graph-node/blob/master/docs/subgraph-manifest.md#17-data-source-templates
+const TemplateSource = zod_1.z.object({
+    kind: zod_1.z.string().describe('The type of data source. Possible values: ethereum/contract.'),
+    name: zod_1.z
+        .string()
+        .describe('The name of the source data. Will be used to generate APIs in the mapping and also for self-documentation purposes.'),
+    network: zod_1.z
+        .string()
+        .describe('For blockchains, this describes which network the subgraph targets'),
+    source: EthereumTemplateContractSource.describe('The source data on a blockchain such as Ethereum.'),
+    mapping: Mapping.describe('The mapping that defines how to ingest the data.'),
+});
+// https://github.com/graphprotocol/graph-node/blob/master/docs/subgraph-manifest.md#18-graft-base
+const GraftBase = zod_1.z.object({
+    base: zod_1.z.string().describe('The subgraph ID of the base subgraph'),
+    block: zod_1.z.bigint().describe('The block number up to which to use data from the base subgraph'),
+});
+// https://github.com/graphprotocol/graph-node/blob/master/docs/subgraph-manifest.md#13-top-level-api
+exports.Manifest = zod_1.z.object({
+    specVersion: zod_1.z
+        .string()
+        .describe('A Semver version indicating which version of this API is being used.'),
+    schema: Schema.describe('The GraphQL schema of this subgraph.'),
+    description: zod_1.z.string().describe("An optional description of the subgraph's purpose.").optional(),
+    repository: zod_1.z.string().describe('An optional link to where the subgraph lives.').optional(),
+    graft: GraftBase.describe('An optional base to graft onto.').optional(),
+    dataSources: zod_1.z
+        .array(DataSource)
+        .describe("Each data source spec defines the data that will be ingested as well as the transformation logic to derive the state of the subgraph's entities based on the source data."),
+    templates: zod_1.z
+        .array(TemplateSource)
+        .optional()
+        .describe('Each data source template defines a data source that can be created dynamically from the mappings.'),
+});

package/dist/subgraph.d.ts

@@ -1,25 +1,105 @@
-import immutable from 'immutable';
 import { Subgraph as ISubgraph } from './protocols/subgraph';
+import { ManifestZodSchema } from './manifest';
 type ResolveFile = (path: string) => string;
 export default class Subgraph {
     static validate(data: any, protocol: any, { resolveFile }: {
         resolveFile: ResolveFile;
     }): Promise<any>;
-    static validateSchema(manifest: any, { resolveFile }: {
+    static validateSchema(manifest: ManifestZodSchema, { resolveFile }: {
         resolveFile: ResolveFile;
     }): void;
-    static validateRepository(manifest: immutable.Collection<any, any>): immutable.List<unknown>;
-    static validateDescription(manifest: immutable.Collection<any, any>): immutable.List<unknown>;
-    static validateHandlers(manifest: immutable.Collection<any, any>, protocol: any, protocolSubgraph: ISubgraph): any;
-    static validateContractValues(manifest: any, protocol: any): any;
-    static validateUniqueDataSourceNames(manifest: any): any;
-    static validateUniqueTemplateNames(manifest: any): any;
-    static dump(manifest: any): string;
+    static validateRepository(manifest: ManifestZodSchema): {
+        path: string[];
+        message: string;
+    }[];
+    static validateDescription(manifest: ManifestZodSchema): {
+        path: string[];
+        message: string;
+    }[];
+    static validateHandlers(manifest: ManifestZodSchema, protocol: any, protocolSubgraph: ISubgraph): any;
+    static validateContractValues(manifest: ManifestZodSchema, protocol: any): any;
+    static validateUniqueDataSourceNames(manifest: ManifestZodSchema): any;
+    static validateUniqueTemplateNames(manifest: ManifestZodSchema): any;
+    static dump(manifest: ManifestZodSchema): string;
     static load(filename: string, { protocol, skipValidation }?: {
         protocol?: any;
         skipValidation?: boolean;
     }): Promise<{
-        result: immutable.Map<any, any>;
+        result: {
+            specVersion: string;
+            schema: {
+                file: string;
+            };
+            dataSources: {
+                kind: string;
+                name: string;
+                network: string;
+                source: {
+                    address: string;
+                    abi: string;
+                    startBlock?: number | bigint | undefined;
+                };
+                mapping: {
+                    file: string;
+                    kind: "ethereum/events";
+                    apiVersion: string;
+                    language: "wasm/assemblyscript";
+                    entities: string[];
+                    eventHandlers?: {
+                        event: string;
+                        handler: string;
+                        topic0?: string | undefined;
+                    }[] | undefined;
+                    callHandlers?: {
+                        function: string;
+                        handler: string;
+                    }[] | undefined;
+                    blockHandlers?: {
+                        handler: string;
+                        filter?: {
+                            kind: "call";
+                        } | undefined;
+                    }[] | undefined;
+                };
+            }[];
+            description?: string | undefined;
+            repository?: string | undefined;
+            graft?: {
+                base: string;
+                block: bigint;
+            } | undefined;
+            templates?: {
+                kind: string;
+                name: string;
+                network: string;
+                source: {
+                    abi: string;
+                    startBlock?: number | bigint | undefined;
+                };
+                mapping: {
+                    file: string;
+                    kind: "ethereum/events";
+                    apiVersion: string;
+                    language: "wasm/assemblyscript";
+                    entities: string[];
+                    eventHandlers?: {
+                        event: string;
+                        handler: string;
+                        topic0?: string | undefined;
+                    }[] | undefined;
+                    callHandlers?: {
+                        function: string;
+                        handler: string;
+                    }[] | undefined;
+                    blockHandlers?: {
+                        handler: string;
+                        filter?: {
+                            kind: "call";
+                        } | undefined;
+                    }[] | undefined;
+                };
+            }[] | undefined;
+        };
         warning: string | null;
     }>;
     static write(manifest: any, filename: string): Promise<void>;

package/dist/subgraph.js

@@ -34,18 +34,19 @@ const yaml_1 = __importDefault(require("yaml"));
 const types_1 = require("yaml/types");
 const debug_1 = __importDefault(require("./debug"));
 const validation = __importStar(require("./validation"));
+const manifest_1 = require("./manifest");
 const subgraphDebug = (0, debug_1.default)('graph-cli:subgraph');
 const throwCombinedError = (filename, errors) => {
     throw new Error(errors.reduce((msg, e) => `${msg}
 
-  Path: ${e.get('path').size === 0 ? '/' : e.get('path').join(' > ')}
-  ${e.get('message').split('\n').join('\n  ')}`, `Error in ${path_1.default.relative(process.cwd(), filename)}:`));
+  Path: ${e.path.length === 0 ? '/' : e.path.join(' > ')}
+  ${e.message.split('\n').join('\n  ')}`, `Error in ${path_1.default.relative(process.cwd(), filename)}:`));
 };
-const buildCombinedWarning = (filename, warnings) => warnings.size > 0
+const buildCombinedWarning = (filename, warnings) => warnings.length > 0
     ? warnings.reduce((msg, w) => `${msg}
 
-    Path: ${w.get('path').size === 0 ? '/' : w.get('path').join(' > ')}
-    ${w.get('message').split('\n').join('\n    ')}`, `Warnings in ${path_1.default.relative(process.cwd(), filename)}:`) + '\n'
+    Path: ${w.path.length === 0 ? '/' : w.path.join(' > ')}
+    ${w.message.split('\n').join('\n    ')}`, `Warnings in ${path_1.default.relative(process.cwd(), filename)}:`) + '\n'
     : null;
 class Subgraph {
     static async validate(data, protocol, { resolveFile }) {
@@ -66,10 +67,12 @@ class Subgraph {
             return definition.name.value === 'SubgraphManifest';
         });
         // Validate the subgraph manifest using this schema
-        return validation.validateManifest(data, rootType, schema, protocol, { resolveFile });
+        return validation.validateManifest(data, rootType, schema, protocol, {
+            resolveFile,
+        });
     }
     static validateSchema(manifest, { resolveFile }) {
-        const filename = resolveFile(manifest.getIn(['schema', 'file']));
+        const filename = resolveFile(manifest.schema.file);
         const validationErrors = validation.validateSchema(filename);
         let errors;
         if (validationErrors.size > 0) {
@@ -94,103 +97,106 @@ class Subgraph {
         }
     }
     static validateRepository(manifest) {
-        const repository = manifest.get('repository');
+        const repository = manifest.repository;
+        // repository is optional, so no need to throw error if it's not set
+        if (!repository)
+            return [];
         return /^https:\/\/github\.com\/graphprotocol\/graph-tooling?$/.test(repository) ||
             // For legacy reasons, we should error on example subgraphs
             /^https:\/\/github\.com\/graphprotocol\/example-subgraphs?$/.test(repository)
-            ? immutable_1.default.List().push(immutable_1.default.fromJS({
-                path: ['repository'],
-                message: `\
+            ? [
+                {
+                    path: ['repository'],
+                    message: `\
 The repository is still set to ${repository}.
 Please replace it with a link to your subgraph source code.`,
-            }))
-            : immutable_1.default.List();
+                },
+            ]
+            : [];
     }
     static validateDescription(manifest) {
         // TODO: Maybe implement this in the future for each protocol example description
-        return manifest.get('description', '').startsWith('Gravatar for ')
-            ? immutable_1.default.List().push(immutable_1.default.fromJS({
-                path: ['description'],
-                message: `\
+        return (manifest?.description || '').startsWith('Gravatar for ')
+            ? [
+                {
+                    path: ['description'],
+                    message: `\
 The description is still the one from the example subgraph.
 Please update it to tell users more about your subgraph.`,
-            }))
-            : immutable_1.default.List();
+                },
+            ]
+            : [];
     }
     static validateHandlers(manifest, protocol, protocolSubgraph) {
-        return manifest
-            .get('dataSources')
-            .filter((dataSource) => protocol.isValidKindName(dataSource.get('kind')))
+        return manifest.dataSources
+            .filter(dataSource => protocol.isValidKindName(dataSource.kind))
             .reduce((errors, dataSource, dataSourceIndex) => {
             const path = ['dataSources', dataSourceIndex, 'mapping'];
-            const mapping = dataSource.get('mapping');
+            const mapping = dataSource.mapping;
             const handlerTypes = protocolSubgraph.handlerTypes();
-            subgraphDebug('Validating dataSource "%s" handlers with %d handlers types defined for protocol', dataSource.get('name'), handlerTypes.size);
+            subgraphDebug('Validating dataSource "%s" handlers with %d handlers types defined for protocol', dataSource.name, handlerTypes.size);
             if (handlerTypes.size == 0) {
                 return errors;
             }
             const areAllHandlersEmpty = handlerTypes
-                .map((handlerType) => mapping.get(handlerType, immutable_1.default.List()))
-                .every((handlers) => handlers.isEmpty());
+                // @ts-expect-error TODO: handlerTypes needs to be improved
+                .map(handlerType => mapping?.[handlerType] || [])
+                .every(handlers => handlers.length === 0);
             const handlerNamesWithoutLast = handlerTypes.pop().join(', ');
             return areAllHandlersEmpty
-                ? errors.push(immutable_1.default.fromJS({
+                ? errors.push({
                     path,
                     message: `\
 Mapping has no ${handlerNamesWithoutLast} or ${handlerTypes.get(-1)}.
 At least one such handler must be defined.`,
-                }))
+                })
                 : errors;
-        }, immutable_1.default.List());
+        }, []);
     }
     static validateContractValues(manifest, protocol) {
         if (!protocol.hasContract()) {
-            return immutable_1.default.List();
+            return [];
         }
         return validation.validateContractValues(manifest, protocol);
     }
     // Validate that data source names are unique, so they don't overwrite each other.
     static validateUniqueDataSourceNames(manifest) {
         const names = [];
-        return manifest
-            .get('dataSources')
-            .reduce((errors, dataSource, dataSourceIndex) => {
+        return manifest.dataSources.reduce((errors, dataSource, dataSourceIndex) => {
             const path = ['dataSources', dataSourceIndex, 'name'];
-            const name = dataSource.get('name');
+            const name = dataSource.name;
             if (names.includes(name)) {
-                errors = errors.push(immutable_1.default.fromJS({
+                errors = errors.push({
                     path,
                     message: `\
 More than one data source named '${name}', data source names must be unique.`,
-                }));
+                });
             }
             names.push(name);
             return errors;
-        }, immutable_1.default.List());
+        }, []);
     }
     static validateUniqueTemplateNames(manifest) {
         const names = [];
-        return manifest
-            .get('templates', immutable_1.default.List())
-            .reduce((errors, template, templateIndex) => {
+        return (manifest?.templates || []).reduce((errors, template, templateIndex) => {
             const path = ['templates', templateIndex, 'name'];
-            const name = template.get('name');
+            const name = template.name;
             if (names.includes(name)) {
-                errors = errors.push(immutable_1.default.fromJS({
+                errors = errors.push({
                     path,
                     message: `\
 More than one template named '${name}', template names must be unique.`,
-                }));
+                });
             }
             names.push(name);
             return errors;
-        }, immutable_1.default.List());
+        }, []);
     }
     static dump(manifest) {
         types_1.strOptions.fold.lineWidth = 90;
         // @ts-expect-error TODO: plain is the value behind the TS constant
         types_1.strOptions.defaultType = 'PLAIN';
-        return yaml_1.default.stringify(manifest.toJS());
+        return yaml_1.default.stringify(manifest);
     }
     static async load(filename, { protocol, skipValidation } = {
         skipValidation: false,
@@ -210,12 +216,18 @@ More than one template named '${name}', template names must be unique.`,
         const resolveFile = maybeRelativeFile => path_1.default.resolve(path_1.default.dirname(filename), maybeRelativeFile);
         // TODO: Validation for file data sources
         if (!has_file_data_sources) {
-            const manifestErrors = await Subgraph.validate(data, protocol, { resolveFile });
+            const manifestErrors = await Subgraph.validate(data, protocol, {
+                resolveFile,
+            });
             if (manifestErrors.size > 0) {
                 throwCombinedError(filename, manifestErrors);
             }
         }
-        const manifest = immutable_1.default.fromJS(data);
+        const manifestSchema = manifest_1.Manifest.safeParse(data);
+        if (!manifestSchema.success) {
+            throw new Error(manifestSchema.error.message);
+        }
+        const manifest = manifestSchema.data;
         // Validate the schema
         Subgraph.validateSchema(manifest, { resolveFile });
         // Perform other validations
@@ -224,18 +236,24 @@ More than one template named '${name}', template names must be unique.`,
             resolveFile,
         });
         const errors = skipValidation
-            ? immutable_1.default.List()
-            : immutable_1.default.List.of(...protocolSubgraph.validateManifest(), ...Subgraph.validateContractValues(manifest, protocol), ...Subgraph.validateUniqueDataSourceNames(manifest), ...Subgraph.validateUniqueTemplateNames(manifest), ...Subgraph.validateHandlers(manifest, protocol, protocolSubgraph));
-        if (errors.size > 0) {
+            ? []
+            : [
+                ...protocolSubgraph.validateManifest(),
+                ...Subgraph.validateContractValues(manifest, protocol),
+                ...Subgraph.validateUniqueDataSourceNames(manifest),
+                ...Subgraph.validateUniqueTemplateNames(manifest),
+                ...Subgraph.validateHandlers(manifest, protocol, protocolSubgraph),
+            ];
+        if (errors.length > 0) {
             throwCombinedError(filename, errors);
         }
         // Perform warning validations
         const warnings = skipValidation
-            ? immutable_1.default.List()
-            : immutable_1.default.List.of(...Subgraph.validateRepository(manifest), ...Subgraph.validateDescription(manifest));
+            ? []
+            : [...Subgraph.validateRepository(manifest), ...Subgraph.validateDescription(manifest)];
         return {
             result: manifest,
-            warning: warnings.size > 0 ? buildCombinedWarning(filename, warnings) : null,
+            warning: warnings.length > 0 ? buildCombinedWarning(filename, warnings) : null,
         };
     }
     static async write(manifest, filename) {

package/dist/validation/contract.d.ts

@@ -1,6 +1,6 @@
-import immutable from 'immutable';
 import Protocol from '../protocols';
 import { ContractCtor } from '../protocols/contract';
+import { ManifestZodSchema } from '../manifest';
 export declare const validateContract: (value: string, ProtocolContract: ContractCtor) => {
     valid: false;
     error: string;
@@ -8,4 +8,4 @@ export declare const validateContract: (value: string, ProtocolContract: Contrac
     valid: true;
     error: string | null;
 };
-export declare const validateContractValues: (manifest: immutable.Map<any, any>, protocol: Protocol) => any;
+export declare const validateContractValues: (manifest: ManifestZodSchema, protocol: Protocol) => any;

package/dist/validation/contract.js

@@ -1,10 +1,6 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateContractValues = exports.validateContract = void 0;
-const immutable_1 = __importDefault(require("immutable"));
 const validateContract = (value, ProtocolContract) => {
     const contract = new ProtocolContract(value);
     const { valid, error } = contract.validate();
@@ -20,25 +16,26 @@ exports.validateContract = validateContract;
 const validateContractValues = (manifest, protocol) => {
     const ProtocolContract = protocol.getContract();
     const fieldName = ProtocolContract.identifierName();
-    return manifest
-        .get('dataSources')
-        .filter((dataSource) => protocol.isValidKindName(dataSource.get('kind')))
+    return manifest.dataSources
+        .filter(datasource => protocol.isValidKindName(datasource.kind))
         .reduce((errors, dataSource, dataSourceIndex) => {
         const path = ['dataSources', dataSourceIndex, 'source', fieldName];
         // No need to validate if the source has no contract field
-        if (!dataSource.get('source').has(fieldName)) {
+        // @ts-expect-error TODO: we need to rework the classes to make this `fieldName` not be a string
+        if (!dataSource.source[fieldName]) {
             return errors;
         }
-        const contractValue = dataSource.getIn(['source', fieldName]);
+        // @ts-expect-error TODO: we need to rework the classes to make this `fieldName` not be a string
+        const contractValue = dataSource.source[fieldName];
         const { valid, error } = (0, exports.validateContract)(contractValue, ProtocolContract);
         // Validate whether the contract is valid for the protocol
         if (valid) {
             return errors;
         }
-        return errors.push(immutable_1.default.fromJS({
+        return errors.push({
             path,
             message: error,
-        }));
-    }, immutable_1.default.List());
+        });
+    }, []);
 };
 exports.validateContractValues = validateContractValues;

package/oclif.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.53.0",
+  "version": "0.54.0-alpha-20230724180700-d5ce4e2",
   "commands": {
     "add": {
       "id": "add",
@@ -561,6 +561,12 @@
             "from-contract"
           ]
         },
+        "skip-install": {
+          "name": "skip-install",
+          "type": "boolean",
+          "summary": "Skip installing dependencies.",
+          "allowNo": false
+        },
         "start-block": {
           "name": "start-block",
           "type": "option",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphprotocol/graph-cli",
-  "version": "0.53.0",
+  "version": "0.54.0-alpha-20230724180700-d5ce4e2",
   "description": "CLI for building for and deploying to The Graph",
   "license": "(Apache-2.0 OR MIT)",
   "engines": {
@@ -44,13 +44,15 @@
     "tmp-promise": "3.0.3",
     "web3-eth-abi": "1.7.0",
     "which": "2.0.2",
-    "yaml": "1.10.2"
+    "yaml": "1.10.2",
+    "zod": "^3.21.4"
   },
   "devDependencies": {
     "@types/debug": "^4.1.7",
     "@types/fs-extra": "^9.0.13",
     "@types/jest": "^29.0.0",
     "@types/js-yaml": "^3.12.7",
+    "@types/node": "^20.3.2",
     "@types/semver": "^7.3.13",
     "@types/which": "^2.0.1",
     "copyfiles": "^2.4.1",
@@ -59,7 +61,8 @@
     "spawn-command": "0.0.2-1",
     "strip-ansi": "6.0.1",
     "tern": "0.24.3",
-    "typescript": "^5.0.0"
+    "typescript": "^5.0.0",
+    "zod-to-json-schema": "^3.21.3"
   },
   "publishConfig": {
     "access": "public"
@@ -75,7 +78,7 @@
     ]
   },
   "scripts": {
-    "build": "tsc -b tsconfig.build.json && oclif manifest && oclif readme && copyfiles -u 1 src/**/*.graphql dist/",
+    "build": "tsc -b tsconfig.build.json && oclif manifest && oclif readme && copyfiles -u 1 src/**/*.graphql dist/ && node scripts/generate-json-schema.mjs",
     "oclif:pack": "npm pack && pnpm oclif pack tarballs --no-xz && node scripts/rename-tarballs.mjs",
     "test": "jest --verbose",
     "test:add": "jest tests/cli/add.test.ts --verbose",