@graphprotocol/graph-cli 0.37.3 → 0.37.4-alpha-20230117095424-b5750b1

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 };

package/src/validation/manifest.ts

@@ -1,360 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import immutable from 'immutable';
-import yaml from 'js-yaml';
-import Protocol from '../protocols';
-
-const List = immutable.List;
-const Map = immutable.Map;
-
-/**
- * Returns a user-friendly type name for a value.
- */
-const typeName = (value: immutable.Collection<unknown, unknown>) =>
-  List.isList(value) ? 'list' : Map.isMap(value) ? 'map' : typeof value;
-
-/**
- * Converts an immutable or plain JavaScript value to a YAML string.
- */
-const toYAML = (x: immutable.Collection<unknown, unknown>) =>
-  yaml
-    .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: immutable.Map<any, any>, fieldName: string) => {
-  const fieldDef = type
-    .get('fields')
-    .find((field: any) => field.getIn(['name', 'value']) === fieldName);
-
-  return fieldDef !== undefined ? fieldDef.get('type') : undefined;
-};
-
-/**
- * Resolves a type in the GraphQL schema.
- */
-const resolveType = (schema: immutable.Map<any, any>, type: immutable.Map<any, any>): any =>
-  type.has('type')
-    ? resolveType(schema, type.get('type'))
-    : type.get('kind') === 'NamedType'
-    ? schema
-        .get('definitions')
-        .find((def: any) => def.getIn(['name', 'value']) === type.getIn(['name', 'value']))
-    : 'resolveType: unimplemented';
-
-/**
- * A map of supported validators.
- */
-const validators = immutable.fromJS({
-  ScalarTypeDefinition: (value: any, ctx: immutable.Map<any, any>) =>
-    (validators.get(ctx.getIn(['type', 'name', 'value'])) as any)(value, ctx),
-
-  UnionTypeDefinition: (value: any, ctx: immutable.Map<any, any>) => {
-    const unionVariants = ctx.getIn(['type', 'types']) as any[];
-
-    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: any) => variantErrors.count()) as any);
-  },
-
-  NamedType: (value: any, ctx: immutable.Map<any, any>) =>
-    validateValue(
-      value,
-      ctx.update('type', type => resolveType(ctx.get('schema'), type)),
-    ),
-
-  NonNullType: (value: any, ctx: immutable.Map<any, any>) =>
-    value !== null && value !== undefined
-      ? validateValue(
-          value,
-          ctx.update('type', type => type.get('type')),
-        )
-      : immutable.fromJS([
-          {
-            path: ctx.get('path'),
-            message: `No value provided`,
-          },
-        ]),
-
-  ListType: (value: any, ctx: immutable.Map<any, any>) =>
-    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.fromJS([
-          {
-            path: ctx.get('path'),
-            message: `Expected list, found ${typeName(value)}:\n${toYAML(value)}`,
-          },
-        ]),
-
-  ObjectTypeDefinition: (value: any, ctx: any) => {
-    return Map.isMap(value)
-      ? ctx
-          .getIn(['type', 'fields'])
-          .map((fieldDef: any) => fieldDef.getIn(['name', 'value']))
-          .concat(value.keySeq())
-          .toSet()
-          .reduce(
-            (errors: any[], key: string) =>
-              getFieldType(ctx.get('type'), key)
-                ? errors.concat(
-                    validateValue(
-                      value.get(key),
-                      ctx
-                        .update('path', (path: string[]) => path.push(key))
-                        .set('type', getFieldType(ctx.get('type'), key)),
-                    ),
-                  )
-                : errors.push(
-                    key == 'templates' && ctx.get('protocol').hasTemplates()
-                      ? immutable.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.fromJS({
-                          path: ctx.get('path'),
-                          message: `Unexpected key in map: ${key}`,
-                        }),
-                  ),
-            List(),
-          )
-      : immutable.fromJS([
-          {
-            path: ctx.get('path'),
-            message: `Expected map, found ${typeName(value)}:\n${toYAML(value)}`,
-          },
-        ]);
-  },
-
-  EnumTypeDefinition: (value: any, ctx: immutable.Map<any, any>) => {
-    const enumValues = (ctx.getIn(['type', 'values']) as any).map((v: any) => {
-      return v.getIn(['name', 'value']);
-    });
-
-    const allowedValues = enumValues.toArray().join(', ');
-
-    return enumValues.includes(value)
-      ? List()
-      : immutable.fromJS([
-          {
-            path: ctx.get('path'),
-            message: `Unexpected enum value: ${value}, allowed values: ${allowedValues}`,
-          },
-        ]);
-  },
-
-  String: (value: any, ctx: immutable.Map<any, any>) =>
-    typeof value === 'string'
-      ? List()
-      : immutable.fromJS([
-          {
-            path: ctx.get('path'),
-            message: `Expected string, found ${typeName(value)}:\n${toYAML(value)}`,
-          },
-        ]),
-
-  BigInt: (value: any, ctx: immutable.Map<any, any>) =>
-    typeof value === 'number'
-      ? List()
-      : immutable.fromJS([
-          {
-            path: ctx.get('path'),
-            message: `Expected BigInt, found ${typeName(value)}:\n${toYAML(value)}`,
-          },
-        ]),
-
-  File: (value: any, ctx: immutable.Map<any, any>) =>
-    typeof value === 'string'
-      ? fs.existsSync(ctx.get('resolveFile')(value))
-        ? List()
-        : immutable.fromJS([
-            {
-              path: ctx.get('path'),
-              message: `File does not exist: ${path.relative(process.cwd(), value)}`,
-            },
-          ])
-      : immutable.fromJS([
-          {
-            path: ctx.get('path'),
-            message: `Expected filename, found ${typeName(value)}:\n${value}`,
-          },
-        ]),
-
-  Boolean: (value: any, ctx: immutable.Map<any, any>) =>
-    typeof value === 'boolean'
-      ? List()
-      : immutable.fromJS([
-          {
-            path: ctx.get('path'),
-            message: `Expected true or false, found ${typeName(value)}:\n${toYAML(value)}`,
-          },
-        ]),
-});
-
-const validateValue = (value: any, ctx: immutable.Collection<any, any>) => {
-  const kind = ctx.getIn(['type', 'kind']);
-  const validator = validators.get(kind) as any;
-
-  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();
-    }
-    return validator(value, ctx);
-  }
-  return immutable.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: any[]) =>
-  dataSources.reduce(
-    (protocolKinds, dataSource) =>
-      protocolKinds.update(Protocol.normalizeName(dataSource.kind), (networks: any) =>
-        (networks || immutable.OrderedMap()).update(dataSource.network, (dataSourceNames: any) =>
-          (dataSourceNames || immutable.OrderedSet()).add(dataSource.name),
-        ),
-      ),
-    immutable.OrderedMap(),
-  );
-
-const validateDataSourceProtocolAndNetworks = (value: any) => {
-  const dataSources = [...value.dataSources, ...(value.templates || [])];
-
-  const protocolNetworkMap = dataSourceListToMap(dataSources);
-
-  if (protocolNetworkMap.size > 1) {
-    return immutable.fromJS([
-      {
-        path: [],
-        message: `Conflicting protocol kinds used in data sources and templates:
-${protocolNetworkMap
-  .map(
-    (dataSourceNames: any, protocolKind: string | undefined) =>
-      `  ${
-        protocolKind === undefined
-          ? 'Data sources and templates having no protocol kind set'
-          : `Data sources and templates using '${protocolKind}'`
-      }:\n${dataSourceNames
-        .valueSeq()
-        .flatten()
-        .map((ds: string) => `    - ${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.fromJS([
-      {
-        path: [],
-        message: `Conflicting networks used in data sources and templates:
-${networks
-  .map(
-    (dataSources: any, network: string | undefined) =>
-      `  ${
-        network === undefined
-          ? 'Data sources and templates having no network set'
-          : `Data sources and templates using '${network}'`
-      }:\n${dataSources.map((ds: string) => `    - ${ds}`).join('\n')}`,
-  )
-  .join('\n')}
-Recommendation: Make all data sources and templates use the same network name.`,
-      },
-    ]);
-  }
-
-  return List();
-};
-
-export const validateManifest = (
-  value: any,
-  type: any,
-  schema: any,
-  protocol: Protocol,
-  { resolveFile }: { resolveFile: (path: string) => string },
-) => {
-  // Validate manifest using the GraphQL schema that defines its structure
-  const errors =
-    value !== null && value !== undefined
-      ? validateValue(
-          immutable.fromJS(value),
-          immutable.fromJS({
-            schema,
-            type,
-            path: [],
-            errors: [],
-            resolveFile,
-            protocol,
-          }),
-        )
-      : immutable.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);
-};