@graphprotocol/graph-cli 0.45.1-alpha-20230405193954-4e288f4 → 0.45.1-alpha-20230409224212-0d77249

package/CHANGELOG.md

@@ -1,13 +1,14 @@
 # @graphprotocol/graph-cli
 
-## 0.45.1-alpha-20230405193954-4e288f4
+## 0.45.1-alpha-20230409224212-0d77249
 
 ### Patch Changes
 
-- [#1259](https://github.com/graphprotocol/graph-tooling/pull/1259)
-  [`4e288f4`](https://github.com/graphprotocol/graph-tooling/commit/4e288f4148a397a02738e2b142bbedec566207ca)
-  Thanks [@saihaj](https://github.com/saihaj)! - refactor out immutable.js usage from schema
-  generation
+- [#1263](https://github.com/graphprotocol/graph-tooling/pull/1263)
+  [`2ba2ba9`](https://github.com/graphprotocol/graph-tooling/commit/2ba2ba96c6cdc10461903b0712f122eb6d245f86)
+  Thanks [@mihirgupta0900](https://github.com/mihirgupta0900)! - Fixes dependency error from
+  `ipfs-http-client` and `concat-stream`. Visit
+  https://github.com/graphprotocol/graph-tooling/issues/1262 for more details.
 
 ## 0.45.0
 

package/dist/codegen/schema.js

@@ -22,18 +22,17 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __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 });
+/* eslint-disable unicorn/no-array-for-each */
+const immutable_1 = __importDefault(require("immutable"));
 const typesCodegen = __importStar(require("./types"));
 const tsCodegen = __importStar(require("./typescript"));
 class IdField {
     constructor(idField) {
-        if (idField?.type.kind !== 'NonNullType') {
-            throw Error('id field must be non-nullable');
-        }
-        if (idField.type.type.kind !== 'NamedType') {
-            throw Error('id field must be a named type');
-        }
-        const typeName = idField.type.type.name.value;
+        const typeName = idField.getIn(['type', 'type', 'name', 'value']);
         this.kind = typeName === 'Bytes' ? IdField.BYTES : IdField.STRING;
     }
     typeName() {
@@ -58,11 +57,11 @@ class IdField {
         return this.kind == IdField.BYTES ? 'id.toHexString()' : 'id';
     }
     static fromFields(fields) {
-        const idField = fields?.find(field => field.name.value === 'id');
+        const idField = fields.find(field => field.getIn(['name', 'value']) === 'id');
         return new IdField(idField);
     }
     static fromTypeDef(def) {
-        return IdField.fromFields(def.fields);
+        return IdField.fromFields(def.get('fields'));
     }
 }
 IdField.BYTES = Symbol('Bytes');
@@ -90,33 +89,33 @@ class SchemaCodeGenerator {
         ];
     }
     generateTypes() {
-        return this.schema.ast.definitions
-            .map(def => {
-            if (this._isEntityTypeDefinition(def)) {
-                return this._generateEntityType(def);
-            }
-        })
-            .filter(Boolean);
+        return this.schema.ast
+            .get('definitions')
+            .filter((def) => this._isEntityTypeDefinition(def))
+            .map((def) => this._generateEntityType(def));
     }
     _isEntityTypeDefinition(def) {
-        return (def.kind === 'ObjectTypeDefinition' &&
-            def.directives?.find(directive => directive.name.value === 'entity') !== undefined);
+        return (def.get('kind') === 'ObjectTypeDefinition' &&
+            def
+                .get('directives')
+                .find((directive) => directive.getIn(['name', 'value']) === 'entity') !== undefined);
     }
     _isInterfaceDefinition(def) {
-        return def.kind === 'InterfaceTypeDefinition';
+        return def.get('kind') === 'InterfaceTypeDefinition';
     }
     _generateEntityType(def) {
-        const name = def.name.value;
+        const name = def.getIn(['name', 'value']);
         const klass = tsCodegen.klass(name, { export: true, extends: 'Entity' });
-        const fields = def.fields;
+        const fields = def.get('fields');
         const idField = IdField.fromFields(fields);
         // Generate and add a constructor
         klass.addMethod(this._generateConstructor(name, fields));
         // Generate and add save() and getById() methods
         this._generateStoreMethods(name, idField).forEach(method => klass.addMethod(method));
         // Generate and add entity field getters and setters
-        def.fields
-            ?.reduce((methods, field) => methods.concat(this._generateEntityFieldMethods(def, field)), [])
+        def
+            .get('fields')
+            .reduce((methods, field) => methods.concat(this._generateEntityFieldMethods(def, field)), immutable_1.default.List())
             .forEach((method) => klass.addMethod(method));
         return klass;
     }
@@ -128,8 +127,7 @@ class SchemaCodeGenerator {
       `);
     }
     _generateStoreMethods(entityName, idField) {
-        return [
-            tsCodegen.method('save', [], tsCodegen.namedType('void'), `
+        return immutable_1.default.List.of(tsCodegen.method('save', [], tsCodegen.namedType('void'), `
         let id = this.get('id')
         assert(id != null,
                'Cannot save ${entityName} entity without an ID')
@@ -137,24 +135,23 @@ class SchemaCodeGenerator {
           assert(id.kind == ${idField.tsValueKind()},
                  \`Entities of type ${entityName} must have an ID of type ${idField.gqlTypeName()} but the id '\${id.displayData()}' is of type \${id.displayKind()}\`)
           store.set('${entityName}', ${idField.tsValueToString()}, this)
-        }`),
-            tsCodegen.staticMethod('load', [tsCodegen.param('id', tsCodegen.namedType(idField.typeName()))], tsCodegen.nullableType(tsCodegen.namedType(entityName)), `
+        }`), tsCodegen.staticMethod('load', [tsCodegen.param('id', tsCodegen.namedType(idField.typeName()))], tsCodegen.nullableType(tsCodegen.namedType(entityName)), `
         return changetype<${entityName} | null>(store.get('${entityName}', ${idField.tsToString()}))
-        `),
-        ];
+        `));
     }
     _generateEntityFieldMethods(entityDef, fieldDef) {
-        return [
+        return (immutable_1.default
+            .List([
             this._generateEntityFieldGetter(entityDef, fieldDef),
             this._generateEntityFieldSetter(entityDef, fieldDef),
-        ]
+        ])
             // generator can return null if the field is not supported
             // so we filter all falsy values
-            .filter(Boolean);
+            .filter(Boolean));
     }
     _generateEntityFieldGetter(_entityDef, fieldDef) {
-        const name = fieldDef.name.value;
-        const gqlType = fieldDef.type;
+        const name = fieldDef.getIn(['name', 'value']);
+        const gqlType = fieldDef.get('type');
         const fieldValueType = this._valueTypeFromGraphQl(gqlType);
         const returnType = this._typeFromGraphQl(gqlType);
         const isNullable = returnType instanceof tsCodegen.NullableType;
@@ -170,12 +167,14 @@ class SchemaCodeGenerator {
       `);
     }
     _generateEntityFieldSetter(_entityDef, fieldDef) {
-        const name = fieldDef.name.value;
-        const isDerivedField = !!fieldDef.directives?.find(directive => directive.name.value === 'derivedFrom');
+        const name = fieldDef.getIn(['name', 'value']);
+        const isDerivedField = !!fieldDef
+            .get('directives')
+            .find((directive) => directive.getIn(['name', 'value']) === 'derivedFrom');
         // We cannot have setters for derived fields
         if (isDerivedField)
             return null;
-        const gqlType = fieldDef.type;
+        const gqlType = fieldDef.get('type');
         const fieldValueType = this._valueTypeFromGraphQl(gqlType);
         const paramType = this._typeFromGraphQl(gqlType);
         const isNullable = paramType instanceof tsCodegen.NullableType;
@@ -201,11 +200,13 @@ Suggestion: add an '!' to the member type of the List, change from '[${baseType}
         return tsCodegen.method(`set ${name}`, [tsCodegen.param('value', paramType)], undefined, isNullable ? setNullable : setNonNullable);
     }
     _resolveFieldType(gqlType) {
-        const typeName = gqlType.name.value;
+        const typeName = gqlType.getIn(['name', 'value']);
         // If this is a reference to another type, the field has the type of
         // the referred type's id field
-        const typeDef = this.schema.ast.definitions?.find(def => (this._isEntityTypeDefinition(def) || this._isInterfaceDefinition(def)) &&
-            def.name.value === typeName);
+        const typeDef = this.schema.ast
+            .get('definitions')
+            .find((def) => (this._isEntityTypeDefinition(def) || this._isInterfaceDefinition(def)) &&
+            def.getIn(['name', 'value']) === typeName);
         if (typeDef) {
             return IdField.fromTypeDef(typeDef).typeName();
         }
@@ -216,31 +217,31 @@ Suggestion: add an '!' to the member type of the List, change from '[${baseType}
      * other entity types, this is the same as the type of the id of the
      * referred type, i.e., `string` or `Bytes`*/
     _valueTypeFromGraphQl(gqlType) {
-        if (gqlType.kind === 'NonNullType') {
-            return this._valueTypeFromGraphQl(gqlType.type);
+        if (gqlType.get('kind') === 'NonNullType') {
+            return this._valueTypeFromGraphQl(gqlType.get('type'));
         }
-        if (gqlType.kind === 'ListType') {
-            return '[' + this._valueTypeFromGraphQl(gqlType.type) + ']';
+        if (gqlType.get('kind') === 'ListType') {
+            return '[' + this._valueTypeFromGraphQl(gqlType.get('type')) + ']';
         }
         return this._resolveFieldType(gqlType);
     }
     /** Determine the base type of `gqlType` by removing any non-null
      * constraints and using the type of elements of lists */
     _baseType(gqlType) {
-        if (gqlType.kind === 'NonNullType') {
-            return this._baseType(gqlType.type);
+        if (gqlType.get('kind') === 'NonNullType') {
+            return this._baseType(gqlType.get('type'));
         }
-        if (gqlType.kind === 'ListType') {
-            return this._baseType(gqlType.type);
+        if (gqlType.get('kind') === 'ListType') {
+            return this._baseType(gqlType.get('type'));
         }
-        return gqlType.name.value;
+        return gqlType.getIn(['name', 'value']);
     }
     _typeFromGraphQl(gqlType, nullable = true) {
-        if (gqlType.kind === 'NonNullType') {
-            return this._typeFromGraphQl(gqlType.type, false);
+        if (gqlType.get('kind') === 'NonNullType') {
+            return this._typeFromGraphQl(gqlType.get('type'), false);
         }
-        if (gqlType.kind === 'ListType') {
-            const type = tsCodegen.arrayType(this._typeFromGraphQl(gqlType.type));
+        if (gqlType.get('kind') === 'ListType') {
+            const type = tsCodegen.arrayType(this._typeFromGraphQl(gqlType.get('type')));
             return nullable ? tsCodegen.nullableType(type) : type;
         }
         // NamedType

package/dist/codegen/schema.test.js

@@ -27,12 +27,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const graphql = __importStar(require("graphql/language"));
+const immutable_1 = __importDefault(require("immutable"));
 const prettier_1 = __importDefault(require("prettier"));
 const schema_1 = __importDefault(require("../schema"));
 const schema_2 = __importDefault(require("./schema"));
 const typescript_1 = require("./typescript");
 const formatTS = (code) => prettier_1.default.format(code, { parser: 'typescript', semi: false });
-const createSchemaCodeGen = (schema) => new schema_2.default(new schema_1.default('', schema, graphql.parse(schema)));
+const createSchemaCodeGen = (schema) => new schema_2.default(new schema_1.default('', schema, immutable_1.default.fromJS(graphql.parse(schema))));
 const testEntity = (generatedTypes, expectedEntity) => {
     const entity = generatedTypes.find(type => type.name === expectedEntity.name);
     expect(entity instanceof typescript_1.Class).toBe(true);
@@ -63,7 +64,7 @@ describe('Schema code generator', () => {
         barfoo: Int
       }
     `);
-        expect(codegen.generateTypes().length).toBe(0);
+        expect(codegen.generateTypes().size).toBe(0);
     });
     describe('Should generate correct classes for each entity', () => {
         const codegen = createSchemaCodeGen(`
@@ -98,7 +99,7 @@ describe('Schema code generator', () => {
             const foo = generatedTypes.find((type) => type.name === 'Foo');
             expect(foo).toBe(undefined);
             // Account and Wallet
-            expect(generatedTypes.length).toBe(2);
+            expect(generatedTypes.size).toBe(2);
         });
         test('Account is an entity with the correct methods', () => {
             testEntity(generatedTypes, {

package/dist/schema.js

@@ -28,6 +28,7 @@ var __importDefault = (this && this.__importDefault) || function (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 {
     constructor(filename, document, ast) {
@@ -44,7 +45,7 @@ class Schema {
     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, ast);
+        return new Schema(filename, document, immutable_1.default.fromJS(ast));
     }
 }
 exports.default = Schema;

package/oclif.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.45.1-alpha-20230405193954-4e288f4",
+  "version": "0.45.1-alpha-20230409224212-0d77249",
   "commands": {
     "add": {
       "id": "add",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphprotocol/graph-cli",
-  "version": "0.45.1-alpha-20230405193954-4e288f4",
+  "version": "0.45.1-alpha-20230409224212-0d77249",
   "description": "CLI for building for and deploying to The Graph",
   "license": "(Apache-2.0 OR MIT)",
   "engines": {