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

package/src/command-helpers/studio.test.js

@@ -1,52 +1,83 @@
-const { validateStudioNetwork, allowedStudioNetworks } = require('./studio')
+import { validateStudioNetwork, allowedStudioNetworks } from './studio'
 
 describe('Version Command Helpers', () => {
   describe('validateStudioNetwork', () => {
     describe("When it's studio", () => {
       test("And it's Ethereum mainnet", () => {
-        expect(() => validateStudioNetwork({
-          studio: true,
-          network: 'mainnet',
-        }))
-          .not
-          .toThrow(new Error(`The Subgraph Studio only allows subgraphs for these networks: ${allowedStudioNetworks.join(', ')}`))
+        expect(() =>
+          validateStudioNetwork({
+            studio: true,
+            network: 'mainnet',
+          }),
+        ).not.toThrow(
+          new Error(
+            `The Subgraph Studio only allows subgraphs for these networks: ${allowedStudioNetworks.join(
+              ', ',
+            )}`,
+          ),
+        )
       })
 
       test("And it's Gnosis chain", () => {
-        expect(() => validateStudioNetwork({
-          studio: true,
-          network: 'gnosis',
-        }))
-          .not
-          .toThrow(new Error(`The Subgraph Studio only allows subgraphs for these networks: ${allowedStudioNetworks.join(', ')}`))
+        expect(() =>
+          validateStudioNetwork({
+            studio: true,
+            network: 'gnosis',
+          }),
+        ).not.toThrow(
+          new Error(
+            `The Subgraph Studio only allows subgraphs for these networks: ${allowedStudioNetworks.join(
+              ', ',
+            )}`,
+          ),
+        )
       })
 
       test("And it's NOT an allowed network", () => {
-        expect(() => validateStudioNetwork({
-          product: 'subgraph-studio',
-          network: 'celo',
-        }))
-          .toThrow(new Error(`The Subgraph Studio only allows subgraphs for these networks: ${allowedStudioNetworks.join(', ')}`))
+        expect(() =>
+          validateStudioNetwork({
+            product: 'subgraph-studio',
+            network: 'celo',
+          }),
+        ).toThrow(
+          new Error(
+            `The Subgraph Studio only allows subgraphs for these networks: ${allowedStudioNetworks.join(
+              ', ',
+            )}`,
+          ),
+        )
       })
     })
 
     describe("When it's NOT studio", () => {
       test("And it's Rinkeby", () => {
-        expect(() => validateStudioNetwork({
-          studio: false,
-          network: 'rinkeby',
-        }))
-          .not
-          .toThrow(new Error(`The Subgraph Studio only allows subgraphs for these networks: ${allowedStudioNetworks.join(', ')}`))
+        expect(() =>
+          validateStudioNetwork({
+            studio: false,
+            network: 'rinkeby',
+          }),
+        ).not.toThrow(
+          new Error(
+            `The Subgraph Studio only allows subgraphs for these networks: ${allowedStudioNetworks.join(
+              ', ',
+            )}`,
+          ),
+        )
       })
 
       test("And it's NOT an allowed network", () => {
-        expect(() => validateStudioNetwork({
-          product: 'hosted-service',
-          network: 'celo',
-        }))
-          .not
-          .toThrow(new Error(`The Subgraph Studio only allows subgraphs for these networks: ${allowedStudioNetworks.join(', ')}`))
+        expect(() =>
+          validateStudioNetwork({
+            product: 'hosted-service',
+            network: 'celo',
+          }),
+        ).not.toThrow(
+          new Error(
+            `The Subgraph Studio only allows subgraphs for these networks: ${allowedStudioNetworks.join(
+              ', ',
+            )}`,
+          ),
+        )
       })
     })
   })

package/src/command-helpers/studio.ts

@@ -0,0 +1,20 @@
+const allowedStudioNetworks = ['mainnet', 'rinkeby', 'goerli', 'gnosis'] as const
+
+const validateStudioNetwork = ({ studio, product, network }:{
+  studio?: boolean
+  product?: 'subgraph-studio'
+  network: typeof allowedStudioNetworks[number]
+}) => {
+  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(
+        ', ',
+      )}`,
+    )
+  }
+}
+
+export { allowedStudioNetworks, validateStudioNetwork }

package/src/command-helpers/{subgraph.js → subgraph.ts}

@@ -1,4 +1,7 @@
-const validateSubgraphName = (name, { allowSimpleName }) => {
+const validateSubgraphName = (
+  name: string,
+  { allowSimpleName }: { allowSimpleName: string },
+) => {
   if (allowSimpleName) {
     return name
   } else {
@@ -13,12 +16,9 @@ You can bypass this check with --allow-simple-name.`)
   }
 }
 
-const getSubgraphBasename = name => {
+const getSubgraphBasename = (name: string) => {
   let segments = name.split('/', 2)
   return segments[segments.length - 1]
 }
 
-module.exports = {
-  validateSubgraphName,
-  getSubgraphBasename,
-}
+export { validateSubgraphName, getSubgraphBasename }

package/src/command-helpers/version.js

@@ -1,15 +1,12 @@
-const semver = require('semver')
-const graphTsUtil = require('../migrations/util/versions')
-const manifestUtil = require('../migrations/util/load-manifest')
+import semver from 'semver'
+import * as graphTsUtil from '../migrations/util/versions'
+import * as manifestUtil from '../migrations/util/load-manifest'
 
 const assertManifestApiVersion = async (manifestPath, minimumApiVersion) => {
   let manifest = await manifestUtil.loadManifest(manifestPath)
 
   let lessThanMinimumVersion = manifestApiVersion =>
-    semver.lt(
-      manifestApiVersion,
-      minimumApiVersion,
-    )
+    semver.lt(manifestApiVersion, minimumApiVersion)
 
   let isLessThanMinimumVersion = false
 
@@ -20,25 +17,26 @@ const assertManifestApiVersion = async (manifestPath, minimumApiVersion) => {
           dataSource &&
           dataSource.mapping &&
           dataSource.mapping.apiVersion &&
-          lessThanMinimumVersion(dataSource.mapping.apiVersion)
+          lessThanMinimumVersion(dataSource.mapping.apiVersion),
       )
     }
 
     if (manifest.templates && Array.isArray(manifest.templates)) {
-      isLessThanMinimumVersion = isLessThanMinimumVersion ||
+      isLessThanMinimumVersion =
+        isLessThanMinimumVersion ||
         manifest.templates.some(
           template =>
             template &&
             template.mapping &&
             template.mapping.apiVersion &&
-            lessThanMinimumVersion(template.mapping.apiVersion)
+            lessThanMinimumVersion(template.mapping.apiVersion),
         )
     }
   }
 
   if (isLessThanMinimumVersion) {
     throw new Error(
-      `The current version of graph-cli can't be used with mappings on apiVersion less than '${minimumApiVersion}'`
+      `The current version of graph-cli can't be used with mappings on apiVersion less than '${minimumApiVersion}'`,
     )
   }
 }
@@ -57,12 +55,9 @@ const assertGraphTsVersion = async (sourceDir, minimumGraphTsVersion) => {
   if (graphTsVersion && semver.lt(semver.coerce(graphTsVersion), minimumGraphTsVersion)) {
     throw new Error(
       `To use this version of the graph-cli you must upgrade the graph-ts dependency to a version greater than or equal to ${minimumGraphTsVersion}
-Also, you'll probably need to take a look at our AssemblyScript migration guide because of language breaking changes: https://thegraph.com/docs/developer/assemblyscript-migration-guide`
+Also, you'll probably need to take a look at our AssemblyScript migration guide because of language breaking changes: https://thegraph.com/docs/developer/assemblyscript-migration-guide`,
     )
   }
 }
 
-module.exports = {
-  assertManifestApiVersion,
-  assertGraphTsVersion,
-}
+export { assertManifestApiVersion, assertGraphTsVersion }

package/src/command-helpers/version.test.js

@@ -1,6 +1,6 @@
-const { assertManifestApiVersion, assertGraphTsVersion } = require('./version')
-const loadManifestUtil = require('../migrations/util/load-manifest')
-const graphTsUtil = require('../migrations/util/versions')
+import { assertManifestApiVersion, assertGraphTsVersion } from './version'
+import * as loadManifestUtil from '../migrations/util/load-manifest'
+import * as graphTsUtil from '../migrations/util/versions'
 
 describe('Version Command Helpers', () => {
   describe('assertManifestApiVersion', () => {
@@ -9,57 +9,64 @@ describe('Version Command Helpers', () => {
 
     describe('With just dataSources', () => {
       test('When all of them are less than minimum apiVersion', async () => {
-        loadManifestUtil.loadManifest = jest.fn()
-          .mockImplementation(() => Promise.resolve({
+        loadManifestUtil.loadManifest = jest.fn().mockImplementation(() =>
+          Promise.resolve({
             dataSources: [
               { mapping: { apiVersion: '0.0.1' } },
               { mapping: { apiVersion: '0.0.2' } },
               { mapping: { apiVersion: '0.0.3' } },
             ],
-          }))
+          }),
+        )
 
-        await expect(assertManifestApiVersion(fakeManifestPath, minimumApiVersion))
-          .rejects
-          .toThrow(new Error(
-            `The current version of graph-cli can't be used with mappings on apiVersion less than '${minimumApiVersion}'`
-          ))
+        await expect(
+          assertManifestApiVersion(fakeManifestPath, minimumApiVersion),
+        ).rejects.toThrow(
+          new Error(
+            `The current version of graph-cli can't be used with mappings on apiVersion less than '${minimumApiVersion}'`,
+          ),
+        )
       })
       test('When one of them is less than minimum apiVersion', async () => {
-        loadManifestUtil.loadManifest = jest.fn()
-          .mockImplementation(() => Promise.resolve({
+        loadManifestUtil.loadManifest = jest.fn().mockImplementation(() =>
+          Promise.resolve({
             dataSources: [
               { mapping: { apiVersion: '0.0.5' } },
               { mapping: { apiVersion: '0.0.2' } },
               { mapping: { apiVersion: '0.0.5' } },
             ],
-          }))
+          }),
+        )
 
-        await expect(assertManifestApiVersion(fakeManifestPath, minimumApiVersion))
-          .rejects
-          .toThrow(new Error(
-            `The current version of graph-cli can't be used with mappings on apiVersion less than '${minimumApiVersion}'`
-          ))
+        await expect(
+          assertManifestApiVersion(fakeManifestPath, minimumApiVersion),
+        ).rejects.toThrow(
+          new Error(
+            `The current version of graph-cli can't be used with mappings on apiVersion less than '${minimumApiVersion}'`,
+          ),
+        )
       })
       test('When none of them are less than minimum apiVersion', async () => {
-        loadManifestUtil.loadManifest = jest.fn()
-          .mockImplementation(() => Promise.resolve({
+        loadManifestUtil.loadManifest = jest.fn().mockImplementation(() =>
+          Promise.resolve({
             dataSources: [
               { mapping: { apiVersion: '0.0.5' } },
               { mapping: { apiVersion: '0.0.6' } },
               { mapping: { apiVersion: '0.0.5' } },
             ],
-          }))
+          }),
+        )
 
-        await expect(assertManifestApiVersion(fakeManifestPath, minimumApiVersion))
-          .resolves
-          .toBe(undefined)
+        await expect(
+          assertManifestApiVersion(fakeManifestPath, minimumApiVersion),
+        ).resolves.toBe(undefined)
       })
     })
     describe('With dataSources and templates', () => {
       describe('And the dataSources have a lower apiVersion', () => {
         test('When all of the templates are less than minimum apiVersion', async () => {
-          loadManifestUtil.loadManifest = jest.fn()
-            .mockImplementation(() => Promise.resolve({
+          loadManifestUtil.loadManifest = jest.fn().mockImplementation(() =>
+            Promise.resolve({
               dataSources: [
                 { mapping: { apiVersion: '0.0.5' } },
                 { mapping: { apiVersion: '0.0.5' } },
@@ -70,17 +77,20 @@ describe('Version Command Helpers', () => {
                 { mapping: { apiVersion: '0.0.2' } },
                 { mapping: { apiVersion: '0.0.3' } },
               ],
-            }))
+            }),
+          )
 
-          await expect(assertManifestApiVersion(fakeManifestPath, minimumApiVersion))
-            .rejects
-            .toThrow(new Error(
-              `The current version of graph-cli can't be used with mappings on apiVersion less than '${minimumApiVersion}'`
-            ))
+          await expect(
+            assertManifestApiVersion(fakeManifestPath, minimumApiVersion),
+          ).rejects.toThrow(
+            new Error(
+              `The current version of graph-cli can't be used with mappings on apiVersion less than '${minimumApiVersion}'`,
+            ),
+          )
         })
         test('When one of the templates is less than minimum apiVersion', async () => {
-          loadManifestUtil.loadManifest = jest.fn()
-            .mockImplementation(() => Promise.resolve({
+          loadManifestUtil.loadManifest = jest.fn().mockImplementation(() =>
+            Promise.resolve({
               dataSources: [
                 { mapping: { apiVersion: '0.0.5' } },
                 { mapping: { apiVersion: '0.0.5' } },
@@ -91,17 +101,20 @@ describe('Version Command Helpers', () => {
                 { mapping: { apiVersion: '0.0.2' } },
                 { mapping: { apiVersion: '0.0.5' } },
               ],
-            }))
+            }),
+          )
 
-          await expect(assertManifestApiVersion(fakeManifestPath, minimumApiVersion))
-            .rejects
-            .toThrow(new Error(
-              `The current version of graph-cli can't be used with mappings on apiVersion less than '${minimumApiVersion}'`
-            ))
+          await expect(
+            assertManifestApiVersion(fakeManifestPath, minimumApiVersion),
+          ).rejects.toThrow(
+            new Error(
+              `The current version of graph-cli can't be used with mappings on apiVersion less than '${minimumApiVersion}'`,
+            ),
+          )
         })
         test('When none of the templates are less than minimum apiVersion', async () => {
-          loadManifestUtil.loadManifest = jest.fn()
-            .mockImplementation(() => Promise.resolve({
+          loadManifestUtil.loadManifest = jest.fn().mockImplementation(() =>
+            Promise.resolve({
               dataSources: [
                 { mapping: { apiVersion: '0.0.5' } },
                 { mapping: { apiVersion: '0.0.5' } },
@@ -112,19 +125,22 @@ describe('Version Command Helpers', () => {
                 { mapping: { apiVersion: '0.0.6' } },
                 { mapping: { apiVersion: '0.0.5' } },
               ],
-            }))
+            }),
+          )
 
-          await expect(assertManifestApiVersion(fakeManifestPath, minimumApiVersion))
-            .rejects
-            .toThrow(new Error(
-              `The current version of graph-cli can't be used with mappings on apiVersion less than '${minimumApiVersion}'`
-            ))
+          await expect(
+            assertManifestApiVersion(fakeManifestPath, minimumApiVersion),
+          ).rejects.toThrow(
+            new Error(
+              `The current version of graph-cli can't be used with mappings on apiVersion less than '${minimumApiVersion}'`,
+            ),
+          )
         })
       })
       describe('And the dataSources do NOT have a lower apiVersion', () => {
         test('When all of the templates are less than minimum apiVersion', async () => {
-          loadManifestUtil.loadManifest = jest.fn()
-            .mockImplementation(() => Promise.resolve({
+          loadManifestUtil.loadManifest = jest.fn().mockImplementation(() =>
+            Promise.resolve({
               dataSources: [
                 { mapping: { apiVersion: '0.0.5' } },
                 { mapping: { apiVersion: '0.0.5' } },
@@ -135,17 +151,20 @@ describe('Version Command Helpers', () => {
                 { mapping: { apiVersion: '0.0.2' } },
                 { mapping: { apiVersion: '0.0.3' } },
               ],
-            }))
+            }),
+          )
 
-          await expect(assertManifestApiVersion(fakeManifestPath, minimumApiVersion))
-            .rejects
-            .toThrow(new Error(
-              `The current version of graph-cli can't be used with mappings on apiVersion less than '${minimumApiVersion}'`
-            ))
+          await expect(
+            assertManifestApiVersion(fakeManifestPath, minimumApiVersion),
+          ).rejects.toThrow(
+            new Error(
+              `The current version of graph-cli can't be used with mappings on apiVersion less than '${minimumApiVersion}'`,
+            ),
+          )
         })
         test('When one of the templates is less than minimum apiVersion', async () => {
-          loadManifestUtil.loadManifest = jest.fn()
-            .mockImplementation(() => Promise.resolve({
+          loadManifestUtil.loadManifest = jest.fn().mockImplementation(() =>
+            Promise.resolve({
               dataSources: [
                 { mapping: { apiVersion: '0.0.5' } },
                 { mapping: { apiVersion: '0.0.5' } },
@@ -156,17 +175,20 @@ describe('Version Command Helpers', () => {
                 { mapping: { apiVersion: '0.0.2' } },
                 { mapping: { apiVersion: '0.0.5' } },
               ],
-            }))
+            }),
+          )
 
-          await expect(assertManifestApiVersion(fakeManifestPath, minimumApiVersion))
-            .rejects
-            .toThrow(new Error(
-              `The current version of graph-cli can't be used with mappings on apiVersion less than '${minimumApiVersion}'`
-            ))
+          await expect(
+            assertManifestApiVersion(fakeManifestPath, minimumApiVersion),
+          ).rejects.toThrow(
+            new Error(
+              `The current version of graph-cli can't be used with mappings on apiVersion less than '${minimumApiVersion}'`,
+            ),
+          )
         })
         test('When none of the templates are less than minimum apiVersion', async () => {
-          loadManifestUtil.loadManifest = jest.fn()
-            .mockImplementation(() => Promise.resolve({
+          loadManifestUtil.loadManifest = jest.fn().mockImplementation(() =>
+            Promise.resolve({
               dataSources: [
                 { mapping: { apiVersion: '0.0.5' } },
                 { mapping: { apiVersion: '0.0.5' } },
@@ -177,11 +199,12 @@ describe('Version Command Helpers', () => {
                 { mapping: { apiVersion: '0.0.6' } },
                 { mapping: { apiVersion: '0.0.5' } },
               ],
-            }))
+            }),
+          )
 
-          await expect(assertManifestApiVersion(fakeManifestPath, minimumApiVersion))
-            .resolves
-            .toBe(undefined)
+          await expect(
+            assertManifestApiVersion(fakeManifestPath, minimumApiVersion),
+          ).resolves.toBe(undefined)
         })
       })
     })
@@ -190,22 +213,28 @@ describe('Version Command Helpers', () => {
     const fakeNodeModulesDir = 'fake/path/to/node/modules'
     const minimumGraphTsVersion = '0.22.0'
 
-    test('When the installed graph-ts version is less than what\'s supported', async () => {
-      graphTsUtil.getGraphTsVersion = jest.fn().mockImplementation(() => Promise.resolve('0.19.0'))
+    test("When the installed graph-ts version is less than what's supported", async () => {
+      graphTsUtil.getGraphTsVersion = jest
+        .fn()
+        .mockImplementation(() => Promise.resolve('0.19.0'))
 
-      await expect(assertGraphTsVersion(fakeNodeModulesDir, minimumGraphTsVersion))
-        .rejects
-        .toThrow(new Error(
+      await expect(
+        assertGraphTsVersion(fakeNodeModulesDir, minimumGraphTsVersion),
+      ).rejects.toThrow(
+        new Error(
           `To use this version of the graph-cli you must upgrade the graph-ts dependency to a version greater than or equal to ${minimumGraphTsVersion}
-Also, you'll probably need to take a look at our AssemblyScript migration guide because of language breaking changes: https://thegraph.com/docs/developer/assemblyscript-migration-guide`
-        ))
+Also, you'll probably need to take a look at our AssemblyScript migration guide because of language breaking changes: https://thegraph.com/docs/developer/assemblyscript-migration-guide`,
+        ),
+      )
     })
     test('When the installed graph-ts version is a supported one', async () => {
-      graphTsUtil.getGraphTsVersion = jest.fn().mockImplementation(() => Promise.resolve('0.22.0'))
+      graphTsUtil.getGraphTsVersion = jest
+        .fn()
+        .mockImplementation(() => Promise.resolve('0.22.0'))
 
-      await expect(assertGraphTsVersion(fakeNodeModulesDir, minimumGraphTsVersion))
-        .resolves
-        .toBe(undefined)
+      await expect(
+        assertGraphTsVersion(fakeNodeModulesDir, minimumGraphTsVersion),
+      ).resolves.toBe(undefined)
     })
   })
 })