pepr 0.40.1 → 0.42.1

package/src/lib/filter/{adjudicators.ts → adjudicators/adjudicators.ts}

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: 2023-Present The Pepr Authors
 
-import { Event, Operation } from "../enums";
-import { AdmissionRequest } from "../../lib/types";
+import { Event, Operation } from "../../enums";
+import { AdmissionRequest, Binding } from "../../types";
 import {
   __,
   allPass,
@@ -58,33 +58,60 @@ export const carriesDeletionTimestamp = pipe(
 );
 export const missingDeletionTimestamp = complement(carriesDeletionTimestamp);
 
-export const carriedKind = pipe(kubernetesObject => kubernetesObject?.metadata?.kind, defaultTo("not set"));
-export const carriedVersion = pipe(kubernetesObject => kubernetesObject?.metadata?.version, defaultTo("not set"));
-export const carriedName = pipe(kubernetesObject => kubernetesObject?.metadata?.name, defaultTo(""));
+export const carriedKind = pipe(
+  (kubernetesObject: KubernetesObject): string | undefined => kubernetesObject?.kind,
+  defaultTo("not set"),
+);
+export const carriedVersion = pipe(
+  (kubernetesObject: KubernetesObject): string | undefined => kubernetesObject?.metadata?.resourceVersion,
+  defaultTo("not set"),
+);
+export const carriedName = pipe(
+  (kubernetesObject: KubernetesObject): string | undefined => kubernetesObject?.metadata?.name,
+  defaultTo(""),
+);
 export const carriesName = pipe(carriedName, equals(""), not);
 export const missingName = complement(carriesName);
 
-export const carriedNamespace = pipe(kubernetesObject => kubernetesObject?.metadata?.namespace, defaultTo(""));
+export const carriedNamespace = pipe(
+  (kubernetesObject: KubernetesObject): string | undefined => kubernetesObject?.metadata?.namespace,
+  defaultTo(""),
+);
 export const carriesNamespace = pipe(carriedNamespace, equals(""), not);
 
-export const carriedAnnotations = pipe(kubernetesObject => kubernetesObject?.metadata?.annotations, defaultTo({}));
+export const carriedAnnotations = pipe(
+  (kubernetesObject: KubernetesObject): { [key: string]: string } | undefined =>
+    kubernetesObject?.metadata?.annotations,
+  defaultTo({}),
+);
 export const carriesAnnotations = pipe(carriedAnnotations, equals({}), not);
 
-export const carriedLabels = pipe(kubernetesObject => kubernetesObject?.metadata?.labels, defaultTo({}));
+export const carriedLabels = pipe(
+  (kubernetesObject: KubernetesObject): { [key: string]: string } | undefined => kubernetesObject?.metadata?.labels,
+  defaultTo({}),
+);
 export const carriesLabels = pipe(carriedLabels, equals({}), not);
 
 /*
   Binding collectors
 */
 
-export const definesDeletionTimestamp = pipe(binding => binding?.filters?.deletionTimestamp, defaultTo(false));
+export const definesDeletionTimestamp = pipe(
+  (binding: Binding): boolean => binding?.filters?.deletionTimestamp ?? false,
+  defaultTo(false),
+);
 export const ignoresDeletionTimestamp = complement(definesDeletionTimestamp);
 
-export const definedName = pipe(binding => binding?.filters?.name, defaultTo(""));
+export const definedName = pipe((binding: Binding): string => {
+  return binding.filters.name;
+}, defaultTo(""));
 export const definesName = pipe(definedName, equals(""), not);
 export const ignoresName = complement(definesName);
 
-export const definedNameRegex = pipe(binding => binding?.filters?.regexName, defaultTo(""));
+export const definedNameRegex = pipe(
+  (binding: Partial<Binding>): string | undefined => binding.filters?.regexName,
+  defaultTo(""),
+);
 export const definesNameRegex = pipe(definedNameRegex, equals(""), not);
 
 export const definedNamespaces = pipe(binding => binding?.filters?.namespaces, defaultTo([]));
@@ -93,45 +120,49 @@ export const definesNamespaces = pipe(definedNamespaces, equals([]), not);
 export const definedNamespaceRegexes = pipe(binding => binding?.filters?.regexNamespaces, defaultTo([]));
 export const definesNamespaceRegexes = pipe(definedNamespaceRegexes, equals([]), not);
 
-export const definedAnnotations = pipe(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 => 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 = pipe(binding => binding?.event, defaultTo(""));
-export const definesDelete = pipe(definedEvent, equals(Operation.DELETE));
+export const definedEvent = (binding: Binding): Event => {
+  return binding.event;
+};
 
-export const definedGroup = pipe(binding => binding?.kind?.group, defaultTo(""));
+export const definesDelete = pipe(definedEvent, equals(Event.DELETE));
+
+export const definedGroup = pipe((binding): string => binding?.kind?.group, defaultTo(""));
 export const definesGroup = pipe(definedGroup, equals(""), not);
 
-export const definedVersion = pipe(binding => binding?.kind?.version, defaultTo(""));
+export const definedVersion = pipe(
+  (binding: Partial<Binding>): string | undefined => binding?.kind?.version,
+  defaultTo(""),
+);
 export const definesVersion = pipe(definedVersion, equals(""), not);
 
-export const definedKind = pipe(binding => binding?.kind?.kind, defaultTo(""));
+export const definedKind = pipe((binding): string => binding?.kind?.kind, defaultTo(""));
 export const definesKind = pipe(definedKind, equals(""), not);
 
-export const definedCategory = pipe(binding => {
+export const definedCategory = (binding: Partial<Binding>) => {
+  // Ordering matters, finalize is a "watch"
   // prettier-ignore
-  return (
-    binding.isFinalize ? "Finalize" :
+  return binding.isFinalize ? "Finalize" :
     binding.isWatch ? "Watch" :
     binding.isMutate ? "Mutate" :
     binding.isValidate ? "Validate" :
-    ""
-  );
-});
+    "";
+};
 
-export const definedCallback = pipe(binding => {
+export const definedCallback = (binding: Partial<Binding>) => {
+  // Ordering matters, finalize is a "watch"
   // prettier-ignore
-  return (
-    binding.isFinalize ? binding.finalizeCallback :
+  return binding.isFinalize ? binding.finalizeCallback :
     binding.isWatch ? binding.watchCallback :
     binding.isMutate ? binding.mutateCallback :
-    binding.isValidate ? binding.validateCallback:
-    null
-  );
-});
+    binding.isValidate ? binding.validateCallback :
+    null;
+};
 export const definedCallbackName = pipe(definedCallback, defaultTo({ name: "" }), callback => callback.name);
 
 /*
@@ -245,13 +276,14 @@ export const unbindableNamespaces = allPass([
 export const misboundDeleteWithDeletionTimestamp = allPass([definesDelete, definesDeletionTimestamp]);
 
 export const operationMatchesEvent = anyPass([
-  pipe(nthArg(1), equals(Event.Any)),
-  pipe((operation, event) => operation === event),
-  pipe((operation, event) => (operation ? event.includes(operation) : false)),
+  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)),
 ]);
 
 export const mismatchedEvent = pipe(
-  (binding, request) => operationMatchesEvent(declaredOperation(request), definedEvent(binding)),
+  (binding: Binding, request: AdmissionRequest): boolean =>
+    operationMatchesEvent(declaredOperation(request), definedEvent(binding)),
   not,
 );
 

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

@@ -0,0 +1,46 @@
+import { GroupVersionKind, kind, KubernetesObject } from "kubernetes-fluent-client";
+import { Event, Operation } from "../../enums";
+import { AdmissionRequest, Binding, Filters } from "../../types";
+
+export const defaultFilters: Filters = {
+  annotations: {},
+  deletionTimestamp: false,
+  labels: {},
+  name: "",
+  namespaces: [],
+  regexName: "^default$",
+  regexNamespaces: [] as string[],
+};
+
+const defaultGroupVersionKind: GroupVersionKind = {
+  kind: "some-kind",
+  group: "some-group",
+};
+
+export const defaultBinding: Binding = {
+  event: Event.ANY,
+  filters: defaultFilters,
+  kind: defaultGroupVersionKind,
+  model: kind.Pod,
+  isFinalize: false,
+  isMutate: false,
+  isQueue: false,
+  isValidate: false,
+  isWatch: false,
+};
+
+export const defaultAdmissionRequest: AdmissionRequest = {
+  uid: "some-uid",
+  kind: { kind: "a-kind", group: "a-group" },
+  resource: { group: "some-group", version: "some-version", resource: "some-resource" },
+  operation: Operation.CONNECT,
+  name: "some-name",
+  userInfo: {},
+  object: {},
+};
+
+export const defaultKubernetesObject: KubernetesObject = {
+  apiVersion: "some-version",
+  kind: "some-kind",
+  metadata: { name: "some-name" },
+};

package/src/lib/filter/filter.ts

@@ -38,7 +38,7 @@ import {
   missingCarriableNamespace,
   unbindableNamespaces,
   uncarryableNamespace,
-} from "./adjudicators";
+} from "./adjudicators/adjudicators";
 
 /**
  * shouldSkipRequest determines if a request should be skipped based on the binding filters.

package/src/lib/finalizer.ts

@@ -2,7 +2,7 @@
 // SPDX-FileCopyrightText: 2023-Present The Pepr Authors
 
 import { K8s, KubernetesObject, RegisterKind } from "kubernetes-fluent-client";
-import Log from "./logger";
+import Log from "./telemetry/logger";
 import { Binding, DeepPartial } from "./types";
 import { Operation } from "./enums";
 import { PeprMutateRequest } from "./mutate-request";

package/src/lib/helpers.ts

@@ -1,9 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: 2023-Present The Pepr Authors
 
-import { promises as fs } from "fs";
-import { K8s, KubernetesObject, kind } from "kubernetes-fluent-client";
-import Log from "./logger";
+import { KubernetesObject } from "kubernetes-fluent-client";
+import Log from "./telemetry/logger";
 import { Binding, CapabilityExport } from "./types";
 import { sanitizeResourceName } from "../sdk/sdk";
 import {
@@ -29,16 +28,10 @@ import {
   missingCarriableNamespace,
   unbindableNamespaces,
   uncarryableNamespace,
-} from "./filter/adjudicators";
+} from "./filter/adjudicators/adjudicators";
 
 export function matchesRegex(pattern: string, testString: string): boolean {
-  // edge-case
-  if (!pattern) {
-    return false;
-  }
-
-  const regex = new RegExp(pattern);
-  return regex.test(testString);
+  return new RegExp(pattern).test(testString);
 }
 
 export class ValidationError extends Error {}
@@ -73,8 +66,8 @@ export type RBACMap = {
  * Decide to run callback after the event comes back from API Server
  **/
 export function filterNoMatchReason(
-  binding: Partial<Binding>,
-  obj: Partial<KubernetesObject>,
+  binding: Binding,
+  kubernetesObject: Partial<KubernetesObject>,
   capabilityNamespaces: string[],
   ignoredNamespaces?: string[],
 ): string {
@@ -82,30 +75,30 @@ export function filterNoMatchReason(
 
   // prettier-ignore
   return (
-    mismatchedDeletionTimestamp(binding, obj) ?
+    mismatchedDeletionTimestamp(binding, kubernetesObject) ?
       `${prefix} Binding defines deletionTimestamp but Object does not carry it.` :
 
-    mismatchedName(binding, obj) ?
-      `${prefix} Binding defines name '${definedName(binding)}' but Object carries '${carriedName(obj)}'.` :
+    mismatchedName(binding, kubernetesObject) ?
+      `${prefix} Binding defines name '${definedName(binding)}' but Object carries '${carriedName(kubernetesObject)}'.` :
 
     misboundNamespace(binding) ?
       `${prefix} Cannot use namespace filter on a namespace object.` :
 
-    mismatchedLabels(binding, obj) ?
+    mismatchedLabels(binding, kubernetesObject) ?
       (
         `${prefix} Binding defines labels '${JSON.stringify(definedLabels(binding))}' ` +
-        `but Object carries '${JSON.stringify(carriedLabels(obj))}'.`
+        `but Object carries '${JSON.stringify(carriedLabels(kubernetesObject))}'.`
       ) :
 
-    mismatchedAnnotations(binding, obj) ?
+    mismatchedAnnotations(binding, kubernetesObject) ?
       (
         `${prefix} Binding defines annotations '${JSON.stringify(definedAnnotations(binding))}' ` +
-        `but Object carries '${JSON.stringify(carriedAnnotations(obj))}'.`
+        `but Object carries '${JSON.stringify(carriedAnnotations(kubernetesObject))}'.`
       ) :
 
-    uncarryableNamespace(capabilityNamespaces, obj) ?
+    uncarryableNamespace(capabilityNamespaces, kubernetesObject) ?
       (
-        `${prefix} Object carries namespace '${carriedNamespace(obj)}' ` +
+        `${prefix} Object carries namespace '${carriedNamespace(kubernetesObject)}' ` +
         `but namespaces allowed by Capability are '${JSON.stringify(capabilityNamespaces)}'.`
       ) :
 
@@ -115,32 +108,32 @@ export function filterNoMatchReason(
         `but namespaces allowed by Capability are '${JSON.stringify(capabilityNamespaces)}'.`
       ) :
 
-    mismatchedNamespace(binding, obj) ?
+    mismatchedNamespace(binding, kubernetesObject) ?
       (
         `${prefix} Binding defines namespaces '${JSON.stringify(definedNamespaces(binding))}' ` +
-        `but Object carries '${carriedNamespace(obj)}'.`
+        `but Object carries '${carriedNamespace(kubernetesObject)}'.`
       ) :
 
-    mismatchedNamespaceRegex(binding, obj) ?
+    mismatchedNamespaceRegex(binding, kubernetesObject) ?
       (
         `${prefix} Binding defines namespace regexes ` +
         `'${JSON.stringify(definedNamespaceRegexes(binding))}' ` +
-        `but Object carries '${carriedNamespace(obj)}'.`
+        `but Object carries '${carriedNamespace(kubernetesObject)}'.`
       ) :
 
-    mismatchedNameRegex(binding, obj) ?
+    mismatchedNameRegex(binding, kubernetesObject) ?
       (
         `${prefix} Binding defines name regex '${definedNameRegex(binding)}' ` +
-        `but Object carries '${carriedName(obj)}'.`
+        `but Object carries '${carriedName(kubernetesObject)}'.`
       ) :
 
-    carriesIgnoredNamespace(ignoredNamespaces, obj) ?
+    carriesIgnoredNamespace(ignoredNamespaces, kubernetesObject) ?
       (
-        `${prefix} Object carries namespace '${carriedNamespace(obj)}' ` +
+        `${prefix} Object carries namespace '${carriedNamespace(kubernetesObject)}' ` +
         `but ignored namespaces include '${JSON.stringify(ignoredNamespaces)}'.`
       ) :
 
-    missingCarriableNamespace(capabilityNamespaces, obj) ? 
+    missingCarriableNamespace(capabilityNamespaces, kubernetesObject) ? 
       (
         `${prefix} Object does not carry a namespace ` +
         `but namespaces allowed by Capability are '${JSON.stringify(capabilityNamespaces)}'.`
@@ -191,18 +184,6 @@ export function createRBACMap(capabilities: CapabilityExport[]): RBACMap {
   }, {});
 }
 
-export async function createDirectoryIfNotExists(path: string) {
-  try {
-    await fs.access(path);
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      await fs.mkdir(path, { recursive: true });
-    } else {
-      throw error;
-    }
-  }
-}
-
 export function hasEveryOverlap<T>(array1: T[], array2: T[]): boolean {
   if (!Array.isArray(array1) || !Array.isArray(array2)) {
     return false;
@@ -255,11 +236,13 @@ export function generateWatchNamespaceError(
   return err.replace(/\.([^ ])/g, ". $1");
 }
 
-// namespaceComplianceValidator ensures that capability bindinds respect ignored and capability namespaces
+// namespaceComplianceValidator ensures that capability bindings respect ignored and capability namespaces
 export function namespaceComplianceValidator(capability: CapabilityExport, ignoredNamespaces?: string[]) {
   const { namespaces: capabilityNamespaces, bindings, name } = capability;
-  const bindingNamespaces = bindings.flatMap((binding: Binding) => binding.filters.namespaces);
-  const bindingRegexNamespaces = bindings.flatMap((binding: Binding) => binding.filters.regexNamespaces || []);
+  const bindingNamespaces: string[] = bindings.flatMap((binding: Binding) => binding.filters.namespaces);
+  const bindingRegexNamespaces: string[] = bindings.flatMap(
+    (binding: Binding) => binding.filters.regexNamespaces || [],
+  );
 
   const namespaceError = generateWatchNamespaceError(
     ignoredNamespaces ? ignoredNamespaces : [],
@@ -310,46 +293,6 @@ export function namespaceComplianceValidator(capability: CapabilityExport, ignor
   }
 }
 
-// check to see if all replicas are ready for all deployments in the pepr-system namespace
-// returns true if all deployments are ready, false otherwise
-export async function checkDeploymentStatus(namespace: string) {
-  const deployments = await K8s(kind.Deployment).InNamespace(namespace).Get();
-  let status = false;
-  let readyCount = 0;
-
-  for (const deployment of deployments.items) {
-    const readyReplicas = deployment.status?.readyReplicas ? deployment.status?.readyReplicas : 0;
-    if (deployment.status?.readyReplicas !== deployment.spec?.replicas) {
-      Log.info(
-        `Waiting for deployment ${deployment.metadata?.name} rollout to finish: ${readyReplicas} of ${deployment.spec?.replicas} replicas are available`,
-      );
-    } else {
-      Log.info(
-        `Deployment ${deployment.metadata?.name} rolled out: ${readyReplicas} of ${deployment.spec?.replicas} replicas are available`,
-      );
-      readyCount++;
-    }
-  }
-  if (readyCount === deployments.items.length) {
-    status = true;
-  }
-  return status;
-}
-
-// wait for all deployments in the pepr-system namespace to be ready
-export async function namespaceDeploymentsReady(namespace: string = "pepr-system") {
-  Log.info(`Checking ${namespace} deployments status...`);
-  let ready = false;
-  while (!ready) {
-    ready = await checkDeploymentStatus(namespace);
-    if (ready) {
-      return ready;
-    }
-    await new Promise(resolve => setTimeout(resolve, 1000));
-  }
-  Log.info(`All ${namespace} deployments are ready`);
-}
-
 // check if secret is over the size limit
 export function secretOverLimit(str: string): boolean {
   const encoder = new TextEncoder();
@@ -374,7 +317,7 @@ export const parseTimeout = (value: string, previous: unknown): number => {
 };
 
 // Remove leading whitespace while keeping format of file
-export function dedent(file: string) {
+export function dedent(file: string): string {
   // Check if the first line is empty and remove it
   const lines = file.split("\n");
   if (lines[0].trim() === "") {
@@ -391,7 +334,7 @@ export function dedent(file: string) {
   return file;
 }
 
-export function replaceString(str: string, stringA: string, stringB: string) {
+export function replaceString(str: string, stringA: string, stringB: string): string {
   // eslint-disable-next-line no-useless-escape
   const escapedStringA = stringA.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&");
   const regExp = new RegExp(escapedStringA, "g");

package/src/lib/mutate-processor.ts

@@ -9,7 +9,7 @@ import { Errors } from "./errors";
 import { shouldSkipRequest } from "./filter/filter";
 import { MutateResponse } from "./k8s";
 import { AdmissionRequest } from "./types";
-import Log from "./logger";
+import Log from "./telemetry/logger";
 import { ModuleConfig } from "./module";
 import { PeprMutateRequest } from "./mutate-request";
 import { base64Encode, convertFromBase64Map, convertToBase64Map } from "./utils";

package/src/lib/mutate-request.ts

@@ -11,19 +11,19 @@ export class PeprMutateRequest<T extends KubernetesObject> {
   Raw: T;
   #input: AdmissionRequest<T>;
 
-  get PermitSideEffects() {
+  get PermitSideEffects(): boolean {
     return !this.#input.dryRun;
   }
 
-  get IsDryRun() {
+  get IsDryRun(): boolean | undefined {
     return this.#input.dryRun;
   }
 
-  get OldResource() {
+  get OldResource(): KubernetesObject | undefined {
     return this.#input.oldObject;
   }
 
-  get Request() {
+  get Request(): AdmissionRequest<KubernetesObject> {
     return this.#input;
   }
 
@@ -42,11 +42,11 @@ export class PeprMutateRequest<T extends KubernetesObject> {
     }
   }
 
-  Merge = (obj: DeepPartial<T>) => {
+  Merge = (obj: DeepPartial<T>): void => {
     this.Raw = mergeDeepRight(this.Raw, obj) as unknown as T;
   };
 
-  SetLabel = (key: string, value: string) => {
+  SetLabel = (key: string, value: string): this => {
     const ref = this.Raw;
     ref.metadata = ref.metadata ?? {};
     ref.metadata.labels = ref.metadata.labels ?? {};
@@ -54,7 +54,7 @@ export class PeprMutateRequest<T extends KubernetesObject> {
     return this;
   };
 
-  SetAnnotation = (key: string, value: string) => {
+  SetAnnotation = (key: string, value: string): this => {
     const ref = this.Raw;
     ref.metadata = ref.metadata ?? {};
     ref.metadata.annotations = ref.metadata.annotations ?? {};
@@ -62,25 +62,25 @@ export class PeprMutateRequest<T extends KubernetesObject> {
     return this;
   };
 
-  RemoveLabel = (key: string) => {
+  RemoveLabel = (key: string): this => {
     if (this.Raw.metadata?.labels?.[key]) {
       delete this.Raw.metadata.labels[key];
     }
     return this;
   };
 
-  RemoveAnnotation = (key: string) => {
+  RemoveAnnotation = (key: string): this => {
     if (this.Raw.metadata?.annotations?.[key]) {
       delete this.Raw.metadata.annotations[key];
     }
     return this;
   };
 
-  HasLabel = (key: string) => {
+  HasLabel = (key: string): boolean => {
     return this.Raw.metadata?.labels?.[key] !== undefined;
   };
 
-  HasAnnotation = (key: string) => {
+  HasAnnotation = (key: string): boolean => {
     return this.Raw.metadata?.annotations?.[key] !== undefined;
   };
 }

package/src/lib/queue.ts

@@ -3,7 +3,7 @@
 import { KubernetesObject } from "@kubernetes/client-node";
 import { WatchPhase } from "kubernetes-fluent-client/dist/fluent/types";
 import { randomBytes } from "node:crypto";
-import Log from "./logger";
+import Log from "./telemetry/logger";
 
 type WatchCallback = (obj: KubernetesObject, phase: WatchPhase) => Promise<void>;
 
@@ -29,11 +29,19 @@ export class Queue<K extends KubernetesObject> {
     this.#uid = `${Date.now()}-${randomBytes(2).toString("hex")}`;
   }
 
-  label() {
+  label(): { name: string; uid: string } {
     return { name: this.#name, uid: this.#uid };
   }
 
-  stats() {
+  stats(): {
+    queue: {
+      name: string;
+      uid: string;
+    };
+    stats: {
+      length: number;
+    };
+  } {
     return {
       queue: this.label(),
       stats: {
@@ -51,7 +59,7 @@ export class Queue<K extends KubernetesObject> {
    * @param reconcile The callback to enqueue for reconcile
    * @returns A promise that resolves when the object is reconciled
    */
-  enqueue(item: K, phase: WatchPhase, reconcile: WatchCallback) {
+  enqueue(item: K, phase: WatchPhase, reconcile: WatchCallback): Promise<void> {
     const note = {
       queue: this.label(),
       item: {
@@ -73,7 +81,7 @@ export class Queue<K extends KubernetesObject> {
    *
    * @returns A promise that resolves when the webapp is reconciled
    */
-  async #dequeue() {
+  async #dequeue(): Promise<false | undefined> {
     // If there is a pending promise, do nothing
     if (this.#pendingPromise) {
       Log.debug("Pending promise, not dequeuing");

package/src/lib/schedule.ts

@@ -57,11 +57,11 @@ export class OnSchedule implements Schedule {
     this.startTime = schedule?.startTime;
     this.completions = schedule?.completions;
   }
-  setStore(store: PeprStore) {
+  setStore(store: PeprStore): void {
     this.store = store;
     this.startInterval();
   }
-  startInterval() {
+  startInterval(): void {
     this.checkStore();
     this.getDuration();
     this.setupInterval();
@@ -70,7 +70,7 @@ export class OnSchedule implements Schedule {
    * Checks the store for this schedule and sets the values if it exists
    * @returns
    */
-  checkStore() {
+  checkStore(): void {
     const result = this.store && this.store.getItem(this.name);
     if (result) {
       const storedSchedule = JSON.parse(result);
@@ -84,7 +84,7 @@ export class OnSchedule implements Schedule {
    * Saves the schedule to the store
    * @returns
    */
-  saveToStore() {
+  saveToStore(): void {
     const schedule = {
       completions: this.completions,
       startTime: this.startTime,
@@ -97,7 +97,7 @@ export class OnSchedule implements Schedule {
   /**
    * Gets the durations in milliseconds
    */
-  getDuration() {
+  getDuration(): void {
     switch (this.unit) {
       case "seconds":
         if (this.every < 10) throw new Error("10 Seconds in the smallest interval allowed");
@@ -119,7 +119,7 @@ export class OnSchedule implements Schedule {
   /**
    * Sets up the interval
    */
-  setupInterval() {
+  setupInterval(): void {
     const now = new Date();
     let delay: number | undefined;
 
@@ -146,7 +146,7 @@ export class OnSchedule implements Schedule {
   /**
    * Starts the interval
    */
-  start() {
+  start(): void {
     this.intervalId = setInterval(() => {
       if (this.completions === 0) {
         this.stop();
@@ -165,7 +165,7 @@ export class OnSchedule implements Schedule {
   /**
    * Stops the interval
    */
-  stop() {
+  stop(): void {
     if (this.intervalId) {
       clearInterval(this.intervalId);
       this.intervalId = null;