Add eslint

Author: rubengrill

.eslintrc

@@ -0,0 +1,15 @@
+{
+  "parser": "@typescript-eslint/parser",
+  "parserOptions": {
+    "sourceType": "module"
+  },
+  "extends": [
+    "eslint:recommended",
+    "plugin:@typescript-eslint/eslint-recommended",
+    "plugin:@typescript-eslint/recommended",
+    "plugin:prettier/recommended"
+  ],
+  "rules": {
+    "@typescript-eslint/explicit-function-return-type": "off"
+  }
+}

package.json

@@ -20,10 +20,12 @@
     "lib"
   ],
   "scripts": {
-    "build": "tsc",
-    "prepare": "yarn run build",
+    "build": "rimraf lib && tsc",
+    "preversion": "yarn test",
+    "version": "yarn run build",
     "postversion": "git push && git push --tags",
-    "test": "jest"
+    "test": "jest",
+    "lint": "eslint --ext .ts src/"
   },
   "peerDependencies": {
     "graphql": "^14.6.0",
@@ -38,13 +40,19 @@
     "@types/node": "^13.11.1",
     "@types/react": "^16.9.34",
     "@types/tmp": "^0.1.0",
+    "@typescript-eslint/eslint-plugin": "^2.28.0",
+    "@typescript-eslint/parser": "^2.28.0",
     "apollo-boost": "^0.4.7",
+    "eslint": "^6.8.0",
+    "eslint-config-prettier": "^6.10.1",
+    "eslint-plugin-prettier": "^3.1.3",
     "graphql": "^14.6.0",
     "import-sort-style-module": "^6.0.0",
     "jest": "^25.3.0",
     "pascal-case": "^3.1.1",
     "prettier": "^2.0.4",
     "prettier-plugin-import-sort": "^0.0.4",
+    "rimraf": "^3.0.2",
     "tmp": "^0.1.0",
     "ts-jest": "^25.3.1",
     "typescript": "^3.8.3"

src/codegenApolloMock.test.ts

@@ -12,6 +12,7 @@ expect.addSnapshotSerializer({
   test(value) {
     return !!(value?.request && value?.result);
   },
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   print(value: any) {
     const {
       request: { variables },
@@ -88,6 +89,7 @@ const getApolloMock = (output: string) => {
 
   fs.writeFileSync(tempFile.name, output);
 
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
   const module = require(tempFile.name);
 
   return module.default;

src/codegenApolloMock.ts

@@ -5,7 +5,13 @@ import MockVisitor from "./visitors/MockVisitor";
 import TypedVisitor from "./visitors/TypedVisitor";
 
 export const plugin: PluginFunction = (schema, documents) => {
-  const documentNodes = documents.map((document) => document.document!);
+  const documentNodes = documents.map((document) => {
+    if (!document.document) {
+      throw new Error("Missing document node");
+    }
+    return document.document;
+  });
+
   const output: string[] = [];
   const inputObjectTypeOutput: string[] = [];
   const mockVisitor = new MockVisitor(output, inputObjectTypeOutput);

src/codegenTypedDocuments.ts

@@ -15,14 +15,21 @@ export const plugin: PluginFunction<Config> = (schema, documents, config) => {
   const output: string[] = [];
 
   documents.forEach((document) => {
-    const basename = path.basename(document.location!);
+    if (!document.location) {
+      throw new Error("Missing document location");
+    }
+    if (!document.document) {
+      throw new Error("Missing document node");
+    }
+
+    const basename = path.basename(document.location);
     const typedVisitor = new TypedVisitor(schema);
     const typedDocumentVisitor = new TypedDocumentVisitor(
       output,
       basename,
       config
     );
-    const typedDocumentNode = visit(document.document!, typedVisitor);
+    const typedDocumentNode = visit(document.document, typedVisitor);
 
     visit(typedDocumentNode, typedDocumentVisitor);
   });

src/createApolloMock.ts

@@ -27,6 +27,7 @@ export type ApolloMockFn = <TVariables extends OperationVariables, TData>(
   options?: ApolloMockOptions
 ) => ApolloMock<TVariables, TData>;
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export default (operations: any): ApolloMockFn => <
   TVariables extends OperationVariables,
   TData
@@ -38,7 +39,12 @@ export default (operations: any): ApolloMockFn => <
 ): ApolloMock<TVariables, TData> => {
   const definitionNode = documentNode.definitions[0];
   const operationNode = definitionNode as OperationDefinitionNode;
-  const operationName = operationNode.name!.value;
+
+  if (!operationNode.name) {
+    throw new Error("Missing operation name");
+  }
+
+  const operationName = operationNode.name.value;
   const operation = operations[operationName];
 
   if (!operation) {

src/types.ts

@@ -1,7 +1,8 @@
 import { DocumentNode } from "graphql";
 
-export type OperationVariables = Record<string, any>;
+export type OperationVariables = Record<string, unknown>;
 
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
 export interface TypedDocumentNode<
   TVariables extends OperationVariables,
   TData

src/visitors/MockVisitor.ts

@@ -19,7 +19,11 @@ export default class MockVisitor {
   get OperationDefinition() {
     return {
       leave: (node: OperationDefinitionNode) => {
-        const name = node.name!.value;
+        if (!node.name) {
+          throw new Error("Operation doesn't have a name");
+        }
+
+        const name = node.name.value;
         const output: string[] = [];
 
         output.push(`operations.${name} = {};\n`);
@@ -53,8 +57,8 @@ export default class MockVisitor {
   }
 
   getTypedFieldSetOutput(
-    fields: TypedField<any>[],
-    parent?: TypedField<any>,
+    fields: TypedField[],
+    parent?: TypedField,
     { indent = 0, input = false } = {}
   ) {
     const output: string[] = [];
@@ -84,8 +88,8 @@ export default class MockVisitor {
         .join(",\n")
     );
 
-    if (parent && !input) {
-      const typename = parent.objectType!.name;
+    if (parent && parent.objectType && !input) {
+      const typename = parent.objectType.name;
 
       output.push(",\n");
       output.push(" ".repeat(indent + 2));
@@ -106,8 +110,12 @@ export default class MockVisitor {
     return output.join("");
   }
 
-  getTypedInputFieldSetOutput(field: TypedField<any>) {
-    const inputObjectTypeName = field.objectType!.name;
+  getTypedInputFieldSetOutput(field: TypedField) {
+    if (!field.objectType) {
+      throw new Error("Method must only be used for object type fields");
+    }
+
+    const inputObjectTypeName = field.objectType.name;
 
     if (!this.inputObjectTypeOutputState[inputObjectTypeName]) {
       const output: string[] = [];
@@ -125,10 +133,7 @@ export default class MockVisitor {
     return inputObjectTypeName;
   }
 
-  getTypedFieldOutput(
-    field: TypedField<any>,
-    { indent = 0, input = false } = {}
-  ) {
+  getTypedFieldOutput(field: TypedField, { indent = 0, input = false } = {}) {
     const name = field.name;
     const output: string[] = [];
 

src/visitors/TypedDocumentVisitor.ts

@@ -1,16 +1,15 @@
-import { DocumentNode, OperationDefinitionNode } from "graphql";
+import { OperationDefinitionNode } from "graphql";
 import { pascalCase } from "pascal-case";
 
-export type Config = { typesModule: string };
-
-interface OutputNode {
-  output: string;
+export interface Config {
+  typesModule: string;
 }
 
 export default class TypedDocumentVisitor {
   output: string[];
   basename: string;
   config: Config;
+  operationOutput: { [operationName: string]: string } = {};
 
   constructor(output: string[], basename: string, config: Config) {
     this.output = output;
@@ -20,52 +19,53 @@ export default class TypedDocumentVisitor {
 
   get Document() {
     return {
-      leave: (node: DocumentNode) => {
+      leave: () => {
         const output: string[] = [];
+        const operationOutputKeys = Object.keys(this.operationOutput);
+        const operationOutputValues = Object.values(this.operationOutput);
 
-        output.push(`declare module "*/${this.basename}" {`);
-        output.push(
-          node.definitions
-            .map(
-              (definitionNode) => ((definitionNode as any) as OutputNode).output
-            )
-            .join("\n")
-        );
+        output.push(`declare module "*/${this.basename}" {\n`);
+
+        operationOutputValues.forEach((operationOutput) => {
+          output.push(operationOutput);
+          output.push("\n");
+        });
 
-        if (node.definitions.length === 1) {
-          const definitionNode = node.definitions[0];
-          const operationNode = definitionNode as OperationDefinitionNode;
-          output.push(`  export default ${operationNode.name!.value}`);
+        if (operationOutputKeys.length === 1) {
+          const [operationName] = operationOutputKeys;
+          output.push(`  export default ${operationName}\n`);
         }
 
         output.push(`}`);
 
-        this.output.push(output.join("\n"));
+        this.output.push(output.join(""));
       },
     };
   }
 
   get OperationDefinition() {
     return {
-      enter: (_node: OperationDefinitionNode) => {
-        const node = _node as OperationDefinitionNode & OutputNode;
-        const output: string[] = [];
-        const typeName = pascalCase(node.name!.value);
+      enter: (node: OperationDefinitionNode) => {
+        if (!node.name) {
+          throw new Error("Operation must have a name");
+        }
+
+        const operationName = node.name.value;
+        const typeName = pascalCase(operationName);
         const typeNameSuffix = pascalCase(node.operation);
+        const output: string[] = [];
 
         output.push(
-          '  import { TypedDocumentNode } from "apollo-typed-documents"'
+          '  import { TypedDocumentNode } from "apollo-typed-documents"\n'
         );
         output.push(
-          `  import {${typeName}${typeNameSuffix}, ${typeName}${typeNameSuffix}Variables} from "${this.config.typesModule}"`
+          `  import { ${typeName}${typeNameSuffix}, ${typeName}${typeNameSuffix}Variables } from "${this.config.typesModule}"\n`
         );
         output.push(
-          `  export const ${
-            node.name!.value
-          }: TypedDocumentNode<${typeName}${typeNameSuffix}Variables, ${typeName}${typeNameSuffix}>`
+          `  export const ${operationName}: TypedDocumentNode<${typeName}${typeNameSuffix}Variables, ${typeName}${typeNameSuffix}>`
         );
 
-        node.output = output.join("\n");
+        this.operationOutput[operationName] = output.join("");
 
         return false; // No need to traverse deeper
       },