@graphprotocol/graph-cli 0.79.0-alpha-20241010142217-5c831cf → 0.79.0-alpha-20241030130848-e62b29d

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # @graphprotocol/graph-cli
 
-## 0.79.0-alpha-20241010142217-5c831cf
+## 0.79.0-alpha-20241030130848-e62b29d
 
 ### Minor Changes
 

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: 'Upload build results to an IPFS node.',
+        char: 'i',
+        default: ipfs_1.DEFAULT_IPFS_URL,
+    }),
     'uncrashable-config': core_1.Flags.file({
         summary: 'Directory for uncrashable config.',
         aliases: ['uc'],

package/dist/compiler/index.js

@@ -70,7 +70,7 @@ class Compiler {
             return fs_extra_1.default.existsSync(path_1.default.join(item, globalsFile));
         });
         if (!globalsLib) {
-            throw Error('Could not locate `@graphprotocol/graph-ts` package in parent directories of subgraph manifest.');
+            throw Error(`Could not locate @graphprotocol/graph-ts package in parent directories of subgraph manifest. ${this.libsDirs}`);
         }
         this.globalsFile = path_1.default.join(globalsLib, globalsFile);
         process.on('uncaughtException', e => {

package/dist/schema.d.ts

@@ -7,4 +7,5 @@ export default class Schema {
     constructor(filename: string, document: string, ast: DocumentNode);
     codeGenerator(): SchemaCodeGenerator;
     static load(filename: string): Promise<Schema>;
+    static loadFromString(filename: string, document: string): Promise<Schema>;
 }

package/dist/schema.js

@@ -29,6 +29,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const graphql = __importStar(require("graphql/language"));
 const schema_1 = __importDefault(require("./codegen/schema"));
+const debug_1 = __importDefault(require("./debug"));
+const schemaDebug = (0, debug_1.default)('graph-cli:type-generator');
 class Schema {
     constructor(filename, document, ast) {
         this.filename = filename;
@@ -46,5 +48,16 @@ class Schema {
         const ast = graphql.parse(document);
         return new Schema(filename, document, ast);
     }
+    static async loadFromString(filename, document) {
+        try {
+            const ast = graphql.parse(document);
+            schemaDebug('Loaded schema from string');
+            return new Schema(filename, document, ast);
+        }
+        catch (e) {
+            schemaDebug('Failed to load schema from string: %s', e.message);
+            throw new Error(`Failed to load schema from string: ${e.message}`);
+        }
+    }
 }
 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;
@@ -17,12 +19,14 @@ export default class TypeGenerator {
     private protocolTypeGenerator;
     constructor(options: TypeGeneratorOptions);
     generateTypes(): Promise<boolean | undefined>;
+    loadSubgraphSchemaFromIPFS(ipfsClient: any, manifest: string): Promise<string>;
     generateUncrashableEntities(graphSchema: any): Promise<any>;
     loadSubgraph({ quiet }?: {
         quiet: boolean;
     }): Promise<any>;
     loadSchema(subgraph: immutable.Map<any, any>): Promise<any>;
-    generateTypesForSchema(schema: any): Promise<any>;
+    generateTypesForSchema(schema: any, fileName?: string, // Default file name
+    outputDir?: string): Promise<any>;
     generateTypesForDataSourceTemplates(subgraph: immutable.Map<any, any>): Promise<any>;
     getFilesToWatch(): Promise<string[]>;
     watchAndGenerateTypes(): Promise<void>;

package/dist/type-generator.js

@@ -31,13 +31,17 @@ 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 js_yaml_1 = __importDefault(require("js-yaml"));
 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"));
@@ -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)({
@@ -90,6 +98,20 @@ class TypeGenerator {
             const schema = await this.loadSchema(subgraph);
             typeGenDebug.extend('generateTypes')('Generating types for 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 this.loadSubgraphSchemaFromIPFS(ipfsClient, manifest);
+                    const subgraphSchema = await schema_1.default.loadFromString(`js${manifest}.graphql`, subgraphSchemaFile);
+                    typeGenDebug.extend('generateTypes')(`Generating types for subgraph datasource ${manifest}`);
+                    await this.generateTypesForSchema(subgraphSchema, `subgraph-${manifest}.ts`);
+                }));
+            }
             toolbox.print.success('\nTypes generated successfully\n');
             if (this.options.uncrashable && this.options.uncrashableConfig) {
                 await this.generateUncrashableEntities(schema);
@@ -101,6 +123,32 @@ class TypeGenerator {
             return false;
         }
     }
+    async loadSubgraphSchemaFromIPFS(ipfsClient, manifest) {
+        typeGenDebug.extend('loadSubgraphSchemaFromIPFS')(`Loading schema from IPFS ${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) {
+            typeGenDebug.extend('loadSubgraphSchemaFromIPFS')(`Failed to load schema from IPFS ${manifest}`);
+            typeGenDebug.extend('loadSubgraphSchemaFromIPFS')(e);
+            throw Error(`Failed to load schema from IPFS ${manifest}`);
+        }
+    }
     async generateUncrashableEntities(graphSchema) {
         const ast = graphql.parse(graphSchema.document);
         const entityDefinitions = ast['definitions'];
@@ -132,7 +180,8 @@ class TypeGenerator {
             return schema_1.default.load(absolutePath);
         });
     }
-    async generateTypesForSchema(schema) {
+    async generateTypesForSchema(schema, fileName = 'schema.ts', // Default file name
+    outputDir = this.options.outputDir) {
         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();
@@ -144,7 +193,7 @@ class TypeGenerator {
             ].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/oclif.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.79.0-alpha-20241010142217-5c831cf",
+  "version": "0.79.0-alpha-20241030130848-e62b29d",
   "commands": {
     "add": {
       "id": "add",
@@ -267,6 +267,14 @@
           "summary": "Generate Float Subgraph Uncrashable helper file.",
           "allowNo": false
         },
+        "ipfs": {
+          "name": "ipfs",
+          "type": "option",
+          "char": "i",
+          "summary": "Upload build results to an IPFS node.",
+          "multiple": false,
+          "default": "https://api.thegraph.com/ipfs/api/v0"
+        },
         "uncrashable-config": {
           "name": "uncrashable-config",
           "type": "option",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphprotocol/graph-cli",
-  "version": "0.79.0-alpha-20241010142217-5c831cf",
+  "version": "0.79.0-alpha-20241030130848-e62b29d",
   "description": "CLI for building for and deploying to The Graph",
   "license": "(Apache-2.0 OR MIT)",
   "engines": {