@graphprotocol/graph-cli 0.64.0 → 0.64.1-alpha-20231218145603-ee88ea0

package/dist/codegen/util.test.js

@@ -1,19 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
 const util_1 = require("./util");
-describe('Codegen utilities', () => {
-    test('Name disambiguation', () => {
-        expect((0, util_1.disambiguateNames)({
+vitest_1.describe.concurrent('Codegen utilities', () => {
+    (0, vitest_1.test)('Name disambiguation', () => {
+        (0, vitest_1.expect)((0, util_1.disambiguateNames)({
             values: ['a', 'b', 'c'],
             getName: x => x,
             setName: (_x, name) => name,
         })).toEqual(['a', 'b', 'c']);
-        expect((0, util_1.disambiguateNames)({
+        (0, vitest_1.expect)((0, util_1.disambiguateNames)({
             values: ['a', 'a', 'a'],
             getName: x => x,
             setName: (_x, name) => name,
         })).toEqual(['a', 'a1', 'a2']);
-        expect((0, util_1.disambiguateNames)({
+        (0, vitest_1.expect)((0, util_1.disambiguateNames)({
             values: [
                 { name: 'ExampleEvent', inputs: [] },
                 { name: 'ExampleEvent', inputs: [{ type: 'uint256' }] },
@@ -30,13 +31,13 @@ describe('Codegen utilities', () => {
             { name: 'ExampleEvent2', inputs: [{ type: 'uint96' }] },
         ]);
     });
-    test('Tuple unrolling', () => {
-        expect((0, util_1.unrollTuple)({
+    (0, vitest_1.test)('Tuple unrolling', () => {
+        (0, vitest_1.expect)((0, util_1.unrollTuple)({
             value: { type: 'tuple', name: 'value', components: [] },
             path: ['value'],
             index: 0,
         })).toEqual([]);
-        expect((0, util_1.unrollTuple)({
+        (0, vitest_1.expect)((0, util_1.unrollTuple)({
             value: {
                 type: 'tuple',
                 name: 'value',
@@ -45,7 +46,7 @@ describe('Codegen utilities', () => {
             path: ['value'],
             index: 0,
         })).toEqual([{ path: ['value', 'a'], type: 'string' }]);
-        expect((0, util_1.unrollTuple)({
+        (0, vitest_1.expect)((0, util_1.unrollTuple)({
             value: {
                 type: 'tuple',
                 name: 'value',
@@ -60,7 +61,7 @@ describe('Codegen utilities', () => {
             { path: ['value', 'a'], type: 'string' },
             { path: ['value', 'b'], type: 'uint256' },
         ]);
-        expect((0, util_1.unrollTuple)({
+        (0, vitest_1.expect)((0, util_1.unrollTuple)({
             value: {
                 type: 'tuple',
                 name: 'value',

package/dist/command-helpers/abi.test.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
 const abi_1 = require("./abi");
 // An object with some test cases for contract deployment block numbers
 const TEST_CONTRACT_START_BLOCKS = {
@@ -82,13 +83,13 @@ const TEST_CONTRACT_START_BLOCKS = {
     // },
 };
 // skip this test since its time consuming
-describe.skip('getStartBlockForContract', () => {
+vitest_1.describe.skip('getStartBlockForContract', () => {
     for (const [network, contracts] of Object.entries(TEST_CONTRACT_START_BLOCKS)) {
         for (const [contract, startBlockExp] of Object.entries(contracts)) {
-            test(`Returns the start block ${network} ${contract} ${startBlockExp}`, async () => {
+            (0, vitest_1.test)(`Returns the start block ${network} ${contract} ${startBlockExp}`, async () => {
                 //loop through the TEST_CONTRACT_START_BLOCKS object and test each network
                 const startBlock = await (0, abi_1.getStartBlockForContract)(network, contract);
-                expect(startBlock).toBe(startBlockExp);
+                (0, vitest_1.expect)(startBlock).toBe(startBlockExp);
             });
         }
     }

package/dist/command-helpers/compiler.test.js

@@ -1,26 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
 const compiler_1 = require("./compiler");
-describe('appendApiVersionForGraph', () => {
-    it('append /api/v0 to Prod URL with trailing slash', () => {
-        expect((0, compiler_1.appendApiVersionForGraph)('https://api.thegraph.com/ipfs/')).toBe('https://api.thegraph.com/ipfs/api/v0');
+vitest_1.describe.concurrent('appendApiVersionForGraph', () => {
+    (0, vitest_1.it)('append /api/v0 to Prod URL with trailing slash', () => {
+        (0, vitest_1.expect)((0, compiler_1.appendApiVersionForGraph)('https://api.thegraph.com/ipfs/')).toBe('https://api.thegraph.com/ipfs/api/v0');
     });
-    it('append /api/v0 to Prod URL without trailing slash', () => {
-        expect((0, compiler_1.appendApiVersionForGraph)('https://api.thegraph.com/ipfs')).toBe('https://api.thegraph.com/ipfs/api/v0');
+    (0, vitest_1.it)('append /api/v0 to Prod URL without trailing slash', () => {
+        (0, vitest_1.expect)((0, compiler_1.appendApiVersionForGraph)('https://api.thegraph.com/ipfs')).toBe('https://api.thegraph.com/ipfs/api/v0');
     });
-    it('append /api/v0 to Staging URL without trailing slash', () => {
-        expect((0, compiler_1.appendApiVersionForGraph)('https://staging.api.thegraph.com/ipfs')).toBe('https://staging.api.thegraph.com/ipfs/api/v0');
+    (0, vitest_1.it)('append /api/v0 to Staging URL without trailing slash', () => {
+        (0, vitest_1.expect)((0, compiler_1.appendApiVersionForGraph)('https://staging.api.thegraph.com/ipfs')).toBe('https://staging.api.thegraph.com/ipfs/api/v0');
     });
-    it('do nothing if Prod URL has /api/v0', () => {
-        expect((0, compiler_1.appendApiVersionForGraph)('https://api.thegraph.com/ipfs/api/v0')).toBe('https://api.thegraph.com/ipfs/api/v0');
+    (0, vitest_1.it)('do nothing if Prod URL has /api/v0', () => {
+        (0, vitest_1.expect)((0, compiler_1.appendApiVersionForGraph)('https://api.thegraph.com/ipfs/api/v0')).toBe('https://api.thegraph.com/ipfs/api/v0');
     });
-    it('do nothing if Prod URL has no /ipfs', () => {
-        expect((0, compiler_1.appendApiVersionForGraph)('https://api.thegraph.com')).toBe('https://api.thegraph.com');
+    (0, vitest_1.it)('do nothing if Prod URL has no /ipfs', () => {
+        (0, vitest_1.expect)((0, compiler_1.appendApiVersionForGraph)('https://api.thegraph.com')).toBe('https://api.thegraph.com');
     });
-    it('do nothing for non-graph endpoint', () => {
-        expect((0, compiler_1.appendApiVersionForGraph)('https://ipfs.saihaj.dev/')).toBe('https://ipfs.saihaj.dev/');
+    (0, vitest_1.it)('do nothing for non-graph endpoint', () => {
+        (0, vitest_1.expect)((0, compiler_1.appendApiVersionForGraph)('https://ipfs.saihaj.dev/')).toBe('https://ipfs.saihaj.dev/');
     });
-    it('do nothing for non-graph endpoint ending with /ipfs', () => {
-        expect((0, compiler_1.appendApiVersionForGraph)('https://ipfs.saihaj.dev/ipfs/')).toBe('https://ipfs.saihaj.dev/ipfs/');
+    (0, vitest_1.it)('do nothing for non-graph endpoint ending with /ipfs', () => {
+        (0, vitest_1.expect)((0, compiler_1.appendApiVersionForGraph)('https://ipfs.saihaj.dev/ipfs/')).toBe('https://ipfs.saihaj.dev/ipfs/');
     });
 });

package/dist/command-helpers/network.test.js

@@ -28,20 +28,21 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const path_1 = __importDefault(require("path"));
 const toolbox = __importStar(require("gluegun"));
+const vitest_1 = require("vitest");
 const yaml_1 = __importDefault(require("yaml"));
 const network_1 = require("./network");
 const SUBGRAPH_PATH_BASE = path_1.default.join(__dirname, '..', '..', '..', '..', 'examples', 'example-subgraph');
-describe('initNetworksConfig', () => {
-    beforeAll(async () => {
+vitest_1.describe.concurrent('initNetworksConfig', () => {
+    (0, vitest_1.beforeAll)(async () => {
         await (0, network_1.initNetworksConfig)(SUBGRAPH_PATH_BASE, 'address');
     });
-    afterAll(async () => {
+    (0, vitest_1.afterAll)(async () => {
         toolbox.filesystem.remove(`${SUBGRAPH_PATH_BASE}/networks.json`);
     });
-    test('generates networks.json from subgraph.yaml', () => {
-        expect(toolbox.filesystem.exists(`${SUBGRAPH_PATH_BASE}/networks.json`)).toBe('file');
+    (0, vitest_1.test)('generates networks.json from subgraph.yaml', () => {
+        (0, vitest_1.expect)(toolbox.filesystem.exists(`${SUBGRAPH_PATH_BASE}/networks.json`)).toBe('file');
     });
-    test('Populates the networks.json file with the data from subgraph.yaml', async () => {
+    (0, vitest_1.test)('Populates the networks.json file with the data from subgraph.yaml', async () => {
         const networksStr = toolbox.filesystem.read(`${SUBGRAPH_PATH_BASE}/networks.json`);
         const networks = JSON.parse(networksStr);
         const expected = {
@@ -49,11 +50,11 @@ describe('initNetworksConfig', () => {
                 ExampleSubgraph: { address: '0x22843e74c59580b3eaf6c233fa67d8b7c561a835' },
             },
         };
-        expect(networks).toStrictEqual(expected);
+        (0, vitest_1.expect)(networks).toStrictEqual(expected);
     });
 });
-describe('updateSubgraphNetwork', () => {
-    beforeAll(async () => {
+vitest_1.describe.concurrent('updateSubgraphNetwork', () => {
+    (0, vitest_1.beforeAll)(async () => {
         const content = {
             optimism: {
                 ExampleSubgraph: { address: '0x12345...' },
@@ -62,25 +63,25 @@ describe('updateSubgraphNetwork', () => {
         toolbox.filesystem.write(`${SUBGRAPH_PATH_BASE}/networks.json`, content);
         toolbox.filesystem.copy(`${SUBGRAPH_PATH_BASE}/subgraph.yaml`, `${SUBGRAPH_PATH_BASE}/subgraph_copy.yaml`);
     });
-    afterAll(async () => {
+    (0, vitest_1.afterAll)(async () => {
         toolbox.filesystem.remove(`${SUBGRAPH_PATH_BASE}/networks.json`);
         toolbox.filesystem.remove(`${SUBGRAPH_PATH_BASE}/subgraph_copy.yaml`);
     });
-    test('Updates subgraph.yaml', async () => {
+    (0, vitest_1.test)('Updates subgraph.yaml', async () => {
         const manifest = `${SUBGRAPH_PATH_BASE}/subgraph_copy.yaml`;
         const networksFie = `${SUBGRAPH_PATH_BASE}/networks.json`;
         let subgraph = toolbox.filesystem.read(manifest);
         let subgraphObj = yaml_1.default.parse(subgraph);
         let network = subgraphObj.dataSources[0].network;
         let address = subgraphObj.dataSources[0].source.address;
-        expect(network).toBe('mainnet');
-        expect(address).toBe('0x22843e74c59580b3eaf6c233fa67d8b7c561a835');
+        (0, vitest_1.expect)(network).toBe('mainnet');
+        (0, vitest_1.expect)(address).toBe('0x22843e74c59580b3eaf6c233fa67d8b7c561a835');
         await (0, network_1.updateSubgraphNetwork)(manifest, 'optimism', networksFie, 'address');
         subgraph = toolbox.filesystem.read(manifest);
         subgraphObj = yaml_1.default.parse(subgraph);
         network = subgraphObj.dataSources[0].network;
         address = subgraphObj.dataSources[0].source.address;
-        expect(network).toBe('optimism');
-        expect(address).toBe('0x12345...');
+        (0, vitest_1.expect)(network).toBe('optimism');
+        (0, vitest_1.expect)(address).toBe('0x12345...');
     });
 });

package/dist/command-helpers/scaffold.d.ts

@@ -15,26 +15,26 @@ export declare const generateScaffold: ({ protocolInstance, abi, contract, netwo
     node?: string | undefined;
     spkgPath?: string | undefined;
 }, spinner: Spinner) => Promise<{
-    'subgraph.yaml': Promise<string>;
-    'schema.graphql': Promise<string>;
-    'package.json': Promise<string>;
+    'subgraph.yaml': string;
+    'schema.graphql': string;
+    'package.json': string;
     'tsconfig.json'?: undefined;
     src?: undefined;
     abis?: undefined;
     tests?: undefined;
 } | {
-    'package.json': Promise<string>;
-    'subgraph.yaml': Promise<string>;
-    'schema.graphql': Promise<string>;
-    'tsconfig.json': Promise<string>;
+    'package.json': string;
+    'subgraph.yaml': string;
+    'schema.graphql': string;
+    'tsconfig.json': string;
     src: {
-        [x: string]: Promise<string>;
+        [x: string]: string;
     } | undefined;
     abis: {
-        [x: string]: Promise<string>;
+        [x: string]: string;
     } | undefined;
     tests: {
-        [x: string]: Promise<string>;
+        [x: string]: string;
     } | undefined;
 }>;
 export declare const writeScaffold: (scaffold: any, directory: string, spinner: Spinner) => Promise<void>;

package/dist/command-helpers/scaffold.js

@@ -42,7 +42,7 @@ const generateScaffold = async ({ protocolInstance, abi, contract, network, subg
         node,
         spkgPath,
     });
-    return scaffold.generate();
+    return await scaffold.generate();
 };
 exports.generateScaffold = generateScaffold;
 const writeScaffoldDirectory = async (scaffold, directory, spinner) => {
@@ -70,7 +70,7 @@ const writeScaffold = async (scaffold, directory, spinner) => {
 };
 exports.writeScaffold = writeScaffold;
 const writeABI = async (abi, contractName) => {
-    const data = prettier_1.default.format(JSON.stringify(abi.data), {
+    const data = await prettier_1.default.format(JSON.stringify(abi.data), {
         parser: 'json',
     });
     await fs_extra_1.default.writeFile(`./abis/${contractName}.json`, data, 'utf-8');
@@ -82,7 +82,7 @@ const writeSchema = async (abi, protocol, schemaPath, entities, contractName) =>
             .filter(event => !entities.includes(event.get('name')))
             .toJS()
         : [];
-    const data = prettier_1.default.format(events.map(event => (0, schema_1.generateEventType)(event, protocol.name, contractName)).join('\n\n'), {
+    const data = await prettier_1.default.format(events.map(event => (0, schema_1.generateEventType)(event, protocol.name, contractName)).join('\n\n'), {
         parser: 'graphql',
     });
     await fs_extra_1.default.appendFile(schemaPath, data, { encoding: 'utf-8' });
@@ -94,7 +94,7 @@ const writeMapping = async (abi, protocol, contractName, entities) => {
             .filter(event => !entities.includes(event.get('name')))
             .toJS()
         : [];
-    const mapping = prettier_1.default.format((0, mapping_1.generateEventIndexingHandlers)(events, contractName), {
+    const mapping = await prettier_1.default.format((0, mapping_1.generateEventIndexingHandlers)(events, contractName), {
         parser: 'typescript',
         semi: false,
     });
@@ -107,7 +107,7 @@ const writeTestsFiles = async (abi, protocol, contractName) => {
     if (events.length > 0) {
         // If a contract is added to a subgraph that has no tests folder
         await fs_extra_1.default.ensureDir('./tests/');
-        const testsFiles = (0, tests_1.generateTestsFiles)(contractName, events, true);
+        const testsFiles = await (0, tests_1.generateTestsFiles)(contractName, events, true);
         for (const [fileName, content] of Object.entries(testsFiles)) {
             await fs_extra_1.default.writeFile(`./tests/${fileName}`, content, 'utf-8');
         }

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

@@ -23,53 +23,53 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const loadManifestUtil = __importStar(require("../migrations/util/load-manifest"));
+const vitest_1 = require("vitest");
+const loadManifestUtils = __importStar(require("../migrations/util/load-manifest"));
 const graphTsUtil = __importStar(require("../migrations/util/versions"));
 const version_1 = require("./version");
-describe('Version Command Helpers', () => {
-    describe('assertManifestApiVersion', () => {
+vitest_1.describe.concurrent('Version Command Helpers', () => {
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.resetModules();
+    });
+    (0, vitest_1.describe)('assertManifestApiVersion', () => {
         const fakeManifestPath = 'fake/manifest/path';
         const minimumApiVersion = '0.0.5';
-        describe('With just dataSources', () => {
-            test('When all of them are less than minimum apiVersion', async () => {
-                // @ts-expect-error TODO: dont pollute the globals
-                loadManifestUtil.loadManifest = jest.fn().mockImplementation(() => Promise.resolve({
+        (0, vitest_1.describe)('With just dataSources', () => {
+            (0, vitest_1.test)('When all of them are less than minimum apiVersion', async () => {
+                vitest_1.vi.spyOn(loadManifestUtils, 'loadManifest').mockImplementation(() => Promise.resolve({
                     dataSources: [
                         { mapping: { apiVersion: '0.0.1' } },
                         { mapping: { apiVersion: '0.0.2' } },
                         { mapping: { apiVersion: '0.0.3' } },
                     ],
                 }));
-                await expect((0, version_1.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 (0, vitest_1.expect)((0, version_1.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 () => {
-                // @ts-expect-error TODO: dont pollute the globals
-                loadManifestUtil.loadManifest = jest.fn().mockImplementation(() => Promise.resolve({
+            (0, vitest_1.test)('When one of them is less than minimum apiVersion', async () => {
+                vitest_1.vi.spyOn(loadManifestUtils, 'loadManifest').mockImplementation(() => Promise.resolve({
                     dataSources: [
                         { mapping: { apiVersion: '0.0.5' } },
                         { mapping: { apiVersion: '0.0.2' } },
                         { mapping: { apiVersion: '0.0.5' } },
                     ],
                 }));
-                await expect((0, version_1.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 (0, vitest_1.expect)((0, version_1.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 () => {
-                // @ts-expect-error TODO: dont pollute the globals
-                loadManifestUtil.loadManifest = jest.fn().mockImplementation(() => Promise.resolve({
+            (0, vitest_1.test)('When none of them are less than minimum apiVersion', async () => {
+                vitest_1.vi.spyOn(loadManifestUtils, 'loadManifest').mockImplementation(() => Promise.resolve({
                     dataSources: [
                         { mapping: { apiVersion: '0.0.5' } },
                         { mapping: { apiVersion: '0.0.6' } },
                         { mapping: { apiVersion: '0.0.5' } },
                     ],
                 }));
-                await expect((0, version_1.assertManifestApiVersion)(fakeManifestPath, minimumApiVersion)).resolves.toBe(undefined);
+                await (0, vitest_1.expect)((0, version_1.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 () => {
-                    // @ts-expect-error TODO: dont pollute the globals
-                    loadManifestUtil.loadManifest = jest.fn().mockImplementation(() => Promise.resolve({
+        (0, vitest_1.describe)('With dataSources and templates', () => {
+            (0, vitest_1.describe)('And the dataSources have a lower apiVersion', () => {
+                (0, vitest_1.test)('When all of the templates are less than minimum apiVersion', async () => {
+                    vitest_1.vi.spyOn(loadManifestUtils, 'loadManifest').mockImplementation(() => Promise.resolve({
                         dataSources: [
                             { mapping: { apiVersion: '0.0.5' } },
                             { mapping: { apiVersion: '0.0.5' } },
@@ -81,11 +81,10 @@ describe('Version Command Helpers', () => {
                             { mapping: { apiVersion: '0.0.3' } },
                         ],
                     }));
-                    await expect((0, version_1.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 (0, vitest_1.expect)((0, version_1.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 () => {
-                    // @ts-expect-error TODO: dont pollute the globals
-                    loadManifestUtil.loadManifest = jest.fn().mockImplementation(() => Promise.resolve({
+                (0, vitest_1.test)('When one of the templates is less than minimum apiVersion', async () => {
+                    vitest_1.vi.spyOn(loadManifestUtils, 'loadManifest').mockImplementation(() => Promise.resolve({
                         dataSources: [
                             { mapping: { apiVersion: '0.0.5' } },
                             { mapping: { apiVersion: '0.0.5' } },
@@ -97,11 +96,10 @@ describe('Version Command Helpers', () => {
                             { mapping: { apiVersion: '0.0.5' } },
                         ],
                     }));
-                    await expect((0, version_1.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 (0, vitest_1.expect)((0, version_1.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 () => {
-                    // @ts-expect-error TODO: dont pollute the globals
-                    loadManifestUtil.loadManifest = jest.fn().mockImplementation(() => Promise.resolve({
+                (0, vitest_1.test)('When none of the templates are less than minimum apiVersion', async () => {
+                    vitest_1.vi.spyOn(loadManifestUtils, 'loadManifest').mockImplementation(() => Promise.resolve({
                         dataSources: [
                             { mapping: { apiVersion: '0.0.5' } },
                             { mapping: { apiVersion: '0.0.5' } },
@@ -113,13 +111,12 @@ describe('Version Command Helpers', () => {
                             { mapping: { apiVersion: '0.0.5' } },
                         ],
                     }));
-                    await expect((0, version_1.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 (0, vitest_1.expect)((0, version_1.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 () => {
-                    // @ts-expect-error TODO: dont pollute the globals
-                    loadManifestUtil.loadManifest = jest.fn().mockImplementation(() => Promise.resolve({
+            (0, vitest_1.describe)('And the dataSources do NOT have a lower apiVersion', () => {
+                (0, vitest_1.test)('When all of the templates are less than minimum apiVersion', async () => {
+                    vitest_1.vi.spyOn(loadManifestUtils, 'loadManifest').mockImplementation(() => Promise.resolve({
                         dataSources: [
                             { mapping: { apiVersion: '0.0.5' } },
                             { mapping: { apiVersion: '0.0.5' } },
@@ -131,11 +128,10 @@ describe('Version Command Helpers', () => {
                             { mapping: { apiVersion: '0.0.3' } },
                         ],
                     }));
-                    await expect((0, version_1.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 (0, vitest_1.expect)((0, version_1.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 () => {
-                    // @ts-expect-error TODO: dont pollute the globals
-                    loadManifestUtil.loadManifest = jest.fn().mockImplementation(() => Promise.resolve({
+                (0, vitest_1.test)('When one of the templates is less than minimum apiVersion', async () => {
+                    vitest_1.vi.spyOn(loadManifestUtils, 'loadManifest').mockImplementation(() => Promise.resolve({
                         dataSources: [
                             { mapping: { apiVersion: '0.0.5' } },
                             { mapping: { apiVersion: '0.0.5' } },
@@ -147,11 +143,10 @@ describe('Version Command Helpers', () => {
                             { mapping: { apiVersion: '0.0.5' } },
                         ],
                     }));
-                    await expect((0, version_1.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 (0, vitest_1.expect)((0, version_1.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 () => {
-                    // @ts-expect-error TODO: dont pollute the globals
-                    loadManifestUtil.loadManifest = jest.fn().mockImplementation(() => Promise.resolve({
+                (0, vitest_1.test)('When none of the templates are less than minimum apiVersion', async () => {
+                    vitest_1.vi.spyOn(loadManifestUtils, 'loadManifest').mockImplementation(() => Promise.resolve({
                         dataSources: [
                             { mapping: { apiVersion: '0.0.5' } },
                             { mapping: { apiVersion: '0.0.5' } },
@@ -163,24 +158,22 @@ describe('Version Command Helpers', () => {
                             { mapping: { apiVersion: '0.0.5' } },
                         ],
                     }));
-                    await expect((0, version_1.assertManifestApiVersion)(fakeManifestPath, minimumApiVersion)).resolves.toBe(undefined);
+                    await (0, vitest_1.expect)((0, version_1.assertManifestApiVersion)(fakeManifestPath, minimumApiVersion)).resolves.toBe(undefined);
                 });
             });
         });
     });
-    describe('assertGraphTsVersion', () => {
+    (0, vitest_1.describe)('assertGraphTsVersion', () => {
         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 () => {
-            // @ts-expect-error TODO: dont pollute the globals
-            graphTsUtil.getGraphTsVersion = jest.fn().mockImplementation(() => Promise.resolve('0.19.0'));
-            await expect((0, version_1.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}
+        (0, vitest_1.test)("When the installed graph-ts version is less than what's supported", async () => {
+            vitest_1.vi.spyOn(graphTsUtil, 'getGraphTsVersion').mockImplementation(() => Promise.resolve('0.19.0'));
+            await (0, vitest_1.expect)((0, version_1.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`));
         });
-        test('When the installed graph-ts version is a supported one', async () => {
-            // @ts-expect-error TODO: dont pollute the globals
-            graphTsUtil.getGraphTsVersion = jest.fn().mockImplementation(() => Promise.resolve('0.22.0'));
-            await expect((0, version_1.assertGraphTsVersion)(fakeNodeModulesDir, minimumGraphTsVersion)).resolves.toBe(undefined);
+        (0, vitest_1.test)('When the installed graph-ts version is a supported one', async () => {
+            vitest_1.vi.spyOn(graphTsUtil, 'getGraphTsVersion').mockImplementation(() => Promise.resolve('0.22.0'));
+            await (0, vitest_1.expect)((0, version_1.assertGraphTsVersion)(fakeNodeModulesDir, minimumGraphTsVersion)).resolves.toBe(undefined);
         });
     });
 });

package/dist/protocols/ethereum/codegen/abi.test.js

@@ -29,14 +29,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const path_1 = __importDefault(require("path"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const immutable_1 = __importDefault(require("immutable"));
+const vitest_1 = require("vitest");
 const ts = __importStar(require("../../../codegen/typescript"));
 const abi_1 = __importDefault(require("../abi"));
 const abi_2 = __importDefault(require("./abi"));
 let tempdir;
 let abi;
 let generatedTypes;
-describe('ABI code generation', () => {
-    beforeAll(async () => {
+vitest_1.describe.concurrent('ABI code generation', () => {
+    (0, vitest_1.beforeAll)(async () => {
         tempdir = await fs_extra_1.default.mkdtemp('abi-codegen');
         try {
             const filename = path_1.default.join(tempdir, 'ABI.json');
@@ -194,12 +195,12 @@ describe('ABI code generation', () => {
             await fs_extra_1.default.remove(tempdir);
         }
     });
-    afterAll(async () => {
+    (0, vitest_1.afterAll)(async () => {
         await fs_extra_1.default.remove(tempdir);
     });
-    describe('Generated types', () => {
-        test('All expected types are generated', () => {
-            expect(generatedTypes.map(type => type.name)).toEqual([
+    (0, vitest_1.describe)('Generated types', () => {
+        (0, vitest_1.test)('All expected types are generated', () => {
+            (0, vitest_1.expect)(generatedTypes.map(type => type.name)).toEqual([
                 'Contract__getProposalResultValue0Struct',
                 'Contract__getProposalInputParam1Struct',
                 'Contract__getProposalInputParam1BarStruct',
@@ -209,27 +210,27 @@ describe('ABI code generation', () => {
             ]);
         });
     });
-    describe('Contract class', () => {
-        test('Exists', () => {
-            expect(generatedTypes.find(type => type.name === 'Contract')).toBeDefined();
+    (0, vitest_1.describe)('Contract class', () => {
+        (0, vitest_1.test)('Exists', () => {
+            (0, vitest_1.expect)(generatedTypes.find(type => type.name === 'Contract')).toBeDefined();
         });
-        test('Has methods', () => {
+        (0, vitest_1.test)('Has methods', () => {
             const contract = generatedTypes.find(type => type.name === 'Contract');
-            expect(contract.methods).toBeInstanceOf(Array);
+            (0, vitest_1.expect)(contract.methods).toBeInstanceOf(Array);
         });
-        test('Has `bind` method', () => {
+        (0, vitest_1.test)('Has `bind` method', () => {
             const contract = generatedTypes.find(type => type.name === 'Contract');
-            expect(contract.methods.find((method) => method.name === 'bind')).toBeDefined();
+            (0, vitest_1.expect)(contract.methods.find((method) => method.name === 'bind')).toBeDefined();
         });
-        test('Has methods for all callable functions', () => {
+        (0, vitest_1.test)('Has methods for all callable functions', () => {
             const contract = generatedTypes.find(type => type.name === 'Contract');
-            expect(contract.methods.map((method) => method.name)).toContain('getProposal');
+            (0, vitest_1.expect)(contract.methods.map((method) => method.name)).toContain('getProposal');
         });
     });
-    describe('Methods for callable functions', () => {
-        test('Have correct parameters', () => {
+    (0, vitest_1.describe)('Methods for callable functions', () => {
+        (0, vitest_1.test)('Have correct parameters', () => {
             const contract = generatedTypes.find(type => type.name === 'Contract');
-            expect(contract.methods.map((method) => [method.name, method.params])).toEqual([
+            (0, vitest_1.expect)(contract.methods.map((method) => [method.name, method.params])).toEqual([
                 ['bind', immutable_1.default.List([ts.param('address', 'Address')])],
                 ['read', immutable_1.default.List()],
                 ['try_read', immutable_1.default.List()],
@@ -257,9 +258,9 @@ describe('ABI code generation', () => {
                 ['try_overloaded2', immutable_1.default.List([ts.param('param0', 'Bytes')])],
             ]);
         });
-        test('Have correct return types', () => {
+        (0, vitest_1.test)('Have correct return types', () => {
             const contract = generatedTypes.find(type => type.name === 'Contract');
-            expect(contract.methods.map((method) => [method.name, method.returnType])).toEqual([
+            (0, vitest_1.expect)(contract.methods.map((method) => [method.name, method.returnType])).toEqual([
                 ['bind', ts.namedType('Contract')],
                 ['read', ts.namedType('Bytes')],
                 ['try_read', 'ethereum.CallResult<Bytes>'],
@@ -276,34 +277,34 @@ describe('ABI code generation', () => {
             ]);
         });
     });
-    describe('Tuples', () => {
-        test('Tuple types exist for function parameters', () => {
+    (0, vitest_1.describe)('Tuples', () => {
+        (0, vitest_1.test)('Tuple types exist for function parameters', () => {
             let tupleType = generatedTypes.find(type => type.name === 'Contract__getProposalInputParam1Struct');
             // Verify that the tuple type has methods
-            expect(tupleType.methods).toBeDefined();
+            (0, vitest_1.expect)(tupleType.methods).toBeDefined();
             // Verify that the tuple type has getters for all tuple fields with
             // the right return types
-            expect(tupleType.methods.map((method) => [method.name, method.returnType])).toEqual([
+            (0, vitest_1.expect)(tupleType.methods.map((method) => [method.name, method.returnType])).toEqual([
                 ['get foo', 'i32'],
                 ['get bar', 'Contract__getProposalInputParam1BarStruct'],
             ]);
             // Inner tuple:
             tupleType = generatedTypes.find(type => type.name === 'Contract__getProposalInputParam1BarStruct');
             // Verify that the tuple type has methods
-            expect(tupleType.methods).toBeDefined();
+            (0, vitest_1.expect)(tupleType.methods).toBeDefined();
             // Verify that the tuple type has getters for all tuple fields with
             // the right return types
-            expect(tupleType.methods.map((method) => [method.name, method.returnType])).toEqual([
+            (0, vitest_1.expect)(tupleType.methods.map((method) => [method.name, method.returnType])).toEqual([
                 ['get baz', 'Address'],
             ]);
         });
-        test('Tuple types exist for function return values', () => {
+        (0, vitest_1.test)('Tuple types exist for function return values', () => {
             const tupleType = generatedTypes.find(type => type.name === 'Contract__getProposalResultValue0Struct');
             // Verify that the tuple type has methods
-            expect(tupleType.methods).toBeDefined();
+            (0, vitest_1.expect)(tupleType.methods).toBeDefined();
             // Verify that the tuple type has getters for all tuple fields with
             // the right return types
-            expect(tupleType.methods.map((method) => [method.name, method.returnType])).toEqual([
+            (0, vitest_1.expect)(tupleType.methods.map((method) => [method.name, method.returnType])).toEqual([
                 ['get result', 'i32'],
                 ['get target', 'Address'],
                 ['get data', 'Bytes'],
@@ -315,11 +316,11 @@ describe('ABI code generation', () => {
                 ['get noCount', 'BigInt'],
             ]);
         });
-        test('Function bodies are generated correctly for tuple arrays', () => {
+        (0, vitest_1.test)('Function bodies are generated correctly for tuple arrays', () => {
             const contract = generatedTypes.find(type => type.name === 'Contract');
             const getter = contract.methods.find((method) => method.name === 'getProposals');
-            expect(getter.body).not.toContain('toTupleArray<undefined>');
-            expect(getter.body).toContain('result[1].toTupleArray<Contract__getProposalsResultValue1Struct>()');
+            (0, vitest_1.expect)(getter.body).not.toContain('toTupleArray<undefined>');
+            (0, vitest_1.expect)(getter.body).toContain('result[1].toTupleArray<Contract__getProposalsResultValue1Struct>()');
         });
     });
 });