@graphprotocol/graph-cli 0.37.2 → 0.37.3-alpha-20230110163550-d64bef6

package/src/{watcher.js → watcher.ts}

@@ -1,8 +1,19 @@
-const chokidar = require('chokidar')
-const path = require('path')
+import chokidar from 'chokidar'
+import path from 'path'
 
-module.exports = class Watcher {
-  constructor(options) {
+export default class Watcher {
+  private onReady: () => void
+  private onTrigger: (arg: any) => void
+  private onCollectFiles: () => Promise<string[]>
+  private onError: (error: Error) => void
+  private watcher: chokidar.FSWatcher | undefined
+
+  constructor(options: {
+    onReady: () => void
+    onTrigger: (arg: any) => void
+    onCollectFiles: () => Promise<string[]>
+    onError: (error: Error) => void
+  }) {
     const { onReady, onTrigger, onCollectFiles, onError } = options
     this.onReady = onReady
     this.onTrigger = onTrigger
@@ -36,11 +47,11 @@ module.exports = class Watcher {
       await onTrigger(undefined)
     })
 
-    watcher.on('error', error => {
+    watcher.on('error', (error: any) => {
       onError(error)
     })
 
-    watcher.on('all', async (eventType, file) => {
+    watcher.on('all', async (_: any, file: any) => {
       try {
         // Collect watch all new files to watch
         let newFiles = await onCollectFiles()
@@ -50,17 +61,17 @@ module.exports = class Watcher {
 
         let watched = watcher.getWatched()
         watchedFiles = Object.keys(watched).reduce(
-          (files, dirname) =>
-            watched[dirname].reduce((files, filename) => {
+          (files: string[], dirname: string) =>
+            watched[dirname].reduce((files: string[], filename: string) => {
               files.push(path.resolve(path.join(dirname, filename)))
               return files
             }, files),
-          []
+          [],
         )
 
-        let diff = (xs, ys) => ({
-          added: ys.filter(y => xs.indexOf(y) < 0),
-          removed: xs.filter(x => ys.indexOf(x) < 0),
+        let diff = (xs: any[], ys: any[]) => ({
+          added: ys.filter((y: any) => xs.indexOf(y) < 0),
+          removed: xs.filter((x: any) => ys.indexOf(x) < 0),
         })
 
         // Diff previously watched files and new files; then remove and

package/tests/cli/globalSetup.js

@@ -1,6 +1,6 @@
-const { npmLinkCli } = require('./util')
+import { npmLinkCli } from './util'
 
-module.exports = async () => {
+export default async () => {
   process.env.GRAPH_CLI_TESTS = '1'
   await npmLinkCli()
 }

package/tests/cli/globalTeardown.js

@@ -1,6 +1,6 @@
-const { npmUnlinkCli } = require('./util')
+import { npmUnlinkCli } from './util'
 
-module.exports = async () => {
+export default async () => {
   delete process.env.GRAPH_CLI_TESTS
   await npmUnlinkCli()
 }

package/tests/cli/init.test.js

@@ -1,5 +1,5 @@
-const path = require('path')
-const { cliTest } = require('./util')
+import path from 'path'
+import { cliTest } from './util'
 
 describe('Init', () => {
   const baseDir = path.join(__dirname, 'init')

package/tests/cli/util.js

@@ -1,7 +1,7 @@
-const fs = require('fs-extra')
-const path = require('path')
-const spawn = require('spawn-command')
-const stripAnsi = require('strip-ansi')
+import fs from 'fs-extra'
+import path from 'path'
+import spawn from 'spawn-command'
+import stripAnsi from 'strip-ansi'
 
 // Deletes folder if:
 // - flag is true
@@ -22,8 +22,7 @@ const cliTest = (title, args, testPath, options = {}) => {
         deleteDir(resolvePath(`./${testPath}`), options.deleteDir)
 
         // Use the provided cwd if desired
-        let cwd =
-          options.cwd ? options.cwd : resolvePath(`./${testPath}`)
+        let cwd = options.cwd ? options.cwd : resolvePath(`./${testPath}`)
 
         let [exitCode, stdout, stderr] = await runGraphCli(args, cwd)
 
@@ -99,7 +98,7 @@ const runCommand = async (command, args = [], cwd = process.cwd()) => {
 
 const runGraphCli = async (args, cwd) => {
   // Resolve the path to graph.js
-  let graphCli = path.join(__dirname, '..', '..', 'bin', 'graph')
+  let graphCli = path.join(__dirname, '..', '..', 'dist', 'bin.js')
 
   return await runCommand(graphCli, args, cwd)
 }
@@ -108,9 +107,4 @@ const npmLinkCli = () => runCommand('npm', ['link'])
 
 const npmUnlinkCli = () => runCommand('npm', ['unlink'])
 
-module.exports = {
-  cliTest,
-  npmLinkCli,
-  npmUnlinkCli,
-  runGraphCli,
-}
+export { cliTest, npmLinkCli, npmUnlinkCli, runGraphCli }

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "outDir": "./dist",
+    "moduleResolution": "node",
+    "module": "commonjs",
+    "target": "es2022",
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "useUnknownInCatchVariables": false,
+    "declaration": false,
+    "skipLibCheck": true,
+    "allowJs": true
+  },
+  "include": ["./src"]
+}

package/src/cli.js

@@ -1,38 +0,0 @@
-const path = require('path')
-const { exec } = require('child_process')
-const which = require('which')
-const { build, system } = require('gluegun')
-
-const run = async argv => {
-  let cli = build()
-    .brand('graph')
-    .src(__dirname)
-
-  const pluginDirs = (
-    await Promise.all(
-      ['npm root -g', 'npm root', 'yarn global dir'].map(async cmd => {
-        try {
-          return await system.run(cmd, { trim: true })
-        } catch (_) {
-          return undefined
-        }
-      }),
-    )
-  ).filter(dir => dir !== undefined)
-
-  // Inject potential plugin directories
-  cli = pluginDirs.reduce(
-    (cli, dir) => cli.plugin(path.join(dir, '@graphprotocol', 'indexer-cli', 'dist')),
-    cli,
-  )
-
-  cli = cli
-    .help()
-    .version()
-    .defaultCommand()
-    .create()
-
-  return await cli.run(argv)
-}
-
-module.exports = { run }

package/src/codegen/types/conversions.js

@@ -1,329 +0,0 @@
-const immutable = require('immutable')
-
-/**
- * ethereum.Value -> AssemblyScript conversions
- */
-const ETHEREUM_VALUE_TO_ASSEMBLYSCRIPT = [
-  // Scalar values
-
-  ['address', 'Address', code => `${code}.toAddress()`],
-  ['bool', 'boolean', code => `${code}.toBoolean()`],
-  ['byte', 'Bytes', code => `${code}.toBytes()`],
-  [
-    /^bytes(1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|26|27|28|29|30|31|32)?$/,
-    'Bytes',
-    code => `${code}.toBytes()`,
-  ],
-  [/^int(8|16|24|32)$/, 'i32', code => `${code}.toI32()`],
-  [/^uint(8|16|24)$/, 'i32', code => `${code}.toI32()`],
-  ['uint32', 'BigInt', code => `${code}.toBigInt()`],
-  [
-    /^u?int(40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)$/,
-    'BigInt',
-    code => `${code}.toBigInt()`,
-  ],
-  ['string', 'string', code => `${code}.toString()`],
-
-  // Arrays
-
-  [/^address\[([0-9]+)?\]$/, 'Array<Address>', code => `${code}.toAddressArray()`],
-  [/^bool\[([0-9]+)?\]$/, 'Array<boolean>', code => `${code}.toBooleanArray()`],
-  [/^byte\[([0-9]+)?\]$/, 'Array<Bytes>', code => `${code}.toBytesArray()`],
-  [
-    /^bytes(1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|26|27|28|29|30|31|32)?\[([0-9]+)?\]$/,
-    'Array<Bytes>',
-    code => `${code}.toBytesArray()`,
-  ],
-  [/^int(8|16|24|32)\[([0-9]+)?\]$/, 'Array<i32>', code => `${code}.toI32Array()`],
-  [/^uint(8|16|24)\[([0-9]+)?\]$/, 'Array<i32>', code => `${code}.toI32Array()`],
-  [/^uint32\[([0-9]+)?\]$/, 'Array<BigInt>', code => `${code}.toBigIntArray()`],
-  [
-    /^u?int(40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)\[([0-9]+)?\]$/,
-    'Array<BigInt>',
-    code => `${code}.toBigIntArray()`,
-  ],
-  [/^string\[([0-9]+)?\]$/, 'Array<string>', code => `${code}.toStringArray()`],
-
-  // Tuples
-
-  ['tuple', 'ethereum.Tuple', code => `${code}.toTuple()`],
-  [
-    /^tuple\[([0-9]+)?\]$/,
-    'Array<ethereum.Tuple>',
-    (code, type) => `${code}.toTupleArray<${type}>()`,
-  ],
-
-  // Multi dimensional arrays
-
-  [/^address\[([0-9]+)?\]\[([0-9]+)?\]$/, 'Array<Array<Address>>', code => `${code}.toAddressMatrix()`],
-  [/^bool\[([0-9]+)?\]\[([0-9]+)?\]$/, 'Array<Array<boolean>>', code => `${code}.toBooleanMatrix()`],
-  [/^byte\[([0-9]+)?\]\[([0-9]+)?\]$/, 'Array<Array<Bytes>>', code => `${code}.toBytesMatrix()`],
-  [
-    /^bytes(1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|26|27|28|29|30|31|32)?\[([0-9]+)?\]\[([0-9]+)?\]$/,
-    'Array<Array<Bytes>>',
-    code => `${code}.toBytesMatrix()`,
-  ],
-  [/^int(8|16|24|32)\[([0-9]+)?\]\[([0-9]+)?\]$/, 'Array<Array<i32>>', code => `${code}.toI32Matrix()`],
-  [/^uint(8|16|24)\[([0-9]+)?\]\[([0-9]+)?\]$/, 'Array<Array<i32>>', code => `${code}.toI32Matrix()`],
-  [/^uint32\[([0-9]+)?\]\[([0-9]+)?\]$/, 'Array<Array<BigInt>>', code => `${code}.toBigIntMatrix()`],
-  [
-    /^u?int(40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)\[([0-9]+)?\]\[([0-9]+)?\]$/,
-    'Array<Array<BigInt>>',
-    code => `${code}.toBigIntMatrix()`,
-  ],
-  [/^string\[([0-9]+)?\]\[([0-9]+)?\]$/, 'Array<Array<string>>', code => `${code}.toStringMatrix()`],
-  [
-    /^tuple\[([0-9]+)?\]\[([0-9]+)?\]$/,
-    'Array<Array<ethereum.Tuple>>',
-    (code, type) => `${code}.toTupleMatrix<${type}>()`,
-  ],
-
-]
-
-/**
- * AssemblyScript -> ethereum.Value conversions
- *
- * Note: The order and patterns for conversions in this direction differ slightly
- * from ethereum.Value -> AssemblyScript, which is why there is a separate table
- * for them.
- */
-const ASSEMBLYSCRIPT_TO_ETHEREUM_VALUE = [
-  // Scalar values
-
-  ['Address', 'address', code => `ethereum.Value.fromAddress(${code})`],
-  ['boolean', 'bool', code => `ethereum.Value.fromBoolean(${code})`],
-  ['Bytes', 'byte', code => `ethereum.Value.fromFixedBytes(${code})`],
-  ['Bytes', 'bytes', code => `ethereum.Value.fromBytes(${code})`],
-  [
-    'Bytes',
-    /^bytes(1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|26|27|28|29|30|31|32)$/,
-    code => `ethereum.Value.fromFixedBytes(${code})`,
-  ],
-  ['i32', /^int(8|16|24|32)$/, code => `ethereum.Value.fromI32(${code})`],
-  [
-    'i32',
-    /^uint(8|16|24)$/,
-    code => `ethereum.Value.fromUnsignedBigInt(BigInt.fromI32(${code}))`,
-  ],
-  [
-    'BigInt',
-    /^int(40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)$/,
-    code => `ethereum.Value.fromSignedBigInt(${code})`,
-  ],
-  [
-    'BigInt',
-    /^uint(32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)$/,
-    code => `ethereum.Value.fromUnsignedBigInt(${code})`,
-  ],
-  ['string', 'string', code => `ethereum.Value.fromString(${code})`],
-
-  // Arrays
-
-  [
-    'Array<Address>',
-    /^address\[([0-9]+)?\]$/,
-    code => `ethereum.Value.fromAddressArray(${code})`,
-  ],
-  [
-    'Array<boolean>',
-    /^bool\[([0-9]+)?\]$/,
-    code => `ethereum.Value.fromBooleanArray(${code})`,
-  ],
-  [
-    'Array<Bytes>',
-    /^byte\[([0-9]+)?\]$/,
-    code => `ethereum.Value.fromFixedBytesArray(${code})`,
-  ],
-  [
-    'Array<Bytes>',
-    /bytes\[([0-9]+)?\]$/,
-    code => `ethereum.Value.fromBytesArray(${code})`,
-  ],
-  [
-    'Array<Bytes>',
-    /^bytes(1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|26|27|28|29|30|31|32)\[([0-9]+)?\]$/,
-    code => `ethereum.Value.fromFixedBytesArray(${code})`,
-  ],
-  [
-    'Array<i32>',
-    /^int(8|16|24|32)\[([0-9]+)?\]$/,
-    code => `ethereum.Value.fromI32Array(${code})`,
-  ],
-  [
-    'Array<i32>',
-    /^uint(8|16|24)\[([0-9]+)?\]$/,
-    code => `ethereum.Value.fromI32Array(${code})`,
-  ],
-  [
-    'Array<BigInt>',
-    /^int(40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)\[([0-9]+)?\]$/,
-    code => `ethereum.Value.fromSignedBigIntArray(${code})`,
-  ],
-  [
-    'Array<BigInt>',
-    /^uint(32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)\[([0-9]+)?\]$/,
-    code => `ethereum.Value.fromUnsignedBigIntArray(${code})`,
-  ],
-  [
-    'Array<string>',
-    /^string\[([0-9]+)?\]$/,
-    code => `ethereum.Value.fromStringArray(${code})`,
-  ],
-
-  // Tuples
-
-  ['ethereum.Tuple', 'tuple', code => `ethereum.Value.fromTuple(${code})`],
-  [
-    'Array<ethereum.Tuple>',
-    /^tuple\[([0-9]+)?\]$/,
-    code => `ethereum.Value.fromTupleArray(${code})`,
-  ],
-  
-  // Multi dimentional arrays
-
-  [
-    'Array<Array<Address>>',
-    /^address\[([0-9]+)?\]\[([0-9]+)?\]$/,
-    code => `ethereum.Value.fromAddressMatrix(${code})`,
-  ],
-  [
-    'Array<Array<boolean>>',
-    /^bool\[([0-9]+)?\]\[([0-9]+)?\]$/,
-    code => `ethereum.Value.fromBooleanMatrix(${code})`,
-  ],
-  [
-    'Array<Array<Bytes>>',
-    /^byte\[([0-9]+)?\]\[([0-9]+)?\]$/,
-    code => `ethereum.Value.fromFixedBytesMatrix(${code})`,
-  ],
-  [
-    'Array<Array<Bytes>>',
-    /bytes\[([0-9]+)?\]\[([0-9]+)?\]$/,
-    code => `ethereum.Value.fromBytesMatrix(${code})`,
-  ],
-  [
-    'Array<Array<Bytes>>',
-    /^bytes(1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|26|27|28|29|30|31|32)\[([0-9]+)?\]\[([0-9]+)?\]$/,
-    code => `ethereum.Value.fromFixedBytesMatrix(${code})`,
-  ],
-  [
-    'Array<Array<i32>>',
-    /^int(8|16|24|32)\[([0-9]+)?\]\[([0-9]+)?\]$/,
-    code => `ethereum.Value.fromI32Matrix(${code})`,
-  ],
-  [
-    'Array<Array<i32>>',
-    /^uint(8|16|24)\[([0-9]+)?\]\[([0-9]+)?\]$/,
-    code => `ethereum.Value.fromI32Matrix(${code})`,
-  ],
-  [
-    'Array<Array<BigInt>>',
-    /^int(40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)\[([0-9]+)?\]\[([0-9]+)?\]$/,
-    code => `ethereum.Value.fromSignedBigIntMatrix(${code})`,
-  ],
-  [
-    'Array<Array<BigInt>>',
-    /^uint(32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)\[([0-9]+)?\]\[([0-9]+)?\]$/,
-    code => `ethereum.Value.fromUnsignedBigIntMatrix(${code})`,
-  ],
-  [
-    'Array<Array<string>>',
-    /^string\[([0-9]+)?\]\[([0-9]+)?\]$/,
-    code => `ethereum.Value.fromStringMatrix(${code})`,
-  ],
-  [
-    'Array<Array<ethereum.Tuple>>',
-    /^tuple\[([0-9]+)?\]\[([0-9]+)?\]$/,
-    code => `ethereum.Value.fromTupleMatrix(${code})`,
-  ],
-]
-
-/**
- * Value -> AssemblyScript conversions
- */
-const VALUE_TO_ASSEMBLYSCRIPT = [
-  // Arrays
-
-  ['[Bytes]', 'Array<Bytes>', code => `${code}.toBytesArray()`],
-  ['[Boolean]', 'Array<boolean>', code => `${code}.toBooleanArray()`],
-  ['[Int]', 'Array<i32>', code => `${code}.toI32Array()`],
-  ['[BigInt]', 'Array<BigInt>', code => `${code}.toBigIntArray()`],
-  ['[ID]', 'Array<string>', code => `${code}.toStringArray()`],
-  ['[String]', 'Array<string>', code => `${code}.toStringArray()`],
-  ['[BigDecimal]', 'Array<BigDecimal>', code => `${code}.toBigDecimalArray()`],
-  [/\[.*\]/, 'Array<string>', code => `${code}.toStringArray()`],
-
-  // Scalar values
-
-  ['Bytes', 'Bytes', code => `${code}.toBytes()`],
-  ['Boolean', 'boolean', code => `${code}.toBoolean()`],
-  ['Int', 'i32', code => `${code}.toI32()`],
-  ['BigInt', 'BigInt', code => `${code}.toBigInt()`],
-  ['ID', 'string', code => `${code}.toString()`],
-  ['String', 'string', code => `${code}.toString()`],
-  ['BigDecimal', 'BigDecimal', code => `${code}.toBigDecimal()`],
-  [/.*/, 'string', code => `${code}.toString()`],
-]
-
-/**
- * AssemblyScript -> Value conversions
- *
- * Note: The order and patterns for conversions in this direction differ slightly
- * from Value -> AssemblyScript, which is why there is a separate table
- * for them.
- */
-const ASSEMBLYSCRIPT_TO_VALUE = [
-  // Matrices
-
-  ['Array<Array<Address>>', '[[Bytes]]', code => `Value.fromBytesMatrix(${code})`],
-  ['Array<Array<Bytes>>', '[[Bytes]]', code => `Value.fromBytesMatrix(${code})`],
-  ['Array<Array<boolean>>', '[[Boolean]]', code => `Value.fromBooleanMatrix(${code})`],
-  ['Array<Array<i32>>', '[[Int]]', code => `Value.fromI32Matrix(${code})`],
-  ['Array<Array<BigInt>>', '[[BigInt]]', code => `Value.fromBigIntMatrix(${code})`],
-  ['Array<Array<string>>', '[[String]]', code => `Value.fromStringMatrix(${code})`],
-  ['Array<Array<string>>', '[[ID]]', code => `Value.fromStringMatrix(${code})`],
-  ['Array<Array<BigDecimal>>', '[[BigDecimal]]', code => `Value.fromBigDecimalMatrix(${code})`],
-  ['Array<Array<string>>', /\[\[.*\]\]/, code => `Value.fromStringMatrix(${code})`],
-  ['Array<Array<string | null>>', null, code => `Value.fromStringMatrix(${code})`],// is this overwriting the Array null below?
-
-  // Arrays
-
-  ['Array<Address>', '[Bytes]', code => `Value.fromBytesArray(${code})`],
-  ['Array<Bytes>', '[Bytes]', code => `Value.fromBytesArray(${code})`],
-  ['Array<boolean>', '[Boolean]', code => `Value.fromBooleanArray(${code})`],
-  ['Array<i32>', '[Int]', code => `Value.fromI32Array(${code})`],
-  ['Array<BigInt>', '[BigInt]', code => `Value.fromBigIntArray(${code})`],
-  ['Array<string>', '[String]', code => `Value.fromStringArray(${code})`],
-  ['Array<string>', '[ID]', code => `Value.fromStringArray(${code})`],
-  ['Array<BigDecimal>', '[BigDecimal]', code => `Value.fromBigDecimalArray(${code})`],
-  ['Array<string>', /\[.*\]/, code => `Value.fromStringArray(${code})`],
-  ['Array<string | null>', null, code => `Value.fromStringArray(${code})`],
-
-  // Scalar values
-
-  ['Address', 'Bytes', code => `Value.fromBytes(${code})`],
-  ['Bytes', 'Bytes', code => `Value.fromBytes(${code})`],
-  ['boolean', 'Boolean', code => `Value.fromBoolean(${code})`],
-  ['i32', 'Int', code => `Value.fromI32(${code})`],
-  ['BigInt', 'BigInt', code => `Value.fromBigInt(${code})`],
-  ['string', 'String', code => `Value.fromString(${code})`],
-  ['string', 'ID', code => `Value.fromString(${code})`],
-  ['BigDecimal', 'BigDecimal', code => `Value.fromBigDecimal(${code})`],
-  ['string', /.*/, code => `Value.fromString(${code})`],
-]
-
-/**
- * Type conversions
- */
-module.exports = immutable.fromJS({
-  ethereum: {
-    AssemblyScript: ETHEREUM_VALUE_TO_ASSEMBLYSCRIPT,
-  },
-  AssemblyScript: {
-    ethereum: ASSEMBLYSCRIPT_TO_ETHEREUM_VALUE,
-    Value: ASSEMBLYSCRIPT_TO_VALUE,
-  },
-  Value: {
-    AssemblyScript: VALUE_TO_ASSEMBLYSCRIPT,
-  },
-})

package/src/command-helpers/fs.js

@@ -1,8 +0,0 @@
-const path = require('path')
-
-const displayPath = p =>
-  path.relative(process.cwd(), p)
-
-module.exports = {
-  displayPath,
-}

package/src/command-helpers/ipfs.js

@@ -1,6 +0,0 @@
-
-const DEFAULT_IPFS_URL = 'https://api.thegraph.com/ipfs/'
-
-module.exports = {
-  DEFAULT_IPFS_URL
-}

package/src/command-helpers/studio.js

@@ -1,15 +0,0 @@
-const allowedStudioNetworks = ['mainnet', 'rinkeby', 'goerli', 'gnosis']
-
-const validateStudioNetwork = ({ studio, product, network }) => {
-  let isStudio = studio || product === 'subgraph-studio'
-  let isAllowedNetwork = allowedStudioNetworks.includes(network)
-
-  if (isStudio && !isAllowedNetwork) {
-    throw new Error(`The Subgraph Studio only allows subgraphs for these networks: ${allowedStudioNetworks.join(', ')}`)
-  }
-}
-
-module.exports = {
-  allowedStudioNetworks,
-  validateStudioNetwork,
-}

package/src/protocols/arweave/subgraph.js

@@ -1,20 +0,0 @@
-const immutable = require('immutable')
-
-module.exports = class ArweaveSubgraph {
-  constructor(options = {}) {
-    this.manifest = options.manifest
-    this.resolveFile = options.resolveFile
-    this.protocol = options.protocol
-  }
-
-  validateManifest() {
-    return immutable.List()
-  }
-
-  handlerTypes() {
-    return immutable.List([
-      'blockHandlers',
-      'transactionHandlers',
-    ])
-  }
-}

package/src/protocols/substreams/subgraph.js

@@ -1,17 +0,0 @@
-const immutable = require('immutable')
-
-module.exports = class SubstreamsSubgraph {
-  constructor(options = {}) {
-    this.manifest = options.manifest
-    this.resolveFile = options.resolveFile
-    this.protocol = options.protocol
-  }
-
-  validateManifest() {
-    return immutable.List()
-  }
-
-  handlerTypes() {
-    return immutable.List([])
-  }
-}

package/src/schema.js

@@ -1,23 +0,0 @@
-let fs = require('fs-extra')
-let graphql = require('graphql/language')
-let immutable = require('immutable')
-
-let SchemaCodeGenerator = require('./codegen/schema')
-
-module.exports = class Schema {
-  constructor(filename, document, ast) {
-    this.filename = filename
-    this.document = document
-    this.ast = ast
-  }
-
-  codeGenerator() {
-    return new SchemaCodeGenerator(this)
-  }
-
-  static async load(filename) {
-    let document = await fs.readFile(filename, 'utf-8')
-    let ast = graphql.parse(document)
-    return new Schema(filename, document, immutable.fromJS(ast))
-  }
-}