Merge pull request #285 from thefrontside/foundation-delay

foundation simulator delay response API

.changes/foundation-delay.md

@@ -0,0 +1,5 @@
+---
+"@simulacrum/foundation-simulator": minor:enhance
+---
+
+Add API to configure a delay of all responses with a set interval. Using this in a simulator would enable a feel closer to a real external endpoint.

packages/foundation/src/index.ts

@@ -32,6 +32,7 @@ import type {
   SimulationRoute,
 } from "./store/schema";
 import type { RecursivePartial } from "./store/types";
+import { delayMiddleware } from "./middleware/delay";
 import { generateRoutesHTML } from "./routeTemplate";
 
 type SimulationHandlerFunctions = (
@@ -57,12 +58,14 @@ export function createFoundationSimulationServer<
   ExtendedSimulationSelectors
 >({
   port = 9000,
+  delayResponses,
   serveJsonFiles,
   openapi,
   extendStore,
   extendRouter,
 }: {
   port: number;
+  delayResponses?: number | { minimum: number; maximum: number };
   serveJsonFiles?: string;
   openapi?: {
     document: Document | (Document | RecursivePartial<Document>)[];
@@ -102,6 +105,7 @@ export function createFoundationSimulationServer<
     app.use(express.json());
     app.use(express.urlencoded({ extended: false }));
     let simulationStore = createSimulationStore(extendStore);
+    app.use(delayMiddleware(delayResponses));
 
     app.use((req, res, next) => {
       // add each response to the internal log

packages/foundation/src/middleware/delay.ts

@@ -0,0 +1,53 @@
+import type { Request, Response, NextFunction } from "express";
+
+export function delayMiddleware(
+  delayResponses?: number | { minimum: number; maximum: number }
+) {
+  const delayMin =
+    typeof delayResponses === "number"
+      ? delayResponses
+      : delayResponses?.minimum;
+  const delayMax =
+    typeof delayResponses === "number" ? undefined : delayResponses?.maximum;
+
+  return async function delayHandler(
+    request: Request,
+    response: Response,
+    next: NextFunction
+  ) {
+    if (delayMin || delayMax) {
+      let timeoutDuration = calculateTimeoutDuration(delayMin, delayMax);
+      await new Promise<void>((resolve) => {
+        let timeoutHandle: NodeJS.Timeout | undefined = undefined;
+
+        const done = () => {
+          if (timeoutHandle) {
+            clearTimeout(timeoutHandle);
+          }
+          resolve();
+        };
+
+        timeoutHandle = setTimeout(done, timeoutDuration);
+      });
+    }
+    next();
+  };
+}
+
+function calculateTimeoutDuration(
+  min: number | undefined,
+  max: number | undefined
+): number {
+  if (max && !min) {
+    // sets the timeout at +/- 20% of configured max
+    return max * 0.8 + max * 0.4 * Math.random();
+  } else if (min && !max) {
+    // sets the timeout at +/- 20% of configured max
+    return min * 0.8 + min * 0.4 * Math.random();
+  } else if (max && min) {
+    const timeoutRange = max - min;
+    return min + timeoutRange * Math.random();
+  }
+
+  return 0;
+}