pepr 0.46.2-nightly.1 → 0.46.2-nightly.2

package/src/lib/core/capability.ts

@@ -206,7 +206,16 @@ export class Capability implements CapabilityExport {
 
     const bindings = this.#bindings;
     const prefix = `${this.#name}: ${model.name}`;
-    const commonChain = { WithLabel, WithAnnotation, WithDeletionTimestamp, Mutate, Validate, Watch, Reconcile, Alias };
+    const commonChain = {
+      WithLabel,
+      WithAnnotation,
+      WithDeletionTimestamp,
+      Mutate,
+      Validate,
+      Watch,
+      Reconcile,
+      Alias,
+    };
 
     type CommonChainType = typeof commonChain;
     type ExtendedCommonChainType = CommonChainType & {
@@ -240,7 +249,9 @@ export class Capability implements CapabilityExport {
           ...binding,
           isValidate: true,
           validateCallback: async (req, logger = aliasLogger) => {
-            Log.info(`Executing validate action with alias: ${binding.alias || "no alias provided"}`);
+            Log.info(
+              `Executing validate action with alias: ${binding.alias || "no alias provided"}`,
+            );
             return await validateCallback(req, logger);
           },
         });
@@ -262,7 +273,9 @@ export class Capability implements CapabilityExport {
           ...binding,
           isMutate: true,
           mutateCallback: async (req, logger = aliasLogger) => {
-            Log.info(`Executing mutation action with alias: ${binding.alias || "no alias provided"}`);
+            Log.info(
+              `Executing mutation action with alias: ${binding.alias || "no alias provided"}`,
+            );
             await mutateCallback(req, logger);
           },
         });
@@ -277,7 +290,9 @@ export class Capability implements CapabilityExport {
         log("Watch Action", watchCallback.toString());
 
         // Create the child logger and cast it to the expected type
-        const aliasLogger = Log.child({ alias: binding.alias || "no alias provided" }) as typeof Log;
+        const aliasLogger = Log.child({
+          alias: binding.alias || "no alias provided",
+        }) as typeof Log;
 
         // Push the binding to the list of bindings for this capability as a new BindingAction
         // with the callback function to preserve
@@ -298,7 +313,9 @@ export class Capability implements CapabilityExport {
         log("Reconcile Action", reconcileCallback.toString());
 
         // Create the child logger and cast it to the expected type
-        const aliasLogger = Log.child({ alias: binding.alias || "no alias provided" }) as typeof Log;
+        const aliasLogger = Log.child({
+          alias: binding.alias || "no alias provided",
+        }) as typeof Log;
 
         // Push the binding to the list of bindings for this capability as a new BindingAction
         // with the callback function to preserve
@@ -307,7 +324,9 @@ export class Capability implements CapabilityExport {
           isWatch: true,
           isQueue: true,
           watchCallback: async (update, phase, logger = aliasLogger) => {
-            Log.info(`Executing reconcile action with alias: ${binding.alias || "no alias provided"}`);
+            Log.info(
+              `Executing reconcile action with alias: ${binding.alias || "no alias provided"}`,
+            );
             await reconcileCallback(update, phase, logger);
           },
         });
@@ -340,8 +359,13 @@ export class Capability implements CapabilityExport {
           isWatch: true,
           isFinalize: true,
           event: Event.UPDATE,
-          finalizeCallback: async (update: InstanceType<T>, logger = aliasLogger): Promise<boolean | void> => {
-            Log.info(`Executing finalize action with alias: ${binding.alias || "no alias provided"}`);
+          finalizeCallback: async (
+            update: InstanceType<T>,
+            logger = aliasLogger,
+          ): Promise<boolean | void> => {
+            Log.info(
+              `Executing finalize action with alias: ${binding.alias || "no alias provided"}`,
+            );
             return await finalizeCallback(update, logger);
           },
         };

package/src/lib/core/module.ts

@@ -21,7 +21,11 @@ export class PeprModule {
    * @param capabilities The capabilities to be loaded into the Pepr runtime
    * @param opts Options for the Pepr runtime
    */
-  constructor({ description, pepr }: PackageJSON, capabilities: Capability[] = [], opts: PeprModuleOptions = {}) {
+  constructor(
+    { description, pepr }: PackageJSON,
+    capabilities: Capability[] = [],
+    opts: PeprModuleOptions = {},
+  ) {
     const config: ModuleConfig = clone(pepr);
     config.description = description;
 

package/src/lib/core/storage.ts

@@ -169,7 +169,9 @@ export class Storage implements PeprStore {
       // If promise has not resolved before MAX_WAIT_TIME reject
       record.timeout = setTimeout(() => {
         record.unsubscribe!();
-        return reject(`MAX_WAIT_TIME elapsed: Key ${key} still seen after ${MAX_WAIT_TIME / 1000}s`);
+        return reject(
+          `MAX_WAIT_TIME elapsed: Key ${key} still seen after ${MAX_WAIT_TIME / 1000}s`,
+        );
       }, MAX_WAIT_TIME);
 
       record.unsubscribe = this.subscribe(data => {

package/src/lib/deploymentChecks.ts

@@ -29,7 +29,9 @@ export async function checkDeploymentStatus(namespace: string): Promise<boolean>
 }
 
 // wait for all deployments in the pepr-system namespace to be ready
-export async function namespaceDeploymentsReady(namespace: string = "pepr-system"): Promise<true | undefined> {
+export async function namespaceDeploymentsReady(
+  namespace: string = "pepr-system",
+): Promise<true | undefined> {
   Log.info(`Checking ${namespace} deployments status...`);
   let ready = false;
   while (!ready) {

package/src/lib/filter/adjudicators/admissionRequest.ts

@@ -22,4 +22,7 @@ export const declaredKind = pipe(
   (request: AdmissionRequest<KubernetesObject>): string => request?.kind?.kind,
   defaultTo(""),
 );
-export const declaredUid = pipe((request: AdmissionRequest<KubernetesObject>): string => request?.uid, defaultTo(""));
+export const declaredUid = pipe(
+  (request: AdmissionRequest<KubernetesObject>): string => request?.uid,
+  defaultTo(""),
+);

package/src/lib/filter/adjudicators/binding.ts

@@ -27,13 +27,22 @@ export const definesNameRegex = pipe(definedNameRegex, equals(""), not);
 export const definedNamespaces = pipe(binding => binding?.filters?.namespaces, defaultTo([]));
 export const definesNamespaces = pipe(definedNamespaces, equals([]), not);
 
-export const definedNamespaceRegexes = pipe(binding => binding?.filters?.regexNamespaces, defaultTo([]));
+export const definedNamespaceRegexes = pipe(
+  binding => binding?.filters?.regexNamespaces,
+  defaultTo([]),
+);
 export const definesNamespaceRegexes = pipe(definedNamespaceRegexes, equals([]), not);
 
-export const definedAnnotations = pipe((binding: Partial<Binding>) => binding?.filters?.annotations, defaultTo({}));
+export const definedAnnotations = pipe(
+  (binding: Partial<Binding>) => binding?.filters?.annotations,
+  defaultTo({}),
+);
 export const definesAnnotations = pipe(definedAnnotations, equals({}), not);
 
-export const definedLabels = pipe((binding: Partial<Binding>) => binding?.filters?.labels, defaultTo({}));
+export const definedLabels = pipe(
+  (binding: Partial<Binding>) => binding?.filters?.labels,
+  defaultTo({}),
+);
 export const definesLabels = pipe(definedLabels, equals({}), not);
 
 export const definedEvent = (binding: Binding): Event => {
@@ -82,4 +91,8 @@ export const definedCallback = (binding: Partial<Binding>): DefinedCallbackRetur
     binding.isValidate ? binding.validateCallback :
     null;
 };
-export const definedCallbackName = pipe(definedCallback, defaultTo({ name: "" }), callback => callback.name);
+export const definedCallbackName = pipe(
+  definedCallback,
+  defaultTo({ name: "" }),
+  callback => callback.name,
+);

package/src/lib/filter/adjudicators/kubernetesObject.ts

@@ -15,7 +15,8 @@ export const carriedKind = pipe(
   defaultTo("not set"),
 );
 export const carriedVersion = pipe(
-  (kubernetesObject: KubernetesObject): string | undefined => kubernetesObject?.metadata?.resourceVersion,
+  (kubernetesObject: KubernetesObject): string | undefined =>
+    kubernetesObject?.metadata?.resourceVersion,
   defaultTo("not set"),
 );
 export const carriedName = pipe(
@@ -40,7 +41,8 @@ export const carriedAnnotations = pipe(
 export const carriesAnnotations = pipe(carriedAnnotations, equals({}), not);
 
 export const carriedLabels = pipe(
-  (kubernetesObject: KubernetesObject): { [key: string]: string } | undefined => kubernetesObject?.metadata?.labels,
+  (kubernetesObject: KubernetesObject): { [key: string]: string } | undefined =>
+    kubernetesObject?.metadata?.labels,
   defaultTo({}),
 );
 export const carriesLabels = pipe(carriedLabels, equals({}), not);

package/src/lib/filter/adjudicators/mismatch.ts

@@ -32,7 +32,12 @@ import {
   carriedNamespace,
   missingDeletionTimestamp,
 } from "./kubernetesObject";
-import { declaredOperation, declaredGroup, declaredVersion, declaredKind } from "./admissionRequest";
+import {
+  declaredOperation,
+  declaredGroup,
+  declaredVersion,
+  declaredKind,
+} from "./admissionRequest";
 import { Event, Operation } from "../../enums";
 import { AdmissionRequest } from "../../common-types";
 
@@ -48,12 +53,20 @@ export const mismatchedName = allPass([
 
 export const mismatchedNameRegex = allPass([
   pipe(nthArg(0), definesNameRegex),
-  pipe((binding, kubernetesObject) => new RegExp(definedNameRegex(binding)).test(carriedName(kubernetesObject)), not),
+  pipe(
+    (binding, kubernetesObject) =>
+      new RegExp(definedNameRegex(binding)).test(carriedName(kubernetesObject)),
+    not,
+  ),
 ]);
 
 export const mismatchedNamespace = allPass([
   pipe(nthArg(0), definesNamespaces),
-  pipe((binding, kubernetesObject) => definedNamespaces(binding).includes(carriedNamespace(kubernetesObject)), not),
+  pipe(
+    (binding, kubernetesObject) =>
+      definedNamespaces(binding).includes(carriedNamespace(kubernetesObject)),
+    not,
+  ),
 ]);
 
 export const mismatchedNamespaceRegex = allPass([
@@ -95,12 +108,16 @@ export const metasMismatch = pipe(
 
 export const mismatchedAnnotations = allPass([
   pipe(nthArg(0), definesAnnotations),
-  pipe((binding, kubernetesObject) => metasMismatch(definedAnnotations(binding), carriedAnnotations(kubernetesObject))),
+  pipe((binding, kubernetesObject) =>
+    metasMismatch(definedAnnotations(binding), carriedAnnotations(kubernetesObject)),
+  ),
 ]);
 
 export const mismatchedLabels = allPass([
   pipe(nthArg(0), definesLabels),
-  pipe((binding, kubernetesObject) => metasMismatch(definedLabels(binding), carriedLabels(kubernetesObject))),
+  pipe((binding, kubernetesObject) =>
+    metasMismatch(definedLabels(binding), carriedLabels(kubernetesObject)),
+  ),
 ]);
 
 export const mismatchedEvent = pipe(
@@ -126,5 +143,7 @@ export const mismatchedKind = allPass([
 export const operationMatchesEvent = anyPass([
   pipe(nthArg(1), equals(Event.ANY)),
   pipe((operation: Operation, event: Event): boolean => operation.valueOf() === event.valueOf()),
-  pipe((operation: Operation, event: Event): boolean => (operation ? event.includes(operation) : false)),
+  pipe((operation: Operation, event: Event): boolean =>
+    operation ? event.includes(operation) : false,
+  ),
 ]);

package/src/lib/filter/adjudicators/postCollection.ts

@@ -3,7 +3,13 @@
 
 import { __, allPass, curry, difference, equals, gt, length, not, nthArg, pipe } from "ramda";
 import { KubernetesObject } from "kubernetes-fluent-client";
-import { definedKind, definedNamespaces, definesDelete, definesDeletionTimestamp, definesNamespaces } from "./binding";
+import {
+  definedKind,
+  definedNamespaces,
+  definesDelete,
+  definesDeletionTimestamp,
+  definesNamespaces,
+} from "./binding";
 import { carriedNamespace, carriesNamespace } from "./kubernetesObject";
 
 /*
@@ -14,7 +20,10 @@ import { carriedNamespace, carriesNamespace } from "./kubernetesObject";
 */
 
 export const bindsToKind = curry(
-  allPass([pipe(nthArg(0), definedKind, equals(""), not), pipe((binding, kind) => definedKind(binding) === kind)]),
+  allPass([
+    pipe(nthArg(0), definedKind, equals(""), not),
+    pipe((binding, kind) => definedKind(binding) === kind),
+  ]),
 );
 export const bindsToNamespace = curry(pipe(bindsToKind(__, "Namespace")));
 export const misboundNamespace = allPass([bindsToNamespace, definesNamespaces]);
@@ -74,4 +83,7 @@ export const unbindableNamespaces = allPass([
   ),
 ]);
 
-export const misboundDeleteWithDeletionTimestamp = allPass([definesDelete, definesDeletionTimestamp]);
+export const misboundDeleteWithDeletionTimestamp = allPass([
+  definesDelete,
+  definesDeletionTimestamp,
+]);

package/src/lib/filter/filter.ts

@@ -12,7 +12,12 @@ import {
   unbindableNamespaces,
   uncarryableNamespace,
 } from "./adjudicators/postCollection";
-import { declaredOperation, declaredGroup, declaredVersion, declaredKind } from "./adjudicators/admissionRequest";
+import {
+  declaredOperation,
+  declaredGroup,
+  declaredVersion,
+  declaredKind,
+} from "./adjudicators/admissionRequest";
 import {
   definedEvent,
   definedName,
@@ -25,7 +30,12 @@ import {
   definedNamespaceRegexes,
   definedNameRegex,
 } from "./adjudicators/binding";
-import { carriedName, carriedNamespace, carriedLabels, carriedAnnotations } from "./adjudicators/kubernetesObject";
+import {
+  carriedName,
+  carriedNamespace,
+  carriedLabels,
+  carriedAnnotations,
+} from "./adjudicators/kubernetesObject";
 import {
   mismatchedDeletionTimestamp,
   mismatchedEvent,
@@ -137,49 +147,72 @@ export function adjudicateMisboundNamespace(binding: Binding): AdjudicationResul
   return misboundNamespace(binding) ? "Cannot use namespace filter on a namespace object." : null;
 }
 
-export function adjudicateMisboundDeleteWithDeletionTimestamp(binding: Binding): AdjudicationResult {
+export function adjudicateMisboundDeleteWithDeletionTimestamp(
+  binding: Binding,
+): AdjudicationResult {
   return misboundDeleteWithDeletionTimestamp(binding)
     ? "Cannot use deletionTimestamp filter on a DELETE operation."
     : null;
 }
 
-export function adjudicateMismatchedDeletionTimestamp(binding: Binding, obj: KubernetesObject): AdjudicationResult {
+export function adjudicateMismatchedDeletionTimestamp(
+  binding: Binding,
+  obj: KubernetesObject,
+): AdjudicationResult {
   return mismatchedDeletionTimestamp(binding, obj)
     ? "Binding defines deletionTimestamp but Object does not carry it."
     : null;
 }
 
-export function adjudicateMismatchedEvent(binding: Binding, req: AdmissionRequest): AdjudicationResult {
+export function adjudicateMismatchedEvent(
+  binding: Binding,
+  req: AdmissionRequest,
+): AdjudicationResult {
   return mismatchedEvent(binding, req)
     ? `Binding defines event '${definedEvent(binding)}' but Request declares '${declaredOperation(req)}'.`
     : null;
 }
 
-export function adjudicateMismatchedName(binding: Binding, obj: KubernetesObject): AdjudicationResult {
+export function adjudicateMismatchedName(
+  binding: Binding,
+  obj: KubernetesObject,
+): AdjudicationResult {
   return mismatchedName(binding, obj)
     ? `Binding defines name '${definedName(binding)}' but Object carries '${carriedName(obj)}'.`
     : null;
 }
 
-export function adjudicateMismatchedGroup(binding: Binding, req: AdmissionRequest): AdjudicationResult {
+export function adjudicateMismatchedGroup(
+  binding: Binding,
+  req: AdmissionRequest,
+): AdjudicationResult {
   return mismatchedGroup(binding, req)
     ? `Binding defines group '${definedGroup(binding)}' but Request declares '${declaredGroup(req)}'.`
     : null;
 }
 
-export function adjudicateMismatchedVersion(binding: Binding, req: AdmissionRequest): AdjudicationResult {
+export function adjudicateMismatchedVersion(
+  binding: Binding,
+  req: AdmissionRequest,
+): AdjudicationResult {
   return mismatchedVersion(binding, req)
     ? `Binding defines version '${definedVersion(binding)}' but Request declares '${declaredVersion(req)}'.`
     : null;
 }
 
-export function adjudicateMismatchedKind(binding: Binding, req: AdmissionRequest): AdjudicationResult {
+export function adjudicateMismatchedKind(
+  binding: Binding,
+  req: AdmissionRequest,
+): AdjudicationResult {
   return mismatchedKind(binding, req)
     ? `Binding defines kind '${definedKind(binding)}' but Request declares '${declaredKind(req)}'.`
     : null;
 }
 
-export function adjudicateUnbindableNamespaces(capabilityNamespaces: string[], binding: Binding): AdjudicationResult {
+export function adjudicateUnbindableNamespaces(
+  capabilityNamespaces: string[],
+  binding: Binding,
+): AdjudicationResult {
   return unbindableNamespaces(capabilityNamespaces, binding)
     ? `Binding defines namespaces ${JSON.stringify(definedNamespaces(binding))} but namespaces allowed by Capability are '${JSON.stringify(capabilityNamespaces)}'.`
     : null;
@@ -194,31 +227,46 @@ export function adjudicateUncarryableNamespace(
     : null;
 }
 
-export function adjudicateMismatchedNamespace(binding: Binding, obj: KubernetesObject): AdjudicationResult {
+export function adjudicateMismatchedNamespace(
+  binding: Binding,
+  obj: KubernetesObject,
+): AdjudicationResult {
   return mismatchedNamespace(binding, obj)
     ? `Binding defines namespaces '${JSON.stringify(definedNamespaces(binding))}' but Object carries '${carriedNamespace(obj)}'.`
     : null;
 }
 
-export function adjudicateMismatchedLabels(binding: Binding, obj: KubernetesObject): AdjudicationResult {
+export function adjudicateMismatchedLabels(
+  binding: Binding,
+  obj: KubernetesObject,
+): AdjudicationResult {
   return mismatchedLabels(binding, obj)
     ? `Binding defines labels '${JSON.stringify(definedLabels(binding))}' but Object carries '${JSON.stringify(carriedLabels(obj))}'.`
     : null;
 }
 
-export function adjudicateMismatchedAnnotations(binding: Binding, obj: KubernetesObject): AdjudicationResult {
+export function adjudicateMismatchedAnnotations(
+  binding: Binding,
+  obj: KubernetesObject,
+): AdjudicationResult {
   return mismatchedAnnotations(binding, obj)
     ? `Binding defines annotations '${JSON.stringify(definedAnnotations(binding))}' but Object carries '${JSON.stringify(carriedAnnotations(obj))}'.`
     : null;
 }
 
-export function adjudicateMismatchedNamespaceRegex(binding: Binding, obj: KubernetesObject): AdjudicationResult {
+export function adjudicateMismatchedNamespaceRegex(
+  binding: Binding,
+  obj: KubernetesObject,
+): AdjudicationResult {
   return mismatchedNamespaceRegex(binding, obj)
     ? `Binding defines namespace regexes '${JSON.stringify(definedNamespaceRegexes(binding))}' but Object carries '${carriedNamespace(obj)}'.`
     : null;
 }
 
-export function adjudicateMismatchedNameRegex(binding: Binding, obj: KubernetesObject): AdjudicationResult {
+export function adjudicateMismatchedNameRegex(
+  binding: Binding,
+  obj: KubernetesObject,
+): AdjudicationResult {
   return mismatchedNameRegex(binding, obj)
     ? `Binding defines name regex '${definedNameRegex(binding)}' but Object carries '${carriedName(obj)}'.`
     : null;

package/src/lib/helpers.ts

@@ -15,7 +15,9 @@ export function validateCapabilityNames(capabilities: CapabilityExport[] | undef
   if (capabilities && capabilities.length > 0) {
     for (let i = 0; i < capabilities.length; i++) {
       if (capabilities[i].name !== sanitizeResourceName(capabilities[i].name)) {
-        throw new ValidationError(`Capability name is not a valid Kubernetes resource name: ${capabilities[i].name}`);
+        throw new ValidationError(
+          `Capability name is not a valid Kubernetes resource name: ${capabilities[i].name}`,
+        );
       }
     }
   }
@@ -88,15 +90,23 @@ export function hasAnyOverlap<T>(array1: T[], array2: T[]): boolean {
   return array1.some(element => array2.includes(element));
 }
 
-export function ignoredNamespaceConflict(ignoreNamespaces: string[], bindingNamespaces: string[]): boolean {
+export function ignoredNamespaceConflict(
+  ignoreNamespaces: string[],
+  bindingNamespaces: string[],
+): boolean {
   return hasAnyOverlap(bindingNamespaces, ignoreNamespaces);
 }
 
-export function bindingAndCapabilityNSConflict(bindingNamespaces: string[], capabilityNamespaces: string[]): boolean {
+export function bindingAndCapabilityNSConflict(
+  bindingNamespaces: string[],
+  capabilityNamespaces: string[],
+): boolean {
   if (!capabilityNamespaces) {
     return false;
   }
-  return capabilityNamespaces.length !== 0 && !hasEveryOverlap(bindingNamespaces, capabilityNamespaces);
+  return (
+    capabilityNamespaces.length !== 0 && !hasEveryOverlap(bindingNamespaces, capabilityNamespaces)
+  );
 }
 
 export function generateWatchNamespaceError(
@@ -125,9 +135,14 @@ export function generateWatchNamespaceError(
 }
 
 // namespaceComplianceValidator ensures that capability bindings respect ignored and capability namespaces
-export function namespaceComplianceValidator(capability: CapabilityExport, ignoredNamespaces?: string[]): void {
+export function namespaceComplianceValidator(
+  capability: CapabilityExport,
+  ignoredNamespaces?: string[],
+): void {
   const { namespaces: capabilityNamespaces, bindings, name } = capability;
-  const bindingNamespaces: string[] = bindings.flatMap((binding: Binding) => binding.filters.namespaces);
+  const bindingNamespaces: string[] = bindings.flatMap(
+    (binding: Binding) => binding.filters.namespaces,
+  );
   const bindingRegexNamespaces: string[] = bindings.flatMap(
     (binding: Binding) => binding.filters.regexNamespaces || [],
   );
@@ -153,12 +168,18 @@ const matchRegexToCapababilityNamespace = (
   bindingRegexNamespaces: string[],
   capabilityNamespaces: string[] | undefined,
 ): void => {
-  if (bindingRegexNamespaces.length > 0 && capabilityNamespaces && capabilityNamespaces.length > 0) {
+  if (
+    bindingRegexNamespaces.length > 0 &&
+    capabilityNamespaces &&
+    capabilityNamespaces.length > 0
+  ) {
     for (const regexNamespace of bindingRegexNamespaces) {
       let matches = false;
       matches =
         regexNamespace !== "" &&
-        capabilityNamespaces.some(capabilityNamespace => matchesRegex(regexNamespace, capabilityNamespace));
+        capabilityNamespaces.some(capabilityNamespace =>
+          matchesRegex(regexNamespace, capabilityNamespace),
+        );
       if (!matches) {
         throw new Error(
           `Ignoring Watch Callback: Object namespace does not match any capability namespace with regex ${regexNamespace}.`,
@@ -168,10 +189,15 @@ const matchRegexToCapababilityNamespace = (
   }
 };
 
-const checkRegexNamespaces = (bindingRegexNamespaces: string[], ignoredNamespaces: string[] | undefined): void => {
+const checkRegexNamespaces = (
+  bindingRegexNamespaces: string[],
+  ignoredNamespaces: string[] | undefined,
+): void => {
   if (bindingRegexNamespaces.length > 0 && ignoredNamespaces && ignoredNamespaces.length > 0) {
     for (const regexNamespace of bindingRegexNamespaces) {
-      const matchedNS = ignoredNamespaces.find(ignoredNS => matchesRegex(regexNamespace, ignoredNS));
+      const matchedNS = ignoredNamespaces.find(ignoredNS =>
+        matchesRegex(regexNamespace, ignoredNS),
+      );
       if (matchedNS) {
         throw new Error(
           `Ignoring Watch Callback: Regex namespace: ${regexNamespace}, is an ignored namespace: ${matchedNS}.`,

package/src/lib/included-files.ts

@@ -3,7 +3,11 @@
 
 import { promises as fs } from "fs";
 
-export async function createDockerfile(version: string, description: string, includedFiles: string[]): Promise<void> {
+export async function createDockerfile(
+  version: string,
+  description: string,
+  includedFiles: string[],
+): Promise<void> {
   const file = `
     # Use an official Node.js runtime as the base image
     FROM ghcr.io/defenseunicorns/pepr/controller:v${version}

package/src/lib/processors/decode-utils.ts

@@ -18,7 +18,10 @@ export function decodeData(wrapped: PeprMutateRequest<KubernetesObject>): {
   return { skipped, wrapped };
 }
 
-export function reencodeData(wrapped: PeprMutateRequest<KubernetesObject>, skipped: string[]): KubernetesObject {
+export function reencodeData(
+  wrapped: PeprMutateRequest<KubernetesObject>,
+  skipped: string[],
+): KubernetesObject {
   const transformed = clone(wrapped.Raw);
 
   const isSecret = wrapped.Request.kind.version === "v1" && wrapped.Request.kind.kind === "Secret";

package/src/lib/processors/mutate-processor.ts

@@ -195,7 +195,10 @@ export async function mutateProcessor(
   return { ...response, allowed: true };
 }
 
-export function updateResponsePatchAndWarnings(patches: Operation[], response: MutateResponse): void {
+export function updateResponsePatchAndWarnings(
+  patches: Operation[],
+  response: MutateResponse,
+): void {
   // Only add the patch if there are patches to apply
   if (patches.length > 0) {
     response.patchType = "JSONPatch";

package/src/lib/processors/validate-processor.ts

@@ -41,7 +41,10 @@ export async function processRequest(
       };
     }
 
-    Log.info(actionMetadata, `Validation action complete (${label}): ${callbackResp.allowed ? "allowed" : "denied"}`);
+    Log.info(
+      actionMetadata,
+      `Validation action complete (${label}): ${callbackResp.allowed ? "allowed" : "denied"}`,
+    );
     return valResp;
   } catch (e) {
     // If any validation throws an error, note the failure in the Response