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

package/src/scaffold/schema.ts

@@ -1,89 +0,0 @@
-import immutable from 'immutable';
-import { ascTypeForProtocol, valueTypeForAsc } from '../codegen/types';
-import * as util from '../codegen/util';
-import Protocol from '../protocols';
-
-export function abiEvents(abi: { data: immutable.Collection<any, any> }) {
-  return util.disambiguateNames({
-    // @ts-expect-error improve typings of disambiguateNames to handle iterables
-    values: abi.data.filter(item => item.get('type') === 'event'),
-    // @ts-expect-error improve typings of disambiguateNames to handle iterables
-    getName: event => event.get('name'),
-    // @ts-expect-error improve typings of disambiguateNames to handle iterables
-    setName: (event, name) => event.set('_alias', name),
-  }) as unknown as immutable.List<any>;
-}
-
-export const protocolTypeToGraphQL = (protocol: string, name: string) => {
-  const ascType = ascTypeForProtocol(protocol, name);
-  return valueTypeForAsc(ascType);
-};
-
-export const generateField = ({
-  name,
-  type,
-  protocolName,
-}: {
-  name: string;
-  type: string;
-  protocolName: string;
-}) => `${name}: ${protocolTypeToGraphQL(protocolName, type)}! # ${type}`;
-
-export const generateEventFields = ({
-  index,
-  input,
-  protocolName,
-}: {
-  index: number;
-  input: any;
-  protocolName: string;
-}) =>
-  input.type == 'tuple'
-    ? util
-        .unrollTuple({ value: input, path: [input.name || `param${index}`], index })
-        .map(({ path, type }: any) => generateField({ name: path.join('_'), type, protocolName }))
-    : [
-        generateField({
-          name: input.name || `param${index}`,
-          type: input.type,
-          protocolName,
-        }),
-      ];
-
-export const generateEventType = (event: any, protocolName: string) => `type ${
-  event._alias
-} @entity(immutable: true) {
-      id: Bytes!
-      ${event.inputs
-        .reduce(
-          (acc: any[], input: any, index: number) =>
-            acc.concat(generateEventFields({ input, index, protocolName })),
-          [],
-        )
-        .join('\n')}
-      blockNumber: BigInt!
-      blockTimestamp: BigInt!
-      transactionHash: Bytes!
-    }`;
-
-export const generateExampleEntityType = (protocol: Protocol, events: any[]) => {
-  if (protocol.hasABIs() && events.length > 0) {
-    return `type ExampleEntity @entity {
-  id: Bytes!
-  count: BigInt!
-  ${events[0].inputs
-    .reduce(
-      (acc: any[], input: any, index: number) =>
-        acc.concat(generateEventFields({ input, index, protocolName: protocol.name })),
-      [],
-    )
-    .slice(0, 2)
-    .join('\n')}
-}`;
-  }
-  return `type ExampleEntity @entity {
-  id: ID!
-  block: Bytes!
-  count: BigInt!
-}`;
-};

package/src/scaffold/tests.ts

@@ -1,217 +0,0 @@
-import { strings } from 'gluegun';
-import prettier from 'prettier';
-import { ascTypeForEthereum, ethereumFromAsc } from '../codegen/types';
-
-const VARIABLES_VALUES = {
-  i32: 123,
-  BigInt: 234,
-  Bytes: 1_234_567_890,
-  Address: '0x0000000000000000000000000000000000000001',
-  string: 'Example string value',
-  bool: true,
-};
-
-export const generateTestsFiles = (contract: any, events: any[], indexEvents?: boolean) => {
-  const eventsTypes = events
-    .flatMap(event =>
-      event.inputs.map((input: any) => {
-        // If the asc type is Array<T> we need to check if T is a native type or a custom graph-ts type
-        // If we don't do that we may miss a type that should be imported from graph-ts
-        const ascType = ascTypeForEthereum(input.type);
-        const inner = fetchArrayInnerType(String(ascType));
-        return inner ? inner[1] : ascType;
-      }),
-    )
-    .filter(type => !type.startsWith('ethereum.') && !isNativeType(type));
-  const importTypes = [...new Set(eventsTypes)].join(', ');
-
-  return {
-    [`${strings.kebabCase(contract)}.test.ts`]: prettier.format(
-      generateExampleTest(contract, events[0], indexEvents, importTypes),
-      { parser: 'typescript', semi: false },
-    ),
-    [`${strings.kebabCase(contract)}-utils.ts`]: prettier.format(
-      generateTestHelper(contract, events, importTypes),
-      { parser: 'typescript', semi: false },
-    ),
-  };
-};
-
-/*
-  Generates the arguments that will be passed to the mock event function from the event inputs. Example:
-  let id = BigInt.fromI32(234)
-  let owner = Address.fromString("0x0000000000000000000000000000000000000001")
-  let displayName = "Example string value"
-  let imageUrl = "Example string value"
-*/
-const generateArguments = (eventInputs: any[]) => {
-  return eventInputs
-    .map((input, index) => {
-      const ascType = ascTypeForEthereum(input.type);
-      return `let ${input.name || `param${index}`} = ${assignValue(ascType)}`;
-    })
-    .join('\n');
-};
-
-// Generates the value that will be assigned to a variable in generateArguments()
-const assignValue = (type: string): string | number | boolean => {
-  switch (type) {
-    case 'string':
-      return `"${VARIABLES_VALUES[type]}"`;
-    case 'BigInt':
-      return `BigInt.fromI32(${VARIABLES_VALUES[type]})`;
-    case 'Address':
-      return `Address.fromString("${VARIABLES_VALUES[type]}")`;
-    case 'Bytes':
-      return `Bytes.fromI32(${VARIABLES_VALUES[type]})`;
-    case fetchArrayInnerType(type)?.input: {
-      const innerType = fetchArrayInnerType(type)![1];
-      return `[${assignValue(innerType)}]`;
-    }
-    default: {
-      const value = VARIABLES_VALUES[type as keyof typeof VARIABLES_VALUES];
-      return value ? value : `"${type} Not implemented"`;
-    }
-  }
-};
-
-/*
-  Generates the assert.fieldEquals() for a given entity and event inputs. Example:
-  assert.fieldEquals(
-    "ExampleEntity",
-    "0xa16081f360e3847006db660bae1c6d1b2e17ec2a",
-    "owner",
-    "0x0000000000000000000000000000000000000001"
-  )
-*/
-const generateFieldsAssertions = (entity: string, eventInputs: any[], indexEvents?: boolean) =>
-  eventInputs
-    .filter(input => input.name != 'id')
-    .map(
-      (input, index) =>
-        `assert.fieldEquals(
-    "${entity}",
-    "0xa16081f360e3847006db660bae1c6d1b2e17ec2a${indexEvents ? '-1' : ''}",
-    "${input.name || `param${index}`}",
-    "${expectedValue(ascTypeForEthereum(input.type))}"
-  )`,
-    )
-    .join('\n');
-
-// Returns the expected value for a given type in generateFieldsAssertions()
-const expectedValue = (type: string): string | number | boolean => {
-  switch (type) {
-    case fetchArrayInnerType(type)?.input: {
-      const innerType = fetchArrayInnerType(type)![1];
-      return `[${expectedValue(innerType)}]`;
-    }
-    default: {
-      const value = VARIABLES_VALUES[type as keyof typeof VARIABLES_VALUES];
-      return value ? value : `${type} Not implemented`;
-    }
-  }
-};
-
-// Checks if the type is a native AS type or should be imported from graph-ts
-const isNativeType = (type: string) => {
-  const natives = [/i32/, /string/, /boolean/];
-
-  return natives.some(rx => rx.test(type));
-};
-
-const fetchArrayInnerType = (type: string) => type.match(/Array<(.*?)>/);
-
-// Generates the example test.ts file
-const generateExampleTest = (
-  contract: string,
-  event: any,
-  indexEvents?: boolean,
-  importTypes?: string,
-) => {
-  const entity = indexEvents ? String(event._alias) : 'ExampleEntity';
-  const eventInputs = event.inputs;
-  const eventName = event._alias;
-
-  return `
-  import { assert, describe, test, clearStore, beforeAll, afterAll } from "matchstick-as/assembly/index"
-  import { ${importTypes} } from "@graphprotocol/graph-ts"
-  import { ${entity} } from "../generated/schema"
-  import { ${
-    indexEvents ? `${eventName} as ${eventName}Event` : eventName
-  } } from "../generated/${contract}/${contract}"
-  import { handle${eventName} } from "../src/${strings.kebabCase(contract)}"
-  import { create${eventName}Event } from "./${strings.kebabCase(contract)}-utils"
-
-
-  // Tests structure (matchstick-as >=0.5.0)
-  // https://thegraph.com/docs/en/developer/matchstick/#tests-structure-0-5-0
-
-  describe("Describe entity assertions", () => {
-    beforeAll(() => {
-      ${generateArguments(eventInputs)}
-      let new${eventName}Event = create${eventName}Event(${eventInputs
-    .map((input: any, index: number) => input.name || `param${index}`)
-    .join(', ')});
-      handle${eventName}(new${eventName}Event)
-    })
-
-    afterAll(() => {
-      clearStore()
-    })
-
-    // For more test scenarios, see:
-    // https://thegraph.com/docs/en/developer/matchstick/#write-a-unit-test
-
-    test("${entity} created and stored", () => {
-      assert.entityCount('${entity}', 1)
-
-      // 0xa16081f360e3847006db660bae1c6d1b2e17ec2a is the default address used in newMockEvent() function
-      ${generateFieldsAssertions(entity, eventInputs, indexEvents)}
-
-      // More assert options:
-      // https://thegraph.com/docs/en/developer/matchstick/#asserts
-    })
-  })
-`;
-};
-
-// Generates the utils helper file
-const generateTestHelper = (contract: string, events: any[], importTypes: string) => {
-  const eventsNames = events.map(event => event._alias);
-
-  return `
-  import { newMockEvent } from 'matchstick-as';
-  import { ethereum, ${importTypes} } from '@graphprotocol/graph-ts';
-  import { ${eventsNames.join(', ')} } from '../generated/${contract}/${contract}';
-
-  ${generateMockedEvents(events).join('\n')}`;
-};
-
-const generateMockedEvents = (events: any[]) =>
-  events.reduce((acc, event) => acc.concat(generateMockedEvent(event)), []);
-
-const generateMockedEvent = (event: any) => {
-  const varName = `${strings.camelCase(event._alias)}Event`;
-  const fnArgs = event.inputs.map(
-    (input: any, index: number) =>
-      `${input.name || `param${index}`}: ${ascTypeForEthereum(input.type)}`,
-  );
-  const ascToEth = event.inputs.map(
-    (input: any, index: number) =>
-      `${varName}.parameters.push(new ethereum.EventParam("${
-        input.name || `param${index}`
-      }", ${ethereumFromAsc(input.name || `param${index}`, input.type)}))`,
-  );
-
-  return `
-    export function create${event._alias}Event(${fnArgs.join(', ')}): ${event._alias} {
-      let ${varName} = changetype<${event._alias}>(newMockEvent());
-
-      ${varName}.parameters = new Array();
-
-      ${ascToEth.join('\n')}
-
-      return ${varName};
-    }
-  `;
-};

package/src/schema.ts

@@ -1,26 +0,0 @@
-import fs from 'fs-extra';
-import * as graphql from 'graphql/language';
-import immutable from 'immutable';
-import SchemaCodeGenerator from './codegen/schema';
-
-export default class Schema {
-  constructor(
-    public filename: string,
-    public document: string,
-    public ast: immutable.Collection<any, any>,
-  ) {
-    this.filename = filename;
-    this.document = document;
-    this.ast = ast;
-  }
-
-  codeGenerator() {
-    return new SchemaCodeGenerator(this);
-  }
-
-  static async load(filename: string) {
-    const document = await fs.readFile(filename, 'utf-8');
-    const ast = graphql.parse(document);
-    return new Schema(filename, document, immutable.fromJS(ast));
-  }
-}

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