feat: add option to automatically add schema and document files referenced in the codegen config to the vite file watcher

resolves #37

Author: danielwaltz

README.md

@@ -58,6 +58,13 @@ codegen({
    * @default true
    */
   enableWatcher: boolean,
+  /**
+   * Automatically add schemas and documents referenced in the codegen config
+   * to the file watcher.
+   *
+   * @default true
+   */
+  watchCodegenConfigFiles: boolean,
   /**
    * Throw an error if codegen fails on server start.
    *

src/index.ts

@@ -30,6 +30,13 @@ export interface Options {
    * @default true
    */
   enableWatcher?: boolean;
+  /**
+   * Automatically add schemas and documents referenced in the codegen config
+   * to the Vite file watcher.
+   *
+   * @default true
+   */
+  watchCodegenConfigFiles?: boolean;
   /**
    * Throw an error if codegen fails on server start.
    *
@@ -98,6 +105,7 @@ export function GraphQLCodegen(options?: Options): Plugin {
     runOnStart = true,
     runOnBuild = true,
     enableWatcher = true,
+    watchCodegenConfigFiles = true,
     throwOnStart = false,
     throwOnBuild = true,
     matchOnDocuments = true,
@@ -135,7 +143,7 @@ export function GraphQLCodegen(options?: Options): Plugin {
 
   return {
     name: "graphql-codegen",
-    async config(_config, env) {
+    async config(_userConfig, env) {
       try {
         if (config) {
           log("Manual config passed, creating codegen context");
@@ -219,6 +227,11 @@ export function GraphQLCodegen(options?: Options): Plugin {
         try {
           log("Match cache initialing");
           await matchCache.init();
+
+          if (watchCodegenConfigFiles) {
+            log("Adding codegen config files to watcher", matchCache.entries());
+            server.watcher.add(matchCache.entries());
+          }
           log("Match cache initialized");
         } catch (error) {
           log("Match cache initialization failed", error);

src/utils/matchCache.ts

@@ -29,5 +29,6 @@ export function createMatchCache(
     init: refresh,
     refresh,
     has: (filePath: string) => cache.has(normalizePath(filePath)),
+    entries: () => Array.from(cache),
   };
 }

test/watch-outside-cwd/__snapshots__/watch-outside-cwd.spec.ts.snap

@@ -0,0 +1,31 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`watch-outside-cwd > generates on schema change outside of cwd 1`] = `
+"export type Maybe<T> = T | null;
+export type InputMaybe<T> = Maybe<T>;
+export type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] };
+export type MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?: Maybe<T[SubKey]> };
+export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]: Maybe<T[SubKey]> };
+export type MakeEmpty<T extends { [key: string]: unknown }, K extends keyof T> = { [_ in K]?: never };
+export type Incremental<T> = T | { [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never };
+/** All built-in and custom scalars, mapped to their actual values */
+export type Scalars = {
+  ID: { input: string; output: string; }
+  String: { input: string; output: string; }
+  Boolean: { input: boolean; output: boolean; }
+  Int: { input: number; output: number; }
+  Float: { input: number; output: number; }
+};
+
+export type Query = {
+  __typename?: 'Query';
+  bar?: Maybe<Scalars['Int']['output']>;
+  foo?: Maybe<Scalars['String']['output']>;
+};
+
+export type FooQueryVariables = Exact<{ [key: string]: never; }>;
+
+
+export type FooQuery = { __typename?: 'Query', foo?: string | null };
+"
+`;

test/watch-outside-cwd/vite-root/codegen.yml

@@ -0,0 +1,7 @@
+schema: ./test/watch-outside-cwd/schema.graphql
+documents: ./test/watch-outside-cwd/vite-root/graphql/**/*.graphql
+generates:
+  ./test/watch-outside-cwd/vite-root/generated/graphql.ts:
+    plugins:
+      - typescript
+      - typescript-operations

test/watch-outside-cwd/watch-outside-cwd.spec.ts

@@ -0,0 +1,77 @@
+import { promises as fs } from "node:fs";
+import { join } from "node:path";
+import { createServer, type UserConfig, type ViteDevServer } from "vite";
+import { afterAll, afterEach, beforeAll, describe, expect, it } from "vitest";
+import codegen from "../../src/index";
+
+const TEST_PATH = "./test/watch-outside-cwd" as const;
+const SCHEMA_PATH = `${TEST_PATH}/schema.graphql` as const;
+const DOCUMENT_PATH = `${TEST_PATH}/vite-root/graphql` as const;
+const OUTPUT_PATH = `${TEST_PATH}/vite-root/generated` as const;
+const OUTPUT_FILE_NAME = "graphql.ts" as const;
+const OUTPUT_FILE = `${OUTPUT_PATH}/${OUTPUT_FILE_NAME}` as const;
+
+const viteConfig = {
+  root: join(import.meta.dirname, "./vite-root"),
+  plugins: [
+    codegen({
+      runOnStart: false,
+      matchOnDocuments: false,
+      matchOnSchemas: true,
+      watchCodegenConfigFiles: true,
+      configFilePathOverride: `${TEST_PATH}/vite-root/codegen.yml`,
+    }),
+  ],
+} satisfies UserConfig;
+
+describe("watch-outside-cwd", () => {
+  let viteServer: ViteDevServer | null = null;
+
+  const isFileGenerated = async (): Promise<boolean> => {
+    try {
+      await new Promise((resolve) => setTimeout(resolve, 200));
+      await fs.access(OUTPUT_FILE);
+      return true;
+    } catch {
+      // ignore
+    }
+
+    return new Promise((resolve, reject) => {
+      if (!viteServer) reject("Vite server not started");
+
+      viteServer?.watcher.on("add", (path: string) => {
+        if (path.includes(OUTPUT_FILE_NAME)) resolve(true);
+      });
+
+      setTimeout(() => reject("Generated file not found"), 5000);
+    });
+  };
+
+  beforeAll(async () => {
+    await fs.writeFile(SCHEMA_PATH, "type Query { foo: String }");
+    await fs.mkdir(DOCUMENT_PATH, { recursive: true });
+    await fs.writeFile(`${DOCUMENT_PATH}/Foo.graphql`, "query Foo { foo }");
+    viteServer = await createServer(viteConfig).then((s) => s.listen());
+  });
+
+  afterAll(async () => {
+    await viteServer?.close();
+    viteServer = null;
+    await fs.rm(SCHEMA_PATH, { recursive: true });
+    await fs.rm(DOCUMENT_PATH, { recursive: true });
+  });
+
+  afterEach(async () => {
+    await fs.rm(OUTPUT_PATH, { recursive: true });
+  });
+
+  it("generates on schema change outside of cwd", async () => {
+    await fs.writeFile(SCHEMA_PATH, "type Query { foo: String bar: Int }");
+
+    await isFileGenerated();
+
+    const file = await fs.readFile(OUTPUT_FILE, "utf-8");
+
+    expect(file).toMatchSnapshot();
+  });
+});