Simplify interceptor code and rename variables for clarity.

packages/safe-chain/src/registryProxy/interceptors/interceptorBuilder.js

@@ -1,41 +1,32 @@
 /**
- * @typedef {import('./requestInterceptorBuilder.js').RequestInterceptorBuilder} RequestInterceptorBuilder
- * @typedef {import('./requestInterceptorBuilder.js').RequestInterceptor} RequestInterceptor
- *
- * @typedef {Object} InterceptorBuilder
- * @property {(requestFunc: (requestHandlerBuilder: RequestInterceptorBuilder) => Promise<void>) => void} onRequest
- * @property {() => Interceptor} build
- *
  * @typedef {Object} Interceptor
- * @property {(targetUrl: string) => Promise<RequestInterceptor>} handleRequest
+ * @property {(targetUrl: string) => Promise<RequestInterceptionHandler>} handleRequest
  * @property {(event: string, listener: (...args: any[]) => void) => Interceptor} on
  * @property {(event: string, ...args: any[]) => boolean} emit
+ *
+ *
+ * @typedef {Object} RequestInterceptionContext
+ * @property {string} targetUrl
+ * @property {(packageName: string | undefined, version: string | undefined) => void} blockMalware
+ * @property {() => RequestInterceptionHandler} build
+ *
+ *
+ * @typedef {Object} RequestInterceptionHandler
+ * @property {{statusCode: number, message: string} | undefined} blockResponse
  */
 
 import { EventEmitter } from "events";
-import { createRequestInterceptorBuilder } from "./requestInterceptorBuilder.js";
 
 /**
- * @returns {InterceptorBuilder}
+ * @param {(requestHandlerBuilder: RequestInterceptionContext) => Promise<void>} requestInterceptionFunc
+ * @returns {Interceptor}
  */
-export function createInterceptorBuilder() {
-  /**
-   * @type {Array<(requestHandlerBuilder: RequestInterceptorBuilder) => Promise<void>>}
-   */
-  const requestHandlers = [];
-
-  return {
-    onRequest(requestFunc) {
-      requestHandlers.push(requestFunc);
-    },
-    build() {
-      return buildInterceptor(requestHandlers);
-    },
-  };
+export function interceptRequests(requestInterceptionFunc) {
+  return buildInterceptor([requestInterceptionFunc]);
 }
 
 /**
- * @param {Array<(requestHandlerBuilder: RequestInterceptorBuilder) => Promise<void>>} requestHandlers
+ * @param {Array<(requestHandlerBuilder: RequestInterceptionContext) => Promise<void>>} requestHandlers
  * @returns {Interceptor}
  */
 function buildInterceptor(requestHandlers) {
@@ -43,7 +34,7 @@ function buildInterceptor(requestHandlers) {
 
   return {
     async handleRequest(targetUrl) {
-      const reqInterceptorBuilder = createRequestInterceptorBuilder(
+      const reqInterceptorBuilder = createRequestContext(
         targetUrl,
         eventEmitter
       );
@@ -63,3 +54,47 @@ function buildInterceptor(requestHandlers) {
     },
   };
 }
+
+/**
+ * @param {string} targetUrl
+ * @param {import('events').EventEmitter} eventEmitter
+ * @returns {RequestInterceptionContext}
+ */
+function createRequestContext(targetUrl, eventEmitter) {
+  /** @type {{statusCode: number, message: string} | undefined}  */
+  let blockResponse = undefined;
+
+  /**
+   * @param {number} statusCode
+   * @param {string} message
+   */
+  function blockRequest(statusCode, message) {
+    blockResponse = { statusCode, message };
+  }
+
+  /**
+   * @param {string | undefined} packageName
+   * @param {string | undefined} version
+   */
+  function blockMalware(packageName, version) {
+    blockRequest(403, "Forbidden - blocked by safe-chain");
+
+    // Emit the malwareBlocked event
+    eventEmitter.emit("malwareBlocked", {
+      packageName,
+      version,
+      targetUrl,
+      timestamp: Date.now(),
+    });
+  }
+
+  return {
+    targetUrl,
+    blockMalware,
+    build() {
+      return {
+        blockResponse,
+      };
+    },
+  };
+}