Run prettier

Author: incrypto32

packages/cli/src/codegen/schema.test.ts

@@ -2,14 +2,7 @@ import * as graphql from 'graphql/language';
 import prettier from 'prettier';
 import Schema from '../schema';
 import SchemaCodeGenerator from './schema';
-import {
-  Class,
-  Method,
-  NamedType,
-  NullableType,
-  Param,
-  StaticMethod,
-} from './typescript';
+import { Class, Method, NamedType, NullableType, Param, StaticMethod } from './typescript';
 
 const formatTS = (code: string) => prettier.format(code, { parser: 'typescript', semi: false });
 
@@ -28,7 +21,6 @@ const testEntity = (generatedTypes: any[], expectedEntity: any) => {
   expect(members).toStrictEqual(expectedEntity.members);
 
   for (const expectedMethod of expectedEntity.methods) {
-
     const method = methods.find((method: any) => method.name === expectedMethod.name);
 
     // eslint-disable-next-line @typescript-eslint/no-unused-expressions

packages/cli/src/codegen/schema.ts

@@ -106,13 +106,14 @@ export default class SchemaCodeGenerator {
 
   generateDerivedLoaders() {
     const fields = this.schema.ast.definitions
-      .filter((def) => this._isEntityTypeDefinition(def))
+      .filter(def => this._isEntityTypeDefinition(def))
       .flatMap((def: any) => def.fields)
       .filter((def: any) => this._isDerivedField(def))
       .map((def: FieldDefinitionNode) => this._getTypeNameForField(def.type));
 
     return [...new Set(fields)].map((typeName: any) => {
-      return this._generateDerivedLoader(typeName)});
+      return this._generateDerivedLoader(typeName);
+    });
   }
 
   _isEntityTypeDefinition(def: DefinitionNode): def is ObjectTypeDefinitionNode {
@@ -122,11 +123,11 @@ export default class SchemaCodeGenerator {
     );
   }
 
-
   _isDerivedField(field: any): boolean {
-    return field.directives?.find(
-      (directive: any) => directive.name.value === 'derivedFrom'
-    ) !== undefined
+    return (
+      field.directives?.find((directive: any) => directive.name.value === 'derivedFrom') !==
+      undefined
+    );
   }
   _isInterfaceDefinition(def: DefinitionNode): def is InterfaceTypeDefinitionNode {
     return def.kind === 'InterfaceTypeDefinition';
@@ -155,43 +156,61 @@ export default class SchemaCodeGenerator {
     return klass;
   }
 
-
   _generateDerivedLoader(typeName: string): any {
     // <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"))
+    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, `
+    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}[]`, `
+    klass.addMethod(
+      tsCodegen.method(
+        'load',
+        [],
+        `${typeName}[]`,
+        `
   let value = store.loadRelated(this._entity, this._id, this._field);
   return changetype<${typeName}[]>(value);
-  `))
+  `,
+      ),
+    );
 
     return klass;
   }
-  
-_getTypeNameForField(gqlType: TypeNode): string {
 
-  if (gqlType.kind === 'NonNullType') {
-    return this._getTypeNameForField(gqlType.type);
-  } if (gqlType.kind === 'ListType') {
-    return this._getTypeNameForField(gqlType.type);
-  } if (gqlType.kind === 'NamedType') {
-    return (gqlType as NamedTypeNode).name.value;
-  }
+  _getTypeNameForField(gqlType: TypeNode): string {
+    if (gqlType.kind === 'NonNullType') {
+      return this._getTypeNameForField(gqlType.type);
+    }
+    if (gqlType.kind === 'ListType') {
+      return this._getTypeNameForField(gqlType.type);
+    }
+    if (gqlType.kind === 'NamedType') {
+      return (gqlType as NamedTypeNode).name.value;
+    }
 
-  throw new Error(`Unknown type kind: ${gqlType}`);
-}
+    throw new Error(`Unknown type kind: ${gqlType}`);
+  }
   _generateConstructor(_entityName: string, fields: readonly FieldDefinitionNode[] | undefined) {
     const idField = IdField.fromFields(fields);
     return tsCodegen.method(
@@ -260,7 +279,6 @@ _getTypeNameForField(gqlType: TypeNode): string {
     );
   }
 
-
   _generateEntityFieldGetter(_entityDef: ObjectTypeDefinitionNode, fieldDef: FieldDefinitionNode) {
     const name = fieldDef.name.value;
     const gqlType = fieldDef.type;
@@ -299,28 +317,24 @@ _getTypeNameForField(gqlType: TypeNode): string {
     let entityName = entityDef.name.value;
     let name = fieldDef.name.value;
     let gqlType = fieldDef.type;
-    let returnType = this._returnTypeForDervied(gqlType)
+    let returnType = this._returnTypeForDervied(gqlType);
     return tsCodegen.method(
       `get ${name}`,
       [],
       returnType,
       `
         return new ${returnType}('${entityName}', this.get('id')!.toString(), '${name}')
       `,
-    )
+    );
   }
 
-
   _returnTypeForDervied(gqlType: any): any {
     if (gqlType.kind === 'NonNullType') {
-      return this._returnTypeForDervied(gqlType.type)
+      return this._returnTypeForDervied(gqlType.type);
     } else if (gqlType.kind === 'ListType') {
-      return this._returnTypeForDervied(gqlType.type)
+      return this._returnTypeForDervied(gqlType.type);
     } else {
-
-      const type = tsCodegen.namedType(
-        gqlType.name.value + 'Loader'
-      );
+      const type = tsCodegen.namedType(gqlType.name.value + 'Loader');
       return type;
     }
   }
@@ -457,4 +471,3 @@ Suggestion: add an '!' to the member type of the List, change from '[${baseType}
     return nullable && !type.isPrimitive() ? tsCodegen.nullableType(type) : type;
   }
 }
-