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

package/dist/type-generator.js

@@ -0,0 +1,224 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const immutable_1 = __importDefault(require("immutable"));
+const path_1 = __importDefault(require("path"));
+const prettier_1 = __importDefault(require("prettier"));
+const graphql = __importStar(require("graphql/language"));
+const chalk_1 = __importDefault(require("chalk"));
+const toolbox = __importStar(require("gluegun/toolbox"));
+const schema_1 = __importDefault(require("./schema"));
+const subgraph_1 = __importDefault(require("./subgraph"));
+const template_1 = __importDefault(require("./codegen/template"));
+const watcher_1 = __importDefault(require("./watcher"));
+const spinner_1 = require("./command-helpers/spinner");
+const migrations_1 = require("./migrations");
+const typescript_1 = require("./codegen/typescript");
+const fs_1 = require("./command-helpers/fs");
+const Index_bs_js_1 = __importDefault(require("@float-capital/float-subgraph-uncrashable/src/Index.bs.js"));
+class TypeGenerator {
+    constructor(options) {
+        this.options = options || {};
+        this.sourceDir =
+            this.options.sourceDir ||
+                (this.options.subgraphManifest && path_1.default.dirname(this.options.subgraphManifest));
+        this.protocol = this.options.protocol;
+        this.protocolTypeGenerator = this.protocol.getTypeGenerator({
+            sourceDir: this.sourceDir,
+            outputDir: this.options.outputDir,
+        });
+        process.on('uncaughtException', function (e) {
+            toolbox.print.error(`UNCAUGHT EXCEPTION: ${e}`);
+        });
+    }
+    async generateTypes() {
+        try {
+            if (!this.options.skipMigrations && this.options.subgraphManifest) {
+                await (0, migrations_1.applyMigrations)({
+                    sourceDir: this.sourceDir,
+                    manifestFile: this.options.subgraphManifest,
+                });
+            }
+            let subgraph = await this.loadSubgraph();
+            // Not all protocols support/have ABIs.
+            if (this.protocol.hasABIs()) {
+                const abis = await this.protocolTypeGenerator.loadABIs(subgraph);
+                await this.protocolTypeGenerator.generateTypesForABIs(abis);
+            }
+            await this.generateTypesForDataSourceTemplates(subgraph);
+            // Not all protocols support/have ABIs.
+            if (this.protocol.hasABIs()) {
+                const templateAbis = await this.protocolTypeGenerator.loadDataSourceTemplateABIs(subgraph);
+                await this.protocolTypeGenerator.generateTypesForDataSourceTemplateABIs(templateAbis);
+            }
+            let schema = await this.loadSchema(subgraph);
+            await this.generateTypesForSchema(schema);
+            toolbox.print.success('\nTypes generated successfully\n');
+            if (this.options.uncrashable && this.options.uncrashableConfig) {
+                await this.generateUncrashableEntities(schema);
+                toolbox.print.success('\nUncrashable Helpers generated successfully\n');
+            }
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    async generateUncrashableEntities(graphSchema) {
+        let ast = graphql.parse(graphSchema.document);
+        let entityDefinitions = ast['definitions'];
+        return await (0, spinner_1.withSpinner)(`Generate Uncrashable Entity Helpers`, `Failed to generate Uncrashable Entity Helpers`, `Warnings while generating Uncrashable Entity Helpers`, async (spinner) => {
+            Index_bs_js_1.default.run(entityDefinitions, this.options.uncrashableConfig, this.options.outputDir);
+            let outputFile = path_1.default.join(this.options.outputDir, 'UncrashableEntityHelpers.ts');
+            (0, spinner_1.step)(spinner, 'Save uncrashable entities to', (0, fs_1.displayPath)(outputFile));
+        });
+    }
+    async loadSubgraph({ quiet } = { quiet: false }) {
+        const subgraphLoadOptions = { protocol: this.protocol, skipValidation: false };
+        if (quiet) {
+            return this.options.subgraph
+                ? this.options.subgraph
+                : subgraph_1.default.load(this.options.subgraphManifest, subgraphLoadOptions).result;
+        }
+        else {
+            const manifestPath = (0, fs_1.displayPath)(this.options.subgraphManifest);
+            return await (0, spinner_1.withSpinner)(`Load subgraph from ${manifestPath}`, `Failed to load subgraph from ${manifestPath}`, `Warnings while loading subgraph from ${manifestPath}`, async (spinner) => {
+                return this.options.subgraph
+                    ? this.options.subgraph
+                    : subgraph_1.default.load(this.options.subgraphManifest, subgraphLoadOptions);
+            });
+        }
+    }
+    async loadSchema(subgraph) {
+        let maybeRelativePath = subgraph.getIn(['schema', 'file']);
+        let absolutePath = path_1.default.resolve(this.sourceDir, maybeRelativePath);
+        return await (0, spinner_1.withSpinner)(`Load GraphQL schema from ${(0, fs_1.displayPath)(absolutePath)}`, `Failed to load GraphQL schema from ${(0, fs_1.displayPath)(absolutePath)}`, `Warnings while loading GraphQL schema from ${(0, fs_1.displayPath)(absolutePath)}`, async (spinner) => {
+            let maybeRelativePath = subgraph.getIn(['schema', 'file']);
+            let absolutePath = path_1.default.resolve(this.sourceDir, maybeRelativePath);
+            return schema_1.default.load(absolutePath);
+        });
+    }
+    async generateTypesForSchema(schema) {
+        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
+            let codeGenerator = schema.codeGenerator();
+            let code = prettier_1.default.format([
+                typescript_1.GENERATED_FILE_NOTE,
+                ...codeGenerator.generateModuleImports(),
+                ...codeGenerator.generateTypes(),
+            ].join('\n'), {
+                parser: 'typescript',
+            });
+            let outputFile = path_1.default.join(this.options.outputDir, 'schema.ts');
+            (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);
+        });
+    }
+    async generateTypesForDataSourceTemplates(subgraph) {
+        return await (0, spinner_1.withSpinner)(`Generate types for data source templates`, `Failed to generate types for data source templates`, `Warnings while generating types for data source templates`, async (spinner) => {
+            // Combine the generated code for all templates
+            let codeSegments = subgraph
+                .get('templates', immutable_1.default.List())
+                .reduce((codeSegments, template) => {
+                (0, spinner_1.step)(spinner, 'Generate types for data source template', `${template.get('name')}`);
+                let codeGenerator = new template_1.default(template, this.protocol);
+                // Only generate module imports once, because they are identical for
+                // all types generated for data source templates.
+                if (codeSegments.isEmpty()) {
+                    codeSegments = codeSegments.concat(codeGenerator.generateModuleImports());
+                }
+                return codeSegments.concat(codeGenerator.generateTypes());
+            }, immutable_1.default.List());
+            if (!codeSegments.isEmpty()) {
+                let code = prettier_1.default.format([typescript_1.GENERATED_FILE_NOTE, ...codeSegments].join('\n'), {
+                    parser: 'typescript',
+                });
+                let outputFile = path_1.default.join(this.options.outputDir, 'templates.ts');
+                (0, spinner_1.step)(spinner, `Write types for templates 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);
+            }
+        });
+    }
+    async getFilesToWatch() {
+        try {
+            let files = [];
+            let subgraph = await this.loadSubgraph({ quiet: true });
+            // Add the subgraph manifest file
+            files.push(this.options.subgraphManifest);
+            // Add the GraphQL schema to the watched files
+            files.push(subgraph.getIn(['schema', 'file']));
+            // Add all file paths specified in manifest
+            subgraph.get('dataSources').map(dataSource => {
+                dataSource.getIn(['mapping', 'abis']).map(abi => {
+                    files.push(abi.get('file'));
+                });
+            });
+            // Make paths absolute
+            return files.map(file => path_1.default.resolve(file));
+        }
+        catch (e) {
+            throw Error(`Failed to load subgraph: ${e.message}`);
+        }
+    }
+    async watchAndGenerateTypes() {
+        let generator = this;
+        let spinner;
+        // Create watcher and generate types once and then on every change to a watched file
+        let watcher = new watcher_1.default({
+            onReady: () => (spinner = toolbox.print.spin('Watching subgraph files')),
+            onTrigger: async (changedFile) => {
+                if (changedFile !== undefined) {
+                    spinner.info(`File change detected: ${(0, fs_1.displayPath)(changedFile)}\n`);
+                }
+                await generator.generateTypes();
+                spinner.start();
+            },
+            onCollectFiles: async () => await generator.getFilesToWatch(),
+            onError: error => {
+                spinner.stop();
+                toolbox.print.error(`${error}\n`);
+                spinner.start();
+            },
+        });
+        // Catch keyboard interrupt: close watcher and exit process
+        process.on('SIGINT', () => {
+            watcher.close();
+            process.exit();
+        });
+        try {
+            await watcher.watch();
+        }
+        catch (e) {
+            toolbox.print.error(`${e.message}`);
+        }
+    }
+}
+exports.default = TypeGenerator;

package/dist/validation/contract.js

@@ -0,0 +1,46 @@
+"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();
+    if (!valid) {
+        return {
+            valid,
+            error: `Contract ${ProtocolContract.identifierName()} is invalid: ${value}\n${error}`,
+        };
+    }
+    return { valid, error };
+};
+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')))
+        .reduce((errors, dataSource, dataSourceIndex) => {
+        let path = ['dataSources', dataSourceIndex, 'source', fieldName];
+        // No need to validate if the source has no contract field
+        if (!dataSource.get('source').has(fieldName)) {
+            return errors;
+        }
+        let contractValue = dataSource.getIn(['source', fieldName]);
+        const { valid, error } = validateContract(contractValue, ProtocolContract);
+        // Validate whether the contract is valid for the protocol
+        if (valid) {
+            return errors;
+        }
+        else {
+            return errors.push(immutable_1.default.fromJS({
+                path,
+                message: error,
+            }));
+        }
+    }, immutable_1.default.List());
+};
+exports.validateContractValues = validateContractValues;

package/dist/validation/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    validateSchema: require('./schema').validateSchema,
+    validateManifest: require('./manifest').validateManifest,
+    validateContractValues: require('./contract').validateContractValues,
+    validateContract: require('./contract').validateContract,
+};

package/dist/validation/manifest.js

@@ -0,0 +1,271 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateManifest = void 0;
+const immutable_1 = __importDefault(require("immutable"));
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const path_1 = __importDefault(require("path"));
+const protocols_1 = __importDefault(require("../protocols"));
+const List = immutable_1.default.List;
+const Map = immutable_1.default.Map;
+/**
+ * Returns a user-friendly type name for a value.
+ */
+const typeName = value => List.isList(value) ? 'list' : Map.isMap(value) ? 'map' : typeof value;
+/**
+ * Converts an immutable or plain JavaScript value to a YAML string.
+ */
+const toYAML = x => js_yaml_1.default
+    .safeDump(typeName(x) === 'list' || typeName(x) === 'map' ? x.toJS() : x, {
+    indent: 2,
+})
+    .trim();
+/**
+ * Looks up the type of a field in a GraphQL object type.
+ */
+const getFieldType = (type, fieldName) => {
+    let fieldDef = type
+        .get('fields')
+        .find(field => field.getIn(['name', 'value']) === fieldName);
+    return fieldDef !== undefined ? fieldDef.get('type') : undefined;
+};
+/**
+ * Resolves a type in the GraphQL schema.
+ */
+const resolveType = (schema, type) => type.has('type')
+    ? resolveType(schema, type.get('type'))
+    : type.get('kind') === 'NamedType'
+        ? schema
+            .get('definitions')
+            .find(def => def.getIn(['name', 'value']) === type.getIn(['name', 'value']))
+        : 'resolveType: unimplemented';
+/**
+ * A map of supported validators.
+ */
+const validators = immutable_1.default.fromJS({
+    ScalarTypeDefinition: (value, ctx) => validators.get(ctx.getIn(['type', 'name', 'value']))(value, ctx),
+    UnionTypeDefinition: (value, ctx) => {
+        const unionVariants = ctx.getIn(['type', 'types']);
+        let errors = List();
+        for (const variantType of unionVariants) {
+            const variantErrors = validateValue(value, ctx.set('type', variantType));
+            // No errors found, union variant matched, early return
+            if (variantErrors.isEmpty()) {
+                return List();
+            }
+            errors = errors.push(variantErrors);
+        }
+        // Return errors from variant that matched the most
+        return List(errors.minBy(variantErrors => variantErrors.count()));
+    },
+    NamedType: (value, ctx) => validateValue(value, ctx.update('type', type => resolveType(ctx.get('schema'), type))),
+    NonNullType: (value, ctx) => value !== null && value !== undefined
+        ? validateValue(value, ctx.update('type', type => type.get('type')))
+        : immutable_1.default.fromJS([
+            {
+                path: ctx.get('path'),
+                message: `No value provided`,
+            },
+        ]),
+    ListType: (value, ctx) => List.isList(value)
+        ? value.reduce((errors, value, i) => errors.concat(validateValue(value, ctx
+            .update('path', path => path.push(i))
+            .update('type', type => type.get('type')))), List())
+        : immutable_1.default.fromJS([
+            {
+                path: ctx.get('path'),
+                message: `Expected list, found ${typeName(value)}:\n${toYAML(value)}`,
+            },
+        ]),
+    ObjectTypeDefinition: (value, ctx) => {
+        return Map.isMap(value)
+            ? ctx
+                .getIn(['type', 'fields'])
+                .map(fieldDef => fieldDef.getIn(['name', 'value']))
+                .concat(value.keySeq())
+                .toSet()
+                .reduce((errors, key) => getFieldType(ctx.get('type'), key)
+                ? errors.concat(validateValue(value.get(key), ctx
+                    .update('path', path => path.push(key))
+                    .set('type', getFieldType(ctx.get('type'), key))))
+                : errors.push(key == 'templates' && ctx.get('protocol').hasTemplates()
+                    ? immutable_1.default.fromJS({
+                        path: ctx.get('path'),
+                        message: `The way to declare data source templates has changed, ` +
+                            `please move the templates from inside data sources to ` +
+                            `a \`templates:\` field at the top level of the manifest.`,
+                    })
+                    : immutable_1.default.fromJS({
+                        path: ctx.get('path'),
+                        message: `Unexpected key in map: ${key}`,
+                    })), List())
+            : immutable_1.default.fromJS([
+                {
+                    path: ctx.get('path'),
+                    message: `Expected map, found ${typeName(value)}:\n${toYAML(value)}`,
+                },
+            ]);
+    },
+    EnumTypeDefinition: (value, ctx) => {
+        const enumValues = ctx.getIn(['type', 'values']).map(v => {
+            return v.getIn(['name', 'value']);
+        });
+        const allowedValues = enumValues.toArray().join(', ');
+        return enumValues.includes(value)
+            ? List()
+            : immutable_1.default.fromJS([
+                {
+                    path: ctx.get('path'),
+                    message: `Unexpected enum value: ${value}, allowed values: ${allowedValues}`,
+                },
+            ]);
+    },
+    String: (value, ctx) => typeof value === 'string'
+        ? List()
+        : immutable_1.default.fromJS([
+            {
+                path: ctx.get('path'),
+                message: `Expected string, found ${typeName(value)}:\n${toYAML(value)}`,
+            },
+        ]),
+    BigInt: (value, ctx) => typeof value === 'number'
+        ? List()
+        : immutable_1.default.fromJS([
+            {
+                path: ctx.get('path'),
+                message: `Expected BigInt, found ${typeName(value)}:\n${toYAML(value)}`,
+            },
+        ]),
+    File: (value, ctx) => typeof value === 'string'
+        ? require('fs').existsSync(ctx.get('resolveFile')(value))
+            ? List()
+            : immutable_1.default.fromJS([
+                {
+                    path: ctx.get('path'),
+                    message: `File does not exist: ${path_1.default.relative(process.cwd(), value)}`,
+                },
+            ])
+        : immutable_1.default.fromJS([
+            {
+                path: ctx.get('path'),
+                message: `Expected filename, found ${typeName(value)}:\n${value}`,
+            },
+        ]),
+    Boolean: (value, ctx) => typeof value === 'boolean'
+        ? List()
+        : immutable_1.default.fromJS([
+            {
+                path: ctx.get('path'),
+                message: `Expected true or false, found ${typeName(value)}:\n${toYAML(value)}`,
+            },
+        ]),
+});
+const validateValue = (value, ctx) => {
+    let kind = ctx.getIn(['type', 'kind']);
+    let validator = validators.get(kind);
+    if (validator !== undefined) {
+        // If the type is nullable, accept undefined and null; if the nullable
+        // type is wrapped in a `NonNullType`, the validator for that `NonNullType`
+        // will catch the missing/unset value
+        if (kind !== 'NonNullType' && (value === undefined || value === null)) {
+            return List();
+        }
+        else {
+            return validator(value, ctx);
+        }
+    }
+    else {
+        return immutable_1.default.fromJS([
+            {
+                path: ctx.get('path'),
+                message: `No validator for unsupported schema type: ${kind}`,
+            },
+        ]);
+    }
+};
+// Transforms list of data sources like this:
+// [
+//   { name: 'contract0', kind: 'ethereum/contract', network: 'mainnet' },
+//   { name: 'contract1', kind: 'ethereum', network: 'mainnet' },
+//   { name: 'contract2', kind: 'ethereum/contract', network: 'gnosis' },
+//   { name: 'contract3', kind: 'near', network: 'near-mainnet' },
+// ]
+//
+// Into Immutable JS structure like this (protocol kind is normalized):
+// {
+//   ethereum: {
+//     mainnet: ['contract0', 'contract1'],
+//     gnosis: ['contract2'],
+//   },
+//   near: {
+//     'near-mainnet': ['contract3'],
+//   },
+// }
+const dataSourceListToMap = dataSources => dataSources.reduce((protocolKinds, dataSource) => protocolKinds.update(protocols_1.default.normalizeName(dataSource.kind), networks => (networks || immutable_1.default.OrderedMap()).update(dataSource.network, dataSourceNames => (dataSourceNames || immutable_1.default.OrderedSet()).add(dataSource.name))), immutable_1.default.OrderedMap());
+const validateDataSourceProtocolAndNetworks = value => {
+    const dataSources = [...value.dataSources, ...(value.templates || [])];
+    const protocolNetworkMap = dataSourceListToMap(dataSources);
+    if (protocolNetworkMap.size > 1) {
+        return immutable_1.default.fromJS([
+            {
+                path: [],
+                message: `Conflicting protocol kinds used in data sources and templates:
+${protocolNetworkMap
+                    .map((dataSourceNames, protocolKind) => `  ${protocolKind === undefined
+                    ? 'Data sources and templates having no protocol kind set'
+                    : `Data sources and templates using '${protocolKind}'`}:\n${dataSourceNames
+                    .valueSeq()
+                    .flatten()
+                    .map(ds => `    - ${ds}`)
+                    .join('\n')}`)
+                    .join('\n')}
+Recommendation: Make all data sources and templates use the same protocol kind.`,
+            },
+        ]);
+    }
+    const networks = protocolNetworkMap.first();
+    if (networks.size > 1) {
+        return immutable_1.default.fromJS([
+            {
+                path: [],
+                message: `Conflicting networks used in data sources and templates:
+${networks
+                    .map((dataSources, network) => `  ${network === undefined
+                    ? 'Data sources and templates having no network set'
+                    : `Data sources and templates using '${network}'`}:\n${dataSources.map(ds => `    - ${ds}`).join('\n')}`)
+                    .join('\n')}
+Recommendation: Make all data sources and templates use the same network name.`,
+            },
+        ]);
+    }
+    return List();
+};
+const validateManifest = (value, type, schema, protocol, { resolveFile }) => {
+    // Validate manifest using the GraphQL schema that defines its structure
+    let errors = value !== null && value !== undefined
+        ? validateValue(immutable_1.default.fromJS(value), immutable_1.default.fromJS({
+            schema: schema,
+            type: type,
+            path: [],
+            errors: [],
+            resolveFile,
+            protocol,
+        }))
+        : immutable_1.default.fromJS([
+            {
+                path: [],
+                message: `Expected non-empty value, found ${typeName(value)}:\n  ${value}`,
+            },
+        ]);
+    // Fail early because a broken manifest prevents us from performing
+    // additional validation steps
+    if (!errors.isEmpty()) {
+        return errors;
+    }
+    // Validate that all data sources are for the same `network` and `protocol` (kind)
+    // (this includes _no_ network/protocol at all)
+    return validateDataSourceProtocolAndNetworks(value);
+};
+exports.validateManifest = validateManifest;