@graphprotocol/graph-cli 0.37.3 → 0.37.4

package/src/subgraph.ts

@@ -1,302 +0,0 @@
-import path from 'path';
-import fs from 'fs-extra';
-import * as graphql from 'graphql/language';
-import immutable from 'immutable';
-import yaml from 'yaml';
-import { strOptions } from 'yaml/types';
-import debug from './debug';
-import { Subgraph as ISubgraph } from './protocols/subgraph';
-import * as validation from './validation';
-
-const subgraphDebug = debug('graph-cli:subgraph');
-
-const throwCombinedError = (filename: string, errors: immutable.List<any>) => {
-  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.relative(process.cwd(), filename)}:`,
-    ),
-  );
-};
-
-const buildCombinedWarning = (filename: string, warnings: immutable.List<any>) =>
-  warnings.size > 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.relative(process.cwd(), filename)}:`,
-      ) + '\n'
-    : null;
-
-type ResolveFile = (path: string) => string;
-
-export default class Subgraph {
-  static async validate(data: any, protocol: any, { resolveFile }: { resolveFile: ResolveFile }) {
-    subgraphDebug(`Validating Subgraph with protocol "%s"`, protocol);
-    if (protocol.name == null) {
-      return immutable.fromJS([
-        {
-          path: [],
-          message: `Unable to determine for which protocol manifest file is built for. Ensure you have at least one 'dataSources' and/or 'templates' elements defined in your subgraph.`,
-        },
-      ]);
-    }
-
-    // Parse the default subgraph schema
-    const schema = graphql.parse(
-      await fs.readFile(
-        path.join(__dirname, 'protocols', protocol.name, `manifest.graphql`),
-        'utf-8',
-      ),
-    );
-
-    // Obtain the root `SubgraphManifest` type from the schema
-    const rootType = schema.definitions.find(definition => {
-      // @ts-expect-error TODO: name field does not exist on definition, really?
-      return definition.name.value === 'SubgraphManifest';
-    });
-
-    // Validate the subgraph manifest using this schema
-    return validation.validateManifest(data, rootType, schema, protocol, { resolveFile });
-  }
-
-  static validateSchema(manifest: any, { resolveFile }: { resolveFile: ResolveFile }) {
-    const filename = resolveFile(manifest.getIn(['schema', 'file']));
-    const validationErrors = validation.validateSchema(filename);
-    let errors: immutable.Collection<any, any>;
-
-    if (validationErrors.size > 0) {
-      errors = validationErrors.groupBy(error => error.get('entity')).sort();
-      const msg = errors.reduce((msg, errors, entity) => {
-        errors = errors.groupBy((error: any) => error.get('directive'));
-        const inner_msgs = errors.reduce((msg: string, errors: any[], directive: string) => {
-          return `${msg}${
-            directive
-              ? `
-    ${directive}:`
-              : ''
-          }
-  ${errors
-    .map(error => error.get('message').split('\n').join('\n  '))
-    .map(msg => `${directive ? '  ' : ''}- ${msg}`)
-    .join('\n  ')}`;
-        }, ``);
-        return `${msg}
-
-  ${entity}:${inner_msgs}`;
-      }, `Error in ${path.relative(process.cwd(), filename)}:`);
-
-      throw new Error(msg);
-    }
-  }
-
-  static validateRepository(manifest: immutable.Collection<any, any>) {
-    const repository = manifest.get('repository');
-
-    return /^https:\/\/github\.com\/graphprotocol\/example-subgraphs?$/.test(repository)
-      ? immutable.List().push(
-          immutable.fromJS({
-            path: ['repository'],
-            message: `\
-The repository is still set to ${repository}.
-Please replace it with a link to your subgraph source code.`,
-          }),
-        )
-      : immutable.List();
-  }
-
-  static validateDescription(manifest: immutable.Collection<any, any>) {
-    // TODO: Maybe implement this in the future for each protocol example description
-    return manifest.get('description', '').startsWith('Gravatar for ')
-      ? immutable.List().push(
-          immutable.fromJS({
-            path: ['description'],
-            message: `\
-The description is still the one from the example subgraph.
-Please update it to tell users more about your subgraph.`,
-          }),
-        )
-      : immutable.List();
-  }
-
-  static validateHandlers(
-    manifest: immutable.Collection<any, any>,
-    protocol: any,
-    protocolSubgraph: ISubgraph,
-  ) {
-    return manifest
-      .get('dataSources')
-      .filter((dataSource: any) => protocol.isValidKindName(dataSource.get('kind')))
-      .reduce((errors: any, dataSource: any, dataSourceIndex: any) => {
-        const path = ['dataSources', dataSourceIndex, 'mapping'];
-        const mapping = dataSource.get('mapping');
-        const handlerTypes = protocolSubgraph.handlerTypes();
-
-        subgraphDebug(
-          'Validating dataSource "%s" handlers with %d handlers types defined for protocol',
-          dataSource.get('name'),
-          handlerTypes.size,
-        );
-
-        if (handlerTypes.size == 0) {
-          return errors;
-        }
-
-        const areAllHandlersEmpty = handlerTypes
-          .map((handlerType: any) => mapping.get(handlerType, immutable.List()))
-          .every((handlers: immutable.List<any>) => handlers.isEmpty());
-
-        const handlerNamesWithoutLast = handlerTypes.pop().join(', ');
-
-        return areAllHandlersEmpty
-          ? errors.push(
-              immutable.fromJS({
-                path,
-                message: `\
-Mapping has no ${handlerNamesWithoutLast} or ${handlerTypes.get(-1)}.
-At least one such handler must be defined.`,
-              }),
-            )
-          : errors;
-      }, immutable.List());
-  }
-
-  static validateContractValues(manifest: any, protocol: any) {
-    if (!protocol.hasContract()) {
-      return immutable.List();
-    }
-
-    return validation.validateContractValues(manifest, protocol);
-  }
-
-  // Validate that data source names are unique, so they don't overwrite each other.
-  static validateUniqueDataSourceNames(manifest: any) {
-    const names: any[] = [];
-    return manifest
-      .get('dataSources')
-      .reduce((errors: immutable.List<any>, dataSource: any, dataSourceIndex: number) => {
-        const path = ['dataSources', dataSourceIndex, 'name'];
-        const name = dataSource.get('name');
-        if (names.includes(name)) {
-          errors = errors.push(
-            immutable.fromJS({
-              path,
-              message: `\
-More than one data source named '${name}', data source names must be unique.`,
-            }),
-          );
-        }
-        names.push(name);
-        return errors;
-      }, immutable.List());
-  }
-
-  static validateUniqueTemplateNames(manifest: any) {
-    const names: any[] = [];
-    return manifest
-      .get('templates', immutable.List())
-      .reduce((errors: immutable.List<any>, template: any, templateIndex: number) => {
-        const path = ['templates', templateIndex, 'name'];
-        const name = template.get('name');
-        if (names.includes(name)) {
-          errors = errors.push(
-            immutable.fromJS({
-              path,
-              message: `\
-More than one template named '${name}', template names must be unique.`,
-            }),
-          );
-        }
-        names.push(name);
-        return errors;
-      }, immutable.List());
-  }
-
-  static dump(manifest: any) {
-    strOptions.fold.lineWidth = 90;
-    // @ts-expect-error TODO: plain is the value behind the TS constant
-    strOptions.defaultType = 'PLAIN';
-
-    return yaml.stringify(manifest.toJS());
-  }
-
-  static async load(
-    filename: string,
-    { protocol, skipValidation }: { protocol?: any; skipValidation?: boolean } = {
-      skipValidation: false,
-    },
-  ) {
-    // Load and validate the manifest
-    let data = null;
-    let has_file_data_sources = false;
-
-    if (filename.match(/.js$/)) {
-      data = require(path.resolve(filename));
-    } else {
-      const raw_data = await fs.readFile(filename, 'utf-8');
-      has_file_data_sources = raw_data.includes('kind: file');
-      data = yaml.parse(raw_data);
-    }
-
-    // Helper to resolve files relative to the subgraph manifest
-    const resolveFile: ResolveFile = maybeRelativeFile =>
-      path.resolve(path.dirname(filename), maybeRelativeFile);
-
-    // TODO: Validation for file data sources
-    if (!has_file_data_sources) {
-      const manifestErrors = await Subgraph.validate(data, protocol, { resolveFile });
-      if (manifestErrors.size > 0) {
-        throwCombinedError(filename, manifestErrors);
-      }
-    }
-
-    const manifest = immutable.fromJS(data) as immutable.Map<any, any>;
-
-    // Validate the schema
-    Subgraph.validateSchema(manifest, { resolveFile });
-
-    // Perform other validations
-    const protocolSubgraph = protocol.getSubgraph({
-      manifest,
-      resolveFile,
-    });
-
-    const errors = skipValidation
-      ? immutable.List()
-      : immutable.List.of(
-          ...protocolSubgraph.validateManifest(),
-          ...Subgraph.validateContractValues(manifest, protocol),
-          ...Subgraph.validateUniqueDataSourceNames(manifest),
-          ...Subgraph.validateUniqueTemplateNames(manifest),
-          ...Subgraph.validateHandlers(manifest, protocol, protocolSubgraph),
-        );
-
-    if (errors.size > 0) {
-      throwCombinedError(filename, errors);
-    }
-
-    // Perform warning validations
-    const warnings = skipValidation
-      ? immutable.List()
-      : immutable.List.of(
-          ...Subgraph.validateRepository(manifest),
-          ...Subgraph.validateDescription(manifest),
-        );
-
-    return {
-      result: manifest,
-      warning: warnings.size > 0 ? buildCombinedWarning(filename, warnings) : null,
-    };
-  }
-
-  static async write(manifest: any, filename: string) {
-    await fs.writeFile(filename, Subgraph.dump(manifest));
-  }
-}

package/src/type-generator.ts

@@ -1,266 +0,0 @@
-import path from 'path';
-// @ts-expect-error TODO: type out if necessary
-import uncrashable from '@float-capital/float-subgraph-uncrashable/src/Index.bs.js';
-import fs from 'fs-extra';
-import * as toolbox from 'gluegun';
-import * as graphql from 'graphql/language';
-import immutable from 'immutable';
-import prettier from 'prettier';
-import DataSourceTemplateCodeGenerator from './codegen/template';
-import { GENERATED_FILE_NOTE } from './codegen/typescript';
-import { displayPath } from './command-helpers/fs';
-import { Spinner, step, withSpinner } from './command-helpers/spinner';
-import { applyMigrations } from './migrations';
-import Protocol from './protocols';
-import Schema from './schema';
-import Subgraph from './subgraph';
-import Watcher from './watcher';
-
-export interface TypeGeneratorOptions {
-  sourceDir?: string;
-  subgraphManifest: string;
-  subgraph?: string;
-  protocol: Protocol;
-  outputDir: string;
-  skipMigrations?: boolean;
-  uncrashable: any;
-  uncrashableConfig: boolean;
-}
-
-export default class TypeGenerator {
-  private sourceDir: string;
-  private options: TypeGeneratorOptions;
-  private protocol: Protocol;
-  private protocolTypeGenerator: any;
-
-  constructor(options: TypeGeneratorOptions) {
-    this.options = options;
-    this.sourceDir =
-      this.options.sourceDir ||
-      (this.options.subgraphManifest && path.dirname(this.options.subgraphManifest));
-
-    this.protocol = this.options.protocol;
-    this.protocolTypeGenerator = this.protocol?.getTypeGenerator?.({
-      sourceDir: this.sourceDir,
-      outputDir: this.options.outputDir,
-    });
-
-    process.on('uncaughtException', e => {
-      toolbox.print.error(`UNCAUGHT EXCEPTION: ${e}`);
-    });
-  }
-
-  async generateTypes() {
-    try {
-      if (!this.options.skipMigrations && this.options.subgraphManifest) {
-        await applyMigrations({
-          sourceDir: this.sourceDir,
-          manifestFile: this.options.subgraphManifest,
-        });
-      }
-      const 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);
-      }
-
-      const 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: any) {
-    const ast = graphql.parse(graphSchema.document);
-    const entityDefinitions = ast['definitions'];
-    return await withSpinner(
-      `Generate Uncrashable Entity Helpers`,
-      `Failed to generate Uncrashable Entity Helpers`,
-      `Warnings while generating Uncrashable Entity Helpers`,
-      async spinner => {
-        uncrashable.run(entityDefinitions, this.options.uncrashableConfig, this.options.outputDir);
-        const outputFile = path.join(this.options.outputDir, 'UncrashableEntityHelpers.ts');
-        step(spinner, 'Save uncrashable entities to', displayPath(outputFile));
-      },
-    );
-  }
-
-  async loadSubgraph({ quiet } = { quiet: false }) {
-    const subgraphLoadOptions = { protocol: this.protocol, skipValidation: false };
-
-    if (quiet) {
-      return this.options.subgraph
-        ? this.options.subgraph
-        : (await Subgraph.load(this.options.subgraphManifest, subgraphLoadOptions)).result;
-    }
-    const manifestPath = displayPath(this.options.subgraphManifest);
-
-    return await 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.load(this.options.subgraphManifest, subgraphLoadOptions);
-      },
-    );
-  }
-
-  async loadSchema(subgraph: immutable.Map<any, any>) {
-    const maybeRelativePath = subgraph.getIn(['schema', 'file']) as string;
-    const absolutePath = path.resolve(this.sourceDir, maybeRelativePath);
-    return await withSpinner(
-      `Load GraphQL schema from ${displayPath(absolutePath)}`,
-      `Failed to load GraphQL schema from ${displayPath(absolutePath)}`,
-      `Warnings while loading GraphQL schema from ${displayPath(absolutePath)}`,
-      async _spinner => {
-        const absolutePath = path.resolve(this.sourceDir, maybeRelativePath);
-        return Schema.load(absolutePath);
-      },
-    );
-  }
-
-  async generateTypesForSchema(schema: any) {
-    return await 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 = prettier.format(
-          [
-            GENERATED_FILE_NOTE,
-            ...codeGenerator.generateModuleImports(),
-            ...codeGenerator.generateTypes(),
-          ].join('\n'),
-          {
-            parser: 'typescript',
-          },
-        );
-
-        const outputFile = path.join(this.options.outputDir, 'schema.ts');
-        step(spinner, 'Write types to', displayPath(outputFile));
-        await fs.mkdirs(path.dirname(outputFile));
-        await fs.writeFile(outputFile, code);
-      },
-    );
-  }
-
-  async generateTypesForDataSourceTemplates(subgraph: immutable.Map<any, any>) {
-    return await 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
-        const codeSegments = subgraph
-          .get('templates', immutable.List())
-          .reduce((codeSegments: any, template: any) => {
-            step(spinner, 'Generate types for data source template', String(template.get('name')));
-
-            const codeGenerator = new DataSourceTemplateCodeGenerator(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.List());
-
-        if (!codeSegments.isEmpty()) {
-          const code = prettier.format([GENERATED_FILE_NOTE, ...codeSegments].join('\n'), {
-            parser: 'typescript',
-          });
-
-          const outputFile = path.join(this.options.outputDir, 'templates.ts');
-          step(spinner, `Write types for templates to`, displayPath(outputFile));
-          await fs.mkdirs(path.dirname(outputFile));
-          await fs.writeFile(outputFile, code);
-        }
-      },
-    );
-  }
-
-  async getFilesToWatch() {
-    try {
-      const files = [];
-      const 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: any) => {
-        dataSource.getIn(['mapping', 'abis']).map((abi: any) => {
-          files.push(abi.get('file'));
-        });
-      });
-
-      // Make paths absolute
-      return files.map(file => path.resolve(file));
-    } catch (e) {
-      throw Error(`Failed to load subgraph: ${e.message}`);
-    }
-  }
-
-  async watchAndGenerateTypes() {
-    const generator = this;
-    let spinner: Spinner;
-
-    // Create watcher and generate types once and then on every change to a watched file
-    const watcher = new Watcher({
-      onReady: () => (spinner = toolbox.print.spin('Watching subgraph files')),
-      onTrigger: async changedFile => {
-        if (changedFile !== undefined) {
-          spinner.info(`File change detected: ${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(String(e.message));
-    }
-  }
-}

package/src/validation/contract.ts

@@ -1,51 +0,0 @@
-import immutable from 'immutable';
-import Protocol from '../protocols';
-import { ContractCtor } from '../protocols/contract';
-
-export const validateContract = (value: string, ProtocolContract: ContractCtor) => {
-  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 };
-};
-
-export const validateContractValues = (manifest: immutable.Map<any, any>, protocol: Protocol) => {
-  const ProtocolContract = protocol.getContract()!;
-
-  const fieldName = ProtocolContract.identifierName();
-
-  return manifest
-    .get('dataSources')
-    .filter((dataSource: any) => protocol.isValidKindName(dataSource.get('kind')))
-    .reduce((errors: any[], dataSource: any, dataSourceIndex: number) => {
-      const path = ['dataSources', dataSourceIndex, 'source', fieldName];
-
-      // No need to validate if the source has no contract field
-      if (!dataSource.get('source').has(fieldName)) {
-        return errors;
-      }
-
-      const contractValue = dataSource.getIn(['source', fieldName]);
-
-      const { valid, error } = validateContract(contractValue, ProtocolContract);
-
-      // Validate whether the contract is valid for the protocol
-      if (valid) {
-        return errors;
-      }
-      return errors.push(
-        immutable.fromJS({
-          path,
-          message: error,
-        }),
-      );
-    }, immutable.List());
-};

package/src/validation/index.ts

@@ -1,5 +0,0 @@
-import { validateContract, validateContractValues } from './contract';
-import { validateManifest } from './manifest';
-import { validateSchema } from './schema';
-
-export { validateContract, validateContractValues, validateManifest, validateSchema };