pepr 0.55.6 → 1.0.0

package/dist/lib.js

@@ -534,6 +534,9 @@ var Capability = class {
    * @param kind if using a custom KubernetesObject not available in `a.*`, specify the GroupVersionKind
    * @returns
    */
+  // This method intentionally defines a fluent, closure-based DSL for chaining capability actions.
+  // Multiple inline helper functions are required to preserve runtime behavior and readability.
+  // eslint-disable-next-line max-statements
   When = (model, kind3) => {
     const matchedKind = (0, import_kubernetes_fluent_client2.modelToGroupVersionKind)(model.name);
     if (!matchedKind && !kind3) {
@@ -1419,6 +1422,10 @@ var OnError = /* @__PURE__ */ ((OnError2) => {
 })(OnError || {});
 
 // src/lib/assets/ignoredNamespaces.ts
+function getIgnoreNamespaces(config) {
+  const fromConfig = config?.alwaysIgnore?.namespaces?.length ? config.alwaysIgnore.namespaces : config?.admission?.alwaysIgnore?.namespaces;
+  return resolveIgnoreNamespaces(fromConfig);
+}
 function resolveIgnoreNamespaces(ignoredNSConfig = []) {
   const ignoredNSEnv = process.env.PEPR_ADDITIONAL_IGNORED_NAMESPACES;
   if (!ignoredNSEnv) {
@@ -1524,9 +1531,7 @@ async function mutateProcessor(config, capabilities, req, reqMetadata) {
       bind.binding,
       bind.req,
       bind.namespaces,
-      resolveIgnoreNamespaces(
-        bind?.config?.alwaysIgnore?.namespaces?.length ? bind.config?.alwaysIgnore?.namespaces : bind.config?.admission?.alwaysIgnore?.namespaces
-      )
+      getIgnoreNamespaces(config)
     );
     if (shouldSkip !== "") {
       logger_default.debug(shouldSkip);
@@ -1698,14 +1703,7 @@ async function validateProcessor(config, capabilities, req, reqMetadata) {
       if (!binding.validateCallback) {
         continue;
       }
-      const shouldSkip = shouldSkipRequest(
-        binding,
-        req,
-        namespaces,
-        resolveIgnoreNamespaces(
-          config?.alwaysIgnore?.namespaces?.length ? config?.alwaysIgnore?.namespaces : config?.admission?.alwaysIgnore?.namespaces
-        )
-      );
+      const shouldSkip = shouldSkipRequest(binding, req, namespaces, getIgnoreNamespaces(config));
       if (shouldSkip !== "") {
         logger_default.debug(shouldSkip);
         continue;
@@ -2181,11 +2179,7 @@ var Controller = class _Controller {
       const startTime = MetricsCollector.observeStart();
       try {
         const request = req.body?.request || {};
-        const { name, namespace: namespace2, gvk } = {
-          name: request?.name ? `/${request.name}` : "",
-          namespace: request?.namespace || "",
-          gvk: request?.kind || { group: "", version: "", kind: "" }
-        };
+        const { name, namespace: namespace2, gvk } = getRequestValues(request);
         const reqMetadata = { uid: request.uid, namespace: namespace2, name };
         logger_default.info(
           { ...reqMetadata, gvk, operation: request.operation, admissionKind },
@@ -2254,6 +2248,13 @@ var Controller = class _Controller {
     }
   }
 };
+function getRequestValues(request) {
+  return {
+    name: request?.name ? `/${request.name}` : "",
+    namespace: request?.namespace || "",
+    gvk: request?.kind || { group: "", version: "", kind: "" }
+  };
+}
 
 // src/lib/errors.ts
 var ErrorList = Object.values(OnError);
@@ -2396,7 +2397,7 @@ var eventToPhaseMap = {
 function setupWatch(capabilities, ignoredNamespaces) {
   for (const capability of capabilities) {
     for (const binding of capability.bindings.filter((b) => b.isWatch)) {
-      runBinding(binding, capability.namespaces, ignoredNamespaces);
+      void runBinding(binding, capability.namespaces, ignoredNamespaces);
     }
   }
 }
@@ -2530,52 +2531,60 @@ function createControllerHooks(opts, capabilities, ignoreNamespaces = []) {
 }
 
 // src/lib/core/module.ts
-var PeprModule = class {
+var PeprModule = class _PeprModule {
   #controller;
   /**
-   * Create a new Pepr runtime
+   * Initialize a new Pepr runtime module.
    *
-   * @param config The configuration for the Pepr runtime
-   * @param capabilities The capabilities to be loaded into the Pepr runtime
-   * @param opts Options for the Pepr runtime
+   * @param pkg The package.json data containing Pepr configuration.
+   * @param capabilities The list of capabilities to load.
+   * @param opts Options for the Pepr runtime settings (e.g., deferStart).
    */
   constructor({ description, pepr }, capabilities = [], opts = {}) {
-    const config = (0, import_ramda13.clone)(pepr);
-    config.description = description;
-    ValidateError(config.onError);
+    const config = _PeprModule.#initializeConfig(description, pepr);
+    _PeprModule.#validateConfig(config);
     if (isBuildMode()) {
-      if (!process.send) {
-        throw new Error("process.send is not defined");
-      }
-      const exportedCapabilities = [];
-      for (const capability of capabilities) {
-        exportedCapabilities.push({
-          name: capability.name,
-          description: capability.description,
-          namespaces: capability.namespaces,
-          bindings: capability.bindings,
-          hasSchedule: capability.hasSchedule
-        });
-      }
-      process.send(exportedCapabilities);
+      _PeprModule.#handleBuildMode(capabilities);
       return;
     }
-    const controllerHooks = createControllerHooks(
-      opts,
-      capabilities,
-      pepr?.alwaysIgnore?.namespaces?.length ? pepr.alwaysIgnore.namespaces : config?.watch?.alwaysIgnore?.namespaces
-    );
+    const controllerHooks = _PeprModule.#createHooks(opts, capabilities, pepr, config);
     this.#controller = new Controller(config, capabilities, controllerHooks);
-    if (opts.deferStart) {
-      return;
+    if (!opts.deferStart) {
+      this.start();
+    }
+  }
+  static #initializeConfig(description, pepr) {
+    const config = (0, import_ramda13.clone)(pepr);
+    config.description = description;
+    return config;
+  }
+  static #validateConfig(config) {
+    ValidateError(config.onError);
+  }
+  static #handleBuildMode(capabilities) {
+    if (!process.send) {
+      throw new Error("process.send is not defined");
     }
-    this.start();
+    const exportedCapabilities = capabilities.map((cap) => ({
+      name: cap.name,
+      description: cap.description,
+      namespaces: cap.namespaces,
+      bindings: cap.bindings,
+      hasSchedule: cap.hasSchedule
+    }));
+    process.send(exportedCapabilities);
+  }
+  static #createHooks(opts, capabilities, pepr, config) {
+    const ignored = pepr?.alwaysIgnore?.namespaces?.length ? pepr.alwaysIgnore.namespaces : config?.watch?.alwaysIgnore?.namespaces;
+    return createControllerHooks(opts, capabilities, ignored);
   }
   /**
-   * Start the Pepr runtime manually.
-   * Normally this is called automatically when the Pepr module is instantiated, but can be called manually if `deferStart` is set to `true` in the constructor.
+   * Starts the Pepr runtime manually.
+   *
+   * Normally this is called automatically when the Pepr module is instantiated,
+   * but it can be invoked manually if `deferStart` is set to `true` in the constructor.
    *
-   * @param port
+   * @param port - The port number to start the server on (default: 3000).
    */
   start = (port = 3e3) => {
     this.#controller.startServer(port);