@graphprotocol/graph-cli 0.37.4 → 0.37.5

package/dist/scaffold/near.test.js

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const protocols_1 = __importDefault(require("../protocols"));
+const index_1 = __importDefault(require("./index"));
+const protocol = new protocols_1.default('near');
+const scaffoldOptions = {
+    protocol,
+    contract: 'abc.def.near',
+    network: 'near-mainnet',
+    contractName: 'Contract',
+};
+const scaffold = new index_1.default(scaffoldOptions);
+describe('NEAR subgraph scaffolding', () => {
+    test('Manifest', () => {
+        expect(scaffold.generateManifest()).toEqual(`\
+specVersion: 0.0.5
+schema:
+  file: ./schema.graphql
+dataSources:
+  - kind: near
+    name: Contract
+    network: near-mainnet
+    source:
+      account: "abc.def.near"
+    mapping:
+      apiVersion: 0.0.5
+      language: wasm/assemblyscript
+      entities:
+        - ExampleEntity
+      receiptHandlers:
+        - handler: handleReceipt
+      file: ./src/contract.ts
+`);
+    });
+    test('Schema (default)', () => {
+        expect(scaffold.generateSchema()).toEqual(`\
+type ExampleEntity @entity {
+  id: ID!
+  block: Bytes!
+  count: BigInt!
+}
+`);
+    });
+    test('Mapping (default)', () => {
+        expect(scaffold.generateMapping()).toEqual(`\
+import { near, BigInt } from "@graphprotocol/graph-ts"
+import { ExampleEntity } from "../generated/schema"
+
+export function handleReceipt(
+  receiptWithOutcome: near.ReceiptWithOutcome
+): void {
+  // Entities can be loaded from the store using a string ID; this ID
+  // needs to be unique across all entities of the same type
+  let entity = ExampleEntity.load(receiptWithOutcome.receipt.id.toHex())
+
+  // Entities only exist after they have been saved to the store;
+  // \`null\` checks allow to create entities on demand
+  if (!entity) {
+    entity = new ExampleEntity(receiptWithOutcome.receipt.id.toHex())
+
+    // Entity fields can be set using simple assignments
+    entity.count = BigInt.fromI32(0)
+  }
+
+  // BigInt and BigDecimal math are supported
+  entity.count = entity.count + BigInt.fromI32(1)
+
+  // Entity fields can be set based on receipt information
+  entity.block = receiptWithOutcome.block.header.hash
+
+  // Entities can be written to the store with \`.save()\`
+  entity.save()
+
+  // Note: If a handler doesn't require existing field values, it is faster
+  // _not_ to load the entity from the store. Instead, create it fresh with
+  // \`new Entity(...)\`, set the fields that should be updated and save the
+  // entity back to the store. Fields that were not set or unset remain
+  // unchanged, allowing for partial updates to be applied.
+}
+`);
+    });
+});

package/dist/scaffold/schema.js

@@ -0,0 +1,86 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateExampleEntityType = exports.generateEventType = exports.generateEventFields = exports.generateField = exports.protocolTypeToGraphQL = exports.abiEvents = void 0;
+const types_1 = require("../codegen/types");
+const util = __importStar(require("../codegen/util"));
+function abiEvents(abi) {
+    return util.disambiguateNames({
+        // @ts-expect-error improve typings of disambiguateNames to handle iterables
+        values: abi.data.filter(item => item.get('type') === 'event'),
+        // @ts-expect-error improve typings of disambiguateNames to handle iterables
+        getName: event => event.get('name'),
+        // @ts-expect-error improve typings of disambiguateNames to handle iterables
+        setName: (event, name) => event.set('_alias', name),
+    });
+}
+exports.abiEvents = abiEvents;
+const protocolTypeToGraphQL = (protocol, name) => {
+    const ascType = (0, types_1.ascTypeForProtocol)(protocol, name);
+    return (0, types_1.valueTypeForAsc)(ascType);
+};
+exports.protocolTypeToGraphQL = protocolTypeToGraphQL;
+const generateField = ({ name, type, protocolName, }) => `${name}: ${(0, exports.protocolTypeToGraphQL)(protocolName, type)}! # ${type}`;
+exports.generateField = generateField;
+const generateEventFields = ({ index, input, protocolName, }) => input.type == 'tuple'
+    ? util
+        .unrollTuple({ value: input, path: [input.name || `param${index}`], index })
+        .map(({ path, type }) => (0, exports.generateField)({ name: path.join('_'), type, protocolName }))
+    : [
+        (0, exports.generateField)({
+            name: input.name || `param${index}`,
+            type: input.type,
+            protocolName,
+        }),
+    ];
+exports.generateEventFields = generateEventFields;
+const generateEventType = (event, protocolName) => `type ${event._alias} @entity(immutable: true) {
+      id: Bytes!
+      ${event.inputs
+    .reduce((acc, input, index) => acc.concat((0, exports.generateEventFields)({ input, index, protocolName })), [])
+    .join('\n')}
+      blockNumber: BigInt!
+      blockTimestamp: BigInt!
+      transactionHash: Bytes!
+    }`;
+exports.generateEventType = generateEventType;
+const generateExampleEntityType = (protocol, events) => {
+    if (protocol.hasABIs() && events.length > 0) {
+        return `type ExampleEntity @entity {
+  id: Bytes!
+  count: BigInt!
+  ${events[0].inputs
+            .reduce((acc, input, index) => acc.concat((0, exports.generateEventFields)({ input, index, protocolName: protocol.name })), [])
+            .slice(0, 2)
+            .join('\n')}
+}`;
+    }
+    return `type ExampleEntity @entity {
+  id: ID!
+  block: Bytes!
+  count: BigInt!
+}`;
+};
+exports.generateExampleEntityType = generateExampleEntityType;

package/dist/scaffold/tests.js

@@ -0,0 +1,179 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTestsFiles = void 0;
+const gluegun_1 = require("gluegun");
+const prettier_1 = __importDefault(require("prettier"));
+const types_1 = require("../codegen/types");
+const VARIABLES_VALUES = {
+    i32: 123,
+    BigInt: 234,
+    Bytes: 1234567890,
+    Address: '0x0000000000000000000000000000000000000001',
+    string: 'Example string value',
+    bool: true,
+};
+const generateTestsFiles = (contract, events, indexEvents) => {
+    const eventsTypes = events
+        .flatMap(event => event.inputs.map((input) => {
+        // If the asc type is Array<T> we need to check if T is a native type or a custom graph-ts type
+        // If we don't do that we may miss a type that should be imported from graph-ts
+        const ascType = (0, types_1.ascTypeForEthereum)(input.type);
+        const inner = fetchArrayInnerType(String(ascType));
+        return inner ? inner[1] : ascType;
+    }))
+        .filter(type => !type.startsWith('ethereum.') && !isNativeType(type));
+    const importTypes = [...new Set(eventsTypes)].join(', ');
+    return {
+        [`${gluegun_1.strings.kebabCase(contract)}.test.ts`]: prettier_1.default.format(generateExampleTest(contract, events[0], indexEvents, importTypes), { parser: 'typescript', semi: false }),
+        [`${gluegun_1.strings.kebabCase(contract)}-utils.ts`]: prettier_1.default.format(generateTestHelper(contract, events, importTypes), { parser: 'typescript', semi: false }),
+    };
+};
+exports.generateTestsFiles = generateTestsFiles;
+/*
+  Generates the arguments that will be passed to the mock event function from the event inputs. Example:
+  let id = BigInt.fromI32(234)
+  let owner = Address.fromString("0x0000000000000000000000000000000000000001")
+  let displayName = "Example string value"
+  let imageUrl = "Example string value"
+*/
+const generateArguments = (eventInputs) => {
+    return eventInputs
+        .map((input, index) => {
+        const ascType = (0, types_1.ascTypeForEthereum)(input.type);
+        return `let ${input.name || `param${index}`} = ${assignValue(ascType)}`;
+    })
+        .join('\n');
+};
+// Generates the value that will be assigned to a variable in generateArguments()
+const assignValue = (type) => {
+    switch (type) {
+        case 'string':
+            return `"${VARIABLES_VALUES[type]}"`;
+        case 'BigInt':
+            return `BigInt.fromI32(${VARIABLES_VALUES[type]})`;
+        case 'Address':
+            return `Address.fromString("${VARIABLES_VALUES[type]}")`;
+        case 'Bytes':
+            return `Bytes.fromI32(${VARIABLES_VALUES[type]})`;
+        case fetchArrayInnerType(type)?.input: {
+            const innerType = fetchArrayInnerType(type)[1];
+            return `[${assignValue(innerType)}]`;
+        }
+        default: {
+            const value = VARIABLES_VALUES[type];
+            return value ? value : `"${type} Not implemented"`;
+        }
+    }
+};
+/*
+  Generates the assert.fieldEquals() for a given entity and event inputs. Example:
+  assert.fieldEquals(
+    "ExampleEntity",
+    "0xa16081f360e3847006db660bae1c6d1b2e17ec2a",
+    "owner",
+    "0x0000000000000000000000000000000000000001"
+  )
+*/
+const generateFieldsAssertions = (entity, eventInputs, indexEvents) => eventInputs
+    .filter(input => input.name != 'id')
+    .map((input, index) => `assert.fieldEquals(
+    "${entity}",
+    "0xa16081f360e3847006db660bae1c6d1b2e17ec2a${indexEvents ? '-1' : ''}",
+    "${input.name || `param${index}`}",
+    "${expectedValue((0, types_1.ascTypeForEthereum)(input.type))}"
+  )`)
+    .join('\n');
+// Returns the expected value for a given type in generateFieldsAssertions()
+const expectedValue = (type) => {
+    switch (type) {
+        case fetchArrayInnerType(type)?.input: {
+            const innerType = fetchArrayInnerType(type)[1];
+            return `[${expectedValue(innerType)}]`;
+        }
+        default: {
+            const value = VARIABLES_VALUES[type];
+            return value ? value : `${type} Not implemented`;
+        }
+    }
+};
+// Checks if the type is a native AS type or should be imported from graph-ts
+const isNativeType = (type) => {
+    const natives = [/i32/, /string/, /boolean/];
+    return natives.some(rx => rx.test(type));
+};
+const fetchArrayInnerType = (type) => type.match(/Array<(.*?)>/);
+// Generates the example test.ts file
+const generateExampleTest = (contract, event, indexEvents, importTypes) => {
+    const entity = indexEvents ? String(event._alias) : 'ExampleEntity';
+    const eventInputs = event.inputs;
+    const eventName = event._alias;
+    return `
+  import { assert, describe, test, clearStore, beforeAll, afterAll } from "matchstick-as/assembly/index"
+  import { ${importTypes} } from "@graphprotocol/graph-ts"
+  import { ${entity} } from "../generated/schema"
+  import { ${indexEvents ? `${eventName} as ${eventName}Event` : eventName} } from "../generated/${contract}/${contract}"
+  import { handle${eventName} } from "../src/${gluegun_1.strings.kebabCase(contract)}"
+  import { create${eventName}Event } from "./${gluegun_1.strings.kebabCase(contract)}-utils"
+
+
+  // Tests structure (matchstick-as >=0.5.0)
+  // https://thegraph.com/docs/en/developer/matchstick/#tests-structure-0-5-0
+
+  describe("Describe entity assertions", () => {
+    beforeAll(() => {
+      ${generateArguments(eventInputs)}
+      let new${eventName}Event = create${eventName}Event(${eventInputs
+        .map((input, index) => input.name || `param${index}`)
+        .join(', ')});
+      handle${eventName}(new${eventName}Event)
+    })
+
+    afterAll(() => {
+      clearStore()
+    })
+
+    // For more test scenarios, see:
+    // https://thegraph.com/docs/en/developer/matchstick/#write-a-unit-test
+
+    test("${entity} created and stored", () => {
+      assert.entityCount('${entity}', 1)
+
+      // 0xa16081f360e3847006db660bae1c6d1b2e17ec2a is the default address used in newMockEvent() function
+      ${generateFieldsAssertions(entity, eventInputs, indexEvents)}
+
+      // More assert options:
+      // https://thegraph.com/docs/en/developer/matchstick/#asserts
+    })
+  })
+`;
+};
+// Generates the utils helper file
+const generateTestHelper = (contract, events, importTypes) => {
+    const eventsNames = events.map(event => event._alias);
+    return `
+  import { newMockEvent } from 'matchstick-as';
+  import { ethereum, ${importTypes} } from '@graphprotocol/graph-ts';
+  import { ${eventsNames.join(', ')} } from '../generated/${contract}/${contract}';
+
+  ${generateMockedEvents(events).join('\n')}`;
+};
+const generateMockedEvents = (events) => events.reduce((acc, event) => acc.concat(generateMockedEvent(event)), []);
+const generateMockedEvent = (event) => {
+    const varName = `${gluegun_1.strings.camelCase(event._alias)}Event`;
+    const fnArgs = event.inputs.map((input, index) => `${input.name || `param${index}`}: ${(0, types_1.ascTypeForEthereum)(input.type)}`);
+    const ascToEth = event.inputs.map((input, index) => `${varName}.parameters.push(new ethereum.EventParam("${input.name || `param${index}`}", ${(0, types_1.ethereumFromAsc)(input.name || `param${index}`, input.type)}))`);
+    return `
+    export function create${event._alias}Event(${fnArgs.join(', ')}): ${event._alias} {
+      let ${varName} = changetype<${event._alias}>(newMockEvent());
+
+      ${varName}.parameters = new Array();
+
+      ${ascToEth.join('\n')}
+
+      return ${varName};
+    }
+  `;
+};

package/dist/schema.js

@@ -0,0 +1,54 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const graphql = __importStar(require("graphql/language"));
+const immutable_1 = __importDefault(require("immutable"));
+const schema_1 = __importDefault(require("./codegen/schema"));
+class Schema {
+    filename;
+    document;
+    ast;
+    constructor(filename, document, ast) {
+        this.filename = filename;
+        this.document = document;
+        this.ast = ast;
+        this.filename = filename;
+        this.document = document;
+        this.ast = ast;
+    }
+    codeGenerator() {
+        return new schema_1.default(this);
+    }
+    static async load(filename) {
+        const document = await fs_extra_1.default.readFile(filename, 'utf-8');
+        const ast = graphql.parse(document);
+        return new Schema(filename, document, immutable_1.default.fromJS(ast));
+    }
+}
+exports.default = Schema;

package/dist/subgraph.js

@@ -0,0 +1,243 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const graphql = __importStar(require("graphql/language"));
+const immutable_1 = __importDefault(require("immutable"));
+const yaml_1 = __importDefault(require("yaml"));
+const types_1 = require("yaml/types");
+const debug_1 = __importDefault(require("./debug"));
+const validation = __importStar(require("./validation"));
+const subgraphDebug = (0, debug_1.default)('graph-cli:subgraph');
+const throwCombinedError = (filename, errors) => {
+    throw new Error(errors.reduce((msg, e) => `${msg}
+
+  Path: ${e.get('path').size === 0 ? '/' : e.get('path').join(' > ')}
+  ${e.get('message').split('\n').join('\n  ')}`, `Error in ${path_1.default.relative(process.cwd(), filename)}:`));
+};
+const buildCombinedWarning = (filename, warnings) => warnings.size > 0
+    ? warnings.reduce((msg, w) => `${msg}
+
+    Path: ${w.get('path').size === 0 ? '/' : w.get('path').join(' > ')}
+    ${w.get('message').split('\n').join('\n    ')}`, `Warnings in ${path_1.default.relative(process.cwd(), filename)}:`) + '\n'
+    : null;
+class Subgraph {
+    static async validate(data, protocol, { resolveFile }) {
+        subgraphDebug(`Validating Subgraph with protocol "%s"`, protocol);
+        if (protocol.name == null) {
+            return immutable_1.default.fromJS([
+                {
+                    path: [],
+                    message: `Unable to determine for which protocol manifest file is built for. Ensure you have at least one 'dataSources' and/or 'templates' elements defined in your subgraph.`,
+                },
+            ]);
+        }
+        // Parse the default subgraph schema
+        const schema = graphql.parse(await fs_extra_1.default.readFile(path_1.default.join(__dirname, 'protocols', protocol.name, `manifest.graphql`), 'utf-8'));
+        // Obtain the root `SubgraphManifest` type from the schema
+        const rootType = schema.definitions.find(definition => {
+            // @ts-expect-error TODO: name field does not exist on definition, really?
+            return definition.name.value === 'SubgraphManifest';
+        });
+        // Validate the subgraph manifest using this schema
+        return validation.validateManifest(data, rootType, schema, protocol, { resolveFile });
+    }
+    static validateSchema(manifest, { resolveFile }) {
+        const filename = resolveFile(manifest.getIn(['schema', 'file']));
+        const validationErrors = validation.validateSchema(filename);
+        let errors;
+        if (validationErrors.size > 0) {
+            errors = validationErrors.groupBy(error => error.get('entity')).sort();
+            const msg = errors.reduce((msg, errors, entity) => {
+                errors = errors.groupBy((error) => error.get('directive'));
+                const inner_msgs = errors.reduce((msg, errors, directive) => {
+                    return `${msg}${directive
+                        ? `
+    ${directive}:`
+                        : ''}
+  ${errors
+                        .map(error => error.get('message').split('\n').join('\n  '))
+                        .map(msg => `${directive ? '  ' : ''}- ${msg}`)
+                        .join('\n  ')}`;
+                }, ``);
+                return `${msg}
+
+  ${entity}:${inner_msgs}`;
+            }, `Error in ${path_1.default.relative(process.cwd(), filename)}:`);
+            throw new Error(msg);
+        }
+    }
+    static validateRepository(manifest) {
+        const repository = manifest.get('repository');
+        return /^https:\/\/github\.com\/graphprotocol\/example-subgraphs?$/.test(repository)
+            ? immutable_1.default.List().push(immutable_1.default.fromJS({
+                path: ['repository'],
+                message: `\
+The repository is still set to ${repository}.
+Please replace it with a link to your subgraph source code.`,
+            }))
+            : immutable_1.default.List();
+    }
+    static validateDescription(manifest) {
+        // TODO: Maybe implement this in the future for each protocol example description
+        return manifest.get('description', '').startsWith('Gravatar for ')
+            ? immutable_1.default.List().push(immutable_1.default.fromJS({
+                path: ['description'],
+                message: `\
+The description is still the one from the example subgraph.
+Please update it to tell users more about your subgraph.`,
+            }))
+            : immutable_1.default.List();
+    }
+    static validateHandlers(manifest, protocol, protocolSubgraph) {
+        return manifest
+            .get('dataSources')
+            .filter((dataSource) => protocol.isValidKindName(dataSource.get('kind')))
+            .reduce((errors, dataSource, dataSourceIndex) => {
+            const path = ['dataSources', dataSourceIndex, 'mapping'];
+            const mapping = dataSource.get('mapping');
+            const handlerTypes = protocolSubgraph.handlerTypes();
+            subgraphDebug('Validating dataSource "%s" handlers with %d handlers types defined for protocol', dataSource.get('name'), handlerTypes.size);
+            if (handlerTypes.size == 0) {
+                return errors;
+            }
+            const areAllHandlersEmpty = handlerTypes
+                .map((handlerType) => mapping.get(handlerType, immutable_1.default.List()))
+                .every((handlers) => handlers.isEmpty());
+            const handlerNamesWithoutLast = handlerTypes.pop().join(', ');
+            return areAllHandlersEmpty
+                ? errors.push(immutable_1.default.fromJS({
+                    path,
+                    message: `\
+Mapping has no ${handlerNamesWithoutLast} or ${handlerTypes.get(-1)}.
+At least one such handler must be defined.`,
+                }))
+                : errors;
+        }, immutable_1.default.List());
+    }
+    static validateContractValues(manifest, protocol) {
+        if (!protocol.hasContract()) {
+            return immutable_1.default.List();
+        }
+        return validation.validateContractValues(manifest, protocol);
+    }
+    // Validate that data source names are unique, so they don't overwrite each other.
+    static validateUniqueDataSourceNames(manifest) {
+        const names = [];
+        return manifest
+            .get('dataSources')
+            .reduce((errors, dataSource, dataSourceIndex) => {
+            const path = ['dataSources', dataSourceIndex, 'name'];
+            const name = dataSource.get('name');
+            if (names.includes(name)) {
+                errors = errors.push(immutable_1.default.fromJS({
+                    path,
+                    message: `\
+More than one data source named '${name}', data source names must be unique.`,
+                }));
+            }
+            names.push(name);
+            return errors;
+        }, immutable_1.default.List());
+    }
+    static validateUniqueTemplateNames(manifest) {
+        const names = [];
+        return manifest
+            .get('templates', immutable_1.default.List())
+            .reduce((errors, template, templateIndex) => {
+            const path = ['templates', templateIndex, 'name'];
+            const name = template.get('name');
+            if (names.includes(name)) {
+                errors = errors.push(immutable_1.default.fromJS({
+                    path,
+                    message: `\
+More than one template named '${name}', template names must be unique.`,
+                }));
+            }
+            names.push(name);
+            return errors;
+        }, immutable_1.default.List());
+    }
+    static dump(manifest) {
+        types_1.strOptions.fold.lineWidth = 90;
+        // @ts-expect-error TODO: plain is the value behind the TS constant
+        types_1.strOptions.defaultType = 'PLAIN';
+        return yaml_1.default.stringify(manifest.toJS());
+    }
+    static async load(filename, { protocol, skipValidation } = {
+        skipValidation: false,
+    }) {
+        // Load and validate the manifest
+        let data = null;
+        let has_file_data_sources = false;
+        if (filename.match(/.js$/)) {
+            data = require(path_1.default.resolve(filename));
+        }
+        else {
+            const raw_data = await fs_extra_1.default.readFile(filename, 'utf-8');
+            has_file_data_sources = raw_data.includes('kind: file');
+            data = yaml_1.default.parse(raw_data);
+        }
+        // Helper to resolve files relative to the subgraph manifest
+        const resolveFile = maybeRelativeFile => path_1.default.resolve(path_1.default.dirname(filename), maybeRelativeFile);
+        // TODO: Validation for file data sources
+        if (!has_file_data_sources) {
+            const manifestErrors = await Subgraph.validate(data, protocol, { resolveFile });
+            if (manifestErrors.size > 0) {
+                throwCombinedError(filename, manifestErrors);
+            }
+        }
+        const manifest = immutable_1.default.fromJS(data);
+        // Validate the schema
+        Subgraph.validateSchema(manifest, { resolveFile });
+        // Perform other validations
+        const protocolSubgraph = protocol.getSubgraph({
+            manifest,
+            resolveFile,
+        });
+        const errors = skipValidation
+            ? immutable_1.default.List()
+            : immutable_1.default.List.of(...protocolSubgraph.validateManifest(), ...Subgraph.validateContractValues(manifest, protocol), ...Subgraph.validateUniqueDataSourceNames(manifest), ...Subgraph.validateUniqueTemplateNames(manifest), ...Subgraph.validateHandlers(manifest, protocol, protocolSubgraph));
+        if (errors.size > 0) {
+            throwCombinedError(filename, errors);
+        }
+        // Perform warning validations
+        const warnings = skipValidation
+            ? immutable_1.default.List()
+            : immutable_1.default.List.of(...Subgraph.validateRepository(manifest), ...Subgraph.validateDescription(manifest));
+        return {
+            result: manifest,
+            warning: warnings.size > 0 ? buildCombinedWarning(filename, warnings) : null,
+        };
+    }
+    static async write(manifest, filename) {
+        await fs_extra_1.default.writeFile(filename, Subgraph.dump(manifest));
+    }
+}
+exports.default = Subgraph;