veryfront 0.1.73 → 0.1.74

package/src/src/server/runtime-handler/local-project-discovery.ts

@@ -17,24 +17,56 @@ const baseLogger = getBaseLogger("SERVER");
 
 const logger = baseLogger.component("runtime-handler");
 
-/** Cache of local adapters by project directory */
-export const localAdapterCache = new LRUCache<string, RuntimeAdapter>({
-  maxEntries: 50,
-});
+/**
+ * Injectable cache container for project discovery state.
+ *
+ * Wraps both the project-path cache (slug → absolute path) and the
+ * adapter cache (project dir → RuntimeAdapter) so that callers — especially
+ * tests — can supply an isolated instance instead of sharing global state.
+ */
+export class ProjectDiscoveryCache {
+  /** Cache of discovered local project paths by slug */
+  readonly projects: LRUCache<string, string>;
+  /** Cache of local adapters by project directory */
+  readonly adapters: LRUCache<string, RuntimeAdapter>;
+
+  constructor(opts?: { maxProjects?: number; maxAdapters?: number }) {
+    this.projects = new LRUCache<string, string>({
+      maxEntries: opts?.maxProjects ?? 100,
+    });
+    this.adapters = new LRUCache<string, RuntimeAdapter>({
+      maxEntries: opts?.maxAdapters ?? 50,
+    });
+  }
 
-// Register cache for monitoring
-registerLRUCache("local-adapter-cache", localAdapterCache);
+  /** Clear both caches */
+  clear(): void {
+    this.projects.clear();
+    this.adapters.clear();
+  }
+}
 
-/** Standard directories to search for local projects */
-export const standardProjectDirs = ["data/projects", "projects"];
+/** Default module-level cache instance (backward-compatible singleton) */
+export const defaultDiscoveryCache = new ProjectDiscoveryCache();
 
-/** Cache of discovered local project paths by slug */
-export const localProjectCache = new LRUCache<string, string>({
-  maxEntries: 100,
-});
+// Register the default caches for monitoring
+registerLRUCache("local-project-cache", defaultDiscoveryCache.projects);
+registerLRUCache("local-adapter-cache", defaultDiscoveryCache.adapters);
 
-// Register cache for monitoring
-registerLRUCache("local-project-cache", localProjectCache);
+/**
+ * @deprecated Use `defaultDiscoveryCache.adapters` instead.
+ * Kept for backward compatibility with existing consumers.
+ */
+export const localAdapterCache = defaultDiscoveryCache.adapters;
+
+/**
+ * @deprecated Use `defaultDiscoveryCache.projects` instead.
+ * Kept for backward compatibility with existing consumers.
+ */
+export const localProjectCache = defaultDiscoveryCache.projects;
+
+/** Standard directories to search for local projects */
+export const standardProjectDirs = ["data/projects", "projects"];
 
 function isNotFoundError(error: unknown): boolean {
   if (!(error instanceof Error)) return false;
@@ -78,12 +110,14 @@ async function isValidLocalProjectPath(path: string, adapter: RuntimeAdapter): P
  * @param slug - The project slug to find
  * @param adapter - The runtime adapter to use for filesystem operations
  * @param headerPath - Optional path from x-project-path header (takes precedence)
+ * @param cache - Optional cache instance (defaults to module-level singleton)
  * @returns The absolute path to the project, or undefined if not found
  */
 export async function findLocalProjectPath(
   slug: string,
   adapter: RuntimeAdapter,
   headerPath?: string,
+  cache: ProjectDiscoveryCache = defaultDiscoveryCache,
 ): Promise<string | undefined> {
   if (headerPath) {
     try {
@@ -92,7 +126,7 @@ export async function findLocalProjectPath(
         const absolutePath = normalizedPath.startsWith("/")
           ? normalizedPath
           : `${cwd()}/${normalizedPath}`;
-        localProjectCache.set(slug, absolutePath);
+        cache.projects.set(slug, absolutePath);
         return absolutePath;
       }
       logger.warn("Ignoring invalid x-project-path override", {
@@ -108,7 +142,7 @@ export async function findLocalProjectPath(
     }
   }
 
-  const cached = localProjectCache.get(slug);
+  const cached = cache.projects.get(slug);
   if (cached) return cached;
 
   for (const dir of standardProjectDirs) {
@@ -118,7 +152,7 @@ export async function findLocalProjectPath(
       if (!await isValidLocalProjectPath(projectPath, adapter)) continue;
 
       const absolutePath = projectPath.startsWith("/") ? projectPath : `${cwd()}/${projectPath}`;
-      localProjectCache.set(slug, absolutePath);
+      cache.projects.set(slug, absolutePath);
       logger.debug("Discovered local project", { slug, path: absolutePath });
       return absolutePath;
     } catch (error) {

package/src/src/server/services/rendering/ssr.service.ts

@@ -27,6 +27,32 @@ import type { CacheRepository } from "../../../repositories/types.js";
 
 const logger = serverLogger.component("ssr-service");
 
+/**
+ * Provides a renderer for a given handler context.
+ * Extracted to allow dependency injection in tests.
+ */
+export interface RendererProvider {
+  getRenderer(ctx: HandlerContext): Promise<RendererAdapter>;
+}
+
+/**
+ * Minimal interface for SSRService consumers (e.g., SSRHandler).
+ * Allows dependency injection and mocking in tests.
+ */
+export interface SSRServiceLike {
+  checkMemoryPressure(): MemoryStatus;
+  renderPage(ctx: HandlerContext, options: SSRRenderOptions): Promise<SSRRenderResult>;
+  createMemoryPressureResult(slug: string): SSRRenderResult;
+}
+
+/**
+ * Default RendererProvider that delegates to the real getRendererForProject.
+ */
+const defaultRendererProvider: RendererProvider = {
+  getRenderer: (ctx: HandlerContext) =>
+    timeAsync("renderer-init", () => getRendererForProject(ctx)),
+};
+
 export interface SSRRenderResult {
   status: number;
   html?: string;
@@ -59,11 +85,16 @@ export interface MemoryStatus {
   heapUsedPercent: number;
 }
 
-export class SSRService {
+export class SSRService implements SSRServiceLike {
   private readonly cacheRepo?: CacheRepository<string>;
+  private readonly rendererProvider: RendererProvider;
 
-  constructor(options?: { cacheRepo?: CacheRepository<string> }) {
+  constructor(options?: {
+    cacheRepo?: CacheRepository<string>;
+    rendererProvider?: RendererProvider;
+  }) {
     this.cacheRepo = options?.cacheRepo;
+    this.rendererProvider = options?.rendererProvider ?? defaultRendererProvider;
   }
 
   checkMemoryPressure(): MemoryStatus {
@@ -78,7 +109,7 @@ export class SSRService {
   }
 
   async getRenderer(ctx: HandlerContext): Promise<RendererAdapter> {
-    return timeAsync("renderer-init", () => getRendererForProject(ctx));
+    return this.rendererProvider.getRenderer(ctx);
   }
 
   async renderPage(ctx: HandlerContext, options: SSRRenderOptions): Promise<SSRRenderResult> {

package/src/src/server/shared/renderer/adapter.ts

@@ -64,11 +64,95 @@ export interface RendererAdapter {
   destroy(): Promise<void>;
 }
 
-let rendererInitPromise: Promise<Renderer> | null = null;
+/**
+ * Abstraction over renderer initialization, allowing tests to inject
+ * a mock renderer without pulling in the full rendering subsystem.
+ */
+export interface RendererInitializer {
+  initialize(options: RendererOptions): Promise<Renderer>;
+  isInitialized(): boolean;
+  get(): Renderer;
+  destroy(): Promise<void>;
+}
+
+/**
+ * Default initializer that delegates to the real shared renderer
+ * singleton from `#veryfront/rendering/renderer.ts`.
+ */
+const defaultInitializer: RendererInitializer = {
+  initialize: initializeRenderer,
+  isInitialized: isRendererInitialized,
+  get: getRenderer,
+  destroy: destroySharedRenderer,
+};
+
+let activeInitializer: RendererInitializer = defaultInitializer;
+let rendererInitState: { initializer: RendererInitializer; promise: Promise<Renderer> } | null =
+  null;
+
+function scheduleInitializerDestroy(
+  initializer: RendererInitializer,
+  pendingPromise?: Promise<unknown>,
+): void {
+  const destroy = async () => {
+    try {
+      await initializer.destroy();
+    } catch (error) {
+      logger.warn("Failed to destroy renderer initializer", {
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  };
+
+  if (pendingPromise) {
+    void pendingPromise
+      .catch(() => undefined)
+      .then(destroy);
+    return;
+  }
+
+  if (!initializer.isInitialized()) return;
+  void destroy();
+}
+
+/**
+ * Replace the renderer initializer used by the adapter layer.
+ * Pass `undefined` to restore the default (real) initializer.
+ *
+ * Returns a disposer that restores the previous initializer — use in
+ * `afterEach` or with `using` to prevent test pollution:
+ *
+ * ```ts
+ * afterEach(() => setRendererInitializer(undefined));
+ * ```
+ *
+ * @internal Test-only — not part of the public API.
+ */
+export function setRendererInitializer(
+  initializer?: RendererInitializer,
+): void {
+  const nextInitializer = initializer ?? defaultInitializer;
+  const previous = activeInitializer;
+  const previousPendingPromise = rendererInitState?.initializer === previous
+    ? rendererInitState.promise
+    : undefined;
+
+  activeInitializer = nextInitializer;
+
+  if (rendererInitState?.initializer !== activeInitializer) {
+    rendererInitState = null;
+  }
+
+  if (previous !== activeInitializer) {
+    scheduleInitializerDestroy(previous, previousPendingPromise);
+  }
+}
 
 async function getOrInitRenderer(): Promise<Renderer> {
-  if (isRendererInitialized()) return getRenderer();
-  if (rendererInitPromise) return rendererInitPromise;
+  if (activeInitializer.isInitialized()) return activeInitializer.get();
+  if (rendererInitState?.initializer === activeInitializer) {
+    return rendererInitState.promise;
+  }
 
   const isProxyMode = getEnvBoolean("PROXY_MODE", false, {
     trueValues: ["1"],
@@ -99,12 +183,19 @@ async function getOrInitRenderer(): Promise<Renderer> {
     cacheType: useApiCache ? "api-distributed" : "memory",
   });
 
-  rendererInitPromise = initializeRenderer(options);
+  const initializer = activeInitializer;
+  const initPromise = initializer.initialize(options);
+  rendererInitState = {
+    initializer,
+    promise: initPromise,
+  };
 
   try {
-    return await rendererInitPromise;
+    return await initPromise;
   } finally {
-    rendererInitPromise = null;
+    if (rendererInitState?.promise === initPromise) {
+      rendererInitState = null;
+    }
   }
 }
 
@@ -308,6 +399,14 @@ export async function getRendererForProject(ctx: HandlerContext): Promise<Render
 }
 
 export async function destroyRendererAdapter(): Promise<void> {
-  await destroySharedRenderer();
-  rendererInitPromise = null;
+  const pendingPromise = rendererInitState?.initializer === activeInitializer
+    ? rendererInitState.promise
+    : undefined;
+  rendererInitState = null;
+
+  if (pendingPromise) {
+    await pendingPromise.catch(() => undefined);
+  }
+
+  await activeInitializer.destroy();
 }

package/src/src/server/shared/renderer/index.ts

@@ -4,5 +4,11 @@
  * @module server/shared/renderer
  */
 
-export { destroyRendererAdapter, getRendererForProject, type RendererAdapter } from "./adapter.js";
+export {
+  destroyRendererAdapter,
+  getRendererForProject,
+  type RendererAdapter,
+  type RendererInitializer,
+  setRendererInitializer,
+} from "./adapter.js";
 export { shouldRejectDueToMemory } from "./memory/pressure.js";