@graphprotocol/graph-cli 0.37.3-alpha-20230111115045-e3bcf23 → 0.37.3-alpha-20230111125757-b437012

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # @graphprotocol/graph-cli
 
-## 0.37.3-alpha-20230111115045-e3bcf23
+## 0.37.3-alpha-20230111125757-b437012
 
 ### Patch Changes
 

package/dist/codegen/types/index.js

@@ -9,7 +9,7 @@ const conversions_1 = __importDefault(require("./conversions"));
 // Conversion utilities
 const conversionsForTypeSystems = (fromTypeSystem, toTypeSystem) => {
     let conversions = conversions_1.default.getIn([fromTypeSystem, toTypeSystem]);
-    if (conversions === undefined) {
+    if (conversions == undefined) {
         throw new Error(`Conversions from '${fromTypeSystem}' to '${toTypeSystem}' are not supported`);
     }
     return conversions;
@@ -31,7 +31,7 @@ const findConversionFromType = (fromTypeSystem, toTypeSystem, fromType) => {
     let conversions = conversionsForTypeSystems(fromTypeSystem, toTypeSystem);
     let conversion = conversions.find(conversion => typeof conversion.get(0) === 'string'
         ? conversion.get(0) === fromType
-        : fromType.match(conversion.get(0)));
+        : Boolean(fromType.match(conversion.get(0))));
     if (conversion === undefined) {
         throw new Error(`Conversion from '${fromTypeSystem}' to '${toTypeSystem}' for ` +
             `source type '${fromType}' is not supported`);
@@ -42,7 +42,7 @@ const findConversionToType = (fromTypeSystem, toTypeSystem, toType) => {
     let conversions = conversionsForTypeSystems(fromTypeSystem, toTypeSystem);
     let conversion = conversions.find(conversion => typeof conversion.get(1) === 'string'
         ? conversion.get(1) === toType
-        : toType.match(conversion.get(1)));
+        : Boolean(toType.match(conversion.get(1))));
     if (conversion === undefined) {
         throw new Error(`Conversion from '${fromTypeSystem}' to '${toTypeSystem}' for ` +
             `target type '${toType}' is not supported`);
@@ -50,20 +50,26 @@ const findConversionToType = (fromTypeSystem, toTypeSystem, toType) => {
     return objectifyConversion(fromTypeSystem, toTypeSystem, conversion);
 };
 // High-level type system API
-const ascTypeForProtocol = (protocol, protocolType) => findConversionFromType(protocol, 'AssemblyScript', protocolType).getIn(['to', 'type']);
+const ascTypeForProtocol = (protocol, protocolType) => findConversionFromType(protocol, 'AssemblyScript', protocolType).getIn([
+    'to',
+    'type',
+]);
 exports.ascTypeForProtocol = ascTypeForProtocol;
 // TODO: this can be removed/replaced by the function above
-const ascTypeForEthereum = ethereumType => ascTypeForProtocol('ethereum', ethereumType);
+const ascTypeForEthereum = (ethereumType) => (0, exports.ascTypeForProtocol)('ethereum', ethereumType);
 exports.ascTypeForEthereum = ascTypeForEthereum;
-const ethereumTypeForAsc = ascType => findConversionFromType('AssemblyScript', 'ethereum', ascType).getIn(['to', 'type']);
+const ethereumTypeForAsc = (ascType) => findConversionFromType('AssemblyScript', 'ethereum', ascType).getIn([
+    'to',
+    'type',
+]);
 exports.ethereumTypeForAsc = ethereumTypeForAsc;
 const ethereumToAsc = (code, ethereumType, internalType) => findConversionFromType('ethereum', 'AssemblyScript', ethereumType).get('convert')(code, internalType);
 exports.ethereumToAsc = ethereumToAsc;
 const ethereumFromAsc = (code, ethereumType) => findConversionToType('AssemblyScript', 'ethereum', ethereumType).get('convert')(code);
 exports.ethereumFromAsc = ethereumFromAsc;
-const ascTypeForValue = valueType => findConversionFromType('Value', 'AssemblyScript', valueType).getIn(['to', 'type']);
+const ascTypeForValue = (valueType) => findConversionFromType('Value', 'AssemblyScript', valueType).getIn(['to', 'type']);
 exports.ascTypeForValue = ascTypeForValue;
-const valueTypeForAsc = ascType => findConversionFromType('AssemblyScript', 'Value', ascType).getIn(['to', 'type']);
+const valueTypeForAsc = (ascType) => findConversionFromType('AssemblyScript', 'Value', ascType).getIn(['to', 'type']);
 exports.valueTypeForAsc = valueTypeForAsc;
 const valueToAsc = (code, valueType) => findConversionFromType('Value', 'AssemblyScript', valueType).get('convert')(code);
 exports.valueToAsc = valueToAsc;

package/dist/scaffold/tests.js

@@ -17,11 +17,11 @@ const VARIABLES_VALUES = {
 };
 const generateTestsFiles = (contract, events, indexEvents) => {
     const eventsTypes = events
-        .flatMap(event => event.inputs.map(input => {
+        .flatMap(event => event.inputs.map((input) => {
         // 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 = (0, types_1.ascTypeForEthereum)(input.type);
-        const inner = fetchArrayInnerType(ascType);
+        const inner = fetchArrayInnerType(String(ascType));
         return inner ? inner[1] : ascType;
     }))
         .filter(type => !type.startsWith('ethereum.') && !isNativeType(type));
@@ -39,16 +39,16 @@ exports.generateTestsFiles = generateTestsFiles;
   let displayName = "Example string value"
   let imageUrl = "Example string value"
 */
-const generateArguments = eventInputs => {
+const generateArguments = (eventInputs) => {
     return eventInputs
         .map((input, index) => {
         let ascType = (0, types_1.ascTypeForEthereum)(input.type);
-        return `let ${input.name || `param${index}`} = ${assignValue(ascType, input.name)}`;
+        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 => {
+const assignValue = (type) => {
     switch (type) {
         case 'string':
             return `"${VARIABLES_VALUES[type]}"`;
@@ -85,7 +85,7 @@ const generateFieldsAssertions = (entity, eventInputs, indexEvents) => eventInpu
   )`)
     .join('\n');
 // Returns the expected value for a given type in generateFieldsAssertions()
-const expectedValue = type => {
+const expectedValue = (type) => {
     switch (type) {
         case fetchArrayInnerType(type)?.input:
             const innerType = fetchArrayInnerType(type)[1];
@@ -96,11 +96,11 @@ const expectedValue = type => {
     }
 };
 // Checks if the type is a native AS type or should be imported from graph-ts
-const isNativeType = type => {
+const isNativeType = (type) => {
     let natives = [/i32/, /string/, /boolean/];
     return natives.some(rx => rx.test(type));
 };
-const fetchArrayInnerType = type => type.match(/Array<(.*?)>/);
+const fetchArrayInnerType = (type) => type.match(/Array<(.*?)>/);
 // Generates the example test.ts file
 const generateExampleTest = (contract, event, indexEvents, importTypes) => {
     const entity = indexEvents ? `${event._alias}` : 'ExampleEntity';
@@ -156,11 +156,12 @@ const generateTestHelper = (contract, events, importTypes) => {
 
   ${generateMockedEvents(events).join('\n')}`;
 };
-const generateMockedEvents = events => events.reduce((acc, event) => acc.concat(generateMockedEvent(event)), []);
-const generateMockedEvent = event => {
+const generateMockedEvents = (events) => events.reduce((acc, event) => acc.concat(generateMockedEvent(event)), []);
+const generateMockedEvent = (event) => {
     const varName = `${gluegun_1.strings.camelCase(event._alias)}Event`;
     const fnArgs = event.inputs.map((input, index) => `${input.name || `param${index}`}: ${(0, types_1.ascTypeForEthereum)(input.type)}`);
-    const ascToEth = event.inputs.map((input, index) => `${varName}.parameters.push(new ethereum.EventParam("${input.name || `param${index}`}", ${(0, types_1.ethereumFromAsc)(input.name || `param${index}`, input.type)}))`);
+    const ascToEth = event.inputs.map((input, index) => `${varName}.parameters.push(new ethereum.EventParam("${input.name ||
+        `param${index}`}", ${(0, types_1.ethereumFromAsc)(input.name || `param${index}`, input.type)}))`);
     return `
     export function create${event._alias}Event(${fnArgs.join(', ')}): ${event._alias} {
       let ${varName} = changetype<${event._alias}>(newMockEvent());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphprotocol/graph-cli",
-  "version": "0.37.3-alpha-20230111115045-e3bcf23",
+  "version": "0.37.3-alpha-20230111125757-b437012",
   "license": "(Apache-2.0 OR MIT)",
   "description": "CLI for building for and deploying to The Graph",
   "main": "dist/cli.js",

package/src/codegen/types/{index.js → index.ts}

@@ -4,17 +4,21 @@ import TYPE_CONVERSIONS from './conversions'
 
 // Conversion utilities
 
-const conversionsForTypeSystems = (fromTypeSystem, toTypeSystem) => {
+const conversionsForTypeSystems = (fromTypeSystem: string, toTypeSystem: string) => {
   let conversions = TYPE_CONVERSIONS.getIn([fromTypeSystem, toTypeSystem])
-  if (conversions === undefined) {
+  if (conversions == undefined) {
     throw new Error(
       `Conversions from '${fromTypeSystem}' to '${toTypeSystem}' are not supported`,
     )
   }
-  return conversions
+  return conversions as immutable.Collection<any, any>
 }
 
-const objectifyConversion = (fromTypeSystem, toTypeSystem, conversion) => {
+const objectifyConversion = (
+  fromTypeSystem: string,
+  toTypeSystem: string,
+  conversion: immutable.Collection<any, any>,
+) => {
   return immutable.fromJS({
     from: {
       typeSystem: fromTypeSystem,
@@ -28,13 +32,17 @@ const objectifyConversion = (fromTypeSystem, toTypeSystem, conversion) => {
   })
 }
 
-const findConversionFromType = (fromTypeSystem, toTypeSystem, fromType) => {
+const findConversionFromType = (
+  fromTypeSystem: string,
+  toTypeSystem: string,
+  fromType: string,
+): immutable.Collection<any, any> => {
   let conversions = conversionsForTypeSystems(fromTypeSystem, toTypeSystem)
 
   let conversion = conversions.find(conversion =>
     typeof conversion.get(0) === 'string'
       ? conversion.get(0) === fromType
-      : fromType.match(conversion.get(0)),
+      : Boolean(fromType.match(conversion.get(0))),
   )
 
   if (conversion === undefined) {
@@ -47,13 +55,17 @@ const findConversionFromType = (fromTypeSystem, toTypeSystem, fromType) => {
   return objectifyConversion(fromTypeSystem, toTypeSystem, conversion)
 }
 
-const findConversionToType = (fromTypeSystem, toTypeSystem, toType) => {
+const findConversionToType = (
+  fromTypeSystem: string,
+  toTypeSystem: string,
+  toType: string,
+): immutable.Collection<any, any> => {
   let conversions = conversionsForTypeSystems(fromTypeSystem, toTypeSystem)
 
   let conversion = conversions.find(conversion =>
     typeof conversion.get(1) === 'string'
       ? conversion.get(1) === toType
-      : toType.match(conversion.get(1)),
+      : Boolean(toType.match(conversion.get(1))),
   )
 
   if (conversion === undefined) {
@@ -68,47 +80,43 @@ const findConversionToType = (fromTypeSystem, toTypeSystem, toType) => {
 
 // High-level type system API
 
-const ascTypeForProtocol = (protocol, protocolType) =>
-  findConversionFromType(protocol, 'AssemblyScript', protocolType).getIn(['to', 'type'])
+export const ascTypeForProtocol = (protocol: any, protocolType: string) =>
+  findConversionFromType(protocol, 'AssemblyScript', protocolType).getIn([
+    'to',
+    'type',
+  ]) as string
 
 // TODO: this can be removed/replaced by the function above
-const ascTypeForEthereum = ethereumType => ascTypeForProtocol('ethereum', ethereumType)
-
-const ethereumTypeForAsc = ascType =>
-  findConversionFromType('AssemblyScript', 'ethereum', ascType).getIn(['to', 'type'])
-
-const ethereumToAsc = (code, ethereumType, internalType) =>
+export const ascTypeForEthereum = (ethereumType: string) =>
+  ascTypeForProtocol('ethereum', ethereumType)
+
+export const ethereumTypeForAsc = (ascType: string) =>
+  findConversionFromType('AssemblyScript', 'ethereum', ascType).getIn([
+    'to',
+    'type',
+  ]) as string
+
+export const ethereumToAsc = (
+  code: string,
+  ethereumType: string,
+  internalType?: string,
+) =>
   findConversionFromType('ethereum', 'AssemblyScript', ethereumType).get('convert')(
     code,
     internalType,
   )
 
-const ethereumFromAsc = (code, ethereumType) =>
+export const ethereumFromAsc = (code: string, ethereumType: string) =>
   findConversionToType('AssemblyScript', 'ethereum', ethereumType).get('convert')(code)
 
-const ascTypeForValue = valueType =>
+export const ascTypeForValue = (valueType: string) =>
   findConversionFromType('Value', 'AssemblyScript', valueType).getIn(['to', 'type'])
 
-const valueTypeForAsc = ascType =>
+export const valueTypeForAsc = (ascType: string) =>
   findConversionFromType('AssemblyScript', 'Value', ascType).getIn(['to', 'type'])
 
-const valueToAsc = (code, valueType) =>
+export const valueToAsc = (code: string, valueType: string) =>
   findConversionFromType('Value', 'AssemblyScript', valueType).get('convert')(code)
 
-const valueFromAsc = (code, valueType) =>
+export const valueFromAsc = (code: string, valueType: string) =>
   findConversionToType('AssemblyScript', 'Value', valueType).get('convert')(code)
-
-export {
-  // protocol <-> AssemblyScript
-  ascTypeForProtocol,
-  // ethereum <-> AssemblyScript
-  ascTypeForEthereum,
-  ethereumTypeForAsc,
-  ethereumToAsc,
-  ethereumFromAsc,
-  // Value <-> AssemblyScript
-  ascTypeForValue,
-  valueTypeForAsc,
-  valueToAsc,
-  valueFromAsc,
-}

package/src/scaffold/{tests.js → tests.ts}

@@ -11,14 +11,14 @@ const VARIABLES_VALUES = {
   bool: true,
 }
 
-const generateTestsFiles = (contract, events, indexEvents) => {
+export const generateTestsFiles = (contract: any, events: any[], indexEvents: number) => {
   const eventsTypes = events
     .flatMap(event =>
-      event.inputs.map(input => {
+      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(ascType)
+        const inner = fetchArrayInnerType(String(ascType))
         return inner ? inner[1] : ascType
       }),
     )
@@ -44,17 +44,17 @@ const generateTestsFiles = (contract, events, indexEvents) => {
   let displayName = "Example string value"
   let imageUrl = "Example string value"
 */
-const generateArguments = eventInputs => {
+const generateArguments = (eventInputs: any[]) => {
   return eventInputs
     .map((input, index) => {
       let ascType = ascTypeForEthereum(input.type)
-      return `let ${input.name || `param${index}`} = ${assignValue(ascType, input.name)}`
+      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 => {
+const assignValue = (type: string): string | number | boolean => {
   switch (type) {
     case 'string':
       return `"${VARIABLES_VALUES[type]}"`
@@ -65,10 +65,10 @@ const assignValue = type => {
     case 'Bytes':
       return `Bytes.fromI32(${VARIABLES_VALUES[type]})`
     case fetchArrayInnerType(type)?.input:
-      const innerType = fetchArrayInnerType(type)[1]
+      const innerType = fetchArrayInnerType(type)![1]
       return `[${assignValue(innerType)}]`
     default:
-      let value = VARIABLES_VALUES[type]
+      let value = VARIABLES_VALUES[type as keyof typeof VARIABLES_VALUES]
       return value ? value : `"${type} Not implemented"`
   }
 }
@@ -82,7 +82,11 @@ const assignValue = type => {
     "0x0000000000000000000000000000000000000001"
   )
 */
-const generateFieldsAssertions = (entity, eventInputs, indexEvents) =>
+const generateFieldsAssertions = (
+  entity: string,
+  eventInputs: any[],
+  indexEvents: number,
+) =>
   eventInputs
     .filter(input => input.name != 'id')
     .map(
@@ -97,28 +101,33 @@ const generateFieldsAssertions = (entity, eventInputs, indexEvents) =>
     .join('\n')
 
 // Returns the expected value for a given type in generateFieldsAssertions()
-const expectedValue = type => {
+const expectedValue = (type: string): string | number | boolean => {
   switch (type) {
     case fetchArrayInnerType(type)?.input:
-      const innerType = fetchArrayInnerType(type)[1]
+      const innerType = fetchArrayInnerType(type)![1]
       return `[${expectedValue(innerType)}]`
     default:
-      let value = VARIABLES_VALUES[type]
+      let 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 => {
+const isNativeType = (type: string) => {
   let natives = [/i32/, /string/, /boolean/]
 
   return natives.some(rx => rx.test(type))
 }
 
-const fetchArrayInnerType = type => type.match(/Array<(.*?)>/)
+const fetchArrayInnerType = (type: string) => type.match(/Array<(.*?)>/)
 
 // Generates the example test.ts file
-const generateExampleTest = (contract, event, indexEvents, importTypes) => {
+const generateExampleTest = (
+  contract: string,
+  event: any,
+  indexEvents: number,
+  importTypes: string,
+) => {
   const entity = indexEvents ? `${event._alias}` : 'ExampleEntity'
   const eventInputs = event.inputs
   const eventName = event._alias
@@ -141,7 +150,7 @@ const generateExampleTest = (contract, event, indexEvents, importTypes) => {
     beforeAll(() => {
       ${generateArguments(eventInputs)}
       let new${eventName}Event = create${eventName}Event(${eventInputs
-    .map((input, index) => input.name || `param${index}`)
+    .map((input: any, index: number) => input.name || `param${index}`)
     .join(', ')});
       handle${eventName}(new${eventName}Event)
     })
@@ -167,7 +176,7 @@ const generateExampleTest = (contract, event, indexEvents, importTypes) => {
 }
 
 // Generates the utils helper file
-const generateTestHelper = (contract, events, importTypes) => {
+const generateTestHelper = (contract: string, events: any[], importTypes: string) => {
   const eventsNames = events.map(event => event._alias)
 
   return `
@@ -178,20 +187,22 @@ const generateTestHelper = (contract, events, importTypes) => {
   ${generateMockedEvents(events).join('\n')}`
 }
 
-const generateMockedEvents = events =>
+const generateMockedEvents = (events: any[]) =>
   events.reduce((acc, event) => acc.concat(generateMockedEvent(event)), [])
 
-const generateMockedEvent = event => {
+const generateMockedEvent = (event: any) => {
   const varName = `${strings.camelCase(event._alias)}Event`
   const fnArgs = event.inputs.map(
-    (input, index) =>
+    (input: any, index: number) =>
       `${input.name || `param${index}`}: ${ascTypeForEthereum(input.type)}`,
   )
   const ascToEth = event.inputs.map(
-    (input, index) =>
-      `${varName}.parameters.push(new ethereum.EventParam("${
-        input.name || `param${index}`
-      }", ${ethereumFromAsc(input.name || `param${index}`, input.type)}))`,
+    (input: any, index: number) =>
+      `${varName}.parameters.push(new ethereum.EventParam("${input.name ||
+        `param${index}`}", ${ethereumFromAsc(
+        input.name || `param${index}`,
+        input.type,
+      )}))`,
   )
 
   return `
@@ -206,5 +217,3 @@ const generateMockedEvent = event => {
     }
   `
 }
-
-export { generateTestsFiles }