config: modulePathPrefix, relativeToCwd, prefix (rubengrill#13)

Author: dleavitt

README.md

@@ -54,6 +54,8 @@ generates:
 ```
 <!-- AUTO-GENERATED-CONTENT:END -->
 
+The `apollo-typed-documents` plugin also accepts the same `modulePathPrefix`, `relativeToCwd` and `prefix` config settings as [typescript-graphql-files-modules](https://graphql-code-generator.com/docs/plugins/typescript-graphql-files-modules).
+
 `tsconfig.json`:
 
 Add `node_modules/apollo-typed-documents/lib/reactHooks.d.ts` in `include` to override the typings for `@apollo/react-hooks`, so that types can be inferred from typed documents.

src/__tests__/codegenTypedDocuments.test.ts

@@ -138,4 +138,119 @@ describe("codegenTypedDocuments", () => {
       }"
     `);
   });
+
+  describe("module path customization", () => {
+    const queryDocument = parse(`
+      query authors {
+        authors {
+          idField
+        }
+      }
+    `);
+
+    const mutationDocument = parse(`
+      mutation createAuthor {
+        createAuthor {
+          idField
+        }
+      }
+    `);
+
+    const documents = [
+      { document: queryDocument, location: "literary/types/authors.gql" },
+      { document: mutationDocument, location: "mutations/createAuthor.gql" },
+    ];
+
+    const getPathConfig = (pluginConfig: Record<string, unknown>) => {
+      return getConfig({
+        documents,
+        plugins: [
+          {
+            codegenTypedDocuments: {
+              typesModule: "@codegen-types",
+              ...pluginConfig,
+            },
+          },
+        ],
+      });
+    };
+
+    it("wildcards the basename by default", async () => {
+      const config = getPathConfig({});
+      const output = await codegen(config);
+
+      expect(output).toMatchInlineSnapshot(`
+        "declare module \\"*/authors.gql\\" {
+          import { TypedDocumentNode } from \\"apollo-typed-documents\\";
+          import { AuthorsQuery, AuthorsQueryVariables } from \\"@codegen-types\\";
+          export const authors: TypedDocumentNode<AuthorsQueryVariables, AuthorsQuery>;
+          export default authors;
+        }
+
+        declare module \\"*/createAuthor.gql\\" {
+          import { TypedDocumentNode } from \\"apollo-typed-documents\\";
+          import { CreateAuthorMutation, CreateAuthorMutationVariables } from \\"@codegen-types\\";
+          export const createAuthor: TypedDocumentNode<CreateAuthorMutationVariables, CreateAuthorMutation>;
+          export default createAuthor;
+        }"
+      `);
+    });
+
+    it("respects the relativeToCwd setting", async () => {
+      const config = getPathConfig({ relativeToCwd: true });
+      const output = await codegen(config);
+
+      expect(output).toEqual(
+        expect.stringContaining(`declare module "*/literary/types/authors.gql"`)
+      );
+      expect(output).toEqual(
+        expect.stringContaining(`declare module "*/mutations/createAuthor.gql"`)
+      );
+    });
+
+    it("respects the prefix setting", async () => {
+      const config = getPathConfig({ prefix: "gql/" });
+      const output = await codegen(config);
+
+      expect(output).toEqual(
+        expect.stringContaining(`declare module "gql/authors.gql"`)
+      );
+      expect(output).toEqual(
+        expect.stringContaining(`declare module "gql/createAuthor.gql"`)
+      );
+    });
+
+    it("even respects the superfluous modulePathPrefix setting", async () => {
+      const config = getPathConfig({ modulePathPrefix: "stuff/" });
+      const output = await codegen(config);
+
+      expect(output).toEqual(
+        expect.stringContaining(`declare module "*/stuff/authors.gql"`)
+      );
+      expect(output).toEqual(
+        expect.stringContaining(`declare module "*/stuff/createAuthor.gql"`)
+      );
+    });
+
+    it("allows combining path settings", async () => {
+      const config = getPathConfig({
+        prefix: "",
+        modulePathPrefix: "defs/",
+        relativeToCwd: true,
+      });
+
+      const output = await codegen(config);
+
+      expect(output).toEqual(
+        expect.stringContaining(
+          `declare module "defs/literary/types/authors.gql"`
+        )
+      );
+      expect(output).toEqual(
+        expect.stringContaining(
+          `declare module "defs/mutations/createAuthor.gql"`
+        )
+      );
+    });
+  });
 });

src/codegenTypedDocuments.ts

@@ -1,5 +1,3 @@
-import path from "path";
-
 import {
   PluginFunction,
   PluginValidateFn,
@@ -8,9 +6,44 @@ import { visit } from "graphql";
 
 import TypedDocumentVisitor from "./visitors/TypedDocumentVisitor";
 
-export type Config = { typesModule: string };
+export type UserConfig = {
+  typesModule: string;
+
+  /**
+   * @default ""
+   * @description Allows specifying a module definition path prefix to provide
+   * distinction between generated types.
+   */
+  modulePathPrefix?: string;
+
+  /**
+   * @default false
+   * @description By default, only the filename is being used to generate TS
+   * module declarations. Setting this to `true` will generate it with a full
+   * path based on the CWD.
+   */
+  relativeToCwd?: boolean;
+
+  /**
+   * @default *\/
+   * @description By default, a wildcard is being added as prefix, you can
+   * change that to a custom prefix.
+   */
+  prefix?: string;
+};
+
+export const plugin: PluginFunction<UserConfig> = (
+  _schema,
+  documents,
+  { typesModule, modulePathPrefix = "", relativeToCwd, prefix = "*/" }
+) => {
+  const config = {
+    typesModule,
+    modulePathPrefix,
+    useRelative: relativeToCwd === true,
+    prefix,
+  };
 
-export const plugin: PluginFunction<Config> = (_schema, documents, config) => {
   const output: string[] = [];
 
   documents.forEach((document) => {
@@ -21,16 +54,15 @@ export const plugin: PluginFunction<Config> = (_schema, documents, config) => {
       throw new Error("Missing document node");
     }
 
-    const basename = path.basename(document.location);
-    const visitor = new TypedDocumentVisitor(output, basename, config);
+    const visitor = new TypedDocumentVisitor(output, document.location, config);
 
     visit(document.document, visitor);
   });
 
   return output.join("\n\n");
 };
 
-export const validate: PluginValidateFn<Config> = (
+export const validate: PluginValidateFn<UserConfig> = (
   _schema,
   _documents,
   config

src/visitors/TypedDocumentVisitor.ts

@@ -1,7 +1,14 @@
+import { basename, relative } from "path";
+
 import { DefinitionNode, DocumentNode, OperationDefinitionNode } from "graphql";
 import { pascalCase } from "pascal-case";
 
-export type Config = { typesModule: string };
+export type Config = {
+  typesModule: string;
+  modulePathPrefix: string;
+  useRelative: boolean;
+  prefix: string;
+};
 
 const isOperationDefinitionNode = (
   node: DefinitionNode
@@ -10,15 +17,21 @@ const isOperationDefinitionNode = (
 export default class TypedDocumentVisitor {
   constructor(
     readonly output: string[],
-    readonly basename: string,
+    readonly location: string,
     readonly config: Config
   ) {}
 
   Document = (node: DocumentNode) => {
     const operationNodes = node.definitions.filter(isOperationDefinitionNode);
     const output: string[] = [];
 
-    output.push(`declare module "*/${this.basename}" {\n`);
+    const filepath = this.config.useRelative
+      ? relative(process.cwd(), this.location)
+      : basename(this.location);
+
+    const modulePath = `${this.config.prefix}${this.config.modulePathPrefix}${filepath}`;
+
+    output.push(`declare module "${modulePath}" {\n`);
     output.push(
       '  import { TypedDocumentNode } from "apollo-typed-documents";\n'
     );