@graphprotocol/graph-cli 0.45.0 → 0.45.1-alpha-20230405193954-4e288f4

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # @graphprotocol/graph-cli
 
+## 0.45.1-alpha-20230405193954-4e288f4
+
+### 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
+
 ## 0.45.0
 
 ### Minor Changes

package/dist/codegen/schema.js

@@ -22,17 +22,18 @@ 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) {
-        const typeName = idField.getIn(['type', 'type', 'name', 'value']);
+        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;
         this.kind = typeName === 'Bytes' ? IdField.BYTES : IdField.STRING;
     }
     typeName() {
@@ -57,11 +58,11 @@ class IdField {
         return this.kind == IdField.BYTES ? 'id.toHexString()' : 'id';
     }
     static fromFields(fields) {
-        const idField = fields.find(field => field.getIn(['name', 'value']) === 'id');
+        const idField = fields?.find(field => field.name.value === 'id');
         return new IdField(idField);
     }
     static fromTypeDef(def) {
-        return IdField.fromFields(def.get('fields'));
+        return IdField.fromFields(def.fields);
     }
 }
 IdField.BYTES = Symbol('Bytes');
@@ -89,33 +90,33 @@ class SchemaCodeGenerator {
         ];
     }
     generateTypes() {
-        return this.schema.ast
-            .get('definitions')
-            .filter((def) => this._isEntityTypeDefinition(def))
-            .map((def) => this._generateEntityType(def));
+        return this.schema.ast.definitions
+            .map(def => {
+            if (this._isEntityTypeDefinition(def)) {
+                return this._generateEntityType(def);
+            }
+        })
+            .filter(Boolean);
     }
     _isEntityTypeDefinition(def) {
-        return (def.get('kind') === 'ObjectTypeDefinition' &&
-            def
-                .get('directives')
-                .find((directive) => directive.getIn(['name', 'value']) === 'entity') !== undefined);
+        return (def.kind === 'ObjectTypeDefinition' &&
+            def.directives?.find(directive => directive.name.value === 'entity') !== undefined);
     }
     _isInterfaceDefinition(def) {
-        return def.get('kind') === 'InterfaceTypeDefinition';
+        return def.kind === 'InterfaceTypeDefinition';
     }
     _generateEntityType(def) {
-        const name = def.getIn(['name', 'value']);
+        const name = def.name.value;
         const klass = tsCodegen.klass(name, { export: true, extends: 'Entity' });
-        const fields = def.get('fields');
+        const fields = def.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
-            .get('fields')
-            .reduce((methods, field) => methods.concat(this._generateEntityFieldMethods(def, field)), immutable_1.default.List())
+        def.fields
+            ?.reduce((methods, field) => methods.concat(this._generateEntityFieldMethods(def, field)), [])
             .forEach((method) => klass.addMethod(method));
         return klass;
     }
@@ -127,7 +128,8 @@ class SchemaCodeGenerator {
       `);
     }
     _generateStoreMethods(entityName, idField) {
-        return immutable_1.default.List.of(tsCodegen.method('save', [], tsCodegen.namedType('void'), `
+        return [
+            tsCodegen.method('save', [], tsCodegen.namedType('void'), `
         let id = this.get('id')
         assert(id != null,
                'Cannot save ${entityName} entity without an ID')
@@ -135,23 +137,24 @@ 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 (immutable_1.default
-            .List([
+        return [
             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.getIn(['name', 'value']);
-        const gqlType = fieldDef.get('type');
+        const name = fieldDef.name.value;
+        const gqlType = fieldDef.type;
         const fieldValueType = this._valueTypeFromGraphQl(gqlType);
         const returnType = this._typeFromGraphQl(gqlType);
         const isNullable = returnType instanceof tsCodegen.NullableType;
@@ -167,14 +170,12 @@ class SchemaCodeGenerator {
       `);
     }
     _generateEntityFieldSetter(_entityDef, fieldDef) {
-        const name = fieldDef.getIn(['name', 'value']);
-        const isDerivedField = !!fieldDef
-            .get('directives')
-            .find((directive) => directive.getIn(['name', 'value']) === 'derivedFrom');
+        const name = fieldDef.name.value;
+        const isDerivedField = !!fieldDef.directives?.find(directive => directive.name.value === 'derivedFrom');
         // We cannot have setters for derived fields
         if (isDerivedField)
             return null;
-        const gqlType = fieldDef.get('type');
+        const gqlType = fieldDef.type;
         const fieldValueType = this._valueTypeFromGraphQl(gqlType);
         const paramType = this._typeFromGraphQl(gqlType);
         const isNullable = paramType instanceof tsCodegen.NullableType;
@@ -200,13 +201,11 @@ 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.getIn(['name', 'value']);
+        const typeName = gqlType.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
-            .get('definitions')
-            .find((def) => (this._isEntityTypeDefinition(def) || this._isInterfaceDefinition(def)) &&
-            def.getIn(['name', 'value']) === typeName);
+        const typeDef = this.schema.ast.definitions?.find(def => (this._isEntityTypeDefinition(def) || this._isInterfaceDefinition(def)) &&
+            def.name.value === typeName);
         if (typeDef) {
             return IdField.fromTypeDef(typeDef).typeName();
         }
@@ -217,31 +216,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.get('kind') === 'NonNullType') {
-            return this._valueTypeFromGraphQl(gqlType.get('type'));
+        if (gqlType.kind === 'NonNullType') {
+            return this._valueTypeFromGraphQl(gqlType.type);
         }
-        if (gqlType.get('kind') === 'ListType') {
-            return '[' + this._valueTypeFromGraphQl(gqlType.get('type')) + ']';
+        if (gqlType.kind === 'ListType') {
+            return '[' + this._valueTypeFromGraphQl(gqlType.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.get('kind') === 'NonNullType') {
-            return this._baseType(gqlType.get('type'));
+        if (gqlType.kind === 'NonNullType') {
+            return this._baseType(gqlType.type);
         }
-        if (gqlType.get('kind') === 'ListType') {
-            return this._baseType(gqlType.get('type'));
+        if (gqlType.kind === 'ListType') {
+            return this._baseType(gqlType.type);
         }
-        return gqlType.getIn(['name', 'value']);
+        return gqlType.name.value;
     }
     _typeFromGraphQl(gqlType, nullable = true) {
-        if (gqlType.get('kind') === 'NonNullType') {
-            return this._typeFromGraphQl(gqlType.get('type'), false);
+        if (gqlType.kind === 'NonNullType') {
+            return this._typeFromGraphQl(gqlType.type, false);
         }
-        if (gqlType.get('kind') === 'ListType') {
-            const type = tsCodegen.arrayType(this._typeFromGraphQl(gqlType.get('type')));
+        if (gqlType.kind === 'ListType') {
+            const type = tsCodegen.arrayType(this._typeFromGraphQl(gqlType.type));
             return nullable ? tsCodegen.nullableType(type) : type;
         }
         // NamedType

package/dist/codegen/schema.test.js

@@ -27,13 +27,12 @@ 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, immutable_1.default.fromJS(graphql.parse(schema))));
+const createSchemaCodeGen = (schema) => new schema_2.default(new schema_1.default('', schema, graphql.parse(schema)));
 const testEntity = (generatedTypes, expectedEntity) => {
     const entity = generatedTypes.find(type => type.name === expectedEntity.name);
     expect(entity instanceof typescript_1.Class).toBe(true);
@@ -64,7 +63,7 @@ describe('Schema code generator', () => {
         barfoo: Int
       }
     `);
-        expect(codegen.generateTypes().size).toBe(0);
+        expect(codegen.generateTypes().length).toBe(0);
     });
     describe('Should generate correct classes for each entity', () => {
         const codegen = createSchemaCodeGen(`
@@ -99,7 +98,7 @@ describe('Schema code generator', () => {
             const foo = generatedTypes.find((type) => type.name === 'Foo');
             expect(foo).toBe(undefined);
             // Account and Wallet
-            expect(generatedTypes.size).toBe(2);
+            expect(generatedTypes.length).toBe(2);
         });
         test('Account is an entity with the correct methods', () => {
             testEntity(generatedTypes, {

package/dist/schema.js

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

package/oclif.manifest.json

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

package/package.json

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