@graphprotocol/graph-cli 0.37.3 → 0.37.4

package/src/scaffold/mapping.ts

@@ -1,44 +0,0 @@
-import * as util from '../codegen/util';
-
-export const generateFieldAssignment = (path: string[]) =>
-  `entity.${path.join('_')} = event.params.${path.join('.')}`;
-
-export const generateFieldAssignments = ({ index, input }: { index: number; input: any }) =>
-  input.type === 'tuple'
-    ? util
-        .unrollTuple({ value: input, index, path: [input.name || `param${index}`] })
-        .map(({ path }: any) => generateFieldAssignment(path))
-    : generateFieldAssignment([input.name || `param${index}`]);
-
-export const generateEventFieldAssignments = (event: any) =>
-  event.inputs.reduce(
-    (acc: any[], input: any, index: number) =>
-      acc.concat(generateFieldAssignments({ input, index })),
-    [],
-  );
-
-export const generateEventIndexingHandlers = (events: any[], contractName: string) =>
-  `
-  import { ${events.map(
-    event => `${event._alias} as ${event._alias}Event`,
-  )}} from '../generated/${contractName}/${contractName}'
-  import { ${events.map(event => event._alias)} } from '../generated/schema'
-
-  ${events
-    .map(
-      event =>
-        `
-  export function handle${event._alias}(event: ${event._alias}Event): void {
-    let entity = new ${event._alias}(event.transaction.hash.concatI32(event.logIndex.toI32()))
-    ${generateEventFieldAssignments(event).join('\n')}
-
-    entity.blockNumber = event.block.number
-    entity.blockTimestamp = event.block.timestamp
-    entity.transactionHash = event.transaction.hash
-
-    entity.save()
-  }
-    `,
-    )
-    .join('\n')}
-`;

package/src/scaffold/near.test.ts

@@ -1,86 +0,0 @@
-import Protocol from '../protocols';
-import Scaffold from './index';
-
-const protocol = new Protocol('near');
-
-const scaffoldOptions = {
-  protocol,
-  contract: 'abc.def.near',
-  network: 'near-mainnet',
-  contractName: 'Contract',
-};
-
-const scaffold = new Scaffold(scaffoldOptions);
-
-describe('NEAR subgraph scaffolding', () => {
-  test('Manifest', () => {
-    expect(scaffold.generateManifest()).toEqual(`\
-specVersion: 0.0.5
-schema:
-  file: ./schema.graphql
-dataSources:
-  - kind: near
-    name: Contract
-    network: near-mainnet
-    source:
-      account: "abc.def.near"
-    mapping:
-      apiVersion: 0.0.5
-      language: wasm/assemblyscript
-      entities:
-        - ExampleEntity
-      receiptHandlers:
-        - handler: handleReceipt
-      file: ./src/contract.ts
-`);
-  });
-
-  test('Schema (default)', () => {
-    expect(scaffold.generateSchema()).toEqual(`\
-type ExampleEntity @entity {
-  id: ID!
-  block: Bytes!
-  count: BigInt!
-}
-`);
-  });
-
-  test('Mapping (default)', () => {
-    expect(scaffold.generateMapping()).toEqual(`\
-import { near, BigInt } from "@graphprotocol/graph-ts"
-import { ExampleEntity } from "../generated/schema"
-
-export function handleReceipt(
-  receiptWithOutcome: near.ReceiptWithOutcome
-): void {
-  // Entities can be loaded from the store using a string ID; this ID
-  // needs to be unique across all entities of the same type
-  let entity = ExampleEntity.load(receiptWithOutcome.receipt.id.toHex())
-
-  // Entities only exist after they have been saved to the store;
-  // \`null\` checks allow to create entities on demand
-  if (!entity) {
-    entity = new ExampleEntity(receiptWithOutcome.receipt.id.toHex())
-
-    // Entity fields can be set using simple assignments
-    entity.count = BigInt.fromI32(0)
-  }
-
-  // BigInt and BigDecimal math are supported
-  entity.count = entity.count + BigInt.fromI32(1)
-
-  // Entity fields can be set based on receipt information
-  entity.block = receiptWithOutcome.block.header.hash
-
-  // Entities can be written to the store with \`.save()\`
-  entity.save()
-
-  // Note: If a handler doesn't require existing field values, it is faster
-  // _not_ to load the entity from the store. Instead, create it fresh with
-  // \`new Entity(...)\`, set the fields that should be updated and save the
-  // entity back to the store. Fields that were not set or unset remain
-  // unchanged, allowing for partial updates to be applied.
-}
-`);
-  });
-});

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