@graphprotocol/graph-cli 0.56.0 → 0.56.1-alpha-20230831035057-3d319d2

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @graphprotocol/graph-cli
 
+## 0.56.1-alpha-20230831035057-3d319d2
+
+### Patch Changes
+
+- [#1433](https://github.com/graphprotocol/graph-tooling/pull/1433)
+  [`3d319d2`](https://github.com/graphprotocol/graph-tooling/commit/3d319d2bf39856b1e8e106b16302bbe40d3028b5)
+  Thanks [@saihaj](https://github.com/saihaj)! - when generating nested tuples make sure they are
+  non-nullable
+
+- [#1433](https://github.com/graphprotocol/graph-tooling/pull/1433)
+  [`8287a05`](https://github.com/graphprotocol/graph-tooling/commit/8287a058f9991bb7fa5591142af6dd17cf2fb77d)
+  Thanks [@saihaj](https://github.com/saihaj)! - 2D arrays are valid entities
+
 ## 0.56.0
 
 ### Minor Changes

package/dist/debug.js

@@ -11,6 +11,12 @@ debug_1.default.formatters.M = immutableMap => {
     if (immutableMap.toMap != null) {
         return JSON.stringify(immutableMap.toMap());
     }
+    if (typeof immutableMap.toJS === 'function') {
+        return JSON.stringify(immutableMap.toJS());
+    }
+    if (typeof immutableMap === 'object') {
+        return JSON.stringify(immutableMap);
+    }
     return immutableMap;
 };
 exports.default = debug_1.default;

package/dist/scaffold/schema.js

@@ -46,14 +46,18 @@ const protocolTypeToGraphQL = (protocol, name) => {
     // TODO: this is a hack to make array type non-nullable
     // We should refactor the way we convert the Values from ASC to GraphQL
     // For arrays we always want non-nullable children
-    return convertedType.endsWith(']') ? convertedType.replace(']', '!]') : convertedType;
+    return convertedType.endsWith(']') ? convertedType.replace(/\]/g, '!]') : convertedType;
 };
 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 })
+        .unrollTuple({
+        value: input,
+        path: [input.name || `param${index}`],
+        index,
+    })
         .map(({ path, type }) => (0, exports.generateField)({ name: path.join('_'), type, protocolName }))
     : [
         (0, exports.generateField)({

package/dist/subgraph.js

@@ -49,8 +49,9 @@ const buildCombinedWarning = (filename, warnings) => warnings.size > 0
     : null;
 class Subgraph {
     static async validate(data, protocol, { resolveFile }) {
-        subgraphDebug(`Validating Subgraph with protocol "%s"`, protocol);
+        subgraphDebug.extend('validate')('Validating Subgraph with protocol %M', protocol);
         if (protocol.name == null) {
+            subgraphDebug.extend('validate')('Protocol has no name, skipping validation');
             return immutable_1.default.fromJS([
                 {
                     path: [],
@@ -66,13 +67,18 @@ class Subgraph {
             return definition.name.value === 'SubgraphManifest';
         });
         // Validate the subgraph manifest using this schema
-        return validation.validateManifest(data, rootType, schema, protocol, { resolveFile });
+        return validation.validateManifest(data, rootType, schema, protocol, {
+            resolveFile,
+        });
     }
     static validateSchema(manifest, { resolveFile }) {
+        subgraphDebug.extend('validate')('Validating schema in manifest');
         const filename = resolveFile(manifest.getIn(['schema', 'file']));
+        subgraphDebug.extend('validate')('Loaded schema from %s', filename);
         const validationErrors = validation.validateSchema(filename);
         let errors;
         if (validationErrors.size > 0) {
+            subgraphDebug.extend('validate')('Schema validation failed for %s', filename);
             errors = validationErrors.groupBy(error => error.get('entity')).sort();
             const msg = errors.reduce((msg, errors, entity) => {
                 errors = errors.groupBy((error) => error.get('directive'));
@@ -94,6 +100,7 @@ class Subgraph {
         }
     }
     static validateRepository(manifest) {
+        subgraphDebug.extend('validate')('Validating repository in manifest');
         const repository = manifest.get('repository');
         return /^https:\/\/github\.com\/graphprotocol\/graph-tooling?$/.test(repository) ||
             // For legacy reasons, we should error on example subgraphs
@@ -107,6 +114,7 @@ Please replace it with a link to your subgraph source code.`,
             : immutable_1.default.List();
     }
     static validateDescription(manifest) {
+        subgraphDebug.extend('validate')('Validating description in 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({
@@ -118,6 +126,7 @@ Please update it to tell users more about your subgraph.`,
             : immutable_1.default.List();
     }
     static validateHandlers(manifest, protocol, protocolSubgraph) {
+        subgraphDebug.extend('validate')('Validating handlers for protocol %s', protocol?.name);
         return manifest
             .get('dataSources')
             .filter((dataSource) => protocol.isValidKindName(dataSource.get('kind')))
@@ -125,7 +134,7 @@ Please update it to tell users more about your subgraph.`,
             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);
+            subgraphDebug.extend('validate')('Validating dataSource "%s" handlers with %d handlers types defined for protocol', dataSource.get('name'), handlerTypes.size);
             if (handlerTypes.size == 0) {
                 return errors;
             }
@@ -144,13 +153,16 @@ At least one such handler must be defined.`,
         }, immutable_1.default.List());
     }
     static validateContractValues(manifest, protocol) {
+        subgraphDebug.extend('validate')('Validating contract values for protocol %s', protocol?.name);
         if (!protocol.hasContract()) {
+            subgraphDebug.extend('validate')('Protocol has no contract, skipping validation');
             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) {
+        subgraphDebug.extend('validate')('Validating that data source names are unique');
         const names = [];
         return manifest
             .get('dataSources')
@@ -158,6 +170,7 @@ At least one such handler must be defined.`,
             const path = ['dataSources', dataSourceIndex, 'name'];
             const name = dataSource.get('name');
             if (names.includes(name)) {
+                subgraphDebug.extend('validate')("Found duplicate data source name '%s', adding error");
                 errors = errors.push(immutable_1.default.fromJS({
                     path,
                     message: `\
@@ -169,6 +182,7 @@ More than one data source named '${name}', data source names must be unique.`,
         }, immutable_1.default.List());
     }
     static validateUniqueTemplateNames(manifest) {
+        subgraphDebug.extend('validate')('Validating that template names are unique');
         const names = [];
         return manifest
             .get('templates', immutable_1.default.List())
@@ -176,6 +190,7 @@ More than one data source named '${name}', data source names must be unique.`,
             const path = ['templates', templateIndex, 'name'];
             const name = template.get('name');
             if (names.includes(name)) {
+                subgraphDebug.extend('validate')("Found duplicate template name '%s', adding error");
                 errors = errors.push(immutable_1.default.fromJS({
                     path,
                     message: `\
@@ -202,21 +217,30 @@ More than one template named '${name}', template names must be unique.`,
             data = require(path_1.default.resolve(filename));
         }
         else {
+            subgraphDebug('Loading manifest from %s', filename);
             const raw_data = await fs_extra_1.default.readFile(filename, 'utf-8');
+            subgraphDebug('Checking for file data sources in %s', filename);
             has_file_data_sources = raw_data.includes('kind: file');
+            subgraphDebug('Parsing manifest from %s', filename);
             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 });
+            subgraphDebug('Validating manifest from %s', filename);
+            const manifestErrors = await Subgraph.validate(data, protocol, {
+                resolveFile,
+            });
             if (manifestErrors.size > 0) {
+                subgraphDebug('Manifest validation failed for %s', filename);
                 throwCombinedError(filename, manifestErrors);
             }
         }
         const manifest = immutable_1.default.fromJS(data);
+        subgraphDebug.extend('manifest')('Loaded: %M', manifest);
         // Validate the schema
+        subgraphDebug.extend('manifest')('Validating schema');
         Subgraph.validateSchema(manifest, { resolveFile });
         // Perform other validations
         const protocolSubgraph = protocol.getSubgraph({

package/dist/validation/schema.js

@@ -30,6 +30,8 @@ exports.validateSchema = exports.typeSuggestion = void 0;
 const fs_1 = __importDefault(require("fs"));
 const graphql = __importStar(require("graphql/language"));
 const immutable_1 = __importDefault(require("immutable"));
+const debug_1 = __importDefault(require("../debug"));
+const validateDebugger = (0, debug_1.default)('graph-cli:validation');
 const List = immutable_1.default.List;
 const Set = immutable_1.default.Set;
 // Builtin scalar types
@@ -101,18 +103,23 @@ const parseSchema = (doc) => {
         throw new Error(`Invalid GraphQL schema: ${e}`);
     }
 };
-const validateEntityDirective = (def) => def.directives.find((directive) => directive.name.value === 'entity')
-    ? List()
-    : immutable_1.default.fromJS([
-        {
-            loc: def.loc,
-            entity: def.name.value,
-            message: `Defined without @entity directive`,
-        },
-    ]);
+const validateEntityDirective = (def) => {
+    validateDebugger('Validating entity directive for %s', def?.name?.value);
+    return def.directives.find((directive) => directive.name.value === 'entity')
+        ? List()
+        : immutable_1.default.fromJS([
+            {
+                loc: def.loc,
+                entity: def.name.value,
+                message: `Defined without @entity directive`,
+            },
+        ]);
+};
 const validateEntityID = (def) => {
+    validateDebugger('Validating entity ID for %s', def?.name?.value);
     const idField = def.fields.find((field) => field.name.value === 'id');
     if (idField === undefined) {
+        validateDebugger('Entity %s has no id field', def?.name?.value);
         return immutable_1.default.fromJS([
             {
                 loc: def.loc,
@@ -126,8 +133,10 @@ const validateEntityID = (def) => {
         (idField.type.type.name.value === 'ID' ||
             idField.type.type.name.value === 'Bytes' ||
             idField.type.type.name.value === 'String')) {
+        validateDebugger('Entity %s has valid id field', def?.name?.value);
         return List();
     }
+    validateDebugger('Entity %s has invalid id field', def?.name?.value);
     return immutable_1.default.fromJS([
         {
             loc: idField.loc,
@@ -136,52 +145,80 @@ const validateEntityID = (def) => {
         },
     ]);
 };
-const validateListFieldType = (def, field) => field.type.kind === 'NonNullType' &&
-    field.type.kind === 'ListType' &&
-    field.type.type.kind !== 'NonNullType'
-    ? immutable_1.default.fromJS([
-        {
-            loc: field.loc,
-            entity: def.name.value,
-            message: `\
-Field '${field.name.value}':
-Field has type [${field.type.type.name.value}]! but
-must have type [${field.type.type.name.value}!]!
-
-Reason: Lists with null elements are not supported.`,
-        },
-    ])
-    : field.type.kind === 'ListType' && field.type.type.kind !== 'NonNullType'
+const validateListFieldType = (def, field) => {
+    validateDebugger('Validating list field type for %s', def?.name?.value);
+    return field.type.kind === 'NonNullType' &&
+        field.type.kind === 'ListType' &&
+        field.type.type.kind !== 'NonNullType'
         ? immutable_1.default.fromJS([
             {
                 loc: field.loc,
                 entity: def.name.value,
                 message: `\
 Field '${field.name.value}':
-Field has type [${field.type.type.name.value}] but
-must have type [${field.type.type.name.value}!]
+Field has type [${field.type.type.name.value}]! but
+must have type [${field.type.type.name.value}!]!
 
 Reason: Lists with null elements are not supported.`,
             },
         ])
-        : List();
+        : field.type.kind === 'ListType' && field.type.type.kind !== 'NonNullType'
+            ? immutable_1.default.fromJS([
+                {
+                    loc: field.loc,
+                    entity: def.name.value,
+                    message: `\
+Field '${field.name.value}':
+Field has type [${field.type.type.name.value}] but
+must have type [${field.type.type.name.value}!]
+
+Reason: Lists with null elements are not supported.`,
+                },
+            ])
+            : List();
+};
 const unwrapType = (type) => {
-    const innerTypeFromList = (listType) => listType.type.kind === 'NonNullType' ? innerTypeFromNonNull(listType.type) : listType.type;
-    const innerTypeFromNonNull = (nonNullType) => nonNullType.type.kind === 'ListType' ? innerTypeFromList(nonNullType.type) : nonNullType.type;
+    validateDebugger.extend('definition')('Unwrapping type %M', type);
+    const innerTypeFromList = (listType) => {
+        validateDebugger.extend('unwrapType').extend('definition')('Unwrapping list type %M', listType);
+        if (listType.type.kind === 'NonNullType') {
+            validateDebugger.extend('unwrapType').extend('innerTypeFromList')('Returning non-null list type');
+            return innerTypeFromNonNull(listType.type);
+        }
+        validateDebugger.extend('unwrapType').extend('innerTypeFromList')('Returning list type');
+        return unwrapType(listType.type);
+    };
+    const innerTypeFromNonNull = (nonNullType) => {
+        validateDebugger.extend('unwrapType').extend('definition')('Unwrapping non-null type %M', nonNullType);
+        if (nonNullType.type.kind === 'ListType') {
+            validateDebugger.extend('unwrapType').extend('innerTypeFromNonNull')('Returning non-null list type');
+            return innerTypeFromList(nonNullType.type);
+        }
+        validateDebugger.extend('unwrapType').extend('innerTypeFromNonNull')('Returning non-null type');
+        return unwrapType(nonNullType.type);
+    };
     // Obtain the inner-most type from the field
-    return type.kind === 'NonNullType'
-        ? innerTypeFromNonNull(type)
-        : type.kind === 'ListType'
-            ? innerTypeFromList(type)
-            : type;
-};
-const gatherLocalTypes = (defs) => defs
-    .filter(def => def.kind === 'ObjectTypeDefinition' ||
-    def.kind === 'EnumTypeDefinition' ||
-    def.kind === 'InterfaceTypeDefinition')
-    .map(def => 
-// @ts-expect-error TODO: name field does not exist on definition, really?
-def.name.value);
+    if (type.kind === 'NonNullType') {
+        validateDebugger('Returning inner type from non-null type');
+        return innerTypeFromNonNull(type);
+    }
+    if (type.kind === 'ListType') {
+        validateDebugger('Returning inner type from list type');
+        return innerTypeFromList(type);
+    }
+    validateDebugger('Returning inner type');
+    return type;
+};
+const gatherLocalTypes = (defs) => {
+    validateDebugger('Gathering local types');
+    return defs
+        .filter(def => def.kind === 'ObjectTypeDefinition' ||
+        def.kind === 'EnumTypeDefinition' ||
+        def.kind === 'InterfaceTypeDefinition')
+        .map(def => 
+    // @ts-expect-error TODO: name field does not exist on definition, really?
+    def.name.value);
+};
 const gatherImportedTypes = (defs) => defs
     .filter(def => def.kind === 'ObjectTypeDefinition' &&
     def.name.value == RESERVED_TYPE &&
@@ -206,19 +243,28 @@ def.directives
     }
     return flattened;
 }, [])), []);
-const entityTypeByName = (defs, name) => defs
-    .filter(def => def.kind === 'InterfaceTypeDefinition' ||
-    (def.kind === 'ObjectTypeDefinition' &&
-        def.directives.find((directive) => directive.name.value === 'entity')))
-    .find(def => def.name.value === name);
-const fieldTargetEntityName = (field) => unwrapType(field.type).name.value;
+const entityTypeByName = (defs, name) => {
+    validateDebugger('Looking up entity type %s', name);
+    return defs
+        .filter(def => def.kind === 'InterfaceTypeDefinition' ||
+        (def.kind === 'ObjectTypeDefinition' &&
+            def.directives.find((directive) => directive.name.value === 'entity')))
+        .find(def => def.name.value === name);
+};
+const fieldTargetEntityName = (field) => {
+    validateDebugger('Looking up field target entity name for %s', field?.name?.value);
+    return unwrapType(field.type).name.value;
+};
 const fieldTargetEntity = (defs, field) => entityTypeByName(defs, fieldTargetEntityName(field));
 const validateInnerFieldType = (defs, def, field) => {
+    validateDebugger('Validating inner field type for %s', def?.name?.value);
     const innerType = unwrapType(field.type);
     // Get the name of the type
     const typeName = innerType.name.value;
+    validateDebugger('Inner field type name: %s', typeName);
     // Look up a possible suggestion for the type to catch common mistakes
     const suggestion = (0, exports.typeSuggestion)(typeName);
+    validateDebugger('Inner field type suggestion: %s', suggestion);
     // Collect all types that we can use here: built-ins + entities + enums + interfaces
     const availableTypes = List.of(...BUILTIN_SCALAR_TYPES, ...gatherLocalTypes(defs), ...gatherImportedTypes(defs));
     // Check whether the type name is available, otherwise return an error
@@ -292,6 +338,7 @@ does not exist on type '${targetEntity.name.value}'`,
         ]);
     }
     const backrefTypeName = unwrapType(derivedFromField.type);
+    validateDebugger.extend('definition')('Backref type name: %M', backrefTypeName);
     const backRefEntity = entityTypeByName(defs, backrefTypeName.name.value);
     // The field we are deriving from must either have type 'def' or one of the
     // interface types that 'def' is implementing
@@ -682,6 +729,7 @@ const validateImportDirectiveArgumentFrom = (def, directive, argument) => {
     }, List());
 };
 const validateImportDirectiveFields = (def, directive) => {
+    validateDebugger('Validating import directive fields: %s', def?.name?.value);
     return directive.arguments.reduce((errors, argument) => {
         return errors.concat(['types', 'from'].includes(argument.name.value)
             ? List([])
@@ -695,6 +743,7 @@ const validateImportDirectiveFields = (def, directive) => {
     }, List([]));
 };
 const validateImportDirectiveTypes = (def, directive) => {
+    validateDebugger('Validating import directive types: %s', def?.name?.value);
     const types = directive.arguments.find((argument) => argument.name.value == 'types');
     return types
         ? validateImportDirectiveArgumentTypes(def, directive, types)
@@ -707,6 +756,7 @@ const validateImportDirectiveTypes = (def, directive) => {
         ]);
 };
 const validateImportDirectiveFrom = (def, directive) => {
+    validateDebugger('Validating import directive from: %s', def?.name?.value);
     const from = directive.arguments.find((argument) => argument.name.value == 'from');
     return from
         ? validateImportDirectiveArgumentFrom(def, directive, from)
@@ -718,13 +768,19 @@ const validateImportDirectiveFrom = (def, directive) => {
             }),
         ]);
 };
-const validateImportDirective = (def, directive) => List.of(...validateImportDirectiveFields(def, directive), ...validateImportDirectiveTypes(def, directive), ...validateImportDirectiveFrom(def, directive));
+const validateImportDirective = (def, directive) => {
+    validateDebugger('Validating import directive: %s', def?.name?.value);
+    return List.of(...validateImportDirectiveFields(def, directive), ...validateImportDirectiveTypes(def, directive), ...validateImportDirectiveFrom(def, directive));
+};
 const validateFulltext = (def, directive) => List.of(...validateFulltextFields(def, directive), ...validateFulltextName(def, directive), ...validateFulltextLanguage(def, directive), ...validateFulltextAlgorithm(def, directive), ...validateFulltextInclude(def, directive));
 const validateSubgraphSchemaDirective = (def, directive) => {
+    validateDebugger('Validating subgraph schema directive: %s', def?.name?.value);
     if (directive.name.value == 'import') {
+        validateDebugger('Validating import directive: %s', def?.name?.value);
         return validateImportDirective(def, directive);
     }
     if (directive.name.value == 'fulltext') {
+        validateDebugger('Validating fulltext directive: %s', def?.name?.value);
         return validateFulltext(def, directive);
     }
     return List([
@@ -735,32 +791,52 @@ const validateSubgraphSchemaDirective = (def, directive) => {
         }),
     ]);
 };
-const validateSubgraphSchemaDirectives = (def) => def.directives.reduce((errors, directive) => errors.concat(validateSubgraphSchemaDirective(def, directive)), List());
-const validateTypeHasNoFields = (def) => def.fields.length
-    ? List([
-        immutable_1.default.fromJS({
-            loc: def.name.loc,
-            entity: def.name.value,
-            message: `${def.name.value} type is not allowed any fields by convention`,
-        }),
-    ])
-    : List();
+const validateSubgraphSchemaDirectives = (def) => {
+    validateDebugger('Validating subgraph schema directives: %s', def?.name?.value);
+    return def.directives.reduce((errors, directive) => errors.concat(validateSubgraphSchemaDirective(def, directive)), List());
+};
+const validateTypeHasNoFields = (def) => {
+    validateDebugger('Validating type has no fields: %s', def?.name?.value);
+    return def.fields.length
+        ? List([
+            immutable_1.default.fromJS({
+                loc: def.name.loc,
+                entity: def.name.value,
+                message: `${def.name.value} type is not allowed any fields by convention`,
+            }),
+        ])
+        : List();
+};
 const validateAtLeastOneExtensionField = (_def) => List();
 const typeDefinitionValidators = {
-    ObjectTypeDefinition: (defs, def) => def.name && def.name.value == RESERVED_TYPE
-        ? List.of(...validateSubgraphSchemaDirectives(def), ...validateTypeHasNoFields(def))
-        : List.of(...validateEntityDirective(def), ...validateEntityID(def), ...validateEntityFields(defs, def), ...validateNoImportDirective(def), ...validateNoFulltext(def)),
-    ObjectTypeExtension: (_defs, def) => validateAtLeastOneExtensionField(def),
-};
-const validateTypeDefinition = (defs, def) => typeDefinitionValidators[def.kind] === undefined
-    ? List()
-    : typeDefinitionValidators[def.kind](defs, def);
-const validateTypeDefinitions = (defs) => defs.reduce((errors, def) => errors.concat(validateTypeDefinition(defs, def)), List());
+    ObjectTypeDefinition: (defs, def) => {
+        validateDebugger('Validating object type definition: %s', def?.name?.value);
+        return def.name && def.name.value == RESERVED_TYPE
+            ? List.of(...validateSubgraphSchemaDirectives(def), ...validateTypeHasNoFields(def))
+            : List.of(...validateEntityDirective(def), ...validateEntityID(def), ...validateEntityFields(defs, def), ...validateNoImportDirective(def), ...validateNoFulltext(def));
+    },
+    ObjectTypeExtension: (_defs, def) => {
+        validateDebugger('Validating object type extension: %s', def?.name?.value);
+        return validateAtLeastOneExtensionField(def);
+    },
+};
+const validateTypeDefinition = (defs, def) => {
+    validateDebugger.extend('definition')('Validating type definition: %M', def);
+    return typeDefinitionValidators[def.kind] === undefined
+        ? List()
+        : typeDefinitionValidators[def.kind](defs, def);
+};
+const validateTypeDefinitions = (defs) => {
+    validateDebugger('Validating type definitions');
+    return defs.reduce((errors, def) => errors.concat(validateTypeDefinition(defs, def)), List());
+};
 const validateNamingCollisionsInTypes = (types) => {
+    validateDebugger('Validating naming collisions in types');
     let seen = Set();
     let conflicting = Set();
     return types.reduce((errors, type) => {
         if (seen.has(type) && !conflicting.has(type)) {
+            validateDebugger('Found naming collision');
             errors = errors.push(immutable_1.default.fromJS({
                 loc: { start: 1, end: 1 },
                 entity: type,
@@ -774,10 +850,16 @@ const validateNamingCollisionsInTypes = (types) => {
         return errors;
     }, List());
 };
-const validateNamingCollisions = (local, imported) => validateNamingCollisionsInTypes(local.concat(imported));
+const validateNamingCollisions = (local, imported) => {
+    validateDebugger('Validating naming collisions');
+    return validateNamingCollisionsInTypes(local.concat(imported));
+};
 const validateSchema = (filename) => {
+    validateDebugger('Validating schema: %s', filename);
     const doc = loadSchema(filename);
+    validateDebugger('Loaded schema: %s', filename);
     const schema = parseSchema(doc);
+    validateDebugger.extend('schema')('Parsed schema: %M', schema);
     return List.of(...validateTypeDefinitions(schema.definitions), ...validateNamingCollisions(gatherLocalTypes(schema.definitions), gatherImportedTypes(schema.definitions)));
 };
 exports.validateSchema = validateSchema;

package/oclif.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.56.0",
+  "version": "0.56.1-alpha-20230831035057-3d319d2",
   "commands": {
     "add": {
       "id": "add",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphprotocol/graph-cli",
-  "version": "0.56.0",
+  "version": "0.56.1-alpha-20230831035057-3d319d2",
   "description": "CLI for building for and deploying to The Graph",
   "license": "(Apache-2.0 OR MIT)",
   "engines": {