feat: add support for input types

rfermann · Apr 17, 2021 · 050472d · 050472d
1 parent e365523
commit 050472d
Show file tree

Hide file tree

Showing 12 changed files with 3,613 additions and 64 deletions.
diff --git a/README.md b/README.md
@@ -45,18 +45,13 @@ generator nestjs {
 
 ## Currently supported objects
 
-- [Enums](#Enums)
-- [Models](#Models)
+- Enums
+- Models
+- Input Types
 
 ## Usage
 
-### Enums
-
-Enums can be used like regular [NestJS GraphQL Enums](https://docs.nestjs.com/graphql/unions-and-enums#enums)
-
-### Models
-
-Models are generated as usual NestJS GraphQL Object Types and can be used as any other Object Types.
+All supported objects can be used as the regular NestJS GraphQL object equivalents.
 
 ## Contributing to NestJS-Prisma-GraphQL-Generator
 

diff --git a/src/Generator/index.test.ts b/src/Generator/index.test.ts
@@ -78,10 +78,10 @@ describe("Generator", () => {
       return 0;
     });
 
-    expect([...folderList]).toStrictEqual(["enums", "Session", "User"]);
+    expect([...folderList]).toStrictEqual(["enums", "Session", "shared", "User"]);
   });
   it("should log the correct actions", async () => {
-    expect.assertions(17);
+    expect.assertions(23);
 
     const generator = new Generator({
       datamodel: "",
@@ -130,5 +130,12 @@ describe("Generator", () => {
     expect(findCompletedMessage(values, Generator.messages.models.parse)).toHaveLength(1);
     expect(findStartedMessage(values, Generator.messages.models.generate)).toHaveLength(1);
     expect(findCompletedMessage(values, Generator.messages.models.generate)).toHaveLength(1);
+
+    expect(findStartedMessage(values, Generator.messages.inputTypes.title)).toHaveLength(1);
+    expect(findCompletedMessage(values, Generator.messages.inputTypes.title)).toHaveLength(1);
+    expect(findStartedMessage(values, Generator.messages.inputTypes.parse)).toHaveLength(1);
+    expect(findCompletedMessage(values, Generator.messages.inputTypes.parse)).toHaveLength(1);
+    expect(findStartedMessage(values, Generator.messages.inputTypes.generate)).toHaveLength(1);
+    expect(findCompletedMessage(values, Generator.messages.inputTypes.generate)).toHaveLength(1);
   });
 });
diff --git a/src/Generator/index.ts b/src/Generator/index.ts
@@ -6,6 +6,7 @@ import Listr from "listr";
 
 import { GeneratorConfig } from "../GeneratorConfig";
 import { EnumHandler } from "../Handlers/EnumHandler";
+import { InputTypeHandler } from "../Handlers/InputTypeHandler";
 import { ModelHandler } from "../Handlers/ModelHandler";
 import { importDmmf } from "../helpers";
 
@@ -17,9 +18,14 @@ export class Generator {
       title: "Parsing and generating Enums",
     },
     init: "Initialize generator",
+    inputTypes: {
+      generate: "Generating Input Types",
+      parse: "Parsing Input Types",
+      title: "Parsing and generating Input Types",
+    },
     models: {
       generate: "Generating Models",
-      parse: "Parsing Arguments, Models and Object Types",
+      parse: "Parsing Models",
       title: "Parsing and generating Models",
     },
     objects: "Processing Models, Object Types and Resolvers",
@@ -32,6 +38,8 @@ export class Generator {
 
   private _enumHandler!: EnumHandler;
 
+  private _inputTypeHandler!: InputTypeHandler;
+
   private _modelHandler!: ModelHandler;
 
   constructor({ generator, otherGenerators }: GeneratorOptions) {
@@ -47,6 +55,7 @@ export class Generator {
           title: Generator.messages.init,
         },
         {
+          // eslint-disable-next-line max-lines-per-function
           task: () =>
             new Listr(
               [
@@ -87,6 +96,22 @@ export class Generator {
                             ]),
                           title: Generator.messages.models.title,
                         },
+                        {
+                          task: async () =>
+                            new Listr([
+                              {
+                                task: () => this._inputTypeHandler.parse(this._enumHandler.getEnums()),
+                                title: Generator.messages.inputTypes.parse,
+                              },
+                              {
+                                task: async () => {
+                                  await this._inputTypeHandler.createFiles();
+                                },
+                                title: Generator.messages.inputTypes.generate,
+                              },
+                            ]),
+                          title: Generator.messages.inputTypes.title,
+                        },
                       ],
                       { concurrent: true }
                     ),
@@ -113,6 +138,7 @@ export class Generator {
 
     this._enumHandler = new EnumHandler({ config: this._config, dmmf: this._dmmf });
     this._modelHandler = new ModelHandler({ config: this._config, dmmf: this._dmmf });
+    this._inputTypeHandler = new InputTypeHandler({ config: this._config, dmmf: this._dmmf });
 
     await this._initOutputFolder();
   }

diff --git a/src/GeneratorConfig/index.ts b/src/GeneratorConfig/index.ts
@@ -2,7 +2,9 @@ import type { GeneratorConfig as PrismaGeneratorConfig } from "@prisma/generator
 
 interface Paths {
   enums: string;
+  inputTypes: string;
   model: string;
+  shared: string;
 }
 
 interface GeneratorOptions {
@@ -31,7 +33,9 @@ export class GeneratorConfig {
     this.basePath = output.value;
     this.paths = {
       enums: "enums",
+      inputTypes: "inputTypes",
       model: "model",
+      shared: "shared",
     };
     this.prismaClientImportPath = prismaClientPath.output.value;
   }

diff --git a/src/Handlers/BaseHandler/BaseFileGenerator/index.ts b/src/Handlers/BaseHandler/BaseFileGenerator/index.ts
@@ -4,6 +4,7 @@ import { IndentationText, NewLineKind, Project, StructureKind } from "ts-morph";
 import type { GeneratorConfig } from "../../../GeneratorConfig";
 import type { Field, ObjectTypes } from "../../../types";
 import { NestJSTypes, TypeEnum } from "../../../types";
+import type { BaseParser } from "../BaseParser";
 import { comparePrimitiveValues } from "../compareFunctions";
 
 interface NestJSImportOptions {
@@ -12,11 +13,14 @@ interface NestJSImportOptions {
 }
 
 export class BaseFileGenerator {
+  private readonly _baseParser: BaseParser;
+
   private readonly _config: GeneratorConfig;
 
   private readonly _project: Project;
 
-  constructor(config: GeneratorConfig) {
+  constructor(baseParser: BaseParser, config: GeneratorConfig) {
+    this._baseParser = baseParser;
     this._config = config;
     this._project = new Project({
       compilerOptions: {
@@ -33,6 +37,10 @@ export class BaseFileGenerator {
   addEnumImports({ enums, sourceFile, type }: { enums: string[]; sourceFile: SourceFile; type: TypeEnum }): void {
     let moduleSpecifier = "";
 
+    if (type === TypeEnum.InputType) {
+      moduleSpecifier = `../../${this._config.paths.enums}`;
+    }
+
     if (type === TypeEnum.ModelType) {
       moduleSpecifier = `../${this._config.paths.enums}`;
     }
@@ -51,6 +59,42 @@ export class BaseFileGenerator {
     });
   }
 
+  addInputTypeImports({
+    inputTypes,
+    model,
+    sourceFile,
+  }: {
+    inputTypes: string[];
+    model?: string;
+    sourceFile: SourceFile;
+  }): void {
+    inputTypes.forEach((inputType) => {
+      let moduleSpecifier = "";
+      const currentModel = this._baseParser.getModelName(inputType);
+
+      if (model && model === currentModel) {
+        moduleSpecifier = `.`;
+      }
+
+      if (model && currentModel && model !== currentModel) {
+        moduleSpecifier = `../../${currentModel}/${this._config.paths.inputTypes}`;
+      }
+
+      if (!model && !currentModel) {
+        moduleSpecifier = `.`;
+      }
+
+      if (model && !currentModel) {
+        moduleSpecifier = `../../${this._config.paths.shared}/${this._config.paths.inputTypes}`;
+      }
+
+      sourceFile.addImportDeclaration({
+        moduleSpecifier: `${moduleSpecifier}/${inputType}`,
+        namedImports: [inputType],
+      });
+    });
+  }
+
   // eslint-disable-next-line class-methods-use-this
   addJsonImports({ imports, sourceFile }: { imports: string[]; sourceFile: SourceFile }): void {
     sourceFile.addImportDeclaration({

diff --git a/src/Handlers/BaseHandler/BaseParser/index.ts b/src/Handlers/BaseHandler/BaseParser/index.ts
@@ -30,8 +30,12 @@ export class BaseParser {
 
   readonly graphqlScalarImports = new Set(["Byte"]);
 
+  readonly inputTypeList: Set<string> = new Set();
+
   readonly jsonImports = new Set(["InputJsonValue", "JsonValue"]);
 
+  readonly modelsList: string[];
+
   readonly nestJSImports = new Set([
     NestJSTypes.Float as string,
     NestJSTypes.GraphQLISODateTime as string,
@@ -42,6 +46,11 @@ export class BaseParser {
 
   constructor(dmmf: DMMF.Document) {
     this.dmmf = dmmf;
+
+    this.dmmf.schema.inputObjectTypes.prisma.forEach(({ name }) => {
+      this.inputTypeList.add(name);
+    });
+    this.modelsList = this.dmmf.datamodel.models.map(({ name }) => name);
   }
 
   getEnumImports({
@@ -84,20 +93,61 @@ export class BaseParser {
     return graphqlScalarImports;
   }
 
+  // eslint-disable-next-line class-methods-use-this
+  getInputType(inputTypes: DMMF.SchemaArgInputType[]): TSField {
+    if (inputTypes.length === 0) {
+      /* istanbul ignore next */
+      throw new Error("No input types available. Extracting GraphQL Type not possible");
+    }
+
+    const isList = inputTypes.find((inputType) => inputType.isList)?.isList ?? false;
+
+    let inputTypeObject = inputTypes.find(
+      (it) => it.location === "inputObjectTypes" || it.location === "outputObjectTypes"
+    );
+
+    if (typeof inputTypeObject === "undefined") {
+      inputTypeObject = inputTypes.find((it) => it.location === "enumTypes");
+    }
+
+    if (typeof inputTypeObject === "undefined") {
+      inputTypeObject = inputTypes.find((it) => it.location === "scalar");
+    }
+
+    if (typeof inputTypeObject === "undefined") {
+      /* istanbul ignore next */
+      throw new Error("Couldn't parse input type");
+    }
+
+    return {
+      isList,
+      location: inputTypeObject.location,
+      type: inputTypeObject.type as string,
+    };
+  }
+
   getJsonImports({
     field: { location, type },
     jsonImports,
     tsType,
   }: {
     field: {
       location: DMMF.FieldLocation;
-      type: string;
+      type: DMMF.ArgType;
     };
     jsonImports: Set<string>;
     tsType: string;
   }): Set<string> {
-    if (location === "scalar" && this.jsonImports.has(type)) {
-      jsonImports.add(type);
+    let stringType = "";
+
+    if (typeof type === "string") {
+      stringType = type;
+    } else {
+      stringType = type.name;
+    }
+
+    if (location === "scalar" && this.jsonImports.has(stringType)) {
+      jsonImports.add(stringType);
     }
 
     if (this.jsonImports.has(tsType.split(" | ")[0])) {
@@ -107,19 +157,17 @@ export class BaseParser {
     return jsonImports;
   }
 
-  // eslint-disable-next-line class-methods-use-this
-  getModelImports({
-    field: { kind, type },
-    modelImports,
-  }: {
-    field: DMMF.Field;
-    modelImports: Set<string>;
-  }): Set<string> {
-    if (kind === "object") {
-      modelImports.add(type);
-    }
+  getModelName(input: string): string | undefined {
+    // eslint-disable-next-line @typescript-eslint/init-declarations
+    let modelName: ReturnType<BaseParser["getModelName"]>;
 
-    return modelImports;
+    this.modelsList.forEach((model) => {
+      if (input.startsWith(model)) {
+        modelName = model;
+      }
+    });
+
+    return modelName;
   }
 
   parseField({
@@ -155,7 +203,7 @@ export class BaseParser {
 
   parseGraphQLType(inputTypes: DMMF.SchemaArgInputType[]): string {
     let inputType = "";
-    const inputTypeObject = this._selectInputType(inputTypes);
+    const inputTypeObject = this.getInputType(inputTypes);
     const { isList, location, type } = inputTypeObject;
 
     if (location === "enumTypes") {
@@ -275,35 +323,4 @@ export class BaseParser {
 
     return fieldType;
   }
-
-  // eslint-disable-next-line class-methods-use-this
-  private _selectInputType(inputTypes: DMMF.SchemaArgInputType[]): TSField {
-    if (inputTypes.length === 0) {
-      throw new Error("No input types available. Extracting GraphQL Type not possible");
-    }
-
-    const isList = inputTypes.find((inputType) => inputType.isList)?.isList ?? false;
-
-    let inputTypeObject = inputTypes.find(
-      (it) => it.location === "inputObjectTypes" || it.location === "outputObjectTypes"
-    );
-
-    if (typeof inputTypeObject === "undefined") {
-      inputTypeObject = inputTypes.find((it) => it.location === "enumTypes");
-    }
-
-    if (typeof inputTypeObject === "undefined") {
-      inputTypeObject = inputTypes.find((it) => it.location === "scalar");
-    }
-
-    if (typeof inputTypeObject === "undefined") {
-      throw new Error("Couldn't parse input type");
-    }
-
-    return {
-      isList,
-      location: inputTypeObject.location,
-      type: inputTypeObject.type as string,
-    };
-  }
 }
diff --git a/src/Handlers/BaseHandler/index.ts b/src/Handlers/BaseHandler/index.ts
@@ -20,6 +20,6 @@ export abstract class BaseHandler {
   constructor({ config, dmmf }: HandlerOptions) {
     this.config = config;
     this.baseParser = new BaseParser(dmmf);
-    this.baseFileGenerator = new BaseFileGenerator(config);
+    this.baseFileGenerator = new BaseFileGenerator(this.baseParser, config);
   }
 }