@graphprotocol/graph-cli 0.90.1 → 0.91.0-alpha-20241202202221-345552f

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # @graphprotocol/graph-cli
 
+## 0.91.0-alpha-20241202202221-345552f
+
+### Minor Changes
+
+- [#1754](https://github.com/graphprotocol/graph-tooling/pull/1754)
+  [`2050bf6`](https://github.com/graphprotocol/graph-tooling/commit/2050bf6259c19bd86a7446410c7e124dfaddf4cd)
+  Thanks [@incrypto32](https://github.com/incrypto32)! - Add support for subgraph datasource and
+  associated types.
+
 ## 0.90.1
 
 ### Patch Changes

package/dist/codegen/schema.d.ts

@@ -20,12 +20,12 @@ export default class SchemaCodeGenerator {
     private schema;
     constructor(schema: Schema);
     generateModuleImports(): tsCodegen.ModuleImports[];
-    generateTypes(): Array<tsCodegen.Class>;
+    generateTypes(generateStoreMethods?: boolean): Array<tsCodegen.Class>;
     generateDerivedLoaders(): any[];
     _isEntityTypeDefinition(def: DefinitionNode): def is ObjectTypeDefinitionNode;
     _isDerivedField(field: FieldDefinitionNode | undefined): boolean;
     _isInterfaceDefinition(def: DefinitionNode): def is InterfaceTypeDefinitionNode;
-    _generateEntityType(def: ObjectTypeDefinitionNode): tsCodegen.Class;
+    _generateEntityType(def: ObjectTypeDefinitionNode, generateStoreMethods?: boolean): tsCodegen.Class;
     _generateDerivedLoader(typeName: string): any;
     _getTypeNameForField(gqlType: TypeNode): string;
     _generateConstructor(_entityName: string, fields: readonly FieldDefinitionNode[] | undefined): tsCodegen.Method;

package/dist/codegen/schema.js

@@ -94,12 +94,12 @@ class SchemaCodeGenerator {
             ], '@graphprotocol/graph-ts'),
         ];
     }
-    generateTypes() {
+    generateTypes(generateStoreMethods = true) {
         return this.schema.ast.definitions
             .map(def => {
             if (this._isEntityTypeDefinition(def)) {
                 schemaCodeGeneratorDebug.extend('generateTypes')(`Generating entity type for ${def.name.value}`);
-                return this._generateEntityType(def);
+                return this._generateEntityType(def, generateStoreMethods);
             }
         })
             .filter(Boolean);
@@ -132,15 +132,17 @@ class SchemaCodeGenerator {
     _isInterfaceDefinition(def) {
         return def.kind === 'InterfaceTypeDefinition';
     }
-    _generateEntityType(def) {
+    _generateEntityType(def, generateStoreMethods = true) {
         const name = def.name.value;
         const klass = tsCodegen.klass(name, { export: true, extends: 'Entity' });
         const fields = def.fields;
         const idField = IdField.fromFields(fields);
         // Generate and add a constructor
         klass.addMethod(this._generateConstructor(name, fields));
-        // Generate and add save() and getById() methods
-        this._generateStoreMethods(name, idField).forEach(method => klass.addMethod(method));
+        if (generateStoreMethods) {
+            // Generate and add save() and getById() methods
+            this._generateStoreMethods(name, idField).forEach(method => klass.addMethod(method));
+        }
         // Generate and add entity field getters and setters
         def.fields
             ?.reduce((methods, field) => methods.concat(this._generateEntityFieldMethods(def, field)), [])

package/dist/codegen/schema.test.js

@@ -34,7 +34,7 @@ const schema_1 = __importDefault(require("../schema"));
 const schema_2 = __importDefault(require("./schema"));
 const typescript_1 = require("./typescript");
 const formatTS = async (code) => await prettier_1.default.format(code, { parser: 'typescript', semi: false });
-const createSchemaCodeGen = (schema) => new schema_2.default(new schema_1.default('', schema, graphql.parse(schema)));
+const createSchemaCodeGen = (schema) => new schema_2.default(new schema_1.default(schema, graphql.parse(schema), ''));
 const testEntity = async (generatedTypes, expectedEntity) => {
     const entity = generatedTypes.find(type => type.name === expectedEntity.name);
     (0, vitest_1.expect)(entity instanceof typescript_1.Class).toBe(true);

package/dist/command-helpers/abi.js

@@ -282,6 +282,8 @@ const getEtherscanLikeAPIUrl = (network) => {
             return 'https://maizenet-explorer.usecorn.com/api';
         case 'corn-testnet':
             return 'https://testnet-explorer.usecorn.com/api';
+        case 'botanix-testnet':
+            return 'https://api.routescan.io/v2/network/testnet/evm/3636/etherscan/api';
         default:
             return `https://api-${network}.etherscan.io/api`;
     }
@@ -446,6 +448,8 @@ const getPublicRPCEndpoint = (network) => {
             return 'https://maizenet-rpc.usecorn.com';
         case 'corn-testnet':
             return 'https://testnet-rpc.usecorn.com';
+        case 'botanix-testnet':
+            return 'https://node.botanixlabs.dev';
         default:
             throw new Error(`Unknown network: ${network}`);
     }

package/dist/command-helpers/scaffold.d.ts

@@ -3,10 +3,10 @@ import Protocol from '../protocols';
 import ABI from '../protocols/ethereum/abi';
 import { Spinner } from './spinner';
 export declare const generateDataSource: (protocol: Protocol, contractName: string, network: string, contractAddress: string, abi: ABI, startBlock?: string) => Promise<Map<unknown, unknown>>;
-export declare const generateScaffold: ({ protocolInstance, abi, contract, network, subgraphName, indexEvents, contractName, startBlock, node, spkgPath, }: {
+export declare const generateScaffold: ({ protocolInstance, abi, source, network, subgraphName, indexEvents, contractName, startBlock, node, spkgPath, entities, }: {
     protocolInstance: Protocol;
     abi: ABI;
-    contract: string;
+    source: string;
     network: string;
     subgraphName: string;
     indexEvents: boolean;
@@ -14,6 +14,7 @@ export declare const generateScaffold: ({ protocolInstance, abi, contract, netwo
     startBlock?: string | undefined;
     node?: string | undefined;
     spkgPath?: string | undefined;
+    entities?: string[] | undefined;
 }, spinner: Spinner) => Promise<{
     'subgraph.yaml': string;
     'schema.graphql': string;

package/dist/command-helpers/scaffold.js

@@ -28,19 +28,20 @@ const generateDataSource = async (protocol, contractName, network, contractAddre
     }))).asMutable();
 };
 exports.generateDataSource = generateDataSource;
-const generateScaffold = async ({ protocolInstance, abi, contract, network, subgraphName, indexEvents, contractName = 'Contract', startBlock, node, spkgPath, }, spinner) => {
+const generateScaffold = async ({ protocolInstance, abi, source, network, subgraphName, indexEvents, contractName = 'Contract', startBlock, node, spkgPath, entities, }, spinner) => {
     (0, spinner_1.step)(spinner, 'Generate subgraph');
     const scaffold = new scaffold_1.default({
         protocol: protocolInstance,
         abi,
         indexEvents,
-        contract,
+        contract: source,
         network,
         contractName,
         startBlock,
         subgraphName,
         node,
         spkgPath,
+        entities,
     });
     return await scaffold.generate();
 };

package/dist/commands/codegen.d.ts

@@ -10,6 +10,7 @@ export default class CodegenCommand extends Command {
         'skip-migrations': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         watch: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         uncrashable: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        ipfs: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
         'uncrashable-config': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
     };
     run(): Promise<void>;

package/dist/commands/codegen.js

@@ -29,6 +29,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const path_1 = __importDefault(require("path"));
 const core_1 = require("@oclif/core");
 const DataSourcesExtractor = __importStar(require("../command-helpers/data-sources"));
+const ipfs_1 = require("../command-helpers/ipfs");
 const version_1 = require("../command-helpers/version");
 const debug_1 = __importDefault(require("../debug"));
 const protocols_1 = __importDefault(require("../protocols"));
@@ -36,9 +37,10 @@ const type_generator_1 = __importDefault(require("../type-generator"));
 const codegenDebug = (0, debug_1.default)('graph-cli:codegen');
 class CodegenCommand extends core_1.Command {
     async run() {
-        const { args: { 'subgraph-manifest': manifest }, flags: { 'output-dir': outputDir, 'skip-migrations': skipMigrations, watch, uncrashable, 'uncrashable-config': uncrashableConfig, }, } = await this.parse(CodegenCommand);
+        const { args: { 'subgraph-manifest': manifest }, flags: { 'output-dir': outputDir, 'skip-migrations': skipMigrations, watch, ipfs, uncrashable, 'uncrashable-config': uncrashableConfig, }, } = await this.parse(CodegenCommand);
         codegenDebug('Initialized codegen manifest: %o', manifest);
         let protocol;
+        let subgraphSources;
         try {
             // Checks to make sure codegen doesn't run against
             // older subgraphs (both apiVersion and graph-ts version).
@@ -50,6 +52,9 @@ class CodegenCommand extends core_1.Command {
             await (0, version_1.assertGraphTsVersion)(path_1.default.dirname(manifest), '0.25.0');
             const dataSourcesAndTemplates = await DataSourcesExtractor.fromFilePath(manifest);
             protocol = protocols_1.default.fromDataSources(dataSourcesAndTemplates);
+            subgraphSources = dataSourcesAndTemplates
+                .filter((ds) => ds.kind == 'subgraph')
+                .map((ds) => ds.source.address);
         }
         catch (e) {
             this.error(e, { exit: 1 });
@@ -60,7 +65,9 @@ class CodegenCommand extends core_1.Command {
             skipMigrations,
             protocol,
             uncrashable,
+            subgraphSources,
             uncrashableConfig: uncrashableConfig || 'uncrashable-config.yaml',
+            ipfsUrl: ipfs,
         });
         // Watch working directory for file updates or additions, trigger
         // type generation (if watch argument specified)
@@ -98,6 +105,11 @@ CodegenCommand.flags = {
         summary: 'Generate Float Subgraph Uncrashable helper file.',
         char: 'u',
     }),
+    ipfs: core_1.Flags.string({
+        summary: 'IPFS node to use for fetching subgraph data.',
+        char: 'i',
+        default: ipfs_1.DEFAULT_IPFS_URL,
+    }),
     'uncrashable-config': core_1.Flags.file({
         summary: 'Directory for uncrashable config.',
         aliases: ['uc'],

package/dist/commands/init.d.ts

@@ -19,6 +19,7 @@ export default class InitCommand extends Command {
         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>;
         network: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        ipfs: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
     };
     run(): Promise<void>;
 }

package/dist/commands/init.js

@@ -31,8 +31,11 @@ const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 const toolbox = __importStar(require("gluegun"));
 const gluegun_1 = require("gluegun");
+const ipfs_http_client_1 = require("ipfs-http-client");
 const core_1 = require("@oclif/core");
 const abi_1 = require("../command-helpers/abi");
+const compiler_1 = require("../command-helpers/compiler");
+const ipfs_1 = require("../command-helpers/ipfs");
 const network_1 = require("../command-helpers/network");
 const node_1 = require("../command-helpers/node");
 const scaffold_1 = require("../command-helpers/scaffold");
@@ -43,6 +46,8 @@ const constants_1 = require("../constants");
 const debug_1 = __importDefault(require("../debug"));
 const protocols_1 = __importDefault(require("../protocols"));
 const schema_1 = require("../scaffold/schema");
+const schema_2 = __importDefault(require("../schema"));
+const utils_1 = __importDefault(require("../utils"));
 const validation_1 = require("../validation");
 const add_1 = __importDefault(require("./add"));
 const protocolChoices = Array.from(protocols_1.default.availableProtocols().keys());
@@ -88,7 +93,7 @@ const DEFAULT_EXAMPLE_SUBGRAPH = 'ethereum-gravatar';
 class InitCommand extends core_1.Command {
     async run() {
         const { args: { subgraphName, directory }, flags, } = await this.parse(InitCommand);
-        const { protocol, node: nodeFlag, 'from-contract': fromContract, 'contract-name': contractName, 'from-example': fromExample, 'index-events': indexEvents, 'skip-install': skipInstall, 'skip-git': skipGit, network, abi: abiPath, 'start-block': startBlock, spkg: spkgPath, } = flags;
+        const { protocol, node: nodeFlag, 'from-contract': fromContract, 'contract-name': contractName, 'from-example': fromExample, 'index-events': indexEvents, 'skip-install': skipInstall, 'skip-git': skipGit, ipfs, network, abi: abiPath, 'start-block': startBlock, spkg: spkgPath, } = flags;
         initDebugger('Flags: %O', flags);
         let { node } = (0, node_1.chooseNodeUrl)({
             node: nodeFlag,
@@ -170,7 +175,7 @@ class InitCommand extends core_1.Command {
                 protocolInstance,
                 abi,
                 directory,
-                contract: fromContract,
+                source: fromContract,
                 indexEvents,
                 network,
                 subgraphName,
@@ -180,6 +185,7 @@ class InitCommand extends core_1.Command {
                 spkgPath,
                 skipInstall,
                 skipGit,
+                ipfsUrl: ipfs,
             }, { commands, addContract: false });
             // Exit with success
             return this.exit(0);
@@ -208,7 +214,7 @@ class InitCommand extends core_1.Command {
                 abi,
                 abiPath,
                 directory,
-                contract: fromContract,
+                source: fromContract,
                 indexEvents,
                 fromExample,
                 network,
@@ -216,6 +222,7 @@ class InitCommand extends core_1.Command {
                 contractName,
                 startBlock,
                 spkgPath,
+                ipfsUrl: ipfs,
             });
             if (!answers) {
                 this.exit(1);
@@ -230,7 +237,7 @@ class InitCommand extends core_1.Command {
                 directory: answers.directory,
                 abi: answers.abi,
                 network: answers.network,
-                contract: answers.contract,
+                source: answers.source,
                 indexEvents: answers.indexEvents,
                 contractName: answers.contractName,
                 node,
@@ -238,6 +245,7 @@ class InitCommand extends core_1.Command {
                 spkgPath: answers.spkgPath,
                 skipInstall,
                 skipGit,
+                ipfsUrl: answers.ipfs,
             }, { commands, addContract: true });
         }
         // Exit with success
@@ -312,6 +320,11 @@ InitCommand.flags = {
         description: 'Check https://thegraph.com/docs/en/developing/supported-networks/ for supported networks',
         dependsOn: ['from-contract'],
     }),
+    ipfs: core_1.Flags.string({
+        summary: 'IPFS node to use for fetching subgraph data.',
+        char: 'i',
+        default: ipfs_1.DEFAULT_IPFS_URL,
+    }),
 };
 exports.default = InitCommand;
 async function processFromExampleInitForm({ directory: initDirectory, subgraphName: initSubgraphName, }) {
@@ -360,7 +373,7 @@ async function retryWithPrompt(func) {
     }
     return undefined;
 }
-async function processInitForm({ protocol: initProtocol, abi: initAbi, abiPath: initAbiPath, directory: initDirectory, contract: initContract, indexEvents: initIndexEvents, fromExample: initFromExample, network: initNetwork, subgraphName: initSubgraphName, contractName: initContractName, startBlock: initStartBlock, spkgPath: initSpkgPath, }) {
+async function processInitForm({ protocol: initProtocol, abi: initAbi, abiPath: initAbiPath, directory: initDirectory, source: initContract, indexEvents: initIndexEvents, fromExample: initFromExample, network: initNetwork, subgraphName: initSubgraphName, contractName: initContractName, startBlock: initStartBlock, spkgPath: initSpkgPath, ipfsUrl, }) {
     let abiFromEtherscan = undefined;
     let startBlockFromEtherscan = undefined;
     let contractNameFromEtherscan = undefined;
@@ -381,6 +394,7 @@ async function processInitForm({ protocol: initProtocol, abi: initAbi, abiPath:
             },
         });
         const protocolInstance = new protocols_1.default(protocol);
+        const isComposedSubgraph = protocolInstance.isComposedSubgraph();
         const isSubstreams = protocol === 'substreams';
         initDebugger.extend('processInitForm')('isSubstreams: %O', isSubstreams);
         const { subgraphName } = await gluegun_1.prompt.ask([
@@ -421,18 +435,20 @@ async function processInitForm({ protocol: initProtocol, abi: initAbi, abiPath:
                 },
             },
         ]);
-        const { contract } = await gluegun_1.prompt.ask([
-            // TODO:
-            // protocols that don't support contract
-            // - arweave
-            // - cosmos
+        const sourceMessage = isComposedSubgraph
+            ? 'Source subgraph identifier'
+            : `Contract ${protocolInstance.getContract()?.identifierName()}`;
+        const { source } = await gluegun_1.prompt.ask([
             {
                 type: 'input',
-                name: 'contract',
-                message: `Contract ${protocolInstance.getContract()?.identifierName()}`,
-                skip: () => initFromExample !== undefined || !protocolInstance.hasContract() || isSubstreams,
+                name: 'source',
+                message: sourceMessage,
+                skip: () => !isComposedSubgraph,
                 initial: initContract,
                 validate: async (value) => {
+                    if (isComposedSubgraph) {
+                        return true;
+                    }
                     if (initFromExample !== undefined || !protocolInstance.hasContract()) {
                         return true;
                     }
@@ -445,7 +461,8 @@ async function processInitForm({ protocol: initProtocol, abi: initAbi, abiPath:
                     return valid ? true : error;
                 },
                 result: async (value) => {
-                    if (initFromExample !== undefined || isSubstreams || initAbiPath) {
+                    if (initFromExample !== undefined || isSubstreams || initAbiPath || isComposedSubgraph) {
+                        initDebugger("value: '%s'", value);
                         return value;
                     }
                     const ABI = protocolInstance.getABI();
@@ -478,6 +495,15 @@ async function processInitForm({ protocol: initProtocol, abi: initAbi, abiPath:
                 },
             },
         ]);
+        const { ipfs } = await gluegun_1.prompt.ask([
+            {
+                type: 'input',
+                name: 'ipfs',
+                message: `IPFS node to use for fetching subgraph manifest`,
+                initial: ipfsUrl,
+                skip: () => !isComposedSubgraph,
+            },
+        ]);
         const { spkg } = await gluegun_1.prompt.ask([
             {
                 type: 'input',
@@ -497,9 +523,14 @@ async function processInitForm({ protocol: initProtocol, abi: initAbi, abiPath:
                 skip: () => !protocolInstance.hasABIs() ||
                     initFromExample !== undefined ||
                     abiFromEtherscan !== undefined ||
-                    isSubstreams,
+                    isSubstreams ||
+                    !!initAbiPath ||
+                    isComposedSubgraph,
                 validate: async (value) => {
-                    if (initFromExample || abiFromEtherscan || !protocolInstance.hasABIs()) {
+                    if (initFromExample ||
+                        abiFromEtherscan ||
+                        !protocolInstance.hasABIs() ||
+                        isComposedSubgraph) {
                         return true;
                     }
                     const ABI = protocolInstance.getABI();
@@ -514,7 +545,10 @@ async function processInitForm({ protocol: initProtocol, abi: initAbi, abiPath:
                     }
                 },
                 result: async (value) => {
-                    if (initFromExample || abiFromEtherscan || !protocolInstance.hasABIs()) {
+                    if (initFromExample ||
+                        abiFromEtherscan ||
+                        !protocolInstance.hasABIs() ||
+                        isComposedSubgraph) {
                         return null;
                     }
                     const ABI = protocolInstance.getABI();
@@ -555,7 +589,7 @@ async function processInitForm({ protocol: initProtocol, abi: initAbi, abiPath:
                 name: 'indexEvents',
                 message: 'Index contract events as entities',
                 initial: true,
-                skip: () => !!initIndexEvents || isSubstreams,
+                skip: () => !!initIndexEvents || isSubstreams || isComposedSubgraph,
             },
         ]);
         return {
@@ -567,9 +601,10 @@ async function processInitForm({ protocol: initProtocol, abi: initAbi, abiPath:
             fromExample: !!initFromExample,
             network,
             contractName,
-            contract,
+            source,
             indexEvents,
             spkgPath: spkg,
+            ipfs,
         };
     }
     catch (e) {
@@ -753,14 +788,33 @@ async function initSubgraphFromExample({ fromExample, subgraphName, directory, s
     }
     printNextSteps.bind(this)({ subgraphName, directory }, { commands });
 }
-async function initSubgraphFromContract({ protocolInstance, subgraphName, directory, abi, network, contract, indexEvents, contractName, node, startBlock, spkgPath, skipInstall, skipGit, }, { commands, addContract, }) {
+async function initSubgraphFromContract({ protocolInstance, subgraphName, directory, abi, network, source, indexEvents, contractName, node, startBlock, spkgPath, skipInstall, skipGit, ipfsUrl, }, { commands, addContract, }) {
     const isSubstreams = protocolInstance.name === 'substreams';
+    const isComposedSubgraph = protocolInstance.isComposedSubgraph();
     if (gluegun_1.filesystem.exists(directory) &&
         !(await gluegun_1.prompt.confirm('Directory already exists, do you want to initialize the subgraph here (files will be overwritten) ?', false))) {
         this.exit(1);
         return;
     }
-    if (protocolInstance.hasABIs() &&
+    let entities;
+    if (isComposedSubgraph) {
+        try {
+            const ipfsClient = (0, ipfs_http_client_1.create)({
+                url: (0, compiler_1.appendApiVersionForGraph)(ipfsUrl),
+                headers: {
+                    ...constants_1.GRAPH_CLI_SHARED_HEADERS,
+                },
+            });
+            const schemaString = await (0, utils_1.default)(ipfsClient, source);
+            const schema = await schema_2.default.loadFromString(schemaString);
+            entities = schema.getEntityNames();
+        }
+        catch (e) {
+            this.error(`Failed to load and parse subgraph schema: ${e.message}`, { exit: 1 });
+        }
+    }
+    if (!protocolInstance.isComposedSubgraph() &&
+        protocolInstance.hasABIs() &&
         ((0, schema_1.abiEvents)(abi).size === 0 ||
             // @ts-expect-error TODO: the abiEvents result is expected to be a List, how's it an array?
             (0, schema_1.abiEvents)(abi).length === 0)) {
@@ -774,12 +828,13 @@ async function initSubgraphFromContract({ protocolInstance, subgraphName, direct
             subgraphName,
             abi,
             network,
-            contract,
+            source,
             indexEvents,
             contractName,
             startBlock,
             node,
             spkgPath,
+            entities,
         }, spinner);
         await (0, scaffold_1.writeScaffold)(scaffold, directory, spinner);
         return true;

package/dist/protocols/ethereum/type-generator.d.ts

@@ -7,6 +7,7 @@ export default class EthereumTypeGenerator {
     private outputDir;
     constructor(options: TypeGeneratorOptions);
     loadABIs(subgraph: immutable.Map<any, any>): Promise<any>;
+    isValidAbiConfig(abiConfig: any): boolean;
     _loadABI(dataSource: any, name: string, maybeRelativePath: string, spinner: Spinner): {
         dataSource: any;
         abi: ABI;

package/dist/protocols/ethereum/type-generator.js

@@ -17,19 +17,36 @@ class EthereumTypeGenerator {
         this.outputDir = options.outputDir;
     }
     async loadABIs(subgraph) {
-        return await (0, spinner_1.withSpinner)('Load contract ABIs', 'Failed to load contract ABIs', `Warnings while loading contract ABIs`, async (spinner) => {
+        return await (0, spinner_1.withSpinner)('Load contract ABIs', 'Failed to load contract ABIs', 'Warnings while loading contract ABIs', async (spinner) => {
             try {
-                return subgraph
-                    .get('dataSources')
-                    .reduce((abis, dataSource) => dataSource
-                    .getIn(['mapping', 'abis'])
-                    .reduce((abis, abi) => abis.push(this._loadABI(dataSource, abi.get('name'), abi.get('file'), spinner)), abis), immutable_1.default.List());
+                const dataSources = subgraph.get('dataSources');
+                if (!dataSources)
+                    return immutable_1.default.List();
+                return dataSources.reduce((accumulatedAbis, dataSource) => {
+                    // Get ABIs from the current data source's mapping
+                    const sourceAbis = dataSource.getIn(['mapping', 'abis']);
+                    if (!sourceAbis)
+                        return accumulatedAbis;
+                    // Process each ABI in the current data source
+                    return sourceAbis.reduce((currentAbis, abiConfig) => {
+                        // Skip invalid ABI configurations
+                        if (!this.isValidAbiConfig(abiConfig)) {
+                            return currentAbis;
+                        }
+                        // Load and add the ABI to our list
+                        const loadedAbi = this._loadABI(dataSource, abiConfig.get('name'), abiConfig.get('file'), spinner);
+                        return currentAbis.push(loadedAbi);
+                    }, accumulatedAbis);
+                }, immutable_1.default.List());
             }
             catch (e) {
                 throw Error(`Failed to load contract ABIs: ${e.message}`);
             }
         });
     }
+    isValidAbiConfig(abiConfig) {
+        return !!(abiConfig?.get('name') && abiConfig?.get('file'));
+    }
     _loadABI(dataSource, name, maybeRelativePath, spinner) {
         try {
             if (this.sourceDir) {

package/dist/protocols/index.d.ts

@@ -8,7 +8,7 @@ export default class Protocol {
     config: ProtocolConfig;
     constructor(datasource: any);
     static availableProtocols(): immutable.Collection<ProtocolName, string[]>;
-    static availableNetworks(): immutable.Map<"ethereum" | "arweave" | "near" | "cosmos" | "substreams" | "substreams/triggers", immutable.List<string>>;
+    static availableNetworks(): immutable.Map<"ethereum" | "arweave" | "near" | "cosmos" | "substreams" | "substreams/triggers" | "subgraph", immutable.List<string>>;
     static normalizeName(name: ProtocolName): ProtocolName;
     displayName(): string;
     isValidKindName(kind: string): boolean;
@@ -24,8 +24,9 @@ export default class Protocol {
     getContract(): ContractCtor | undefined;
     getManifestScaffold(): any;
     getMappingScaffold(): any;
+    isComposedSubgraph(): boolean;
 }
-export type ProtocolName = 'arweave' | 'ethereum' | 'near' | 'cosmos' | 'substreams' | 'substreams/triggers';
+export type ProtocolName = 'arweave' | 'ethereum' | 'near' | 'cosmos' | 'substreams' | 'substreams/triggers' | 'subgraph';
 export interface ProtocolConfig {
     displayName: string;
     abi?: any;

package/dist/protocols/index.js

@@ -45,8 +45,11 @@ const contract_2 = __importDefault(require("./near/contract"));
 const NearManifestScaffold = __importStar(require("./near/scaffold/manifest"));
 const NearMappingScaffold = __importStar(require("./near/scaffold/mapping"));
 const subgraph_4 = __importDefault(require("./near/subgraph"));
+const SubgraphDataSourceManifestScaffold = __importStar(require("./subgraph/scaffold/manifest"));
+const SubgraphMappingScaffold = __importStar(require("./subgraph/scaffold/mapping"));
+const subgraph_5 = __importDefault(require("./subgraph/subgraph"));
 const SubstreamsManifestScaffold = __importStar(require("./substreams/scaffold/manifest"));
-const subgraph_5 = __importDefault(require("./substreams/subgraph"));
+const subgraph_6 = __importDefault(require("./substreams/subgraph"));
 const protocolDebug = (0, debug_1.default)('graph-cli:protocol');
 class Protocol {
     static fromDataSources(dataSourcesAndTemplates) {
@@ -60,6 +63,7 @@ class Protocol {
          * some other places use datasource object
          */
         const name = typeof datasource === 'string' ? datasource : datasource.kind;
+        protocolDebug('Initializing protocol with datasource %O', datasource);
         this.name = Protocol.normalizeName(name);
         protocolDebug('Initializing protocol %s', this.name);
         switch (this.name) {
@@ -75,6 +79,9 @@ class Protocol {
             case 'near':
                 this.config = nearProtocol;
                 break;
+            case 'subgraph':
+                this.config = subgraphProtocol;
+                break;
             case 'substreams':
                 this.config = substreamsProtocol;
                 /**
@@ -99,6 +106,7 @@ class Protocol {
             near: ['near'],
             cosmos: ['cosmos'],
             substreams: ['substreams'],
+            subgraph: ['subgraph'],
         });
     }
     static availableNetworks() {
@@ -153,6 +161,7 @@ class Protocol {
                 'uni-3', // Juno testnet
             ],
             substreams: ['mainnet'],
+            subgraph: ['mainnet'],
         });
     }
     static normalizeName(name) {
@@ -178,7 +187,7 @@ class Protocol {
         // A problem with hasEvents usage in the codebase is that it's almost every where
         // where used, the ABI data is actually use after the conditional, so it seems
         // both concept are related. So internally, we map to this condition.
-        return this.hasABIs();
+        return this.hasABIs() && !this.isComposedSubgraph();
     }
     hasTemplates() {
         return this.config.getTemplateCodeGen != null;
@@ -213,6 +222,9 @@ class Protocol {
     getMappingScaffold() {
         return this.config.mappingScaffold;
     }
+    isComposedSubgraph() {
+        return this.name === 'subgraph';
+    }
 }
 exports.default = Protocol;
 const arweaveProtocol = {
@@ -255,6 +267,20 @@ const ethereumProtocol = {
     manifestScaffold: EthereumManifestScaffold,
     mappingScaffold: EthereumMappingScaffold,
 };
+const subgraphProtocol = {
+    displayName: 'Subgraph',
+    abi: abi_1.default,
+    contract: undefined,
+    getTemplateCodeGen: undefined,
+    getTypeGenerator(options) {
+        return new type_generator_1.default(options);
+    },
+    getSubgraph(options) {
+        return new subgraph_5.default(options);
+    },
+    manifestScaffold: SubgraphDataSourceManifestScaffold,
+    mappingScaffold: SubgraphMappingScaffold,
+};
 const nearProtocol = {
     displayName: 'NEAR',
     abi: undefined,
@@ -274,7 +300,7 @@ const substreamsProtocol = {
     getTypeGenerator: undefined,
     getTemplateCodeGen: undefined,
     getSubgraph(options) {
-        return new subgraph_5.default(options);
+        return new subgraph_6.default(options);
     },
     manifestScaffold: SubstreamsManifestScaffold,
     mappingScaffold: undefined,

package/dist/protocols/subgraph/manifest.graphql

@@ -0,0 +1,71 @@
+# Each referenced type's in any of the types below must be listed
+# here either as `scalar` or `type` for the validation code to work
+# properly.
+#
+# That's why `String` is listed as a scalar even though it's built-in
+# GraphQL basic types.
+scalar String
+scalar File
+scalar BigInt
+scalar Boolean
+scalar JSON
+
+union StringOrBigInt = String | BigInt
+
+type SubgraphManifest {
+  specVersion: String!
+  features: [String!]
+  schema: Schema!
+  description: String
+  repository: String
+  graft: Graft
+  dataSources: [DataSource!]!
+  indexerHints: IndexerHints
+}
+
+type Schema {
+  file: File!
+}
+
+type IndexerHints {
+  prune: StringOrBigInt
+}
+
+type DataSource {
+  kind: String!
+  name: String!
+  network: String
+  context: JSON
+  source: ContractSource!
+  mapping: ContractMapping!
+}
+
+type ContractSource {
+  address: String!
+  startBlock: BigInt
+}
+
+type ContractMapping {
+  kind: String
+  apiVersion: String!
+  language: String!
+  file: File!
+  abis: [ContractABI!]
+  entities: [String!]!
+  handlers: [EntityHandler!]
+}
+
+type ContractABI {
+  name: String!
+  file: File!
+}
+
+type EntityHandler {
+  handler: String!
+  entity: String!
+}
+
+type Graft {
+  base: String!
+  block: BigInt!
+}

package/dist/protocols/subgraph/scaffold/manifest.d.ts

@@ -0,0 +1,9 @@
+export declare const source: ({ contract, startBlock, }: {
+    contract: string;
+    contractName: string;
+    startBlock: string;
+}) => string;
+export declare const mapping: ({ entities, contractName, }: {
+    entities: string[];
+    contractName: string;
+}) => string;

package/dist/protocols/subgraph/scaffold/manifest.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapping = exports.source = void 0;
+const source = ({ contract, startBlock, }) => `
+      address: '${contract}'
+      startBlock: ${startBlock}`;
+exports.source = source;
+const mapping = ({ entities, contractName, }) => `
+      kind: ethereum/events
+      apiVersion: 0.0.7
+      language: wasm/assemblyscript
+      entities:
+       - ExampleEntity
+      handlers:
+      ${entities
+    .map(entity => `
+        - handler: handle${entity}
+          entity: ${entity}`)
+    .join(' ')}
+      file: ./src/${contractName}.ts
+`;
+exports.mapping = mapping;

package/dist/protocols/subgraph/scaffold/mapping.d.ts

@@ -0,0 +1,4 @@
+export declare const generatePlaceholderHandlers: ({ entities, contract, }: {
+    entities: string[];
+    contract: string;
+}) => string;

package/dist/protocols/subgraph/scaffold/mapping.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePlaceholderHandlers = void 0;
+const generatePlaceholderHandlers = ({ entities, contract, }) => `
+import { ExampleEntity } from '../generated/schema'
+import {${entities.join(', ')}} from '../generated/subgraph-${contract}'
+import { EntityTrigger } from '@graphprotocol/graph-ts'
+
+${entities
+    .map(entityName => `
+export function handle${entityName}(entity: EntityTrigger<${entityName}>): void {
+  // Empty handler for ${entityName}
+}`)
+    .join('\n')}
+`;
+exports.generatePlaceholderHandlers = generatePlaceholderHandlers;

package/dist/protocols/subgraph/subgraph.d.ts

@@ -0,0 +1,10 @@
+import immutable from 'immutable';
+import { Subgraph, SubgraphOptions } from '../subgraph';
+export default class SubgraphDataSource implements Subgraph {
+    manifest: SubgraphOptions['manifest'];
+    resolveFile: SubgraphOptions['resolveFile'];
+    protocol: SubgraphOptions['protocol'];
+    constructor(options: SubgraphOptions);
+    validateManifest(): immutable.List<unknown>;
+    handlerTypes(): immutable.List<never>;
+}

package/dist/protocols/subgraph/subgraph.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const immutable_1 = __importDefault(require("immutable"));
+class SubgraphDataSource {
+    constructor(options) {
+        this.manifest = options.manifest;
+        this.resolveFile = options.resolveFile;
+        this.protocol = options.protocol;
+    }
+    validateManifest() {
+        return immutable_1.default.List();
+    }
+    handlerTypes() {
+        return immutable_1.default.List([]);
+    }
+}
+exports.default = SubgraphDataSource;

package/dist/scaffold/index.d.ts

@@ -11,6 +11,7 @@ export interface ScaffoldOptions {
     subgraphName?: string;
     node?: string;
     spkgPath?: string;
+    entities?: string[];
 }
 export default class Scaffold {
     protocol: Protocol;
@@ -23,6 +24,7 @@ export default class Scaffold {
     node?: string;
     startBlock?: string;
     spkgPath?: string;
+    entities?: string[];
     constructor(options: ScaffoldOptions);
     generatePackageJson(): Promise<string>;
     generatePackageJsonForSubstreams(): Promise<string>;

package/dist/scaffold/index.js

@@ -30,6 +30,7 @@ class Scaffold {
         this.startBlock = options.startBlock;
         this.node = options.node;
         this.spkgPath = options.spkgPath;
+        this.entities = options.entities;
     }
     async generatePackageJson() {
         return await prettier_1.default.format(JSON.stringify({

package/dist/schema.d.ts

@@ -1,10 +1,12 @@
 import type { DocumentNode } from 'graphql/language';
 import SchemaCodeGenerator from './codegen/schema';
 export default class Schema {
-    filename: string;
     document: string;
     ast: DocumentNode;
-    constructor(filename: string, document: string, ast: DocumentNode);
+    filename?: string | undefined;
+    constructor(document: string, ast: DocumentNode, filename?: string | undefined);
     codeGenerator(): SchemaCodeGenerator;
     static load(filename: string): Promise<Schema>;
+    static loadFromString(document: string): Promise<Schema>;
+    getEntityNames(): string[];
 }

package/dist/schema.js

@@ -30,11 +30,11 @@ const fs_extra_1 = __importDefault(require("fs-extra"));
 const graphql = __importStar(require("graphql/language"));
 const schema_1 = __importDefault(require("./codegen/schema"));
 class Schema {
-    constructor(filename, document, ast) {
-        this.filename = filename;
+    constructor(document, ast, filename) {
         this.document = document;
         this.ast = ast;
         this.filename = filename;
+        this.filename = filename;
         this.document = document;
         this.ast = ast;
     }
@@ -44,7 +44,22 @@ class Schema {
     static async load(filename) {
         const document = await fs_extra_1.default.readFile(filename, 'utf-8');
         const ast = graphql.parse(document);
-        return new Schema(filename, document, ast);
+        return new Schema(document, ast, filename);
+    }
+    static async loadFromString(document) {
+        try {
+            const ast = graphql.parse(document);
+            return new Schema(document, ast);
+        }
+        catch (e) {
+            throw new Error(`Failed to load schema from string: ${e.message}`);
+        }
+    }
+    getEntityNames() {
+        return this.ast.definitions
+            .filter(def => def.kind === 'ObjectTypeDefinition' &&
+            def.directives?.find(directive => directive.name.value === 'entity') !== undefined)
+            .map(entity => entity.name.value);
     }
 }
 exports.default = Schema;

package/dist/type-generator.d.ts

@@ -9,6 +9,8 @@ export interface TypeGeneratorOptions {
     skipMigrations?: boolean;
     uncrashable: boolean;
     uncrashableConfig: string;
+    subgraphSources: string[];
+    ipfsUrl: string;
 }
 export default class TypeGenerator {
     private sourceDir;
@@ -22,7 +24,14 @@ export default class TypeGenerator {
         quiet: boolean;
     }): Promise<any>;
     loadSchema(subgraph: immutable.Map<any, any>): Promise<any>;
-    generateTypesForSchema(schema: any): Promise<any>;
+    generateTypesForSchema({ schema, fileName, // Default file name
+    outputDir, // Default output directory
+    generateStoreMethods, }: {
+        schema: any;
+        fileName?: string;
+        outputDir?: string;
+        generateStoreMethods?: boolean;
+    }): Promise<any>;
     generateTypesForDataSourceTemplates(subgraph: immutable.Map<any, any>): Promise<any>;
     getFilesToWatch(): Promise<string[]>;
     watchAndGenerateTypes(): Promise<void>;

package/dist/type-generator.js

@@ -31,17 +31,21 @@ const fs_extra_1 = __importDefault(require("fs-extra"));
 const toolbox = __importStar(require("gluegun"));
 const graphql = __importStar(require("graphql/language"));
 const immutable_1 = __importDefault(require("immutable"));
+const ipfs_http_client_1 = require("ipfs-http-client");
 const prettier_1 = __importDefault(require("prettier"));
 // @ts-expect-error TODO: type out if necessary
 const Index_bs_js_1 = __importDefault(require("@float-capital/float-subgraph-uncrashable/src/Index.bs.js"));
 const template_1 = __importDefault(require("./codegen/template"));
 const typescript_1 = require("./codegen/typescript");
+const compiler_1 = require("./command-helpers/compiler");
 const fs_1 = require("./command-helpers/fs");
 const spinner_1 = require("./command-helpers/spinner");
+const constants_1 = require("./constants");
 const debug_1 = __importDefault(require("./debug"));
 const migrations_1 = require("./migrations");
 const schema_1 = __importDefault(require("./schema"));
 const subgraph_1 = __importDefault(require("./subgraph"));
+const utils_1 = __importDefault(require("./utils"));
 const watcher_1 = __importDefault(require("./watcher"));
 const typeGenDebug = (0, debug_1.default)('graph-cli:type-generator');
 class TypeGenerator {
@@ -66,6 +70,10 @@ class TypeGenerator {
             process.exit(0);
             return;
         }
+        if (this.options.subgraphSources.length > 0) {
+            typeGenDebug.extend('generateTypes')('Subgraph uses subgraph datasources.');
+            toolbox.print.success('Subgraph uses subgraph datasources.');
+        }
         try {
             if (!this.options.skipMigrations && this.options.subgraphManifest) {
                 await (0, migrations_1.applyMigrations)({
@@ -89,7 +97,25 @@ class TypeGenerator {
             }
             const schema = await this.loadSchema(subgraph);
             typeGenDebug.extend('generateTypes')('Generating types for schema');
-            await this.generateTypesForSchema(schema);
+            await this.generateTypesForSchema({ schema });
+            if (this.options.subgraphSources.length > 0) {
+                const ipfsClient = (0, ipfs_http_client_1.create)({
+                    url: (0, compiler_1.appendApiVersionForGraph)(this.options.ipfsUrl.toString()),
+                    headers: {
+                        ...constants_1.GRAPH_CLI_SHARED_HEADERS,
+                    },
+                });
+                await Promise.all(this.options.subgraphSources.map(async (manifest) => {
+                    const subgraphSchemaFile = await (0, utils_1.default)(ipfsClient, manifest);
+                    const subgraphSchema = await schema_1.default.loadFromString(subgraphSchemaFile);
+                    typeGenDebug.extend('generateTypes')(`Generating types for subgraph datasource ${manifest}`);
+                    await this.generateTypesForSchema({
+                        schema: subgraphSchema,
+                        fileName: `subgraph-${manifest}.ts`,
+                        generateStoreMethods: false,
+                    });
+                }));
+            }
             toolbox.print.success('\nTypes generated successfully\n');
             if (this.options.uncrashable && this.options.uncrashableConfig) {
                 await this.generateUncrashableEntities(schema);
@@ -132,19 +158,21 @@ class TypeGenerator {
             return schema_1.default.load(absolutePath);
         });
     }
-    async generateTypesForSchema(schema) {
+    async generateTypesForSchema({ schema, fileName = 'schema.ts', // Default file name
+    outputDir = this.options.outputDir, // Default output directory
+    generateStoreMethods = true, }) {
         return await (0, spinner_1.withSpinner)(`Generate types for GraphQL schema`, `Failed to generate types for GraphQL schema`, `Warnings while generating types for GraphQL schema`, async (spinner) => {
             // Generate TypeScript module from schema
             const codeGenerator = schema.codeGenerator();
             const code = await prettier_1.default.format([
                 typescript_1.GENERATED_FILE_NOTE,
                 ...codeGenerator.generateModuleImports(),
-                ...codeGenerator.generateTypes(),
+                ...codeGenerator.generateTypes(generateStoreMethods),
                 ...codeGenerator.generateDerivedLoaders(),
             ].join('\n'), {
                 parser: 'typescript',
             });
-            const outputFile = path_1.default.join(this.options.outputDir, 'schema.ts');
+            const outputFile = path_1.default.join(outputDir, fileName); // Use provided outputDir and fileName
             (0, spinner_1.step)(spinner, 'Write types to', (0, fs_1.displayPath)(outputFile));
             await fs_extra_1.default.mkdirs(path_1.default.dirname(outputFile));
             await fs_extra_1.default.writeFile(outputFile, code);

package/dist/utils.d.ts

@@ -0,0 +1 @@
+export default function loadSubgraphSchemaFromIPFS(ipfsClient: any, manifest: string): Promise<string>;

package/dist/utils.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const debug_1 = __importDefault(require("./debug"));
+const utilsDebug = (0, debug_1.default)('graph-cli:utils');
+async function loadSubgraphSchemaFromIPFS(ipfsClient, manifest) {
+    try {
+        const manifestBuffer = ipfsClient.cat(manifest);
+        let manifestFile = '';
+        for await (const chunk of manifestBuffer) {
+            manifestFile += Buffer.from(chunk).toString('utf8'); // Explicitly convert each chunk to UTF-8
+        }
+        const manifestYaml = js_yaml_1.default.safeLoad(manifestFile);
+        let schema = manifestYaml.schema.file['/'];
+        if (schema.startsWith('/ipfs/')) {
+            schema = schema.slice(6);
+        }
+        const schemaBuffer = ipfsClient.cat(schema);
+        let schemaFile = '';
+        for await (const chunk of schemaBuffer) {
+            schemaFile += Buffer.from(chunk).toString('utf8'); // Explicitly convert each chunk to UTF-8
+        }
+        return schemaFile;
+    }
+    catch (e) {
+        utilsDebug.extend('loadSubgraphSchemaFromIPFS')(`Failed to load schema from IPFS ${manifest}`);
+        utilsDebug.extend('loadSubgraphSchemaFromIPFS')(e);
+        throw Error(`Failed to load schema from IPFS ${manifest}`);
+    }
+}
+exports.default = loadSubgraphSchemaFromIPFS;

package/oclif.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.90.1",
+  "version": "0.91.0-alpha-20241202202221-345552f",
   "commands": {
     "add": {
       "id": "add",
@@ -239,6 +239,14 @@
           "summary": "Generate Float Subgraph Uncrashable helper file.",
           "allowNo": false
         },
+        "ipfs": {
+          "name": "ipfs",
+          "type": "option",
+          "char": "i",
+          "summary": "IPFS node to use for fetching subgraph data.",
+          "multiple": false,
+          "default": "https://api.thegraph.com/ipfs/api/v0"
+        },
         "uncrashable-config": {
           "name": "uncrashable-config",
           "type": "option",
@@ -453,7 +461,8 @@
             "ethereum",
             "near",
             "cosmos",
-            "substreams"
+            "substreams",
+            "subgraph"
           ]
         },
         "node": {
@@ -550,6 +559,14 @@
           "dependsOn": [
             "from-contract"
           ]
+        },
+        "ipfs": {
+          "name": "ipfs",
+          "type": "option",
+          "char": "i",
+          "summary": "IPFS node to use for fetching subgraph data.",
+          "multiple": false,
+          "default": "https://api.thegraph.com/ipfs/api/v0"
         }
       },
       "args": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphprotocol/graph-cli",
-  "version": "0.90.1",
+  "version": "0.91.0-alpha-20241202202221-345552f",
   "description": "CLI for building for and deploying to The Graph",
   "license": "(Apache-2.0 OR MIT)",
   "engines": {