@graphprotocol/graph-cli 0.51.0-alpha-20230530203813-7e94f46 → 0.51.0

package/CHANGELOG.md

@@ -1,11 +1,21 @@
 # @graphprotocol/graph-cli
 
-## 0.51.0-alpha-20230530203813-7e94f46
+## 0.51.0
 
 ### Minor Changes
 
+- [#1340](https://github.com/graphprotocol/graph-tooling/pull/1340)
+  [`2375877`](https://github.com/graphprotocol/graph-tooling/commit/23758774b33b5b7c6934f57a3e137870205ca6f0)
+  Thanks [@incrypto32](https://github.com/incrypto32)! - Add support for codegen for derived field
+  loaders, This adds getters for derived fields defined in the schema for entities.
+
+- [#1363](https://github.com/graphprotocol/graph-tooling/pull/1363)
+  [`f928262`](https://github.com/graphprotocol/graph-tooling/commit/f9282626d7e906cfdc0fc826bdbc92ff2c907e97)
+  Thanks [@saihaj](https://github.com/saihaj)! - add `graph clean` command to delete generated
+  artifacts
+
 - [#1296](https://github.com/graphprotocol/graph-tooling/pull/1296)
-  [`7170d9a`](https://github.com/graphprotocol/graph-tooling/commit/7170d9a7062ae6db4eac73818ba32606b0f18657)
+  [`dab4ca1`](https://github.com/graphprotocol/graph-tooling/commit/dab4ca1f5df7dcd0928bbaa20304f41d23b20ced)
   Thanks [@dotansimha](https://github.com/dotansimha)! - Added support for handling GraphQL `Int8`
   scalar as `i64` (AssemblyScript)
 

package/dist/codegen/schema.d.ts

@@ -21,13 +21,20 @@ export default class SchemaCodeGenerator {
     constructor(schema: Schema);
     generateModuleImports(): tsCodegen.ModuleImports[];
     generateTypes(): Array<tsCodegen.Class>;
+    generateDerivedLoaders(): any[];
     _isEntityTypeDefinition(def: DefinitionNode): def is ObjectTypeDefinitionNode;
+    _isDerivedField(field: FieldDefinitionNode | undefined): boolean;
     _isInterfaceDefinition(def: DefinitionNode): def is InterfaceTypeDefinitionNode;
     _generateEntityType(def: ObjectTypeDefinitionNode): tsCodegen.Class;
+    _generateDerivedLoader(typeName: string): any;
+    _getTypeNameForField(gqlType: TypeNode): string;
     _generateConstructor(_entityName: string, fields: readonly FieldDefinitionNode[] | undefined): tsCodegen.Method;
     _generateStoreMethods(entityName: string, idField: IdField): Array<tsCodegen.Method | tsCodegen.StaticMethod>;
     _generateEntityFieldMethods(entityDef: ObjectTypeDefinitionNode, fieldDef: FieldDefinitionNode): Array<tsCodegen.Method>;
     _generateEntityFieldGetter(_entityDef: ObjectTypeDefinitionNode, fieldDef: FieldDefinitionNode): tsCodegen.Method;
+    _generateDerivedFieldGetter(entityDef: ObjectTypeDefinitionNode, fieldDef: FieldDefinitionNode): tsCodegen.Method;
+    _returnTypeForDervied(gqlType: TypeNode): tsCodegen.NamedType;
+    _generatedEntityDerivedFieldGetter(_entityDef: ObjectTypeDefinitionNode, fieldDef: FieldDefinitionNode): tsCodegen.Method;
     _generateEntityFieldSetter(_entityDef: ObjectTypeDefinitionNode, fieldDef: FieldDefinitionNode): tsCodegen.Method | null;
     _resolveFieldType(gqlType: NamedTypeNode): string;
     /** Return the type that values for this field must have. For scalar

package/dist/codegen/schema.js

@@ -22,7 +22,12 @@ 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 debug_1 = __importDefault(require("debug"));
 const typesCodegen = __importStar(require("./types"));
 const tsCodegen = __importStar(require("./typescript"));
 class IdField {
@@ -98,10 +103,23 @@ class SchemaCodeGenerator {
         })
             .filter(Boolean);
     }
+    generateDerivedLoaders() {
+        const fields = this.schema.ast.definitions.filter(def => this._isEntityTypeDefinition(def))
+            .flatMap((def) => def.fields)
+            .filter(def => this._isDerivedField(def))
+            .filter(def => def?.type !== undefined).map(def => this._getTypeNameForField(def.type));
+        return [...new Set(fields)].map(typeName => {
+            return this._generateDerivedLoader(typeName);
+        });
+    }
     _isEntityTypeDefinition(def) {
         return (def.kind === 'ObjectTypeDefinition' &&
             def.directives?.find(directive => directive.name.value === 'entity') !== undefined);
     }
+    _isDerivedField(field) {
+        return (field?.directives?.find((directive) => directive.name.value === 'derivedFrom') !==
+            undefined);
+    }
     _isInterfaceDefinition(def) {
         return def.kind === 'InterfaceTypeDefinition';
     }
@@ -120,6 +138,42 @@ class SchemaCodeGenerator {
             .forEach((method) => klass.addMethod(method));
         return klass;
     }
+    _generateDerivedLoader(typeName) {
+        // <field>Loader
+        const klass = tsCodegen.klass(`${typeName}Loader`, { export: true, extends: 'Entity' });
+        klass.addMember(tsCodegen.klassMember('_entity', 'string'));
+        klass.addMember(tsCodegen.klassMember('_field', 'string'));
+        klass.addMember(tsCodegen.klassMember('_id', 'string'));
+        // Generate and add a constructor
+        klass.addMethod(tsCodegen.method('constructor', [
+            tsCodegen.param('entity', 'string'),
+            tsCodegen.param('id', 'string'),
+            tsCodegen.param('field', 'string'),
+        ], undefined, `
+      super();
+      this._entity = entity;
+      this._id = id;
+      this._field = field;
+`));
+        // Generate load() method for the Loader
+        klass.addMethod(tsCodegen.method('load', [], `${typeName}[]`, `
+  let value = store.loadRelated(this._entity, this._id, this._field);
+  return changetype<${typeName}[]>(value);
+  `));
+        return klass;
+    }
+    _getTypeNameForField(gqlType) {
+        if (gqlType.kind === 'NonNullType') {
+            return this._getTypeNameForField(gqlType.type);
+        }
+        if (gqlType.kind === 'ListType') {
+            return this._getTypeNameForField(gqlType.type);
+        }
+        if (gqlType.kind === 'NamedType') {
+            return gqlType.name.value;
+        }
+        throw new Error(`Unknown type kind: ${gqlType}`);
+    }
     _generateConstructor(_entityName, fields) {
         const idField = IdField.fromFields(fields);
         return tsCodegen.method('constructor', [tsCodegen.param('id', idField.tsNamedType())], undefined, `
@@ -156,6 +210,12 @@ class SchemaCodeGenerator {
             .filter(Boolean);
     }
     _generateEntityFieldGetter(_entityDef, fieldDef) {
+        const isDerivedField = this._isDerivedField(fieldDef);
+        const codegenDebug = (0, debug_1.default)('codegen');
+        if (isDerivedField) {
+            codegenDebug(`Generating derived field getter for ${fieldDef.name.value}`);
+            return this._generateDerivedFieldGetter(_entityDef, fieldDef);
+        }
         const name = fieldDef.name.value;
         const gqlType = fieldDef.type;
         const fieldValueType = this._valueTypeFromGraphQl(gqlType);
@@ -179,6 +239,42 @@ class SchemaCodeGenerator {
        ${isNullable ? getNullable : getNonNullable}
       `);
     }
+    _generateDerivedFieldGetter(entityDef, fieldDef) {
+        const entityName = entityDef.name.value;
+        const name = fieldDef.name.value;
+        const gqlType = fieldDef.type;
+        const returnType = this._returnTypeForDervied(gqlType);
+        return tsCodegen.method(`get ${name}`, [], returnType, `
+        return new ${returnType}('${entityName}', this.get('id')!.toString(), '${name}')
+      `);
+    }
+    _returnTypeForDervied(gqlType) {
+        if (gqlType.kind === 'NonNullType') {
+            return this._returnTypeForDervied(gqlType.type);
+        }
+        if (gqlType.kind === 'ListType') {
+            return this._returnTypeForDervied(gqlType.type);
+        }
+        const type = tsCodegen.namedType(gqlType.name.value + 'Loader');
+        return type;
+    }
+    _generatedEntityDerivedFieldGetter(_entityDef, fieldDef) {
+        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;
+        const getNonNullable = `return ${typesCodegen.valueToAsc('value!', fieldValueType)}`;
+        const getNullable = `if (!value || value.kind == ValueKind.NULL) {
+                          return null
+                        } else {
+                          return ${typesCodegen.valueToAsc('value', fieldValueType)}
+                        }`;
+        return tsCodegen.method(`get ${name}`, [], returnType, `
+       let value = this.get('${name}')
+       ${isNullable ? getNullable : getNonNullable}
+      `);
+    }
     _generateEntityFieldSetter(_entityDef, fieldDef) {
         const name = fieldDef.name.value;
         const isDerivedField = !!fieldDef.directives?.find(directive => directive.name.value === 'derivedFrom');

package/dist/codegen/schema.test.js

@@ -299,14 +299,9 @@ describe('Schema code generator', () => {
                     {
                         name: 'get wallets',
                         params: [],
-                        returnType: new typescript_1.NullableType(new typescript_1.ArrayType(new typescript_1.NamedType('string'))),
+                        returnType: new typescript_1.NamedType('WalletLoader'),
                         body: `
-              let value = this.get('wallets')
-              if (!value || value.kind == ValueKind.NULL) {
-                return null
-              } else {
-                return value.toStringArray()
-              }
+              return new WalletLoader("Account", this.get('id')!.toString(), "wallets") 
             `,
                     },
                 ],

package/dist/commands/clean.d.ts

@@ -0,0 +1,10 @@
+import { Command } from '@oclif/core';
+export default class CleanCommand extends Command {
+    static description: string;
+    static flags: {
+        help: import("@oclif/core/lib/interfaces").BooleanFlag<void>;
+        'codegen-dir': import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        'build-dir': import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/clean.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const gluegun_1 = require("gluegun");
+class CleanCommand extends core_1.Command {
+    async run() {
+        const { flags: { 'codegen-dir': codegenDir, 'build-dir': buildDir }, } = await this.parse(CleanCommand);
+        const spinner = gluegun_1.print.spin(`Cleaning cache and generated files`);
+        spinner.start();
+        try {
+            await gluegun_1.filesystem.removeAsync(codegenDir);
+            await gluegun_1.filesystem.removeAsync(buildDir);
+            spinner.succeed();
+            gluegun_1.print.success('Cache and generated files cleaned');
+        }
+        catch (e) {
+            spinner.fail('Failed to clean cache and generated files');
+        }
+        finally {
+            spinner.stop();
+        }
+    }
+}
+CleanCommand.description = 'Clean the cache and generated files.';
+CleanCommand.flags = {
+    help: core_1.Flags.help({
+        char: 'h',
+    }),
+    'codegen-dir': core_1.Flags.directory({
+        summary: 'Directory where the "graph codegen" code is stored.',
+        default: 'generated/',
+    }),
+    'build-dir': core_1.Flags.directory({
+        summary: 'Directory where the "graph build" code is stored.',
+        default: 'build/',
+    }),
+};
+exports.default = CleanCommand;

package/dist/type-generator.js

@@ -130,6 +130,7 @@ class TypeGenerator {
                 typescript_1.GENERATED_FILE_NOTE,
                 ...codeGenerator.generateModuleImports(),
                 ...codeGenerator.generateTypes(),
+                ...codeGenerator.generateDerivedLoaders(),
             ].join('\n'), {
                 parser: 'typescript',
             });

package/oclif.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.51.0-alpha-20230530203813-7e94f46",
+  "version": "0.51.0",
   "commands": {
     "add": {
       "id": "add",
@@ -184,6 +184,39 @@
         }
       }
     },
+    "clean": {
+      "id": "clean",
+      "description": "Clean the cache and generated files.",
+      "strict": true,
+      "pluginName": "@graphprotocol/graph-cli",
+      "pluginAlias": "@graphprotocol/graph-cli",
+      "pluginType": "core",
+      "aliases": [],
+      "flags": {
+        "help": {
+          "name": "help",
+          "type": "boolean",
+          "char": "h",
+          "description": "Show CLI help.",
+          "allowNo": false
+        },
+        "codegen-dir": {
+          "name": "codegen-dir",
+          "type": "option",
+          "summary": "Directory where the \"graph codegen\" code is stored.",
+          "multiple": false,
+          "default": "generated/"
+        },
+        "build-dir": {
+          "name": "build-dir",
+          "type": "option",
+          "summary": "Directory where the \"graph build\" code is stored.",
+          "multiple": false,
+          "default": "build/"
+        }
+      },
+      "args": {}
+    },
     "codegen": {
       "id": "codegen",
       "description": "Generates AssemblyScript types for a subgraph.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphprotocol/graph-cli",
-  "version": "0.51.0-alpha-20230530203813-7e94f46",
+  "version": "0.51.0",
   "description": "CLI for building for and deploying to The Graph",
   "license": "(Apache-2.0 OR MIT)",
   "engines": {