Move OpenAPI file watching into server/openapi-watcher.ts and load-openapi-document.ts

Agent-Logs-Url: https://github.com/counterfact/api-simulator/sessions/ec10975a-392f-4945-ab3c-cb4e22edf971

Author: Copilot

src/app.ts

@@ -1,29 +1,23 @@
 import fs, { rm } from "node:fs/promises";
 import nodePath from "node:path";
 
-import { dereference } from "@apidevtools/json-schema-ref-parser";
-import { type FSWatcher, watch as watchFile } from "chokidar";
-import createDebug from "debug";
 import { createHttpTerminator, type HttpTerminator } from "http-terminator";
 
 import { startRepl as startReplServer } from "./repl/repl.js";
 import type { Config } from "./server/config.js";
-import { CHOKIDAR_OPTIONS } from "./server/constants.js";
 import { ContextRegistry } from "./server/context-registry.js";
 import { createKoaApp } from "./server/create-koa-app.js";
-import {
-  Dispatcher,
-  type DispatcherRequest,
-  type OpenApiDocument,
-} from "./server/dispatcher.js";
+import { Dispatcher, type DispatcherRequest } from "./server/dispatcher.js";
 import { koaMiddleware } from "./server/koa-middleware.js";
+import { loadOpenApiDocument } from "./server/load-openapi-document.js";
 import { ModuleLoader } from "./server/module-loader.js";
+import { OpenApiWatcher } from "./server/openapi-watcher.js";
 import { Registry } from "./server/registry.js";
 import { Transpiler } from "./server/transpiler.js";
 import { CodeGenerator } from "./typescript-generator/code-generator.js";
 import { runtimeCanExecuteErasableTs } from "./util/runtime-can-execute-erasable-ts.js";
 
-const debug = createDebug("counterfact:app");
+export { loadOpenApiDocument } from "./server/load-openapi-document.js";
 
 type MswHandlerMap = {
   [key: string]: (request: MockRequest) => Promise<unknown>;
@@ -41,19 +35,6 @@ const allowedMethods = [
 
 export type MockRequest = DispatcherRequest & { rawPath: string };
 
-export async function loadOpenApiDocument(source: string) {
-  try {
-    return (await dereference(source)) as OpenApiDocument;
-  } catch (error) {
-    debug("could not load OpenAPI document from %s: %o", source, error);
-    const details = error instanceof Error ? error.message : String(error);
-    throw new Error(
-      `Could not load the OpenAPI spec from "${source}".\n${details}`,
-      { cause: error },
-    );
-  }
-}
-
 const mswHandlers: MswHandlerMap = {};
 
 export async function handleMswRequest(request: MockRequest) {
@@ -167,6 +148,8 @@ export async function counterfact(config: Config) {
 
   const koaApp = createKoaApp(registry, middleware, config, contextRegistry);
 
+  const openApiWatcher = new OpenApiWatcher(config.openApiPath, dispatcher);
+
   async function start(options: Config) {
     const { generate, startServer, watch, buildCache } = options;
 
@@ -179,35 +162,10 @@ export async function counterfact(config: Config) {
     }
 
     let httpTerminator: HttpTerminator | undefined;
-    let openApiWatcher: FSWatcher | undefined;
-
-    if (
-      startServer &&
-      config.openApiPath !== "_" &&
-      !config.openApiPath.startsWith("http")
-    ) {
-      openApiWatcher = watchFile(config.openApiPath, CHOKIDAR_OPTIONS).on(
-        "change",
-        () => {
-          void (async () => {
-            try {
-              dispatcher.openApiDocument = await loadOpenApiDocument(
-                config.openApiPath,
-              );
-              debug("reloaded OpenAPI document from %s", config.openApiPath);
-            } catch (error: unknown) {
-              debug(
-                "failed to reload OpenAPI document from %s: %o",
-                config.openApiPath,
-                error,
-              );
-            }
-          })();
-        },
-      );
-    }
 
     if (startServer) {
+      await openApiWatcher.watch();
+
       if (!nativeTs) {
         await transpiler.watch();
       }
@@ -232,7 +190,7 @@ export async function counterfact(config: Config) {
         await codeGenerator.stopWatching();
         await transpiler.stopWatching();
         await moduleLoader.stopWatching();
-        await openApiWatcher?.close();
+        await openApiWatcher.stopWatching();
         await httpTerminator?.terminate();
       },
     };

src/server/load-openapi-document.ts

@@ -0,0 +1,19 @@
+import { dereference } from "@apidevtools/json-schema-ref-parser";
+import createDebug from "debug";
+
+import type { OpenApiDocument } from "./dispatcher.js";
+
+const debug = createDebug("counterfact:server:load-openapi-document");
+
+export async function loadOpenApiDocument(source: string) {
+  try {
+    return (await dereference(source)) as OpenApiDocument;
+  } catch (error) {
+    debug("could not load OpenAPI document from %s: %o", source, error);
+    const details = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `Could not load the OpenAPI spec from "${source}".\n${details}`,
+      { cause: error },
+    );
+  }
+}

src/server/openapi-watcher.ts

@@ -0,0 +1,54 @@
+import { type FSWatcher, watch } from "chokidar";
+import createDebug from "debug";
+
+import { waitForEvent } from "../util/wait-for-event.js";
+import { CHOKIDAR_OPTIONS } from "./constants.js";
+import type { Dispatcher } from "./dispatcher.js";
+import { loadOpenApiDocument } from "./load-openapi-document.js";
+
+const debug = createDebug("counterfact:server:openapi-watcher");
+
+export class OpenApiWatcher {
+  private readonly openApiPath: string;
+
+  private readonly dispatcher: Dispatcher;
+
+  private watcher: FSWatcher | undefined;
+
+  public constructor(openApiPath: string, dispatcher: Dispatcher) {
+    this.openApiPath = openApiPath;
+    this.dispatcher = dispatcher;
+  }
+
+  public async watch(): Promise<void> {
+    if (this.openApiPath === "_" || this.openApiPath.startsWith("http")) {
+      return;
+    }
+
+    this.watcher = watch(this.openApiPath, CHOKIDAR_OPTIONS).on(
+      "change",
+      () => {
+        void (async () => {
+          try {
+            this.dispatcher.openApiDocument = await loadOpenApiDocument(
+              this.openApiPath,
+            );
+            debug("reloaded OpenAPI document from %s", this.openApiPath);
+          } catch (error: unknown) {
+            debug(
+              "failed to reload OpenAPI document from %s: %o",
+              this.openApiPath,
+              error,
+            );
+          }
+        })();
+      },
+    );
+
+    await waitForEvent(this.watcher, "ready");
+  }
+
+  public async stopWatching(): Promise<void> {
+    await this.watcher?.close();
+  }
+}