pepr 0.46.2 → 0.46.3-nightly.0

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

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

@@ -4,7 +4,13 @@ import Log from "../telemetry/logger";
 import { Binding } from "../types";
 import { Capability } from "../core/capability";
 import { Event } from "../enums";
-import { K8s, KubernetesObject, WatchCfg, WatchEvent, GenericClass } from "kubernetes-fluent-client";
+import {
+  K8s,
+  KubernetesObject,
+  WatchCfg,
+  WatchEvent,
+  GenericClass,
+} from "kubernetes-fluent-client";
 import { Queue } from "../core/queue";
 import { WatchPhase, WatcherType } from "kubernetes-fluent-client/dist/fluent/types";
 import { KubernetesListObject } from "kubernetes-fluent-client/dist/types";
@@ -51,8 +57,12 @@ export function getOrCreateQueue(obj: KubernetesObject): Queue<KubernetesObject>
 
 // Watch configuration
 const watchCfg: WatchCfg = {
-  resyncFailureMax: process.env.PEPR_RESYNC_FAILURE_MAX ? parseInt(process.env.PEPR_RESYNC_FAILURE_MAX, 10) : 5,
-  resyncDelaySec: process.env.PEPR_RESYNC_DELAY_SECONDS ? parseInt(process.env.PEPR_RESYNC_DELAY_SECONDS, 10) : 5,
+  resyncFailureMax: process.env.PEPR_RESYNC_FAILURE_MAX
+    ? parseInt(process.env.PEPR_RESYNC_FAILURE_MAX, 10)
+    : 5,
+  resyncDelaySec: process.env.PEPR_RESYNC_DELAY_SECONDS
+    ? parseInt(process.env.PEPR_RESYNC_DELAY_SECONDS, 10)
+    : 5,
   lastSeenLimitSeconds: process.env.PEPR_LAST_SEEN_LIMIT_SECONDS
     ? parseInt(process.env.PEPR_LAST_SEEN_LIMIT_SECONDS, 10)
     : 300,
@@ -79,7 +89,9 @@ export function setupWatch(capabilities: Capability[], ignoredNamespaces?: strin
   capabilities.map(capability =>
     capability.bindings
       .filter(binding => binding.isWatch)
-      .forEach(bindingElement => runBinding(bindingElement, capability.namespaces, ignoredNamespaces)),
+      .forEach(bindingElement =>
+        runBinding(bindingElement, capability.namespaces, ignoredNamespaces),
+      ),
   );
 }
 
@@ -100,12 +112,20 @@ async function runBinding(
   // The watch callback is run when an object is received or dequeued
   Log.debug({ watchCfg }, "Effective WatchConfig");
 
-  const watchCallback = async (kubernetesObject: KubernetesObject, phase: WatchPhase): Promise<void> => {
+  const watchCallback = async (
+    kubernetesObject: KubernetesObject,
+    phase: WatchPhase,
+  ): Promise<void> => {
     // First, filter the object based on the phase
     if (phaseMatch.includes(phase)) {
       try {
         // Then, check if the object matches the filter
-        const filterMatch = filterNoMatchReason(binding, kubernetesObject, capabilityNamespaces, ignoredNamespaces);
+        const filterMatch = filterNoMatchReason(
+          binding,
+          kubernetesObject,
+          capabilityNamespaces,
+          ignoredNamespaces,
+        );
         if (filterMatch !== "") {
           Log.debug(filterMatch);
           return;
@@ -139,7 +159,10 @@ async function runBinding(
       // [ true, void, undefined ] SHOULD remove finalizer
       // [ false ] should NOT remove finalizer
       if (shouldRemoveFinalizer === false) {
-        Log.debug({ obj: kubernetesObject }, `Skipping removal of finalizer '${peprFinal}' from '${resource}'`);
+        Log.debug(
+          { obj: kubernetesObject },
+          `Skipping removal of finalizer '${peprFinal}' from '${resource}'`,
+        );
       } else {
         await removeFinalizer(binding, kubernetesObject);
       }
@@ -147,16 +170,19 @@ async function runBinding(
   };
 
   // Setup the resource watch
-  const watcher = K8s(binding.model, { ...binding.filters, kindOverride: binding.kind }).Watch(async (obj, phase) => {
-    Log.debug(obj, `Watch event ${phase} received`);
-
-    if (binding.isQueue) {
-      const queue = getOrCreateQueue(obj);
-      await queue.enqueue(obj, phase, watchCallback);
-    } else {
-      await watchCallback(obj, phase);
-    }
-  }, watchCfg);
+  const watcher = K8s(binding.model, { ...binding.filters, kindOverride: binding.kind }).Watch(
+    async (obj, phase) => {
+      Log.debug(obj, `Watch event ${phase} received`);
+
+      if (binding.isQueue) {
+        const queue = getOrCreateQueue(obj);
+        await queue.enqueue(obj, phase, watchCallback);
+      } else {
+        await watchCallback(obj, phase);
+      }
+    },
+    watchCfg,
+  );
 
   // Register event handlers
   registerWatchEventHandlers(watcher, logEvent, metricsCollector);
@@ -214,10 +240,14 @@ export function registerWatchEventHandlers(
     [WatchEvent.CONNECT]: url => logEvent(WatchEvent.CONNECT, url),
     [WatchEvent.DATA_ERROR]: err => logEvent(WatchEvent.DATA_ERROR, err.message),
     [WatchEvent.RECONNECT]: retryCount =>
-      logEvent(WatchEvent.RECONNECT, `Reconnecting after ${retryCount} attempt${retryCount === 1 ? "" : "s"}`),
+      logEvent(
+        WatchEvent.RECONNECT,
+        `Reconnecting after ${retryCount} attempt${retryCount === 1 ? "" : "s"}`,
+      ),
     [WatchEvent.RECONNECT_PENDING]: () => logEvent(WatchEvent.RECONNECT_PENDING),
     [WatchEvent.ABORT]: err => logEvent(WatchEvent.ABORT, err.message),
-    [WatchEvent.OLD_RESOURCE_VERSION]: errMessage => logEvent(WatchEvent.OLD_RESOURCE_VERSION, errMessage),
+    [WatchEvent.OLD_RESOURCE_VERSION]: errMessage =>
+      logEvent(WatchEvent.OLD_RESOURCE_VERSION, errMessage),
     [WatchEvent.NETWORK_ERROR]: err => logEvent(WatchEvent.NETWORK_ERROR, err.message),
     [WatchEvent.LIST_ERROR]: err => logEvent(WatchEvent.LIST_ERROR, err.message),
     [WatchEvent.LIST]: list => logEvent(WatchEvent.LIST, JSON.stringify(list, undefined, 2)),

package/src/lib/telemetry/metrics.ts

@@ -56,7 +56,9 @@ export class MetricsCollector {
     this.addSummary(this.#metricNames.mutate, "Mutation operation summary");
     this.addSummary(this.#metricNames.validate, "Validation operation summary");
     this.addGauge(this.#metricNames.cacheMiss, "Number of cache misses per window", ["window"]);
-    this.addGauge(this.#metricNames.resyncFailureCount, "Number of failures per resync operation", ["count"]);
+    this.addGauge(this.#metricNames.resyncFailureCount, "Number of failures per resync operation", [
+      "count",
+    ]);
   }
 
   #getMetricName = (name: string): string => `${this.#prefix}_${name}`;
@@ -173,7 +175,9 @@ export class MetricsCollector {
       if (firstKey !== undefined) {
         this.#cacheMissWindows.delete(firstKey);
       }
-      this.#gauges.get(this.#getMetricName(this.#metricNames.cacheMiss))?.remove({ window: firstKey });
+      this.#gauges
+        .get(this.#getMetricName(this.#metricNames.cacheMiss))
+        ?.remove({ window: firstKey });
     }
   };
 }

package/src/lib/telemetry/webhookTimeouts.ts

@@ -9,7 +9,10 @@ export class MeasureWebhookTimeout {
 
   constructor(webhookType: WebhookType) {
     this.#webhookType = webhookType;
-    metricsCollector.addCounter(`${webhookType}_timeouts`, `Number of ${webhookType} webhook timeouts`);
+    metricsCollector.addCounter(
+      `${webhookType}_timeouts`,
+      `Number of ${webhookType} webhook timeouts`,
+    );
   }
 
   start(timeout: number = 10): void {

package/src/templates/.prettierrc.json

@@ -4,10 +4,11 @@
   "bracketSpacing": true,
   "embeddedLanguageFormatting": "auto",
   "insertPragma": false,
-  "printWidth": 80,
+  "printWidth": 100,
   "quoteProps": "as-needed",
   "requirePragma": false,
   "semi": true,
   "tabWidth": 2,
-  "useTabs": false
+  "useTabs": false,
+  "vueIndentScriptAndStyle": false
 }

package/src/templates/capabilities/hello-pepr.ts

@@ -89,9 +89,7 @@ When(a.ConfigMap)
   .IsCreated()
   .WithName("example-1")
   .Mutate(request => {
-    request
-      .SetLabel("pepr", "was-here")
-      .SetAnnotation("pepr.dev", "annotations-work-too");
+    request.SetLabel("pepr", "was-here").SetAnnotation("pepr.dev", "annotations-work-too");
 
     // Use the Store to persist data between requests and Pepr controller pods
     Store.setItem("example-1", "was-here");
@@ -228,11 +226,7 @@ function example4Cb(cm: PeprMutateRequest<a.ConfigMap>) {
  * Note because the Capability defines namespaces, the namespace specified here must be one of those.
  * Alternatively, you can remove the namespace from the Capability definition and specify it here.
  */
-When(a.ConfigMap)
-  .IsCreated()
-  .InNamespace("pepr-demo-2")
-  .WithName("example-4a")
-  .Mutate(example4Cb);
+When(a.ConfigMap).IsCreated().InNamespace("pepr-demo-2").WithName("example-4a").Mutate(example4Cb);
 
 /**
  * ---------------------------------------------------------------------------------------------------

package/dist/.github/workflows/pepr-excellent-examples-matrix.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=pepr-excellent-examples-matrix.d.ts.map

package/dist/.github/workflows/pepr-excellent-examples-matrix.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pepr-excellent-examples-matrix.d.ts","sourceRoot":"","sources":["../../../.github/workflows/pepr-excellent-examples-matrix.js"],"names":[],"mappings":""}

package/dist/commitlint.config.d.ts

@@ -1,4 +0,0 @@
-declare let _extends: string[];
-export { _extends as extends };
-export declare let ignores: ((message: any) => boolean)[];
-//# sourceMappingURL=commitlint.config.d.ts.map

package/dist/commitlint.config.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"commitlint.config.d.ts","sourceRoot":"","sources":["../commitlint.config.js"],"names":[],"mappings":""}

package/dist/integration/helpers/cmd.d.ts

@@ -1,22 +0,0 @@
-export interface Spec {
-    cmd: string;
-    stdin?: string[];
-    cwd?: string;
-    env?: object;
-}
-export interface Result {
-    stdout: string[];
-    stderr: string[];
-    exitcode: number;
-}
-export declare class Cmd {
-    result?: Result;
-    cmd: string;
-    stdin: string[];
-    cwd: string;
-    env: object;
-    constructor(spec: Spec);
-    runRaw(): Promise<Result>;
-    run(): Promise<Result>;
-}
-//# sourceMappingURL=cmd.d.ts.map

package/dist/integration/helpers/cmd.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cmd.d.ts","sourceRoot":"","sources":["../../../integration/helpers/cmd.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,IAAI;IACnB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,MAAM;IACrB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,qBAAa,GAAG;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;gBAEA,IAAI,EAAE,IAAI;IAOtB,MAAM,IAAI,OAAO,CAAC,MAAM,CAAC;IAoCzB,GAAG,IAAI,OAAO,CAAC,MAAM,CAAC;CAQvB"}

package/dist/integration/helpers/pepr.d.ts

@@ -1,5 +0,0 @@
-import { Spec, Result } from "./cmd";
-export declare function projectRoot(): Promise<string>;
-export declare function tgzifyModule(modulePath: string): Promise<void>;
-export declare function cli(workdir: string, spec: Spec): Promise<Result>;
-//# sourceMappingURL=pepr.d.ts.map

package/dist/integration/helpers/pepr.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pepr.d.ts","sourceRoot":"","sources":["../../../integration/helpers/pepr.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,IAAI,EAAO,MAAM,EAAE,MAAM,OAAO,CAAC;AAM1C,wBAAsB,WAAW,IAAI,OAAO,CAAC,MAAM,CAAC,CAKnD;AAED,wBAAsB,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAOpE;AAED,wBAAsB,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC,CAetE"}