@graphprotocol/graph-cli 0.37.3-alpha-20230110164921-a0dbdfc → 0.37.3-alpha-20230111114757-a72d102

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # @graphprotocol/graph-cli
 
-## 0.37.3-alpha-20230110164921-a0dbdfc
+## 0.37.3-alpha-20230111114757-a72d102
 
 ### Patch Changes
 

package/dist/type-generator.js

@@ -31,8 +31,7 @@ const immutable_1 = __importDefault(require("immutable"));
 const path_1 = __importDefault(require("path"));
 const prettier_1 = __importDefault(require("prettier"));
 const graphql = __importStar(require("graphql/language"));
-const chalk_1 = __importDefault(require("chalk"));
-const toolbox = __importStar(require("gluegun/toolbox"));
+const toolbox = __importStar(require("gluegun"));
 const schema_1 = __importDefault(require("./schema"));
 const subgraph_1 = __importDefault(require("./subgraph"));
 const template_1 = __importDefault(require("./codegen/template"));
@@ -41,15 +40,20 @@ const spinner_1 = require("./command-helpers/spinner");
 const migrations_1 = require("./migrations");
 const typescript_1 = require("./codegen/typescript");
 const fs_1 = require("./command-helpers/fs");
+// @ts-expect-error TODO: type out if necessary
 const Index_bs_js_1 = __importDefault(require("@float-capital/float-subgraph-uncrashable/src/Index.bs.js"));
 class TypeGenerator {
+    sourceDir;
+    options;
+    protocol;
+    protocolTypeGenerator;
     constructor(options) {
-        this.options = options || {};
+        this.options = options;
         this.sourceDir =
             this.options.sourceDir ||
                 (this.options.subgraphManifest && path_1.default.dirname(this.options.subgraphManifest));
         this.protocol = this.options.protocol;
-        this.protocolTypeGenerator = this.protocol.getTypeGenerator({
+        this.protocolTypeGenerator = this.protocol?.getTypeGenerator?.({
             sourceDir: this.sourceDir,
             outputDir: this.options.outputDir,
         });
@@ -104,11 +108,11 @@ class TypeGenerator {
         if (quiet) {
             return this.options.subgraph
                 ? this.options.subgraph
-                : subgraph_1.default.load(this.options.subgraphManifest, subgraphLoadOptions).result;
+                : (await subgraph_1.default.load(this.options.subgraphManifest, subgraphLoadOptions)).result;
         }
         else {
             const manifestPath = (0, fs_1.displayPath)(this.options.subgraphManifest);
-            return await (0, spinner_1.withSpinner)(`Load subgraph from ${manifestPath}`, `Failed to load subgraph from ${manifestPath}`, `Warnings while loading subgraph from ${manifestPath}`, async (spinner) => {
+            return await (0, spinner_1.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_1.default.load(this.options.subgraphManifest, subgraphLoadOptions);
@@ -118,8 +122,7 @@ class TypeGenerator {
     async loadSchema(subgraph) {
         let maybeRelativePath = subgraph.getIn(['schema', 'file']);
         let absolutePath = path_1.default.resolve(this.sourceDir, maybeRelativePath);
-        return await (0, spinner_1.withSpinner)(`Load GraphQL schema from ${(0, fs_1.displayPath)(absolutePath)}`, `Failed to load GraphQL schema from ${(0, fs_1.displayPath)(absolutePath)}`, `Warnings while loading GraphQL schema from ${(0, fs_1.displayPath)(absolutePath)}`, async (spinner) => {
-            let maybeRelativePath = subgraph.getIn(['schema', 'file']);
+        return await (0, spinner_1.withSpinner)(`Load GraphQL schema from ${(0, fs_1.displayPath)(absolutePath)}`, `Failed to load GraphQL schema from ${(0, fs_1.displayPath)(absolutePath)}`, `Warnings while loading GraphQL schema from ${(0, fs_1.displayPath)(absolutePath)}`, async (_spinner) => {
             let absolutePath = path_1.default.resolve(this.sourceDir, maybeRelativePath);
             return schema_1.default.load(absolutePath);
         });
@@ -176,8 +179,8 @@ class TypeGenerator {
             // 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 => {
-                dataSource.getIn(['mapping', 'abis']).map(abi => {
+            subgraph.get('dataSources').map((dataSource) => {
+                dataSource.getIn(['mapping', 'abis']).map((abi) => {
                     files.push(abi.get('file'));
                 });
             });

package/dist/validation/contract.js

@@ -22,7 +22,7 @@ const validateContractValues = (manifest, protocol) => {
     const fieldName = ProtocolContract.identifierName();
     return manifest
         .get('dataSources')
-        .filter(dataSource => protocol.isValidKindName(dataSource.get('kind')))
+        .filter((dataSource) => protocol.isValidKindName(dataSource.get('kind')))
         .reduce((errors, dataSource, dataSourceIndex) => {
         let path = ['dataSources', dataSourceIndex, 'source', fieldName];
         // No need to validate if the source has no contract field
@@ -30,7 +30,7 @@ const validateContractValues = (manifest, protocol) => {
             return errors;
         }
         let contractValue = dataSource.getIn(['source', fieldName]);
-        const { valid, error } = validateContract(contractValue, ProtocolContract);
+        const { valid, error } = (0, exports.validateContract)(contractValue, ProtocolContract);
         // Validate whether the contract is valid for the protocol
         if (valid) {
             return errors;

package/dist/validation/manifest.js

@@ -13,11 +13,11 @@ const Map = immutable_1.default.Map;
 /**
  * Returns a user-friendly type name for a value.
  */
-const typeName = value => List.isList(value) ? 'list' : Map.isMap(value) ? 'map' : typeof value;
+const typeName = (value) => List.isList(value) ? 'list' : Map.isMap(value) ? 'map' : typeof value;
 /**
  * Converts an immutable or plain JavaScript value to a YAML string.
  */
-const toYAML = x => js_yaml_1.default
+const toYAML = (x) => js_yaml_1.default
     .safeDump(typeName(x) === 'list' || typeName(x) === 'map' ? x.toJS() : x, {
     indent: 2,
 })
@@ -28,7 +28,7 @@ const toYAML = x => js_yaml_1.default
 const getFieldType = (type, fieldName) => {
     let fieldDef = type
         .get('fields')
-        .find(field => field.getIn(['name', 'value']) === fieldName);
+        .find((field) => field.getIn(['name', 'value']) === fieldName);
     return fieldDef !== undefined ? fieldDef.get('type') : undefined;
 };
 /**
@@ -39,7 +39,7 @@ const resolveType = (schema, type) => type.has('type')
     : type.get('kind') === 'NamedType'
         ? schema
             .get('definitions')
-            .find(def => def.getIn(['name', 'value']) === type.getIn(['name', 'value']))
+            .find((def) => def.getIn(['name', 'value']) === type.getIn(['name', 'value']))
         : 'resolveType: unimplemented';
 /**
  * A map of supported validators.
@@ -58,7 +58,7 @@ const validators = immutable_1.default.fromJS({
             errors = errors.push(variantErrors);
         }
         // Return errors from variant that matched the most
-        return List(errors.minBy(variantErrors => variantErrors.count()));
+        return List(errors.minBy((variantErrors) => variantErrors.count()));
     },
     NamedType: (value, ctx) => validateValue(value, ctx.update('type', type => resolveType(ctx.get('schema'), type))),
     NonNullType: (value, ctx) => value !== null && value !== undefined
@@ -83,12 +83,12 @@ const validators = immutable_1.default.fromJS({
         return Map.isMap(value)
             ? ctx
                 .getIn(['type', 'fields'])
-                .map(fieldDef => fieldDef.getIn(['name', 'value']))
+                .map((fieldDef) => fieldDef.getIn(['name', 'value']))
                 .concat(value.keySeq())
                 .toSet()
                 .reduce((errors, key) => getFieldType(ctx.get('type'), key)
                 ? errors.concat(validateValue(value.get(key), ctx
-                    .update('path', path => path.push(key))
+                    .update('path', (path) => path.push(key))
                     .set('type', getFieldType(ctx.get('type'), key))))
                 : errors.push(key == 'templates' && ctx.get('protocol').hasTemplates()
                     ? immutable_1.default.fromJS({
@@ -109,7 +109,7 @@ const validators = immutable_1.default.fromJS({
             ]);
     },
     EnumTypeDefinition: (value, ctx) => {
-        const enumValues = ctx.getIn(['type', 'values']).map(v => {
+        const enumValues = ctx.getIn(['type', 'values']).map((v) => {
             return v.getIn(['name', 'value']);
         });
         const allowedValues = enumValues.toArray().join(', ');
@@ -203,8 +203,8 @@ const validateValue = (value, ctx) => {
 //     'near-mainnet': ['contract3'],
 //   },
 // }
-const dataSourceListToMap = dataSources => dataSources.reduce((protocolKinds, dataSource) => protocolKinds.update(protocols_1.default.normalizeName(dataSource.kind), networks => (networks || immutable_1.default.OrderedMap()).update(dataSource.network, dataSourceNames => (dataSourceNames || immutable_1.default.OrderedSet()).add(dataSource.name))), immutable_1.default.OrderedMap());
-const validateDataSourceProtocolAndNetworks = value => {
+const dataSourceListToMap = (dataSources) => dataSources.reduce((protocolKinds, dataSource) => protocolKinds.update(protocols_1.default.normalizeName(dataSource.kind), (networks) => (networks || immutable_1.default.OrderedMap()).update(dataSource.network, (dataSourceNames) => (dataSourceNames || immutable_1.default.OrderedSet()).add(dataSource.name))), immutable_1.default.OrderedMap());
+const validateDataSourceProtocolAndNetworks = (value) => {
     const dataSources = [...value.dataSources, ...(value.templates || [])];
     const protocolNetworkMap = dataSourceListToMap(dataSources);
     if (protocolNetworkMap.size > 1) {
@@ -218,7 +218,7 @@ ${protocolNetworkMap
                     : `Data sources and templates using '${protocolKind}'`}:\n${dataSourceNames
                     .valueSeq()
                     .flatten()
-                    .map(ds => `    - ${ds}`)
+                    .map((ds) => `    - ${ds}`)
                     .join('\n')}`)
                     .join('\n')}
 Recommendation: Make all data sources and templates use the same protocol kind.`,
@@ -234,7 +234,7 @@ Recommendation: Make all data sources and templates use the same protocol kind.`
 ${networks
                     .map((dataSources, network) => `  ${network === undefined
                     ? 'Data sources and templates having no network set'
-                    : `Data sources and templates using '${network}'`}:\n${dataSources.map(ds => `    - ${ds}`).join('\n')}`)
+                    : `Data sources and templates using '${network}'`}:\n${dataSources.map((ds) => `    - ${ds}`).join('\n')}`)
                     .join('\n')}
 Recommendation: Make all data sources and templates use the same network name.`,
             },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphprotocol/graph-cli",
-  "version": "0.37.3-alpha-20230110164921-a0dbdfc",
+  "version": "0.37.3-alpha-20230111114757-a72d102",
   "license": "(Apache-2.0 OR MIT)",
   "description": "CLI for building for and deploying to The Graph",
   "main": "dist/cli.js",
@@ -38,6 +38,7 @@
   "devDependencies": {
     "@types/debug": "^4.1.7",
     "@types/fs-extra": "^9.0.13",
+    "@types/js-yaml": "^3.12.7",
     "@types/which": "^2.0.1",
     "copyfiles": "^2.4.1",
     "jest": "26.0.0",

package/src/protocols/index.ts

@@ -205,9 +205,9 @@ export default class Protocol {
   }
 }
 
-type ProtocolName = 'arweave' | 'ethereum' | 'near' | 'cosmos' | 'substreams'
+export type ProtocolName = 'arweave' | 'ethereum' | 'near' | 'cosmos' | 'substreams'
 
-interface ProtocolConfig {
+export interface ProtocolConfig {
   displayName: string
   abi?: any
   contract?: any

package/src/{type-generator.js → type-generator.ts}

@@ -3,33 +3,51 @@ import immutable from 'immutable'
 import path from 'path'
 import prettier from 'prettier'
 import * as graphql from 'graphql/language'
-import chalk from 'chalk'
-import * as toolbox from 'gluegun/toolbox'
+import * as toolbox from 'gluegun'
 
 import Schema from './schema'
 import Subgraph from './subgraph'
 import DataSourceTemplateCodeGenerator from './codegen/template'
 import Watcher from './watcher'
-import { step, withSpinner } from './command-helpers/spinner'
+import { Spinner, step, withSpinner } from './command-helpers/spinner'
 import { applyMigrations } from './migrations'
 import { GENERATED_FILE_NOTE } from './codegen/typescript'
 import { displayPath } from './command-helpers/fs'
+import Protocol from './protocols'
+
+// @ts-expect-error TODO: type out if necessary
 import uncrashable from '@float-capital/float-subgraph-uncrashable/src/Index.bs.js'
 
+interface TypeGeneratorOptions {
+  sourceDir?: string
+  subgraphManifest: string
+  subgraph?: string
+  protocol: Protocol
+  outputDir: string
+  skipMigrations?: boolean
+  uncrashable: any
+  uncrashableConfig: boolean
+}
+
 export default class TypeGenerator {
-  constructor(options) {
-    this.options = options || {}
+  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({
+    this.protocolTypeGenerator = this.protocol?.getTypeGenerator?.({
       sourceDir: this.sourceDir,
       outputDir: this.options.outputDir,
     })
 
-    process.on('uncaughtException', function (e) {
+    process.on('uncaughtException', function(e) {
       toolbox.print.error(`UNCAUGHT EXCEPTION: ${e}`)
     })
   }
@@ -77,7 +95,7 @@ export default class TypeGenerator {
     }
   }
 
-  async generateUncrashableEntities(graphSchema) {
+  async generateUncrashableEntities(graphSchema: any) {
     let ast = graphql.parse(graphSchema.document)
     let entityDefinitions = ast['definitions']
     return await withSpinner(
@@ -102,7 +120,7 @@ export default class TypeGenerator {
     if (quiet) {
       return this.options.subgraph
         ? this.options.subgraph
-        : Subgraph.load(this.options.subgraphManifest, subgraphLoadOptions).result
+        : (await Subgraph.load(this.options.subgraphManifest, subgraphLoadOptions)).result
     } else {
       const manifestPath = displayPath(this.options.subgraphManifest)
 
@@ -110,7 +128,7 @@ export default class TypeGenerator {
         `Load subgraph from ${manifestPath}`,
         `Failed to load subgraph from ${manifestPath}`,
         `Warnings while loading subgraph from ${manifestPath}`,
-        async spinner => {
+        async _spinner => {
           return this.options.subgraph
             ? this.options.subgraph
             : Subgraph.load(this.options.subgraphManifest, subgraphLoadOptions)
@@ -119,22 +137,21 @@ export default class TypeGenerator {
     }
   }
 
-  async loadSchema(subgraph) {
-    let maybeRelativePath = subgraph.getIn(['schema', 'file'])
+  async loadSchema(subgraph: immutable.Map<any, any>) {
+    let maybeRelativePath = subgraph.getIn(['schema', 'file']) as string
     let 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 => {
-        let maybeRelativePath = subgraph.getIn(['schema', 'file'])
+      async _spinner => {
         let absolutePath = path.resolve(this.sourceDir, maybeRelativePath)
         return Schema.load(absolutePath)
       },
     )
   }
 
-  async generateTypesForSchema(schema) {
+  async generateTypesForSchema(schema: any) {
     return await withSpinner(
       `Generate types for GraphQL schema`,
       `Failed to generate types for GraphQL schema`,
@@ -161,7 +178,7 @@ export default class TypeGenerator {
     )
   }
 
-  async generateTypesForDataSourceTemplates(subgraph) {
+  async generateTypesForDataSourceTemplates(subgraph: immutable.Map<any, any>) {
     return await withSpinner(
       `Generate types for data source templates`,
       `Failed to generate types for data source templates`,
@@ -170,7 +187,7 @@ export default class TypeGenerator {
         // Combine the generated code for all templates
         let codeSegments = subgraph
           .get('templates', immutable.List())
-          .reduce((codeSegments, template) => {
+          .reduce((codeSegments: any, template: any) => {
             step(
               spinner,
               'Generate types for data source template',
@@ -217,8 +234,8 @@ export default class TypeGenerator {
       files.push(subgraph.getIn(['schema', 'file']))
 
       // Add all file paths specified in manifest
-      subgraph.get('dataSources').map(dataSource => {
-        dataSource.getIn(['mapping', 'abis']).map(abi => {
+      subgraph.get('dataSources').map((dataSource: any) => {
+        dataSource.getIn(['mapping', 'abis']).map((abi: any) => {
           files.push(abi.get('file'))
         })
       })
@@ -232,7 +249,7 @@ export default class TypeGenerator {
 
   async watchAndGenerateTypes() {
     let generator = this
-    let spinner
+    let spinner: Spinner
 
     // Create watcher and generate types once and then on every change to a watched file
     let watcher = new Watcher({

package/src/validation/{contract.js → contract.ts}

@@ -1,6 +1,7 @@
 import immutable from 'immutable'
+import Protocol from '../protocols'
 
-const validateContract = (value, ProtocolContract) => {
+export const validateContract = (value: any, ProtocolContract: any) => {
   const contract = new ProtocolContract(value)
 
   const { valid, error } = contract.validate()
@@ -15,15 +16,18 @@ const validateContract = (value, ProtocolContract) => {
   return { valid, error }
 }
 
-const validateContractValues = (manifest, protocol) => {
+export const validateContractValues = (
+  manifest: immutable.Map<any, any>,
+  protocol: Protocol,
+) => {
   const ProtocolContract = protocol.getContract()
 
   const fieldName = ProtocolContract.identifierName()
 
   return manifest
     .get('dataSources')
-    .filter(dataSource => protocol.isValidKindName(dataSource.get('kind')))
-    .reduce((errors, dataSource, dataSourceIndex) => {
+    .filter((dataSource: any) => protocol.isValidKindName(dataSource.get('kind')))
+    .reduce((errors: any[], dataSource: any, dataSourceIndex: number) => {
       let path = ['dataSources', dataSourceIndex, 'source', fieldName]
 
       // No need to validate if the source has no contract field
@@ -48,5 +52,3 @@ const validateContractValues = (manifest, protocol) => {
       }
     }, immutable.List())
 }
-
-export { validateContract, validateContractValues }

package/src/validation/{manifest.js → manifest.ts}

@@ -10,13 +10,13 @@ const Map = immutable.Map
 /**
  * Returns a user-friendly type name for a value.
  */
-const typeName = 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 =>
+const toYAML = (x: immutable.Collection<unknown, unknown>) =>
   yaml
     .safeDump(typeName(x) === 'list' || typeName(x) === 'map' ? x.toJS() : x, {
       indent: 2,
@@ -26,10 +26,10 @@ const toYAML = x =>
 /**
  * Looks up the type of a field in a GraphQL object type.
  */
-const getFieldType = (type, fieldName) => {
+const getFieldType = (type: immutable.Map<any, any>, fieldName: string) => {
   let fieldDef = type
     .get('fields')
-    .find(field => field.getIn(['name', 'value']) === fieldName)
+    .find((field: any) => field.getIn(['name', 'value']) === fieldName)
 
   return fieldDef !== undefined ? fieldDef.get('type') : undefined
 }
@@ -37,24 +37,29 @@ const getFieldType = (type, fieldName) => {
 /**
  * Resolves a type in the GraphQL schema.
  */
-const resolveType = (schema, type) =>
+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 => def.getIn(['name', 'value']) === type.getIn(['name', 'value']))
+        .find(
+          (def: any) => def.getIn(['name', 'value']) === type.getIn(['name', 'value']),
+        )
     : 'resolveType: unimplemented'
 
 /**
  * A map of supported validators.
  */
 const validators = immutable.fromJS({
-  ScalarTypeDefinition: (value, ctx) =>
-    validators.get(ctx.getIn(['type', 'name', 'value']))(value, ctx),
+  ScalarTypeDefinition: (value: any, ctx: immutable.Map<any, any>) =>
+    (validators.get(ctx.getIn(['type', 'name', 'value'])) as any)(value, ctx),
 
-  UnionTypeDefinition: (value, ctx) => {
-    const unionVariants = ctx.getIn(['type', 'types'])
+  UnionTypeDefinition: (value: any, ctx: immutable.Map<any, any>) => {
+    const unionVariants = ctx.getIn(['type', 'types']) as any[]
 
     let errors = List()
 
@@ -68,16 +73,16 @@ const validators = immutable.fromJS({
     }
 
     // Return errors from variant that matched the most
-    return List(errors.minBy(variantErrors => variantErrors.count()))
+    return List(errors.minBy((variantErrors: any) => variantErrors.count()) as any)
   },
 
-  NamedType: (value, ctx) =>
+  NamedType: (value: any, ctx: immutable.Map<any, any>) =>
     validateValue(
       value,
       ctx.update('type', type => resolveType(ctx.get('schema'), type)),
     ),
 
-  NonNullType: (value, ctx) =>
+  NonNullType: (value: any, ctx: immutable.Map<any, any>) =>
     value !== null && value !== undefined
       ? validateValue(
           value,
@@ -90,7 +95,7 @@ const validators = immutable.fromJS({
           },
         ]),
 
-  ListType: (value, ctx) =>
+  ListType: (value: any, ctx: immutable.Map<any, any>) =>
     List.isList(value)
       ? value.reduce(
           (errors, value, i) =>
@@ -111,21 +116,21 @@ const validators = immutable.fromJS({
           },
         ]),
 
-  ObjectTypeDefinition: (value, ctx) => {
+  ObjectTypeDefinition: (value: any, ctx: any) => {
     return Map.isMap(value)
       ? ctx
           .getIn(['type', 'fields'])
-          .map(fieldDef => fieldDef.getIn(['name', 'value']))
+          .map((fieldDef: any) => fieldDef.getIn(['name', 'value']))
           .concat(value.keySeq())
           .toSet()
           .reduce(
-            (errors, key) =>
+            (errors: any[], key: string) =>
               getFieldType(ctx.get('type'), key)
                 ? errors.concat(
                     validateValue(
                       value.get(key),
                       ctx
-                        .update('path', path => path.push(key))
+                        .update('path', (path: string[]) => path.push(key))
                         .set('type', getFieldType(ctx.get('type'), key)),
                     ),
                   )
@@ -153,8 +158,8 @@ const validators = immutable.fromJS({
         ])
   },
 
-  EnumTypeDefinition: (value, ctx) => {
-    const enumValues = ctx.getIn(['type', 'values']).map(v => {
+  EnumTypeDefinition: (value: any, ctx: immutable.Map<any, any>) => {
+    const enumValues = (ctx.getIn(['type', 'values']) as any).map((v: any) => {
       return v.getIn(['name', 'value'])
     })
 
@@ -170,7 +175,7 @@ const validators = immutable.fromJS({
         ])
   },
 
-  String: (value, ctx) =>
+  String: (value: any, ctx: immutable.Map<any, any>) =>
     typeof value === 'string'
       ? List()
       : immutable.fromJS([
@@ -180,7 +185,7 @@ const validators = immutable.fromJS({
           },
         ]),
 
-  BigInt: (value, ctx) =>
+  BigInt: (value: any, ctx: immutable.Map<any, any>) =>
     typeof value === 'number'
       ? List()
       : immutable.fromJS([
@@ -190,7 +195,7 @@ const validators = immutable.fromJS({
           },
         ]),
 
-  File: (value, ctx) =>
+  File: (value: any, ctx: immutable.Map<any, any>) =>
     typeof value === 'string'
       ? require('fs').existsSync(ctx.get('resolveFile')(value))
         ? List()
@@ -207,7 +212,7 @@ const validators = immutable.fromJS({
           },
         ]),
 
-  Boolean: (value, ctx) =>
+  Boolean: (value: any, ctx: immutable.Map<any, any>) =>
     typeof value === 'boolean'
       ? List()
       : immutable.fromJS([
@@ -220,9 +225,9 @@ const validators = immutable.fromJS({
         ]),
 })
 
-const validateValue = (value, ctx) => {
+const validateValue = (value: any, ctx: immutable.Collection<any, any>) => {
   let kind = ctx.getIn(['type', 'kind'])
-  let validator = validators.get(kind)
+  let validator = validators.get(kind) as any
 
   if (validator !== undefined) {
     // If the type is nullable, accept undefined and null; if the nullable
@@ -261,18 +266,20 @@ const validateValue = (value, ctx) => {
 //     'near-mainnet': ['contract3'],
 //   },
 // }
-const dataSourceListToMap = dataSources =>
+const dataSourceListToMap = (dataSources: any[]) =>
   dataSources.reduce(
     (protocolKinds, dataSource) =>
-      protocolKinds.update(Protocol.normalizeName(dataSource.kind), networks =>
-        (networks || immutable.OrderedMap()).update(dataSource.network, dataSourceNames =>
-          (dataSourceNames || immutable.OrderedSet()).add(dataSource.name),
+      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 => {
+const validateDataSourceProtocolAndNetworks = (value: any) => {
   const dataSources = [...value.dataSources, ...(value.templates || [])]
 
   const protocolNetworkMap = dataSourceListToMap(dataSources)
@@ -284,7 +291,7 @@ const validateDataSourceProtocolAndNetworks = value => {
         message: `Conflicting protocol kinds used in data sources and templates:
 ${protocolNetworkMap
   .map(
-    (dataSourceNames, protocolKind) =>
+    (dataSourceNames: any, protocolKind: string | undefined) =>
       `  ${
         protocolKind === undefined
           ? 'Data sources and templates having no protocol kind set'
@@ -292,7 +299,7 @@ ${protocolNetworkMap
       }:\n${dataSourceNames
         .valueSeq()
         .flatten()
-        .map(ds => `    - ${ds}`)
+        .map((ds: string) => `    - ${ds}`)
         .join('\n')}`,
   )
   .join('\n')}
@@ -310,12 +317,12 @@ Recommendation: Make all data sources and templates use the same protocol kind.`
         message: `Conflicting networks used in data sources and templates:
 ${networks
   .map(
-    (dataSources, network) =>
+    (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 => `    - ${ds}`).join('\n')}`,
+      }:\n${dataSources.map((ds: string) => `    - ${ds}`).join('\n')}`,
   )
   .join('\n')}
 Recommendation: Make all data sources and templates use the same network name.`,
@@ -326,7 +333,13 @@ Recommendation: Make all data sources and templates use the same network name.`,
   return List()
 }
 
-const validateManifest = (value, type, schema, protocol, { resolveFile }) => {
+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
   let errors =
     value !== null && value !== undefined
@@ -358,5 +371,3 @@ const validateManifest = (value, type, schema, protocol, { resolveFile }) => {
   // (this includes _no_ network/protocol at all)
   return validateDataSourceProtocolAndNetworks(value)
 }
-
-export { validateManifest }